RixSceneGraph.h

Go to the documentation of this file.

/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 1986-2019 Pixar. All rights reserved.
#
# The information in this file (the "Software") is provided for the exclusive
# use of the software licensees of Pixar ("Licensees").  Licensees have the
# right to incorporate the Software into other products for use by other
# authorized software licensees of Pixar, without fee. Except as expressly
# permitted herein, the Software may not be disclosed to third parties, copied
# or duplicated in any form, in whole or in part, without the prior written
# permission of Pixar.
#
# The copyright notices in the Software and this entire statement, including the
# above license grant, this restriction and the following disclaimer, must be
# included in all copies of the Software, in whole or in part, and all permitted
# derivative works of the Software, unless such copies or derivative works are
# solely in the form of machine-executable object code generated by a source
# language processor.
#
# PIXAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL PIXAR BE
# LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  IN NO CASE WILL
# PIXAR'S TOTAL LIABILITY FOR ALL DAMAGES ARISING OUT OF OR IN CONNECTION WITH
# THE USE OR PERFORMANCE OF THIS SOFTWARE EXCEED $50.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/

/*
 * Version 2
 *
 * This is a preview release and is not supported.  This API will change substantially
 * in the next release of RenderMan.  Names, namespaces, methods, parameters, types,
 * enums, and the structure of the interface are expected to change.
 *
 */

#ifndef RixSceneGraph_h
#define RixSceneGraph_h

#include "RiTypesHelper.h"  // RtUString, RtPoint3, RtMatrix4x4, etc.
#include "RixInterfaces.h"  // RixInterface
#include "RtParamList.h"    // RtParamList, RtDataType, RtDetailType

class RixSGCamera;
class RixSGCurves;
class RixSGGeometry;
class RixSGGroup;
class RixSGAnalyticLight;
class RixSGManager;
class RixSGMaterial;
class RixSGMesh;
class RixSGNuPatch;
class RixSGPoints;
class RixSGProcedural;
class RixSGQuadric;
class RixSGScene;
class RixSGVolume;
class RixSGBlobby;
struct RixSGDisplayChannel;
struct RixSGShader;

typedef uint64_t (*RixSGUpdateIdCallback)(void* ctx, RixSGGroup const* node, RtUString const& path);

class Ri;
namespace Sg
{
class DagProperties;
}
namespace riley
{
class Riley;
}

enum class RixSGError
{
    k_Success,       
    k_InvalidState,  
    k_InvalidInput,  
};

enum class RixSGDagType
{
    k_Group,          
    k_Camera,         
    k_ClippingPlane,  
    k_AnalyticLight,  
    k_Geometry,       
    k_Quadric,        
    k_Mesh,           
    k_NuPatch,        
    k_Curves,         
    k_Points,         
    k_Blobby,         
    k_Volume,         
    k_Procedural,     
};

enum class RixSGShaderType
{
    k_Invalid,        
    k_Pattern,        
    k_Bxdf,           
    k_Integrator,     
    k_Light,          
    k_LightFilter,    
    k_Projection,     
    k_Displacement,   
    k_SampleFilter,   
    k_DisplayFilter,  
    k_Display,        
};

struct RixSGDisplayChannel
{
    RixSGDisplayChannel();

    RixSGDisplayChannel(RtDataType t, RtUString h);

    RixSGDisplayChannel(RixSGDisplayChannel const&) = default;

    RixSGDisplayChannel& operator=(RixSGDisplayChannel const&) = default;

    RtDataType type;

    RtUString handle;

    RtParamList params;
};

struct RixSGShader
{
    RixSGShader();

    RixSGShader(RixSGShaderType t, RtUString n, RtUString h);

    RixSGShader(RixSGShader const&) = default;

    RixSGShader& operator=(RixSGShader const&) = default;

    RixSGShaderType type;

    RtUString name;

    RtUString handle;

    RtParamList params;
};

class RixSGMaterial
{
public:
    virtual RtUString GetIdentifier() const = 0;

    virtual RixSGError SetIdentifier(RtUString identifier) = 0;

    virtual RixSGError SetBxdf(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetLight(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetLightFilter(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetDisplace(unsigned num, RixSGShader const* nodes) = 0;

    inline RixSGMaterial() = default;
    virtual ~RixSGMaterial() = default;
};

class RixSGGroup
{
public:
    virtual RixSGDagType GetDagType() const = 0;

    virtual RtUString GetIdentifier() const = 0;

    virtual RixSGError SetIdentifier(RtUString identifier) = 0;

    virtual RixSGError SetTransform(unsigned numsamples, RtMatrix4x4 const* xforms,
                                    float const* times) = 0;

    virtual RixSGError SetTransformNumSamples(unsigned numsamples) = 0;

    virtual RixSGError SetTransformSample(unsigned sample, RtMatrix4x4 const& xform,
                                          float time) = 0;

    RixSGError SetTransform(RtMatrix4x4 const& xform);

    RixSGError SetIdentity();

    virtual RixSGError SetHidden(int state) = 0;

    virtual int GetHidden() const = 0;

    virtual RixSGError AddCoordinateSystem(RixSGGroup* coordsys) = 0;

    virtual RixSGError RemoveCoordinateSystem(RixSGGroup* coordsys) = 0;

    virtual unsigned GetNumCoordinateSystems() const = 0;

    virtual RixSGGroup* GetCoordinateSystem(unsigned idx) const = 0;

    virtual RixSGError AddChild(RixSGGroup* child) = 0;

    virtual RixSGError RemoveChild(RixSGGroup* child) = 0;

    virtual unsigned GetNumChildren() const = 0;

    virtual RixSGGroup* GetChild(unsigned idx) const = 0;

    virtual unsigned GetNumParents() const = 0;

    virtual RixSGGroup* GetParent(unsigned idx) const = 0;

    virtual RixSGGroup* FindDagNode(char const* path) const = 0;

    virtual RixSGMaterial* GetMaterial() const = 0;

    virtual RixSGError SetMaterial(RixSGMaterial* material) = 0;

    virtual RixSGError OverrideMaterial(RixSGMaterial* material, unsigned depth,
                                        RixSGGroup** path) = 0;

    virtual RtParamList const& GetAttributes() const = 0;

    virtual RixSGError SetAttributes(RtParamList const& attributes) = 0;

    virtual RixSGError SetNested(bool state) = 0;

    virtual bool GetNested() const = 0;

    virtual RixSGError SetInheritTransform(bool value) = 0;

    virtual int Dirty() const = 0;
    virtual void ToRi(Ri* ri, Sg::DagProperties const& prop) = 0;
    virtual void ToRiley(riley::Riley* riley, Sg::DagProperties const& prop) = 0;
    virtual void DeleteInstance(Sg::DagProperties const& prop) = 0;
    virtual void DeleteMaster() = 0;
    RixSGGroup(RixSGGroup const&) = delete;
    RixSGGroup const& operator=(RixSGGroup const&) = delete;

    inline RixSGGroup() = default;
    virtual ~RixSGGroup() = default;
};

class RixSGCamera : public RixSGGroup
{
public:
    virtual RixSGError SetRenderable(int renderable) = 0;

    virtual RixSGError SetProjection(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetDisplay(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetOrientTransform(RtMatrix4x4 const& localxform) = 0;

    virtual RtParamList const& GetProperties() const = 0;

    virtual RixSGError SetProperties(RtParamList const& prop) = 0;

protected:
    inline RixSGCamera() = default;
    virtual ~RixSGCamera() = default;
};

class RixSGClippingPlane : public RixSGGroup
{
public:
    virtual RixSGError SetActive(bool active) = 0;

    virtual RixSGError SetOrientTransform(RtMatrix4x4 const& localxform) = 0;

protected:
    inline RixSGClippingPlane() = default;
    virtual ~RixSGClippingPlane() = default;
};

class RixSGAnalyticLight : public RixSGGroup
{
public:
    virtual RixSGError SetLight(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetLightFilter(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetOrientTransform(RtMatrix4x4 const& localxform) = 0;

protected:
    inline RixSGAnalyticLight() = default;
    virtual ~RixSGAnalyticLight() = default;
};

class RixSGGeometry : public RixSGGroup
{
public:
    virtual RtUString Geometry() const = 0;

    virtual RixSGError SetGeometry(RtUString type) = 0;

    virtual RtParamList const& GetPrimVars() const = 0;

    virtual RixSGError SetPrimVars(RtParamList const& primvars) = 0;

protected:
    inline RixSGGeometry() = default;
    virtual ~RixSGGeometry() = default;
};

class RixSGQuadric : public RixSGGeometry
{
public:
    virtual RixSGError SetGeometry(RtUString type) = 0;

protected:
    inline RixSGQuadric() = default;
    virtual ~RixSGQuadric() = default;
};

class RixSGMesh : public RixSGGeometry
{
public:
    virtual RixSGError Define(int32_t npolys, int32_t npoints, int32_t nverts) = 0;

    virtual RixSGError SetScheme(RtUString scheme) = 0;

protected:
    inline RixSGMesh() = default;
    virtual ~RixSGMesh() = default;
};

class RixSGPoints : public RixSGGeometry
{
public:
    virtual RixSGError Define(int32_t npoints) = 0;

protected:
    inline RixSGPoints() = default;
    virtual ~RixSGPoints() = default;
};

class RixSGVolume : public RixSGGeometry
{
public:
    virtual RixSGError Define(int32_t nx, int32_t ny, int32_t nz) = 0;

protected:
    inline RixSGVolume() = default;
    virtual ~RixSGVolume() = default;
};

class RixSGBlobby : public RixSGGeometry
{
public:
    virtual RixSGError Define(int32_t nleaf) = 0;

protected:
    inline RixSGBlobby() = default;
    virtual ~RixSGBlobby() = default;
};

class RixSGCurves : public RixSGGeometry
{
public:
    virtual RixSGError Define(RtUString type, RtUString wrap, RtUString basis, int32_t ncurves,
                              int32_t npoints) = 0;

protected:
    inline RixSGCurves() = default;
    virtual ~RixSGCurves() = default;
};

class RixSGNuPatch : public RixSGGeometry
{
public:
    virtual RixSGError Define(int32_t nu, int32_t uorder, int32_t nv, int32_t vorder) = 0;

protected:
    inline RixSGNuPatch() = default;
    virtual ~RixSGNuPatch() = default;
};

class RixSGProcedural : public RixSGGeometry
{
public:
    virtual RixSGError Define(RtUString subdivfunction, RtUString boundfunction) = 0;

protected:
    inline RixSGProcedural() = default;
    virtual ~RixSGProcedural() = default;
};

class RixSGScene
{
public:
    virtual RixSGMaterial* CreateMaterial(RtUString identifier) = 0;

    virtual RixSGError DeleteMaterial(RixSGMaterial* material) = 0;

    virtual RixSGGroup* CreateGroup(RtUString identifier) = 0;

    virtual RixSGCamera* CreateCamera(RtUString identifier) = 0;

    virtual RixSGClippingPlane* CreateClippingPlane(RtUString identifier) = 0;

    virtual RixSGAnalyticLight* CreateAnalyticLight(RtUString identifier) = 0;

    virtual RixSGGeometry* CreateGeometry(RtUString identifier) = 0;

    virtual RixSGQuadric* CreateQuadric(RtUString identifier) = 0;

    virtual RixSGMesh* CreateMesh(RtUString identifier) = 0;

    virtual RixSGPoints* CreatePoints(RtUString identifier) = 0;

    virtual RixSGVolume* CreateVolume(RtUString identifier) = 0;

    virtual RixSGBlobby* CreateBlobby(RtUString identifier) = 0;

    virtual RixSGCurves* CreateCurves(RtUString identifier) = 0;

    virtual RixSGNuPatch* CreateNuPatch(RtUString identifier) = 0;

    virtual RixSGProcedural* CreateProcedural(RtUString identifier) = 0;

    virtual RixSGError DeleteDagNode(RixSGGroup* node) = 0;

    virtual RixSGGroup* FindDagNode(char const* path) const = 0;


    virtual RixSGError Render(char const* cmd) = 0;

    virtual RixSGError Stop() = 0;

    struct ScopedEdit
    {
        ScopedEdit(RixSGScene* scene);
        ~ScopedEdit();
        RixSGScene* const sg;
    };

    virtual void EditBegin() = 0;

    virtual void EditEnd() = 0;

    virtual RixSGError Clear() = 0;

    virtual RixSGGroup* Root() const = 0;

    virtual RixSGError SetIntegrator(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetSampleFilter(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetDisplayFilter(unsigned num, RixSGShader const* nodes) = 0;

    virtual RixSGError SetDisplayChannel(unsigned num, RixSGDisplayChannel const* nodes) = 0;

    virtual RtParamList const& GetOptions() const = 0;

    virtual RixSGError SetOptions(RtParamList const& options) = 0;

    virtual RixSGError SetUpdateIdCallback(RixSGUpdateIdCallback callback, void* ctx) = 0;

protected:
    RixSGScene() = default;
    virtual ~RixSGScene() = default;
};

class RixSGManager : public RixInterface
{
public:
    virtual RixSGScene* CreateScene(RtUString orientation = US_NULL, char sep = '|') = 0;

    virtual RixSGError DeleteScene(RixSGScene* scene) = 0;

protected:
    RixSGManager() : RixInterface(2)
    {}
    virtual ~RixSGManager() = default;
};

/* inlined */

inline RixSGDisplayChannel::RixSGDisplayChannel() : type(RtDataType::k_float), handle(US_NULL)
{}

inline RixSGDisplayChannel::RixSGDisplayChannel(RtDataType t, RtUString h) : type(t), handle(h)
{}

inline RixSGShader::RixSGShader() : type(RixSGShaderType::k_Invalid), name(US_NULL), handle(US_NULL)
{}

inline RixSGShader::RixSGShader(RixSGShaderType t, RtUString n, RtUString h)
    : type(t), name(n), handle(h)
{}

inline RixSGError RixSGGroup::SetTransform(RtMatrix4x4 const& xform)
{
    return SetTransform(1, &xform, nullptr);
}

inline RixSGError RixSGGroup::SetIdentity()
{
    return SetTransformNumSamples(0);
}

inline RixSGScene::ScopedEdit::ScopedEdit(RixSGScene* scene) : sg(scene)
{
    sg->EditBegin();
}

inline RixSGScene::ScopedEdit::~ScopedEdit()
{
    sg->EditEnd();
}

#endif  // RixSceneGraph_h