namespace RED

Namespace of all REDsdk interfaces and classes.

Classes:

classAnimationClip
classAnimationData
classBoundingSphere
classChunkInterpretersDictionary
classCID
classColor
classFactory
classFastRandom
classFileHeader
classFileInfo
classFileSystemTools
classFrameStatistics
structGPUID
classIAnimationClipController
classIChunkSaver
classICloudsVolumeShape
classIDataManager
classIFont
classIGeometryDatabase
classIGICache
classIGraphicDevice
classIImage
classIImage2D
classIImage3D
classIImageComposite
classIImageCube
classIImageReadback
classILicense
classILightShape
classILineShape
classImageTools
classIMaterial
classIMaterialController
classIMaterialControllerProperty
classIMeshShape
classIMoonLightShape
classIOptions
classIOTools
classIPhysicalLightShape
classIPointShape
classIREDFile
classIREDObject
classIReferenceManager
classIReferenceSolving
classIResourceManager
classIShape
classISkeletalAnimationBlender
classISkeletalAnimationController
classISkyLightShape
classISoftBucket
classISoftLight
classISoftRayContext
classISoftRenderingContext
classISoftShaderContext
classIStream
classISunLightShape
classITextShape
classITransformShape
classIUserData
classIViewpoint
classIViewpointRenderList
classIVolumeShape
classIWindow
classLayerSet
structLicenseTime
template< class Key, class Item > classMap
classMatrix
classMemoryAllocator
classMemoryLeakTracker
classMutex
classNoise
classObject
classPassStatistics
classPostProcess
classProduct
classQuaternion
classRandom
classRayCutoffShader
classRayGIDiffuseShader
classRayGIReflectionColorShader
classRayGIRefractionColorShader
classRayReflectionShader
classRayRefractionShader
classReflectionShader
classRenderCode
classRenderLayer
classRenderShader
classRenderShaderAAFilter
classRenderShaderAmbient
classRenderShaderAnisotropic
classRenderShaderData
classRenderShaderEdges
classRenderShaderEnvironmental
classRenderShaderLambert
classRenderShaderLogo
classRenderShaderParameter
classRenderShaderPhong
classRenderShaderRefractionEffect
classRenderShaderSectionCut
classRenderShaderSolid
classRenderShaderText
classRenderShaderVertexColor
classRenderShaderViewport
classRNG
classShader
classShaderProgramID
classShaderString
classShapePath
classSoftFrameBufferSample
classState
classStateShader
classStateShaderPlatformData
classStreamingPolicy
classString
classThread
classTimer
classUserData
classUserDataRaw
template< class T > classVector
classVector3
classVector4
classVersion
classViewpointStatistics
classVolumetricEffect
classVolumetricEffectBoxVolume
classVolumetricEffectClouds
classVolumetricEffectLightVolume
classWindowRenderInfo

Functions:

RED_RC REDFullExpGetREDErrorMessage ( RED::String & oErrorMessage, RED_RC iRC )
void REDFullExpREDBreak ( RED_RC iRC, const char * iCaller, const void * iObject, const char * iExpression, const char * iInfo )

Enumerations:

enumAA_FILTER { AA_NOTHING =  0, AA_AREA_FXAA =  1 }
enumACCESS_MODE { AM_READ =  1, AM_WRITE =  2, AM_READWRITE_OVER =  3, AM_READWRITE_APPEND =  4 }
enumATTENUATION { 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 }
enumBSDF_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 }
enumBSDF_REQUEST { BSDF_REQUEST_UNDEFINED =  0, BSDF_REQUEST_EVAL =  1, BSDF_REQUEST_PDF =  2, BSDF_REQUEST_EMITTED =  3, BSDF_REQUEST_SAMPLE =  4 }
enumCHANNEL { CHN_RED =  0, CHN_GREEN =  1, CHN_BLUE =  2, CHN_ALPHA =  3 }
enumCLOUDS_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 }
enumCLUSTER_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 }
enumDRIVER_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 }
enumENV_TYPE { ENV_SPHERICAL =  0, ENV_CYLINDRICAL =  1, ENV_HEMISPHERICAL =  2 }
enumFILTER_MODE { FM_LINEAR =  1, FM_NEAREST =  2 }
enumFONT_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 }
enumFONT_RENDER_MODE { FNT_UNKNOWN =  0, FNT_BITMAP =  1, FNT_TRIANGLE =  2, FNT_LINE =  3, FNT_TEXTURE =  4 }
enumFONT_TYPE { FNT_UNDEFINED =  0, FNT_SYSTEM =  1, FNT_CUSTOM =  2 }
enumFORMAT { 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 }
enumFRAME_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 }
enumGI_CACHE_MODE { GICM_CAMERA_VIEW =  0, GICM_CAMERA_SPHERICAL =  1, GICM_WORLD =  2 }
enumGREY_OPERATION { GOP_GGG1 =  0, GOP_GGGG =  1, GOP_000G =  2, GOP_111G =  3, GOP_XXXG =  4, GOP_GGGX =  5 }
enumHARDWARE_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 }
enumHOST_PRODUCT { HPROD_UNKNOWN =  0, HPROD_AUTODESK_MAX =  1, HPROD_AUTODESK_VIZ =  2 }
enumIO_FBX_FILE_VERSION { IOFV_DEFAULT =  0, IOFV_2010 = , IOFV_2011 = , IOFV_2012 = , IOFV_2013 = , IOFV_2014 = , IOFV_2016 =  }
enumIO_LOAD_MATERIAL_TYPE { IOLMT_GENERIC =  0, IOLMT_REALISTIC =  1 }
enumIO_LOAD_TEXTURE_TRANSPARENCY { IOLTT_ALPHA =  0, IOLTT_RGB =  1 }
enumIO_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 }
enumIO_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 }
enumLAYER_MODE { LRM_ALPHA_PLUS_ONE_MINUS_ALPHA =  0, LRM_ONE_PLUS_ONE_MINUS_ALPHA =  1 }
enumLIGHT_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 =  }
enumLIST_POS { LIST_LAST =  -1, LIST_FIRST =  0 }
enumMATERIAL_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 }
enumMESH_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 }
enumMESH_FORMAT { MFT_ZERO =  0, MFT_UBYTE =  1, MFT_SHORT =  2, MFT_INT =  3, MFT_FLOAT =  4, MFT_DOUBLE =  5 }
enumMESH_TEXCOORD_MAPPING { MTCM_PLANAR =  0, MTCM_SPHERICAL =  1, MTCM_CYLINDRICAL =  2, MTCM_CYLINDRICAL_CAP =  3, MTCM_BOX =  4 }
enumOPERATING_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 }
enumOPTION_VALUE_FORMAT { OPT_UNKNOWN =  0, OPT_BOOLEAN =  1, OPT_DOUBLE =  2, OPT_INTEGER =  3 }
enumOPTIONS { 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_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_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_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_PATH_GI =  0x00000070 }
enumPLATFORM { PTM_UNKNOWN =  -1, PTM_WINDOWS =  0, PTM_LINUX =  1, PTM_MACOS =  2, PTM_COUNT =  3 }
enumPRODUCT { 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 }
enumPROPERTY_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 }
enumRENDER_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 }
enumRENDERING_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 }
enumRENDERING_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_SIZE =  8 }
enumROOT_MOTION_COMPONENT { RMC_ROTATION =  0, RMC_POSITION_X = , RMC_POSITION_Y = , RMC_POSITION_Z =  }
enumROOT_MOTION_POLICY { RMP_DEFAULT =  0, RMP_CUMULATIVE = , RMP_DELTA = , RMP_ZERO =  }
enumRSV_TYPE { RSV_TRIANGLE =  1, RSV_LINE =  2, RSV_TRIANGLE_UBYTE_NORMALS =  3 }
enumSOFT_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 }
enumTARGET { TGT_NONE =  0, TGT_TEX_1D =  1, TGT_TEX_2D =  2, TGT_TEX_RECT =  3, TGT_TEX_CUBE =  4, TGT_TEX_3D =  5 }
enumTEXT_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 }
enumTEXT_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 }
enumTHREAD_PRIORITY { TP_LOWEST =  0, TP_LOW =  1, TP_NORMAL =  2, TP_HIGH =  3, TP_HIGHEST =  4 }
enumTONEMAPPING_OPERATOR { TMO_CLAMP =  0x00, TMO_PHOTOGRAPHIC =  0x01, TMO_NEUTRAL =  0x02, TMO_EXPOSURE =  0x03 }
enumTRANSACTION_MODE { TRANSACTION_OUT =  -1, TRANSACTION_IN =  0 }
enumVIEWPOINT_TYPE { VPT_PARALLEL =  0x01, VPT_PERSPECTIVE =  0x02, VPT_CUSTOM =  0x03 }
enumVRL_SIZEPOS { VSP_ANCHOR_FIXED =  1, VSP_ANCHOR_STRETCHED =  2, VSP_SIZE_FIXED =  4, VSP_SIZE_STRETCHED =  8, VSP_SIZE_STRETCHED_AUTO_RATIO =  16 }
enumVRL_SORT { VST_FRONT =  0, VST_SCENE =  1, VST_BACK =  2 }
enumWRAP_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(*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 unsignedint (__stdcall *THREAD_CALLBACK)(void *iThreadClass)
typedef int __w64int64
typedef bool(*INTERRUPT_CALLBACK )(void *iUserData)
typedef void(*LoadChunkNotificationCallback )(RED::uint64 iSize, void *iParameter)
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 __w64uint64
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_RCiRC
)

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_RCiRC,
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

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.

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.

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+ klin*d + kqua*d^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/(d*d*d) 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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

Lists all possible material types used during IO loading.

Enumerator:

IOLMT_GENERIC

Create generic material during loading.

IOLMT_REALISTIC

Create realistic material during loading.

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.

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.

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.

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.

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.

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.

Note that the ALL* passes 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

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

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.

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.

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.

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.

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_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_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.01.
[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_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_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.

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

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.

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.

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.

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_SIZE

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.

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.

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.

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.

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.

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*(a*a) - 2*(a*a*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.

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.

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.

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.

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.

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.

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.

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.

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::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::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.