BRAY_ProceduralScene.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_ProceduralScene.h (BRAY Library, C++)
*
* COMMENTS:     BRAY procedural for building scenes with BRAY_Interface.
*
*               This procedural can be inherited from and used as an easy
*               way to generate render time geometry. All that needs to
*               be implemented is the updateScene() and the
*               doSetParameter() methods, as well as a BRAY_ProceduralFactory.
*/

#ifndef __BRAY_ProceduralScene__
#define __BRAY_ProceduralScene__

#include <BRAY/BRAY_Procedural.h>
#include <BRAY/BRAY_Interface.h>
#include <UT/UT_SmallArray.h>

class BRAY_Accelerator;
class BRAY_Instance;

class BRAY_API BRAY_ProceduralScene : public BRAY_Procedural
{
public:
    /// Derive the SceneHit so we can pass around the hit instance
    class BRAY_API SceneHit : public BRAY_Procedural::Hit
    {
    public:
        ~SceneHit() override = default;

        const BRAY_Instance *inst;
    };

    /// Wrapper around BRAY::ScenePtr
    class BRAY_API Scene
    {
    public:
        Scene();

        /// Reset the scene
        void reset();

        /// Bind the built scene to our pointers and check for validity
        bool bindScene();

        /// Create an attribute list with all attributes
        void
        createAttribList(UT_Array<BRAY_AttribList::Attrib> &alist);

        /// Get the bounding box of the scene
        void bounds(UT_BoundingBox &bounds, BRAYtime time) const;

        /// Templated function to evaluate attributes
        /// Specialized for: int32/64, fpreal32/64, UT_StringHolder,
        ///     UT_ValArray<int32/64>, UT_ValArray<fpreal32/64> UT_StringArray
        template <typename T>
        const T *attribEval(
                int attrib,
                BRAYtime time,
                const BRAY_Procedural::Hit &hit,
                T *buf,
                int size) const;

        /// Intersect the scene
        template <typename T>
        BRAY_Procedural::HitPtr
        intersect(const BRAY_Procedural::Ray<T> &ray,
                  const BRAY_ProceduralScene &proc) const;

        /// Get the underlying ScenePtr
        BRAY::ScenePtr &scene() { return myScene; }
        const BRAY::ScenePtr &scene() const { return myScene; }

        struct AttrInfo
        {
            int                             myAttribIdx;
            BRAY_AttribList::AttributeOwner myOwner;
        };

    private:
        BRAY::ScenePtr                   myScene;
        BRAY_Accelerator                *myAccelerator;
        BRAY_Scene                      *myRawScene;
        // This array of maps let's us go from the global attriblist idx
        // to the instance's attriblist idx
        UT_Array<UT_StringMap<AttrInfo>> myAttribInstanceMap;
    };

    BRAY_ProceduralScene();
    virtual ~BRAY_ProceduralScene() override {};

    HitPtr newHit() const final override { return HitPtr(new SceneHit()); }

    /// Get the underlying ScenePtr
    BRAY::ScenePtr &scene() { return myScene.scene(); }
    const BRAY::ScenePtr &scene() const { return myScene.scene(); }

    /// Reset the underlying ScenePtr, note you'll need to get the
    /// new ScenePtr using @c scene()
    void reset() { myScene.reset(); }

    /// Allow the deriving class to override these, but by default build
    /// the scene and set myValid based on it's return result
    void    doBeginUpdate() override { /* no action */ };
    void    doEndUpdate() override;

    /// Check to see whether the procedural is valid
    bool    checkIsValid() const override { return myValid; };

    /// Build or update the underlying scene, return true on success.
    /// Use @c scene() to get the underlying ScenePtr, and use
    virtual bool updateScene() = 0;

    /// Get the attribute list
    const BRAY_AttribList       *attribList() const override
        { return myAttribs; }

    /// Fills the given bounding box
    void bounds(UT_BoundingBox &bounds, BRAYtime time) const override
        { myScene.bounds(bounds, time); }

    /// @{
    /// Perform ray-intersection
    HitPtr intersect(const Ray32 &ray) const final override
        { return myScene.intersect(ray, *this); }
    HitPtr intersect(const Ray64 &ray) const final override
        { return myScene.intersect(ray, *this); }
    /// @}

    // These are pure virtuals for the derived class to deal with
    using BRAY_Procedural::factory;
    using BRAY_Procedural::doSetParameter;
    // NOTE: Not sure if this one should have a default in this class
    using BRAY_Procedural::update;

    /// @{
    /// Evaluate an attribute on this primitive.  The methods should return a
    /// pointer to the attribute data.  If there isn't a direct raw pointer to
    /// the data, the buffer passed in can be used to store the data and that
    /// pointer can be returned.
    const int32          *attribVal(int attrib, BRAYtime time,
                                    const Hit &hit_info, int32 *buf,
                                    int size) const final override;
    const int64          *attribVal(int attrib, BRAYtime time,
                                    const Hit &hit_info, int64 *buf,
                                    int size) const final override;
    const fpreal32       *attribVal(int attrib, BRAYtime time,
                                    const Hit &hit_info, fpreal32 *buf,
                                    int size) const final override;
    const fpreal64       *attribVal(int attrib, BRAYtime time,
                                    const Hit &hit_info, fpreal64 *buf,
                                    int size) const final override;
    const UT_StringHolder *attribVal(int attrib, BRAYtime time,
                                    const Hit &hit_info, UT_StringHolder *buf,
                                     int size) const final override;
    /// @}

    /// @{
    /// Evaluation of array attributes (each attribute can have an arbitrary
    /// number of entries.  By default, the array attribute evaluators set the
    /// arrays to a size of 0 and return the storage array.
    const UT_ValArray<int32>    *attribVal(int attrib,
                                            BRAYtime time,
                                            const Hit &hit_info,
                                            UT_ValArray<int32> *buf,
                                            int size) const final override;
    const UT_ValArray<int64>    *attribVal(int attrib,
                                            BRAYtime time,
                                            const Hit &hit_info,
                                            UT_ValArray<int64> *buf,
                                            int size) const final override;
    const UT_ValArray<fpreal32> *attribVal(int attrib,
                                            BRAYtime time,
                                            const Hit &hit_info,
                                            UT_ValArray<fpreal32> *buf,
                                            int size) const final override;
    const UT_ValArray<fpreal64> *attribVal(int attrib,
                                            BRAYtime time,
                                            const Hit &hit_info,
                                            UT_ValArray<fpreal64> *buf,
                                            int size) const final override;
    const UT_StringArray        *attribVal(int attrib,
                                            BRAYtime time,
                                            const Hit &hit_info,
                                            UT_StringArray *buf,
                                            int size) const final override;
    /// @}

private:
    Scene                        myScene;
    const BRAY_AttribList       *myAttribs;
    bool                         myValid;
};

#endif