PxrGeoAovs.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 pxrgeoaovs_h
#define pxrgeoaovs_h

#include "RixIntegrator.h"
#include "RixPredefinedStrings.hpp"
#include "RixBxdf.h"
#include "RixShading.h"
#include "RixShadingUtils.h"

namespace PxrGeoAOV
{
//  NOTE: The order of PxrGeoAovIds and s_aovNames MUST match.
//        Moreover, __Pworld must be listed BEFORE __depth, so we may
//        be able to reuse __Pworld's Y component in __depth.

enum PxrGeoAovIds
{
    k_Pworld = RixShadingContext::k_numBuiltinVars,  // the ones before are defined in
                                                     // RixShadingContext::BuiltinVar
    k_Nworld,
    k_depth,
    k_st,
    k_Pref,
    k_WPref,
    k_Nref,
    k_WNref,
    k_faceindex,
    k_numGeoAovs
};

// The order of all of the built in vars must match the order and content of
// RixShadingContext::BuiltinVar
static const RtUString s_aovNames[k_numGeoAovs] = {RtUString("P"),
                                                   RtUString("PRadius"),
                                                   RtUString("Po"),
                                                   RtUString("Nn"),
                                                   RtUString("Ngn"),
                                                   RtUString("Non"),
                                                   RtUString("Tn"),
                                                   RtUString("Vn"),
                                                   RtUString("VLen"),
                                                   RtUString("curvature"),
                                                   RtUString("incidentRaySpread"),
                                                   RtUString("incidentRayRadius"),
                                                   RtUString("incidentLobeSampled"),
                                                   RtUString("mpSize"),
                                                   RtUString("biasR"),
                                                   RtUString("biasT"),
                                                   RtUString("u"),
                                                   RtUString("v"),
                                                   RtUString("w"),
                                                   RtUString("du"),
                                                   RtUString("dv"),
                                                   RtUString("dw"),
                                                   RtUString("dPdu"),
                                                   RtUString("dPdv"),
                                                   RtUString("dPdw"),
                                                   RtUString("dPdtime"),
                                                   RtUString("time"),
                                                   RtUString("id"),
                                                   RtUString("id2"),
                                                   RtUString("outsideIOR"),
                                                   RtUString("Oi"),
                                                   RtUString("lpeState"),
                                                   RtUString("launchShadingCtxId"),
                                                   RtUString("motionFore"),
                                                   RtUString("motionBack"),
                                                   RtUString("curvature_u"),
                                                   RtUString("curvature_v"),
                                                   RtUString("dPcameradtime"),
                                                   RtUString("wavelength"),
                                                   RtUString("Naon"),
                                                   RtUString("__Pworld"),
                                                   RtUString("__Nworld"),
                                                   RtUString("__depth"),
                                                   RtUString("__st"),
                                                   RtUString("__Pref"),
                                                   RtUString("__WPref"),
                                                   RtUString("__Nref"),
                                                   RtUString("__WNref"),
                                                   RtUString("__faceindex")};

//  Geometric AOV output can be entirely disabled by emitting:
//  Option "user" "int disableIntegratorAOVs" [1]
//
//  If you want your integrator to support this option, you need to explicitely
//  use that function to check its value.
//
inline bool disableIntegratorAOVs(RixContext& ctx, RixChannelId*& aovIdList)
{
    RixRenderState* rstate = (RixRenderState*)ctx.GetRixInterface(k_RixRenderState);
    RtInt count = 0, value = 0;
    RixRenderState::Type type;
    const static RtUString US_USER_DISABLEINTEGRATORAOVS("user:disableIntegratorAOVs");
    RtInt ret = rstate->GetOption(
        US_USER_DISABLEINTEGRATORAOVS, &value, sizeof(RtInt), &type, &count);
    if (ret == 0 && count == 1 && value == 1)
    {
        aovIdList = NULL;
        return true;
    }
    return false;
}

//  This method should be called in RenderBegin as this is a one-time operation.
//  If our AOVs have been requested, their channel ids will be stored in
//  aovIdList. If not, aovIdList will be NULL to signal the fact that there is
//  nothing to output.
//
inline void GetChannelIds(RixIntegratorEnvironment& env, RixChannelId*& aovIdList)
{
    if (!aovIdList)
    {
        aovIdList = new RixChannelId[k_numGeoAovs];
    }

    //  set all channels to un-requested
    for (int i = 0; i < k_numGeoAovs; i++) aovIdList[i] = k_InvalidChannelId;

    //  Get displays
    RtInt numDisplays = env.numDisplays;
    RixDisplayChannel const* displayChannels = env.displays;

    int const entries = sizeof( s_aovNames ) / sizeof( s_aovNames[ 0 ] );
    // If the line immediately following fails to compile, it likely means that
    // the table above is out of sync with RixShadingContext::BuiltinVar.
    // Change the magic number 9 when adding another geoaov
    static_assert(entries == RixShadingContext::k_numBuiltinVars + 9,
                  "s_aovNames out of sync with RixShadingContext::BuiltinVar");
    
    //  parse the channels
    int numRequestedAOVs = 0;
    for (int dc = 0; dc < numDisplays; ++dc)
    {
        for (int n = 0; n < k_numGeoAovs; n++)
        {
            if (displayChannels[dc].channel == s_aovNames[n])
            {
                // store the channel id in the correct aov slot
                aovIdList[n] = displayChannels[dc].id;
                ++numRequestedAOVs;
                break;
            }
        }
    }

    //  no requested AOVs : de-allocate and set to NULL.
    //  This is an early out signal.
    if (!numRequestedAOVs)
    {
        delete[] aovIdList;
        aovIdList = NULL;
    }
}

//  Returns true if we need temp float memory.
//
inline bool NeedTempFloat(RixChannelId* aovIdList)
{
    assert(aovIdList != NULL);
    return (aovIdList[k_Pworld] != k_InvalidChannelId && aovIdList[k_depth] != k_InvalidChannelId);
}

//
inline void Splat(
    RtInt numShadingContexts,
    RixShadingContext const** sctxs,
    RixDisplayServices* dspsvc,
    RtFloat3* aovValue,
    RtFloat* savedFloat,
    RixChannelId* aovIdList,
    RixBXLobeTraits const* lobesWanted = NULL,
    RtUString coordinateSystem = Rix::k_camera)
{
    // we are NEVER expecting aovIdList == NULL
    // as it is our signal to skip this function.
    assert(aovIdList != NULL);
    assert(aovValue != NULL);

    // we get multiple shading contexts : go through them one by one.
    for (int g = 0; g < numShadingContexts; g++)
    {
        RixShadingContext const& sctx = *sctxs[g];

        // no geometry hit : move along
        if (!sctx.HasHits()) continue;

        if (RixIsMatte(sctx) > 0) continue;

        //  Should only write for 'camera hits' during integration.
        //  Camera hits are normally the first hits, or for volumes,
        //  the first scattering event.
        int* rayDepths = new int[sctx.numPts];
        bool write = false;
        if (sctx.GetProperty(k_RayDepth, rayDepths))
        {
            if (rayDepths[0] == 0)
            {
                RixBxdf& bxdf = *(sctx.GetBxdf());
                if (!bxdf.GetAllLobeTraits().GetContinuation())
                {
                    write = true;
                }
            }
        }
        else
        {
            write = true;
        }
        delete[] rayDepths;

        if (!write) continue;

        for (RtInt d = 0; d < k_numGeoAovs; d++)
        {
            if (aovIdList[d] != k_InvalidChannelId)
            {
                if (d < RixShadingContext::k_numBuiltinVars)
                {
                    switch (d)
                    {
                    // Sometimes need to be transformed as Points
                    case RixShadingContext::k_P:
                    case RixShadingContext::k_Po:
                    {
                        RtFloat3 const* p;
                        sctx.GetBuiltinVar((RixShadingContext::BuiltinVar)d, &p);

                        if (coordinateSystem)
                        {
                            // we need to operate on copies
                            memcpy(aovValue, p, sctx.numPts * sizeof(RtFloat3));
                            // transform copy to specified space
                            sctx.Transform(
                                RixShadingContext::k_AsPoints,
                                Rix::k_current,
                                coordinateSystem,
                                aovValue);
                            p = aovValue;
                        }

                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            if (lobesWanted && !lobesWanted[i].GetValid())
                            {
                                // Currently only single scattered volumes would
                                // have a non-NULL lobesWanted sent into this call, where
                                // lobesWanted set to none suggests no scattering event
                                // occurred and we do not want to splat.
                                continue;
                            }
                            dspsvc->Write(
                                aovIdList[d], sctx.integratorCtxIndex[i], (RtColorRGB)p[i]);
                        }
                        break;
                    }

                    // Sometimes need to be transformed as Vectors
                    case RixShadingContext::k_Tn:
                    case RixShadingContext::k_Vn:
                    case RixShadingContext::k_dPdu:
                    case RixShadingContext::k_dPdv:
                    case RixShadingContext::k_dPdw:
                    {
                        RtFloat3 const* p;
                        sctx.GetBuiltinVar((RixShadingContext::BuiltinVar)d, &p);

                        if (coordinateSystem)
                        {
                            // we need to operate on copies
                            memcpy(aovValue, p, sctx.numPts * sizeof(RtFloat3));
                            // transform copy to specified space
                            sctx.Transform(
                                RixShadingContext::k_AsVectors,
                                Rix::k_current,
                                coordinateSystem,
                                aovValue);
                            p = aovValue;
                        }

                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            if (lobesWanted && !lobesWanted[i].GetValid())
                            {
                                // Currently only single scattered volumes would
                                // have a non-NULL lobesWanted sent into this call, where
                                // lobesWanted set to none suggests no scattering event
                                // occurred and we do not want to splat.
                                continue;
                            }
                            dspsvc->Write(
                                aovIdList[d], sctx.integratorCtxIndex[i], (RtColorRGB)p[i]);
                        }
                        break;
                    }

                    case RixShadingContext::k_dPdtime:
                    case RixShadingContext::k_dPcameradtime:
                    {
                        RtFloat3 const* p;
                        sctx.GetBuiltinVar(RixShadingContext::k_dPcameradtime, &p);

                        if (coordinateSystem)
                        {
                            // we need to operate on copies
                            memcpy(aovValue, p, sctx.numPts * sizeof(RtFloat3));
                            // transform copy to specified space
                            sctx.Transform(
                                RixShadingContext::k_AsVectors,
                                Rix::k_current,
                                coordinateSystem,
                                aovValue);
                            p = aovValue;
                        }

                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            if (lobesWanted && !lobesWanted[i].GetValid())
                            {
                                // Currently only single scattered volumes would
                                // have a non-NULL lobesWanted sent into this call, where
                                // lobesWanted set to none suggests no scattering event
                                // occurred and we do not want to splat.
                                continue;
                            }
                            dspsvc->Write(
                                aovIdList[d], sctx.integratorCtxIndex[i], (RtColorRGB)p[i]);
                        }
                        break;
                    }

                    // Sometimes need to be transformed as Normals
                    case RixShadingContext::k_Nn:
                    case RixShadingContext::k_Ngn:
                    case RixShadingContext::k_Non:
                    case RixShadingContext::k_Naon:
                    {
                        RtFloat3 const* p;
                        sctx.GetBuiltinVar((RixShadingContext::BuiltinVar)d, &p);

                        if (coordinateSystem)
                        {
                            // we need to operate on copies
                            memcpy(aovValue, p, sctx.numPts * sizeof(RtFloat3));
                            // transform copy to specified space
                            sctx.Transform(
                                RixShadingContext::k_AsNormals,
                                Rix::k_current,
                                coordinateSystem,
                                aovValue);
                            p = aovValue;
                        }

                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            if (lobesWanted && !lobesWanted[i].GetValid())
                            {
                                // Currently only single scattered volumes would
                                // have a non-NULL lobesWanted sent into this call, where
                                // lobesWanted set to none suggests no scattering event
                                // occurred and we do not want to splat.
                                continue;
                            }
                            dspsvc->Write(
                                aovIdList[d], sctx.integratorCtxIndex[i], (RtColorRGB)p[i]);
                        }
                        break;
                    }

                    // No transforms ever needed
                    case RixShadingContext::k_Oi:
                    case RixShadingContext::k_motionFore:
                    case RixShadingContext::k_motionBack:
                    {
                        RtFloat3 const* p;
                        sctx.GetBuiltinVar((RixShadingContext::BuiltinVar)d, &p);
                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            if (lobesWanted && !lobesWanted[i].GetValid())
                            {
                                // Currently only single scattered volumes would
                                // have a non-NULL lobesWanted sent into this call, where
                                // lobesWanted set to none suggests no scattering event
                                // occurred and we do not want to splat.
                                continue;
                            }
                            dspsvc->Write(
                                aovIdList[d], sctx.integratorCtxIndex[i], (RtColorRGB)p[i]);
                        }
                        break;
                    }

                    case RixShadingContext::k_PRadius:
                    case RixShadingContext::k_VLen:
                    case RixShadingContext::k_curvature:
                    case RixShadingContext::k_incidentRaySpread:
                    case RixShadingContext::k_incidentRayRadius:
                    case RixShadingContext::k_mpSize:
                    case RixShadingContext::k_biasR:
                    case RixShadingContext::k_biasT:
                    case RixShadingContext::k_u:
                    case RixShadingContext::k_v:
                    case RixShadingContext::k_w:
                    case RixShadingContext::k_du:
                    case RixShadingContext::k_dv:
                    case RixShadingContext::k_dw:
                    case RixShadingContext::k_time:
                    case RixShadingContext::k_outsideIOR:
                    case RixShadingContext::k_curvatureU:
                    case RixShadingContext::k_curvatureV:
                    {
                        RtFloat const* p;
                        sctx.GetBuiltinVar((RixShadingContext::BuiltinVar)d, &p);
                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            dspsvc->Write(aovIdList[d], sctx.integratorCtxIndex[i], p[i]);
                        }
                        break;
                    }
                    case RixShadingContext::k_incidentLobeSampled:
                    case RixShadingContext::k_Id:
                    case RixShadingContext::k_Id2:
                    case RixShadingContext::k_launchShadingCtxId:
                    {
                        int numDisplays;
                        RixDisplayChannel const* displays;
                        dspsvc->GetDisplayChannels(&numDisplays, &displays);
                        bool asInt = false;
                        for (int i = 0; i < numDisplays; i++)
                        {
                            if (displays[i].id == aovIdList[d])
                            {
                                asInt = (displays[i].type == RixDisplayChannel::k_IntegerChannel);
                                break;
                            }
                        }
                        RtInt const* p;
                        sctx.GetBuiltinVar((RixShadingContext::BuiltinVar)d, &p);
                        if (asInt)
                            for (int i = 0; i < sctx.numPts; i++)
                                dspsvc->Write(aovIdList[d], sctx.integratorCtxIndex[i], p[i]);
                        else
                            for (int i = 0; i < sctx.numPts; i++)
                                dspsvc->Write(
                                    aovIdList[d],
                                    sctx.integratorCtxIndex[i],
                                    static_cast<float>(p[i]));
                        break;
                    }
                    case RixShadingContext::k_lpeState:
                    {
                        // Undefined to write a pointer to an AOV.
                        assert(true == false);
                        break;
                    }
                    default: break;
                    }
                }
                else
                {
                    switch (d)
                    {
                    case k_Pworld:
                    {
                        // Get P in current space
                        RtFloat3 const* tmpP;
                        sctx.GetBuiltinVar(RixShadingContext::k_P, &tmpP);

                        // we can not transform the original P : we must operate
                        // on a copy.
                        memcpy(aovValue, tmpP, sctx.numPts * sizeof(RtFloat3));

                        // transform copy to world space
                        sctx.Transform(
                            RixShadingContext::k_AsPoints, Rix::k_current, Rix::k_world, aovValue);

                        // if __depth has also been requested, save Y position
                        // in world space
                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            dspsvc->Write(
                                aovIdList[d], sctx.integratorCtxIndex[i], (RtColorRGB)aovValue[i]);
                            if (aovIdList[k_depth] != k_InvalidChannelId)
                                savedFloat[i] = aovValue[i][1];
                        }
                        break;
                    }
                    case k_Nworld:
                    {
                        // Get Nn in current space
                        RtFloat3 const* tmpN;
                        sctx.GetBuiltinVar(RixShadingContext::k_Nn, &tmpN);

                        // we can not transform the original N : we must operate
                        // on a copy.
                        memcpy(aovValue, tmpN, sctx.numPts * sizeof(RtFloat3));

                        sctx.Transform(
                            RixShadingContext::k_AsNormals, Rix::k_current, Rix::k_world, aovValue);

                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            dspsvc->Write(
                                aovIdList[d],
                                sctx.integratorCtxIndex[i],
                                (RtColorRGB)(aovValue[i]));
                        }
                        break;
                    }
                    case k_depth:
                    {
                        int* rayTrueDepths = new int[sctx.numPts];
                        bool haveTrueDepths = sctx.GetProperty(k_RayTrueDepth, rayTrueDepths);
                        RtFloat3 const* tmpP = nullptr;
                        RixIntegratorContext *iCtx = nullptr;
                        if (haveTrueDepths)
                        {
                            sctx.GetBuiltinVar(RixShadingContext::k_P, &tmpP);
                            iCtx = sctx.GetIntegratorContext();                            
                        }
                        // depth from camera
                        RtFloat const* tmpf;
                        sctx.GetBuiltinVar(RixShadingContext::k_VLen, &tmpf);
                        RtFloat3 const* Nn;
                        sctx.GetBuiltinVar(RixShadingContext::k_Nn, &Nn);
                        RtFloat3 const* Vn;
                        sctx.GetBuiltinVar(RixShadingContext::k_Vn, &Vn);

                        // Y position in world space
                        bool PworldNotComputed = (aovIdList[k_Pworld] == k_InvalidChannelId);
                        if (PworldNotComputed)
                        {
                            sctx.GetBuiltinVar(RixShadingContext::k_P, &tmpP);

                            // we can not transform the original P : we must
                            // operate on a copy.
                            memcpy(aovValue, tmpP, sctx.numPts * sizeof(RtFloat3));

                            // transform copy to world space
                            sctx.Transform(
                                RixShadingContext::k_AsPoints,
                                Rix::k_current,
                                Rix::k_world,
                                aovValue);
                        }
                        RtColorRGB depth;
                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            float VLen;
                            // If the true depth of the shading
                            // context is not zero, VLen might not be
                            // the actual desired camera depth, it may
                            // only be the distance to the previous
                            // hit. Here we recompute an actual
                            // distance from the hit point to the
                            // origin of the camera ray.
                            if (haveTrueDepths && rayTrueDepths[i] != 0)
                            {
                                VLen = RtVector3(tmpP[i] - iCtx->primaryRays[sctx.integratorCtxIndex[i]].origin).Length();
                            }
                            else
                            {
                                VLen = tmpf[i];
                            }
                            if (PworldNotComputed)
                            {
                                depth = RtColorRGB(VLen, aovValue[i][1], AbsDot(Nn[i], Vn[i]));
                            }
                            else
                            {
                                depth = RtColorRGB(VLen, savedFloat[i], AbsDot(Nn[i], Vn[i]));
                            }
                            dspsvc->Write(aovIdList[d], sctx.integratorCtxIndex[i], depth);
                        }
                        delete[] rayTrueDepths;
                        break;
                    }
                    case k_st:
                    {
                        RtFloat2 const* st;
                        RtFloat2 defaultST(0.0f, 0.0f);
                        sctx.GetPrimVar(Rix::k_st, defaultST, &st);
                        for (int i = 0; i < sctx.numPts; i++)
                        {
                            dspsvc->Write(
                                aovIdList[d],
                                sctx.integratorCtxIndex[i],
                                RtColorRGB(st[i].x, st[i].y, 0.f));
                        }
                        break;
                    }
                    case k_Pref:
                    case k_WPref:
                    case k_Nref:
                    case k_WNref:
                    {
                        RtFloat3 const* p;
                        RixSCDetail pDetail = sctx.GetPrimVar(s_aovNames[d], RtFloat3(0.0f), &p);
                        if (pDetail == k_RixSCVarying)
                        {
                            // we need to operate on copies
                            memcpy(aovValue, p, sctx.numPts * sizeof(RtFloat3));

                            RixShadingContext::TransformInterpretation interp;
                            if (d == k_Pref || d == k_WPref)
                                interp = RixShadingContext::k_AsPoints;
                            else
                                interp = RixShadingContext::k_AsNormals;

                            sctx.Transform(interp, Rix::k_current, Rix::k_object, aovValue, NULL);
                            p = aovValue;

                            for (int i = 0; i < sctx.numPts; i++)
                            {
                                dspsvc->Write(
                                    aovIdList[d], sctx.integratorCtxIndex[i], (RtColorRGB)p[i]);
                            }
                        }
                        break;
                    }
                    case k_faceindex:
                    {
                        float const* p = nullptr;
                        sctx.GetPrimVar(Rix::k_faceindex, 0.0f, &p);
                        if (p)
                        {
                            int numDisplays;
                            RixDisplayChannel const* displays;
                            dspsvc->GetDisplayChannels(&numDisplays, &displays);
                            bool asInt = false;
                            for (int i = 0; i < numDisplays; i++)
                            {
                                if (displays[i].id == aovIdList[d])
                                {
                                    asInt = (displays[i].type == RixDisplayChannel::k_IntegerChannel);
                                    break;
                                }
                            }
                            for (int i = 0; i < sctx.numPts; i++)
                            {
                                if (asInt)
                                    dspsvc->Write(aovIdList[d], sctx.integratorCtxIndex[i],
                                        static_cast<int>(p[i]));
                                else
                                    dspsvc->Write(aovIdList[d], sctx.integratorCtxIndex[i], p[i]);
                            }
                        }
                        break;
                    }
                    }  // switch
                }      // else
            }          // if requested aov
        }              // iterate over aov list
    }                  // iterate over shading contexts
}

}  // namespace PxrGeoAOV

#endif