Riley.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 0.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 Riley_h
#define Riley_h

#include "RiTypesHelper.h"  // RtUString
#include "RixInterfaces.h"
#include "RtParamList.h"

// Id for acquiring Riley from RixContext::GetRixInterface
#define k_RixRileyManager RixInterfaceId(-1)

namespace riley
{
enum class CameraId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class GeometryInstanceId : uint32_t
{
    k_InvalidId = 0,
};

enum class GeometryMasterId : uint32_t
{
    k_InvalidId = 0,
};

enum class MaterialId : uint32_t
{
    k_DefaultId = 0,
    k_InvalidId = UINT32_MAX,
};

enum class DisplacementId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class IntegratorId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class LightInstanceId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class LightMasterId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class LightShaderId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class LightFilterId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class CoordinateSystemId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class CameraResult
{
    k_Error,
    k_Success
};

enum class CoordinateSystemResult
{
    k_Error,
    k_Success
};

enum class DisplacementResult
{
    k_Error,
    k_Success,
    k_ResendPrimVars
};

enum class IntegratorResult
{
    k_Error,
    k_Success
};

enum class LightShaderResult
{
    k_Error,
    k_Success,
    k_ResendPrimVars
};

enum class MaterialResult
{
    k_Error,
    k_Success,
    k_ResendPrimVars
};

enum class GeometryMasterResult
{
    k_Error,
    k_Success,
    k_ResendPrimVars
};

enum class GeometryInstanceResult
{
    k_Error,
    k_Success,
    k_ResendPrimVars
};

enum class LightInstanceResult
{
    k_Error,
    k_Success,
    k_ResendPrimVars
};

// New Render Target API

enum class RenderOutputResult
{
    k_Success,
    k_Error,
    k_ErrorRenderTargetAttached,
    k_ErrorDisplayAttached
};

enum class RenderOutputType : uint8_t
{
    k_Float,    // 32-bit single precision floating point number
    k_Integer,  // 32-bit one's complement integer
    k_Color,    // 3-k_Float
    k_Vector    // 3-k_Float
};

enum class RenderOutputId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class RenderTargetResult
{
    k_Success,
    k_Error,
    k_ErrorDisplayAttached
};

enum class DisplayResult
{
    k_Success,
    k_Error,
};

enum class RenderTargetId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

enum class DisplayId : uint32_t
{
    k_InvalidId = UINT32_MAX,
};

// TODO: actually I think we only support a single integrator for all render views.
struct RenderView
{
    RenderTargetId renderTargetId;
    IntegratorId integratorId;
    CameraId cameraId;
};

enum class RenderMode
{
    k_Batch,
    k_Interactive
};

struct RenderSettings
{
    RenderMode mode;
};

struct ShadingNode
{
    enum Type
    {
        k_Invalid,
        k_Pattern,
        k_Bxdf,
        k_Integrator,
        k_Light,
        k_LightFilter,
        k_Projection,
        k_Displacement,
        k_SampleFilter,
        k_DisplayFilter
    };

    Type type;
    RtUString name;
    RtUString handle;
    RtParamList params;
};

struct Transform
{
    unsigned samples;
    RtMatrix4x4 const* matrix;
    float const* time;
};

struct ScopedCoordinateSystem
{
    unsigned count;
    CoordinateSystemId const* coordsysIds;
};

class Riley
{
public:
    virtual ~Riley(){};

    virtual void Begin() = 0;

    virtual void End() = 0;

    virtual void Render(uint32_t numRenderViews, RenderView const* renderViews,
                        RenderSettings settings) = 0;

    virtual void RequestUpdate() = 0;

    virtual void Stop() = 0;

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

    virtual RenderOutputId CreateRenderOutput(  //
        RtUString name, RenderOutputType type, RtUString source, RtUString accumulationRule,
        RtUString filter, float const* filterSize, float relativePixelVariance,
        RtParamList const& params) = 0;

    virtual RenderOutputResult ModifyRenderOutput(  //
        RenderOutputId renderOutput, RtUString const* name, RenderOutputType const* type,
        RtUString const* source, RtUString const* accumulationRule, RtUString const* filter,
        float const* const* filterSize, float* relativePixelVariance,
        RtParamList const* params) = 0;

    virtual RenderOutputResult DeleteRenderOutput(RenderOutputId renderOutput) = 0;

    virtual RenderTargetId CreateRenderTarget(  //
        uint32_t numRenderOutputs, RenderOutputId const* renderOutputs, uint32_t const* extent,
        RtUString filterMode, float pixelVariance, RtParamList const& params) = 0;

    virtual RenderTargetResult ModifyRenderTarget(  //
        RenderTargetId renderTarget, uint32_t const* numRenderOutputs,
        RenderOutputId const* const* renderOutputs, uint32_t const* const* extent,
        RtUString const* filterMode, float const* pixelVariance, RtParamList const* params) = 0;

    virtual RenderTargetResult DeleteRenderTarget(RenderTargetId renderTargetId) = 0;

    virtual DisplayId CreateDisplay(RenderTargetId renderTarget, RtUString name, RtUString driver,
                                    uint32_t numRenderOutputs, RenderOutputId const* renderOutputs,
                                    RtParamList const& driverParams) = 0;

    virtual DisplayResult DeleteDisplay(DisplayId displayId) = 0;

    virtual void CreateDisplayFilterChain(riley::ShadingNode const* nodes, int nNodes) = 0;

    virtual void CreateSampleFilterChain(riley::ShadingNode const* nodes, int nNodes) = 0;

    virtual CameraId CreateCamera(RtUString name, ShadingNode const& projection,
                                  Transform const& xform, RtParamList const& properties) = 0;

    virtual CameraResult ModifyCamera(CameraId cameraId, ShadingNode const* projection,
                                      Transform const* xform, RtParamList const* properties) = 0;

    virtual void DeleteCamera(CameraId cameraId) = 0;

    virtual void SetClippingPlanes(uint32_t numClippingPlanes, Transform const* xforms,
                                   float (*params)[6]) = 0;

    virtual void SetActiveCamera(CameraId cameraId) = 0;

    virtual IntegratorId CreateIntegrator(ShadingNode const& integratorNode) = 0;

    virtual IntegratorResult ModifyIntegrator(IntegratorId integratorId,
                                              ShadingNode const* integratorNode) = 0;

    virtual IntegratorResult DeleteIntegrator(IntegratorId integratorId) = 0;

    virtual CoordinateSystemId CreateCoordinateSystem(Transform const& xform,
                                                      RtParamList const& attributes) = 0;

    virtual CoordinateSystemResult ModifyCoordinateSystem(CoordinateSystemId coordsysId,
                                                          Transform const* xform,
                                                          RtParamList const* attributes) = 0;

    virtual void DeleteCoordinateSystem(CoordinateSystemId coordsysId) = 0;

    virtual DisplacementId CreateDisplacement(ShadingNode const* shadingNodes,
                                              int nShadingNodes) = 0;

    virtual DisplacementResult ModifyDisplacement(DisplacementId displacementId,
                                                  ShadingNode const* shadingNodes,
                                                  int nShadingNodes) = 0;

    virtual void DeleteDisplacement(DisplacementId displacementId) = 0;

    virtual LightShaderId CreateLightShader(ShadingNode const* lightNodes, int nLightNodes,
                                            ShadingNode const* filterNodes, int nFilterNodes) = 0;

    virtual LightShaderResult ModifyLightShader(LightShaderId lightShaderId,
                                                ShadingNode const* lightNodes, int nLightNodes,
                                                ShadingNode const* filterNodes,
                                                int nFilterNodes) = 0;

    virtual void DeleteLightShader(LightShaderId lightShaderId) = 0;

    virtual MaterialId CreateMaterial(ShadingNode const* shadingNodes, int nShadingNodes) = 0;

    virtual MaterialResult ModifyMaterial(MaterialId materialId, ShadingNode const* shadingNodes,
                                          int nShadingNodes) = 0;

    virtual void DeleteMaterial(MaterialId materialId) = 0;

    virtual GeometryMasterId CreateGeometryMaster(RtUString type, DisplacementId displacementId,
                                                  RtParamList const& primvars) = 0;

    typedef bool (*CreateGeometryMasterCB)(void* fnData, RtParamList& primvars);

    virtual GeometryMasterId CreateGeometryMasterDeferred(RtUString type,
                                                          DisplacementId displacementId,
                                                          RtParamList const& primvars,
                                                          CreateGeometryMasterCB fn,
                                                          void* fnData) = 0;

    virtual GeometryMasterResult ModifyGeometryMaster(RtUString type, GeometryMasterId geoMasterId,
                                                      DisplacementId const* displacementId,
                                                      RtParamList const* primvars) = 0;

    virtual void DeleteGeometryMaster(GeometryMasterId geoMasterId) = 0;

    virtual GeometryInstanceId CreateGeometryInstance(GeometryMasterId groupMasterId,
                                                      GeometryMasterId geoMasterId,
                                                      MaterialId materialId,
                                                      ScopedCoordinateSystem const& coordsys,
                                                      Transform const& xform,
                                                      RtParamList const& attributes) = 0;

    virtual GeometryInstanceResult ModifyGeometryInstance(GeometryMasterId groupMasterId,
                                                          GeometryInstanceId instanceId,
                                                          MaterialId const* materialId,
                                                          ScopedCoordinateSystem const* coordsys,
                                                          Transform const* xform,
                                                          RtParamList const* attributes) = 0;

    virtual void DeleteGeometryInstance(GeometryMasterId groupMasterId,
                                        GeometryInstanceId instanceId) = 0;

    virtual LightInstanceId CreateLightInstance(GeometryMasterId groupMasterId,
                                                GeometryMasterId geoMasterId, MaterialId materialId,
                                                LightShaderId lightShaderId,
                                                ScopedCoordinateSystem const& coordsys,
                                                Transform const& xform,
                                                RtParamList const& attributes) = 0;

    virtual LightInstanceResult ModifyLightInstance(GeometryMasterId groupMasterId,
                                                    LightInstanceId lightInstanceId,
                                                    MaterialId const* materialId,
                                                    LightShaderId const* lightShaderId,
                                                    ScopedCoordinateSystem const* coordsys,
                                                    Transform const* xform,
                                                    RtParamList const* attributes) = 0;

    virtual void DeleteLightInstance(GeometryMasterId groupMasterId,
                                     LightInstanceId lightInstanceId) = 0;
};

}  // namespace riley

class RixRileyManager : public RixInterface
{
public:
    virtual riley::Riley* CreateRiley(char const* rendervariant) = 0;
    virtual void DestroyRiley(riley::Riley* rl) = 0;

    virtual void GetOptionOverrides(RtParamList& options) const = 0;

protected:
    RixRileyManager() : RixInterface(2)
    {}
};

#endif