RixBxdfLobe.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 RixBxdfLobe_h
#define RixBxdfLobe_h

#include <algorithm>                    // for min
#include <cassert>                      // for assert
#include <cstring>                      // for memset, NULL
#include "RixInterfaces.h"              // for RixLPEInfo, RixContext, etc
#include "RixShadingUtils.h"            // for RixFindFirstSetBit
#include "prmanapi.h"                   // for PRMAN_INLINE
#include "RiTypesHelper.h"              // for RtColorRGB

static const unsigned char k_RixBXMaxNumDiffuseLobes  = 4;

static const unsigned char k_RixBXMaxNumSpecularLobes = 8;

static const unsigned char k_RixBXMaxNumUserLobes     = 8;

static const unsigned char k_RixBXSubsurfaceLobeId1   = 9;
static const unsigned char k_RixBXSubsurfaceLobeId2   = 10;
static const unsigned char k_RixBXSubsurfaceLobeId3   = 11;

struct RixBXLobeSampled
{
    PRMAN_INLINE RixBXLobeSampled();

    PRMAN_INLINE RixBXLobeSampled(unsigned short serialized);

    PRMAN_INLINE RixBXLobeSampled(
        bool discrete,
        bool specular,
        bool reflect,
        bool user,
        unsigned char lpeId,
        unsigned char lobeId);

    // CompareLobeID: returns true if rhs is the same as this lobeId.
    PRMAN_INLINE bool CompareLobeID(RixBXLobeSampled const& rhs) const
    {
        return (fields.bits.valid && rhs.fields.bits.valid &&
                fields.bits.specular == rhs.fields.bits.specular &&
                fields.bits.user == rhs.fields.bits.user &&
                fields.bits.lobeId == rhs.fields.bits.lobeId);
    }

    // Read-only accessors; these all verify that the valid bit is set before
    // returning true.
    PRMAN_INLINE bool GetValid() const;
    PRMAN_INLINE bool GetDiscrete() const;
    PRMAN_INLINE bool GetSolidAngle() const;
    PRMAN_INLINE bool GetDiffuse() const;
    PRMAN_INLINE bool GetSpecular() const;
    PRMAN_INLINE bool GetReflect() const;
    PRMAN_INLINE bool GetTransmit(bool* entering = NULL) const;
    PRMAN_INLINE bool GetEntering() const; // only valid for Transmit
    PRMAN_INLINE bool GetContinuation() const;
    PRMAN_INLINE bool GetScattering() const;
    PRMAN_INLINE bool GetUser() const;
    PRMAN_INLINE unsigned char GetLpeId() const;
    PRMAN_INLINE unsigned char GetLobeId() const;
    PRMAN_INLINE bool LobeIdIsSubsurface() const;
    PRMAN_INLINE bool GetThinShadowFlag() const;
    PRMAN_INLINE unsigned char GetUnused() const;

    // Set individual fields (only SetValid() changes the valid bit).
    PRMAN_INLINE void SetValid(bool val);
    PRMAN_INLINE void SetDiscrete(bool val);
    PRMAN_INLINE void SetSpecular(bool val);
    PRMAN_INLINE void SetReflect();
    PRMAN_INLINE void SetTransmit(bool entering);
    PRMAN_INLINE void SetEntering(bool entering); // valid only for Transmit
    PRMAN_INLINE void SetContinuation(bool val);
    PRMAN_INLINE void SetUser(bool val);
    PRMAN_INLINE void SetLpeId(unsigned char val);
    PRMAN_INLINE void SetLobeId(unsigned char val);
    PRMAN_INLINE void SetThinShadowFlag(bool val);
    PRMAN_INLINE void SetUnused(unsigned char val);

    PRMAN_INLINE void Set(
        bool vDiscrete,
        bool vSpecular,
        bool vReflect,
        bool vContinuation,
        bool vUser,
        unsigned char vLpeId,
        unsigned char vLobeId,
        bool vThinShadowFlag = false);

    // Convert to a serialized integral representation.
    PRMAN_INLINE unsigned short Serialize() const;

    struct Bitfield
    {
        unsigned short valid    : 1; 
        unsigned short discrete : 1; 
        unsigned short specular : 1; 
        unsigned short reflect  : 1; 
        unsigned short entering : 1; 
        unsigned short continuation : 1; 
        unsigned short user     : 1;     
        unsigned short lpeId    : 3;     
        unsigned short lobeId   : 4; 
        unsigned short thinShadow : 1;
        unsigned short unused   : 1; 
    };

    union Converter
    {
        Bitfield bits;
        unsigned short us;
    };

private:
    Converter fields;
};

PRMAN_INLINE RixBXLobeSampled RixBXLookupLobeByName(
    RixContext& ctx,
    bool discrete,
    bool specular,
    bool reflect,
    bool user,
    unsigned char lobeId, // nb: ignored
    char const* name);

struct RixBXLobeTraits
{
    PRMAN_INLINE RixBXLobeTraits();

    PRMAN_INLINE RixBXLobeTraits(unsigned serialized);

    PRMAN_INLINE RixBXLobeTraits(
        bool discrete,
        bool solidAngle,
        bool reflect,
        bool transmit,
        unsigned short D,
        unsigned short S,
        unsigned short U);

    PRMAN_INLINE explicit RixBXLobeTraits(RixBXLobeSampled lobe);

    // Read-only accessors; return individual fields.
    PRMAN_INLINE bool GetDiscrete() const;
    PRMAN_INLINE bool GetSolidAngle() const;
    PRMAN_INLINE bool GetReflect() const;
    PRMAN_INLINE bool GetTransmit() const;
    PRMAN_INLINE bool GetContinuation() const;
    PRMAN_INLINE unsigned short GetDiffuse() const;
    PRMAN_INLINE unsigned short GetSpecular() const;
    PRMAN_INLINE unsigned short GetUser() const;
    PRMAN_INLINE bool GetValid() const;

    PRMAN_INLINE bool GetMaxSpecularDepth() const;
    PRMAN_INLINE bool GetMaxDiffuseDepth() const;

    // Set individual fields.
    PRMAN_INLINE void SetValid(bool val);
    PRMAN_INLINE void SetDiscrete(bool val);
    PRMAN_INLINE void SetSolidAngle(bool val);
    PRMAN_INLINE void SetReflect(bool val);
    PRMAN_INLINE void SetTransmit(bool val);
    PRMAN_INLINE void SetContinuation(bool val);
    PRMAN_INLINE void SetMaxSpecularDepth(bool val);
    PRMAN_INLINE void SetMaxDiffuseDepth(bool val);
    PRMAN_INLINE void SetDiffuse(unsigned short bits);
    PRMAN_INLINE void SetSpecular(unsigned short bits);
    PRMAN_INLINE void SetUser(unsigned short bits);

    PRMAN_INLINE void SetNone();

    PRMAN_INLINE void SetAll();

    PRMAN_INLINE bool HasAny() const;

    PRMAN_INLINE bool HasAnyDiffSpec() const;

    PRMAN_INLINE bool HasAnyDiffuse() const;

    PRMAN_INLINE bool HasAnySpecular() const;

    PRMAN_INLINE bool HasAnyUser() const;

    // Convert to a serialized integral representation.
    PRMAN_INLINE unsigned Serialize() const;

    PRMAN_INLINE RixBXLobeTraits const& operator&=(RixBXLobeTraits const& rhs);

    PRMAN_INLINE RixBXLobeTraits const& operator|=(RixBXLobeTraits const& rhs);

    struct Bitfield
    {
        unsigned valid              : 1;         
        unsigned discreteSubset     : 1;         
        unsigned solidAngleSubset   : 1;         
        unsigned reflectSubset      : 1;         
        unsigned transmitSubset     : 1;         
        unsigned continuationSubset : 1;         
        unsigned D : k_RixBXMaxNumDiffuseLobes;  
        unsigned S : k_RixBXMaxNumSpecularLobes; 
        unsigned U : k_RixBXMaxNumUserLobes;     

        unsigned maxspeculardepth   : 1;
        unsigned maxdiffusedepth    : 1;
    };

    union Converter
    {
        Bitfield bits;
        unsigned us;
    };

private:
    Converter fields;
};

PRMAN_INLINE RixBXLobeTraits operator&(
    RixBXLobeTraits const& lhs,
    RixBXLobeTraits const& rhs);

PRMAN_INLINE RixBXLobeTraits operator|(
    RixBXLobeTraits const& lhs,
    RixBXLobeTraits const& rhs);

// clang-format off
static const RixBXLobeTraits k_RixBXTraitsNullLobe(
    false, false, false, false, 0x0, 0x0, 0x0);
static const RixBXLobeTraits k_RixBXTraitsReflectDiffuse(
    false, true, true, false, 0xF, 0x0, 0x0);
static const RixBXLobeTraits k_RixBXTraitsReflectSpecular(
    false, true, true, false, 0x0, 0xFF, 0x0);
static const RixBXLobeTraits k_RixBXTraitsTransmitDiffuse(
    false, true, false, true, 0xF, 0x0, 0x0);
static const RixBXLobeTraits k_RixBXTraitsTransmitSpecular(
    false, true, false, true, 0x0, 0xFF, 0x0);
static const RixBXLobeTraits k_RixBXTraitsAllDiffuse(
    false, true, true, true, 0xF, 0x0, 0x0);
static const RixBXLobeTraits k_RixBXTraitsAllSpecular(
    false, true, true, true, 0x0, 0xFF, 0x0);
static const RixBXLobeTraits k_RixBXTraitsAllUser(
    false, false, false, false, 0x0, 0x0, 0xFF);
static const RixBXLobeTraits k_RixBXTraitsAllReflect(
    false, true, true, false, 0x0F, 0xFF, 0x0);
static const RixBXLobeTraits k_RixBXTraitsAllTransmit(
    false, true, false, true, 0x0F, 0xFF, 0x0);
static const RixBXLobeTraits k_RixBXTraitsAllLobe(
    false, true, true, true, 0x0F, 0xFF, 0xFF);
// clang-format on

struct RixBXActiveLobeWeights
{
    PRMAN_INLINE RixBXActiveLobeWeights();

    PRMAN_INLINE RixBXActiveLobeWeights(
        RixBXLobeTraits lobeTraits,
        int numDiffuseLobes,
        int numSpecularLobes,
        int numUserLobes,
        RtColorRGB* diffuseLobes[],
        RtColorRGB* specularLobes[],
        RtColorRGB* userLobes[],
        unsigned char diffuseLpeIds[],
        unsigned char specularLpeIds[],
        unsigned char userLpeIds[],
        int offset = 0);

    PRMAN_INLINE RixBXActiveLobeWeights(RixBXActiveLobeWeights const& that);

    PRMAN_INLINE RixBXActiveLobeWeights& operator=(
        RixBXActiveLobeWeights const& that);

    // Get the pointer to the array of weights for a diffuse or specular lobe.
    PRMAN_INLINE RtColorRGB const* GetDiffuseLobe(int i) const;
    PRMAN_INLINE RtColorRGB const* GetSpecularLobe(int i) const;
    PRMAN_INLINE RtColorRGB const* GetUserLobe(int i) const;
    PRMAN_INLINE RtColorRGB* GetDiffuseLobe(int i);
    PRMAN_INLINE RtColorRGB* GetSpecularLobe(int i);
    PRMAN_INLINE RtColorRGB* GetUserLobe(int i);

    // Clears all diffuse or specular lobes from active lobes list
    PRMAN_INLINE void ClearAllDiffuseLobes();
    PRMAN_INLINE void ClearAllSpecularLobes();
    PRMAN_INLINE void ClearAllUserLobes();

    // Get or set the current offset into array of weights.
    PRMAN_INLINE int GetOffset() const;
    PRMAN_INLINE void SetOffset(int offset);

    // Get or set the lobe traits.
    PRMAN_INLINE RixBXLobeTraits GetLobeTraits() const;
    PRMAN_INLINE void SetLobeTraits(RixBXLobeTraits lobes);

    // Get the number of diffuse or specular lobes.
    PRMAN_INLINE unsigned char GetNumDiffuseLobes() const;
    PRMAN_INLINE unsigned char GetNumSpecularLobes() const;
    PRMAN_INLINE unsigned char GetNumUserLobes() const;

    // Get the original LPE id of a diffuse or specular lobe.
    PRMAN_INLINE unsigned char GetDiffuseLpeId(int i) const;
    PRMAN_INLINE unsigned char GetSpecularLpeId(int i) const;
    PRMAN_INLINE unsigned char GetUserLpeId(int i) const;

    // Return the sum at a particular index in the array of lobe weights.
    PRMAN_INLINE RtColorRGB SumAtIndex(
        int index,
        bool includeUserLobes = false) const;

    // Multiply by a value at a particular index in the array of lobe weights.
    PRMAN_INLINE void MultiplyByWeightAtIndex(
        int index,
        float weight,
        bool includeUserLobes = false);
    PRMAN_INLINE void MultiplyByWeightAtIndex(
        int index,
        RtColorRGB const& weight,
        bool includeUserLobes = false);

    // Sets to zero at a particular index in the array of lobe weights.
    PRMAN_INLINE void ZeroAtIndex(int index, bool includeUserLobes = false);

private:
    friend struct RixBXLobeWeights;

    // Ptrs to diffuse and specular weights
    RtColorRGB* m_diffuseLobes[k_RixBXMaxNumDiffuseLobes];
    RtColorRGB* m_specularLobes[k_RixBXMaxNumSpecularLobes];
    RtColorRGB* m_userLobes[k_RixBXMaxNumUserLobes];

    int m_offset;                     // Offset into arrays
    RixBXLobeTraits m_lobeTraits;     // Active lobe traits
    unsigned char m_numDiffuseLobes;  // Diff lobe count
    unsigned char m_numSpecularLobes; // Spec lobe count
    unsigned char m_numUserLobes;     // User lobe count

    // Diffuse and specular LPE ids.
    unsigned char m_diffuseLpeIds[k_RixBXMaxNumDiffuseLobes];
    unsigned char m_specularLpeIds[k_RixBXMaxNumSpecularLobes];
    unsigned char m_userLpeIds[k_RixBXMaxNumUserLobes];
};

// RixBXLobeWeights distributes weights into qualitative properties.
struct RixBXLobeWeights
{
    PRMAN_INLINE RixBXLobeWeights();

    PRMAN_INLINE RixBXLobeWeights(
        int numPoints,
        int numDiffuseLobes,
        int numSpecularLobes,
        int numUserLobes,
        RtColorRGB* diffuseLobes[],
        RtColorRGB* specularLobes[],
        RtColorRGB* userLobes[],
        int offset = 0);

    PRMAN_INLINE RixBXLobeWeights(RixBXLobeWeights const& that);

    PRMAN_INLINE RixBXLobeWeights& operator=(RixBXLobeWeights const& that);

    // Get the pointer to the array of weights for a diffuse or specular lobe.
    PRMAN_INLINE RtColorRGB const* GetDiffuseLobe(int i) const;
    PRMAN_INLINE RtColorRGB const* GetSpecularLobe(int i) const;
    PRMAN_INLINE RtColorRGB const* GetUserLobe(int i) const;
    PRMAN_INLINE RtColorRGB* GetDiffuseLobe(int i);
    PRMAN_INLINE RtColorRGB* GetSpecularLobe(int i);
    PRMAN_INLINE RtColorRGB* GetUserLobe(int i);

    // Get or set the current number of points in the arrays of weights.
    PRMAN_INLINE int GetNumPoints() const;
    PRMAN_INLINE void SetNumPoints(int numPoints);

    // Get or set the current offset into array of weights.
    PRMAN_INLINE int GetOffset() const;
    PRMAN_INLINE void SetOffset(int offset);

    // Get, set or add to the active lobe traits.
    PRMAN_INLINE RixBXLobeTraits GetActiveLobeTraits() const;
    PRMAN_INLINE void SetActiveLobeTraits(RixBXLobeTraits lobes);
    PRMAN_INLINE void AddActiveLobeTraits(RixBXLobeTraits lobes);

    // Get the number of diffuse or specular lobes.
    PRMAN_INLINE int GetNumDiffuseLobes() const;
    PRMAN_INLINE int GetNumSpecularLobes() const;
    PRMAN_INLINE int GetNumUserLobes() const;

    PRMAN_INLINE RtColorRGB* AddActiveLobe(
        RixBXLobeSampled lobe,
        bool doInitializeWeights = true);

    PRMAN_INLINE void GetActiveLobes(RixBXActiveLobeWeights& r) const;

    PRMAN_INLINE void GetActiveLobesIntersection(
        RixBXLobeWeights const& rhs,
        RixBXActiveLobeWeights& activeLhs,
        RixBXActiveLobeWeights& activeRhs) const;

    // Copy over just the active lobe weights in 'src' at the given index into
    // the lobe weights. Any lobes that are not present in 'src' will not be
    // updated in this instance.
    PRMAN_INLINE void CopyWeightAtIndex(
        int index,
        RixBXActiveLobeWeights const& src,
        bool includeUserLobes = false);

    // Add in just the active lobe weights in 'src' at the given index into
    // the lobe weights. Any lobes that are not present in 'src' will not be
    // updated in this instance.
    PRMAN_INLINE void AddWeightAtIndex(
        int index,
        RixBXActiveLobeWeights const& src,
        bool includeUserLobes = false);

private:
    // Ptrs to diffuse and specular weights
    RtColorRGB* m_diffuseLobes[k_RixBXMaxNumDiffuseLobes];
    RtColorRGB* m_specularLobes[k_RixBXMaxNumSpecularLobes];
    RtColorRGB* m_userLobes[k_RixBXMaxNumUserLobes];

    int m_numPoints;                    // Size of each array
    int m_offset;                       // Offset into arrays
    RixBXLobeTraits m_activeLobeTraits; // Active lobe traits
    unsigned char m_numDiffuseLobes;    // Diff lobe count
    unsigned char m_numSpecularLobes;   // Spec lobe count
    unsigned char m_numUserLobes;       // User lobe count
};


PRMAN_INLINE int RixBXChoose(float const xi, int const numThresholds,
                             float const* thresholds);

PRMAN_INLINE bool RixBXChooseLobe(float const xi,
                                  RixBXActiveLobeWeights& lw,
                                  RixBXLobeSampled &chosenLobe);

PRMAN_INLINE void RixBXChooseLobe(int const npoints, float const* xi,
                                  RixBXLobeWeights& lw,
                                  RixBXLobeSampled* lobeSampled);

PRMAN_INLINE void RixBXChooseLobe(float const xi, RixBXActiveLobeWeights& lw,
                                  RixBXLobeTraits &traits);

//
// --- inline implementations of classes and functions above ---
//

//
// class RixBXLobeSampled inline implementation
//

PRMAN_INLINE
RixBXLobeSampled::RixBXLobeSampled()
{
    /* Init all fields to zero. We write one instruction that has the
     * same effect as performing the following assignments:

     fields.bits.valid = 0;
     fields.bits.discrete = 0;
     fields.bits.specular = 0;
     fields.bits.reflect = 0;
     fields.bits.entering = 0;
     fields.bits.continuation = 0;
     fields.bits.user = 0;
     fields.bits.lpeId = 0;
     fields.bits.lobeId = 0;
     fields.bits.thinShadow = 0;
     fields.bits.unused = 0;
    */

    fields.us = 0;
}

PRMAN_INLINE
RixBXLobeSampled::RixBXLobeSampled(unsigned short serialized)
{
    fields.us = serialized;
}

PRMAN_INLINE
RixBXLobeSampled::RixBXLobeSampled(
    bool vDiscrete,
    bool vSpecular,
    bool vReflect,
    bool vUser,
    unsigned char vLpeId,
    unsigned char vLobeId)
{
    fields.bits.valid        = 1;
    fields.bits.discrete     = vDiscrete;
    fields.bits.specular     = vSpecular;
    fields.bits.reflect      = vReflect;
    fields.bits.entering     = 0;
    fields.bits.continuation = 0;
    fields.bits.user         = vUser;
    fields.bits.lpeId        = vLpeId & 0x7;
    fields.bits.lobeId       = vLobeId & 0xF;
    fields.bits.thinShadow   = 0;
    fields.bits.unused       = 0;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetValid() const
{
    return fields.bits.valid;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetDiscrete() const
{
    return fields.bits.valid && fields.bits.discrete;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetSolidAngle() const
{
    return fields.bits.valid && !fields.bits.discrete;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetDiffuse() const
{
    return fields.bits.valid && !fields.bits.specular;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetSpecular() const
{
    return fields.bits.valid && fields.bits.specular;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetReflect() const
{
    return fields.bits.valid && fields.bits.reflect;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetTransmit(bool* vEntering) const
{
    bool transmit = fields.bits.valid && !fields.bits.reflect;
    if (vEntering)
        *vEntering = fields.bits.entering && transmit;
    return transmit;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetEntering() const
{
    return fields.bits.valid && !fields.bits.reflect && fields.bits.entering;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetContinuation() const
{
    return fields.bits.valid && fields.bits.continuation;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetScattering() const
{
    return fields.bits.valid && !fields.bits.continuation;
}

PRMAN_INLINE bool
RixBXLobeSampled::GetUser() const
{
    return fields.bits.valid && fields.bits.user;
}

PRMAN_INLINE unsigned char
RixBXLobeSampled::GetLpeId() const
{
    return (unsigned char)(fields.bits.valid ? fields.bits.lpeId : 0);
}

PRMAN_INLINE unsigned char
RixBXLobeSampled::GetLobeId() const
{
    return (unsigned char)(fields.bits.valid ? fields.bits.lobeId : 0);
}

PRMAN_INLINE bool
RixBXLobeSampled::LobeIdIsSubsurface() const
{
    if (!fields.bits.valid)
        return false;
    else
        return (fields.bits.lobeId == k_RixBXSubsurfaceLobeId1 ||
                fields.bits.lobeId == k_RixBXSubsurfaceLobeId2 ||
                fields.bits.lobeId == k_RixBXSubsurfaceLobeId3);
}

PRMAN_INLINE bool
RixBXLobeSampled::GetThinShadowFlag() const
{
    return fields.bits.valid && fields.bits.thinShadow;
}

PRMAN_INLINE unsigned char
RixBXLobeSampled::GetUnused() const
{
    return (unsigned char)(fields.bits.valid ? fields.bits.unused : 0);
}

PRMAN_INLINE void
RixBXLobeSampled::SetValid(bool val)
{
    fields.bits.valid = val;
}

PRMAN_INLINE void
RixBXLobeSampled::SetDiscrete(bool val)
{
    fields.bits.discrete = val;
}

PRMAN_INLINE void
RixBXLobeSampled::SetSpecular(bool val)
{
    fields.bits.specular = val;
}

PRMAN_INLINE void
RixBXLobeSampled::SetReflect()
{
    fields.bits.reflect = 1;
}

PRMAN_INLINE void
RixBXLobeSampled::SetTransmit(bool val)
{
    fields.bits.reflect  = 0;
    fields.bits.entering = val;
}

PRMAN_INLINE void
RixBXLobeSampled::SetEntering(bool val)
{
    // valid only for Transmit
    assert(fields.bits.reflect == 0);
    fields.bits.entering = val;
}

PRMAN_INLINE void
RixBXLobeSampled::SetContinuation(bool val)
{
    fields.bits.continuation = val;
}

PRMAN_INLINE void
RixBXLobeSampled::SetUser(bool val)
{
    fields.bits.user = val;
}

PRMAN_INLINE void
RixBXLobeSampled::SetLpeId(unsigned char val)
{
    fields.bits.lpeId = val & 0x7;
}

PRMAN_INLINE void
RixBXLobeSampled::SetLobeId(unsigned char val)
{
    fields.bits.lobeId = val & 0xF;
}

PRMAN_INLINE void
RixBXLobeSampled::SetThinShadowFlag(bool val)
{
    fields.bits.thinShadow = val;
}

PRMAN_INLINE void
RixBXLobeSampled::SetUnused(unsigned char val)
{
    fields.bits.unused = val & 0x1;
}

PRMAN_INLINE void
RixBXLobeSampled::Set(
    bool vDiscrete,
    bool vSpecular,
    bool vReflect,
    bool vContinuation,
    bool vUser,
    unsigned char vLpeId,
    unsigned char vLobeId,
    bool vThinShadowFlag)
{
    fields.bits.valid        = 1;
    fields.bits.discrete     = vDiscrete;
    fields.bits.specular     = vSpecular;
    fields.bits.reflect      = vReflect;
    fields.bits.continuation = vContinuation;
    fields.bits.entering     = 0;
    fields.bits.user         = vUser;
    fields.bits.lpeId        = vLpeId & 0x7;
    fields.bits.lobeId       = vLobeId & 0xF;
    fields.bits.thinShadow   = vThinShadowFlag;
    fields.bits.unused       = 0;
}

PRMAN_INLINE unsigned short
RixBXLobeSampled::Serialize() const
{
    return fields.us;
}

//
// RixBXLookupLobeByName() inline implementation
//

PRMAN_INLINE RixBXLobeSampled
RixBXLookupLobeByName(
    RixContext& ctx,
    bool discrete,
    bool specular,
    bool reflect,
    bool user,
    unsigned char lobeId,
    char const* name)
{
    unsigned char lpeId = 0;
    if (RixLPEInfo* lpeInfo = (RixLPEInfo*)ctx.GetRixInterface(k_RixLPEInfo))
    {
        lpeId = (unsigned char)lpeInfo->GetLpeIdByName(
            discrete, specular, reflect, user, lobeId, name);
    }
    return RixBXLobeSampled(discrete, specular, reflect, user, lpeId, lobeId);
}

//
// class RixBXLobeTraits inline implementation.
//

PRMAN_INLINE
RixBXLobeTraits::RixBXLobeTraits()
{
    // starts with a valid but clean lobe traits
    SetNone();
    fields.bits.valid = 1;
}

PRMAN_INLINE
RixBXLobeTraits::RixBXLobeTraits(unsigned serialized)
{
    // initializes from serialization as unsigned short
    fields.us = serialized;
}

PRMAN_INLINE
RixBXLobeTraits::RixBXLobeTraits(
    bool discrete,
    bool solidAngle,
    bool reflect,
    bool transmit,
    unsigned short D,
    unsigned short S,
    unsigned short U)
{
    assert(sizeof(fields.bits) == sizeof(unsigned));
    fields.bits.discreteSubset     = discrete;
    fields.bits.solidAngleSubset   = solidAngle;
    fields.bits.reflectSubset      = reflect;
    fields.bits.transmitSubset     = transmit;
    fields.bits.continuationSubset = 0;
    fields.bits.D                  = D & 0x0F;
    fields.bits.S                  = S & 0xFF;
    fields.bits.U                  = U & 0xFF;
    fields.bits.maxspeculardepth   = 0;
    fields.bits.maxdiffusedepth    = 0;
    fields.bits.valid              = 1; // samples are valid until explicitly set to invalid (by bxdf)
}

PRMAN_INLINE
RixBXLobeTraits::RixBXLobeTraits(RixBXLobeSampled lobe)
{
    if (lobe.GetValid())
    {
        if (lobe.GetUser())
        {
            fields.bits.discreteSubset     = 0;
            fields.bits.solidAngleSubset   = 0;
            fields.bits.reflectSubset      = 0;
            fields.bits.transmitSubset     = 0;
            fields.bits.continuationSubset = 0;

            fields.bits.D = 0;
            fields.bits.S = 0;
            if (lobe.GetLpeId() < k_RixBXMaxNumUserLobes)
                fields.bits.U = (1 << lobe.GetLpeId()) & 0xFF;
            else
                fields.bits.U = 0;
        }
        else
        {
            fields.bits.discreteSubset     = lobe.GetDiscrete();
            fields.bits.solidAngleSubset   = lobe.GetSolidAngle();
            fields.bits.reflectSubset      = lobe.GetReflect();
            fields.bits.transmitSubset     = lobe.GetTransmit();
            fields.bits.continuationSubset = lobe.GetContinuation();

            if (lobe.GetDiffuse() && lobe.GetLpeId() < k_RixBXMaxNumDiffuseLobes)
                fields.bits.D = (1 << lobe.GetLpeId()) & 0x0F;
            else
                fields.bits.D = 0;
            if (lobe.GetSpecular() && lobe.GetLpeId() < k_RixBXMaxNumSpecularLobes)
                fields.bits.S = (1 << lobe.GetLpeId()) & 0xFF;
            else
                fields.bits.S = 0;
            fields.bits.U     = 0;
        }
        SetValid(true);
    }
    else
    {
        SetNone();
        SetValid(false); // an invalid sample
    }
    fields.bits.maxspeculardepth = 0;
    fields.bits.maxdiffusedepth  = 0;
}

PRMAN_INLINE bool
RixBXLobeTraits::GetValid() const
{
    return fields.bits.valid;
}

PRMAN_INLINE bool
RixBXLobeTraits::GetDiscrete() const
{
    return fields.bits.discreteSubset;
}

PRMAN_INLINE bool
RixBXLobeTraits::GetSolidAngle() const
{
    return fields.bits.solidAngleSubset;
}

PRMAN_INLINE bool
RixBXLobeTraits::GetReflect() const
{
    return fields.bits.reflectSubset;
}

PRMAN_INLINE bool
RixBXLobeTraits::GetTransmit() const
{
    return fields.bits.transmitSubset;
}

PRMAN_INLINE bool
RixBXLobeTraits::GetContinuation() const
{
    return fields.bits.continuationSubset;
}

PRMAN_INLINE unsigned short
RixBXLobeTraits::GetDiffuse() const
{
    return static_cast<unsigned short>(fields.bits.D);
}

PRMAN_INLINE unsigned short
RixBXLobeTraits::GetSpecular() const
{
    return static_cast<unsigned short>(fields.bits.S);
}

PRMAN_INLINE unsigned short
RixBXLobeTraits::GetUser() const
{
    return static_cast<unsigned short>(fields.bits.U);
}

PRMAN_INLINE bool
RixBXLobeTraits::GetMaxSpecularDepth() const
{
    return fields.bits.maxspeculardepth;
}

PRMAN_INLINE bool
RixBXLobeTraits::GetMaxDiffuseDepth() const
{
    return fields.bits.maxdiffusedepth;
}

PRMAN_INLINE void
RixBXLobeTraits::SetValid(bool val)
{
    fields.bits.valid = val;
}

PRMAN_INLINE void
RixBXLobeTraits::SetDiscrete(bool val)
{
    fields.bits.discreteSubset = val;
}

PRMAN_INLINE void
RixBXLobeTraits::SetSolidAngle(bool val)
{
    fields.bits.solidAngleSubset = val;
}

PRMAN_INLINE void
RixBXLobeTraits::SetReflect(bool val)
{
    fields.bits.reflectSubset = val;
}

PRMAN_INLINE void
RixBXLobeTraits::SetTransmit(bool val)
{
    fields.bits.transmitSubset = val;
}

PRMAN_INLINE void
RixBXLobeTraits::SetContinuation(bool val)
{
    fields.bits.continuationSubset = val;
}

PRMAN_INLINE void
RixBXLobeTraits::SetDiffuse(unsigned short val)
{
    fields.bits.D = static_cast<unsigned>(val & 0x0F);
}

PRMAN_INLINE void
RixBXLobeTraits::SetSpecular(unsigned short val)
{
    fields.bits.S = static_cast<unsigned>(val & 0xFF);
}

PRMAN_INLINE void
RixBXLobeTraits::SetUser(unsigned short val)
{
    fields.bits.U = static_cast<unsigned>(val & 0xFF);
}

PRMAN_INLINE void
RixBXLobeTraits::SetMaxSpecularDepth(bool val)
{
    fields.bits.maxspeculardepth = val;
}

PRMAN_INLINE void
RixBXLobeTraits::SetMaxDiffuseDepth(bool val)
{
    fields.bits.maxdiffusedepth = val;
}

PRMAN_INLINE void
RixBXLobeTraits::SetNone()
{
    /* Init all fields to zero. We write one instruction that has the
     * same effect as performing the following assignments:

     fields.bits.discreteSubset = 0;
     fields.bits.solidAngleSubset = 0;
     fields.bits.reflectSubset = 0;
     fields.bits.transmitSubset = 0;
     fields.bits.continuationSubset = 0;
     fields.bits.D = 0;
     fields.bits.S = 0;
     fields.bits.U = 0;
     fields.bits.maxspeculardepth = 0;
     fields.bits.maxdiffusedepth = 0;
    */

    fields.us = 0;
}

PRMAN_INLINE void
RixBXLobeTraits::SetAll()
{
    fields.bits.valid              = 1;
    fields.bits.discreteSubset     = 0;
    fields.bits.solidAngleSubset   = 1;
    fields.bits.reflectSubset      = 1;
    fields.bits.transmitSubset     = 1;
    fields.bits.continuationSubset = 0;
    fields.bits.maxspeculardepth   = 0;
    fields.bits.maxdiffusedepth    = 0;
    fields.bits.D                  = 0x0F;
    fields.bits.S                  = 0xFF;
    fields.bits.U                  = 0xFF;
}

PRMAN_INLINE bool
RixBXLobeTraits::HasAny() const
{
    return HasAnyDiffSpec() || HasAnyUser();
}

PRMAN_INLINE bool
RixBXLobeTraits::HasAnyDiffSpec() const
{
    return (fields.bits.D | fields.bits.S) &&
           (fields.bits.reflectSubset | fields.bits.transmitSubset |
               fields.bits.continuationSubset);
}

PRMAN_INLINE bool
RixBXLobeTraits::HasAnyDiffuse() const
{
    return (fields.bits.D != 0) &&
           (fields.bits.reflectSubset || fields.bits.transmitSubset);
}

PRMAN_INLINE bool
RixBXLobeTraits::HasAnySpecular() const
{
    return (fields.bits.S != 0) &&
           (fields.bits.reflectSubset || fields.bits.transmitSubset);
}

PRMAN_INLINE bool
RixBXLobeTraits::HasAnyUser() const
{
    return (fields.bits.U != 0);
}

PRMAN_INLINE unsigned
RixBXLobeTraits::Serialize() const
{
    return fields.us;
}

PRMAN_INLINE RixBXLobeTraits const& 
RixBXLobeTraits::operator&=(RixBXLobeTraits const& rhs)
{
    /* Bitwise AND all fields. We write one instruction that has the
     * same effect as performing the following assignments:

     fields.bits.discreteSubset &= rhs.fields.bits.discreteSubset;
     fields.bits.solidAngleSubset &= rhs.fields.bits.solidAngleSubset;
     fields.bits.reflectSubset &= rhs.fields.bits.reflectSubset;
     fields.bits.transmitSubset &= rhs.fields.bits.transmitSubset;
     fields.bits.continuationSubset &= rhs.fields.bits.continuationSubset;
     fields.bits.D &= rhs.fields.bits.D;
     fields.bits.S &= rhs.fields.bits.S;
     fields.bits.U &= rhs.fields.bits.U;
     fields.bits.maxspeculardepth &= rhs.fields.bits.maxspeculardepth;
     fields.bits.maxdiffusedepth  &= rhs.fields.bits.maxdiffusedepth;
    */

    fields.us &= rhs.fields.us;

    return *this;
}

PRMAN_INLINE RixBXLobeTraits const& 
RixBXLobeTraits::operator|=(RixBXLobeTraits const& rhs)
{
    /* Bitwise OR all fields. We write one instruction that has the
     * same effect as performing the following assignments:

     fields.bits.discreteSubset |= rhs.fields.bits.discreteSubset;
     fields.bits.solidAngleSubset |= rhs.fields.bits.solidAngleSubset;
     fields.bits.reflectSubset |= rhs.fields.bits.reflectSubset;
     fields.bits.transmitSubset |= rhs.fields.bits.transmitSubset;
     fields.bits.continuationSubset |= rhs.fields.bits.continuationSubset;
     fields.bits.D |= rhs.fields.bits.D;
     fields.bits.S |= rhs.fields.bits.S;
     fields.bits.U |= rhs.fields.bits.U;
     fields.bits.maxspeculardepth |= rhs.fields.bits.maxspeculardepth;
     fields.bits.maxdiffusedepth  |= rhs.fields.bits.maxdiffusedepth;
    */

    fields.us |= rhs.fields.us;

    return *this;
}

PRMAN_INLINE RixBXLobeTraits 
operator&(RixBXLobeTraits const& lhs, RixBXLobeTraits const& rhs)
{
    /* Bitwise AND all fields. We write one instruction that has the
     * same effect as performing the following assignments:

       r.fields.bits.discreteSubset =
           lhs.fields.bits.discreteSubset & rhs.fields.bits.discreteSubset;
       r.fields.bits.solidAngleSubset =
           lhs.fields.bits.solidAngleSubset & rhs.fields.bits.solidAngleSubset;
       r.fields.bits.reflectSubset =
           lhs.fields.bits.reflectSubset & rhs.fields.bits.reflectSubset;
       r.fields.bits.transmitSubset =
           lhs.fields.bits.transmitSubset & rhs.fields.bits.transmitSubset;
       r.fields.bits.continuationSubset =
           lhs.fields.bits.continuationSubset &
           rhs.fields.bits.continuationSubset;
       r.fields.bits.D = lhs.fields.bits.D & rhs.fields.bits.D;
       r.fields.bits.S = lhs.fields.bits.S & rhs.fields.bits.S;
       r.fields.bits.U = lhs.fields.bits.U & rhs.fields.bits.U;
    */

    RixBXLobeTraits r(lhs.Serialize() & rhs.Serialize());
    return r;
}

PRMAN_INLINE RixBXLobeTraits 
operator|(RixBXLobeTraits const& lhs, RixBXLobeTraits const& rhs)
{
    /* Bitwise OR all fields. We write one instruction that has the
     * same effect as performing the following assignments:

       r.fields.bits.discreteSubset =
           lhs.fields.bits.discreteSubset | rhs.fields.bits.discreteSubset;
       r.fields.bits.solidAngleSubset =
           lhs.fields.bits.solidAngleSubset | rhs.fields.bits.solidAngleSubset;
       r.fields.bits.reflectSubset =
           lhs.fields.bits.reflectSubset | rhs.fields.bits.reflectSubset;
       r.fields.bits.transmitSubset =
           lhs.fields.bits.transmitSubset | rhs.fields.bits.transmitSubset;
       r.fields.bits.continuationSubset =
           lhs.fields.bits.continuationSubset |
           rhs.fields.bits.continuationSubset;
       r.fields.bits.D = lhs.fields.bits.D | rhs.fields.bits.D;
       r.fields.bits.S = lhs.fields.bits.S | rhs.fields.bits.S;
       r.fields.bits.U = lhs.fields.bits.U | rhs.fields.bits.U;
    */

    RixBXLobeTraits r(lhs.Serialize() | rhs.Serialize());
    return r;
}

//
// class RixBXActiveLobeWeights implementation
//

PRMAN_INLINE
RixBXActiveLobeWeights::RixBXActiveLobeWeights()
    : m_offset(0),
      m_numDiffuseLobes(0),
      m_numSpecularLobes(0),
      m_numUserLobes(0)
{
}

PRMAN_INLINE
RixBXActiveLobeWeights::RixBXActiveLobeWeights(
    RixBXLobeTraits lobeTraits,
    int numDiffuseLobes,
    int numSpecularLobes,
    int numUserLobes,
    RtColorRGB* diffuseLobes[],
    RtColorRGB* specularLobes[],
    RtColorRGB* userLobes[],
    unsigned char diffuseLpeIds[],
    unsigned char specularLpeIds[],
    unsigned char userLpeIds[],
    int offset)
    : m_offset(offset),
      m_lobeTraits(lobeTraits),
      m_numDiffuseLobes((unsigned char)numDiffuseLobes),
      m_numSpecularLobes((unsigned char)numSpecularLobes),
      m_numUserLobes((unsigned char)numUserLobes)
{
    for (int i = 0; i < numDiffuseLobes; i++)
    {
        m_diffuseLobes[i]  = diffuseLobes[i];
        m_diffuseLpeIds[i] = diffuseLpeIds[i];
    }

    for (int i = 0; i < numSpecularLobes; i++)
    {
        m_specularLobes[i]  = specularLobes[i];
        m_specularLpeIds[i] = specularLpeIds[i];
    }

    for (int i = 0; i < numUserLobes; i++)
    {
        m_userLobes[i]  = userLobes[i];
        m_userLpeIds[i] = userLpeIds[i];
    }
}

PRMAN_INLINE
RixBXActiveLobeWeights::RixBXActiveLobeWeights(
    RixBXActiveLobeWeights const& that)
    : m_offset(that.m_offset),
      m_lobeTraits(that.m_lobeTraits),
      m_numDiffuseLobes(that.m_numDiffuseLobes),
      m_numSpecularLobes(that.m_numSpecularLobes),
      m_numUserLobes(that.m_numUserLobes)
{
    for (int i = 0; i < m_numDiffuseLobes; i++)
    {
        m_diffuseLobes[i]  = that.m_diffuseLobes[i];
        m_diffuseLpeIds[i] = that.m_diffuseLpeIds[i];
    }
    for (int i = 0; i < m_numSpecularLobes; i++)
    {
        m_specularLobes[i]  = that.m_specularLobes[i];
        m_specularLpeIds[i] = that.m_specularLpeIds[i];
    }
    for (int i = 0; i < m_numUserLobes; i++)
    {
        m_userLobes[i]  = that.m_userLobes[i];
        m_userLpeIds[i] = that.m_userLpeIds[i];
    }
}

PRMAN_INLINE RixBXActiveLobeWeights& 
RixBXActiveLobeWeights::operator=(RixBXActiveLobeWeights const& that)
{
    m_offset           = that.m_offset;
    m_lobeTraits       = that.m_lobeTraits;
    m_numDiffuseLobes  = that.m_numDiffuseLobes;
    m_numSpecularLobes = that.m_numSpecularLobes;
    m_numUserLobes     = that.m_numUserLobes;

    for (int i = 0; i < m_numDiffuseLobes; i++)
    {
        m_diffuseLobes[i]  = that.m_diffuseLobes[i];
        m_diffuseLpeIds[i] = that.m_diffuseLpeIds[i];
    }
    for (int i = 0; i < m_numSpecularLobes; i++)
    {
        m_specularLobes[i]  = that.m_specularLobes[i];
        m_specularLpeIds[i] = that.m_specularLpeIds[i];
    }
    for (int i = 0; i < m_numUserLobes; i++)
    {
        m_userLobes[i]  = that.m_userLobes[i];
        m_userLpeIds[i] = that.m_userLpeIds[i];
    }

    return *this;
}

PRMAN_INLINE int
RixBXActiveLobeWeights::GetOffset() const
{
    return m_offset;
}

PRMAN_INLINE void
RixBXActiveLobeWeights::SetOffset(int offset)
{
    m_offset = offset;
}

PRMAN_INLINE RixBXLobeTraits
RixBXActiveLobeWeights::GetLobeTraits() const
{
    return m_lobeTraits;
}

PRMAN_INLINE void
RixBXActiveLobeWeights::SetLobeTraits(RixBXLobeTraits lobes)
{
    m_lobeTraits = lobes;
}

PRMAN_INLINE unsigned char
RixBXActiveLobeWeights::GetNumDiffuseLobes() const
{
    return m_numDiffuseLobes;
}

PRMAN_INLINE unsigned char
RixBXActiveLobeWeights::GetNumSpecularLobes() const
{
    return m_numSpecularLobes;
}

PRMAN_INLINE unsigned char
RixBXActiveLobeWeights::GetNumUserLobes() const
{
    return m_numUserLobes;
}

PRMAN_INLINE RtColorRGB const*
RixBXActiveLobeWeights::GetDiffuseLobe(int i) const
{
    return m_diffuseLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB const*
RixBXActiveLobeWeights::GetSpecularLobe(int i) const
{
    return m_specularLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB const*
RixBXActiveLobeWeights::GetUserLobe(int i) const
{
    return m_userLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB*
RixBXActiveLobeWeights::GetDiffuseLobe(int i)
{
    return m_diffuseLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB*
RixBXActiveLobeWeights::GetSpecularLobe(int i)
{
    return m_specularLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB*
RixBXActiveLobeWeights::GetUserLobe(int i)
{
    return m_userLobes[i] + m_offset;
}

PRMAN_INLINE unsigned char
RixBXActiveLobeWeights::GetDiffuseLpeId(int i) const
{
    return m_diffuseLpeIds[i];
}

PRMAN_INLINE unsigned char
RixBXActiveLobeWeights::GetSpecularLpeId(int i) const
{
    return m_specularLpeIds[i];
}

PRMAN_INLINE unsigned char
RixBXActiveLobeWeights::GetUserLpeId(int i) const
{
    return m_userLpeIds[i];
}

PRMAN_INLINE void
RixBXActiveLobeWeights::ClearAllDiffuseLobes()
{
    m_numDiffuseLobes = 0;
    // Removes all diffuse lobes from traits
    m_lobeTraits &= (k_RixBXTraitsAllSpecular | k_RixBXTraitsAllUser);
}

PRMAN_INLINE void
RixBXActiveLobeWeights::ClearAllSpecularLobes()
{
    m_numSpecularLobes = 0;
    // Removes all specular lobes from traits
    m_lobeTraits &= (k_RixBXTraitsAllDiffuse | k_RixBXTraitsAllUser);
}

PRMAN_INLINE void
RixBXActiveLobeWeights::ClearAllUserLobes()
{
    m_numUserLobes = 0;
    // Removes all user lobes from traits
    m_lobeTraits &= (k_RixBXTraitsAllDiffuse | k_RixBXTraitsAllSpecular);
}

PRMAN_INLINE RtColorRGB
RixBXActiveLobeWeights::SumAtIndex(int index, bool includeUserLobes) const
{
    RtColorRGB sum(0.0f);

    int idx = m_offset + index;
    for (int i = 0; i < m_numDiffuseLobes; i++)
        sum += m_diffuseLobes[i][idx];
    for (int i = 0; i < m_numSpecularLobes; i++)
        sum += m_specularLobes[i][idx];

    if (includeUserLobes)
    {
        for (int i = 0; i < m_numUserLobes; i++)
            sum += m_userLobes[i][idx];
    }

    return sum;
}

PRMAN_INLINE void
RixBXActiveLobeWeights::MultiplyByWeightAtIndex(
    int index,
    float weight,
    bool includeUserLobes)
{
    int idx = m_offset + index;
    for (int i = 0; i < m_numDiffuseLobes; i++)
        m_diffuseLobes[i][idx] *= weight;
    for (int i = 0; i < m_numSpecularLobes; i++)
        m_specularLobes[i][idx] *= weight;

    if (includeUserLobes)
    {
        for (int i = 0; i < m_numUserLobes; i++)
            m_userLobes[i][idx] *= weight;
    }
}

PRMAN_INLINE void
RixBXActiveLobeWeights::MultiplyByWeightAtIndex(
    int index,
    RtColorRGB const& weight,
    bool includeUserLobes)
{
    int idx = m_offset + index;
    for (int i = 0; i < m_numDiffuseLobes; i++)
        m_diffuseLobes[i][idx] *= weight;
    for (int i = 0; i < m_numSpecularLobes; i++)
        m_specularLobes[i][idx] *= weight;

    if (includeUserLobes)
    {
        for (int i = 0; i < m_numUserLobes; i++)
            m_userLobes[i][idx] *= weight;
    }
}

PRMAN_INLINE void
RixBXActiveLobeWeights::ZeroAtIndex(int index, bool includeUserLobes)
{
    int idx = m_offset + index;
    for (int i = 0; i < m_numDiffuseLobes; i++)
        m_diffuseLobes[i][idx].Zero();
    for (int i = 0; i < m_numSpecularLobes; i++)
        m_specularLobes[i][idx].Zero();

    if (includeUserLobes)
    {
        for (int i = 0; i < m_numUserLobes; i++)
            m_userLobes[i][idx].Zero();
    }
}

//
// struct RixBXLobeWeights implementation
//

PRMAN_INLINE
RixBXLobeWeights::RixBXLobeWeights()
    : m_numPoints(0),
      m_offset(0),
      m_numDiffuseLobes(0),
      m_numSpecularLobes(0),
      m_numUserLobes(0)
{
}

PRMAN_INLINE
RixBXLobeWeights::RixBXLobeWeights(
    int numPoints,
    int numDiffuseLobes,
    int numSpecularLobes,
    int numUserLobes,
    RtColorRGB* diffuseLobes[],
    RtColorRGB* specularLobes[],
    RtColorRGB* userLobes[],
    int offset)
    : m_numPoints(numPoints),
      m_offset(offset),
      m_numDiffuseLobes((unsigned char)numDiffuseLobes),
      m_numSpecularLobes((unsigned char)numSpecularLobes),
      m_numUserLobes((unsigned char)numUserLobes)
{
    for (int i = 0; i < numDiffuseLobes; i++)
        m_diffuseLobes[i] = diffuseLobes[i];

    for (int i = 0; i < numSpecularLobes; i++)
        m_specularLobes[i] = specularLobes[i];

    for (int i = 0; i < numUserLobes; i++)
        m_userLobes[i] = userLobes[i];
}

PRMAN_INLINE
RixBXLobeWeights::RixBXLobeWeights(RixBXLobeWeights const& that)
    : m_numPoints(that.m_numPoints),
      m_offset(that.m_offset),
      m_activeLobeTraits(that.m_activeLobeTraits),
      m_numDiffuseLobes(that.m_numDiffuseLobes),
      m_numSpecularLobes(that.m_numSpecularLobes),
      m_numUserLobes(that.m_numUserLobes)
{
    for (int i = 0; i < m_numDiffuseLobes; i++)
        m_diffuseLobes[i] = that.m_diffuseLobes[i];

    for (int i = 0; i < m_numSpecularLobes; i++)
        m_specularLobes[i] = that.m_specularLobes[i];

    for (int i = 0; i < m_numUserLobes; i++)
        m_userLobes[i] = that.m_userLobes[i];
}

PRMAN_INLINE RixBXLobeWeights& 
RixBXLobeWeights::operator=(RixBXLobeWeights const& that)
{
    m_numPoints        = that.m_numPoints;
    m_offset           = that.m_offset;
    m_activeLobeTraits = that.m_activeLobeTraits;
    m_numDiffuseLobes  = that.m_numDiffuseLobes;
    m_numSpecularLobes = that.m_numSpecularLobes;
    m_numUserLobes     = that.m_numUserLobes;

    for (int i = 0; i < m_numDiffuseLobes; i++)
        m_diffuseLobes[i] = that.m_diffuseLobes[i];

    for (int i = 0; i < m_numSpecularLobes; i++)
        m_specularLobes[i] = that.m_specularLobes[i];

    for (int i = 0; i < m_numUserLobes; i++)
        m_userLobes[i] = that.m_userLobes[i];

    return *this;
}

PRMAN_INLINE RtColorRGB const*
RixBXLobeWeights::GetDiffuseLobe(int i) const
{
    return m_diffuseLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB const*
RixBXLobeWeights::GetSpecularLobe(int i) const
{
    return m_specularLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB const*
RixBXLobeWeights::GetUserLobe(int i) const
{
    return m_userLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB*
RixBXLobeWeights::GetDiffuseLobe(int i)
{
    return m_diffuseLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB*
RixBXLobeWeights::GetSpecularLobe(int i)
{
    return m_specularLobes[i] + m_offset;
}

PRMAN_INLINE RtColorRGB*
RixBXLobeWeights::GetUserLobe(int i)
{
    return m_userLobes[i] + m_offset;
}

PRMAN_INLINE int
RixBXLobeWeights::GetNumPoints() const
{
    return m_numPoints;
}

PRMAN_INLINE void
RixBXLobeWeights::SetNumPoints(int numPoints)
{
    m_numPoints = numPoints;
}

PRMAN_INLINE int
RixBXLobeWeights::GetOffset() const
{
    return m_offset;
}

PRMAN_INLINE void
RixBXLobeWeights::SetOffset(int offset)
{
    m_offset = offset;
}

PRMAN_INLINE RixBXLobeTraits
RixBXLobeWeights::GetActiveLobeTraits() const
{
    return m_activeLobeTraits;
}

PRMAN_INLINE void
RixBXLobeWeights::SetActiveLobeTraits(RixBXLobeTraits lobes)
{
    m_activeLobeTraits = lobes;
}

PRMAN_INLINE void
RixBXLobeWeights::AddActiveLobeTraits(RixBXLobeTraits lobes)
{
    m_activeLobeTraits |= lobes;
}

PRMAN_INLINE int
RixBXLobeWeights::GetNumDiffuseLobes() const
{
    return m_numDiffuseLobes;
}

PRMAN_INLINE int
RixBXLobeWeights::GetNumSpecularLobes() const
{
    return m_numSpecularLobes;
}

PRMAN_INLINE int
RixBXLobeWeights::GetNumUserLobes() const
{
    return m_numUserLobes;
}

PRMAN_INLINE RtColorRGB*
RixBXLobeWeights::AddActiveLobe(
    RixBXLobeSampled lobeSampled,
    bool doInitializeWeights)
{
    // If lobeSampled is valid, then either GetDiffuse() or
    // GetSpecular() must be true, so we will always trigger one of
    // the inner conditionals
    if (lobeSampled.GetValid())
    {
        RtColorRGB* p;
        unsigned char lpeId = lobeSampled.GetLpeId();
        unsigned short traitMask;
        unsigned short sampleMask;
        if (lobeSampled.GetUser())
        {
            p = m_userLobes[lpeId];
            traitMask = m_activeLobeTraits.GetUser();
            sampleMask = (1U << lpeId) & 0xFFU;
        }
        else if (lobeSampled.GetDiffuse())
        {
            p = m_diffuseLobes[lpeId];
            traitMask = m_activeLobeTraits.GetDiffuse();
            sampleMask = (1U << lpeId) & 0x0FU;
        }
        else { // if (lobeSampled.GetSpecular())
            p = m_specularLobes[lpeId];
            traitMask = m_activeLobeTraits.GetSpecular();
            sampleMask = (1U << lpeId) & 0xFFU;
        }
        if (!(traitMask & sampleMask))
        {
            RixBXLobeTraits traits(lobeSampled);
            m_activeLobeTraits |= traits;
            if (doInitializeWeights)
                memset(p, 0, m_numPoints * sizeof(RtColorRGB));
        }
        return p + m_offset;
    }
    else
        return NULL;
}

PRMAN_INLINE void
RixBXLobeWeights::GetActiveLobes(RixBXActiveLobeWeights& r) const
{
    r.m_numDiffuseLobes = r.m_numSpecularLobes = r.m_numUserLobes = 0;
    r.m_lobeTraits = m_activeLobeTraits;
    r.m_offset     = m_offset;

    int mask;
    unsigned long lpeId;
    mask = m_activeLobeTraits.GetDiffuse() & ((1 << m_numDiffuseLobes) - 1);
    while (mask)
    {
        lpeId = RixFindFirstSetBit(mask);
        mask &= mask - 1;
        r.m_diffuseLobes[r.m_numDiffuseLobes]  = m_diffuseLobes[lpeId];
        r.m_diffuseLpeIds[r.m_numDiffuseLobes] = (unsigned char)lpeId;
        r.m_numDiffuseLobes++;
    }
    mask = m_activeLobeTraits.GetSpecular() & ((1 << m_numSpecularLobes) - 1);
    while (mask)
    {
        lpeId = RixFindFirstSetBit(mask);
        mask &= mask - 1;
        r.m_specularLobes[r.m_numSpecularLobes]  = m_specularLobes[lpeId];
        r.m_specularLpeIds[r.m_numSpecularLobes] = (unsigned char)lpeId;
        r.m_numSpecularLobes++;
    }
    mask = m_activeLobeTraits.GetUser() & ((1 << m_numUserLobes) - 1);
    while (mask)
    {
        lpeId = RixFindFirstSetBit(mask);
        mask &= mask - 1;
        r.m_userLobes[r.m_numUserLobes]  = m_userLobes[lpeId];
        r.m_userLpeIds[r.m_numUserLobes] = (unsigned char)lpeId;
        r.m_numUserLobes++;
    }
}

PRMAN_INLINE void
RixBXLobeWeights::GetActiveLobesIntersection(
    RixBXLobeWeights const& rhs,
    RixBXActiveLobeWeights& activeLhs,
    RixBXActiveLobeWeights& activeRhs) const
{
    int numDiffuseLobes  = 0;
    int numSpecularLobes = 0;
    int numUserLobes     = 0;

    RixBXLobeTraits lobes = (m_activeLobeTraits & rhs.m_activeLobeTraits);
    int mask;
    unsigned long lpeId;
    int nDiff = std::min(m_numDiffuseLobes, rhs.m_numDiffuseLobes);
    mask = lobes.GetDiffuse() & ((1 << nDiff) - 1);
    while (mask)
    {
        lpeId = RixFindFirstSetBit(mask);
        mask &= mask - 1;
        activeLhs.m_diffuseLobes[numDiffuseLobes] = m_diffuseLobes[lpeId];
        activeRhs.m_diffuseLobes[numDiffuseLobes] = rhs.m_diffuseLobes[lpeId];
        activeLhs.m_diffuseLpeIds[numDiffuseLobes] = (unsigned char)lpeId;
        activeRhs.m_diffuseLpeIds[numDiffuseLobes] = (unsigned char)lpeId;
        numDiffuseLobes++;
    }
    int nSpec = std::min(m_numSpecularLobes, rhs.m_numSpecularLobes);
    mask = lobes.GetSpecular() & ((1 << nSpec) - 1);
    while (mask)
    {
        lpeId = RixFindFirstSetBit(mask);
        mask &= mask - 1;
        activeLhs.m_specularLobes[numSpecularLobes] = m_specularLobes[lpeId];
        activeRhs.m_specularLobes[numSpecularLobes] = rhs.m_specularLobes[lpeId];
        activeLhs.m_specularLpeIds[numSpecularLobes] = (unsigned char)lpeId;
        activeRhs.m_specularLpeIds[numSpecularLobes] = (unsigned char)lpeId;
        numSpecularLobes++;
    }
    int nUser = std::min(m_numUserLobes, rhs.m_numUserLobes);
    mask = lobes.GetUser() & ((1 << nUser) - 1);
    while (mask)
    {
        lpeId = RixFindFirstSetBit(mask);
        mask &= mask - 1;
        activeLhs.m_userLobes[numUserLobes]  = m_userLobes[lpeId];
        activeRhs.m_userLobes[numUserLobes]  = rhs.m_userLobes[lpeId];
        activeLhs.m_userLpeIds[numUserLobes] = (unsigned char)lpeId;
        activeRhs.m_userLpeIds[numUserLobes] = (unsigned char)lpeId;
        numUserLobes++;
    }

    activeLhs.m_offset           = m_offset;
    activeLhs.m_lobeTraits       = lobes;
    activeLhs.m_numDiffuseLobes  = (unsigned char)numDiffuseLobes;
    activeLhs.m_numSpecularLobes = (unsigned char)numSpecularLobes;
    activeLhs.m_numUserLobes     = (unsigned char)numUserLobes;

    activeRhs.m_offset           = rhs.m_offset;
    activeRhs.m_lobeTraits       = lobes;
    activeRhs.m_numDiffuseLobes  = (unsigned char)numDiffuseLobes;
    activeRhs.m_numSpecularLobes = (unsigned char)numSpecularLobes;
    activeRhs.m_numUserLobes     = (unsigned char)numUserLobes;
}

PRMAN_INLINE void
RixBXLobeWeights::CopyWeightAtIndex(
    int index,
    RixBXActiveLobeWeights const& src,
    bool includeUserLobes)
{
    // Copy over just the active diffuse, specular, and user lobes in 'src'.
    int nDiff = src.GetNumDiffuseLobes();
    for (int i = 0; i < nDiff; i++)
    {
        int lpeId = src.GetDiffuseLpeId(i);
        GetDiffuseLobe(lpeId)[index] = src.GetDiffuseLobe(i)[index];
    }

    int nSpec = src.GetNumSpecularLobes();
    for (int i = 0; i < nSpec; i++)
    {
        int lpeId = src.GetSpecularLpeId(i);
        GetSpecularLobe(lpeId)[index] = src.GetSpecularLobe(i)[index];
    }

    if (includeUserLobes)
    {
        int nUser = src.GetNumUserLobes();
        for (int i = 0; i < nUser; i++)
        {
            int lpeId = src.GetUserLpeId(i);
            GetUserLobe(lpeId)[index] = src.GetUserLobe(i)[index];
        }
    }
}

PRMAN_INLINE void
RixBXLobeWeights::AddWeightAtIndex(
    int index,
    RixBXActiveLobeWeights const& src,
    bool includeUserLobes)
{
    // Add in just the active diffuse, specular, and user lobes in 'src'.
    int nDiff = src.GetNumDiffuseLobes();
    for (int i = 0; i < nDiff; i++)
    {
        int lpeId = src.GetDiffuseLpeId(i);
        GetDiffuseLobe(lpeId)[index] += src.GetDiffuseLobe(i)[index];
    }

    int nSpec = src.GetNumSpecularLobes();
    for (int i = 0; i < nSpec; i++)
    {
        int lpeId = src.GetSpecularLpeId(i);
        GetSpecularLobe(lpeId)[index] += src.GetSpecularLobe(i)[index];
    }

    if (includeUserLobes)
    {
        int nUser = src.GetNumUserLobes();
        for (int i = 0; i < nUser; i++)
        {
            int lpeId = src.GetUserLpeId(i);
            GetUserLobe(lpeId)[index] += src.GetUserLobe(i)[index];
        }
    }
}

// Randomly choose between numThresholds+1 scattering lobes using xi
PRMAN_INLINE int
RixBXChoose(float const xi, int const numThresholds, float const* thresholds)
{
    // below lowest threshold?
    if (xi < thresholds[0])
    {
        return 0; // chose lobe 0
    }
    // between thresholds?
    for (int i = 1; i < numThresholds; i++)
    {
        if (thresholds[i - 1] <= xi && xi < thresholds[i])
        {
            return i; // chose lobe i
        }
    }
    // must be above highest threshold
    return numThresholds; // chose last lobe
}

PRMAN_INLINE bool
RixBXChooseLobe(float const xi,
                RixBXActiveLobeWeights& lw,
                RixBXLobeSampled &chosenLobe)
{
    // Selects a lobe from a set of lobe responses stored in active weights, lw.
    // We employ a heuristic that seems to work well in practice where we take the
    // square root of the maximum channel value to guide the importance sampling.
    // We use this metric instead of one based on, for example, the luminance because
    // using the maximum channel appears to be more robust in certain cases where a
    // particular color channel's response is strong.

    // Stochastically choose a lobe
    int numDiffuse = lw.GetNumDiffuseLobes();
    int numSpecular = lw.GetNumSpecularLobes();
    int totalLobes = numDiffuse + numSpecular;

    // We only ever consider the first point
    const int point = 0;

    // Keep track of the number of non-zero lobe responses
    int nLobes = 0;

    // Build an importance table from all lobes
    float importance[k_RixBXMaxNumDiffuseLobes+k_RixBXMaxNumSpecularLobes];
    float totalImportance = 0.f;
    int lobeId = 0;
    for( int l = 0; l < numDiffuse; l++ )
    {
        RtColorRGB *pLobe = lw.GetDiffuseLobe(l);
        float val = sqrtf(std::max(0.0f, pLobe[point].ChannelMax()));

        if (val > 0.f) {
            nLobes += 1;
            lobeId = l;
        }

        totalImportance += val;
        importance[l] = totalImportance;
    }
    bool firstLobeIsDiffuse = nLobes > 0;
    for( int l = 0; l < numSpecular; l++ )
    {
        RtColorRGB *pLobe = lw.GetSpecularLobe(l);
        float val = sqrtf(std::max(0.0f, pLobe[point].ChannelMax()));

        if (val > 0.f) {
            nLobes += 1;
            lobeId = l;
        }

        totalImportance += val;
        importance[numDiffuse+l] = totalImportance;
    }

    if( totalImportance == 0.f || (nLobes == 0) )
    {
        // This can happen if the sampled/evaluated lobe has a black albedo at
        // this point. Indicate as such to the caller.
        chosenLobe.SetValid(false);
        return false;
    }

    // Early out if only one lobe
    if( nLobes == 1 )
    {
        bool isSpecular = !firstLobeIsDiffuse;
        unsigned char lpeId = isSpecular ? lw.GetSpecularLpeId(lobeId) : lw.GetDiffuseLpeId(lobeId);
        chosenLobe.SetSpecular( isSpecular );
        chosenLobe.SetLpeId( lpeId );
        chosenLobe.SetValid(true);
        return true;
    }

    // Normalize the importance
    for( int l = 0; l < totalLobes; l++ )
        importance[l] /= totalImportance;

    // Choose the lobe
    int lobe = RixBXChoose( xi, totalLobes-1, importance );

    if( lobe < 0 || lobe >= totalLobes )
    {
        // This should never happen but invalidate the event and return in any
        // error case.
        assert(0);
        chosenLobe.SetValid(false);
        return false;
    }

    // Get the probability of having chosen this lobe
    float probability = (lobe == 0) ?
        importance[0] : (importance[lobe] - importance[lobe-1]);

    bool isDiffuse = lobe < numDiffuse;
    if( !isDiffuse ) lobe -= numDiffuse;

    unsigned char lpeId = 0;

    for( int l = 0; l < numDiffuse; l++ )
    {
        RtColorRGB *pDiffuse = lw.GetDiffuseLobe(l);
        if( isDiffuse && (l == lobe) )
        {
            lpeId = lw.GetDiffuseLpeId(l);
            // Modify the weight
            pDiffuse[point] /= probability;
        }
        else
            pDiffuse[point].Zero();
    }

    for( int l = 0; l < numSpecular; l++ )
    {
        RtColorRGB *pSpec = lw.GetSpecularLobe(l);
        if( !isDiffuse && (l == lobe) )
        {
            lpeId = lw.GetSpecularLpeId(l);
            // Modify the weight
            pSpec[point] /= probability;
        }
        else
            pSpec[point].Zero();
    }

    // Fill in the chosen lobe info
    chosenLobe.SetValid(true);
    chosenLobe.SetSpecular( !isDiffuse );
    chosenLobe.SetLpeId( lpeId );
    return true;
}

PRMAN_INLINE void
RixBXChooseLobe(int const npoints,
                float const* xi,
                RixBXLobeWeights& lw,
                RixBXLobeSampled* lobeSampled)
{
    RixBXActiveLobeWeights activeWeights;
    lw.GetActiveLobes(activeWeights);
    int offset = activeWeights.GetOffset();
    for( int i = 0; i < npoints; i++ )
    {
        activeWeights.SetOffset(offset+i);

        if( !lobeSampled[i].GetValid() )
        {
            continue;
        }

        RixBXLobeSampled chosenLobe;
        if( RixBXChooseLobe( xi[i], activeWeights, chosenLobe) )
        {
            lobeSampled[i].SetSpecular(chosenLobe.GetSpecular());
            lobeSampled[i].SetLpeId(chosenLobe.GetLpeId());
        }
    }
}

PRMAN_INLINE void
RixBXChooseLobe(float const xi, RixBXActiveLobeWeights& lw,
                RixBXLobeTraits &traits)
{
    RixBXLobeSampled chosenLobe;

    if(RixBXChooseLobe(xi, lw, chosenLobe))
    {
        // Modify the traits
        if( chosenLobe.GetSpecular() )
        {
            traits.SetDiffuse(0);
            unsigned short s = (unsigned short)(1U << chosenLobe.GetLpeId());
            traits.SetSpecular(s);
        }
        else
        {
            unsigned short d = (unsigned short)(1U << chosenLobe.GetLpeId());
            traits.SetDiffuse(d);
            traits.SetSpecular(0);
        }
    }
}

#endif