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_ACCELERATOR,       // Accelerator

    // Controls for general rendering
    BRAY_OPT_SAMPLES_PER_PIXEL,
    BRAY_OPT_RAYBIAS,
    BRAY_OPT_SCREENDOOR_LIMIT,
    BRAY_OPT_FPS,

    BRAY_OPT_HD_FOREGROUND,     // Hydra renders in foreground (not background)
    BRAY_OPT_IPR_INC_RANDOM,    // Random seed modified each IPR render
    BRAY_OPT_IPR_CONVERGENCE,   // Use IPR style integration convergence
    BRAY_OPT_IPR_PROXY_DEPTH,
    BRAY_OPT_IPR_RESERVE_THREADS,
    BRAY_OPT_IPR_INTERACTION,   // Interaction mode (see enum)
    BRAY_OPT_IPR_TILES_FOR_IMAGEFILTER, // Tiles 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

    // Control for disabled lighting
    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_RENDER_CAMERA,
    BRAY_OPT_DICING_CAMERA,
    BRAY_OPT_OFFSCREEN_QUALITY,
    BRAY_OPT_ENABLE_DOF,        // Enable DOF

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

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

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

    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_GEO_VELBLUR,       // (0[no blur], 1[vel blur], 2[accel blur])
    BRAY_OBJ_GEO_SAMPLES,       // integer
    BRAY_OBJ_XFORM_SAMPLES,     // integer

    BRAY_OBJ_DICING_QUALITY,    // <= 0[no dicing], 1[on m-p per pixel]

    /// @{
    /// @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_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_VISIBILITY_MASK,   // integer

    BRAY_OBJ_ENABLE_LOFT,
    BRAY_OBJ_LOFT_PTS_THRESH,
    BRAY_OBJ_TRACESETS,
    BRAY_OBJ_LIGHT_CATEGORIES,

    BRAY_OBJ_IS_MATTE,  // bool

    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_LIGHTSOURCE_SAMPLING_QUALITY,  // real

    BRAY_OBJ_SMOOTHP, // bool

    BRAY_OBJ_HD_RPRIM_ID, // int
    BRAY_OBJ_RENDER_MASK, // invisible, used only by karma delegate

    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_MAX_PROPERTIES,
    BRAY_CAMERA_INVALID_PROPERTY = BRAY_CAMERA_MAX_PROPERTIES
};

enum BRAY_LightProperty
{
    BRAY_LIGHT_ENABLE,          // bool
    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_AREA_MAP,        // string: environment map for sampling
    BRAY_LIGHT_SHADOW_COLOR,    // real[2]
    BRAY_LIGHT_SHADOW_DISTANCE, // real
    BRAY_LIGHT_MIS_BIAS,        // real [-1,1]
    BRAY_LIGHT_SAMPLING_QUALITY,// real
    BRAY_LIGHT_FORCE_UNIFORM_SAMPLING,  // bool
    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_BLUR,    // float (softness for distant lights)
    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_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_EXCLUDE_DCM,     // Exclude from deep camera images
    BRAY_PLANE_DISABLE,         // Disable the image plane
    BRAY_PLANE_SEPARATE_FILE,   // Filename to write image to
    BRAY_PLANE_DITHER,          // Dither for quantizing to integer values
    BRAY_PLANE_DEFAULT_VALUE,   // Default value for 1-channel planes

    BRAY_PLANE_MAX_PROPERTIES,
    BRAY_PLANE_INVALID_PROPERTY = BRAY_PLANE_MAX_PROPERTIES
};

/// Properties interpreted by the command line renderer
enum BRAY_CommandProperty
{
    BRAY_COMMAND_FRAME,                 // Start frame
    BRAY_COMMAND_FRAME_COUNT,           // Number of frames to render
    BRAY_COMMAND_FRAME_INC,             // Frame increment
    BRAY_COMMAND_CHECKPOINT,            // Seconds between checkpoint writes
    BRAY_COMMAND_TIMELIMIT,             // Time limit for rendering
    BRAY_COMMAND_TIMELIMIT_IMAGE,       // Time limit is specified per image
    BRAY_COMMAND_TIMELIMIT_NOSAVE_PARTIAL,      // Don't save WIP after timelimit

    BRAY_COMMAND_MAX_PROPERTIES,
    BRAY_COMMAND_INVALID_PROPERTY = BRAY_COMMAND_MAX_PROPERTIES
};

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

    BRAY_MAX_PROPERTY_TYPES,
    BRAY_INVALID_PROPERTY = BRAY_MAX_PROPERTY_TYPES
};

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

/// Look up the enum given a name.
BRAY_API extern const UT_StringHolder   &BRAYproperty(
                                                BRAY_PropertyType ty, int id);
BRAY_API extern int             BRAYproperty(BRAY_PropertyType ty,
                                        const char *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 char *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)
PROPERTY_LOOKUP(commandProperty, BRAY_COMMAND_PROPERTY, BRAY_CommandProperty)
#undef PROPERTY_LOOKUP

/// Lookup a property type by name
BRAY_API extern BRAY_PropertyType        BRAYpropertyType(const char *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:tilesize" -> {BRAY_SCENE_PROPERTY, BRAY_OPT_TILESIZE}
/// 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:
///     "tilesize" -> { BRAY_SCENE_PROPERTY, BRAY_OPT_TILESIZE }
///     "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; }
template <> inline constexpr size_t
BRAYmaxOptions<BRAY_CommandProperty>() { return BRAY_COMMAND_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; }
template <> inline constexpr BRAY_PropertyType
BRAYpropertyType<BRAY_CommandProperty>() { return BRAY_COMMAND_PROPERTY; }
/// @}


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
};
BRAY_API extern BRAY_LightType           BRAYlightType(const char *name);
BRAY_API extern const UT_StringHolder   &BRAYlightType(BRAY_LightType o);

// 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
};
BRAY_API extern BRAY_InteractionType     BRAYinteractionType(const char *name);
BRAY_API extern const UT_StringHolder   &BRAYinteractionType(
                                                BRAY_InteractionType t);

/// 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
};
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_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
{
    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),

    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_ANY_CAMERA = (BRAY_RAY_CAMERA | BRAY_PROXY_CAMERA | BRAY_GUIDE_CAMERA),
    BRAY_ANY_SHADOW = (BRAY_RAY_SHADOW | BRAY_PROXY_SHADOW | BRAY_GUIDE_SHADOW),

    BRAY_RAY_ALL        = 0xFFFF,

    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);

/// Material evaluation flags
enum BRAY_MaterialMask
{
    BRAY_MATMASK_NO_LIGHTSOURCE_EMISSION    = (1 << 0)
};

/// 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_INVALID
};
BRAY_API extern BRAY_Projection  BRAYprojection(const UT_StringRef &n);
BRAY_API extern const char      *BRAYprojection(BRAY_Projection t);

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_Pz,      // float: Pz (in space of camera)
    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_Ng,      // vector: geometric normal
    BRAY_RAYIMPORT_HIT_FLAGS,   // int: hit flags
    BRAY_RAYIMPORT_LEVEL,       // int: ray level
    BRAY_RAYIMPORT_HD_PRIM,     // int: hydra rprim id for selection
    BRAY_RAYIMPORT_HD_INST,     // int: hydra inst idx (0th level) for selection

    BRAY_RAYIMPORT_INVALID      // Not a valid ray import
};
BRAY_API extern BRAY_VexRayImport        BRAYrayImport(const UT_StringRef &n);
BRAY_API extern const char              *BRAYrayImport(BRAY_VexRayImport t);

/// 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_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_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_Pz,      1, 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_Ng,      3, false)
INSTANTIATE(BRAY_RAYIMPORT_HIT_FLAGS,   1, false)
INSTANTIATE(BRAY_RAYIMPORT_LEVEL,       1, false)

#undef INSTANTIATE

#endif