RixBxdf.h

#ifndef RixBxdf_h
#define RixBxdf_h
/* $Revision: #11 $ $Date: 2016/01/04 $
# ------------------------------------------------------------------------------
#
# Copyright (c) 2013-2015 Pixar Animation Studios. All rights reserved.
#
# The information in this file (the "Software") is provided for the
# exclusive use of the software licensees of Pixar.  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 Animation Studios.
#
# 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.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/
#include "RixShading.h"
#include "RixShadingUtils.h"
#include "RixBxdfLobe.h"
#include "RixRNG.h"

enum RixBXEvaluateDomain
{
    // Legend for diagrams
    // V = view , L = light/connect/merge, N = normal, ------ = surface

    k_RixBXEmptyDomain = 0, // black hole (possibly emissive)

    k_RixBXFront = 1,   // two-sided, non-translucent 
                        // V\ N /L
                        //----------
                        // 
                        //   or
                        //    N
                        //----------
                        // V/   \L

    k_RixBXBack = 2,    // translucent, interior integrator
                        // V\ N 
                        //----------
                        //      \L
                        //   or
                        //    N /L
                        //----------
                        // V/

    k_RixBXBoth = 3,    // thin-translucent, two-sided 
                        // V\ N /L
                        //----------
                        // V/   \L

    k_RixBXOutside = 4, // 1-sided, requires Nn/Ngn facing "outside"
                        // V\ N /L
                        //----------
                        // V/
    
    k_RixBXInside = 5,  // 1-sided, requires Nn/Ngn facing "outside"
                        // V\ N
                        //----------
                        // V/   \L

    k_RixBXVolume = 6   // transmits light from all directions
};

enum RixBXTransportTrait
{
    k_RixBXDirectLighting = 1<<0, // (direct lighting samples only)
    k_RixBXIndirectLighting = 1<<1, // (indirect lighting samples only)
    k_RixBXAnyLighting = k_RixBXDirectLighting | k_RixBXIndirectLighting
};

enum RixBXRayFlags
{
    k_RixBXBothEndsInVolume = 0,
    k_RixBXOriginOnBoundary = 1,
    k_RixBXEndOnBoundary = 2,
    k_RixBXBothEndsOnBoundary = 3
};

class RixBsdf;
class RixOpacity;
class RixVolumeIntegrator;
class RixIntegratorContext;
class RixLightingServices;
struct RtRayGeometry;

class RixBxdfFactory : public RixShadingPlugin
{
public:
    virtual int GetInterface() const { return k_RixBxdfFactory; }

    virtual int Init(RixContext &ctx, char const *pluginPath) = 0;
    virtual RixSCParamInfo const *GetParamTable() = 0;
    virtual void Finalize(RixContext &ctx) = 0;

    enum InstanceHints
    {
        k_TriviallyOpaque=0,
        k_ComputesOpacity=1,    
        k_OpacityCanBeCached=2, 
        k_ComputesPresence=4,   
        k_PresenceCanBeCached=8,
        k_OpacityMask=0x0F,
        k_ComputesInterior=0x10,     
        k_InteriorTransmission=0x20, 
        k_InteriorHeterogeneous=0x40,
        k_InteriorOverlapping=0x80,  
        k_InteriorMask=0xF0
    };
    virtual int GetInstanceHints(RtConstPointer /* instancedata */) const
    {
        return k_TriviallyOpaque;
    }

    virtual RixBsdf *BeginScatter(RixShadingContext const *,
                                  RixBXLobeTraits const &hints,
                                  RixSCShadingMode,
                                  RtConstPointer instancedata) = 0;
    virtual void EndScatter(class RixBsdf *bsdf) = 0; 

    virtual RixOpacity *BeginOpacity(RixShadingContext const *, 
                                     RixSCShadingMode,
                                     RtConstPointer /* instancedata */)
                    { return 0; }
    virtual void EndOpacity(class RixOpacity *) {}

    virtual class RixVolumeIntegrator *BeginInterior(RixShadingContext const *, 
                                                    RixSCShadingMode,
                                                    RtConstPointer /* instancedata */)
                    { return 0; }
    virtual void EndInterior(RixVolumeIntegrator *) {}

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

class RixBsdf
{
public:
    RixBsdf(RixShadingContext const *sCtx, RixBxdfFactory *fact) :
        shadingCtx(sCtx), bxdfFactory(fact) {}

    virtual ~RixBsdf() {}

    RixShadingContext const *GetShadingCtx() { return shadingCtx; }
    RixBxdfFactory *GetBxdfFactory() { return bxdfFactory; }

    virtual RixBXEvaluateDomain GetEvaluateDomain() = 0;

    virtual void GetAggregateLobeTraits(RixBXLobeTraits *t) = 0;

    PRMAN_INLINE RixBXLobeTraits GetAllLobeTraits()
    {
        RixBXLobeTraits t;
        this->GetAggregateLobeTraits(&t);
        return t;
    }

    enum BxdfProperty
    {
        k_Albedo,       
        k_MaterialIor   
    };
    virtual RixSCDetail GetProperty(BxdfProperty, void const ** /* result */) const
    {
        return k_RixSCInvalidDetail;
    }

    virtual bool EmitLocal(RtColorRGB* /* result */)
    {
        return false;

        /*

          RtInt nPts = shadingCtx->numPts;
          for (int i = 0; i < nPts; i++)
              result[i] = RtColorRGB(1.0f);

          return true;
        */
    }

    virtual void GenerateSample(RixBXTransportTrait transportTrait,
                                RixBXLobeTraits const *lobesWanted,
                                RixRNG *rng,
                                RixBXLobeSampled *lobesSampled,
                                RtVector3 *sampleDirs,
                                RixBXLobeWeights &weights,
                                RtFloat *forwardPdfs,
                                RtFloat *reversePdfs) = 0;

    virtual void EvaluateSample(RixBXTransportTrait transportTrait,
                                RixBXLobeTraits const *lobesWanted,
                                RixBXLobeTraits *lobesEvaluated,
                                RtVector3 const *sampleDirs,
                                RixBXLobeWeights &weights,
                                RtFloat *forwardPdfs,
                                RtFloat *reversePdfs) = 0;

    virtual void EvaluateSamplesAtIndex(RixBXTransportTrait transportTrait,
                                RixBXLobeTraits const &lobesWanted,
                                RtInt index,
                                RtInt numSamples,
                                RixBXLobeTraits *lobesEvaluated,
                                RtVector3 const *sampleDirs,
                                RixBXLobeWeights &weights,
                                RtFloat *forwardPdfs,
                                RtFloat *reversePdfs) = 0;

    virtual void Release() { if (bxdfFactory) bxdfFactory->EndScatter(this); }

protected:
    RixShadingContext const *shadingCtx;
    RixBxdfFactory *bxdfFactory;
};

class RixOpacity
{
public:
    RixOpacity(RixShadingContext const *sCtx, RixBxdfFactory *fact) :
        shadingCtx(sCtx), bxdfFactory(fact) {}
    virtual ~RixOpacity() {}
    RixBxdfFactory *GetBxdfFactory() { return bxdfFactory; }
    RixShadingContext const *GetShadingCtx() { return shadingCtx; }

    virtual bool GetPresence(RtFloat *result) = 0;

    virtual bool GetOpacity(RtColorRGB *result) = 0;

    virtual void Release() { if (bxdfFactory) bxdfFactory->EndOpacity(this); }

protected:
    RixShadingContext const *shadingCtx;
    RixBxdfFactory *bxdfFactory;
};

class RixVolumeIntegrator
{
public:
    RixVolumeIntegrator(RixShadingContext const *sCtx, RixBxdfFactory *f) :
        shadingCtx(sCtx), bxdfFactory(f), params(NULL) {}
    virtual ~RixVolumeIntegrator() {}
    RixShadingContext const *GetShadingCtx() { return shadingCtx; }
    void SetShadingCtx(const RixShadingContext *ctx) { shadingCtx = ctx; }
    RixBxdfFactory *GetBxdfFactory() { return bxdfFactory; }

    virtual void SetParameters(void const *subclassParams) 
    {
        params = subclassParams;
    }

    class IntegratorDelegate
    {
    public:
        virtual void PerformDirectLighting(RixShadingContext const &,
                                       RixBXLobeTraits const *lobesWanted,
                                       int step) = 0;

    protected:
        virtual ~IntegratorDelegate() {}
    };

    virtual void Release() { if(bxdfFactory) bxdfFactory->EndInterior(this); }

    enum VolumeProperty
    {
        k_DensityType,  
        k_DensityFloat, 
        k_DensityColor, 
        k_MaxDensity,   
    };
    virtual RixSCDetail GetProperty(VolumeProperty, void const ** /* result */) const
    {
        return k_RixSCInvalidDetail;
    }
     
    virtual void GetNearestHits(RtInt numRays, RtRayGeometry const *rays, 
                                RixRNG *rng,
                                RixBXLobeTraits const &lobesWanted, 
                                RixIntegratorContext &iCtx,
                                RixLightingServices *lightingServices,
                                IntegratorDelegate *lcb,
                                RtInt *numGrps, 
                                RixShadingContext const **shadeGrps,
                                char const *subset=NULL,
                                bool isLightPath=false,
                                RtHitSides hitSides=k_SidesBoth,
                                bool isPrimary=false
                                )=0;

    virtual void GetTransmission(RtInt /* numRays */, RtRayGeometry const * /* rays */,
                                 RixRNG * /* rng */,
                                 RixIntegratorContext &iCtx,
                                 RtColorRGB * /* trans */,
                                 char const * /* subset */ =NULL) {}


    virtual void GetNearestHitsAndPdfs(RtInt numRays,
                                RtRayGeometry const *rays, 
                                RixRNG *rng,
                                RixBXLobeTraits const &lobesWanted, 
                                RixIntegratorContext &iCtx,
                                bool /* insideVolume */,
                                bool /* generateLongBeams */,
                                bool * /* scatterRay */,
                                RtInt *numGrps, 
                                RixShadingContext const **shadeGrps,
                                RtFloat * forwardPdf,
                                RtFloat * reversePdf,
                                RtFloat * crossPdf,
                                RtFloat * forwardBoundaryPdf,
                                RtFloat * reverseBoundaryPdf,
                                RtColorRGB * densityCoefficient) {
        GetNearestHits(numRays, rays, rng, lobesWanted, iCtx,
            NULL, NULL, numGrps, shadeGrps, NULL);
        for ( int i = 0; i < numRays; ++i)
        {
            forwardPdf[i] = reversePdf[i] = crossPdf[i] =
            forwardBoundaryPdf[i] = reverseBoundaryPdf[i] =
            densityCoefficient[i].r = densityCoefficient[i].g =
            densityCoefficient[i].b = 1.0f;
        }
    }

    virtual void GetTransmissionAndPdfs(
                                RtInt numRays,
                                RtRayGeometry const *rays,
                                RixRNG *rng,
                                RixIntegratorContext &iCtx,
                                RixBXRayFlags const * /* rayFlags */,
                                RtColorRGB *trans, 
                                RtFloat * forwardPdf, RtFloat * reversePdf,
                                RtFloat * crossPdf,
                                RtColorRGB * /* densityCoefficient */ = NULL) 
    {
        GetTransmission(numRays, rays, rng, iCtx, trans, NULL);
        for ( int i = 0; i < numRays; ++i)
        {
            forwardPdf[i] = reversePdf[i] = crossPdf[i] = 1.0f;
        }
    }

    virtual RixBsdf * CreateBSDF(RixShadingContext const * /* vCtx */,
        RixShadingContext::Allocator & /* pool */)
    {
        return NULL;
    }

    virtual bool IsMultiScatter() const
    {
        return false;
    }
protected:
    RixShadingContext const *shadingCtx;
    RixBxdfFactory *bxdfFactory;
    void const *params;
};

#define RIX_BXDFPLUGINCREATE \
extern "C" PRMANEXPORT RixBxdfFactory *CreateRixBxdfFactory(const char *hint)

#define RIX_BXDFPLUGINDESTROY \
extern "C" PRMANEXPORT void DestroyRixBxdfFactory(RixBxdfFactory *bxdf)

#endif