BRAY_Types.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        BRAY_Types.h (BRAY Library, C++)
 *
 * COMMENTS:
 */

#ifndef __BRAY_Types__
#define __BRAY_Types__

#include "BRAY_API.h"
#include <UT/UT_StringHolder.h>
#include <GT/GT_Types.h>

class UT_WorkBuffer;

enum
{
    // Note - when adding event types, make sure to update ::eventType()
    BRAY_EVENT_NEW_FLAG,        // Added a new object
    BRAY_EVENT_DEL_FLAG,        // Object is being deleted
    BRAY_EVENT_ATTRIB_P_FLAG,   // P attribute changed
    BRAY_EVENT_ATTRIB_FLAG,     // Generic attribute changed
    BRAY_EVENT_TOPOLOGY_FLAG,   // Topology changed
    BRAY_EVENT_XFORM_FLAG,      // Transforms changed
    BRAY_EVENT_CONTENTS_FLAG,   // Contents changed (add/delete objects)
    BRAY_EVENT_PROPERTIES_FLAG, // Instance properties changed
    BRAY_EVENT_MATERIAL_FLAG,   // Material has changed
    BRAY_EVENT_TRACESET_FLAG,   // Traceset has changed

    BRAY_EVENT_MAXFLAGS
};
UT_ASSERT_COMPILETIME(BRAY_EVENT_MAXFLAGS <= 32);
#define ENUM_FLAG(TOKEN)  BRAY_EVENT_##TOKEN = (1 << BRAY_EVENT_##TOKEN##_FLAG)
/// Types of events that can be sent as updates to the renderer
enum BRAY_EventType
{
    BRAY_NO_EVENT = 0,
    ENUM_FLAG(NEW),
    ENUM_FLAG(DEL),
    ENUM_FLAG(ATTRIB_P),
    ENUM_FLAG(ATTRIB),
    ENUM_FLAG(TOPOLOGY),
    ENUM_FLAG(XFORM),
    ENUM_FLAG(CONTENTS),
    ENUM_FLAG(PROPERTIES),
    ENUM_FLAG(MATERIAL),
    ENUM_FLAG(TRACESET),
};
#undef ENUM_FLAG

static inline BRAY_EventType
operator|(BRAY_EventType a, BRAY_EventType b)
{
    return BRAY_EventType(uint(a)|uint(b));
}

/// Create a nice string for the event type mask
BRAY_API extern UT_StringHolder BRAYeventType(BRAY_EventType type);

/// Option tokens used at the "global" (scene) level
/// @note If you add an scene option, please update BRAY_HdUtil.C
enum BRAY_SceneOption
{
    BRAY_OPT_RENDERER = 0,      // Name of the renderer (read-only)
    BRAY_OPT_VERSION,           // Houdini version (read-only)
    BRAY_OPT_ENGINE,            // Accelerator (deprecated)
    BRAY_OPT_DELEGATE,          // Accelerator

    // Controls for general rendering
    BRAY_OPT_SAMPLES_PER_PIXEL,
    BRAY_OPT_PATHTRACEDSAMPLES,
    BRAY_OPT_RAYBIAS,
    BRAY_OPT_AUTO_RAYBIAS,
    BRAY_OPT_SCREENDOOR_LIMIT,
    BRAY_OPT_FPS,
    BRAY_OPT_FRAME,
    BRAY_OPT_CONVERGENCE_MODE,  // branched/pathtraced integration convergence switch
    BRAY_OPT_RR_CUTOFF_DEPTH,   // russian roulette cutoff depth
    BRAY_OPT_CONSTRAIN_MAX_ROUGH, // Constrain by maximum roughness

    BRAY_OPT_IMAGEMODE,         // Bucket rendering mode
    BRAY_OPT_PROGRESSIVE_PASSES,// Number of progressive passes before bucket mode

    BRAY_OPT_HD_FOREGROUND,     // Hydra renders in foreground (not background)
    BRAY_OPT_IPR_ENABLE,
    BRAY_OPT_IPR_INC_RANDOM,    // Random seed modified each IPR render
    BRAY_OPT_IPR_PROXY_DEPTH,
    BRAY_OPT_IPR_RESERVE_THREADS,
    BRAY_OPT_IPR_INTERACTION,   // Interaction mode (see enum)
    BRAY_OPT_IPR_BUCKETS_FOR_IMAGEFILTER,       // Buckets rendered before image filters
    BRAY_OPT_IPR_TIME_FOR_IMAGEFILTER,  // Timeout before image filters run
    BRAY_OPT_IPR_PROXY_FOR_IMAGEFILTER, // Proxy step before running filters

    // Controls for off-line rendering cache
    BRAY_OPT_USECACHERATIO,     // Whether to use the cache ratio
    BRAY_OPT_CACHERATIO,        // Amount of memory to use as cache
    BRAY_OPT_CACHESIZE,         // Absolute cache ratio

    // Object settings overrides
    BRAY_OPT_OVERRIDE_OBJECT,   // Override object settings matching this pattern

    // Control for disabled lighting
    BRAY_OPT_OVERRIDE_LIGHTING, // Override lighting mode
    BRAY_OPT_DISABLE_LIGHTING,  // Disable all lighting (headlight)
    BRAY_OPT_AO_SAMPLES,        // Ambient occlusion samples for headlight
    BRAY_OPT_AO_DISTANCE,       // Ambient occlusion max distance for headlight
    BRAY_OPT_AO_COLORLIMIT,     // Ambient occlusion color limit threshold
    BRAY_OPT_DEPTHCUE_COLOR,    // Color for depthcue fog
    BRAY_OPT_DEPTHCUE_ALPHA,    // Alpha for depthcue fog
    BRAY_OPT_DEPTHCUE_Z,        // Distance range for depth cue fog (near,far)

    // Controls for lighting modes
    BRAY_OPT_LIGHT_SAMPLING_MODE,       // (0[Uniform], 1[Light Tree])
    BRAY_OPT_LIGHT_SAMPLING_QUALITY,
    BRAY_OPT_COLOR_LIMIT,
    BRAY_OPT_COLOR_LIMIT_INDLINKED,
    BRAY_OPT_COLOR_LIMIT_INDIRECT,

    // Renderer working color space
    BRAY_OPT_WORKING_COLOR_SPACE,

    BRAY_OPT_RENDER_CAMERA,
    BRAY_OPT_DICING_CAMERA,
    BRAY_OPT_OFFSCREEN_QUALITY,
    BRAY_OPT_DICING_QUALITY_SCALE,      // Multiplier for DICING_QUALITY
    BRAY_OPT_IPR_CONTINUOUS_DICING,     // IPR continuous dicing
    BRAY_OPT_ENABLE_DOF,        // Enable DOF
    BRAY_OPT_IMAGE_BLUR,        // Image motion blur

    BRAY_OPT_RESOLUTION,        // Should match the data window size
    BRAY_OPT_BUCKETSIZE,
    BRAY_OPT_BUCKETORDER,
    BRAY_OPT_IMAGEFILTER,       // Image filter plugins (JSON string)
    BRAY_OPT_PIXELFILTER,
    BRAY_OPT_PIXELFILTERSIZE,
    BRAY_OPT_SAMPLEFILTER,      // Sample filter plugins (JSON string)
    BRAY_OPT_PIXELORACLE,       // Pixel oracle

    BRAY_OPT_USE_BACKGROUND,
    BRAY_OPT_BACKGROUND_IPRFILTER,

    BRAY_OPT_RANDOMSEED,
    BRAY_OPT_ABORTMISSINGTEXTURE,
    BRAY_OPT_ABORTNOGPUDEVICE,
    BRAY_OPT_EMBREE_SSE,
    BRAY_OPT_EMBREE_QUALITY,
    BRAY_OPT_EXPORTCOMPONENTS,
    BRAY_OPT_DIFFUSECOMPONENTS,
    BRAY_OPT_REFRACTCOMPONENTS,
    BRAY_OPT_VOLUMECOMPONENTS,
    BRAY_OPT_SSSCOMPONENTS,

    BRAY_OPT_AUTOHEADLIGHT,

    // Image properties
    BRAY_OPT_DATAWINDOW,        // Window size should match resolution
    BRAY_OPT_PIXELASPECT,

    BRAY_OPT_UNITS,             // The metres per unit in world space

    // Path guiding
    BRAY_OPT_GUIDING_ENABLE,
    BRAY_OPT_GUIDING_SAMPLES,
    BRAY_OPT_GUIDING_MIS_BIAS,
    BRAY_OPT_GUIDING_COMPONENTS,
    BRAY_OPT_GUIDING_PREPITERATIONS,    // deprecated
    BRAY_OPT_GUIDING_SPATIALFILTER,     // deprecated
    BRAY_OPT_GUIDING_DIRECTIONALFILTER, // deprecated
    BRAY_OPT_GUIDING_DETERMINISTIC,
    BRAY_OPT_GUIDING_CLEARBUFFERS,

    // Texture baking
    BRAY_OPT_UVUNWRAP_TYPE,
    BRAY_OPT_UVUNWRAP_INFO,             // Print out baking information
    BRAY_OPT_UVUNWRAP_OBJECT_ID,
    BRAY_OPT_UVUNWRAP_TEXTURE_TILE,
    BRAY_OPT_UVUNWRAP_PTEX_MIN_RES,
    BRAY_OPT_UVUNWRAP_PTEX_MAX_RES,
    BRAY_OPT_UVUNWRAP_PTEX_SMALL_PCT,
    BRAY_OPT_UVUNWRAP_PTEX_REL_SCALE,
    BRAY_OPT_UVUNWRAP_PTEX_SCALE,

    BRAY_OPT_BAKE_MODE,         // Baking mode
    BRAY_OPT_BAKE_UDIM,         // UDIM for baking
    BRAY_OPT_BAKE_LOW,          // Low res mesh
    BRAY_OPT_BAKE_CAGE,         // Cage mesh
    BRAY_OPT_BAKE_HIGH,         // High res mesh

    // Parameters for baking
    BRAY_OPT_BAKE_USE_MIKKT,    // Use MikkT
    BRAY_OPT_BAKE_TRACESET,     // Trace group
    BRAY_OPT_BAKE_TRACE_BIAS,   // Bias for trace from low to high mesh
    BRAY_OPT_BAKE_OC_SAMPLES,   // Number of samples for occlusion
    BRAY_OPT_BAKE_OC_MAXDIST,   // Occlusion maximum distance
    BRAY_OPT_BAKE_OC_BIAS,      // Occlusion bias
    BRAY_OPT_BAKE_TH_SAMPLES,   // Number of samples for thickness
    BRAY_OPT_BAKE_CV_SAMPLES,   // Number of samples for cavity
    BRAY_OPT_BAKE_CV_MAXDIST,   // Cavity maximum distance
    BRAY_OPT_BAKE_CV_BIAS,      // Cavity bias
    BRAY_OPT_BAKE_CV_RAYBIAS,   // Cavity ray bias
    BRAY_OPT_BAKE_CU_SAMPLES,   // Number of samples for curvature
    BRAY_OPT_BAKE_CU_SCALE,     // Curvature scale
    BRAY_OPT_BAKE_CU_BIAS,      // Cavity bias
    BRAY_OPT_BAKE_CU_SDIST,     // Curvature s distance
    BRAY_OPT_BAKE_USE_LIGHTING, // Enable lighting
    BRAY_OPT_BAKE_FLIPN,        // Flip normal
    BRAY_OPT_BAKE_PBOX_MODE,    // Mode for scene bounding box
    BRAY_OPT_BAKE_PBOX_UNIFORM, // Uniform or stretched
    BRAY_OPT_BAKE_PBOX_MIN,     // Minimum scene bounds
    BRAY_OPT_BAKE_PBOX_MAX,     // Maximum scene bounds

    BRAY_OPT_MAX_SCENE_OPTIONS,
    BRAY_OPT_INVALID_SCENE = BRAY_OPT_MAX_SCENE_OPTIONS
};

/// @note If you add an object property, please update BRAY_HdUtil.C
enum BRAY_ObjectProperty
{
    BRAY_OBJ_MOTION_BLUR,       // boolean
    BRAY_OBJ_SAMPLE_FROM_STAGE, // Choose motion segments by samples on stage
    BRAY_OBJ_GEO_VELBLUR,       // (0[no blur], 1[vel blur], 2[accel blur])
    BRAY_OBJ_GEO_SAMPLES,       // integer
    BRAY_OBJ_XFORM_SAMPLES,     // integer
    BRAY_OBJ_BLUR_STYLE,        // (0[lin], 1[rot])

    BRAY_OBJ_INSTANCE_VELBLUR,  // (0[no blur], 1[vel blur], 2[accel blur])
    BRAY_OBJ_INSTANCE_SAMPLES,  // integer

    BRAY_OBJ_DICING_QUALITY,    // <= 0[no dicing], 1[on m-p per pixel]
    BRAY_OBJ_DICING_FLATNESS,   // real
    BRAY_OBJ_TRUE_DISPLACE,     // int (0 = bump map, 1 = true, 2 = disable)
    BRAY_OBJ_DICING_DEPTH_MIN,  // integer (-1: unbound)
    BRAY_OBJ_DICING_DEPTH_MAX,  // integer (-1: unbound)

    BRAY_OBJ_CUSPANGLE,         // real

    /// @{
    /// @note: The order must match theBsdfBounceTypes in PBR_Types.h
    BRAY_OBJ_DIFFUSE_SAMPLES,
    BRAY_OBJ_REFLECT_SAMPLES,
    BRAY_OBJ_REFRACT_SAMPLES,
    BRAY_OBJ_VOLUME_SAMPLES,
    BRAY_OBJ_SSS_SAMPLES,

    BRAY_OBJ_DIFFUSE_LIMIT,
    BRAY_OBJ_REFLECT_LIMIT,
    BRAY_OBJ_REFRACT_LIMIT,
    BRAY_OBJ_VOLUME_LIMIT,
    BRAY_OBJ_SSS_LIMIT,

    BRAY_OBJ_DIFFUSE_QUALITY,
    BRAY_OBJ_REFLECT_QUALITY,
    BRAY_OBJ_REFRACT_QUALITY,
    BRAY_OBJ_VOLUME_QUALITY,
    BRAY_OBJ_SSS_QUALITY,
    /// @}

    BRAY_OBJ_VOLUME_SAMPLING,   // (0[raymarch], 1[woodcock/delta])
    BRAY_OBJ_VOLUME_STEP_RATE,
    BRAY_OBJ_VOLUME_UNIFORM,    // bool
    BRAY_OBJ_VOLUME_UNIFORM_DENSITY, // real
    BRAY_OBJ_VOLUME_UNIFORM_SAMPLES, // integer
    BRAY_OBJ_VOLUME_VBLUR_SCALE, // real
    BRAY_OBJ_VOLUME_SAMPLING_CHANNEL, // string
    BRAY_OBJ_VOLUME_FILTER_TYPE,    // string
    BRAY_OBJ_VOLUME_FILTER_WIDTH,   // real

    BRAY_OBJ_VISIBILITY_MASK,   // integer

    BRAY_OBJ_ENABLE_LOFT,
    BRAY_OBJ_LOFT_PTS_THRESH,
    BRAY_OBJ_TRACESETS,
    BRAY_OBJ_LIGHT_CATEGORIES,

    BRAY_OBJ_HOLDOUT_MODE,      // int

    BRAY_OBJ_POINT_STYLE,       // Point rendering style
    BRAY_OBJ_CURVE_STYLE,       // Curve style
    BRAY_OBJ_CURVE_BASIS,       // Curve basis override

    BRAY_OBJ_TREAT_AS_LIGHTSOURCE,  // (0[no], 1[yes], 2[auto])
    BRAY_OBJ_IS_LIGHTSOURCE,        // invisible, set by BRAY under the hood
    BRAY_OBJ_VOLLIGHT_IMPORTANCE_GRID_SIZE, // int (invisible, for now)
    BRAY_OBJ_GEOLIGHT_NUM_PERPRIM_CESAMPS,  // int (invisible, for now)

    BRAY_OBJ_LIGHTSOURCE_SAMPLING_QUALITY,  // real
    BRAY_OBJ_LIGHTSOURCE_DIFFUSE_SCALE,  // real
    BRAY_OBJ_LIGHTSOURCE_SPECULAR_SCALE,  // real

    BRAY_OBJ_IS_PORTAL,             // bool
    BRAY_OBJ_PORTAL_DOME_LIGHTS,    // string

    BRAY_OBJ_SMOOTHP,               // bool
    BRAY_OBJ_CULL_BACKFACE,         // (0[off], 1[cull back], 2[cull front])

    BRAY_OBJ_HD_RPRIM_ID, // int
    BRAY_OBJ_RENDER_MASK, // invisible, used only by karma delegate
    BRAY_OBJ_CUSTOM_TRACESETS,  // Custom trace groups
    BRAY_OBJ_LPE_TAG,   // string

    BRAY_OBJ_INTERNAL_REFLECT_ENABLE,
    BRAY_OBJ_LIGHT_SUBSET, // int
    BRAY_OBJ_DIELECTRIC_PRIORITY, // int

    BRAY_OBJ_CAUSTICS_ENABLE, // bool
    BRAY_OBJ_CAUSTICS_ROUGHNESS_CLAMP, // real

    BRAY_OBJ_FAKECAUSTICS_BSDF_ENABLE, // bool
    BRAY_OBJ_FAKECAUSTICS_COLOR,       // (r,g,b)
    BRAY_OBJ_FAKECAUSTICS_OPACITY,     // (r,g,b)

    // per-component variance AA settings
    BRAY_OBJ_VARIANCEAA_THRESH,
    BRAY_OBJ_VARIANCEAA_MIN_SAMPLES,
    BRAY_OBJ_VARIANCEAA_MAX_SAMPLES,

    BRAY_OBJ_MTLX_IMAGE_WIDTH,
    BRAY_OBJ_MTLX_IMAGE_BLUR,

    // UV unwrapping IDs
    BRAY_OBJ_UVUNWRAP_LOWRES,
    BRAY_OBJ_UVUNWRAP_CAGE,
    BRAY_OBJ_UVUNWRAP_HIGHRES,

    BRAY_OBJ_BUMP_SHADOW_TERMINATOR,

    BRAY_OBJ_MAX_PROPERTIES,
    BRAY_OBJ_INVALID_PROPERTY = BRAY_OBJ_MAX_PROPERTIES
};

enum BRAY_CameraProperty
{
    BRAY_CAMERA_FOCAL,          // real
    BRAY_CAMERA_APERTURE,       // real
    BRAY_CAMERA_PROJECTION,     // enum
    BRAY_CAMERA_LENSSHADER,     // string
    BRAY_CAMERA_ORTHO_WIDTH,    // real
    BRAY_CAMERA_CLIP,           // real[2] (near and far)
    BRAY_CAMERA_SHUTTER,        // real[2] (open and close)
    BRAY_CAMERA_FOCUS_DISTANCE, // real
    BRAY_CAMERA_FSTOP,          // real
    BRAY_CAMERA_WINDOW,         // real[4] (NDC mapping window)
    BRAY_CAMERA_EXPOSURE,       // real
    BRAY_CAMERA_TINT,           // real[3]
    BRAY_CAMERA_COORDSYS_ASPECT,// real

    BRAY_CAMERA_MAX_PROPERTIES,
    BRAY_CAMERA_INVALID_PROPERTY = BRAY_CAMERA_MAX_PROPERTIES
};

enum BRAY_LightProperty
{
    BRAY_LIGHT_ENABLE,          // bool
    BRAY_LIGHT_SHADER,          // string
    BRAY_LIGHT_AREA_SHAPE,      // int (see BRAY_LightType)
    BRAY_LIGHT_NORMALIZE_AREA,  // bool
    BRAY_LIGHT_AREA_SIZE,       // real[2]
    BRAY_LIGHT_ACTIVE_RADIUS,   // real
    BRAY_LIGHT_POINT_RADIUS,    // real
    BRAY_LIGHT_SHADOW_COLOR,    // real[2]
    BRAY_LIGHT_SHADOW_DISTANCE, // real
    BRAY_LIGHT_SHADOW_FALLOFF,  // real
    BRAY_LIGHT_SHADOW_FALLOFF_GAMMA,    // real
    BRAY_LIGHT_MIS_BIAS,        // real [-1,1]
    BRAY_LIGHT_SAMPLING_QUALITY,// real
    BRAY_LIGHT_SAMPLING_MODE,   // int (see LightSamplingMode)
    BRAY_LIGHT_SHADOW_TRACESET, // string
    BRAY_LIGHT_CATEGORY,        // string: category name
    BRAY_LIGHT_HDRI_MAX_ISIZE,  // int (max size for importance sampling tables)
    BRAY_LIGHT_DISTANT_ANGLE,   // float (angle which subtends sun)
    BRAY_LIGHT_DIFFUSE_SCALE,   // float multiplier for diffuse/sss/volume
    BRAY_LIGHT_SPECULAR_SCALE,  // float multiplier for refl/refr
    BRAY_LIGHT_SINGLE_SIDED,    // bool, single or double sided
    BRAY_LIGHT_RENDER_LIGHT_GEO,        // bool
    BRAY_LIGHT_LIGHT_GEO_CASTS_SHADOW,  // bool
    BRAY_LIGHT_LPE_TAG, // string
    BRAY_LIGHT_PORTAL_MIS_BIAS,       // real
    BRAY_LIGHT_ILLUM_BACKGROUND, // bool illuminates background holdout
    BRAY_LIGHT_CONTRIBUTIONS,    // string
    BRAY_LIGHT_CONTRIBUTES_CAUSTIC, // bool contributes to caustic
    BRAY_LIGHT_SKY_LIGHT,       // Type of sky light (none, sky, sky+sun, sun)
    BRAY_LIGHT_SPREAD,          // float (0,1] spread value

    BRAY_LIGHT_MAX_PROPERTIES,
    BRAY_LIGHT_INVALID_PROPERTY = BRAY_LIGHT_MAX_PROPERTIES
};

enum BRAY_PlaneProperty
{
    BRAY_PLANE_FILTER,          // Pixel filter
    BRAY_PLANE_SAMPLING,        // Sample filtering (0 = average etc.)
    BRAY_PLANE_DITHER,          // Dither for quantizing to integer values
    BRAY_PLANE_DEFAULT_VALUE,   // Default value for 1-channel planes
    BRAY_PLANE_CRYPTO_ENABLE,   // Cryptomatte enable
    BRAY_PLANE_CRYPTO_RANK,     // Cryptomatte maximum rank
    BRAY_PLANE_CRYPTO_SIDECAR,  // Cryptomatte sidecar manifest file

    BRAY_PLANE_MAX_PROPERTIES,
    BRAY_PLANE_INVALID_PROPERTY = BRAY_PLANE_MAX_PROPERTIES
};

enum BRAY_PropertyType
{
    BRAY_SCENE_PROPERTY,
    BRAY_OBJECT_PROPERTY,
    BRAY_LIGHT_PROPERTY,
    BRAY_CAMERA_PROPERTY,
    BRAY_PLANE_PROPERTY,

    BRAY_MAX_PROPERTY_TYPES,
    BRAY_INVALID_PROPERTY = BRAY_MAX_PROPERTY_TYPES
};

/// Not all applications are able to load HDAs.  If an application is able to
/// load HDAs, it should create a subclass of BRAY_HDALoader and instantiate a
/// loader.  The constructor will register the class for the application and
/// the destructor will de-register.
class BRAY_API BRAY_HDALoader
{
public:
    BRAY_HDALoader();
    virtual ~BRAY_HDALoader();

    /// The className() is used to print out error messages in case there are
    /// multiple HDA loaders instantiated.
    virtual const char  *className() const = 0;

    /// Return true if the HDA given by the path was loaded.  It's possible the
    /// same path may be passed multiple times, and it's up to the implementor
    /// to optimize for this case.  It's up to the implementor to print out
    /// errors using UT_ErrorLog.
    virtual bool         loadHDA(const UT_StringHolder &path) = 0;
};

/// Return the name of the renderer
BRAY_API extern const UT_StringHolder   &BRAYrendererName();

/// Look up the enum given a name.
BRAY_API constexpr inline exint BRAYpropertyCount(BRAY_PropertyType ty)
{
    switch (ty)
    {
        case BRAY_SCENE_PROPERTY:
            return BRAY_OPT_MAX_SCENE_OPTIONS;
        case BRAY_OBJECT_PROPERTY:
            return BRAY_OBJ_MAX_PROPERTIES;
        case BRAY_LIGHT_PROPERTY:
            return BRAY_LIGHT_MAX_PROPERTIES;
        case BRAY_CAMERA_PROPERTY:
            return BRAY_CAMERA_MAX_PROPERTIES;
        case BRAY_PLANE_PROPERTY:
            return BRAY_PLANE_MAX_PROPERTIES;
        default:
            break;
    }
    return 0;
}
BRAY_API extern const UT_StringHolder   &BRAYproperty(
                                                BRAY_PropertyType ty, int id);
BRAY_API extern int             BRAYproperty(BRAY_PropertyType ty,
                                        const UT_StringRef &name);
BRAY_API extern exint           BRAYpropertySize(BRAY_PropertyType ty, int id);
BRAY_API extern GT_Storage      BRAYpropertyStorage(BRAY_PropertyType ty, int id);

inline bool
BRAYisValid(BRAY_PropertyType ty, int id)
{
    return GT_STORE_INVALID
        != BRAYpropertyStorage(ty, id);
}

inline bool
BRAYisValid(const std::pair<BRAY_PropertyType, int> &prop)
{
    return BRAYisValid(prop.first, prop.second);
}

#define PROPERTY_LOOKUP(NAME, STYLE, ENUM) \
    inline ENUM BRAY##NAME(const UT_StringRef &name) \
            { return ENUM(BRAYproperty(STYLE, name)); } \
    inline const UT_StringHolder &BRAY##NAME(ENUM token) \
            { return BRAYproperty(STYLE, token); } \
    inline exint BRAY##NAME##Size(ENUM token) \
            { return BRAYpropertySize(STYLE, token); } \
    inline GT_Storage BRAY##NAME##Storage(ENUM token) \
            { return BRAYpropertyStorage(STYLE, token); } \
    /* end of macro */
PROPERTY_LOOKUP(sceneOption, BRAY_SCENE_PROPERTY, BRAY_SceneOption)
PROPERTY_LOOKUP(objectProperty, BRAY_OBJECT_PROPERTY, BRAY_ObjectProperty)
PROPERTY_LOOKUP(lightProperty, BRAY_LIGHT_PROPERTY, BRAY_LightProperty)
PROPERTY_LOOKUP(cameraProperty, BRAY_CAMERA_PROPERTY, BRAY_CameraProperty)
PROPERTY_LOOKUP(planeProperty, BRAY_PLANE_PROPERTY, BRAY_PlaneProperty)
#undef PROPERTY_LOOKUP

/// Lookup a property type by name
BRAY_API extern BRAY_PropertyType        BRAYpropertyType(const UT_StringRef &name);
/// Look up the name of a property type by the id
BRAY_API extern const UT_StringHolder   &BRAYpropertyType(BRAY_PropertyType id);

/// This function will resolve generic names to the appropriate property type
/// and property identifier.  For example:
///     "plane:filter" -> {BRAY_PLANE_PROPERTY, BRAY_PLANE_FILTER}
///     "camera:focal" -> {BRAY_CAMERA_PROPERTY, BRAY_CAMERA_FOCAL}
///     "global:bucketsize" -> {BRAY_SCENE_PROPERTY, BRAY_OPT_BUCKETSIZE}
/// If the token doesn't map to a property, the function will return an invalid
/// pair (i.e. BRAYisValid(result) == false).
///
/// If the token isn't prefixed with a property type, the @c default_style will
/// be used.  For example, with the default of BRAY_SCENE_PROPERTY:
///     "bucketsize" -> { BRAY_SCENE_PROPERTY, BRAY_OPT_BUCKETSIZE }
///     "focal" -> {invalid_property_pair} (error - not a scene property)
BRAY_API extern std::pair<BRAY_PropertyType, int>
                        BRAYproperty(const char *token,
                                BRAY_PropertyType style=BRAY_SCENE_PROPERTY);

/// Given a property type, this will compose a name string that fully qualifies
/// the property.  This is a string that would be suitable for @c
/// BRAYlookupProperty().  This may return a @c nullptr.
BRAY_API extern const char      *BRAYproperty(UT_WorkBuffer &storage,
                                        BRAY_PropertyType type,
                                        int property_id,
                                        const char *prefix = "");

/// @{
/// Generic method to return the number of options given an enum
template <typename T> static inline constexpr size_t BRAYmaxOptions()
{ SYS_UNIMPLEMENTED_TEMPLATE(T); return 0; }

template <> inline constexpr size_t
BRAYmaxOptions<BRAY_SceneOption>() { return BRAY_OPT_MAX_SCENE_OPTIONS; }
template <> inline constexpr size_t
BRAYmaxOptions<BRAY_ObjectProperty>() { return BRAY_OBJ_MAX_PROPERTIES; }
template <> inline constexpr size_t
BRAYmaxOptions<BRAY_LightProperty>() { return BRAY_LIGHT_MAX_PROPERTIES; }
template <> inline constexpr size_t
BRAYmaxOptions<BRAY_CameraProperty>() { return BRAY_CAMERA_MAX_PROPERTIES; }
template <> inline constexpr size_t
BRAYmaxOptions<BRAY_PlaneProperty>() { return BRAY_PLANE_MAX_PROPERTIES; }
/// @}

/// @{
/// Generic method to find the valud of the property type enum given the enum
template <typename T> static inline constexpr BRAY_PropertyType BRAYpropertyType()
{ SYS_UNIMPLEMENTED_TEMPLATE(T); return BRAY_INVALID_PROPERTY; }

template <> inline constexpr BRAY_PropertyType
BRAYpropertyType<BRAY_SceneOption>() { return BRAY_SCENE_PROPERTY; }
template <> inline constexpr BRAY_PropertyType
BRAYpropertyType<BRAY_ObjectProperty>() { return BRAY_OBJECT_PROPERTY; }
template <> inline constexpr BRAY_PropertyType
BRAYpropertyType<BRAY_LightProperty>() { return BRAY_LIGHT_PROPERTY; }
template <> inline constexpr BRAY_PropertyType
BRAYpropertyType<BRAY_CameraProperty>() { return BRAY_CAMERA_PROPERTY; }
template <> inline constexpr BRAY_PropertyType
BRAYpropertyType<BRAY_PlaneProperty>() { return BRAY_PLANE_PROPERTY; }
/// @}


enum BRAY_OverrideLight
{
    BRAY_OVERRIDE_LIGHT_OFF,            // Standard lighting
    BRAY_OVERRIDE_LIGHT_EMISSIVE,       // Only emissive objects
    BRAY_OVERRIDE_LIGHT_HEADLIGHT,      // Force: Headlight
    BRAY_OVERRIDE_LIGHT_DOMELIGHT,      // Force: Dome Light
};

enum BRAY_LightType
{
    BRAY_LIGHT_POINT,
    BRAY_LIGHT_SPHERE,
    BRAY_LIGHT_RECT,
    BRAY_LIGHT_DISK,
    BRAY_LIGHT_CYLINDER,
    BRAY_LIGHT_LINE,
    BRAY_LIGHT_ENVIRONMENT,
    BRAY_LIGHT_DISTANT,
    BRAY_LIGHT_GEOMETRY,

    BRAY_LIGHT_UNDEFINED,
    BRAY_LIGHT_MAX = BRAY_LIGHT_UNDEFINED
};

enum BRAY_RenderStage
{
    BRAY_STAGE_INACTIVE,
    BRAY_STAGE_LOADING,
    BRAY_STAGE_INITIALIZING,
    BRAY_STAGE_GUIDING_TRAINING,
    BRAY_STAGE_RENDERING,
    BRAY_STAGE_CONVERGED,

    BRAY_STAGE_MAX_TYPES
};

// Different types of user interaction in IPR
enum BRAY_InteractionType
{
    BRAY_INTERACTION_NORMAL,
    BRAY_INTERACTION_FLIPBOOK,
    BRAY_INTERACTION_PLAYING,
    BRAY_INTERACTION_SCRUBBING,
    BRAY_INTERACTION_EDITING,
    BRAY_INTERACTION_TUMBLING,

    BRAY_INTERACTION_MAX_TYPES
};

enum BRAY_BucketOrder
{
    BRAY_BUCKETORDER_MIDDLE,    // Render starting centered on focus point
    BRAY_BUCKETORDER_TOP,       // Render top down
    BRAY_BUCKETORDER_BOTTOM,    // Render bottom up
    BRAY_BUCKETORDER_LEFT,      // Render left to right
    BRAY_BUCKETORDER_RIGHT,     // Render right to left

    BRAY_BUCKETORDER_MAX
};

enum BRAY_ImageMode
{
    BRAY_IMAGEMODE_PROGRESSIVE,       // Pass over all buckets on image
    BRAY_IMAGEMODE_BUCKET,            // Finish buckets before advancing

    BRAY_IMAGEMODE_MAX
};

/// Projection modes for rendering
enum BRAY_Projection
{
    BRAY_PROJ_ORTHOGRAPHIC,     // orthographic projection mode
    BRAY_PROJ_PERSPECTIVE,      // perspective projection mode
    BRAY_PROJ_CVEX_SHADER,      // run a CVEX lens shader
    BRAY_PROJ_BAKING,           // Custom baking projection mode

    BRAY_PROJ_MAX,
    BRAY_PROJ_INVALID = BRAY_PROJ_MAX
};

enum BRAY_VexRayImport
{
    BRAY_RAYIMPORT_P,           // vector: ray origin
    BRAY_RAYIMPORT_D,           // vector: ray direction
    BRAY_RAYIMPORT_TIME,        // float: shutter time
    BRAY_RAYIMPORT_NEAR,        // float: near bias
    BRAY_RAYIMPORT_FAR,         // float: max distance
    BRAY_RAYIMPORT_MASK,        // int: intersection mask
    BRAY_RAYIMPORT_CONTRIB,     // vector: contribution

    BRAY_RAYIMPORT_HIT_ISHIT,   // bool: Hit or miss
    BRAY_RAYIMPORT_HIT_P,       // vector: Hit position (in world space)
    BRAY_RAYIMPORT_HIT_P_CAMERA,// vector: Hit position (in camera space)
    BRAY_RAYIMPORT_HIT_Pz,      // float: Pz (in space of camera)
    BRAY_RAYIMPORT_HIT_VELOCITY,// vector: Hit velocity (in world space)
    BRAY_RAYIMPORT_HIT_MOTION,  // vector: Motion Vector  (in raster space)
    BRAY_RAYIMPORT_HIT_STACK,   // int[]: Hit stack
    BRAY_RAYIMPORT_HIT_ELEM,    // int: Hit element (raw id)
    BRAY_RAYIMPORT_HIT_PRIMID,  // int: Hit primitive id
    BRAY_RAYIMPORT_HIT_COORD,   // vector: raw parametric coords {u,v,w}
    BRAY_RAYIMPORT_HIT_DIST,    // float: Hit distance
    BRAY_RAYIMPORT_HIT_DPDZ,    // float: dPdz
    BRAY_RAYIMPORT_HIT_N,       // vector: smooth normal
    BRAY_RAYIMPORT_HIT_N_CAMERA,// vector: smooth normal (in camera space)
    BRAY_RAYIMPORT_HIT_N_FACING,// vector: view facing smooth normal (in world space) 
    BRAY_RAYIMPORT_HIT_N_FACINGRATIO,  // float: facing ratio of smooth normal
    BRAY_RAYIMPORT_HIT_Ng,      // vector: geometric normal
    BRAY_RAYIMPORT_HIT_Ng_CAMERA,   // vector: geometric normal (in camera space)
    BRAY_RAYIMPORT_HIT_Ng_FACING,   // vector: view facing geometric normal (in world space)
    BRAY_RAYIMPORT_HIT_Ng_FACINGRATIO, // float: facing ratio of geometric normal
    BRAY_RAYIMPORT_HIT_FLAGS,   // int: hit flags
    BRAY_RAYIMPORT_HIT_OBJECTID,// int: hit object id
    BRAY_RAYIMPORT_HIT_ISBACKFACE,  // bool: is hit object backface
    BRAY_RAYIMPORT_LEVEL,       // int: ray level
    BRAY_RAYIMPORT_VOLUME_LEVEL,// int: ray volume level
    BRAY_RAYIMPORT_PIXEL_SAMPLES,       // int: pixel samples (ie camera rays) 
    BRAY_RAYIMPORT_HD_PRIM,     // int: hydra rprim id for selection
    BRAY_RAYIMPORT_HD_INST,     // int: hydra inst idx (0th level) for selection
    BRAY_RAYIMPORT_NOFAKECAUSTICS,      // bool: disable fake caustics

    BRAY_RAYIMPORT_CURVE_ATTRIB_P,      // vector: interpolated curve position
    BRAY_RAYIMPORT_CURVE_ATTRIB_WIDTH,  // float:  interpolated curve width
    BRAY_RAYIMPORT_CURVE_ATTRIB_TANV,   // vector: interpolated curve pos derivative

    BRAY_RAYIMPORT_ISSHADOWRAY,         // bool: is the ray a shadow ray (i.e. isshadowray)
    BRAY_RAYIMPORT_CONESPREAD,          // float: ray cone half angle

    BRAY_RAYIMPORT_BAKE_P,              // P from the bake state
    BRAY_RAYIMPORT_BAKE_P_LOW,          // P_low
    BRAY_RAYIMPORT_BAKE_P_HIGH,         // P_high
    BRAY_RAYIMPORT_BAKE_P_CAGE,         // P_cage
    BRAY_RAYIMPORT_BAKE_N,              // N
    BRAY_RAYIMPORT_BAKE_N_LOW,          // N_low
    BRAY_RAYIMPORT_BAKE_N_HIGH,         // N_high
    BRAY_RAYIMPORT_BAKE_N_CAGE,         // N_cage
    BRAY_RAYIMPORT_BAKE_MIKKT_N,        // mikktN
    BRAY_RAYIMPORT_BAKE_MIKKT_U,        // mikktU
    BRAY_RAYIMPORT_BAKE_MIKKT_V,        // mikktV
    BRAY_RAYIMPORT_BAKE_PRIM_ID,        // primId
    BRAY_RAYIMPORT_BAKE_U,              // u
    BRAY_RAYIMPORT_BAKE_V,              // v
    BRAY_RAYIMPORT_BAKE_MINBOX,         // Minimum bounds
    BRAY_RAYIMPORT_BAKE_MAXBOX,         // Maximum bounds
    BRAY_RAYIMPORT_BAKE_MINBOX_LOW,     // Minimum bounds (low mesh)
    BRAY_RAYIMPORT_BAKE_MAXBOX_LOW,     // Maximum bounds (low mesh)
    BRAY_RAYIMPORT_BAKE_MINBOX_HIGH,    // Minimum bounds (high mesh)
    BRAY_RAYIMPORT_BAKE_MAXBOX_HIGH,    // Maximum bounds (high mesh)
    BRAY_RAYIMPORT_BAKE_MINBOX_CAGE,    // Minimum bounds (cage mesh)
    BRAY_RAYIMPORT_BAKE_MAXBOX_CAGE,    // Maximum bounds (cage mesh)
    BRAY_RAYIMPORT_BAKE_TRACESET,       // The integer traceset

    BRAY_RAYIMPORT_MAX,
    BRAY_RAYIMPORT_INVALID = BRAY_RAYIMPORT_MAX // Not a valid ray import
};

enum BRAY_VexLightImport
{
    BRAY_LIGHTIMPORT_SURFNORMAL,                // vector: surface normal in light shader
    BRAY_LIGHTIMPORT_SURFACEINCIDENT,           // vector: surface camera vector in light shader
    BRAY_LIGHTIMPORT_LIGHTVECTOR,               // vector: surface to light vector in light shader
    BRAY_LIGHTIMPORT_SURFACEPOSITION,       // vector: surface position in light shader

    BRAY_LIGHTIMPORT_MAX,
    BRAY_LIGHTIMPORT_INVALID = BRAY_LIGHTIMPORT_MAX     // Not a valid light import
};

#define ENUM_MAPPER(TYPE, METHOD) \
    BRAY_API extern TYPE METHOD(const UT_StringRef &name); \
    BRAY_API extern const UT_StringHolder &METHOD(TYPE o); \
    /* end macro */

ENUM_MAPPER(BRAY_LightType, BRAYlightType)
ENUM_MAPPER(BRAY_RenderStage, BRAYrenderStage)
ENUM_MAPPER(BRAY_InteractionType, BRAYinteractionType)
ENUM_MAPPER(BRAY_BucketOrder, BRAYbucketOrder)
ENUM_MAPPER(BRAY_ImageMode, BRAYimageMode)
ENUM_MAPPER(BRAY_Projection, BRAYprojection)
ENUM_MAPPER(BRAY_VexRayImport, BRAYrayImport)
ENUM_MAPPER(BRAY_VexLightImport, BRAYlightImport)

#undef ENUM_MAPPER

/// Consistent representation of time type within BRAY
using BRAYtime = float;

/// Consistent representation for material ids
using BRAYmaterialId = int;

/// Invalid material id
static constexpr BRAYmaterialId BRAY_INVALID_MATERIAL_ID = 0;

/// List of known LPE prefixes
enum BRAY_LPEPrefix
{
    BRAY_LPEPREFIX_NONE         = 0x0000,
    BRAY_LPEPREFIX_UNOCCLUDED   = 0x0001,
    BRAY_LPEPREFIX_HOLDOUTS     = 0x0002
};
static inline BRAY_LPEPrefix
operator|(BRAY_LPEPrefix a, BRAY_LPEPrefix b)
{
    return BRAY_LPEPrefix(uint(a)|uint(b));
}
static inline BRAY_LPEPrefix
operator&(BRAY_LPEPrefix a, BRAY_LPEPrefix b)
{
    return BRAY_LPEPrefix(uint(a)&uint(b));
}

enum BRAY_RayVisibilityEnum
{
    BRAY_RAY_CAMERA_ENUM,
    BRAY_RAY_DIFFUSE_ENUM,
    BRAY_RAY_REFLECT_ENUM,
    BRAY_RAY_REFRACT_ENUM,
    BRAY_RAY_VOLUME_ENUM,
    BRAY_RAY_SHADOW_REG_ENUM,
    BRAY_RAY_SHADOW_BG_ENUM,

    BRAY_PROXY_CAMERA_ENUM,
    BRAY_PROXY_SHADOW_ENUM,

    BRAY_GUIDE_CAMERA_ENUM,
    BRAY_GUIDE_SHADOW_ENUM,
};

#define ENUM_TO_MASK(TOKEN)     TOKEN = (1 << TOKEN##_ENUM)
/// Ray visibility flags
enum BRAY_RayVisibility : uint16
{
    BRAY_RAY_NONE = 0,

    ENUM_TO_MASK(BRAY_RAY_CAMERA),
    ENUM_TO_MASK(BRAY_RAY_DIFFUSE),
    ENUM_TO_MASK(BRAY_RAY_REFLECT),
    ENUM_TO_MASK(BRAY_RAY_REFRACT),
    ENUM_TO_MASK(BRAY_RAY_VOLUME),
    ENUM_TO_MASK(BRAY_RAY_SHADOW_REG),
    ENUM_TO_MASK(BRAY_RAY_SHADOW_BG),

    ENUM_TO_MASK(BRAY_PROXY_CAMERA),
    ENUM_TO_MASK(BRAY_PROXY_SHADOW),

    ENUM_TO_MASK(BRAY_GUIDE_CAMERA),
    ENUM_TO_MASK(BRAY_GUIDE_SHADOW),

    BRAY_RAY_SHADOW = (BRAY_RAY_SHADOW_REG | BRAY_RAY_SHADOW_BG),
    BRAY_ANY_CAMERA = (BRAY_RAY_CAMERA | BRAY_PROXY_CAMERA | BRAY_GUIDE_CAMERA),
    BRAY_ANY_SHADOW = (BRAY_RAY_SHADOW | BRAY_PROXY_SHADOW | BRAY_GUIDE_SHADOW),

    // Temporary flag only for the hydra delegate's internal use. DO NOT USE!
    BRAY_RAY_HYDRA_RENDER   = 0x8000,

    BRAY_RAY_ALL        = 0x7FFF,

    BRAY_RAY_PROXY_MASK = (BRAY_PROXY_CAMERA|BRAY_PROXY_SHADOW),
    BRAY_RAY_GUIDE_MASK = (BRAY_GUIDE_CAMERA|BRAY_GUIDE_SHADOW),
    BRAY_RAY_RENDER_MASK = (BRAY_RAY_ALL & ~BRAY_RAY_PROXY_MASK
                                        & ~BRAY_RAY_GUIDE_MASK),
};
#undef ENUM_TO_MASK

static inline BRAY_RayVisibility
operator|(BRAY_RayVisibility a, BRAY_RayVisibility b)
{
    return BRAY_RayVisibility(uint(a)|uint(b));
}
static inline BRAY_RayVisibility
operator&(BRAY_RayVisibility a, BRAY_RayVisibility b)
{
    return BRAY_RayVisibility(uint(a)&uint(b));
}
static inline BRAY_RayVisibility
operator~(BRAY_RayVisibility a)
{
    return BRAY_RayVisibility(~uint(a));
}

BRAY_API extern UT_StringHolder BRAYrayVisibility(BRAY_RayVisibility mask);

/// Generic method to return the number of components for a given import
/// Note that arrays types return 0 (see BRAYrayImportArray())
template <BRAY_VexRayImport T> static inline constexpr size_t BRAYrayImportSize()
{
#if !defined(__clang__) && !SYS_IS_GCC_GE(9, 2)
    SYS_UNIMPLEMENTED_TEMPLATE(T);
#endif
    return 0;
}
/// Generic method to return whether the import variable is array valued
template <BRAY_VexRayImport T> static inline constexpr bool BRAYrayImportIsArray()
{
#if !defined(__clang__) && !SYS_IS_GCC_GE(9, 2)
    SYS_UNIMPLEMENTED_TEMPLATE(T);
#endif
    return false;
}


template <BRAY_VexLightImport T> static inline constexpr size_t BRAYlightImportSize()
{
#if !defined(__clang__) && !SYS_IS_GCC_GE(9, 2)
    SYS_UNIMPLEMENTED_TEMPLATE(T);
#endif
    return 0;
}
/// Generic method to return whether the import variable is array valued
template <BRAY_VexLightImport T> static inline constexpr bool BRAYlightImportIsArray()
{
#if !defined(__clang__) && !SYS_IS_GCC_GE(9, 2)
    SYS_UNIMPLEMENTED_TEMPLATE(T);
#endif
    return false;
}

#define INSTANTIATE(VAR, SIZE, IS_ARRAY) \
    template <> inline constexpr size_t \
    BRAYrayImportSize<VAR>() { return SIZE; } \
    template <> inline constexpr bool \
    BRAYrayImportIsArray<VAR>() { return IS_ARRAY; } \
    /* end of macro */

INSTANTIATE(BRAY_RAYIMPORT_P,           3, false)
INSTANTIATE(BRAY_RAYIMPORT_D,           3, false)
INSTANTIATE(BRAY_RAYIMPORT_TIME,        1, false)
INSTANTIATE(BRAY_RAYIMPORT_NEAR,        1, false)
INSTANTIATE(BRAY_RAYIMPORT_FAR,         1, false)
INSTANTIATE(BRAY_RAYIMPORT_MASK,        1, false)
INSTANTIATE(BRAY_RAYIMPORT_CONTRIB,     3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_P,       3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_P_CAMERA,    3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_Pz,      1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_VELOCITY,3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_MOTION,  3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_STACK,   0, true)
INSTANTIATE(BRAY_RAYIMPORT_HIT_ELEM,    1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_PRIMID,  1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_COORD,   3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_DIST,    1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_DPDZ,    1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_N,       3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_N_CAMERA,    3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_N_FACING,    3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_N_FACINGRATIO,   1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_Ng,      3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_Ng_CAMERA,   3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_Ng_FACING,   3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_Ng_FACINGRATIO,  1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_FLAGS,   1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_OBJECTID,1, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_ISBACKFACE,  1, false)
INSTANTIATE(BRAY_RAYIMPORT_LEVEL,       1, false)
INSTANTIATE(BRAY_RAYIMPORT_VOLUME_LEVEL,1, false)
INSTANTIATE(BRAY_RAYIMPORT_NOFAKECAUSTICS,  1, false)
INSTANTIATE(BRAY_RAYIMPORT_ISSHADOWRAY, 1, false)

#undef INSTANTIATE

#define INSTANTIATE(VAR, SIZE, IS_ARRAY) \
    template <> inline constexpr size_t \
    BRAYlightImportSize<VAR>() { return SIZE; } \
    template <> inline constexpr bool \
    BRAYlightImportIsArray<VAR>() { return IS_ARRAY; } \
    /* end of macro */

INSTANTIATE(BRAY_LIGHTIMPORT_SURFNORMAL,             3, false)
INSTANTIATE(BRAY_LIGHTIMPORT_SURFACEINCIDENT,    3, false)
INSTANTIATE(BRAY_LIGHTIMPORT_LIGHTVECTOR,            3, false)
INSTANTIATE(BRAY_LIGHTIMPORT_SURFACEPOSITION,    3, false)
#undef INSTANTIATE

// LightSamplingMode
// enum for BRAY_OPT_LIGHT_SAMPLING_MODE
enum BRAY_LightSamplingMode
{
    BRAY_LSM_UNIFORM = 0,       //  uniform sampling
    BRAY_LSM_LIGHT_TREE         //  light hierarchy
};

#endif