RixSceneGraph.h

Go to the documentation of this file.

/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 2020 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 3
 *
 * 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

namespace stats
{
class Session;
}

#define k_RixSGManagerVersion 3
#define RMAN_SCENEGRAPH_NAMESPACE scenegraph
#define RMAN_SCENEGRAPH_NAMESPACE_OPEN_SCOPE \
    namespace RMAN_SCENEGRAPH_NAMESPACE      \
    {
#define RMAN_SCENEGRAPH_NAMESPACE_CLOSE_SCOPE }

RMAN_NAMESPACE_OPEN_SCOPE
RMAN_SCENEGRAPH_NAMESPACE_OPEN_SCOPE

class Camera;
class Curves;
class Geometry;
class Group;
class AnalyticLight;
class Material;
class Mesh;
class NuPatch;
class Points;
class Procedural;
class Quadric;
class Scene;
class Volume;
class Blobby;
struct DisplayChannel;
struct Shader;

typedef uint64_t (*UpdateIdCallback)(void* ctx, Group const* node, RtUString const& path);

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

enum class DagType
{
    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 ShaderType
{
    k_Invalid,        
    k_Pattern,        
    k_Bxdf,           
    k_Integrator,     
    k_Light,          
    k_LightFilter,    
    k_Projection,     
    k_Displacement,   
    k_SampleFilter,   
    k_DisplayFilter,  
    k_Display,        
};

struct DisplayChannel
{
    DisplayChannel();

    DisplayChannel(RtDataType t, RtUString h);

    DisplayChannel(DisplayChannel const&) = default;

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

    RtDataType type;

    RtUString handle;

    RtParamList params;
};

struct Shader
{
    Shader();

    Shader(ShaderType t, RtUString n, RtUString h);

    Shader(Shader const&) = default;

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

    ShaderType type;

    RtUString name;

    RtUString handle;

    RtParamList params;
};

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

    virtual Error SetIdentifier(RtUString identifier) = 0;

    virtual Error SetBxdf(unsigned num, Shader const* nodes) = 0;

    virtual Error SetLight(unsigned num, Shader const* nodes) = 0;

    virtual Error SetLightFilter(unsigned num, Shader const* nodes) = 0;

    virtual Error SetDisplace(unsigned num, Shader const* nodes) = 0;

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

class Group
{
public:
    virtual DagType GetDagType() const = 0;

    virtual RtUString GetIdentifier() const = 0;

    virtual Error SetIdentifier(RtUString identifier) = 0;

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

    virtual Error SetTransformNumSamples(unsigned numsamples) = 0;

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

    Error SetTransform(RtMatrix4x4 const& xform);

    Error SetIdentity();

    virtual unsigned GetTransformNumSamples() const = 0;

    virtual Error GetTransformSample(unsigned sample, RtMatrix4x4& xform, float& time) const = 0;

    virtual Error SetHidden(int state) = 0;

    virtual int GetHidden() const = 0;

    virtual Error AddCoordinateSystem(Group* coordsys) = 0;

    virtual Error RemoveCoordinateSystem(Group* coordsys) = 0;

    virtual Error RemoveAllCoordinateSystems() = 0;

    virtual unsigned GetNumCoordinateSystems() const = 0;

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

    virtual Error AddChild(Group* child) = 0;

    virtual Error RemoveChild(Group* child) = 0;

    virtual Error RemoveAllChildren() = 0;

    virtual unsigned GetNumChildren() const = 0;

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

    virtual unsigned GetNumParents() const = 0;

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

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

    virtual Material* GetMaterial() const = 0;

    virtual Error SetMaterial(Material* material) = 0;

    virtual Error OverrideMaterial(Material* material, unsigned depth, Group** path) = 0;

    virtual RtParamList const& GetAttributes() const = 0;

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

    virtual Error SetNested(bool state) = 0;

    virtual bool GetNested() const = 0;

    virtual Error SetInheritTransform(bool value) = 0;

    virtual bool GetInheritTransform() const = 0;

    Group(Group const&) = delete;
    Group const& operator=(Group const&) = delete;

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

class Camera : public virtual Group
{
public:
    virtual Error SetRenderable(int renderable) = 0;

    virtual Error SetProjection(unsigned num, Shader const* nodes) = 0;

    virtual Error SetDisplay(unsigned num, Shader const* nodes) = 0;

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

    virtual RtParamList const& GetProperties() const = 0;

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

protected:
    inline Camera() = default;
    ~Camera() override = default;
};

class ClippingPlane : public virtual Group
{
public:
    virtual Error SetActive(bool active) = 0;

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

protected:
    inline ClippingPlane() = default;
    ~ClippingPlane() override = default;
};

class AnalyticLight : public virtual Group
{
public:
    virtual Error SetLight(unsigned num, Shader const* nodes) = 0;

    virtual Error SetLightFilter(unsigned num, Shader const* nodes) = 0;

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

    virtual RtParamList const& GetProperties() const = 0;

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

protected:
    inline AnalyticLight() = default;
    ~AnalyticLight() override = default;
};

class Geometry : public virtual Group
{
public:
    virtual RtUString GetGeometry() const = 0;

    virtual Error SetGeometry(RtUString type) = 0;

    virtual RtPrimVarList const& GetPrimVars() const = 0;

    virtual Error SetPrimVars(RtPrimVarList const& primvars) = 0;

protected:
    inline Geometry() = default;
    ~Geometry() override = default;
};

class Quadric : public virtual Geometry
{
public:
    virtual Error SetGeometry(RtUString type) = 0;

protected:
    inline Quadric() = default;
    ~Quadric() override = default;
};

class Mesh : public virtual Geometry
{
public:
    virtual Error Define(int32_t npolys, int32_t npoints, int32_t nverts) = 0;

    virtual Error SetScheme(RtUString scheme) = 0;

protected:
    inline Mesh() = default;
    ~Mesh() override = default;
};

class Points : public virtual Geometry
{
public:
    virtual Error Define(int32_t npoints) = 0;

protected:
    inline Points() = default;
    ~Points() override = default;
};

class Volume : public virtual Geometry
{
public:
    virtual Error Define(int32_t nx, int32_t ny, int32_t nz) = 0;

protected:
    inline Volume() = default;
    ~Volume() override = default;
};

class Blobby : public virtual Geometry
{
public:
    virtual Error Define(int32_t nleaf) = 0;

protected:
    inline Blobby() = default;
    ~Blobby() override = default;
};

class Curves : public virtual Geometry
{
public:
    virtual Error Define(RtUString type, RtUString wrap, RtUString basis, int32_t ncurves,
                         int32_t npoints) = 0;

protected:
    inline Curves() = default;
    ~Curves() override = default;
};

class NuPatch : public virtual Geometry
{
public:
    virtual Error Define(int32_t nu, int32_t uorder, int32_t nv, int32_t vorder) = 0;

protected:
    inline NuPatch() = default;
    ~NuPatch() override = default;
};

class Procedural : public virtual Geometry
{
public:
    virtual Error Define(RtUString subdivfunction, RtUString boundfunction) = 0;

protected:
    inline Procedural() = default;
    ~Procedural() override = default;
};

class Scene
{
public:
    virtual Material* CreateMaterial(RtUString identifier) = 0;

    virtual Error DeleteMaterial(Material* material) = 0;

    virtual Group* CreateGroup(RtUString identifier) = 0;

    virtual Camera* CreateCamera(RtUString identifier) = 0;

    virtual ClippingPlane* CreateClippingPlane(RtUString identifier) = 0;

    virtual AnalyticLight* CreateAnalyticLight(RtUString identifier) = 0;

    virtual Geometry* CreateGeometry(RtUString identifier) = 0;

    virtual Quadric* CreateQuadric(RtUString identifier) = 0;

    virtual Mesh* CreateMesh(RtUString identifier) = 0;

    virtual Points* CreatePoints(RtUString identifier) = 0;

    virtual Volume* CreateVolume(RtUString identifier) = 0;

    virtual Blobby* CreateBlobby(RtUString identifier) = 0;

    virtual Curves* CreateCurves(RtUString identifier) = 0;

    virtual NuPatch* CreateNuPatch(RtUString identifier) = 0;

    virtual Procedural* CreateProcedural(RtUString identifier) = 0;

    virtual Error DeleteDagNode(Group* node) = 0;

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


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

    virtual Error Stop() = 0;

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

    virtual void EditBegin() = 0;

    virtual void EditEnd() = 0;

    virtual Error Clear() = 0;

    virtual Group* Root() const = 0;

    virtual Error SetIntegrator(unsigned num, Shader const* nodes) = 0;

    virtual Error SetSampleFilter(unsigned num, Shader const* nodes) = 0;

    virtual Error SetDisplayFilter(unsigned num, Shader const* nodes) = 0;

    virtual Error SetDisplayChannel(unsigned num, DisplayChannel const* nodes) = 0;

    virtual RtParamList const& GetOptions() const = 0;

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

    virtual Error SetUpdateIdCallback(UpdateIdCallback callback, void* ctx) = 0;

    //
    virtual Error InvalidateTexture(RtUString const name) = 0;

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

/* inlined */

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

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

inline Shader::Shader() : type(ShaderType::k_Invalid), name(US_NULL), handle(US_NULL)
{}

inline Shader::Shader(ShaderType t, RtUString n, RtUString h) : type(t), name(n), handle(h)
{}

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

inline Error Group::SetIdentity()
{
    return SetTransformNumSamples(0);
}

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

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

RMAN_SCENEGRAPH_NAMESPACE_CLOSE_SCOPE

RMAN_NAMESPACE_CLOSE_SCOPE

// Backward compatability
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::AnalyticLight RixSGAnalyticLight;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Blobby RixSGBlobby;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Camera RixSGCamera;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::ClippingPlane RixSGClippingPlane;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Curves RixSGCurves;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::DagType RixSGDagType;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::DisplayChannel RixSGDisplayChannel;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Error RixSGError;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Geometry RixSGGeometry;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Group RixSGGroup;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Material RixSGMaterial;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Mesh RixSGMesh;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::NuPatch RixSGNuPatch;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Points RixSGPoints;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Procedural RixSGProcedural;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Quadric RixSGQuadric;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Scene RixSGScene;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Shader RixSGShader;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::ShaderType RixSGShaderType;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::UpdateIdCallback RixSGUpdateIdCallback;
typedef RMAN_NAMESPACE::RMAN_SCENEGRAPH_NAMESPACE::Volume RixSGVolume;

class RixSGManager : public RixInterface
{
public:
    virtual RixSGScene* CreateScene(RtParamList const& config, RtParamList const& renderConfig, stats::Session& statsSession) = 0;

    virtual RixSGError DeleteScene(RixSGScene* scene) = 0;

protected:
    RixSGManager() : RixInterface(k_RixSGManagerVersion)
    {}
    ~RixSGManager() override = default;
};

#endif  // RixSceneGraph_h