RixProjection.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
#
# ------------------------------------------------------------------------------
*/


#ifndef RixProjection_h
#define RixProjection_h

#include "RixInterfaces.h"              // for RixContext
#include "RixShading.h"                 // for RixParameterList (ptr only), etc
#include "prmanapi.h"                   // for PRMANEXPORT
#include "ri.h"                         // for RtPoint2

class RixProjectionContext;
struct RtRayGeometry;


class RixProjectionEnvironment
{
public:
    RixProjectionEnvironment() : m_version(2) {}

    int m_version;

    int width;
    int height;

    float pixelAspectRatio;

    float clippingNear;
    float clippingFar;

    float screenWindowLeft;
    float screenWindowRight;
    float screenWindowTop;
    float screenWindowBottom;

    float shutterOpen;
    float shutterClose;

    unsigned worldToCameraNumSamples;
    RtMatrix4x4 const* worldToCameraMatrix;
    float const* worldToCameraTimes;

    char _reserved[32];
};

class RixProjection
{
public:

    enum DicingHint
    {
        k_Orthographic,
        k_Perspective,
        k_Spherical
    };

    enum DeepMetric
    {
        k_cameraZ   = 0,
        k_rayLength = 1
    };

    // Projections can be queried at the beginning of rendering for
    // general properties interesting to the renderer. They should
    // return k_RixSCInvalidDetail if a particular property is
    // unsupported.  If a property is supported, k_RixSCUniform or
    // k_RixSCVarying should be returned according to the detail of
    // the result. A trivial implementation that supports no
    // properties of any sort should simply return
    // k_RixSCInvalidDetail.
    enum ProjectionProperty
    {
        // enum DicingHint - see above
        k_DicingHint,

        // enum DeepMetric - see above
        k_DeepMetric,

        // float: field of view of the plugin for perspective and
        // spherical. Used by the renderer as hint on how to dice
        // geometry.
        k_FieldOfView,

        // float: depth of field (defocus) for perspective projections
        k_FStop,
        k_FocalLength,
        k_FocalDistance,
    };

    virtual RixSCDetail GetProperty(
        ProjectionProperty,
        void const** result) const = 0;


    virtual void Project(RixProjectionContext& pCtx) = 0;

    virtual void RenderBegin(RixContext& ctx, RixProjectionEnvironment const& env,
                             RixParameterList const* instanceParams) = 0;

    virtual void RenderEnd(RixContext& rixCtx) {
        PIXAR_ARGUSED(rixCtx);
    }

protected:
    virtual ~RixProjection() {};
};

class RixProjectionFactory : public RixShadingPlugin
{
public:
    virtual int GetInterface() const override { return k_RixProjectionFactory; }

    // Projection plugins do not support InstanceData. As a consequence, the following methods are
    // not expected to be implemented and won't be called by the renderer.
    virtual void CreateInstanceData(RixContext& rixCtx, RtUString const handle,
                                    RixParameterList const* instanceParams,
                                    InstanceData* instanceData) override final
    {
        PIXAR_ARGUSED(rixCtx);
        PIXAR_ARGUSED(handle);
        PIXAR_ARGUSED(instanceParams);
        PIXAR_ARGUSED(instanceData);
    }

    virtual void SynchronizeInstanceData(RixContext& rixCtx, RtUString const handle,
                                         RixParameterList const* instanceParams,
                                         uint32_t const editHints,
                                         InstanceData* instanceData) override final
    {
        PIXAR_ARGUSED(rixCtx);
        PIXAR_ARGUSED(handle);
        PIXAR_ARGUSED(instanceParams);
        PIXAR_ARGUSED(editHints);
        PIXAR_ARGUSED(instanceData);
    }

    virtual RixProjection* CreateProjection(
        RixContext& ctx,
        RtUString const handle,
        RixParameterList const* pList) = 0;

    virtual void DestroyProjection(RixProjection const* projection) = 0;

protected:
    RixProjectionFactory() : RixShadingPlugin(k_RixShadingVersion) {}
    virtual ~RixProjectionFactory() {}
};

#define RIX_PROJECTIONFACTORYCREATE \
    extern "C" PRMANEXPORT RixProjectionFactory* CreateRixProjectionFactory(RtUString const hint)

#define RIX_PROJECTIONFACTORYDESTROY \
    extern "C" PRMANEXPORT void DestroyRixProjectionFactory(RixProjectionFactory* factory)


class RixProjectionContext : public RixContext
{
public:
    int numRays;


    RtPoint2 const* screen;


    RtPoint2 const* lens;
    RtPoint2 const* aperture;


    float* time;


    RtRayGeometry* rays;


    RtColorRGB* tint;


    virtual void TransformOrigins(
        RtUString const fromSpace,
        RtUString const toSpace) = 0;
    virtual void TransformDirections(
        RtUString const fromSpace,
        RtUString const toSpace) = 0;

protected:
    RixProjectionContext() : RixContext() {}
    virtual ~RixProjectionContext() {}
};

#endif