BRAY_ProceduralFactory.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        BRAY_ProceduralFactory.h (BRAY Library, C++)
 *
 * COMMENTS:
 */

#ifndef __BRAY_ProceduralFactory__
#define __BRAY_ProceduralFactory__

#include "BRAY_API.h"
#include <GT/GT_Handles.h>
#include <UT/UT_Map.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>

class UT_JSONWriter;
class BRAY_AttribList;
class BRAY_Procedural;

/// Provides an interface to bind Hydra USD primitives to Karma primitives.
///
/// The constructor/destructor typically look like this: @code
/// Subclass::Subclass()
/// {
///     bind("tokenname");
/// }
/// Subclass::~Subclass()
/// {
///     unbind("tokenname");
/// }
/// @endcode
class BRAY_API BRAY_ProceduralFactory
    : UT_NonCopyable
{
public:
    /// When the factory is instantiated, it will be registered with the name
    /// given.
    BRAY_ProceduralFactory(const UT_StringHolder &name);
    virtual ~BRAY_ProceduralFactory();

    /// Return the name of the factory
    const UT_StringHolder       &name() const { return myName; }

    /// Create a procedural
    BRAY_Procedural     *createProcedural() const;

    /// @{
    /// Get the static of supported parameters by the procedural
    /// Procedurals are also given an opportunity to construct
    /// on the fly tables after going through the list of attributes
    /// defined on points.
    virtual const BRAY_AttribList       *paramList() const = 0;
    /// @}

    /// A flag to determine whether or not this procedural accepts
    /// parameters from outside it's parameter list.
    /// If this is enabled, not only will the parameters from
    /// @c paramList() be added, but also any parameters that
    /// match the @c matchExtraParam() method
    virtual bool acceptsExtraParameters() const { return false; };

    /// Determine whether this attribute should be added as an extra
    /// parameter.
    /// This will only be called if @c acceptsExtraParameters() returns true
    virtual bool matchExtraParameter(const UT_StringHolder &attrib_name) const
    {
        return false;
    };


    /// The list of procedurals is stored in a map of {name, ProceduralFactory}
    using MapType = UT_StringMap<const BRAY_ProceduralFactory *>;
    using iterator = MapType::const_iterator;

    /// @{
    /// Access the list of all the registered procedurals
    static const MapType        &procedurals();
    static iterator              begin() { return procedurals().begin(); }
    static iterator              end() { return procedurals().end(); }
    /// @}

    /// @{
    /// Print list of procedural factory types
    static void print();
    static void print(UT_JSONWriter &w);
    /// @}

protected:
    /// Create a procedural
    virtual BRAY_Procedural     *create() const = 0;

    /// Provide some extra info for this procedural used when printing help
    virtual const UT_StringHolder       &extraHelp() const
    {
        return UT_StringHolder::theEmptyString;
    }
private:
    UT_StringHolder     myName;
};

extern "C" {
    /// Register a new procedural.  This method should allocate a new
    /// sub-class of the BRAY_ProceduralFactory.
    SYS_VISIBILITY_EXPORT extern void   BRAYregisterProcedural();
}

#endif