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_SharedPtr.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_UniquePtr.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_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 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;
};

class BRAY_API OptionSet
{
public:
    OptionSet();
    OptionSet(const OptionSet &src);
    OptionSet(const VPRM_OptionSetPtr &o);
    ~OptionSet();

    OptionSet   &operator=(const OptionSet &o);

    /// @{
    /// 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();

    /// 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);

    /// 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        lockOptions();

    /// Grab a copy of the current scene options
    OptionSet   sceneOptions() const;

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

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

    /// Grab a copy of the current camera properties
    OptionSet   cameraProperties() const;

    /// Grab a copy of the current image plane properties
    OptionSet   planeProperties() 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 sceneOptions().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 sceneOptions().size(token);
    }

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

    /// Return whether an option has variadic arguments
    SYS_FORCE_INLINE bool
    optionIsVariadic(BRAY_SceneOption token) const
    {
        return sceneOptions().isVariadic(token);
    }
    bool                optionB(BRAY_SceneOption t) const
                                { return *sceneOptions().bval(t); }
    int64               optionI(BRAY_SceneOption t) const
                                { return *sceneOptions().ival(t); }
    fpreal64            optionF(BRAY_SceneOption t) const
                                { return *sceneOptions().fval(t); }
    UT_StringHolder     optionS(BRAY_SceneOption t) const
                                { return *sceneOptions().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 objectProperties().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);
    }

    /// 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 objectProperties().size(token);
    }

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

    /// Return whether an property has variadic arguments
    SYS_FORCE_INLINE bool
    propertyIsVariadic(BRAY_ObjectProperty token) const
    {
        return objectProperties().isVariadic(token);
    }
    bool                propertyB(BRAY_SceneOption t) const
                                { return *objectProperties().bval(t); }
    int64               propertyI(BRAY_SceneOption t) const
                                { return *objectProperties().ival(t); }
    fpreal64            propertyF(BRAY_SceneOption t) const
                                { return *objectProperties().fval(t); }
    UT_StringHolder     propertyS(BRAY_SceneOption t) const
                                { return *objectProperties().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);

private:
    UT_SharedPtr<BRAY_Scene>    myScene;
};

/// 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
    void        updateSurfaceCode(const ScenePtr &scene,
                        const char *name,
                        const UT_StringRef &code);
    /// Update displacement shader VEX code
    /// Returns true if the name or the code changed.
    bool        updateDisplaceCode(const ScenePtr &scene,
                        const char *name,
                        const UT_StringRef &code);
private:
    BRAY_VexMaterial    *myMat;
};

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

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);

    /// 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 char *name = nullptr);

    /// 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; }

    /// @{
    /// 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 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);

    /// Get the current object properties for modification.  If there are no
    /// face sets, the array length will be 1.  Otherwise, the properties for
    /// every face set will also be included in the array.
    ///
    /// If the object hasn't been initialized yet, default properties will be
    /// returned.
    void        objectProperties(const ScenePtr &scene,
                        UT_Array<OptionSet> &properties) const;

    /// @{
    /// This will return the object's base properties, or the scene defaults if
    /// the object isn't defined yet.
    OptionSet           objectProperties(const 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);

    /// Update volume fields.  This method will fail if the underlying
    /// primitive isn't a volume (see createVolume())
    bool                setVolume(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        lockOptions(ScenePtr &scene);

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        lockOptions(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); }

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

    void            *map();
    void             unmap();
    bool             isMapped() 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;
};

/// 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_RENDERING,
        };

        Stats()
        {
            clear();
            myFrameCount = 0;
        }
        void    clear()
        {
            myWorldToCamera = UT_Matrix4D(1);
            myWorldToScreen = UT_Matrix4D(1);
            myStage = STAGE_INACTIVE;
            myPercentDone = 0;
            myCameraRays = 0;
            myIndirectRays = 0;
            myOcclusionRays = 0;
            myLightGeoRays = 0;
            myProbeRays = 0;
            myObjectCountsSet = false;
            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;
            myFilterErrors.clear();
            myPrimvar.clear();
        }

        /// Transform matrices
        UT_Matrix4D     myWorldToCamera;
        UT_Matrix4D     myWorldToScreen;

        /// 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
        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

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

        // Internal stats
        UT_StringHolder myPrimvar;

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

    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;

    /// 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 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();

private:
    UT_SharedPtr<BRAY_Renderer> myRenderer;
};

};      // End of namespace

#endif