namespace RED

Namespace of all REDsdk interfaces and classes.

Classes:

class	AnimationClip
class	AnimationData
class	BoundingSphere
class	ChunkInterpretersDictionary
class	CID
class	Color
class	Factory
class	FastRandom
class	FileHeader
class	FileInfo
class	FileSystemTools
class	FrameStatistics
struct	GPUID
class	IAnimationClipController
class	IChunkSaver
class	ICloudsVolumeShape
class	IDataManager
class	IFont
class	IGeometryDatabase
class	IGICache
class	IGraphicDevice
class	IImage
class	IImage2D
class	IImage3D
class	IImageComposite
class	IImageCube
class	IImageReadback
class	ILicense
class	ILightShape
class	ILineShape
class	ImageTools
class	IMaterial
class	IMaterialController
class	IMaterialControllerProperty
class	IMeshShape
class	IMoonLightShape
class	IOptions
class	IOTools
class	IPhysicalLightShape
class	IPointShape
class	IREDFile
class	IREDObject
class	IReferenceManager
class	IReferenceSolving
class	IResourceManager
class	IShape
class	ISkeletalAnimationBlender
class	ISkeletalAnimationController
class	ISkyLightShape
class	ISoftBucket
class	ISoftLight
class	ISoftRayContext
class	ISoftRenderingContext
class	ISoftShaderContext
class	IStream
class	ISunLightShape
class	ITextShape
class	ITransformShape
class	IUserData
class	IViewpoint
class	IViewpointRenderList
class	IVolumeShape
class	IWindow
class	LayerSet
struct	LicenseTime
template< class Key, class Item > class	Map
class	Matrix
class	MemoryAllocator
class	MemoryLeakTracker
class	Mutex
class	Noise
class	Object
class	PassStatistics
class	PostProcess
class	Product
class	Quaternion
class	Random
class	RayCutoffShader
class	RayGIDiffuseShader
class	RayGIReflectionColorShader
class	RayGIRefractionColorShader
class	RayReflectionShader
class	RayRefractionShader
class	ReflectionShader
class	RenderCode
class	RenderLayer
class	RenderShader
class	RenderShaderAAFilter
class	RenderShaderAmbient
class	RenderShaderAnisotropic
class	RenderShaderData
class	RenderShaderEdges
class	RenderShaderEnvironmental
class	RenderShaderLambert
class	RenderShaderLogo
class	RenderShaderParameter
class	RenderShaderPhong
class	RenderShaderRefractionEffect
class	RenderShaderSectionCut
class	RenderShaderSolid
class	RenderShaderText
class	RenderShaderVertexColor
class	RenderShaderViewport
class	RNG
class	Shader
class	ShaderProgramID
class	ShaderString
class	ShapePath
class	SoftFrameBufferSample
class	State
class	StateShader
class	StateShaderPlatformData
class	StreamingPolicy
class	String
class	Thread
class	Timer
class	UserData
class	UserDataRaw
template< class T > class	Vector
class	Vector3
class	Vector4
class	Version
class	ViewpointStatistics
class	VolumetricEffect
class	VolumetricEffectBoxVolume
class	VolumetricEffectClouds
class	VolumetricEffectLightVolume
class	WindowRenderInfo

Functions:

RED_RC REDFullExp	GetREDErrorMessage ( RED::String & oErrorMessage, RED_RC iRC )
void REDFullExp	REDBreak ( RED_RC iRC, const char * iCaller, const void * iObject, const char * iExpression, const char * iInfo )

Enumerations:

enum	AA_FILTER { AA_NOTHING = 0, AA_AREA_FXAA = 1 }
enum	ACCESS_MODE { AM_READ = 1, AM_WRITE = 2, AM_READWRITE_OVER = 3, AM_READWRITE_APPEND = 4 }
enum	ATTENUATION { ATN_LINQUA = 1, ATN_DMAX2 = 2, ATN_NONE = 3, ATN_LINEAR = 4, ATN_QUADRATIC = 5, ATN_CUBIC = 6, ATN_N3DSMAX = 7, ATN_L3DSMAX = 8, ATN_Q3DSMAX = 9 }
enum	BSDF_EVENT { BSDF_EVENT_UNDEFINED = 0x0000, BSDF_EVENT_DIFFUSION = 0x0001, BSDF_EVENT_REFLECTION = 0x0002, BSDF_EVENT_TRANSMISSION = 0x0004, BSDF_EVENT_ABSORPTION = 0x0008, BSDF_EVENT_ALL = 0xffff }
enum	BSDF_REQUEST { BSDF_REQUEST_UNDEFINED = 0, BSDF_REQUEST_EVAL = 1, BSDF_REQUEST_PDF = 2, BSDF_REQUEST_EMITTED = 3, BSDF_REQUEST_SAMPLE = 4 }
enum	CHANNEL { CHN_RED = 0, CHN_GREEN = 1, CHN_BLUE = 2, CHN_ALPHA = 3 }
enum	CLOUDS_TYPE { CT_CUMULUS = 0, CT_STRATUS = 1, CT_CIRRUS_1 = 2, CT_CIRRUS_2 = 3, CT_CIRRUS_3 = 4, CT_CIRRUS_4 = 5, CT_CIRRUS_5 = 6 }
enum	CLUSTER_GPU_TIME { CGT_INIT = 0, CGT_EVENT_HANDLING = 1, CGT_STREAMS_UPDATES = 2, CGT_BATCHES_UPDATES = 3, CGT_FONTS_UPDATE = 4, CGT_CUBES_UPDATE = 5, CGT_ALL = 6, CGT_SIZE = 7 }
enum	DRIVER_VALIDATION { DR_OK = 0, DR_OK_NEWER = 1, DR_NOT_CERTIFIED = 2, DR_KNOWN_ERRORS = 3, DR_NO_DRIVER_INSTALLED = 4, DR_OK_SOFTWARE_RENDERING = 5 }
enum	ENV_TYPE { ENV_SPHERICAL = 0, ENV_CYLINDRICAL = 1, ENV_HEMISPHERICAL = 2 }
enum	FILTER_MODE { FM_LINEAR = 1, FM_NEAREST = 2 }
enum	FONT_CHARSET { FNT_DEFAULT_CHARSET = 0, FNT_ANSI_CHARSET = 1, FNT_SYMBOL_CHARSET = 2, FNT_SHIFTJIS_CHARSET = 3, FNT_HANGEUL_CHARSET = 4, FNT_HANGUL_CHARSET = 5, FNT_GB2312_CHARSET = 6, FNT_CHINESEBIG5_CHARSET = 7, FNT_JOHAB_CHARSET = 8, FNT_HEBREW_CHARSET = 9, FNT_ARABIC_CHARSET = 10, FNT_GREEK_CHARSET = 11, FNT_TURKISH_CHARSET = 12, FNT_VIETNAMESE_CHARSET = 13, FNT_THAI_CHARSET = 14, FNT_EASTEUROPE_CHARSET = 15, FNT_MAC_CHARSET = 16, FNT_BALTIC_CHARSET = 17 }
enum	FONT_RENDER_MODE { FNT_UNKNOWN = 0, FNT_BITMAP = 1, FNT_TRIANGLE = 2, FNT_LINE = 3, FNT_TEXTURE = 4 }
enum	FONT_TYPE { FNT_UNDEFINED = 0, FNT_SYSTEM = 1, FNT_CUSTOM = 2 }
enum	FORMAT { FMT_NODATA = 0, FMT_RGBA = 1, FMT_RGB = 2, FMT_FLOAT = 3, FMT_FLOAT_RGBA = 4, FMT_FLOAT_RGB = 5, FMT_L8 = 6, FMT_A8 = 7, FMT_RGBA_DXT1 = 8, FMT_RGBA_DXT3 = 9, FMT_RGBA_DXT5 = 10, FMT_RGB_DXT1 = 11, FMT_HALF_FLOAT = 12, FMT_HALF_FLOAT_RGBA = 13, FMT_HALF_FLOAT_RGB = 14, FMT_FLOAT_RGBA_AA = 15 }
enum	FRAME_TRACING_FEEDBACK { FTF_BY_BLOCKS = -1, FTF_BY_SURFACE_LEVEL_0 = 0, FTF_BY_SURFACE_LEVEL_1 = 1, FTF_BY_SURFACE_LEVEL_2 = 2, FTF_BY_SURFACE_LEVEL_3 = 3, FTF_BY_SURFACE_LEVEL_4 = 4, FTF_BY_SURFACE_LEVEL_5 = 5, FTF_BY_BLOCKS_LEVEL_0 = 6, FTF_BY_BLOCKS_LEVEL_1 = 7, FTF_BY_BLOCKS_LEVEL_2 = 8, FTF_BY_BLOCKS_LEVEL_3 = 9, FTF_BY_BLOCKS_LEVEL_4 = 10, FTF_BY_BLOCKS_LEVEL_5 = 11, FTF_PATH_TRACING = 12 }
enum	GI_CACHE_MODE { GICM_CAMERA_VIEW = 0, GICM_CAMERA_SPHERICAL = 1, GICM_WORLD = 2 }
enum	GREY_OPERATION { GOP_GGG1 = 0, GOP_GGGG = 1, GOP_000G = 2, GOP_111G = 3, GOP_XXXG = 4, GOP_GGGX = 5 }
enum	HARDWARE_PLATFORM { HW_GENERIC = 0x00000000, HW_NVIDIA_GENERIC = 0x00000001, HW_NVIDIA_NV30 = 0x00000002, HW_NVIDIA_NV40 = 0x00000004, HW_NVIDIA_G80 = 0x00000008, HW_NVIDIA_G200 = 0x00000010, HW_NVIDIA_G400 = 0x00000020, HW_ATI_GENERIC = 0x00000100, HW_ATI_R300 = 0x00000200, HW_ATI_R400 = 0x00000400, HW_ATI_R500 = 0x00000800, HW_ATI_R600 = 0x00001000, HW_ATI_R700 = 0x00002000, HW_ATI_R800 = 0x00004000, HW_INTEL_GENERIC = 0x00010000, HW_INTEL_GMA_3000 = 0x00020000, HW_INTEL_GMA_4000 = 0x00040000, HW_INTEL_GMA_GEN7 = 0x00080000, HW_SOFT_TRACER = 0x00100000, HW_USER_GENERIC = 0x01000000, HW_USER_01 = 0x02000000, HW_USER_02 = 0x04000000, HW_USER_03 = 0x08000000, HW_VIRTUAL_GENERIC = 0x10000000, HW_VIRTUAL_01 = 0x20000000, HW_VIRTUAL_02 = 0x40000000, HW_VIRTUAL_03 = 0x80000000 }
enum	HOST_PRODUCT { HPROD_UNKNOWN = 0, HPROD_AUTODESK_MAX = 1, HPROD_AUTODESK_VIZ = 2 }
enum	IO_FBX_FILE_VERSION { IOFV_DEFAULT = 0, IOFV_2010 = , IOFV_2011 = , IOFV_2012 = , IOFV_2013 = , IOFV_2014 = , IOFV_2016 = }
enum	IO_LOAD_MATERIAL_TYPE { IOLMT_GENERIC = 0, IOLMT_REALISTIC = 1 }
enum	IO_LOAD_TEXTURE_TRANSPARENCY { IOLTT_ALPHA = 0, IOLTT_RGB = 1 }
enum	IO_OBJECT_TYPE { IOOT_NODE = 0x0001, IOOT_MESH = 0x0002, IOOT_LINE = 0x0004, IOOT_MATERIAL = 0x0008, IOOT_TEXTURE = 0x0010, IOOT_LIGHT = 0x0020, IOOT_VIEWPOINT = 0x0040, IOOT_SKINNING = 0x0080, IOOT_ANIMATION = 0x0100, IOOT_ALL = 0xFFFF }
enum	IO_SYSTEM_UNIT { IOSU_MM = 0, IOSU_CM = 1, IOSU_DM = 2, IOSU_M = 3, IOSU_KM = 4, IOSU_INCH = 5, IOSU_FOOT = 6, IOSU_MILE = 7, IOSU_YARD = 8 }
enum	LAYER_MODE { LRM_ALPHA_PLUS_ONE_MINUS_ALPHA = 0, LRM_ONE_PLUS_ONE_MINUS_ALPHA = 1 }
enum	LIGHT_TYPE { LT_NONE = , LT_AMBIENT = , LT_DIRECTIONAL = , LT_POINT = , LT_POINT_SPOT = , LT_BEAM = , LT_AREA = , LT_AREA_SPOT = , LT_SUN = , LT_SKY = , LT_PHYSICAL = , LT_MOON = }
enum	LIST_POS { LIST_LAST = -1, LIST_FIRST = 0 }
enum	MATERIAL_PASS { MTL_PRELIT = 0x0001, MTL_LIT = 0x0002, MTL_POSTLIT = 0x0004, MTL_RAYTRACE = 0x0008, MTL_INDIRECT_PRELIT = 0x0010, MTL_INDIRECT_LIT = 0x0020, MTL_INDIRECT_POSTLIT = 0x0040, MTL_ALL = 0x007f, MTL_INTERNAL = 0x1000 }
enum	MESH_CHANNEL { MCL_VERTEX = 0, MCL_USER0 = 1, MCL_NORMAL = 2, MCL_COLOR = 3, MCL_USER1 = 4, MCL_USER2 = 5, MCL_USER3 = 6, MCL_USER4 = 7, MCL_TEX0 = 8, MCL_TEX1 = 9, MCL_TEX2 = 10, MCL_TEX3 = 11, MCL_TEX4 = 12, MCL_TEX5 = 13, MCL_TEX6 = 14, MCL_TEX7 = 15, MCL_SIZE = 16 }
enum	MESH_FORMAT { MFT_ZERO = 0, MFT_UBYTE = 1, MFT_SHORT = 2, MFT_INT = 3, MFT_FLOAT = 4, MFT_DOUBLE = 5, MFT_HALF_FLOAT = 6 }
enum	MESH_TEXCOORD_MAPPING { MTCM_PLANAR = 0, MTCM_SPHERICAL = 1, MTCM_CYLINDRICAL = 2, MTCM_CYLINDRICAL_CAP = 3, MTCM_BOX = 4 }
enum	OPERATING_SYSTEM { OS_NOT_SUPPORTED = 0, OS_WIN_2000 = 1, OS_WIN_XP_32 = 2, OS_WIN_XP_64 = 3, OS_WIN_VISTA_32 = 4, OS_WIN_VISTA_64 = 5, OS_WIN_SEVEN_32 = 6, OS_WIN_SEVEN_64 = 7, OS_WIN_EIGHT_32 = 8, OS_WIN_EIGHT_64 = 9, OS_WIN_TEN_32 = 10, OS_WIN_TEN_64 = 11, OS_LIN_32 = 12, OS_LIN_64 = 13, OS_MAC_OSX_64 = 14 }
enum	OPTION_VALUE_FORMAT { OPT_UNKNOWN = 0, OPT_BOOLEAN = 1, OPT_DOUBLE = 2, OPT_INTEGER = 3 }
enum	OPTIONS { OPTIONS_RAY_PRIMARY = 0x00000001, OPTIONS_RAY_SHADOWS = 0x00000002, OPTIONS_RAY_REFLECTIONS = 0x00000003, OPTIONS_RAY_REFRACTIONS = 0x00000004, OPTIONS_RAY_TRANSPARENCY = 0x00000005, OPTIONS_RAY_REFRACTIONS_BACK = 0x00000006, OPTIONS_RAY_MAX_THREADS = 0x00000007, OPTIONS_RAY_CUTOFF = 0x00000008, OPTIONS_RAY_ENABLE_GLOSSY_EFFECTS = 0x00000009, OPTIONS_RAY_ENABLE_AREA_SAMPLING = 0x0000000A, OPTIONS_RAY_ENABLE_SOFT_TRACER = 0x0000000B, OPTIONS_RAY_ENABLE_CAUSTICS = 0x0000000C, OPTIONS_RAY_CAUSTICS_SAMPLING_RATE = 0x0000000D, OPTIONS_RAY_CAUSTICS_SEARCH_RADIUS = 0x0000000E, OPTIONS_RAY_CAUSTICS_SEARCH_COUNT = 0x0000000F, OPTIONS_RAY_LIGHTS_SAMPLING_RATE = 0x00000010, OPTIONS_RAY_GLOSSY_SAMPLING_RATE = 0x00000011, OPTIONS_RAY_VOLUME = 0x00000012, OPTIONS_RAY_DISPLACEMENT = 0x00000013, OPTIONS_RAY_USE_EMBREE = 0x00000014, OPTIONS_RAY_FORCE_EMBREE = 0x00000015, OPTIONS_RAY_ENABLE_OPEN_IMAGE_DENOISE = 0x00000016, OPTIONS_VIEWPOINT_PICKABLE = 0x00000020, OPTIONS_SHADOW_MAP_DEPTH = 0x00000021, OPTIONS_POLYGON_FILL_MODE = 0x00000022, OPTIONS_SHADOW_MAP_TRANSPARENCY = 0x00000023, OPTIONS_AUTO_CUBE_ENV_SIZE = 0x00000024, OPTIONS_AUTO_CUBE_ENV_UPDATE_MODE = 0x00000025, OPTIONS_AUTO_CUBE_ALLOW_RAYTRACER = 0x00000026, OPTIONS_GI_CACHE_TRANSPAR_DRAW = 0x00000027, OPTIONS_MATERIAL_LAYER_INTERSECT = 0x00000028, OPTIONS_TONE_MAPPING_IGNORE_BACKGROUND = 0x00000029, OPTIONS_VIEWPOINT_ORTHOGRAPHIC_EYE_AUTO_OFFSET = 0x0000002A, OPTIONS_REFRESH_INSTANCE_COUNTERS = 0x0000002B, OPTIONS_WINDOW_HDR = 0x00000030, OPTIONS_WINDOW_PICK_AREA = 0x00000031, OPTIONS_WINDOW_PICK_AREA_TRIANGLE = 0x00000032, OPTIONS_WINDOW_DRAW_SYNC = 0x00000033, OPTIONS_DATA_RELEASE_TIMER = 0x00000040, OPTIONS_IMMEDIATE_MODE = 0x00000041, OPTIONS_LIGHT_CUTOFF = 0x00000042, OPTIONS_FORCE_STENCIL = 0x00000043, OPTIONS_SAMPLER = 0x00000044, OPTIONS_FORCE_COMPRESSED_IMAGES_INTEL = 0x00000045, OPTIONS_OPENGL_CONTEXT_MAJOR = 0x00000046, OPTIONS_OPENGL_CONTEXT_MINOR = 0x00000047, OPTIONS_OPENGL_CONTEXT_DEBUG = 0x00000048, OPTIONS_RAY_GI = 0x00000050, OPTIONS_RAY_GI_ERROR = 0x00000051, OPTIONS_RAY_GI_ESTIMATOR_SAMPLING_RATE = 0x00000052, OPTIONS_RAY_GI_CACHE_PASSES_COUNT = 0x00000054, OPTIONS_RAY_GI_CACHE_HEMI_SAMPLING_RATE = 0x00000055, OPTIONS_RAY_GI_CACHE_INTERP_SAMPLES_COUNT = 0x00000056, OPTIONS_RAY_GI_SHOW_SAMPLES = 0x0000005A, OPTIONS_RAY_GI_ENABLE_VOLUME = 0x0000005B, OPTIONS_RAY_GI_CACHE_PRECISE = 0x0000005C, OPTIONS_RAY_GI_FOR_GLOSSINESS = 0x0000005D, OPTIONS_RAY_GI_FOR_LIGHTING = 0x0000005E, OPTIONS_RAY_SOFT_SHADOW_MAP_TRANSPARENCY = 0x00000060, OPTIONS_RAY_AREA_SHADOW_SPACING = 0x00000061, OPTIONS_RAY_AREA_SHADOW_SPREAD = 0x00000062, OPTIONS_RAY_CONTEXT_CALLBACK_PERSISTENCE = 0x00000063, OPTIONS_RAY_FORCE_TRANSPARENCY = 0x00000064, OPTIONS_RAY_SOFT_PREVIEW = 0x00000065, OPTIONS_RAY_WORLD_CACHE_SAMPLES_COUNT = 0x00000066, OPTIONS_RAY_WORLD_CACHE_SAMPLES_SPREAD = 0x00000067, OPTIONS_RAY_TRANSPARENCY_TOLERANCE_GPU = 0x00000068, OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD = 0x00000069, OPTIONS_RAY_MAX_SECONDARY_RAY_INTENSITY = 0x0000006A, OPTIONS_RAY_ENABLE_DENOISER = 0x0000006B, OPTIONS_RAY_DENOISER_STRENGTH = 0x0000006C, OPTIONS_RAY_DENOISER_RADIUS = 0x0000006D, OPTIONS_RAY_TRANSPARENCY_FFP_GPU = 0x0000006E, OPTIONS_RAY_ADAPTIVE_SAMPLING_ALLOWED_TIME = 0x0000006F, OPTIONS_PATH_GI = 0x00000070, OPTIONS_RAY_GI_ESTIMATOR_FULL_PATH = 0x00000071 }
enum	PLATFORM { PTM_UNKNOWN = -1, PTM_WINDOWS = 0, PTM_LINUX = 1, PTM_MACOS = 2, PTM_COUNT = 3 }
enum	POLYGON_WINDING_RULE { PWR_ODD = 0, PWR_NON_ZERO = 1, PWR_POSITIVE = 2, PWR_NEGATIVE = 3, PWR_ABS_GEQ_TWO = 4 }
enum	PRODUCT { PROD_UNKNOWN = -1, PROD_REDEXPORTER_MAX = 0, PROD_REDODADEVICE = 1, PROD_REDSDK = 2, PROD_REDPARASOLID = 3, PROD_REDMATERIALEDITOR = 4, PROD_REDC3D = 5, PROD_REDNET = 6, PROD_REDART = 7, PROD_COUNT = 8 }
enum	PROPERTY_TYPE { PYT_UNDEFINED = 0, PYT_FLOAT = 1, PYT_INTEGER = 2, PYT_BOOLEAN = 3, PYT_COLOR = 4, PYT_TEXTURE2D = 5, PYT_STRING = 6, PYT_TEXTURE3D = 7, PYT_TEXTURECUBE = 8, PYT_VECTOR4 = 9, PYT_LAYERSET = 10, PYT_TEXTURECOMPOSITE = 11 }
enum	RENDER_MODE { RM_SHADOW_CASTER = 0, RM_TEX_INTENSITY_RAMP_RES = 1, RM_TEX_CUBEMAP_SPOT_RES = 2, RM_TEX_RADIAL_BEAM_RES = 3, RM_SHADOW_MAP = 4, RM_ACTIVATED = 5, RM_DOUBLE_SIDED = 6, RM_CAUSTICS = 7, RM_VISIBLE_GEOMETRY = 8, RM_DEFINE_VOLUME = 9, RM_ENLIGHTEN_VOLUME = 10, RM_BAKED = 11, RM_SINGLE_SIDED_BIAS = 12, RM_USE_EXACT_LIGHT_PROB = 13, RM_USE_MIS = 14, RM_COUNT = 15 }
enum	RENDERING_PASS { RPA_UNDEFINED_PASS = 0, RPA_CONTEXT_CULLING = 1, RPA_VISIBILITY_CULLING = 2, RPA_LIGHT_CULLING = 3, RPA_RAY_DATABASE_UPDATE = 4, RPA_PRELIT_OPAQUE = 5, RPA_PRELIT_TRANSPAR = 6, RPA_LIT_OPAQUE = 7, RPA_LIT_TRANSPAR = 8, RPA_POSTLIT_OPAQUE = 9, RPA_POSTLIT_TRANSPAR = 10, RPA_COMPOSITE_IMAGE = 11, RPA_SHADOW_MAP_OPAQUE = 12, RPA_SHADOW_MAP_TRANSPAR = 13, RPA_GI_CACHE_OPAQUE = 14, RPA_GI_CACHE_TRANSPAR = 15, RPA_INDIRECT_PRELIT_OPAQUE = 16, RPA_INDIRECT_PRELIT_TRANSPAR = 17, RPA_INDIRECT_LIT_OPAQUE = 18, RPA_INDIRECT_LIT_TRANSPAR = 19, RPA_INDIRECT_POSTLIT_OPAQUE = 20, RPA_INDIRECT_POSTLIT_TRANSPAR = 21, RPA_INDIRECT_SHADOW_MAP_OPAQUE = 22, RPA_INDIRECT_SHADOW_MAP_TRANSPAR = 23, RPA_INDIRECT_BACKGROUND = 24, RPA_GPU_RAY_TRANSPARENCY = 25, RPA_GPU_RAY_TID = 26, RPA_GPU_RAY_POSITIONS = 27, RPA_GPU_RAY_DIRECTIONS = 28, RPA_GPU_RAY_NORMALS = 29, RPA_GPU_RAY_CUTOFF = 30, RPA_SIZE = 31 }
enum	RENDERING_PROGRESS_STEP { RPS_RENDER_NOT_STARTED = 0, RPS_GI_ESTIMATOR_PROCESSING = 1, RPS_GI_CACHE_PROCESSING = 2, RPS_CAUSTICS_PROCESSING = 3, RPS_RAY_TRACING_PROCESSING = 4, RPS_DENOISER_PROCESSING = 5, RPS_HARDWARE_RENDERING = 6, RPS_RENDER_COMPLETE = 7, RPS_WORLD_GI_CACHE_PROCESSING = 8, RPS_SIZE = 9 }
enum	ROOT_MOTION_COMPONENT { RMC_ROTATION = 0, RMC_POSITION_X = , RMC_POSITION_Y = , RMC_POSITION_Z = }
enum	ROOT_MOTION_POLICY { RMP_DEFAULT = 0, RMP_CUMULATIVE = , RMP_DELTA = , RMP_ZERO = }
enum	RSV_TYPE { RSV_TRIANGLE = 1, RSV_LINE = 2, RSV_TRIANGLE_UBYTE_NORMALS = 3 }
enum	SOFT_GEOMETRY_PRIMITIVE { GEO_UNMODIFIED = 0, GEO_POINTS = 1, GEO_LINE_SEGMENTS = 2, GEO_LINE_SEGMENTS_ADJACENCY = 3, GEO_LINE_STRIP = 4, GEO_TRIANGLES = 5, GEO_TRIANGLES_ADJACENCY = 6 }
enum	TARGET { TGT_NONE = 0, TGT_TEX_1D = 1, TGT_TEX_2D = 2, TGT_TEX_RECT = 3, TGT_TEX_CUBE = 4, TGT_TEX_3D = 5 }
enum	TEXT_ALPHA_MODE { TEXT_ALPHA_LINEAR = 0, TEXT_ALPHA_3A2_MINUS_2A3 = 1, TEXT_ALPHA_SQRTA = 2, TEXT_ALPHA_LINEAR_DEPTH = 3, TEXT_ALPHA_3A2_MINUS_2A3_DEPTH = 4, TEXT_ALPHA_SQRTA_DEPTH = 5 }
enum	TEXT_ATTACH_POS { TAP_TOP_LEFT = 1, TAP_TOP = 2, TAP_TOP_RIGHT = 3, TAP_RIGHT = 4, TAP_BOTTOM_RIGHT = 5, TAP_BOTTOM = 6, TAP_BOTTOM_LEFT = 7, TAP_LEFT = 8, TAP_CENTER = 9, TAP_BASELINE_LEFT = 10, TAP_BASELINE_CENTER = 11, TAP_BASELINE_RIGHT = 12, TAP_TOP_LEFT_EDGE = 13, TAP_BOTTOM_LEFT_EDGE = 14, TAP_LEFT_EDGE = 15, TAP_BASELINE_LEFT_EDGE = 16 }
enum	THREAD_PRIORITY { TP_LOWEST = 0, TP_LOW = 1, TP_NORMAL = 2, TP_HIGH = 3, TP_HIGHEST = 4 }
enum	TONEMAPPING_OPERATOR { TMO_CLAMP = 0x00, TMO_PHOTOGRAPHIC = 0x01, TMO_NEUTRAL = 0x02, TMO_EXPOSURE = 0x03, TMO_EXPONENTIAL = 0x04 }
enum	TRANSACTION_MODE { TRANSACTION_OUT = -1, TRANSACTION_IN = 0 }
enum	VIEWPOINT_TYPE { VPT_PARALLEL = 0x01, VPT_PERSPECTIVE = 0x02, VPT_CUSTOM = 0x03 }
enum	VRL_SIZEPOS { VSP_ANCHOR_FIXED = 1, VSP_ANCHOR_STRETCHED = 2, VSP_SIZE_FIXED = 4, VSP_SIZE_STRETCHED = 8, VSP_SIZE_STRETCHED_AUTO_RATIO = 16 }
enum	VRL_SORT { VST_FRONT = 0, VST_SCENE = 1, VST_BACK = 2 }
enum	WRAP_MODE { WM_REPEAT = 1, WM_MIRRORED_REPEAT = 2, WM_CLAMP = 3, WM_CLAMP_TO_EDGE = 4, WM_CLAMP_TO_BORDER = 5 }

Typedefs:

typedef void(*	BATCH_SYNC_CALLBACK )(void *iUserData)
typedef RED_RC(*	IChunkInterpreterProto )(RED::IReferenceManager iReferenceManager, RED::IStream iStream, const RED::StreamingPolicy &iPolicy, unsigned int iChunkSignature, RED::uint64 iChunkSize, RED::Object **oResult, const RED::State &iState)
typedef RED_RC(*	IMAGE_TOOLS_LOAD_CALLBACK )(RED::Object *oImage, const RED::String &iFilePath, RED::FORMAT iPixelFormat, bool iVerticalFlip, bool iLocalStorage, RED::TARGET iTarget, const RED::State &iState)
typedef RED_RC(*	INSTANCE_COUNTER_CALLBACK )(RED::Vector4 &oReferenceValue, int iUid, const RED::Vector< RED::Object * > &iInstancePath, void *iUserData)
typedef RED_RC(*	INSTANCE_COUNTER_IMAGE_CALLBACK )(RED::Object &oReferenceValue, int iUid, const RED::Vector< RED::Object > &iInstancePath, void *iUserData)
typedef unsigned	int (__stdcall THREAD_CALLBACK)(void iThreadClass)
typedef int __w64	int64
typedef bool(*	INTERRUPT_CALLBACK )(void *iUserData)
typedef void(*	LoadChunkNotificationCallback )(RED::uint64 iSize, void *iParameter)
typedef void(*	OPENGL_BUFFER_CALLBACK )(void *iUser)
typedef void(*	OPENGL_MATERIAL_CALLBACK )(RED::Object iWindow, RED::Object iVRL, RED::Object iViewpoint, RED::Object iMaterial, RED::MATERIAL_PASS iPass, RED::Object iLight, unsigned int iShaderID, void iUser)
typedef void(*	OPENGL_VIEWPOINT_CALLBACK )(RED::Object iWindow, RED::Object iVRL, RED::Object iViewpoint, void iUser)
typedef void(*	ProgressCallback )(const RED::String &iMessage, float iProgression, void *iUserData)
typedef void(*	REDSDK_ERROR_CALLBACK )(RED_RC iRC, const char iCaller, const void iObject, const char iExpression, const char iInfo, void *iUser)
typedef RED_RC(*	RENDERING_PROGRESS_CALLBACK )(const RED::FrameStatistics &iFrameStatistics, void *iUserData)
typedef RED_RC(*	SOFT_BUCKET_CALLBACK )(const RED::Object iViewpoint, RED::ISoftBucket ioISoftBucket, void *ioUserData)
typedef RED_RC(*	SOFT_GEOMETRY_SHADER )(RED::Vector< double >(&oVertexAttrib)[RED_VSH_NB_INPUTS], RED_VSH_INPUT(&oChannels)[RED_VSH_NB_INPUTS], int &oChannelsCount, RED::Vector< int > &oPrimitives, RED::SOFT_GEOMETRY_PRIMITIVE &oType, void (iVertexAttrib[RED_VSH_NB_INPUTS]), RED::MESH_FORMAT iFormat[RED_VSH_NB_INPUTS], int iSize[RED_VSH_NB_INPUTS], int iVerticesCount, int iIndex, int iCount, RED::SOFT_GEOMETRY_PRIMITIVE &iType, const double iProgramLocal, const double iModelViewMatrix, const double iModelViewProjMatrix, const double iModelMatrix)
typedef RED_RC(*	SOFT_PIXEL_ANALYSIS_CALLBACK )(bool &oNext, const RED::ISoftRayContext &iRayContext, const RED::ISoftRenderingContext &iRenderingContext, void *iUser)
typedef bool(*	SOFT_RAY_PROCESSING_INTERSECTION_CALLBACK )(double &oTHit, double &oTHit1, double &oTHit2, const double iE[3], const double iP[3], double iTIn, const RED::LayerSet iLayerSet, int iNumThread, void ioUserData)
typedef RED_RC(*	SOFT_RAY_PROCESSING_SHADING_CALLBACK )(double oDataChannel[RED::MCL_SIZE][4], double oGeoNormal[4], RED::Object &oMaterial, RED::LayerSet &oLayerSet, double iTHit, double iTHit1, double iTHit2, const double iE[3], const double iP[3], int iNumThread, void *ioUserData)
typedef RED_RC(*	SOFT_SHADER_CALLBACK )(RED::SoftFrameBufferSample &ioFrameBufferSample, const RED::ISoftRayContext &iRayContext, const RED::ISoftShaderContext &iShaderContext, const RED::ISoftRenderingContext &iRenderingContext, const RED::Version &iVersion, void *iUserData)
typedef unsigned int __w64	uint64
typedef RED_RC(*	USER_SWITCH_CALLBACK )(const RED::Object iViewpoint, const RED::Object iShape, RED::Vector< int > &iSelectedChildren, void *iUserData, int iStateNumber)

Functions documentation

RED_RC REDFullExp RED::GetREDErrorMessage	(	RED::String &	oErrorMessage,
		RED_RC	iRC
	)

Gets an error message for a given RED_RC error code.

The method returns a string message in oErrorMessage filled with an explanatory text based on the value of iRC. The text is written in plain english, using standard ascii characters. Text lines are around 80 characters wide.
The audience of these messages are developpers. The message is mainly a simplified version of the return code documentation, provided for convenience.

Parameters:

oErrorMessage:	The returned error message string.
iRC:	The return code to translate.

Returns:

RED_OK if the function has succeeded,
RED_BAD_PARAM if iRC is not recognized,
RED_ALLOC_FAILURE if we can't allocate oErrorMessage.

void REDFullExp RED::REDBreak	(	RED_RC	iRC,
		const char *	iCaller,
		const void *	iObject,
		const char *	iExpression,
		const char *	iInfo
	)

Internal error break routine.

Parameters:

iRC:	Error code.
iCaller:	Name of the calling method or function.
iObject:	Relevant object address for the error.
iExpression:	Called source expression string.
iInfo:	Extra information string.

Enumerations documentation

enum RED::AA_FILTER

Enumerator:

AA_NOTHING	enum AA_FILTER Lists all built-in post filters of the RED::RenderShaderAAFilter. Anti-aliasing post filter that does nothing. It can be used to act as a pass-through of the input image without modifying it.
AA_AREA_FXAA	Anti-aliasing post filter based on the original FXAA algorithm from NVIDIA.

enum RED::ACCESS_MODE

This enumeration lists all stream read / write modes.

Enumerator:

AM_READ	The stream will be accessed in read only mode.
AM_WRITE	The stream will be accessed in write only mode. Existing data will be overwritten.
AM_READWRITE_OVER	The stream will be accessed in read-write mode. If the stream already exists, it will be overwritten.
AM_READWRITE_APPEND	The stream will be accessed in read-write mode. If the stream already exists: 1. data will be appended at the end of it if it is a file stream 2. data will be appended after the most recently written data if it is a memory stream. In order to append data at the end of the memory stream instead, use the Move method to set the writing cursor position at the end of the stream.

enum RED::ATTENUATION

Lists all the built-in attenuation equations that can be used by the light source. Parameters that are mentioned must be supplied to through RED::ILightShape::SetAttenuation or through a built-in construction helper such as RED::ILightShape::SetPointLight. See the section Decay equations to learn about the various attenuation modes and settings.

Enumerator:

ATN_LINQUA	I = 1/(1+ klind + kquad^2), where klin is the linear attenuation factor, kqua the quadratic attenuation factor and d is the distance between the point being lit and the light source.
ATN_DMAX2	I = 1-(d/dmax)^2, where d is the distance between the point being lit and the light source, and dmax an attenuation distance.
ATN_NONE	The light intensity does not decrease as the lit point goes farther from the light.
ATN_LINEAR	I = Imax/d equation. d is the distance between the lit point and the light source.
ATN_QUADRATIC	I = Imax/(d*d) equation. d is the distance between the lit point and the light source.
ATN_CUBIC	I = Imax/(ddd) equation. d is the distance between the lit point and the light source.
ATN_N3DSMAX	No attenuation due to distance, but near and far attenuation can still be used (specific to 3DS Max software).
ATN_L3DSMAX	A linear-like attenuation, I = min(1,att[0]/d). (specific to 3DS Max software).
ATN_Q3DSMAX	A quadratic-like attenuation, I = min(1,(att[0] * att[0])/(d * d)). (specific to 3DS Max software).

enum RED::BSDF_EVENT

Enumerator:

BSDF_EVENT_UNDEFINED
BSDF_EVENT_DIFFUSION
BSDF_EVENT_REFLECTION
BSDF_EVENT_TRANSMISSION
BSDF_EVENT_ABSORPTION
BSDF_EVENT_ALL

enum RED::BSDF_REQUEST

Enumerator:

BSDF_REQUEST_UNDEFINED
BSDF_REQUEST_EVAL
BSDF_REQUEST_PDF
BSDF_REQUEST_EMITTED
BSDF_REQUEST_SAMPLE

enum RED::CHANNEL

Identification of an image channel. An image that has a single channel is considered as a RED::CHN_RED channel image.

Enumerator:

CHN_RED	Red pixel component of an image.
CHN_GREEN	Green pixel component of an image.
CHN_BLUE	Blue pixel component of an image.
CHN_ALPHA	Alpha pixel component of an image.

enum RED::CLOUDS_TYPE

Defines the type of a clouds layer in the sky (see List of REDsdk clouds type).

Enumerator:

CT_CUMULUS	Puffy clouds with high density and clearly defined edges.
CT_STRATUS	Flat hazy clouds with low density.
CT_CIRRUS_1	Thin, wispy clouds visible at high altitude, model 1.
CT_CIRRUS_2	Thin, wispy clouds visible at high altitude, model 2.
CT_CIRRUS_3	Thin, wispy clouds visible at high altitude, model 3.
CT_CIRRUS_4	Thin, wispy clouds visible at high altitude, model 4.
CT_CIRRUS_5	Thin, wispy clouds visible at high altitude, model 5.

enum RED::CLUSTER_GPU_TIME

Lists all available timers for the time spent during the GPU update for REDsdk.

Enumerator:

CGT_INIT	Initialization sequence of the GPU cluster update.
CGT_EVENT_HANDLING	Time spent parsing and handling changes resulting of the list of events received for the REDsdk transaction being closed and that triggered the GPU cluster update.
CGT_STREAMS_UPDATES	Time spent updating GPU scene streams. This is the internal REDsdk view of all scene graphs.
CGT_BATCHES_UPDATES	Time spent updating GPU data containing geometry batches. A geometry batch update is triggered by the update of shapes contents ( changes in RED::MESH_CHANNEL contents ).
CGT_FONTS_UPDATE	Time spent updating modified fonts.
CGT_CUBES_UPDATE	Time spent updating dynamic cube maps.
CGT_ALL	This is the total time spending in cluster GPU update. E.g. the sum of all other timers.
CGT_SIZE	Size of this enumeration.

enum RED::DRIVER_VALIDATION

Lists the different driver validation levels that are returned by the RED::IGraphicDevice interface.

Enumerator:

DR_OK	This driver version should work with all REDsdk applications. This code is returned if the installed driver for a graphic card is matching the recommended driver for this card.
DR_OK_NEWER	This driver version should work with all REDsdk applications. This code is returned if the installed driver is newer than the recommended driver for this card. We assume that a driver which is newer than the recommendation we make should be working. This code is made to avoid creating user frustrations in indicating that a driver is not correct whereas it's working and valid. Nearly all the time, a DR_OK_NEWER code indicates that a working driver is installed and running. However, sometimes, there can still be problems. Therefore, this return codes lets you indicate a green flag to the user while still keeping in mind that the driver recommendation is available in case of problems.
DR_NOT_CERTIFIED	This driver version may work with REDsdk but we can't be sure of it. The current installed driver version is usually older than the driver version which is recommended for this graphic card. We can't tell whether it'll be working or not.
DR_KNOWN_ERRORS	Please change the version of this driver for a recommended version. This installed version has known issues and we don't recommend using it at all with REDsdk.
DR_NO_DRIVER_INSTALLED	On legacy operating systems, this message indicated that no graphic driver was installed on the system and that a valid driver had to be installed before executing REDsdk. On recent operating systems (Windows 10+) REDsdk may not be able to access the details of a graphic card's driver and this return code won't be returned anymore since the operating system is in charge of the driver revisions. DR_OK is returned.
DR_OK_SOFTWARE_RENDERING	Indicates that a software driver is installed on the local computer. This corresponds to REDsdk running in a virtualization environment. No graphic driver is needed in this case and REDsdk must be started in software rendering mode.

enum RED::ENV_TYPE

List of the supported environmental projection types.

Enumerator:

ENV_SPHERICAL	Environment mapping type for RED::IImageCube::CreateEnvironmentMap. The source image must be a latitude / longitude spherical map. The (u,v) = (0,0.5) texture map point intersects the X axis of the cube map; the (u,v) = (0,1) texture map point intersects the Z axis of the cube map.
ENV_CYLINDRICAL	Environment mapping type for RED::IImageCube::CreateEnvironmentMap. The source image is wrapped as a cylinder to define the cube map. The cylinder axis is aligned with the Z axis of the cube map. The (u,v) = (0,0.5) point is mapped along the X axis of the cube map.
ENV_HEMISPHERICAL	Environment mapping type for RED::IImageCube::CreateEnvironmentMap. The source image must be a latitude / longitude hemispherical map. This is similar to the ENV_SPHERICAL mapping considering only the part of the map above the line of horizon. The (u,v) = (0,0) texture map point intersects the X axis of the cube map; the (u,v) = (0,1) texture map point intersects the Z axis of the cube map.

enum RED::FILTER_MODE

Lists the possible texture sampling modes when the texture needs to be minified or magnified on screen.

Enumerator:

FM_LINEAR	The sampling of a texel is interpolated amongst all neighboring texels.
FM_NEAREST	The sampling of a texel is chosen to be the value of the closest texture pixel.

enum RED::FONT_CHARSET

Lists all possible charsets for a font. Charsets indicates the set of unicode characters that will be made accessible for a given font.

Enumerator:

FNT_DEFAULT_CHARSET	Font default system character set. This value redirects to a given charset based on the system's locale.
FNT_ANSI_CHARSET	Font character set.
FNT_SYMBOL_CHARSET	Font character set.
FNT_SHIFTJIS_CHARSET	Font character set.
FNT_HANGEUL_CHARSET	Font character set.
FNT_HANGUL_CHARSET	Font character set.
FNT_GB2312_CHARSET	Font character set.
FNT_CHINESEBIG5_CHARSET	Font character set.
FNT_JOHAB_CHARSET	Font character set.
FNT_HEBREW_CHARSET	Font character set.
FNT_ARABIC_CHARSET	Font character set.
FNT_GREEK_CHARSET	Font character set.
FNT_TURKISH_CHARSET	Font character set.
FNT_VIETNAMESE_CHARSET	Font character set.
FNT_THAI_CHARSET	Font character set.
FNT_EASTEUROPE_CHARSET	Font character set.
FNT_MAC_CHARSET	Font character set.
FNT_BALTIC_CHARSET	Font character set.

enum RED::FONT_RENDER_MODE

Possible rendering modes for a font. Valid for system fonts.

Enumerator:

FNT_UNKNOWN	Unspecified font rendering mode.
FNT_BITMAP	Renders a font using bitmaps.
FNT_TRIANGLE	Renders a font using triangles.
FNT_LINE	Renders a font using lines.
FNT_TEXTURE	Renders a font using textures. Used for high quality font display.

enum RED::FONT_TYPE

Top level font classification. Indicates the font data source.

Enumerator:

FNT_UNDEFINED	Indicates a font with undefined contents.
FNT_SYSTEM	Indicates a system font.
FNT_CUSTOM	Indicates a custom font.

enum RED::FORMAT

Lists all possible pixel formats for an image.

Enumerator:

FMT_NODATA	Currently we've nothing in the image. Such an image is bound as a black texture for all targets.
FMT_RGBA	8 bits per component, 32 bits per pixel, RGBA in memory.
FMT_RGB	8 bits per component, 24 bits per pixel, RGB in memory.
FMT_FLOAT	s1e8m23 IEEE floating point format. 32 bits per pixel.
FMT_FLOAT_RGBA	1 float per component, 128 bits per pixel, RGBA in memory.
FMT_FLOAT_RGB	1 float per component, 96 bits per pixel, RGB in memory.
FMT_L8	8 bits per component, 8 bits per pixel, L in memory. Loaded as a (L,L,L,1) texture on the GPU.
FMT_A8	8 bits per component, 8 bits per pixel, A in memory. Loaded as a (0,0,0,A) texture on the GPU.
FMT_RGBA_DXT1	Compressed image format (lossy). Uses one bit for alpha values. Is the greatest compressed form with the RED::FMT_RGB_DXT1.
FMT_RGBA_DXT3	Compressed image format (lossy). Uses a better encoding for alpha values. Uses more memory than RED::FMT_RGBA_DXT1.
FMT_RGBA_DXT5	Compressed image format (lossy). Uses the best alpha encoding that is available for these compressed formats. Uses the same memory amount as the RED::FMT_RGBA_DXT3.
FMT_RGB_DXT1	Compressed image format (lossy). Is the biggest compression kind with RED::FMT_RGBA_DXT1.
FMT_HALF_FLOAT	Half-float format. 16 bits per pixel.
FMT_HALF_FLOAT_RGBA	Half-float RGBA format. 16 bits per component, 64 bits per pixel.
FMT_HALF_FLOAT_RGB	Half-float RGB format. 16 bits per component, 48 bits per pixel.
FMT_FLOAT_RGBA_AA	Compressed RGBA format for anti-aliased images. 256 bits per pixel. Can be parsed as a RGBA double format, using 8 bytes per R,G,B,A component.

enum RED::FRAME_TRACING_FEEDBACK

Lists feedback modes of the RED::IWindow::FrameTracing call.

Enumerator:

FTF_BY_BLOCKS	RED::IWindow::FrameTracing will return based on the specified time interval and will use a basic progressive refinement method to display the image. At the coarsest feedback level, 32 x 32 pixel blocks are displayed that are progressively refined until the full image is calculated.
FTF_BY_SURFACE_LEVEL_0	RED::IWindow::FrameTracing will return once the level 0 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 0 (1 ray calculated every 32 x 32 pixels). The feedback uses geometry surfaces rather than blocks. See RED::IWindow::FrameTracing for details.
FTF_BY_SURFACE_LEVEL_1	RED::IWindow::FrameTracing will return once the level 1 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 1 (1 ray calculated every 16 x 16 pixels). The feedback uses geometry surfaces rather than blocks. See RED::IWindow::FrameTracing for details.
FTF_BY_SURFACE_LEVEL_2	RED::IWindow::FrameTracing will return once the level 2 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 2 (1 ray calculated every 8 x 8 pixels). The feedback uses geometry surfaces rather than blocks. See RED::IWindow::FrameTracing for details.
FTF_BY_SURFACE_LEVEL_3	RED::IWindow::FrameTracing will return once the level 3 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 3 (1 ray calculated every 4 x 4 pixels). The feedback uses geometry surfaces rather than blocks. See RED::IWindow::FrameTracing for details.
FTF_BY_SURFACE_LEVEL_4	RED::IWindow::FrameTracing will return once the level 4 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 4 (1 ray calculated every 2 x 2 pixels). The feedback uses geometry surfaces rather than blocks. See RED::IWindow::FrameTracing for details.
FTF_BY_SURFACE_LEVEL_5	RED::IWindow::FrameTracing will return once the image has been fully processed. Note that because of the feedback interval of the method, the calculation may return before the image is actually completed. The image is complete only when RED::IWindow::FrameTracing says so. The feedback uses geometry surfaces rather than blocks. See RED::IWindow::FrameTracing for details.
FTF_BY_BLOCKS_LEVEL_0	RED::IWindow::FrameTracing will return once the level 0 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 0 (1 ray calculated every 32 x 32 pixels). The feedback uses blocks rather than geometry surfaces. See RED::IWindow::FrameTracing for details.
FTF_BY_BLOCKS_LEVEL_1	RED::IWindow::FrameTracing will return once the level 1 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 1 (1 ray calculated every 16 x 16 pixels). The feedback uses blocks rather than geometry surfaces. See RED::IWindow::FrameTracing for details.
FTF_BY_BLOCKS_LEVEL_2	RED::IWindow::FrameTracing will return once the level 2 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 2 (1 ray calculated every 8 x 8 pixels). The feedback uses blocks rather than geometry surfaces. See RED::IWindow::FrameTracing for details.
FTF_BY_BLOCKS_LEVEL_3	RED::IWindow::FrameTracing will return once the level 3 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 3 (1 ray calculated every 4 x 4 pixels). The feedback uses blocks rather than geometry surfaces. See RED::IWindow::FrameTracing for details.
FTF_BY_BLOCKS_LEVEL_4	RED::IWindow::FrameTracing will return once the level 4 of the image has been fully processed. This means that all pixels first hit surface are calculated and that the shading is calculated at level 4 (1 ray calculated every 2 x 2 pixels). The feedback uses blocks rather than geometry surfaces. See RED::IWindow::FrameTracing for details.
FTF_BY_BLOCKS_LEVEL_5	RED::IWindow::FrameTracing will return once the image has been fully processed. Note that because of the feedback interval of the method, the calculation may return before the image is actually completed. The image is complete only when RED::IWindow::FrameTracing says so. The feedback uses blocks rather than geometry surfaces. See RED::IWindow::FrameTracing for details.
FTF_PATH_TRACING	RED::IWindow::FrameTracing will return based on the specified time interval and will use a path tracing-based refinement method to display the image.

enum RED::GI_CACHE_MODE

Lists GI cache computation modes of the RED::IWindow::FrameTracingGICache call.

Enumerator:

GICM_CAMERA_VIEW	The GI cache is computed for the given camera only.
GICM_CAMERA_SPHERICAL	The GI cache is computed for the whole set of directions around the camera position. The generated GI cache is then suitable to render panoramas.
GICM_WORLD	The GI cache is computed for the whole scene, without taking the camera into account.

enum RED::GREY_OPERATION

Defines all possible grey levelling operations.

Enumerator:

GOP_GGG1	The grey level is replicated on all RGB channels. 1.0 is set in the alpha channel.
GOP_GGGG	The grey level is replicated on all RGBA channels.
GOP_000G	The grey level is replicated in the alpha channel. RGB channels are set to 0.0.
GOP_111G	The grey level is replicated in the alpha channel. RGB channels are set to 1.0.
GOP_XXXG	The grey level is replicated in the alpha channel. RGB channels are not modified.
GOP_GGGX	The grey level is replicated in all RGB channels. The alpha channel is not modified.

enum RED::HARDWARE_PLATFORM

Identification of the hardware platform used by the application.

Enumerator:

HW_GENERIC	Generic platform identifier. This is the shader configuration that is searched for when no other configurations matching the runtime platform have been found.
HW_NVIDIA_GENERIC	NVIDIA hardware platform identifier for all NVIDIA chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_GENERIC configuration will be searched for.
HW_NVIDIA_NV30	NVIDIA hardware platform identifier for all NV30 chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_NVIDIA_GENERIC configuration will be searched for.
HW_NVIDIA_NV40	NVIDIA hardware platform identifier for all NV40 and G70 chipsets revisions. G70 chipsets correspond mainly to a die shrink of NV40 chipsets and are not considered as being different. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_NVIDIA_GENERIC configuration will be searched for.
HW_NVIDIA_G80	NVIDIA hardware platform identifier for all G80 and G90 chipsets revisions. G90 chipsets correspond mainly to a die shrink of G80 chipsets and are not considered as being different. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_NVIDIA_GENERIC configuration will be searched for.
HW_NVIDIA_G200	NVIDIA hardware platform identifier for all G200 chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_NVIDIA_GENERIC configuration will be searched for.
HW_NVIDIA_G400	NVIDIA hardware platform identifier for all G400 chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_NVIDIA_GENERIC configuration will be searched for.
HW_ATI_GENERIC	ATI hardware platform identifier for all ATI chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_GENERIC configuration will be searched for.
HW_ATI_R300	ATI hardware platform identifier for all R300 chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_ATI_GENERIC configuration will be searched for.
HW_ATI_R400	ATI hardware platform identifier for all R400 chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_ATI_GENERIC configuration will be searched for.
HW_ATI_R500	ATI hardware platform identifier for all R500 chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_ATI_GENERIC configuration will be searched for.
HW_ATI_R600	ATI hardware platform identifier for all R600 chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_ATI_GENERIC configuration will be searched for.
HW_ATI_R700	ATI hardware platform identifier for all R700 chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_ATI_GENERIC configuration will be searched for.
HW_ATI_R800	ATI hardware platform identifier for all R800 (Evergreen) chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_ATI_GENERIC configuration will be searched for.
HW_INTEL_GENERIC	INTEL hardware platform identifier for all INTEL chipsets revisions. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_GENERIC configuration will be searched for.
HW_INTEL_GMA_3000	INTEL hardware platform identifier for integrated graphics "Graphics Media Accelerator": 915G, 915GM, 945G, 945GM, 946QZ, Q965, Q963, Q35, G33, G31, Q33, G965, GM965, GL960 and G35 chipsets.
HW_INTEL_GMA_4000	INTEL hardware platform identifier for integrated graphics "Graphics Media Accelerator": GL40, GS45, GM45, GM47, Q43, Q45, G41, G43 and G45 chipsets.
HW_INTEL_GMA_GEN7	INTEL hardware platform identifier for integrated "Graphics Media Accelerator" in the Ivy Bridge and Haswell INTEL processors product lines.
HW_SOFT_TRACER	Software ray-tracing platform identifier. This is the platform identifier for all frames being rendered without any GPU.
HW_USER_GENERIC	Uer platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_GENERIC configuration will be searched for.
HW_USER_01	User platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_USER_GENERIC configuration will be searched for.
HW_USER_02	User platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_USER_GENERIC configuration will be searched for.
HW_USER_03	User platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_USER_GENERIC configuration will be searched for.
HW_VIRTUAL_GENERIC	Virtualization software layer platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_GENERIC configuration will be searched for.
HW_VIRTUAL_01	Virtualization software layer platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_VIRTUAL_GENERIC configuration will be searched for.
HW_VIRTUAL_02	Virtualization software layer platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_VIRTUAL_GENERIC configuration will be searched for.
HW_VIRTUAL_03	Virtualization software layer platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_VIRTUAL_GENERIC configuration will be searched for.

enum RED::HOST_PRODUCT

Aliases for the external products that can host REDsdk applications. This is used internally and can be freely omitted just by using the HPROD_UNKNOWN value.

Enumerator:

HPROD_UNKNOWN
HPROD_AUTODESK_MAX
HPROD_AUTODESK_VIZ

enum RED::IO_FBX_FILE_VERSION

FBX file version.

Enumerator:

IOFV_DEFAULT
IOFV_2010	2010 compatibility.
IOFV_2011	2011 compatibility.
IOFV_2012	2012 compatibility.
IOFV_2013	2013 compatibility.
IOFV_2014	2014 compatibility.
IOFV_2016	2016 compatibility.

enum RED::IO_LOAD_MATERIAL_TYPE

Lists all possible material types used during IO loading.

Enumerator:

IOLMT_GENERIC	Create generic material during loading.
IOLMT_REALISTIC	Create realistic material during loading.

enum RED::IO_LOAD_TEXTURE_TRANSPARENCY

Lists transparency mode in loaded texture.

Enumerator:

IOLTT_ALPHA	Transparency information is in the alpha channel.
IOLTT_RGB	Transparency information is in the RGB channels.

enum RED::IO_OBJECT_TYPE

Object types for import/export.

Enumerator:

IOOT_NODE	Node hierarchy.
IOOT_MESH	Mesh.
IOOT_LINE	Line.
IOOT_MATERIAL	Material.
IOOT_TEXTURE	Texture.
IOOT_LIGHT	Light.
IOOT_VIEWPOINT	Viewpoint.
IOOT_SKINNING	Skeleton and Skinning data.
IOOT_ANIMATION	Animations.
IOOT_ALL	All objects.

enum RED::IO_SYSTEM_UNIT

System unit.

Enumerator:

IOSU_MM	Millimeter.
IOSU_CM	Centimeter.
IOSU_DM	Decimeter.
IOSU_M	Meter.
IOSU_KM	Kilometer.
IOSU_INCH	Inch.
IOSU_FOOT	Foot.
IOSU_MILE	Mile.
IOSU_YARD	Yard.

enum RED::LAYER_MODE

Defines the possible texture composition modes when using the built-in REDImageComposite::Layered method.

Enumerator:

LRM_ALPHA_PLUS_ONE_MINUS_ALPHA	The operation uses the alpha * src + (1 - alpha) * dest combination.
LRM_ONE_PLUS_ONE_MINUS_ALPHA	The operation uses the 1 * src + (1 - alpha) * dest combination.

enum RED::LIGHT_TYPE

Defines the type of a light.

Lists all the types of lights.

Enumerator:

LT_NONE
LT_AMBIENT
LT_DIRECTIONAL
LT_POINT
LT_POINT_SPOT
LT_BEAM
LT_AREA
LT_AREA_SPOT
LT_SUN
LT_SKY
LT_PHYSICAL
LT_MOON

enum RED::LIST_POS

Indicates the position of a shader in the list of shaders for a rendering pass.

Enumerator:

LIST_LAST	Inserts the shader after all other shaders in the list at the time of the call.
LIST_FIRST	Inserts the shader first before all other shaders in the list at the time of the call.

enum RED::MATERIAL_PASS

Lists all the possible passes that can be the target of a Shader object. We have three kind of rendering passes:

Direct lighting passes ( PRELIT, LIT, POSTLIT ) that target one stage of the normal 3d drawing pipeline. Rendering order is PRELIT, LIT and finally POSTLIT. Ambient lighting is managed by the PRELIT pass. All other lights are handled during the LIT pass (one or many rendering passes are processed for each light, depending on the lighting configuration).
Indirect lighting passes ( INDIRECT_PRELIT, INDIRECT_LIT and MTL_INDIRECT_POSTLIT ) are identical to the direct passes, but are used for all indirect lighting workflows (ray-traced reflections, transparencies and all other indirect illumination stuff).
The RAYTRACE pass is a special pass used by the raytracer for the configuration of the whole engine behavior.
MTL_INTERNAL indicates an internal rendering pass of the engine.

Note that the MTL_ALL pass can be used for some shader searches.

Enumerator:

MTL_PRELIT
MTL_LIT
MTL_POSTLIT
MTL_RAYTRACE
MTL_INDIRECT_PRELIT
MTL_INDIRECT_LIT
MTL_INDIRECT_POSTLIT
MTL_ALL
MTL_INTERNAL

enum RED::MESH_CHANNEL

Lists all data channels in a CID_REDMeshShape. We have 16 predefined channels that can store data arrays for the rendering of the geometry.

Enumerator:

MCL_VERTEX	Usually stores geometry spatial coordinates.
MCL_USER0	This channel is often chosen as the default channel for tangent space vector information for the application of a bump map. See RED::IMeshShape::BuildTangents.
MCL_NORMAL	Usually stores per vertex normals.
MCL_COLOR
MCL_USER1
MCL_USER2
MCL_USER3
MCL_USER4
MCL_TEX0	MCL_TEX0 - 7 are usually storing texture coordinates.
MCL_TEX1
MCL_TEX2
MCL_TEX3
MCL_TEX4
MCL_TEX5
MCL_TEX6
MCL_TEX7
MCL_SIZE

enum RED::MESH_FORMAT

Lists all possible data channels formats of a mesh. See RED::IMeshShape::SetArray.

Enumerator:

MFT_ZERO	No data in the corresponding channel.
MFT_UBYTE	One byte per component, unsigned int8. Note that using this data format usually requires a 4 bytes memory alignment for optimal performances. Therefore, you should declare 4 coordinates per vertex.
MFT_SHORT	Two bytes per component, short16. As for the byte format, a memory alignment on 4 bytes boundaries is usually required for optimal performances. Therefore, a choice of 2 or 4 coordinates per vertex is recommended.
MFT_INT	Four bytes per component, int32.
MFT_FLOAT	Four bytes per component, float32.
MFT_DOUBLE	Eight bytes per component, float64.
MFT_HALF_FLOAT	Two bytes per component, half16. Memory alignment on 4 bytes boundaries is usually preferred for optimnal performances.

enum RED::MESH_TEXCOORD_MAPPING

Lists all texture coordinates calculation methods in a CID_REDMeshShape. Generally used for texture coordinates generation. See RED::IMeshShape::BuildTextureCoordinates.

Enumerator:

MTCM_PLANAR	Defines a planar texture coordinates mapping.
MTCM_SPHERICAL	Defines a spherical texture coordinates mapping.
MTCM_CYLINDRICAL	Defines a cylindrical texture coordinates mapping.
MTCM_CYLINDRICAL_CAP	Defines a cylindrical cap texture coordinates mapping.
MTCM_BOX	Defines a box texture coordinates mapping.

enum RED::OPERATING_SYSTEM

Lists all REDsdk supported operating systems.

Enumerator:

OS_NOT_SUPPORTED	RED::IGraphicDevice operating system identifier. Identify any operating system that can't run REDsdk.
OS_WIN_2000	RED::IGraphicDevice operating system identifier. Windows 2000.
OS_WIN_XP_32	RED::IGraphicDevice operating system identifier. Windows XP 32 bits.
OS_WIN_XP_64	RED::IGraphicDevice operating system identifier. Windows XP 64 bits.
OS_WIN_VISTA_32	RED::IGraphicDevice operating system identifier. Windows Vista 32 bits.
OS_WIN_VISTA_64	RED::IGraphicDevice operating system identifier. Windows Vista 64 bits.
OS_WIN_SEVEN_32	RED::IGraphicDevice operating system identifier. Windows Seven 32 bits.
OS_WIN_SEVEN_64	RED::IGraphicDevice operating system identifier. Windows Seven 64 bits.
OS_WIN_EIGHT_32	RED::IGraphicDevice operating system identifier. Windows Eight 32 bits.
OS_WIN_EIGHT_64	RED::IGraphicDevice operating system identifier. Windows Eight 64 bits.
OS_WIN_TEN_32	RED::IGraphicDevice operating system identifier. Windows Ten 32 bits.
OS_WIN_TEN_64	RED::IGraphicDevice operating system identifier. Windows Ten 64 bits.
OS_LIN_32	RED::IGraphicDevice operating system identifier. All Linux 32 bits editions.
OS_LIN_64	RED::IGraphicDevice operating system identifier. All Linux 64 bits editions.
OS_MAC_OSX_64	RED::IGraphicDevice operating system identifier. Macintosh OS X 64 bits edition.

enum RED::OPTION_VALUE_FORMAT

Identifies all possible formats for an option value.

Enumerator:

OPT_UNKNOWN	Unknown option format.
OPT_BOOLEAN	Indicates a boolean value option.
OPT_DOUBLE	Indicates a double precision floating point value option. Note that this format can be used for simple precision & double precision query methods. Internal options are stored in double precision, but they can be accessed in simple precision format for convenience.
OPT_INTEGER	Indicates an integer value option.

enum RED::OPTIONS

Lists all REDsdk engine options. A REDsdk option can be set at three different engine interface levels:

On the RED::IResourceManager interface. An option set on the resource manager applies to all windows and cameras of the cluster, unless the window or camera has overloaded the same option by itself.
On the RED::IWindow interface. An option set on a window applies to all cameras linked to that window, unless the camera has overloaded the same option.
On the RED::IViewpoint interface. Most options can be applied at the three interfaces, but some of them are restricted to two or one single interface. Please refer to the documentation for each option for all details on this.

Enumerator:

OPTIONS_RAY_PRIMARY	[boolean]: [false, true]. [default]: false. [scope]: All options instances. Activate the primary-ray casting in the rendering workflow of all viewpoints in the scope of that option container. Primary-ray casting is a pre-requisite for all ray-tracer lighting calculations. Primary-ray casting provides the list of visible objects in a scene (perfect occlusion culling).
OPTIONS_RAY_SHADOWS	[integer]: [0,inf[. [default]: 0. [scope]: All options instances. Activate shadow casting for all lights that can cast ray-traced shadows when the specified value is greater than or equal to 1. Activation of shadows forces the activation of the primary ray option. The value of this option indicates the depth of the shadow casting process in the ray-tracing tree.
OPTIONS_RAY_REFLECTIONS	[integer]: [0,inf[. [default]: 0. [scope]: All options instances. Activate the calculation of ray-traced reflections for objects that can reflect light when the specified value is greater than or equal to 1. Activation of reflection forces the activation of the primary ray option. The value of this option indicates the depth of the reflection calculation process in the ray-tracing tree.
OPTIONS_RAY_REFRACTIONS	[integer]: [0,inf[. [default]: 0. [scope]: All options instances. Activate the calculation of ray-traced refractions for objects that are refractive. Activation of the refractions forces the activation of the primary ray option. The value of this option indicates the depth of the refraction calculation process in the ray-tracing tree.
OPTIONS_RAY_TRANSPARENCY	[integer]: [0,inf[. [default]: 1 (1 transparency depth). [scope]: All options instances. Activate the calculation of ray-traced transparencies for objects that are transparent. Activating this option does not force the activation of the primary ray option. The value of this option indicates the transparency depth that'll be rendered for transparent objects.
OPTIONS_RAY_REFRACTIONS_BACK	[boolean]: [false, true]. [default]: false. [scope]: All options instances. When this option is off, the last refractive rays of the rendered ray- tree pass through all refractive objects to only hit opaque objects. For example, if we consider a refractive surfacic sphere over an opaque ground, and render that scene with a refraction depth set to one, then refractive rays will show the inner face of the sphere if the option is set to true, or they'll show the background if the option is set to false. Disabling this option result in better looking images - however with fake refraction rays for the last depth - whenever there's not enough refraction depth to get through all refractive layers.
OPTIONS_RAY_MAX_THREADS	[integer]: [1,inf[. [default]: 2048. [scope]: All options instances. The Red engine ray-tracer uses every processor available in the host computer for its rendering. This option can be used to clamp this number to a maximal number of threads running in parallel for the ray- tracer, so that some CPU bandwidth can be reserved for other tasks.
OPTIONS_RAY_CUTOFF	[double]: [0.0, 1.0]. [default]: 0.02. [scope]: All options instances. The value of this option is used as input for the ray-tracer to set the minimal intensity of a ray that is considered as having a valid contribution to the final image. Note that a 0.0f cutoff value removes all optimization effects that can be related to using a cutoff shader such as the RED::RayCutoffShader.
OPTIONS_RAY_ENABLE_GLOSSY_EFFECTS	[boolean]: [false,true]. [default]: true. [scope]: All options instances. The value of this option let the user to enable or to disable the calculation of glossy ray-traced effects. When off, whatever may be specified by ray-tracer shaders, only one reflection ray and only one refraction ray is fired to render reflection and refraction effects.
OPTIONS_RAY_ENABLE_AREA_SAMPLING	[boolean]: [false, true]. [default]: true. [scope]: All options instances. The value of this option let the user to enable or to disable the calculation of area light sampling effects. If turned off, then all area lights are replaced by point lights using one single sample. This result in faster lighting and shadowing for example suitable for all pre-visualization purposes.
OPTIONS_RAY_ENABLE_SOFT_TRACER	[integer]: 0 (disabled), 1 (enabled, hybrid) or 2 (enabled, exclusive). [default]: 0 = disabled. [scope]: Cluster's resource manager only. The value of this option let the user to enable or to disable the software based ray- tracer. This option must be enabled while in a transaction and before any call to RED::IWindow::FrameTracing or to RED::IWindow::FrameDrawing. It indicates the engine that it must proceed to all the necessary setup to be able to render a frame in software. Note that this option does not conflict with the GPU rendering at all. On activation, software tracing is made possible and all GPU accelerated rendering modes remain available. The option is disabled by default to avoid the extra burden caused by the CPU rendering setup needs (for examples with textures that have to be accessible on the CPU). This option has three values: 0: Disabled, this means that only RED::IWindow::FrameDrawing is possible for the application, using only the GPU. 1: Enabled in hybrid mode. This means that both GPU and CPU based renderings are possible. A window can be rendered using the GPU while another one is processed using the software tracer. This is the most memory consuming mode as the two rendering systems are working simultaneously. 2: Enabled in exclusive mode. This means that GPU rendering will be disabled and only CPU rendering will be made possible. Setting this option is only valid at the resource manager level and must be done at the application startup before any REDsdk operation, and the option value can't be changed anymore after the closing of the first transaction.
OPTIONS_RAY_ENABLE_CAUSTICS	[boolean]: [false, true]. [default]: false. [scope]: All options instances. Activate the calculation of caustics for transparent and reflective objects. Note that the generation of caustics depends also on the setup of the object materials and the lights. Caustics are supported by physical lights only.
OPTIONS_RAY_CAUSTICS_SAMPLING_RATE	[integer]: [0, 100000]. [default]: 1000. [scope]: All options instances. Set the sampling rate of the caustics photons. The total number of caustics photons for the whole scene is the squared value of the sampling rate (default is 1000x1000 photons).
OPTIONS_RAY_CAUSTICS_SEARCH_RADIUS	[double]: [0.0, inf[. [default]: 4.0. [scope]: All options instances. When rendering caustics, the n nearest photons from the point being shaded are queried. This option defines the radius of the search area around that point in scene units. The bigger the radius, the smoother the caustics.
OPTIONS_RAY_CAUSTICS_SEARCH_COUNT	[integer]: [0, 4096]. [default]: 64. [scope]: All options instances. Number of photons used for the caustics estimation. The photons search is limited by the value of OPTIONS_RAY_CAUSTICS_SEARCH_RADIUS but if more than OPTIONS_RAY_CAUSTICS_SEARCH_COUNT are found, only the OPTIONS_RAY_CAUSTICS_SEARCH_COUNT nearest photons will be used to estimate caustics. If the option is set to 0 then all the valid photons inside the search radius will be used to compute the caustics estimate.
OPTIONS_RAY_LIGHTS_SAMPLING_RATE	[integer]: [0,inf[. [default]: 8. [scope]: All options instances. Set the number of samples to be taken while sampling scene lights. A value of 0 means that the number of samples set to each light is taken. Any other positive values overwrite the lights settings. The real number of samples taken is the square of the option value. For example, if the option is set to 4, 16 samples will be taken.
OPTIONS_RAY_GLOSSY_SAMPLING_RATE	[integer]: [0,inf[. [default]: 8. [scope]: All options instances. Set the number of samples to be taken while sampling glossiness (reflection or refraction). A value of 0 means that the number of samples set to each material is taken. Any other positive values overwrite the materials settings. The real number of samples taken is the square of the option value. For example, if the option is set to 4, 16 samples will be taken.
OPTIONS_RAY_VOLUME	[integer]: [0,inf[. [default]: 0. [scope]: All options instances. Activate the calculation of ray-traced volume for volume shape containing volumetric effects when the specified value is greater than or equal to 1. The value of this option indicates the depth of the volume calculation to be processed in the ray-tracing tree.
OPTIONS_RAY_DISPLACEMENT	[boolean]: [false,true]. [default]: true. [scope]: All options instances. Activate software ray-tracer displacement mapping calculations when enabled. If the option is turned on (default) then displacement maps specified by RED::StateShader::SetDisplacement are used to modify the rendered geometries. If the option is turned off, then no displacement occurs.
OPTIONS_RAY_USE_EMBREE	[boolean]: [false, true]. [default]: true. [scope]: All options instances. Intel Embree is a collection of ray casting methods. Thanks to its careful handling of SSE instruction sets, it can provide an acceleration ratio between x1.2 and x2 to the rendering of images. However, it does not currently support lot of RED features: double precision matrices and geometries, lines, displacement... When the option is turned on, the Embree raycaster is used only for triangle-based geometries in 32bit float precision (vertex channel). Other type of geometries, or geometries using higher precision vertex channels are still processed using the RED raycasting mechanism or ignored. Please note that for geometries processed by Embree, the transformation matrices are casted to 32bit float (which may result in a loss of accuracy). If the Intel Embree library can't be found, REDsdk will return a RED_EMBREE_DLL_NOT_FOUND return code. The error can be resolved on disabling RED::OPTIONS_RAY_USE_EMBREE. If a scene contains lines, then Embree will not be used unless the RED::OPTIONS_RAY_FORCE_EMBREE is enabled. In that case, the scene is rendered without lines by Embree. If the option is off, the whole data are processed using the RED raycasting algorithms. If GPU-based ray-tracing is used, the option value is automatically ignored and considered as false.
OPTIONS_RAY_FORCE_EMBREE	[boolean]: [false, true]. [default]: false. [scope]: All options instances. This option can be turned on to force the usage of Embree regardless of the scene contents. In this case all lines present in the scene are ignored. Note that displaced surfaces are still visible, but are always processed by the RED raycasting solution. This option should be set once for all before using any ray-tracing feature.
OPTIONS_RAY_ENABLE_OPEN_IMAGE_DENOISE	[boolean]: [false,true]. [default]: false. [scope]: All options instances. This option turns on the Intel Open Image Denoise that can modify software generated images during a post calculation pass. The denoiser will try to remove noise in the image while preserving all its details.
OPTIONS_VIEWPOINT_PICKABLE	[boolean]: [false, true]. [default]: true. [scope]: All options instances. Defines whether objects can be picked in that viewpoint. The picking is a method of the window used to perform screen based ray selection of shapes within the DAG displayed by the window.
OPTIONS_SHADOW_MAP_DEPTH	[integer]: [0,inf[. [default]: 1 (shadow map applied on first skin). [scope]: All options instances. Defines the rendering depth for which shadow maps are applied on scene elements. A depth of 2 enables shadow maps to generate shadows in a reflection image for example.
OPTIONS_POLYGON_FILL_MODE	[integer]: 0, 1 or 2. [default]: 0 (filled polygons). [scope]: All options instances. Defines the polygon fill mode (points, line, filled) for all rendered geometries that are sent to the rendering for the viewpoint that has the given option value. Value 0 is used to render triangles as filled polygons. Value 1 is used to render triangles as only edges and value 2 is to render triangles as only their three definition vertices.
OPTIONS_SHADOW_MAP_TRANSPARENCY	[boolean]: [false, true]. [default]: false (transparent objects cast shadows). [scope]: All options instances. Defines the behavior of shadow mapping versus transparent objects. Because shadow mapping is a shadowing method based on the distance of an occluder from the light source, transparent objects cast black shadows and the amount of transparency can't be considered in the shadowing. This option is used to change this behavior. Whenever set to true, shadow maps will ignore all transparent objects that won't cast shadows anymore.
OPTIONS_AUTO_CUBE_ENV_SIZE	[integer]: 1 to maximum texture size. Must be POTD. [default]: 512. [scope]: All options instances. Defines the size of cube images that are dynamically created for the RED::RenderShaderParameter::REF_AUTO_CUBE_MAP reference. The value must be a power-of-two number.
OPTIONS_AUTO_CUBE_ENV_UPDATE_MODE	[integer]: 0 or 1. [default]: 0. [scope]: All options instances. This option rules the update mode of all cube images that are dynamically created for the RED::RenderShaderParameter::REF_AUTO_CUBE_MAP reference. 0 means that all dynamic cube images are calculated once and are never updated. 1 means that all dynamic cube images are updated every frame. It's possible to switch the option value from 0 to 1 and vice-versa the next frame to do one single update of all images.
OPTIONS_AUTO_CUBE_ALLOW_RAYTRACER	[boolean]: [false, true]. [default]: false. [scope]: All options instances. If this option's value is false, then cube images that are dynamically created or update for the RED::RenderShaderParameter::REF_AUTO_CUBE_MAP reference and through the RED::IImageCube::AutoCubeUpdate call will be generated without any ray-tracer option being activated. If this option's value is true, then the source camera scene's ray-tracing options will be used.
OPTIONS_GI_CACHE_TRANSPAR_DRAW	[boolean]: [false, true]. [default]: false. [scope]: All options instances. If this option's value is false, then an indirect irradiance cache set on a VRL won't be rendered for transparent objects for all cameras that have the option turned off. This saves render time in configurations where transparent objects are almost not diffuse (all common glasses) and for which the global illumination contribution can be neglected. By default, this option is disabled, so that we render faster ignoring transparency rendering passes.
OPTIONS_MATERIAL_LAYER_INTERSECT	[boolean]: [false, true]. [default]: false. [scope]: All options instances. This option lets you change the inheritance mechanism applied for the selection of a material rendering configuration based on RED::LayerSets. By default, the rendering configuration of a material uses all shaders that have been registered with a RED::LayerSet that exactly matches the RED::LayerSet of the camera that is viewing the scene. This behavior can be changed through this option. By enabling it, the rendering configuration of a material will be defined by the set of shaders that have been registered with a RED::LayerSet that intersects the RED::LayerSet of the camera that is viewing the scene. Several remarks on this option: Shaders that will be selected will all use the same RED::LayerSet. The method will NOT select two shaders that intersect the layerset of the camera because of one intersection layer and that have different layersets. The solution is no longer unique: the engine will select the first set of shaders whose common layerset is intersecting the camera layerset, parsing the material from the last shader added to a rendering pass to the first shader that was added to a rendering pass. The fallback configuration (all layers) remain unchanged. It's worth mentioning that what we call a rendering configuration is the list of shaders that have been registered for a given RED::LayerSet. If a shader #1 is added to a pass using layers A,B,C and another one #2 is added to a pass using layers A,C,D; then the two shaders won't coexist in the same rendering configuration, even if the camera layerset contains A which is shared by both shaders in their passes. If shader #1 is added to a pass using A,B,C, shader #2 added to A,C,D and shader #2 also added to A,B,C; then using a camera with layerset with B only will select the configuration with shaders #1 and #2. If the camera layerset is defined using layer C; then the configuration with shader #2 will be selected instead, because it was added last. The configuration with #1 and #2 could be selected also, but it was declared first.
OPTIONS_TONE_MAPPING_IGNORE_BACKGROUND	[boolean]: [false, true]. [default]: false (disabled). [scope]: All options instances. This option let the user control whether the contribution of the background images or clear color is considered during the tone mapping calculations or not. If the option is enabled, all pixels of the image that are viewing the background are discarded during tone mapping calculations: they don't have any impact on the image luminance and their colors are not modified. If the option is disabled, the VRL's clear color or background images will participate to the tonemapping process, both in luminance calculations and tonemapping. Note that this option is not supported if the tonemapping is performed by the GPU and if the engine anti-aliasing is activated at the same time. In this specific configuration, an aliasing border may be visible in the resulting image.
OPTIONS_VIEWPOINT_ORTHOGRAPHIC_EYE_AUTO_OFFSET	[double]: [ 0.0, DBL_MAX [. [default]: 1e4. [scope]: All options instances. This option causes the eye position of all orthographic cameras to be moved away along the opposite direction of the camera sight distance during rendering phases. This is used to reduce the parallax error in shading programs that are using the camera position reference (RED::RenderShaderParameter::REF_EYE_POS_WCS) or that are calculated in the view space axis system, for which the eye position is at the origin. The eye position returned by RED::IViewpoint::GetEye remains unchanged. The modification only occurs during the rendering of the camera. The offset value is set by default to 10.000 model units. Note that the application can mimic the behavior of this offset by manually shifting the eye position of the camera from the wished number of units. Please also note that using too large values here may lead to inacurracies in the hardware display.
OPTIONS_REFRESH_INSTANCE_COUNTERS	[boolean]: [false, true]. [default]: false (disabled). [scope]: All options instances. This option let the user force the update mechanism for instance counters. Instance counters are detailed noticeably there: Using instance counters. Instance counter values (for both values and images) are only updated when a shape event occurs on the path to the shape instance. It may be wishful to also force a global scene graph refresh of the scene values noticeably if there are material changes and no corresponding scene graph data updates. Enabling this option will refresh instance counter values for the entire scene graph(s) of the camera(s) receiving the option value enabled (either natively or after inheritance).
OPTIONS_WINDOW_HDR	[integer]: 0 to 2. [default]: 0. [scope]: Window instances or the resource manager. Enable or disable the HDR rendering pipeline for the specified window. Available values for this option are: 0: HDR is disabled. 1: Half float HDR is enabled. 2: Full float HDR is enabled. HDR is directly performed using the hardware capabilities if the hardware has the appropriate blending functions available. The HDR function is enabled at the window level and it can be overridden at the RED::IViewpointRenderList level. However, cameras do not have any control over the HDR (cameras are not associated to rendering buffers whereas VRLs are). Half float HDR consumes less memory than full float HDR (50% less), but has a lower accuracy resulting of 16 bits half floating point values being used to store color components.
OPTIONS_WINDOW_PICK_AREA	[integer]: 0 to 20. [default]: 1. [scope]: Window instances or the resource manager. Specify the radius in pixels of the picking window used to find geometries during a RED::IWindow::FramePicking call. The default size of 1 means that any geometry under a 3x3 pixel block will be selected by the call.
OPTIONS_WINDOW_PICK_AREA_TRIANGLE	[boolean]: [false, true]. [default]: true. [scope]: Window instances or the resource manager. This is a performance option for the RED::IWindow::FramePicking call. If the option is enabled, then the picking method will use the full picking window frustum to determine whether a triangle or a textured text is being intersected or not. If this option is disabled, triangles and textured texts triangles are picked using the ray emanated from the pick window center. Practically, then, if the option is turned on, very small triangles or objects will be returned by the picking. Otherwise, they can be missed because the ray used for the picking operation will not hit them, but in this latter case, the picking operation is faster.
OPTIONS_WINDOW_DRAW_SYNC	[boolean]: [false, true]. [default]: false. [scope]: Window instances or the resource manager. This is a performance option that affects the behavior of a window rendering. By default REDsdk does not synchronize the rendering before swapping the window back buffer. Consequently, all hardware vendors usually combine several frames to get better rendering performances. This behavior may be problematic with big data models that take time to render. In this case, the frame overlap can cause a bit of delay in the responsiveness of the application that may be unpleasant. Using this option adds several synchronization points at the end of the rendering of each pass in a frame: all pending rendering orders are flushed and executed before moving forward in the rendering pipeline and before the buffers are effectively swapped. Turning this option on may have a small negative impact on performances, but forces every frame to be finished before a new one is actually started. This can also be useful for multi-threaded high performance applications to measure the real rendering time of a frame on the rendering thread: the RED::IWindow::FrameDrawing call won't return before the actual completion of the frame, which is not the case by default: the option is disabled.
OPTIONS_DATA_RELEASE_TIMER	[integer]: [1,inf[ indicates a number of transactions. [default]: 1 (one transaction alive). [scope]: Cluster's resource manager only. The RED engine uses a number of graphic resources for all its internal processing purposes (shadow mapping, ray-tracing, composite images, texturing operations to only name the main data sources). All these resources are shared by all rendering tasks that are performed by the engine. By default, all these resources are maintained alive when they are used for the rendering of every transaction: BeginState + Do some data edition + EndState + FrameDrawing for one or many windows and then BeginState again and so on. Some applications can render multiple windows separately, each window being on its own transaction cycle, making the previous live condition (survival for 1 transaction) inefficient: If the application renders a given window 100 times before rendering another window that was using for example some buffers for shadow mapping, then upon restarting the rendering of that window, the shared buffer will have to be re-allocated, as it has been found unused for 100 frames and therefore has been destroyed. This option can be used to control the behavior of the internal pool of shared resources in the engine. It defines the number of consecutive transactions below which no shared resource will be released from memory.
OPTIONS_IMMEDIATE_MODE	[integer]: 0 (force off), 1 (let the material decide) or 2 (force on). [default]: 1 (let the material decide). [scope]: Cluster's resource manager only. This option can be used to configure the rendering mode of all geometries inside the REDsdk cluster. It may override the setup made by the RED::IMaterial::SetImmediateMode call. Immediate mode is a legacy slow rendering method that has the advantage to not consume any memory on the graphic card (all the data to render is sent to the graphic card every frame). Therefore, turning this option to "2" (force on) will remove all memory needs for the geometry rendering. Then, if immediate mode is enabled on materials or "forced on", the rendering will take more time than if it's disabled on materials or "forced off".
OPTIONS_LIGHT_CUTOFF	[double]: [0.0,inf[. [default]: 0.003. [scope]: Cluster's resource manager only. This value defines a minimal lighting intensity a light must emit to be taken into consideration. This parameter helps improving rendering performances in environments where many lights are set. In such environments, it's not rare to see that many lights have a neglectable influence over the shading at a given point. This cutoff value helps the engine discard neglectable lights, whose color contribution to the shaded point is below the cutoff value. See details on this option here: Light cutoff option. Please note that this value is empirical and arbitrary: it's an absolute intensity cutoff threshold applied to the contribution of a single light, regardless of its environment. In physical HDR environments, the real contribution of a physical light goes infinitely far away. Therefore, if the cutoff is set too high in dark scenes, the application of tonemapping can reveal the light cutoff as a smooth frontier between lit and non lit areas. The cutoff works for both physical and non physical lights. Very small cutoff values can be ignored for non physical lights rendered on the GPU to preserve some numerical accuracy in the decay calculations performed by rendering shaders.
OPTIONS_FORCE_STENCIL	[boolean]: [false, true]. [default]: false (disabled). [scope]: Cluster's resource manager only. This option forces the usage of stencil buffers for auxiliary RED::IViewpointRenderLists and for all internal buffers used by a window. Some hardware configurations (virtualization platforms, some bad hardware / os driver combinations) don't support stencil buffers to be turned on for OpenGL Framebuffer objects. If the option is enabled on a system that does not support FBOs with stencil buffers, then RED_DRV_FRAMEBUFFER_CREATION_ERROR can be returned by REDsdk calls. This option should be setup once at the engine startup.
OPTIONS_SAMPLER	[integer]: 0 (legacy QMC sampler), 1 (HM sampler). [default]: 0 (legacy QMC sampler). [scope]: Cluster's resource manager only. This option can be used to change the Quasi Monte Carlo sampler used by REDsdk. There are currently two QMC samplers available: The legacy QMC sampler used by default, The new HM sampler, which is meant to be used with adaptive ray-tracing. The legacy QMC sampler does not produce good results with adaptive software rendering of images, therefore, it can't be used if the RED::OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD is greater than 0.0. The new HM sampler has been designed to match adaptive ray-tracing needs. Its also a bit faster. This option must be modified at the resource manager level, as it can affect all of REDsdk's sampling algorithms. It should be modified only after the creation of the resource manager, or when no rendering occurs. Changing this option's value while a rendering occurs may provoke unexpected results.
OPTIONS_FORCE_COMPRESSED_IMAGES_INTEL	[boolean]: [ false, true ]. [default]: false (disabled). [scope]: Cluster's resource manager only. This option is used to change the behavior of the RED::IImage2D::SetCompressedPixels methods specifically on INTEL GPUs. Due to an INTEL driver bug, the loading of compressed images on the GPU can fail when texture mipmaps are also enabled for these textures. The default bypass for this problem used by REDsdk is to load the texture in its uncompressed form on INTEL GPUs so that the texture corruption bug does not show up when texture mipmaps are enabled. Turning on this option changes the behavior and forces the texture to be compressed in the GPU video memory when asked to do so.
OPTIONS_OPENGL_CONTEXT_MAJOR	[integer]: [ 0, inf [. [default]: 0 (no version requirement). [scope]: Cluster's resource manager only. This option can be used before the engine startup to force the version of OpenGL contexts creation. By default, REDsdk does not require any OpenGL context version. On setting up any positive value for this option, contexts will be created using wglCreateContextAttribsARB using the WGL_CONTEXT_PROFILE_MASK_ARB flag and the WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB flags. This option's value define the major version of the OpenGL context.
OPTIONS_OPENGL_CONTEXT_MINOR	[integer]: [ 0, inf [. [default]: 0 (no version requirement). [scope]: Cluster's resource manager only. This option can be used before the engine startup to force the version of OpenGL contexts creation. This option's value defines the minor version of the OpenGL context. See RED::OPTIONS_OPENGL_CONTEXT_MAJOR for further details.
OPTIONS_OPENGL_CONTEXT_DEBUG	[boolean]: [ false, true ]. [default]: false. [scope]: Cluster's resource manager only. This option can be used before the engine startup to force the debug mode for OpenGL contexts creation. This option is only effective if the OPTIONS_OPENGL_CONTEXT_MAJOR is being set.
OPTIONS_RAY_GI	[boolean]: [false, true]. [default]: false. [scope]: All options instances. Enable or disable Global Illumination rendering.
OPTIONS_RAY_GI_ERROR	[double]: [0.001,1000.0] indicates the error tolerance of the global illumination solution. [default]: 0.02 (for RED::GICM_WORLD generation mode, the error should be set to a distance depending on the scene units and data; see below for explanations). [scope]: All options instances. The error is inversely proportional to the global illumination precision. A good choice is too leave the error to its default value (except in RED::GICM_WORLD generation mode). Decreasing this error would enhance the final global illumination quality but at the price of a bigger memory consumption and a longer rendering time. In RED::GICM_CAMERA_VIEW and RED::GICM_CAMERA_SPHERICAL GI cache generation modes, the option value is unitless. In RED::GICM_WORLD mode, the error becomes the minimum distance allowed between two cache samples in model units.
OPTIONS_RAY_GI_ESTIMATOR_SAMPLING_RATE	[integer]: [1,65535[ indicates the squared root of the number of rays used to compute the estimator. [default]: 1000 (one million rays for the whole estimator). [scope]: All options instances. This is the sampling rate of the estimator, i.e the squared root of the total number of rays that will be traced to compute the indirect illumination estimator (first GI pass). You can increase this value for a better estimator convergence but the default value will be good most of the time.
OPTIONS_RAY_GI_CACHE_PASSES_COUNT	[integer]: [-127,127] indicates the number of indirect illumination cache refinement passes if positive; if negative, it is interpreted as a minimum convergence threshold. [default]: 3. [scope]: All options instances. The indirect illumination cache is built by iteratively refining an initial set of irradiance samples taken into the scene. The initial set a a density proportional to the OPTIONS_RAY_GI_ERROR value. Then a fixed or variable number of refinement passes are processed to locally refine the cache following scene geometric and/or lighting variations. The fixed number of passes is given by the value of the OPTIONS_RAY_GI_CACHE_PASSES_COUNT option if positive. If negative, a convergence threshold is computed as: convergence_threshold = 1.0 + 1.0 / OPTIONS_RAY_GI_CACHE_PASSES_COUNT. Then, the cache is refined until it converges to at least the convergence threshold value.
OPTIONS_RAY_GI_CACHE_HEMI_SAMPLING_RATE	[integer]: [1,inf[ indicates the number of samples to be taken while sampling the hemisphere. The real number of samples is the square of the option value. [default]: 22 (22x22=484 samples). [scope]: All options instances. This is the square root of the actual number of samples taken to estimate the global illumination at a given location during the global illumination cache computation. If a null or negative value is set, a value of 1 will be automatically assumed.
OPTIONS_RAY_GI_CACHE_INTERP_SAMPLES_COUNT	[integer]: [1,inf[ indicates the number of samples taken while estimating the indirect illumination using the cache. [default]: 20. [scope]: All options instances. This number is used after the global illumination cache computation, during the rendering phase. It influences the smoothness of the rendered indirect illumination. The bigger the interpolation samples count is, the smoother the result will be (meaning that small details will be lost). If a null or negative value is set, a value of 1 will be automatically assumed.
OPTIONS_RAY_GI_SHOW_SAMPLES	[integer]: 0, 1, 2 or 4. [default]: 0 (none). [scope]: All options instances. This option is mainly for debugging purposes as it discards any shading operation to only render the position of the selected GI samples. Its use should be reserved to expert users. 0 means show no GI samples. 1 means show GI estimator samples. 2 means show GI cache samples. 4 means show pixels where GI cache samples were used to approximate glossiness (in magenta).
OPTIONS_RAY_GI_ENABLE_VOLUME	[boolean]: [false, true]. [default]: false. [scope]: All options instances. Enable or disable the volume rendering during the global illumination process.
OPTIONS_RAY_GI_CACHE_PRECISE	[boolean]: [false, true]. [default]: false. [scope]: All options instances. Enable the high precision computation mode for the global illumination cache. If enabled, small geometric details are automatically detected by the engine and better GI estimation is performed. This is good to avoid interpolation artifacts over fine geometry variations like cabinet gaps, tiles edges, window frames...
OPTIONS_RAY_GI_FOR_GLOSSINESS	[double]: [0, 32]. [default]: 1.0 (enabled). [scope]: All options instances. This option enables the use of the global illumination cache for the acceleration of glossiness computation. Because glossiness is a blurry effect, we can use computations of cheaper quality for rays being spread through a glossy reflection/refraction as they will finally be averaged together. Once turned on, the option lets the engine to reconstruct an approximation of the lighting reaching a point by requesting the global illumination cache instead of directly compute the illumination. This can dramatically reduce the time needed to render a scene with a lot of glossy materials. The lesser the value, the better the glossiness quality (a value of 0 turns glossiness approximation off). If no GI cache has been computed, the option has no effect and is considered as disabled.
OPTIONS_RAY_GI_FOR_LIGHTING	[boolean]: [false, true]. [default]: false. [scope]: All options instances. This option enables the use of the global illumination cache for the enhancement of sampled lights rendering. If turned on, the engine uses the global illumination cache to concentrate sampling on meaningful lights. This generally leads to an increase in lighting quality with no decrease in rendering time. However, the effect of the option is closely related to the quality of the GI cache. Hence, it performs best with default or higher GI cache settings. If no GI cache has been computed, the option has no effect and is considered as disabled. This option has no effect if path tracing is used to render the scene (see RED::OPTIONS_PATH_GI instead).
OPTIONS_RAY_SOFT_SHADOW_MAP_TRANSPARENCY	[boolean]: [false, true]. [default]: true (enabled). [scope]: All options instances. This option let the user control the behavior of software shadow maps. A shadow map that is rendered by the graphic card is not able to take into consideration partial occlusion resulting of transparent objects. It can ignore transparent objects or consider them as shadow blockers for the shadow map (see OPTIONS_SHADOW_MAP_TRANSPARENCY). This is not the same for software shadow maps, that can cumulate the lighting attenuation caused by partially transparent occluders found on the path from the light to the surface. This option is then used to turn on or off the contribution of transparent surfaces.
OPTIONS_RAY_AREA_SHADOW_SPACING	[integer]: [1,inf[. [default]: 16. [scope]: All options instances. This is the average screen size distance in pixels between two samples used to sample area shadows for the GPU ray-tracer.
OPTIONS_RAY_AREA_SHADOW_SPREAD	[integer]: [1,inf[. [default]: 8. [scope]: All options instances. This is the coverage factor of GPU area shadow samples on screen. A larger spread value generates more blurry shadows while a smaller value tends to generate sharper shadows.
OPTIONS_RAY_CONTEXT_CALLBACK_PERSISTENCE	[boolean]: [false,true]. [default]: false (disabled). [scope]: All options instances. This option controls the behavior of the ray-tracer vs. the context switch callback that can be set on shapes of a scene graph (see RED::IShape::SetContextSwitchCallback). By default, objects that are discarded by the context switch callback are removed from ALL REDsdk scene processings. This implies that objects discarded at this stage are not present in any of the ray-tracer acceleration structures that can be stored and maintained by the engine. Turning this option on changes the persistence of objects discarded by the context switch callback. Once enabled, objects that are discarded by the context switch callback will still be stored in the ray-tracer acceleration structures maintained by the engine. Consequently, the acceleration structure may consume more memory, but changing the context visibility of an object will have no cost on it.
OPTIONS_RAY_FORCE_TRANSPARENCY	[boolean]: [false,true]. [default]: false (disabled). [scope]: All options instances. This option controls the behavior of the ray-tracer vs. the number of transparency layers that are rendered. By default, this option is disabled so that when a primary ray hits an opaque surface, its propagation is stopped. Turning this option on let the software ray-tracer pursue the propagation of a ray, even behind opaque surfaces. The need to see behind opaque surfaces arise in rendering configurations that are using a non-natural depth buffer setup. For example, rendering methods to see backward edges, section cutting, custom depth ordering, or material priorities are rendering setups that may use an exotic depth buffer setup.
OPTIONS_RAY_SOFT_PREVIEW	[boolean]: [false,true]. [default]: false (disabled). [scope]: All options instances. This option modifies the behavior of the software ray-tracer after changes of data in the cluster. When enabled, the software ray-tracer does partial update of the rendered image to quickly provide a visual feedback depicting the changes. Then the image resumes and finishes normally. The partial update of the image can be performed if only materials have been modified during the transaction. The option requires a RED::IWindow::FrameTracingImageLayers call to be used, with the RED::RenderLayer::LT_MATERIAL_ID layer activated. It does not work with materials that are modified and returned by custom ray-tracing callbacks (RED::IViewpointRenderList::SetViewpointSoftRayProcessingCallbacks) if these materials are not used by standard geometries in the scene graph.
OPTIONS_RAY_WORLD_CACHE_SAMPLES_COUNT	[integer]: [1,INT_MAX[. [default]: 10000. [scope]: All options instances. This option rules the number of samples that'll be calculated for a given world space cache. This applies to global illumination caches computed in world space and to shadow caches. Increasing the value will make finer caches that take a longer time to be processed.
OPTIONS_RAY_WORLD_CACHE_SAMPLES_SPREAD	[double]: [0.001, 1000.0]. [default]: 1.0. [scope]: All options instances. This option rules the coverage of a world cache sample when replayed by the GPU. This is the sphere of influence of samples that can be globally increased or decreased by changing this option. The sample spread value is applied as a multiplier on the world cache samples influence. Increasing the value will make the cache look smoother, but fine cache details may be blurred. Decreasing the value will make the cache exhibit more details, but 'bubbles' may appear due to lack of samples and of interpolation.
OPTIONS_RAY_TRANSPARENCY_TOLERANCE_GPU	[double]: [0.0, inf[. [default]: 0.001. [scope]: Resource manager only. This option rules the numerical tolerancy used by the GPU ray-tracer to let transparency ray takeoff during the GPU ray-casting process. Increasing this value may solve incorrect ray propagation in scene that have large units. Reducing this value may increase the numerical precision of the visible transparency layers crossed by fired GPU rays. Please note that the value of this option should be set once at the application startup. Please destroy the resource manager and re-create it to have this value changed during the course of the application, otherwise, the change may be ignored or improperly handled.
OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD	[double]: [0.0,1.0]. [default]: 0.0. [scope]: All options instances. This option rules the usage of adaptive sampling during the processing of an anti-aliased image. Adaptive sampling will run only if the image is calculated using several samples per pixel, as specified by the RED::IViewpointRenderList::SetSoftAntiAlias method. If the option value is set to 0.0, adaptive sampling is disabled. At higher values, the number of samples fired to generate an image may be cut if the measured signal contrast value appears to be below this threshold value. Turning on adaptive sampling for the ray-tracer must be done together with a change of the RED::OPTIONS_SAMPLER used by REDsdk. The REDsdk's HM sampler must be used for adaptive sampling to run. If the sampler is not set, then calls to RED::IWindow::FrameTracing will return RED_WFLOW_INVALID_SAMPLER. Typical values for adaptive sampling threshold are in the 0.001 - 0.01 range, starting at 0.005 to see the effect. Refer to Adaptive sampling for a detailed view of adaptive sampling in REDsdk.
OPTIONS_RAY_MAX_SECONDARY_RAY_INTENSITY	[double]: [ 1.0, DBL_MAX [. [default]: 100.0. [scope]: All options instances. This options can be used to clamp the intensity of very bright secondary rays in the image. Secondary rays are reflection and refraction rays. These rays may become very bright when they randomly directly hit visible light sources geometries that are very intense. When this arises and if the sampling quality is not set high enough, these very bright rays tend to add some unpleasant noise in the image (also called fireflies). This option introduces a bias in the final image as the real signal can be clamped if it exceeds the specified threshold level. To disable this option, set it to DBL_MAX. To increase the effect of this option, reduce the max intensity value.
OPTIONS_RAY_ENABLE_DENOISER	[boolean]: [false,true]. [default]: false. [scope]: All options instances. This option turns on the denoiser that can modify software generated images during a post calculation pass. The denoiser will try to remove noise in the image while preserving all its details. The strength of this effect is ruled by the RED::OPTIONS_RAY_DENOISER_STRENGTH and RED::OPTIONS_RAY_DENOISER_RADIUS options.
OPTIONS_RAY_DENOISER_STRENGTH	[double]: [ 0.01, 10.0 [. [default]: 1.0. [scope]: All options instances. This option defines the strength of the denoising effect applied to software generated images if the RED::OPTIONS_RAY_ENABLE_DENOISER is activated. The strength can be assimilated to a kind of blur effect applied to the image. If set to a stronger value, the denoiser will smooth more details in the image, resulting in a less noisy result but at the expense of losses in the details in the original image.
OPTIONS_RAY_DENOISER_RADIUS	[integer]: [ 0, 100 ]. [default]: 10. [scope]: All options instances. This option defines the effect radius of the denoising effect applied to software generated images if the RED::OPTIONS_RAY_ENABLE_DENOISER is activated. A larger radius means that the denoiser will analyze more samples to remove the noise in an image, increasing the time it'll take to denoise the image and possibly increasing the quality of the result. Increasing the radius will strengthen the denoising effect too.
OPTIONS_RAY_TRANSPARENCY_FFP_GPU	[boolean]: [false,true]. [default]: false (disabled). [scope]: All options instances. This option rules the kind of GPU shaders used by the GPU hardware transparency. By default REDsdk's GPU ray-tracing shaders are using REDsdk's high definition viewing matrices that can provide an increased numerical accuracy during ray propagations. Turning on this option will force REDsdk's ray- traced GPU transparency to use legacy Fixed Function Pipeline matrices instead of high definition matrices. Turning on this option might be required in a mixed GPU rendering environment where different shaders have to co-exist for the rendering of a single frame, so that all shaders are based on the same numerical accuracy.
OPTIONS_RAY_ADAPTIVE_SAMPLING_ALLOWED_TIME	[ double ] : [ 0.0, inf [ in seconds. [ default ] : 0.0. [ scope ] : All options instances. This option works when Adaptive sampling is enabled for the currently rendered scene. It forces the engine to stop all calculations after the specified amount of time has been spent. This option can be used to drive the quality of the resulting image by specifying an amount of time allowed to calculate it. The engine will optimize the amount of time it's granted to refine the most noisy areas in an image first, trying to provide the best image quality for the allowed time. This is time driven adaptive sampling; If the option value is set to 0 seconds, time driven adaptive sampling is turned off and the value of the RED::OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD rules adaptation. If set to any positive value, expressed in seconds, this option overrides the RED::OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD whose value is ignored as not used in that case. The minimal amount of time taken to process an image is bound by the time taken to process global illumination plus the time taken to do a first parsing of the image based on rendering settings. Images processed when this option is turned on are not deterministic as the amount of calculations the engine can issue in a fixed amount of time depends on the target computer number of threads and workload of the system at the time of the processing.
OPTIONS_PATH_GI	[integer]: [0,100]. [default]: 3. [scope]: All options instances. Sets the number of bounces used to compute the global illumination. This option has an effect only if path tracing is used to render the image. As you increase the value of that option, the global illumination becomes more accurate but the rendering time increases. The default value is 3 which differs from what you get with the GI cache (the GI cache computes an infinite number of GI bounces). This leads to darker images when using path-tracing comparing to using the GI cache. To get similar results with both methods, you need to increase the option value to something high. This option overcomes the value of the RED::OPTIONS_RAY_GI one.
OPTIONS_RAY_GI_ESTIMATOR_FULL_PATH	[ boolean ]: [ false, true ]. [ default ] : false (disabled). [ scope ]: All options instances. If turned on, this option modifies the behavior of the GI estimator phase. GI paths that are processed by the system are fully processed until their extinction. This significantly extends the GI estimator phase calculation time, but increases its quality for that extra price. Noticeably, estimator halos that can be visible in very indirectly illuminated scenes tend to be smaller or to disappear and the estimator is more reliable and stable to camera movements and options changes. Please note that this option should be combined with a high value of RED::OPTIONS_RAY_GI_ESTIMATOR_SAMPLING_RATE. The refinement of the estimator will be better when the estimator sampling rate is increased to high values like 2000, 4000 or even 8000.

enum RED::PLATFORM

Enumerator:

PTM_UNKNOWN
PTM_WINDOWS
PTM_LINUX
PTM_MACOS
PTM_COUNT

enum RED::POLYGON_WINDING_RULE

Lists polygon winding rule. See RED::IMeshShape::Polygon.

Enumerator:

PWR_ODD	Fill odd numbers, default setting.
PWR_NON_ZERO	Fill non-zero numbers.
PWR_POSITIVE	Fill positive numbers.
PWR_NEGATIVE	Fill negative numbers.
PWR_ABS_GEQ_TWO	Fill ABSolute values Greater than EQual to TWO.

enum RED::PRODUCT

Aliases for the Redway3d products. Internal to redway3d.

Redway3d products supported platforms.

Enumerator:

PROD_UNKNOWN
PROD_REDEXPORTER_MAX
PROD_REDODADEVICE
PROD_REDSDK
PROD_REDPARASOLID
PROD_REDMATERIALEDITOR
PROD_REDC3D
PROD_REDNET
PROD_REDART
PROD_COUNT

enum RED::PROPERTY_TYPE

Lists the available type for material controller properties.

Enumerator:

PYT_UNDEFINED	The property has undefined type. This is the default type for newly created properties.
PYT_FLOAT	The property is a numerical floating value in [-FLT_MAX, FLT_MAX] (except if the definition range has been modified using SetRange).
PYT_INTEGER	The property is a numerical integer value in [INT_MIN, INT_MAX] (except if the definition range has been modified using SetRange).
PYT_BOOLEAN	The property is a boolean value in { true, false }.
PYT_COLOR	The property is a RGBA color with each component in [0, 1].
PYT_TEXTURE2D	The property is a pointer to a RED::Object instance implementing RED::IImage2D.
PYT_STRING	The property is a string.
PYT_TEXTURE3D	The property is a pointer to a RED::Object instance implementing RED::IImage3D.
PYT_TEXTURECUBE	The property is a pointer to a RED::Object instance implementing RED::IImageCube.
PYT_VECTOR4	The property is a four dimensions vector
PYT_LAYERSET	The property is a layer set.
PYT_TEXTURECOMPOSITE	The property is a pointer to a RED::Object instance implementing RED::IImageComposite.

enum RED::RENDER_MODE

Lists all rendering configurations of a light. These parameters are used to define the behavior of the light.

Enumerator:

RM_SHADOW_CASTER	Is the light casting shadows or not ?
RM_TEX_INTENSITY_RAMP_RES	Resolution of the intensity ramp texture being used. Default set to 8192 pixels, which is then clamped to the used hardware limits.
RM_TEX_CUBEMAP_SPOT_RES	Resolution of the spot's cube map being used. Default set to 256 x 256 pixels per face.
RM_TEX_RADIAL_BEAM_RES	Resolution of the radial beam texture being used. Default set to 256 x 256 pixels.
RM_SHADOW_MAP	Use shadow maps for this light as the shadow projection method. A light with shadow maps activated won't project any ray-traced shadow.
RM_ACTIVATED	Is the light source currently activated ? An inactive light source is ignored for the rendering, but remains in the scene however.
RM_DOUBLE_SIDED	Is the light source double sided? Apply to physical lights only.
RM_CAUSTICS	Does the light source generate caustics? Apply to physical lights (including the sun) with no IES profile only.
RM_VISIBLE_GEOMETRY	If this rendering mode is set to zero, then physical lights geometries and skylight portals will become invisible.
RM_DEFINE_VOLUME	Does the light defines volume when used with RED::VolumetricEffectLightVolume? Not all types of light can define light volumes. Please see RED::VolumetricEffectLightVolume for more informations. This render mode is ignored for non-compatible lights.
RM_ENLIGHTEN_VOLUME	Does the light enlighten participating media during volumetric rendering?
RM_BAKED	If this rendering mode is set to any non zero value, then the light is ignored for all lighting passes. However, it participates to the calculation of a GI cache, using RED::IWindow::FrameTracingGICache. Please refer to Light baking for details on light baking.
RM_SINGLE_SIDED_BIAS	This is a value that can be used to modify the behavior of the RED::ILightShape::SetShadowBias method. By default (value = 0), the shadow bias offset the hit point along the normal at the hit surface, taking into consideration the visible face of the surface. This means that if we see the back side of a double sided surface, the normal is reverted and the shadow bias offsets the hit point along this reverted normal. If the option is enabled (value != 0), then the shadow bias always offset the hit point along the original surface normal with no back side normal inversion.
RM_USE_EXACT_LIGHT_PROB	This rather cryptic light option can be turned on to increase the accuracy of the probabilistic calculations that occur while sampling lights. If some place in an image appears too noisy for the sampling quality set for the rendering, enabling this render mode for all lights that surround the noisy aera will help reducing the noise. Turning on this render mode costs some extra render time.
RM_USE_MIS	This rendering mode toggles the use of multiple importance sampling for the visibility of this light in glossy reflections or refractions. By default, the usage of multiple importance sampling is enabled (value = 1). Turning it off (value = 0) will result in lower quality reflections of light emitter shapes. Turning off multiple importance sampling for a light may remove some indirect sampling artifacts for that light that can be oberved after several ray bounces. Turning off multiple importance sampling for ALL lights will save some calculation time in the image.
RM_COUNT	Number of terms in this enumeration.

enum RED::RENDERING_PASS

Defines the various GPU rendering passes that compose the rendering of a frame by the GPU.

Enumerator:

RPA_UNDEFINED_PASS
RPA_CONTEXT_CULLING	CPU context culling pass for the global scene graph. Time is spent in this pass to parse the entire model to display for the considered camera in the rendered VRL. The RED::IShape::SetContextSwitchCallback time is included in that pass time.
RPA_VISIBILITY_CULLING	CPU visibility culling pass for the global scene graph. Time is spent in this pass to determine the subset of the scene that is directly visible from the considered camera. The RED::IShape::SetVisibilitySwitchCallback time is included in that pass time.
RPA_LIGHT_CULLING	CPU light source culling pass for the global scene graph. Time is spent in this pass to determine the subset of the scene that is visible from the light, in the considered camera.
RPA_RAY_DATABASE_UPDATE	CPU or GPU update time for any ray-tracer acceleration structure. Both the GPU ray-tracer of the software ray-tracer are using acceleration structures. Time spent for the creation, update or destruction of any acceleration structure appear here.
RPA_PRELIT_OPAQUE	GPU pre-lighting pass for opaque elements. This is the time spent for the rendering of the RED::MTL_PRELIT pass, for opaque elements, for the considered camera in the rendered VRL.
RPA_PRELIT_TRANSPAR	GPU pre-lighting pass for transparent elements. This is the time spent for the rendering of the RED::MTL_PRELIT pass, for transparent elements, for the considered camera in the rendered VRL.
RPA_LIT_OPAQUE	GPU lighting pass for opaque elements. This is the time spent for the rendering of the RED::MTL_LIT pass, for opaque elements, for the considered camera in the rendered VRL.
RPA_LIT_TRANSPAR	GPU lighting pass for transparent elements. This is the time spent for the rendering of the RED::MTL_LIT pass, for transparent elements, for the considered camera in the rendered VRL.
RPA_POSTLIT_OPAQUE	GPU post-lighting pass for opaque elements. This is the time spent for the rendering of the RED::MTL_POSTLIT pass, for opaque elements, for the considered camera in the rendered VRL.
RPA_POSTLIT_TRANSPAR	GPU post-lighting pass for transparent elements. This is the time spent for the rendering of the RED::MTL_POSTLIT pass, for transparent elements, for the considered camera in the rendered VRL.
RPA_COMPOSITE_IMAGE	GPU composite image rendering pass. Such passes may occur before any other pass, on the need to update the contents of a composite image before a draw.
RPA_SHADOW_MAP_OPAQUE	GPU rendering of a shadow map for opaque elements. The rendering of a shadow map includes several sub-passes. See Customized shadow mapping for details.
RPA_SHADOW_MAP_TRANSPAR	GPU rendering of a shadow map for transparent elements. The rendering of a shadow map includes several sub-passes. See Customized shadow mapping for details.
RPA_GI_CACHE_OPAQUE	GPU global illumination cache replay pass for opaque objects.
RPA_GI_CACHE_TRANSPAR	GPU global illumination cache replay pass for transparent objects.
RPA_INDIRECT_PRELIT_OPAQUE	GPU indirect pre-lighting pass for opaque elements.
RPA_INDIRECT_PRELIT_TRANSPAR	GPU indirect pre-lighting pass for transparent elements.
RPA_INDIRECT_LIT_OPAQUE	GPU indirect lighting pass for opaque elements.
RPA_INDIRECT_LIT_TRANSPAR	GPU indirect lighting pass for transparent elements.
RPA_INDIRECT_POSTLIT_OPAQUE	GPU indirect post-lighting pass for opaque elements.
RPA_INDIRECT_POSTLIT_TRANSPAR	GPU indirect post-lighting pass for transparent elements.
RPA_INDIRECT_SHADOW_MAP_OPAQUE	GPU indirect rendering pass of a shadow map for opaque elements.
RPA_INDIRECT_SHADOW_MAP_TRANSPAR	GPU indirect rendering pass of a shadow map for transparent elements.
RPA_INDIRECT_BACKGROUND	GPU indirect rendering pass for background visibility.
RPA_GPU_RAY_TRANSPARENCY	GPU internal ray-tracer pass. Several occurrences of this pass may be recorded for all the different rays that have to be propagated by the GPU ray-tracer.
RPA_GPU_RAY_TID	GPU internal ray-tracer pass. Several occurrences of this pass may be recorded for all the different rays that have to be propagated by the GPU ray-tracer.
RPA_GPU_RAY_POSITIONS	GPU internal ray-tracer pass. Several occurrences of this pass may be recorded for all the different rays that have to be propagated by the GPU ray-tracer.
RPA_GPU_RAY_DIRECTIONS	GPU internal ray-tracer pass. Several occurrences of this pass may be recorded for all the different rays that have to be propagated by the GPU ray-tracer.
RPA_GPU_RAY_NORMALS	GPU internal ray-tracer pass. Several occurrences of this pass may be recorded for all the different rays that have to be propagated by the GPU ray-tracer.
RPA_GPU_RAY_CUTOFF	GPU internal ray-tracer pass. Several occurrences of this pass may be recorded for all the different rays that have to be propagated by the GPU ray-tracer.
RPA_SIZE	Size of the RED::HARDWARE_RENDERING_PASS enumeration.

enum RED::RENDERING_PROGRESS_STEP

Defines the various steps that compose the rendering of a frame by the software ray tracer.

Enumerator:

RPS_RENDER_NOT_STARTED	The rendering of the image has not been started yet.
RPS_GI_ESTIMATOR_PROCESSING	The Global illumination estimator is being processed.
RPS_GI_CACHE_PROCESSING	The Global illumination cache is being processed.
RPS_CAUSTICS_PROCESSING	The caustics map is being processed.
RPS_RAY_TRACING_PROCESSING	The ray-tracing of the image is being processed (including anti-aliasing).
RPS_DENOISER_PROCESSING	The image denoiser is running after the ray-traced image has been processed.
RPS_HARDWARE_RENDERING	The rendering of the frame is being processed by the hardware. This is only informative has no progression can be precisely measured while using the GPU.
RPS_RENDER_COMPLETE
RPS_WORLD_GI_CACHE_PROCESSING	The GI cache definition for the entire scene is being processed. This step comes before other GI cache passes when a world cache is being generated.
RPS_SIZE

enum RED::ROOT_MOTION_COMPONENT

Identification of a root motion component for the RED::ISkeletalAnimationController.

Enumerator:

RMC_ROTATION	Rotation root motion option.
RMC_POSITION_X	Root motion option for the X component of the position.
RMC_POSITION_Y	Root motion option for the Y component of the position.
RMC_POSITION_Z	Root motion option for the Z component of the position.

enum RED::ROOT_MOTION_POLICY

Value to give to the root motion options.

Enumerator:

RMP_DEFAULT	The default value for the root motion component: applies the animation result to the root bone.
RMP_CUMULATIVE	Cumulates the animation deltas and applies the result to the root bone.
RMP_DELTA	Sets the animation deltas to the root bone.
RMP_ZERO	Ignores the animation root motion and sets the root bone transforms to zero.

enum RED::RSV_TYPE

Defines the type of primitives that can be shaded using the RenderShaderViewport shader.

Enumerator:

RSV_TRIANGLE	Triangle-based primitives. Primitives must have their normals defined, using a regular xyz or xyzw encoding in RED::MFT_FLOAT or RED::MFT_DOUBLE precision.
RSV_LINE	Line-based primitives, i.e primitives without normals.
RSV_TRIANGLE_UBYTE_NORMALS	Triangle-based primitives. Primitives must have their normals defined using a xyzw RED::MFT_UBYTE encoding. w is unusued, but needed for memory alignment.

enum RED::SOFT_GEOMETRY_PRIMITIVE

Lists different types of geometrical primitives that can be received and produced by a software geometry shader.

Enumerator:

GEO_UNMODIFIED	Indicates that the source primitive kind is not modified. The source primitive assembly is not modified either.
GEO_POINTS	The geometry shader receives or generates indexed points.
GEO_LINE_SEGMENTS	The geometry shader receives or produces indexed line segments.
GEO_LINE_SEGMENTS_ADJACENCY	The geometry shader receives indexed segments with adjacency.
GEO_LINE_STRIP	The geometry shader receives or produces one indexed line strip.
GEO_TRIANGLES	The geometry shader receives or produces indexed triangles.
GEO_TRIANGLES_ADJACENCY	The geometry shader receives indexed triangles with adjacency.

enum RED::TARGET

Lists all possible texture bindings modes for the rendering. A texture need to be bound in a precise manner to be used by the graphical hardware.

Enumerator:

TGT_NONE	The texture is not bound to any valid target. It won't show up anything on screen.
TGT_TEX_1D	The texture is a single dimension texture, and can be accessed with a single texture coordinate in the [0,1] range. The image bound that way must be a POTD dimensioned texture.
TGT_TEX_2D	The texture is a two dimensions texture, and can be accessed with two texture coordinates in the [0,1] x [0,1] range. The image bound that way must be a POTD dimensioned texture.
TGT_TEX_RECT	The texture is a rectangle texture. Unlike the other texture formats, it's accessed with 2D texture coordinates in the [0,width] x [0,height] range, where width and height are the pixel dimensions of the texture. Both POTD and NPOTD (Non-POTD) textures can be set to the rectangular target.
TGT_TEX_CUBE	The texture is a cube texture. This can be used for all environmental mapping effect. It's sampled using a spatial direction [s,t,r].
TGT_TEX_3D	The texture is a three dimensions texture, and can be accessed with three texture coordinates in the [0,1] x [0,1] x [0,1] range. The image bound that way may be POTD or NPOTD textures.

enum RED::TEXT_ALPHA_MODE

Chooses the text alpha interpolation method for a RED::RenderShaderText.

Enumerator:

TEXT_ALPHA_LINEAR	Alpha is linearly interpolated.
TEXT_ALPHA_3A2_MINUS_2A3	Uses an alpha interpolation formula based on the 3(aa) - 2(aa*a) equation.
TEXT_ALPHA_SQRTA	Uses an alpha interpolation formula based on sqrt(a).
TEXT_ALPHA_LINEAR_DEPTH	Same as TEXT_ALPHA_LINEAR; the text custom depth channel is used to redefine the final depth of the text in the z-buffer.
TEXT_ALPHA_3A2_MINUS_2A3_DEPTH	Same as TEXT_ALPHA_3A2_MINUS_2A3; the text custom depth channel is used to redefine the final depth of the text in the z-buffer.
TEXT_ALPHA_SQRTA_DEPTH	Same as TEXT_ALPHA_SQRTA; the text custom depth channel is used to redefine the final depth of the text in the z-buffer.

enum RED::TEXT_ATTACH_POS

Relative position of a text to its anchoring point:

Enumerator:

TAP_TOP_LEFT	The top left corner of the text bounding rectangle will be placed at the anchoring position.
TAP_TOP	The middle of the top line of the text bounding rectangle will be placed at the anchoring position.
TAP_TOP_RIGHT	The top right corner of the text bounding rectangle will be placed at the anchoring position.
TAP_RIGHT	The middle of the right line of the text bounding rectangle will be placed at the anchoring position.
TAP_BOTTOM_RIGHT	The bottom right corner of the text bounding rectangle will be placed at the anchoring position.
TAP_BOTTOM	The middle of the bottom line of the text bounding rectangle will be placed at the anchoring position.
TAP_BOTTOM_LEFT	The bottom left corner of the text bounding rectangle will be placed at the anchoring position.
TAP_LEFT	The middle of the left line of the text bounding rectangle will be placed at the anchoring position.
TAP_CENTER	The center of the text bounding rectangle will be placed at the anchoring position.
TAP_BASELINE_LEFT	The point of the left edge of the text bounding rectangle that corresponds to the height of the text baseline will be placed at the anchoring position.
TAP_BASELINE_CENTER	The point at the middle of the text bounding rectangle width and at the height that corresponds to the height of the text baseline will be placed at the anchoring position.
TAP_BASELINE_RIGHT	The point of the right edge of the text bounding rectangle that corresponds to the height of the text baseline will be placed at the anchoring position.
TAP_TOP_LEFT_EDGE	The leading leftmost vertical edge of the character is used as "left edge" reference. Then, we combine this with the top edge of the text bounding rectangle to get the anchoring position. Technically speaking, we ignore negative glyph origins (gmetrics.gmptGlyphOrigin.x) to anchor the string.
TAP_BOTTOM_LEFT_EDGE	The leading leftmost vertical edge of the character is used as "left edge" reference. Then, we combine this with the bottom edge of the text bounding rectangle to get the anchoring position. Technically speaking, we ignore negative glyph origins (gmetrics.gmptGlyphOrigin.x) to anchor the string.
TAP_LEFT_EDGE	The leading leftmost vertical edge of the character is used as "left edge" reference. Then, we combine this with the middle of the text bounding rectangle to get the anchoring position. Technically speaking, we ignore negative glyph origins (gmetrics.gmptGlyphOrigin.x) to anchor the string.
TAP_BASELINE_LEFT_EDGE	The leading leftmost vertical edge of the character is used as "left edge" reference. Then, we combine this with the baseline of the text bounding rectangle to get the anchoring position. Technically speaking, we ignore negative glyph origins (gmetrics.gmptGlyphOrigin.x) to anchor the string.

enum RED::THREAD_PRIORITY

Thread priority. Used on Windows systems only. These values are ignored on other systems.

Enumerator:

TP_LOWEST	Lowest thread priority.
TP_LOW	Low thread priority.
TP_NORMAL	Normal thread priority.
TP_HIGH	High thread priority.
TP_HIGHEST	Highest thread priority.

enum RED::TONEMAPPING_OPERATOR

Lists the possible tone mapping operators which can be applied to images.

Enumerator:

TMO_CLAMP	RGBA color components are clamped to [0.0, 1.0].
TMO_PHOTOGRAPHIC	Tone mapping operator derived from photographers' best practices.
TMO_NEUTRAL	This is the neutral 'no tone mapping' operator that does not change any input intensities.
TMO_EXPOSURE	Tone mapping operator that simply multiplies the input intensities by the exposute parameter value.
TMO_EXPONENTIAL	Exponential tonemapping operator based on the average luminance in an image.

enum RED::TRANSACTION_MODE

Lists the current transaction mode we're in.

Enumerator:

TRANSACTION_OUT	Indicates that we're outside of a transaction. We can't modify any state sensitive data in the cluster.
TRANSACTION_IN	Indicates that we're inside a transaction. We can modify state sensitive objects in the cluster, using the state instance got from the RED::IResourceManager interface.

enum RED::VIEWPOINT_TYPE

Lists the possible projections for a viewpoint.

Enumerator:

VPT_PARALLEL	Orthographic viewpoint projection. See RED::IViewpoint::SetFrustumParallel.
VPT_PERSPECTIVE	Perspective viewpoint projection. See RED::IViewpoint::SetFrustumPerspective.
VPT_CUSTOM	Custom viewpoint projection. See RED::IViewpoint::SetFrustumCustom.

enum RED::VRL_SIZEPOS

Enumerates all anchoring and resizing behaviors of a viewpoint that is inserted in a VRL.

Enumerator:

VSP_ANCHOR_FIXED	Specify this parameter when inserting a viewpoint in a VRL to specify that on a REDWindow::Resize operation, the coordinates of the viewpoint anchor will remain fix. When the window is too small to encapsulate the entire viewpoint, it is being cropped to the window dimensions.
VSP_ANCHOR_STRETCHED	Specify this parameter when inserting a viewpoint in a VRL to specify that on a REDWindow::Resize operation, the coordinates of the viewpoint anchor will move proportionally to the window size change ratio. For example, an anchor at 100,50 in a 640,480 window will be moved at 100x800/640,50x600/480 during a resize operation that turns the 640,480 pixels window in a 800,600 pixels window.
VSP_SIZE_FIXED	Specify this parameter when inserting a viewpoint in a VRL to specify that on a REDWindow::Resize operation, the viewpoint size remain fixed, whatever may be the movement of it's anchor. If the viewpoint is too wide to be fully contained in the window, it is cropped.
VSP_SIZE_STRETCHED	Specify this parameter when inserting a viewpoint in a VRL to specify that on a REDWindow::Resize operation, the viewpoint size vary as the vrl size is changing. The viewpoint ratio is not modified, meaning that a cube will be distorted if the vrl's height / width ratio is being modified.
VSP_SIZE_STRETCHED_AUTO_RATIO	Specify this parameter when inserting a viewpoint in a VRL to specify that on a REDWindow::Resize operation, the viewpoint size vary with the vrl size change. The viewpoint height / width (or vertical fov / horizontal fov) ratio is maintained equal to the vrl height / width ratio, meaning that the rendering of a cube remains seen as a cube whatever may be the vrl size it's in.

enum RED::VRL_SORT

Defines the viewpoint list ordering in the RED::IViewpointRenderList.

Enumerator:

VST_FRONT	Indicates to target the foreground list of viewpoints in a VRL. Foreground viewpoints are drawn over scene and back viewpoints.
VST_SCENE	Indicates to target the scene list of viewpoints in a VRL.
VST_BACK	Indicates to target the background list of viewpoints in a VRL. Background viewpoints are drawn behind scene and foreground viewpoints.

enum RED::WRAP_MODE

Lists the possible texturing wrap modes for a texture.

Enumerator:

WM_REPEAT	Repeat the texture pattern out of the texture's limits.
WM_MIRRORED_REPEAT	Repeat the texture pattern with an inversion of the texture out of the texture's limits.
WM_CLAMP	The texture sampling result is zero outside of the texture's limits.
WM_CLAMP_TO_EDGE	The texture sampling results remain slightly inside the texture when it's out of the texture's limits.
WM_CLAMP_TO_BORDER	The texture sampling results are set to the texture's border color when it's out of the texture's limits.

Types documentation

typedef void(* RED::BATCH_SYNC_CALLBACK)(void *iUserData)

Prototype of the batch synchronization callback.

This callback can be helpful in high performance multi-threaded rendering environments to control the edition flow of rendering batches that are bypassing the regular transaction system.

Shared geometry data channels or indices are bypassing the REDsdk's transaction system: one single array can be used as source of the data for a geometry. Consequently, modifiying the contents of a shared array in an auxiliary thread while the engine is rendering can be fatal to the application or can lead to visual artifacts.

During the startup of a RED::IWindow::FrameDrawing, the engine synchronizes all the data that have to be visualized on the GPU. This task occurs at the early startup of the rendering call. Once this step is over, shared geometrical data can be safely modified in a multi-threaded context.

The purpose of this callback is to indicate that the GPU geometrical data synchronization is over.

Parameters:

iUserData:

A user data pointer specified by RED::IResourceManager::SetBatchSyncCallback.

typedef RED_RC(* RED::IChunkInterpreterProto)(RED::IReferenceManager *iReferenceManager, RED::IStream *iStream, const RED::StreamingPolicy &iPolicy, unsigned int iChunkSignature, RED::uint64 iChunkSize, RED::Object **oResult, const RED::State &iState)

Method used to translate a raw stream into engine data.

Parameters:

iReferenceManager:	The object instance used to solve all links between chunk parameters (crossed references, shared resources, etc...)
iStream:	The source stream.
iChunkSignature:	Chunk number.
iChunkSize:	Byte size of the chunk.
oResult:	Created object.
iState:	Current transaction.

Returns:

RED_OK in case of success,
RED_BAD_PARAM for all invalid inputs,
RED_ALLOC_FAILURE upon a memory allocation failure,
RED_FAIL otherwise.

typedef RED_RC(* RED::IMAGE_TOOLS_LOAD_CALLBACK)(RED::Object *oImage, const RED::String &iFilePath, RED::FORMAT iPixelFormat, bool iVerticalFlip, bool iLocalStorage, RED::TARGET iTarget, const RED::State &iState)

Prototype of the RED image custom format loading.

Parameters:

oImage	pointer to the returned image. This image must have been properly created before the call (and must implement RED::IImage and RED::IImage2D interfaces).
iInput	reference to the input stream.
iImageFormat	image file format.
iPixelFormat	requested pixel format for the returned image.
iVerticalFlip	true to flip the loaded image lines of pixels vertically, false to let it unchanged.
iLocal	true to load the image in the local (CPU memory) storage of the image, false to load it directly in the graphics card memory. If iLocal is true, then the source pixel array is kept in the local storage of the image regardless of the value of iTarget. If iLocal is false, the source pixel array is loaded and then set into the image with possible formats & conversions depending on the hardware backend capabilities and value of iTarget. For instance, a non-power-of-two (NPOTD) image can be loaded and will remain as NPOTD in the local storage while it'll be turned into a power-of-two (POTD) image if iLocal is false and iTarget is RED::TGT_TEX_2D for instance.
iTarget	this specifies the target of the loaded image once in the graphics card memory. Note that the target must be chosen in accordance with the requested iPixelFormat.
iState	current transaction.

Returns:

RED_OK on success,
other RED_RCs from the custom callback.

typedef RED_RC(* RED::INSTANCE_COUNTER_CALLBACK)(RED::Vector4 &oReferenceValue, int iUid, const RED::Vector< RED::Object * > &iInstancePath, void *iUserData)

Prototype of the instance counter callback.

The instance counter callback is used with the RED::RenderShaderParameter::REF_INSTANCE_COUNTER reference. The callback is useless if the reference is not used in a shader to leverage all values it has returned.

The callback receives several parameters:

An object UID: This is an unique ID. Two objects in the camera that visualizes the scene graph can't have the same ID (note that two objects in different cameras may have the same ID, the uniqueness is granted at the camera level).
A shape path from the root of the scene down to the object instance itself. This shape path uniquely identifies the instance.

The callback returns a RED::Vector4 that contains the value that will be received by the shader using the reference for this specific object instance.

See Using instance counters for a practical example of using instance counters.

Parameters:

oReferenceValue:	The result of the callback.
iUid:	The object instance unique ID.
iInstancePath:	The path from the root down to the object instance corresponding to 'iUid'. The leaf of this vector is the instanced object shape itself.

Returns:

Any RED_RC is authorized here. RED_OK in case of success.

typedef RED_RC(* RED::INSTANCE_COUNTER_IMAGE_CALLBACK)(RED::Object *&oReferenceValue, int iUid, const RED::Vector< RED::Object * > &iInstancePath, void *iUserData)

Prototype of the instance counter callback for image parameters.

This callback works as the RED::INSTANCE_COUNTER_CALLBACK prototype, but it's used to associate images to instances rather than values. This callback works with the RED::RenderShaderParameter::REF_INSTANCE_COUNTER_IMAGE reference.

See the RED::INSTANCE_COUNTER_CALLBACK documentation for details on the callback mechanism.

See Using instance counters for a practical example of using instance counters.

Parameters:

oReferenceValue:	The result of the callback.
iUid:	The object instance unique ID.
iInstancePath:	The path from the root down to the object instance corresponding to 'iUid'. The leaf of this vector is the instanced object shape itself.

Returns:

Any RED_RC is authorized here. RED_OK in case of success.

typedef unsigned RED::int(__stdcall *THREAD_CALLBACK)(void *iThreadClass)

Threaded method prototype.

The argument of the method is the RED::Thread class instance that has launched the thread itself. To retrieve user arguments, use RED::Thread::GetUserArgument.

Parameters:

iThreadClass:

The thread class address.

Returns:

0 in case of success, any other value in case of error. Thread errors should be set using RED::Thread::StopRun.

typedef int __w64 RED::int64

typedef bool(* RED::INTERRUPT_CALLBACK)(void *iUserData)

Prototype of the RED rendering interruption method.

If a RED::IResourceManager::SetInterruptCallback call occurs, a method with that prototype is called by the engine during rendering phases, to figure out whether we need to stop the rendering (returns true) or not (returns false).

Parameters:

iUserData:

A user data pointer specified by RED::IResourceManager::SetInterruptCallback.

typedef void(* RED::LoadChunkNotificationCallback)(RED::uint64 iSize, void *iParameter)

typedef void(* RED::OPENGL_BUFFER_CALLBACK)(void *iUser)

Prototype of the OpenGL buffer customization callback.

This callback can be used to do custom OpenGL rendering configuration down the rendering pipeline of REDsdk. It gets called once each time RED::IResourceManager::EndState is called.

On invocation, an OpenGL context corresponding to the rendering pass is already set. According to REDsdk contexts sharing rules (see Managing multiple windows and external OpenGL contexts), this context is shared with all other contexts in REDsdk so there should be no need to change it.

Parameters:

iUser:

User data specified during the callback setup.

typedef void(* RED::OPENGL_MATERIAL_CALLBACK)(RED::Object *iWindow, RED::Object *iVRL, RED::Object *iViewpoint, RED::Object *iMaterial, RED::MATERIAL_PASS iPass, RED::Object *iLight, unsigned int iShaderID, void *iUser)

Prototype of the OpenGL material customization callback.

This callback can be used to do custom OpenGL rendering configuration down the rendering pipeline of REDsdk. It gets called as many times as needed each time a material needs to be setup for the rendering of some data. Material setups occur for each window, viewpoint render list, viewpoint, material, shader pass and render shader. Based on culling results, geometrical primitive batching, instanciations, this method will be called whenever set.

Parameters:

iWindow:	The RED::IWindow being rendered. May be NULL for some internal rendering passes.
iVRL:	The RED::IViewpointRenderList being rendered. May be NULL for some internal rendering passes.
iViewpoint:	The RED::IViewpoint being rendered. May be NULL for some internal rendering passes.
iMaterial:	The REDsdk material object being rendered. May be NULL for some internal rendering passes.
iPass:	The current rendering pass. Note that there are many internal rendering passes for which iPass is RED::MTL_INTERNAL.
iLight:	NULL or the current light shape address we're rendering for.
iShaderID:	RED::Object::GetID value of the calling RED::RenderShader.
iUser:	User data specified during the callback setup.

typedef void(* RED::OPENGL_VIEWPOINT_CALLBACK)(RED::Object *iWindow, RED::Object *iVRL, RED::Object *iViewpoint, void *iUser)

Prototype of the OpenGL viewpoint customization callback.

This callback can be used to do custom OpenGL rendering configuration down the rendering pipeline of REDsdk. It gets called as many times as needed each time a viewpoint needs to be setup for the rendering of some data. Viewpoint setups occur for each window and viewpoint render lists and the callback is called accordingly.

Parameters:

iWindow:	The RED::IWindow being rendered.
iVRL:	The RED::IViewpointRenderList being rendered.
iViewpoint:	The RED::IViewpoint being rendered.
iUser:	User data specified during the callback setup.

typedef void(* RED::ProgressCallback)(const RED::String &iMessage, float iProgression, void *iUserData)

Prototype of the progress indicator callback.

iMessage text message depending on the current processing. iProgression progression of the current processing (in [0, 1]). iUserData custom user data associated with the callback.

typedef void(* RED::REDSDK_ERROR_CALLBACK)(RED_RC iRC, const char *iCaller, const void *iObject, const char *iExpression, const char *iInfo, void *iUser)

Prototype of the error handling callback.

This callback gets called each time a REDsdk error is being raised. The call will receive a number of informations that may help find out the source of the problem that caused the error to be raised. Use RED::IResourceManager::SetErrorCallback to setup an error callback.

The iRC is the error code. The iObject is the object address that has emitted the error code. This may be a user object (for example the address of a shape or of a material) or this may be an internal REDsdk object address. The iCaller is the calling method or function in REDsdk that has emitted the error. While this may sound meaningless, this information will help us answer you faster if we have to investigate the problem.

Then, two extra informations can be provided: a iExpression and iInfo strings. Both strings are optional but can provide relevant extra informations to understand the cause of the problem.

Please watch out to avoid re-entrance of rendering calls. Raising an application display panel from this callback may provoke recursive re-entering rendering calls (once created, the application event loop is called again to display the panel, and this provokes a paint event that calls a REDsdk rendering method again, while we're still in the process of handling an error).

Parameters:

iRC:	Error code.
iCaller:	Name of the calling method or function.
iObject:	Relevant object address for the error.
iExpression:	Called source expression string.
iInfo:	Extra information string.
iUser:	User data specified on callback setup.

typedef RED_RC(* RED::RENDERING_PROGRESS_CALLBACK)(const RED::FrameStatistics &iFrameStatistics, void *iUserData)

Prototype of the RED rendering progress method.

If a RED::IWindow::SetRenderingProgressCallback call occurs, a method with that prototype is called by the engine during the rendering of a frame to inform the application of the percentage of processing done.

Parameters:

iFrameStatistics:	Calculated frame statistics at the time of the call.
iUserData:	User data associated to the callback.

Returns:

The callback must return RED_OK to indicate a success, or any other valid RED_RC code to indicate that an error has occurred.

typedef RED_RC(* RED::SOFT_BUCKET_CALLBACK)(const RED::Object *iViewpoint, RED::ISoftBucket *ioISoftBucket, void *ioUserData)

Custom bucket definition callback

If this callback is set, the software ray-tracer uses this callback to fill the list of buckets to compute in the image.

This callback gets called each time a ray-tracer thread needs to work on a pixel region of the image. The REDISoftBucket interface can be used to 'feed' the software ray-tracer with new data to process.

This method is called while in a synchronization point between threads, so it should return as quickly as possible. The call will be issued from each calculation thread.

Parameters:

iViewpoint:	Camera being currently rendered in software.
ioISoftBucket:	Interface to the software ray-tracer for the manipulation of the list of software buckets to process.
ioUserData:	User data pointer.

typedef RED_RC(* RED::SOFT_GEOMETRY_SHADER)(RED::Vector< double >(&oVertexAttrib)[RED_VSH_NB_INPUTS], RED_VSH_INPUT(&oChannels)[RED_VSH_NB_INPUTS], int &oChannelsCount, RED::Vector< int > &oPrimitives, RED::SOFT_GEOMETRY_PRIMITIVE &oType, void *(iVertexAttrib[RED_VSH_NB_INPUTS]), RED::MESH_FORMAT iFormat[RED_VSH_NB_INPUTS], int iSize[RED_VSH_NB_INPUTS], int iVerticesCount, int *iIndex, int iCount, RED::SOFT_GEOMETRY_PRIMITIVE &iType, const double *iProgramLocal, const double *iModelViewMatrix, const double *iModelViewProjMatrix, const double *iModelMatrix)

SOFT_GEOMETRY_SHADER: Prototype of a software geometry vertex shader.

Geometry shaders can be used to modify the primitive assembly, unlike regular vertex shaders that are bound to the mesh input geometry.

Geometry shaders are declared through RED::ShaderString::GeometryShaderStart.

Each graphic primitive rendered by a material that is using a geometry shader will receive a call to the geometry shader to modify the input geometry channels. The geometry shader must include the vertex transformation to device space in all its calculations. The result of a geometry shader is sent to the pixel shader stage.

Most common rendering usages of the geometry shader include:

Double precision data processing, for all legacy hardware that have no native double precision support (in this specific case, the primitive assembly does not need any change).
Displacement mapping, through the dynamic creation of geometry resulting of a modification of the primitive assembly within the geometry shader.
Dynamic primitive generation (adaptative tessellation, etc...) using the same primitive assembly edition mechanism.

The geometry shader generates a list of transformed vertex attributes and the list of channels that corresponds to it. For example if the input mesh has 10 vertices with positions, normals and one UV channel and the geometry shader produces 50 vertices with positions, normals and UV transformed 3 times, we'll get the following:

oVertexAttrib[0]: Points to a vector of 50 * 4 doubles (homogeneous vertex out).
oVertexAttrib[1]: Points to a vector of 50 * 4 doubles (transformed normals).
oVertexAttrib[2]: Points to a vector of 50 * 4 doubles (source UV after transform).
oVertexAttrib[3]: Points to a vector of 50 * 4 doubles (source UV after transform).
oVertexAttrib[4]: Points to a vector of 50 * 4 doubles (source UV v).
oChannel[0] = RED_VSH_VERTEX.
oChannel[1] = RED_VSH_NORMAL.
oChannel[2] = RED_VSH_TEX0.
oChannel[3] = RED_VSH_TEX1.
oChannel[4] = RED_VSH_TEX2.

The first returned channel must be RED_VSH_VERTEX and 'oVertexAttrib[0]' must contain the transformed vertices coordinates in homogeneous space.

Then, the list of primitives has to be returned in 'oPrimitives'. Only one kind of primitive can be returned by the geometry shader. It's not necessarily of the same kind as the input one. The RED::GEO_UNMODIFIED primitive kind can be used to specify that the source indexed primitive list is not modified and therefore, 'oPrimitives' can be ignored. In this case, the rendering occurs using 'iPrimitives'.
The list of primitives is in indexed mode, as the source primitives are. The number of primitives is defined by the actual size used in 'oPrimitives'.

Parameters:

oVertexAttrib:	List of output vertex attributes. 4 doubles are returned for each vertex that is produced by the geometry shader. oVertexAttrib[0] is the list of vertex attributes for 'oChannels[0]'.
oChannels:	Output channels that are produced by the geometry shader.
oChannelsCount:	Number of valid output channels returned.
oPrimitives:	Output list of indexed geometry primitives (lines, triangles, points).
oType:	The produced primitive type. Can't be GEO_TRIANGLES_ADJACENCY.
iVertexAttrib:	Input vertex attributes array as defined in the source mesh and mapped by the RED::RenderCode specification.
iVerticesCount:	Number of input vertices.
iIndex:	The source indexed set of primitives.
iCount:	The number of source primitives.
iType:	The source primitive type.
iProgramLocal:	Input program local parameters (4 doubles for each program entry being defined by the shader parameters).
iModelViewMatrix:	Modelview matrix (object to view space). 16 doubles, column major.
iModelViewProjMatrix:	Modelview-Projection matrix (object to device space). 16 doubles, column major.
iModelMatrix:	Model matrix (object to world space). 16 doubles, column major.

Returns:

Any RED_RC value indicating an error, RED_OK in case of success. If an error is returned, the rendering stops for the object that was processed.

typedef RED_RC(* RED::SOFT_PIXEL_ANALYSIS_CALLBACK)(bool &oNext, const RED::ISoftRayContext &iRayContext, const RED::ISoftRenderingContext &iRenderingContext, void *iUser)

Prototype of a pixel analyzer callback method.

Defines the prototype for a pixel analyzer method. The pixel analysis callback is being called back for every pixel in the image that hits a geometrical primitive in the image. The propagation occurs for a primary pixel beam and starts with the closest hit primitive from the pixel beam startup. If oNext is returned set to true, the propagation of the pixel beam continues and returns all other primitives behind the last primitive that was hit.

Please note that the callback is repeatedly called for every non empty pixel in the image, taking advantage of multi-threading: there may be concurrent calls to the callback that occurs.

Parameters:

oNext:	If returned true, we'll continue the propagation of the pixel beam to see other primitives that could be behind the previously returned object.
iRayContext:	Software ray context with informations on the currently hit object.
iRenderingContext:	Rendering context of the image.
iUser:	User pointer as specified in RED::IViewpointRenderList::SetPixelAnalysisCallback.

Returns:

The callback must return RED_OK to indicate a success in processing the pixel. Any other RED_RC code can be returned to indicate an error.

typedef bool(* RED::SOFT_RAY_PROCESSING_INTERSECTION_CALLBACK)(double &oTHit, double &oTHit1, double &oTHit2, const double iE[3], const double iP[3], double iTIn, const RED::LayerSet *iLayerSet, int iNumThread, void *ioUserData)

Custom ray intersection callback.

If this callback is set, the ray-tracer uses it to get extra intersection information sourced from data which is not stored inside the scene graph of the camera. The callback is launched for each ray processed by the ray-tracer. It returns either an intersection or no intersection.

The ray is defined by [ iE, iP ], but is limited at its beginning by its ray real starting position defined by iE + iTIn * ( iP - iE ).

The callback returns oTHit which must be set to the parametric length of the source ray [ iE, iP ] at the intersection point. In addition to oTHit, oTHit1 and oTHit2 can be filled with any user proprietary data (UV coordinates for instance, or anything else relevant to the callback RED::SOFT_RAY_PROCESSING_SHADING_CALLBACK that'll be called afterwards).

Parameters:

oTHit:	Parametric length of the ray of the found intersection.
oTHit1:	Hit primitive user information.
oTHit2:	Hit primitive user information.
iE:	Ray starting position.
iP:	Ray ending position.
iTIn:	Ray starting position by parametric length on [ iE, iP ].
iLayerSet:	Layerset to consider that may be set by REDsdk during the processing of shadow rays. If a valid RED::LayerSet address is received by the callback, then the intersection callback should discard all custom geometries that don't match iLayerSet from its results.
iNumThread:	Number of the calling thread.
ioUserData:	User data pointer specified during callback setup.

Returns:

true if an intersection occurs, false otherwise.

typedef RED_RC(* RED::SOFT_RAY_PROCESSING_SHADING_CALLBACK)(double oDataChannel[RED::MCL_SIZE][4], double oGeoNormal[4], RED::Object *&oMaterial, RED::LayerSet *&oLayerSet, double iTHit, double iTHit1, double iTHit2, const double iE[3], const double iP[3], int iNumThread, void *ioUserData)

Custom ray shading callback.

If this callback is set, the ray-tracer uses it to gather shading informations for all the extra primitives being intersected by the means of the SOFT_RAY_PROCESSING_INTERSECTION_CALLBACK.

The shading callback is called after the intersection callback. Therefore, informations to return from the shading callback are relative to the last intersection found for the same iNumThread thread number. The last intersection data is accessible from ( iTHit, iE, iP ).

Parameters:

oDataChannel:	Data channel values to use at the shading point. All fields in this array should be filled accordingly to the RED::RenderCode binding specifications set in oMaterial for the shaders to be processed.
oGeoNormal:	Geometrical surface normal at the shading point. The geometrical normal may differ from the interpolated surface normal. This normal must be returned with valid values, and will be renormalized after the callback's return.
oMaterial:	The material address to use for the shading of the last hit primitive for that thread.
oLayerSet:	The layerset address to use for the shading of the last hit primitive for that thread. Note that the layerset object address (if any is returned) pointed to by this method must remain alive after the call as it'll be used 'as is' by the ray-tracer during shading calculations.
iTHit:	Parametric length of the ray at the intersection.
iTHit1:	Hit primitive user information.
iTHit2:	Hit primitive user information.
iE:	Ray starting position.
iP:	Ray ending position.
iNumThread:	Number of the calling thread.
ioUserData:	User data pointer specified during callback setup.

Returns:

RED_OK if the method has succeeded,
RED_FAIL otherwise.

typedef RED_RC(* RED::SOFT_SHADER_CALLBACK)(RED::SoftFrameBufferSample &ioFrameBufferSample, const RED::ISoftRayContext &iRayContext, const RED::ISoftShaderContext &iShaderContext, const RED::ISoftRenderingContext &iRenderingContext, const RED::Version &iVersion, void *iUserData)

Prototype of the software shading method.

This method defines the prototype of a software shading function. All shaders are defined through this prototype when the software ray-tracer is enabled.

The SOFT_SHADER callback is registered in the RED::HW_SOFT_TRACER platform, and is declared as a pixel shader in a RED::RenderShader using RED::ShaderString::SoftShaderStart.

The method is dynamically loaded from the specified DLL at runtime or has been specified as a custom shading callback with RED::IResourceManager::RegisterShadingCallback, and is executed in a multi-threaded environment.

The method receives all the parameter it needs for the production of its results: 'iRayContext', 'iShaderContext' and 'iRenderingContext' all define the shading parameters that can be accessed for the calculation.

Additional framebuffer informations are accessible from the RED::SoftFrameBufferSample data structure that is used as an I/O structure.

A software shader should at least write a color in the framebuffer.

Parameters:

ioFrameBufferSample:	Input / output structure containing framebuffer sample data.
iRayContext:	The current ray context.
iShaderContext:	The shader parameters.
iRenderingContext:	The global rendering context.
iVersion:	version of the shader being evaluated.
iUserData:	custom user data set in IResourceManager::RegisterShadingCallback.

Returns:

Any RED_RC is authorized.

typedef unsigned int __w64 RED::uint64

typedef RED_RC(* RED::USER_SWITCH_CALLBACK)(const RED::Object *iViewpoint, const RED::Object *iShape, RED::Vector< int > &iSelectedChildren, void *iUserData, int iStateNumber)

Prototype of a custom culling callback.

Defines the prototype for a culling callback. The callback receives the viewpoint that is rendering the shape that owns the callback and a list that must be filled with all indices of the children of the shape that are to be considered further for the rendering of the frame.

If the shape that owns the callback is a node:

If the node has three children, then it must return 0, 1 and 2 in iSelectedChildren to select all its children. Only numbers written to iSelectedChildren will be kept.
As a faster alternative, the node can tell the engine to keep all its children by writing a single negative value in iSelectedChildren.
All child numbers returned in iSelectedChildren must be written in growing order. If 2, 0, 1 is written in the selected children list, then 0 and 1 will be ignored. 0, 1, 2 should be written instead.

If the shape that owns the callback is a leaf:

If iSelectedChildren is returned empty, the shape will be discarded for the visibility defined by the callback.

See RED::IShape::SetContextSwitchCallback or RED::IShape::SetVisibilitySwitchCallback for details on the callbacks and the effects they produce.

See Using culling callbacks for visibility control for a practical callback usage example.

Parameters:

iViewpoint:	Rendered camera.
iShape:	Current shape whose child list is being culled.
iSelectedChildren:	Numbers of selected children in shape's list.
iUserData:	Custom user data set in the RED::IShape::SetContextSwitchCallback function.
iStateNumber:	The number of the rendered transaction.