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

#ifndef RixLightFilter_h
#define RixLightFilter_h

#include <cstddef>          // for NULL, size_t
#include <new>              // for operator new
#include "RixBxdf.h"        // for RixBXLobeSampled
#include "RixInterfaces.h"  // for RixContext
#include "RixShading.h"     // for RixShadingContext, etc
#include "prmanapi.h"       // for PRMANEXPORT
#include "RiTypesHelper.h"  // for RtVector3, etc.

class RixLPEState;
class RixLightFilterContext;
struct RixBXLobeWeights;

class RixLightFilter : public RixShadingPlugin
{
public:
    int GetInterface() const override
    {
        return k_RixLightFilter;
    }

    virtual void Filter(RixLightFilterContext const* lfCtx, void* instanceData,
                        int const numSamples, int const* shadingCtxIndex,
                        RtVector3 const* directions, float const* distances,
                        float const* lightPdfsDirect, RixBXLobeWeights* contribution) = 0;

    enum FilterRadianceModifierProperty
    {
        k_Multiplier,   
        k_MaxDistance,  
    };

    virtual bool GetRadianceModifier(FilterRadianceModifierProperty property,
                                     RixLightFilterContext const* lfCtx,
                                     void* instanceData, float* result) const = 0;

    // Lights can be queried for general properties.  If a particular property
    // is unsupported, GetProperty() should return k_RixSCInvalidDetail.
    // Otherwise, return k_RixSCUniform or k_RixSCVarying according to the
    // detail of the result.
    enum LightFilterProperty
    {
        // RtUString: The group(s) to which the filter belongs for linking purposes.
        // If empty, the light filter is enabled everywhere.
        k_LinkingGroups,
        // int: if non-zero, the ShadowFilter method will be called
        // by the renderer to determine the light filter's effects on
        // shadows
        k_FiltersShadows,
        k_numLightFilterProperties
    };

    virtual RixSCDetail GetProperty(void* instanceData, LightFilterProperty prop,
                                    void const** result) const = 0;

protected:
    RixLightFilter() : RixShadingPlugin(k_RixShadingVersion)
    {}
    ~RixLightFilter() override
    {}

public:
    virtual void ShadowFilter(RixLightFilterContext const* lfCtx, void* instanceData,
                              int const numSamples, int const* shadingCtxIndex,
                              RtVector3 const* directions, float const* distances,
                              RixBXLobeSampled const* incidentLobeSampled,
                              RtColorRGB* transmissions)
    {
        PIXAR_ARGUSED(lfCtx);
        PIXAR_ARGUSED(instanceData);
        PIXAR_ARGUSED(numSamples);
        PIXAR_ARGUSED(shadingCtxIndex);
        PIXAR_ARGUSED(directions);
        PIXAR_ARGUSED(distances);
        PIXAR_ARGUSED(incidentLobeSampled);
        PIXAR_ARGUSED(transmissions);
    }
};

// clang-format off
#define RIX_LIGHTFILTERPLUGINCREATE \
    extern "C" PRMANEXPORT RixLightFilter* CreateRixLightFilter(const char* hint)

#define RIX_LIGHTFILTERPLUGINDESTROY \
    extern "C" PRMANEXPORT void DestroyRixLightFilter(RixLightFilter* modifier)
// clang-format on

class RixLightFilterContext : public RixContext
{
public:
    int numPts;

    virtual bool IsEnabled(void const* instance, void** instanceData) const = 0;

    virtual void GetBuiltinVar(RixShadingContext::BuiltinVar, int const** var) const = 0;
    virtual void GetBuiltinVar(RixShadingContext::BuiltinVar, float const** var) const = 0;
    virtual void GetBuiltinVar(RixShadingContext::BuiltinVar, RtFloat3 const** var) const = 0;
    virtual void GetBuiltinVar(RixShadingContext::BuiltinVar, RixLPEState* const** var) const = 0;

    virtual RixSCDetail GetPrimVar(RtUString const name, float fill, float const** var,
                                   float const** radius = NULL) const = 0;
    virtual RixSCDetail GetPrimVar(RtUString const name, RtFloat2 fill, RtFloat2 const** var,
                                   float const** radius = NULL) const = 0;
    virtual RixSCDetail GetPrimVar(RtUString const name, RtFloat3 fill, RtFloat3 const** var,
                                   float const** radius = NULL) const = 0;
    virtual RixSCDetail GetPrimVar(RtUString const name, RtUString const** var) const = 0;
    virtual RixSCDetail GetPrimVar(RtUString const name, RtMatrix4x4 const& fill,
                                   RtMatrix4x4 const** var) const = 0;

    virtual int Transform(RixShadingContext::TransformInterpretation interp,
                          RtUString const fromSpace, RtUString const toSpace, RtFloat3* var,
                          float* width = NULL) const = 0;

    // Separate source and destination arrays.
    virtual int Transform(RixShadingContext::TransformInterpretation interp,
                          RtUString const fromSpace, RtUString const toSpace,
                          RtFloat3 const* srcVar, RtFloat3* dstVar, float const* srcWidth,
                          float* dstWidth) const = 0;

    virtual int Transform(RixShadingContext::TransformInterpretation interp,
                          RtUString const fromSpace, RtUString const toSpace, int numPts,
                          int const* shadingCtxIndex, RtFloat3 const* srcVar, RtFloat3* dstVar,
                          float const* srcWidth, float* dstWidth) const = 0;
    //  use "placement new" and not rely on invocation of a destructor.
    virtual void* Allocate(size_t n, size_t size) const = 0;

    template <class T>
    T* New(size_t nObjs) const
    {
        T* mem = static_cast<T*>(Allocate(nObjs, sizeof(T)));
        return new (mem) T[nObjs];
    }

    class Allocator
    {
    public:
        Allocator(RixLightFilterContext const* lfCtx) : m_lfCtx(lfCtx)
        {}
        template <typename T>
        T* Allocate(int num)
        {
            if (num == 0) return NULL;
            return (T*)m_lfCtx->Allocate(num, sizeof(T));
        }

    private:
        RixLightFilterContext const* m_lfCtx;
    };

protected:
    ~RixLightFilterContext() override
    {}

public:
    virtual RixShadingContext* CreateMutableContext(RixLightFilter const* filter,
                                                    void* instanceData) const = 0;

    virtual void EndMutableContext(RixShadingContext* ctx) const = 0;

    virtual RixLight* GetCurrentLight() const = 0;
};

#endif