BRAY_Interface.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_Interface.h (BRAY Library, C++)
 *
 * COMMENTS:
 */

#ifndef __BRAY_Interface__
#define __BRAY_Interface__

#include "BRAY_API.h"
#include <UT/UT_Array.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_Options.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Rect.h>
#include <UT/UT_Set.h>
#include <UT/UT_VectorTypes.h>
#include <GT/GT_Handles.h>
#include <GT/GT_DataArray.h>
#include <PXL/PXL_Common.h>
#include "BRAY_Types.h"

// Classes referenced by the interface
class BRAY_Procedural;
class BRAY_ProceduralFactory;
class BRAY_AOVBuffer;
class BRAY_Camera;
class BRAY_Object;
class BRAY_Renderer;
class BRAY_Light;
class BRAY_Scene;
class BRAY_ShaderGraph;
class BRAY_ShaderInstance;
class BRAY_VexMaterial;
class VPRM_Space;
class VPRM_OptionSet;
class UT_JSONWriter;

using VPRM_OptionSetPtr = UT_IntrusivePtr<VPRM_OptionSet>;
using VPRM_SpacePtr = UT_IntrusivePtr<VPRM_Space>;

namespace BRAY
{

class CameraPtr;
class LightPtr;
class MaterialPtr;
class ObjectPtr;
class ScenePtr;
class ShaderGraphPtr;

class BRAY_API SpacePtr
{
public:
    SpacePtr();
    SpacePtr(const VPRM_SpacePtr &s);
    SpacePtr(const SpacePtr &s);
    SpacePtr(const UT_Matrix4D &xforms);
    SpacePtr(const UT_Matrix4D *xforms, size_t num_motion_segments);
    ~SpacePtr();
    SpacePtr    &operator=(const SpacePtr &s);

    /// @{
    /// Private access
    bool                isValid() const { return mySpace.get() != nullptr; }
    VPRM_SpacePtr       &space() { return mySpace; }
    const VPRM_SpacePtr &space() const { return mySpace; }
    /// @}
    /// Bool operator to test validity of pointer
    SYS_SAFE_BOOL        operator bool() const { return isValid(); }

    /// Multiply by the given space (i.e. this * sp)
    SpacePtr            mulSpace(const SpacePtr &sp) const;

    /// Return the number of motion segments
    int                 motionSegments() const;
    const UT_Matrix4D   &getTransform(int segment) const;
    void                 getTransform(UT_Matrix4D &x, BRAYtime shutter) const;
    void                 dump() const;
    void                 dump(UT_JSONWriter &w) const;
private:
    VPRM_SpacePtr       mySpace;
};

/// The OptionSet acts as a pointer to an underlying set of options for various
/// different object types.
class BRAY_API OptionSet
{
public:
    OptionSet();
    /// The copy c-tor will copy the underlying pointer, but refer to the same
    /// underlying object.
    OptionSet(const OptionSet &src);
    OptionSet(const VPRM_OptionSetPtr &o);
    ~OptionSet();

    /// The assignment operator will change the pointer to the underlying
    /// object.  Both OptionSets will point to the same underlying object.
    OptionSet   &operator=(const OptionSet &o);

    /// This will create a new OptionSet, inheriting state information from the
    /// this option set.  Note that changing values in the this set @b may
    /// result in unexpected changes in the new option set.
    OptionSet   duplicate() const;

    /// Returns true if property can be erased to revert back to default value.
    /// If the options aren't inherited (i.e. offline render), it cannot be
    /// erased.
    bool        canErase(int token) const;

    /// Erase properties
    void        erase(const UT_Set<int> &tokens);

    /// @{
    /// Private access
    bool                isValid() const { return myOptions.get() != nullptr; }
    VPRM_OptionSetPtr           &options() { return myOptions; }
    const VPRM_OptionSetPtr     &options() const { return myOptions; }
    /// @}
    /// Bool operator to test validity of pointer
    SYS_SAFE_BOOL        operator bool() const { return isValid(); }

    /// Return the name associated with a given option (i.e. dicingquality)
    const UT_StringHolder       &name(int token) const;

    /// Return the fully qualified name (i.e. karma::object::dicingquality)
    UT_StringHolder             fullName(int token) const;

    /// Return the token associated with a given name (or -1 if invalid)
    int                          find(const UT_StringRef &name) const;

    /// Import a property value.  Method is specialized for T in:
    /// - bool
    /// - int32/int64
    /// - fpreal32/fpreal64
    /// - UT_StringHolder
    template <typename T>
    const T     *import(int token, T *val, size_t n) const;

    /// Interface to set an property.  This template class is specialized for:
    /// - bool
    /// - int32
    /// - int64
    /// - fpreal32
    /// - fpreal64
    /// - UT_StringHolder
    template <typename T>
    bool        set(int token, const T *value, exint tuple_size);

    /// Simple interface to set a scalar property
    template <typename T>
    SYS_FORCE_INLINE bool set(int token, const T &value)
    {
        return set(token, &value, 1);
    }

    /// Test whether a value is the same as the current property
    template <typename T>
    bool        isEqual(int token, const T *value, exint tuple_size) const;

    /// Simple interface for equality of a scalar value.
    template <typename T>
    SYS_FORCE_INLINE bool       isEqual(int token, const T &value) const
    {
        return isEqual(token, &value, 1);
    }

    /// Test whether an option has variadic arguments
    bool        isVariadic(int token) const;

    /// Return the size of an option.  This can be used for variadics
    exint       size(int token) const;

    /// Return the storage of an option.  This will only be one of:
    /// - GT_STORE_INVALID
    /// - GT_STORE_UINT8 (for bool storage)
    /// - GT_STORE_INT64
    /// - GT_STORE_REAL64
    /// - GT_STORE_STRING
    GT_Storage  storage(int token) const;

    /// @{
    /// Direct access to internal option data.  There are no checks on these
    /// methods
    const bool                  *bval(int token) const;
    const int64                 *ival(int token) const;
    const fpreal64              *fval(int token) const;
    const UT_StringHolder       *sval(int token) const;
    /// @}

    /// @private Debug the options (only available in debug builds)
    void        dump(UT_JSONWriter &w) const;

private:
    VPRM_OptionSetPtr   myOptions;
};

/// When defining materials for face sets, the material specification is
/// given by a pair of the @c MaterialPtr and an array of integers.  The
/// integers specify the list of faces to material and must appear in
/// sorted order (smallest to largest).
/// Interface to the scene manager
class BRAY_API ScenePtr
{
public:
    ScenePtr() = default;
    ~ScenePtr();

    /// Allocate a new scene
    static ScenePtr     allocScene();

    /// convenience methods to determine which renderer is active (tests
    /// the value of the BRAY_OPT_ENGINE option)
    bool        isKarmaCPU() const;
    bool        isKarmaXPU() const;

    /// Test validity
    bool        isValid() const { return myScene.get() != nullptr; }

    /// Test whether the scene is thread-safe
    bool        threadSafe() const;

    /// Test whether the renderer supports nested instancing
    bool        nestedInstancing() const;

    /// Update an object in the scene
    void        updateObject(const ObjectPtr &ptr, BRAY_EventType event);

    /// Update light object in the scene
    void        updateLight(const LightPtr &ptr, BRAY_EventType event);

    /// Update camera object in the scene
    void        updateCamera(const CameraPtr &ptr, BRAY_EventType event);

    /// Update material object in the scene
    void        updateMaterial(const MaterialPtr &ptr, BRAY_EventType event);

    /// @{
    /// Set the unit scale for the scene - this is in meters/unit.  For
    /// example, centimeters would be 0.01.
    void        setSceneUnits(fpreal64 units);
    fpreal64    sceneUnits() const;
    /// @}

    /// Set camera ray visibility.  The mask should be a combination of
    ///   - BRAY_RAY_CAMERA
    ///   - BRAY_PROXY_CAMERA
    ///   - BRAY_GUIDE_CAMERA
    /// For example, (BRAY_RAY_CAMERA|BRAY_GUIDE_CAMERA) will cause guide and
    /// renderable object to be visible to camera rays, but not proxy objects
    void        setCameraRayMask(BRAY_RayVisibility mask);

    /// Set shadow ray visibility.  The mask should be a combination of
    ///   - BRAY_RAY_SHADOW
    ///   - BRAY_PROXY_SHADOW
    ///   - BRAY_GUIDE_SHADOW
    /// For example, (BRAY_RAY_SHADOW|BRAY_PROXY_SHADOW) will cause proxy and
    /// renderable object to cast shadows, but not GUIDE objects.
    void        setShadowRayMask(BRAY_RayVisibility mask);

    /// Force redicing of displacement and subd surfaces on the next render.
    /// This will only take effect on the next call to beginRender().
    void        forceRedice();

    /// @{
    /// Private access to the underling scene
    SYS_SAFE_BOOL        operator bool() const { return isValid(); }
    const BRAY_Scene    *scenePtr() const { return myScene.get(); }
    BRAY_Scene          *scenePtr() { return myScene.get(); }
    /// @}

    /// After changing any options, must commit prior to rendering
    void        commitOptions();

    /// @{
    /// Grab a copy of the current scene options
    OptionSet           sceneOptions();
    const OptionSet     constSceneOptions() const;
    /// @}

    /// @{
    /// Grab a copy of the current object properties.
    OptionSet           objectProperties();
    const OptionSet     constObjectProperties() const;
    /// @}

    /// @{
    /// Grab a copy of the current light properties
    OptionSet           lightProperties();
    const OptionSet     constLightProperties() const;

    /// @{
    /// Grab a copy of the current camera properties
    OptionSet           cameraProperties();
    const OptionSet     constCameraProperties() const;
    /// @}

    /// Grab a copy of the current image plane properties
    OptionSet           planeProperties();
    const OptionSet     constPlaneProperties() const;
    /// @}

    /// Grab a the default properties for a given type.  Changing their values
    /// will cause all future objects created to inherit the new values.
    OptionSet   defaultProperties(BRAY_PropertyType type) const;

    /// @{
    /// Convenience methods to look up scene and scene options.
    /// Get an scene option value.
    template <typename T>
    SYS_FORCE_INLINE const T    *optionImport(BRAY_SceneOption token,
                                        T *val, size_t n) const
    {
        return constSceneOptions().import(token, val, n);
    }

    /// Interface to set an option.  This template class is specialized for:
    template <typename T>
    SYS_FORCE_INLINE bool       setOption(BRAY_SceneOption token,
                                        const T *value,
                                        exint tuple_size)
    {
        return sceneOptions().set(token, value, tuple_size);
    }

    /// Simple interface to set a scalar option
    template <typename T>
    SYS_FORCE_INLINE bool
    setOption(BRAY_SceneOption token, const T &value)
    {
        return setOption(token, &value, 1);
    }

    /// Return the size of an option.  This can be used for variadics
    /// (e.g. shading quality will be 1)
    SYS_FORCE_INLINE exint      optionSize(BRAY_SceneOption token) const
    {
        return constSceneOptions().size(token);
    }

    /// Return the storage class of an option.
    SYS_FORCE_INLINE GT_Storage
    optionStorage(BRAY_SceneOption token) const
    {
        return constSceneOptions().storage(token);
    }

    /// Return whether an option has variadic arguments
    SYS_FORCE_INLINE bool
    optionIsVariadic(BRAY_SceneOption token) const
    {
        return constSceneOptions().isVariadic(token);
    }
    bool                optionB(BRAY_SceneOption t) const
                                { return *constSceneOptions().bval(t); }
    int64               optionI(BRAY_SceneOption t) const
                                { return *constSceneOptions().ival(t); }
    fpreal64            optionF(BRAY_SceneOption t) const
                                { return *constSceneOptions().fval(t); }
    UT_StringHolder     optionS(BRAY_SceneOption t) const
                                { return *constSceneOptions().sval(t); }
    /// @}

    /// @{
    /// Convenience methods to look up object properties.
    /// Get an object property value.
    template <typename T>
    SYS_FORCE_INLINE const T    *propertyImport(BRAY_ObjectProperty token,
                                        T *val, size_t n) const
    {
        return constObjectProperties().import(token, val, n);
    }

    /// Interface to set an property.  This template class is specialized for:
    template <typename T>
    SYS_FORCE_INLINE bool       setProperty(BRAY_ObjectProperty token,
                                        const T *value,
                                        exint tuple_size)
    {
        return objectProperties().set(token, value, tuple_size);
    }

    /// Locking the object property prevents any overriding of the property
    /// after the fact, essentially turning the property into a read-only
    /// property.  This method is intended to lock default properties.  The
    /// current value of the property is used as the value.
    ///
    /// The return value is the previous lock state of the property.
    bool                lockProperty(BRAY_ObjectProperty token, bool state);

    /// Lock properties based on a string pattern of parameter names.  This
    /// method returns the number of properties modified.
    exint               lockProperties(const char *pattern, bool state);

    /// Lock or unlock all object properties.
    SYS_FORCE_INLINE exint      lockAllObjectProperties(bool state)
                                    { return lockProperties("*", state); }

    /// Simple interface to set a scalar property
    template <typename T>
    SYS_FORCE_INLINE bool
    setProperty(BRAY_ObjectProperty token, const T &value)
    {
        return setProperty(token, &value, 1);
    }

    /// Return the size of an option.  This can be used for variadics
    /// (e.g. shading quality will be 1)
    SYS_FORCE_INLINE exint      propertySize(BRAY_ObjectProperty token) const
    {
        return constObjectProperties().size(token);
    }

    /// Return the storage class of an option.
    SYS_FORCE_INLINE GT_Storage
    propertyStorage(BRAY_ObjectProperty token) const
    {
        return constObjectProperties().storage(token);
    }

    /// Return whether an property has variadic arguments
    SYS_FORCE_INLINE bool
    propertyIsVariadic(BRAY_ObjectProperty token) const
    {
        return constObjectProperties().isVariadic(token);
    }
    bool                propertyB(BRAY_SceneOption t) const
                                { return *constObjectProperties().bval(t); }
    int64               propertyI(BRAY_SceneOption t) const
                                { return *constObjectProperties().ival(t); }
    fpreal64            propertyF(BRAY_SceneOption t) const
                                { return *constObjectProperties().fval(t); }
    UT_StringHolder     propertyS(BRAY_SceneOption t) const
                                { return *constObjectProperties().sval(t); }
    /// @}

    /// Create a light
    LightPtr            createLight(const UT_StringHolder &name);

    /// Create a camera
    CameraPtr           createCamera(const UT_StringHolder &name);

    /// Create a material
    MaterialPtr         createMaterial(const UT_StringHolder &name);

    /// Find a material.
    MaterialPtr         findMaterial(const UT_StringRef &name) const;

    /// Add a named transform space (that can be referenced from VEX)
    /// Returns true if the space was added (false if the space already exists)
    bool                addSpace(const UT_StringHolder &name,
                                const SpacePtr &space,
                                bool replace_existing = true);

    /// Add traceset name to global list (categories on objects that do not
    /// belong to this list will be ignored)
    /// Returns true if added, false if already exists.
    bool                addTraceset(const UT_StringHolder &name);

    /// Check to see if a traceset exists.
    bool                isTraceset(const UT_StringHolder &name);

    /// Create a shader nodegraph
    ShaderGraphPtr      createShaderGraph(const UT_StringHolder &name);

    /// Load an HDA to define shader code.  Not all applications support this
    /// feature.
    bool        loadHDA(const char *path);

private:
    UT_SharedPtr<BRAY_Scene>    myScene;
};

/// Input connector for materials.  This defines the name of the geometry
/// attribute (@c myInputName) to bind to the VEX shader parameter (@c myParmName)
struct BRAY_API MaterialInput
{
    enum class Storage
    {
        FLOAT,
        INTEGER,
        STRING
    };
    MaterialInput(const UT_StringHolder &primvar,
            const UT_StringHolder &shader_parm,
            Storage store,
            int tsize,
            bool is_array)
        : myGeometry(primvar)
        , myParmName(shader_parm)
        , myStorage(store)
        , myTupleSize(tsize)
        , myIsArray(is_array)
    {
    }

    UT_StringHolder     myGeometry;     // Input name (primvar name)
    UT_StringHolder     myParmName;     // Parameter Name (VEX parameter name)
    Storage             myStorage;      // Base storage type
    int                 myTupleSize;    // Element tuple size
    bool                myIsArray;      // Whether parameter is an array
};

using MaterialInputList = UT_Array<MaterialInput>;

/// Interface to scene materials
class BRAY_API MaterialPtr
{
public:
    MaterialPtr(BRAY_VexMaterial *mat = nullptr)
        : myMat(mat)
    {
    }
    ~MaterialPtr() {}

    bool        isValid() const { return myMat != nullptr; }

    /// @{
    /// Access to the underling material
    SYS_SAFE_BOOL                operator bool() const { return isValid(); }
    const BRAY_VexMaterial      *materialPtr() const { return myMat; }
    /// @}

    /// Update the surface shader and arguments
    void        updateSurface(const ScenePtr &scene,
                        const UT_StringArray &arguments);
    /// Update the displacement shader and arguments
    /// Returns true if arguments changed.
    bool        updateDisplace(const ScenePtr &scene,
                        const UT_StringArray &arguments);

    /// Update surface shader VEX code.  The @c preload flag is used when other
    /// shaders in the network might depend on the code being updated.
    void        updateSurfaceCode(const ScenePtr &scene,
                        const UT_StringHolder &name,
                        const UT_StringRef &code,
                        bool preload=false);
    /// Update displacement shader VEX code The @c preload flag is used when
    /// other shaders in the network might depend on the code being updated.
    /// Returns true if the name or the code changed.
    bool        updateDisplaceCode(const ScenePtr &scene,
                        const UT_StringHolder &name,
                        const UT_StringRef &code,
                        bool preload=false);

    /// Update the surface shader graph
    void        updateSurfaceGraph(const ScenePtr &scene,
                        const UT_StringHolder &name,
                        const ShaderGraphPtr &graphptr);
    /// Update the displacement shader graph
    /// Returns true if the name or the code changed.
    bool        updateDisplaceGraph(const ScenePtr &scene,
                        const UT_StringHolder &name,
                        const ShaderGraphPtr &graphptr);

    /// Set the material input list
    void        setInputs(const ScenePtr &scene,
                        const MaterialInputList &inputs,
                        bool for_surface);

private:
    BRAY_VexMaterial    *myMat;
};

struct BRAY_API FacesetMaterial
{
    FacesetMaterial(const GT_DataArrayHandle &facelist = GT_DataArrayHandle(),
            const MaterialPtr &material = MaterialPtr())
        : myFaceList(facelist)
        , myMaterial(material)
    {
    }
    GT_DataArrayHandle  myFaceList;
    MaterialPtr         myMaterial;
};

class BRAY_API ObjectPtr
{
public:
    ObjectPtr() = default;
    ~ObjectPtr();

    /// Create an object given a GT_Primitive handle.
    /// At the current time, the only classes supported are:
    /// - GT_PrimPolygonMesh
    /// - GT_PrimSubdivisionMesh
    /// - GT_PrimCurveMesh
    /// - GT_PrimPointMesh
    /// The method will return a nullptr if it can't create a primitive
    static ObjectPtr    createGeometry(const GT_PrimitiveHandle &prim);

    /// For polygonal meshes, use this to create geometry to handle holes
    static ObjectPtr    createGeometry(const GT_PrimitiveHandle &prim,
                                const GT_DataArrayHandle &holes);

    /// Create a volume given its detail attribute and the names and
    /// GT_PrimitiveHandles of the corresponding fields in the volume
    using FieldList = UT_Array<std::pair<UT_StringHolder, GT_PrimitiveHandle>>;
    static ObjectPtr    createVolume(const UT_StringHolder &name);

    /// Create an instance of an object
    static ObjectPtr    createInstance(const ObjectPtr &obj,
                                const UT_StringHolder &name);

    /// Create a nested scene graph
    static ObjectPtr    createScene();

    /// Create a procedural object.
    /// Ownership of the procedural is passed to the object.
    static ObjectPtr    createProcedural(UT_UniquePtr<BRAY_Procedural> proc);

    /// Test validity
    bool        isValid() const { return myObject != nullptr; }

    /// Query if object is a leaf node (ie not scenegraph or instance)
    bool        isLeaf() const;

    /// @{
    /// Access to the underlying object
    SYS_SAFE_BOOL        operator bool() const { return isValid(); }
    const BRAY_Object   *objectPtr() const { return myObject.get(); }
    BRAY_Object         *objectPtr() { return myObject.get(); }
    /// @}

    /// Bind a material to the object.  The method will fail if the underlying
    /// object cannot set the material.
    bool        setMaterial(ScenePtr &scene,
                        const MaterialPtr &mat,
                        const OptionSet &opts,
                        exint nfacesets=0,
                        const FacesetMaterial *faceset_mat=nullptr);

    /// Set the prototype for an instance object
    void        setInstancePrototype(const ObjectPtr &proto);

    /// Set the transform on the instance
    void        setInstanceTransforms(const UT_Array<SpacePtr> &xforms);

    /// Set attributes on instances
    void        setInstanceAttributes(const ScenePtr &scene,
                        const GT_AttributeListHandle &alist);

    /// Set property overrides for instances.  The array must have an entry for
    /// every instance.  It's possible to have default options.  Each
    /// attribute's name should match an object property name.  Warnings will
    /// be output if an attribute doesn't match.
    void        setInstanceProperties(const ScenePtr &scene,
                        const GT_AttributeListHandle &alist);

    /// Set instance IDs. If not set (or given an empty array), it is assumed
    /// that the ids are contiguous 0...N-1 where N is the number of xforms.
    void        setInstanceIds(UT_Array<exint> ids);

    /// Add an object to a scene
    void        addInstanceToScene(ObjectPtr &obj);

    /// Check to make sure that number of xforms, attribute list, ids all match
    bool        validateInstance() const;

    /// @{
    /// This will return the object's base properties, or the scene defaults if
    /// the object isn't defined yet.
    OptionSet           objectProperties(ScenePtr &scene);
    const OptionSet     objectProperties(const ScenePtr &scene) const;
    /// @}

    /// Get the underlying GT_PrimitiveHandle (if possible).  This method may
    /// return a nullptr.
    GT_PrimitiveHandle  geometry() const;

    /// Pointer to the contained procedural.  This may return a nullptr.
    BRAY_Procedural     *procedural();

    /// Update the geometry for the object.  The method will fail if you're
    /// trying to change the underlying primitive type.
    bool                setGeometry(const GT_PrimitiveHandle &prim);

    /// Set the list of "holes" for a polygon mesh (subdivision meshes have the
    /// list of holes specified in the subdivision tags).
    bool                setGeometry(const GT_PrimitiveHandle &prim,
                                    const GT_DataArrayHandle &holes);

    /// Update volume fields.  This method will fail if the underlying
    /// primitive isn't a volume (see createVolume())
    bool                setVolume(const ScenePtr &scene,
                                  const GT_AttributeListHandle &clist,
                                  const FieldList& fields);

    /// Return the detail attributes for a volume primitive
    const GT_AttributeListHandle        &volumeDetailAttributes() const;

    /// TODO: Deprecate this
    void        takeOwnership(BRAY_Object *obj);

protected:
    UT_SharedPtr<BRAY_Object>   myObject;
};

class BRAY_API LightPtr
{
public:
    LightPtr(const UT_SharedPtr<BRAY_Light> &lp = UT_SharedPtr<BRAY_Light>())
        : myLight(lp)
    {
    }
    ~LightPtr();

    /// Test validity
    bool        isValid() const { return myLight != nullptr; }

    /// @{
    /// Access to the underlying object
    SYS_SAFE_BOOL        operator bool() const { return isValid(); }
    const BRAY_Light    *lightPtr() const { return myLight.get(); }
    BRAY_Light          *lightPtr() { return myLight.get(); }
    /// @}

    /// Return the type of light
    BRAY_LightType      type() const;

    /// Set the transform on the instance
    void        setTransform(const SpacePtr &xforms);

    /// Set the shader for the light
    void        setShader(ScenePtr &scene, const UT_StringArray &args);

    /// Get the current object properties for modification.
    OptionSet   objectProperties();

    /// Get the current light properties for modification.
    OptionSet   lightProperties();

    /// After changing any options, must lock prior to rendering
    void        commitOptions(ScenePtr &scene);

    /// Update the light shader graph
    void        updateShaderGraph(const ScenePtr &scene,
                        const UT_StringHolder &name,
                        const ShaderGraphPtr &graphptr);

protected:
    UT_SharedPtr<BRAY_Light>    myLight;

};

class BRAY_API CameraPtr
{
public:
    CameraPtr(const UT_SharedPtr<BRAY_Camera> &cp = UT_SharedPtr<BRAY_Camera>())
        : myCamera(cp)
    {
    }
    ~CameraPtr();

    /// Test validity
    bool        isValid() const { return myCamera != nullptr; }

    /// @{
    /// Access to the underlying object
    SYS_SAFE_BOOL        operator bool() const { return isValid(); }
    const BRAY_Camera   *cameraPtr() const { return myCamera.get(); }
    BRAY_Camera         *cameraPtr() { return myCamera.get(); }
    /// @}

    /// Set the transform on the instance
    void        setTransform(const SpacePtr &xforms);

    /// Set the lens shader for the camera
    void        setShader(const ScenePtr &scene, const UT_StringArray &args);

    /// Get the current object properties for modification.
    OptionSet   objectProperties();

    /// Set number of motion samples for animated camera properties (1 upon
    /// construction). The last motion sample is assumed to have time offset of
    /// 1.0. (eg. if there are 3 samples, the time offsets are: 0, 0.5, 1.0)
    void        resizeCameraProperties(int nseg);

    /// Get the current camera properties for modification.
    UT_Array<OptionSet> cameraProperties();

    /// After changing any options, must lock prior to rendering
    void        commitOptions(ScenePtr &scene);

protected:
    UT_SharedPtr<BRAY_Camera>   myCamera;

};

class BRAY_API AOVBufferPtr
{
public:
    AOVBufferPtr() = default;

    AOVBufferPtr(const UT_SharedPtr<BRAY_AOVBuffer> &aov)
        : myAOVBuffer(aov)
    {}

    ~AOVBufferPtr() {};

    bool        operator==(const AOVBufferPtr &aov) const
                    { return aov.myAOVBuffer == myAOVBuffer; }
    bool        operator!=(const AOVBufferPtr &aov) const
                    { return !(*this == aov); }

    const UT_StringHolder       &getName() const;
    const UT_StringHolder       &getVariable() const;

    int              getXres() const;
    int              getYres() const;
    PXL_DataFormat   getFormat() const;
    PXL_Packing      getPacking() const;
    float            getDefaultValue() const;

    void            *map();
    void             unmap();
    bool             isMapped() const;

    // For extra channels
    int              getNumExtra() const;
    const UT_StringHolder &nameExtra(int idx) const;
    PXL_DataFormat   getFormatExtra(int idx) const;
    PXL_Packing      getPackingExtra(int idx) const;
    void            *mapExtra(int idx);
    void             unmapExtra(int idx);

    // metadata to write to header of output file
    const UT_Options &getMetadata() const;

    bool             isConverged() const;
    void             setConverged();
    void             clearConverged();

    // Valid only after raster is allocated (ie render started)
    bool             isValid() const;

    SYS_SAFE_BOOL        operator bool() const { return isValid(); }

private:
    UT_SharedPtr<BRAY_AOVBuffer> myAOVBuffer;
};

/// A render product represents an output file
class BRAY_API OutputFile
{
public:
    // Test whether the type is understook by karma
    // For example "karma:checkpoint"
    static bool isKnownType(const UT_StringRef &type);

    // Clear all existing output files
    static void clearFiles(BRAY::ScenePtr &scene);

    struct BRAY_API AOV
    {
        AOV(const UT_StringHolder &name)
            : myName(name)
        {
        }
        /// Method is specialized for T in:
        /// - bool
        ///     - int32/int64
        ///     - fpreal32/fpreal64
        ///     - UT_StringHolder
        template <typename T>
        bool        setOption(const UT_StringHolder &name,
                            const T *value,
                            exint size);
        template <typename T>
        bool        setOption(const UT_StringHolder &name, const T &value)
                        { return setOption(name, &value, 1); }

        /// Copy over options from those passed in
        bool    setOptions(const UT_Options &options);

        const UT_StringHolder   &name() const { return myName; }
        const UT_Options        &options() const { return myOptions; }

        /// Dump method for debugging
        void    dump(UT_JSONWriter &w) const;
    private:
        UT_StringHolder myName;
        UT_Options      myOptions;
    };
    OutputFile(BRAY::ScenePtr &scene,
            const UT_StringHolder &filename,
            const UT_StringHolder &type)
        : myScene(scene)
        , myFilename(filename)
        , myType(type)
    {
    }

    ~OutputFile()
    {
        if (myFilename)
            commit();
    }

    /// @{
    /// Method is specialized for T in:
    /// - bool
    /// - int32/int64
    /// - fpreal32/fpreal64
    /// - UT_StringHolder
    template <typename T>
    bool        setOption(const UT_StringHolder &name,
                        const T *value,
                        exint size);
    template <typename T>
    bool        setOption(const UT_StringHolder &name, const T &value)
                    { return setOption(name, &value, 1); }
    /// @}

    /// Copy over options from those passed in
    bool    setOptions(const UT_Options &options);

    /// Add an AOV to this output file
    AOV         &appendAOV(const UT_StringHolder &name)
    {
        myAOVs.emplace_back(name);
        return myAOVs.last();
    }

    /// Commit and add this output file to the render
    bool        commit()
    {
        bool    result = doCommit();
        cancel();       // Once committed, no more changes
        return result;
    }
    /// Cancel this output file for some reason
    void        cancel() { myFilename.clear(); }

    /// Access member data
    const UT_StringHolder       &filename() const { return myFilename; }
    const UT_StringHolder       &type() const { return myType; }
    const UT_Array<AOV>         &aovs() const { return myAOVs; }
    const UT_Options            &options() const { return myOptions; }

    /// @{
    /// Dump information (used by karma:debug)
    void        dump() const;
    void        dump(UT_JSONWriter &w) const;
    /// @}

private:
    bool        doCommit();
    BRAY::ScenePtr      &myScene;
    UT_StringHolder      myFilename;
    UT_StringHolder      myType;
    UT_Array<AOV>        myAOVs;
    UT_Options           myOptions;
};


/// Interface to the renderer
class BRAY_API RendererPtr
{
public:
    /// Class used to define image planes
    struct ImagePlane
    {
        UT_StringHolder myName;
        UT_StringHolder myVariable;
        int             mySize;
        PXL_DataFormat  myDataFormat;
        OptionSet       myOptions;
    };

    struct Stats
    {
        enum RenderStage
        {
            STAGE_INACTIVE,
            STAGE_LOADING,
            STAGE_INITIALIZING,
            STAGE_GUIDING_TRAINING,
            STAGE_RENDERING,
        };

        Stats()
        {
            clear();
            myFrameCount = 0;
        }
        void    clear()
        {
            myWorldToCamera = UT_Matrix4D(1);
            myWorldToScreen = UT_Matrix4D(1);
            myWorldToNDC = UT_Matrix4D(1);
            myWorldToRaster = UT_Matrix4D(1);
            myStage = STAGE_INACTIVE;
            myPercentDone = 0;
            myCameraRays = 0;
            myIndirectRays = 0;
            myOcclusionRays = 0;
            myLightGeoRays = 0;
            myProbeRays = 0;
            myPolyCount = UT_Vector2I(0, 0);
            myCurveCount = UT_Vector2I(0, 0);
            myPointCount = UT_Vector2I(0, 0);
            myPointMeshCount = UT_Vector2I(0, 0);
            myVolumeCount = UT_Vector2I(0, 0);
            myProceduralCount = UT_Vector2I(0, 0);
            myLightCount = 0;
            myLightTreeCount = 0;
            myCameraCount = 0;
            myOctreeBuildTime = 0;
            myLoadWallClock = 0;
            myLoadCPU = 0;
            myLoadSystem = 0;
            myLoadMemory = 0;
            myTotalWallClock = 0;
            myTotalCPU = 0;
            myTotalSystem = 0;
            myCurrentMemory = 0;
            myPeakMemory = 0;
            myObjectCountsSet = false;
            myFilterErrors.clear();
            myPrimvar.clear();
            myDetailedTimes.clear();
            myRenderProgressAnnotation.clear();
            myRenderStatsAnnotation.clear();
        }

        /// Transform matrices
        UT_Matrix4D     myWorldToCamera;
        UT_Matrix4D     myWorldToScreen;
        UT_Matrix4D     myWorldToNDC;
        UT_Matrix4D     myWorldToRaster;

        /// Current state of rendering
        RenderStage     myStage;

        /// Total number of frames rendered
        int             myFrameCount;

        /// Percent complete of current frame
        fpreal          myPercentDone;

        /// Ray counts
        int64           myCameraRays;
        int64           myIndirectRays;
        int64           myOcclusionRays;
        int64           myLightGeoRays;
        int64           myProbeRays;

        /// Object counts -- only defined if verbose >= 2
        UT_Vector2I     myPolyCount; // Individual/Instances
        UT_Vector2I     myCurveCount; // Individual/Instances
        UT_Vector2I     myPointCount; // Individual/Instances
        UT_Vector2I     myPointMeshCount; // Individual/Instances
        UT_Vector2I     myVolumeCount; // Individual/Instances
        UT_Vector2I     myProceduralCount; // Individual/Instances
        UT_Vector2D     myNearFar;
        int64           myLightCount; // Total lights in the scene
        int64           myLightTreeCount; // Lights in the light tree
        int64           myCameraCount; // Cameras in the scene

        /// Times
        fpreal          myOctreeBuildTime;      // Time to build octree

        /// Initialization times
        fpreal          myLoadWallClock;        // Wall clock time for load
        fpreal          myLoadCPU;              // CPU time for load
        fpreal          myLoadSystem;           // System time for load
        int64           myLoadMemory;           // Memory after load

        /// Render times
        fpreal          myTotalWallClock;       // Wall clock time for render
        fpreal          myTotalCPU;             // CPU time for load
        fpreal          myTotalSystem;          // System time for load
        int64           myCurrentMemory;        // Current memory

        int64           myPeakMemory;           // Memory after load

        // Whether myPolyCount, myCurveCount etc. are set
        bool            myObjectCountsSet;

        // Errors from image/pixel/sample filters
        UT_StringArray  myFilterErrors;

        // Internal stats
        UT_StringHolder myPrimvar;

        /// Detailed times if verbose >= 4
        UT_StringHolder myDetailedTimes;

        // Accelerator stats
        UT_StringHolder myRenderProgressAnnotation;     // multi line
        UT_StringHolder myRenderStatsAnnotation;        // multi line
    };

    RendererPtr() = default;
    ~RendererPtr() {};

    /// Allocate renderer
    static RendererPtr  allocRenderer(BRAY::ScenePtr &sceneptr);

    SYS_SAFE_BOOL        operator bool() const { return myRenderer.get(); }

    /// @{
    /// Define image planes for rendering
    void         clearOutputPlanes();
    AOVBufferPtr addOutputPlane(const ImagePlane &plane);
    int          getAOVCount() const;
    /// @}

    /// Return stats about rendering
    const Stats &renderStats() const;

    /// Call before rendering begins.  This lets the renderer prepare data
    /// structures before render() is called.  For example, this will ensure
    /// all AOV buffers are allocated and active.  The method returns false if
    /// there were errors setting up the render.
    bool        prepareRender();

    /// Start rendering a scene
    void        render(bool (*stopreq)(void *) = nullptr, void *data = nullptr);

    /// Test to see whether the current renderer is active
    bool        isRendering() const;

    /// Test to see if there was an error rendering
    bool        isError() const;

    /// Test to see if the renderer is paused
    bool        isPaused() const;

    /// Tells the renderer to prepare to be stopped
    void        prepareForStop();

    /// Pause rendering -- Returns true if the renderer is paused
    bool        pauseRender();

    /// Restart rendering  -- Returns true if @c isRendering();
    bool        resumeRender();

    /// Set a point in the image to give priority to rendering
    void        setPriority(int x, int y);

    /// Set a region in the image which should have priority
    void        setPriority(const UT_DimRect &region);

    /// Clear the priority focus
    void        clearPriority();

private:
    UT_SharedPtr<BRAY_Renderer> myRenderer;
};

class BRAY_API ShaderGraphPtr
{
public:
    ShaderGraphPtr(UT_SharedPtr<BRAY_ShaderGraph> graph)
    : myGraph(graph)
    {}
    ~ShaderGraphPtr() {};

    /// @{
    /// Access to the underlying object
    const BRAY_ShaderGraph *graphPtr() const { return myGraph.get(); }
    /// @}

    /// Make new node based on type and add to list of nodes in the current
    /// graph. Returns NULL if unknown type.
    /// Note that the root node (ie with surface/displace output) must be the
    /// first node added to the graph.
    BRAY_ShaderInstance *createNode(const UT_StringHolder &type,
                                    const UT_StringHolder &name);

    /// Returns OptionSet that contains input parameters for given shader node.
    /// Can be used to read and write values.
    OptionSet            nodeParams(BRAY_ShaderInstance *node);

    /// Make connection between two nodes
    bool                 wireNodes(const UT_StringHolder &srcnode,
                                   const UT_StringHolder &srcoutput,
                                   const UT_StringHolder &dstnode,
                                   const UT_StringHolder &dstinput);

    // Definition of a shader node
    class NodeDecl
        : UT_NonCopyable
    {
    public:
        NodeDecl() {}
        NodeDecl(const UT_StringHolder &n)
            : myName(n)
        {
        }

        struct Parameter
        {
            UT_StringHolder     myName; // Name of parameter

            bool        isBool() const { return myB.size() > 0; }
            bool        isInt() const { return myI.size() > 0; }
            bool        isReal() const { return myF.size() > 0; }
            bool        isFloat() const { return myF.size() > 0; }
            bool        isString() const { return myS.size() > 0; }
            bool        isVariadic() const { return myVariadic; }

            exint       size() const
            {
                return myB.size() + myI.size() + myF.size() + myS.size();
            }

            UT_Array<bool>              myB;    // Bool defaults
            UT_Array<int64>             myI;    // Integer defaults
            UT_Array<fpreal64>          myF;    // Real defaults
            UT_Array<UT_StringHolder>   myS;    // String defaults
            bool                        myVariadic; // Array valued (variadic)

            void        dump(UT_JSONWriter &w) const;
        };

        const UT_StringHolder            name() const { return myName; }
        const UT_Array<Parameter>       &inputs() const { return myInputs; }
        const UT_Array<Parameter>       &outputs() const { return myOutputs; }

        void    setName(const UT_StringHolder &n) { myName = n; }
        void    addInput(const Parameter &parm) { myInputs.append(parm); }
        void    addOutput(const Parameter &parm) { myOutputs.append(parm); }

        void    dump() const;
        void    dump(UT_JSONWriter &w) const;

    private:
        UT_StringHolder                 myName;
        UT_Array<Parameter>             myInputs;
        UT_Array<Parameter>             myOutputs;
    };

    // Extract the definition of all supported nodes
    static const UT_Array<const NodeDecl *>     &allNodes();
    // Find a node given the name
    static const NodeDecl       *findNode(const UT_StringRef &name);

private:
    UT_SharedPtr<BRAY_ShaderGraph>  myGraph;
};

};      // End of namespace

#endif