RED

Types

	AnimationClip
	AnimationData
	AxisAlignedBoundingBox
	BoundingSphere
	ChunkInterpretersDictionary
	CID
	Color
	Factory
	FastRandom
	FileHeader
	FileInfo
	FileSystemTools
	FrameStatistics
	GPUID
	IAnimationClipController
	IChunkSaver
	ICloudsVolumeShape
	IDataManager
	IFont
	IGeometryDatabase
	IGICache
	IGraphicDevice
	IImage
	IImage2D
	IImage3D
	IImageComposite
	IImageCube
	IImageReadback
	ILicense
	ILightShape
	ILineShape
	ImageTools
	IMaterial
	IMaterialController
	IMaterialControllerProperty
	IMeshShape
	IMoonLightShape
	IOptions
	IOTools
	IPhysicalLightShape
	IPointShape
	IREDFile
	IREDObject
	IReferenceManager
	IReferenceSolving
	IResourceManager
	IShape
	ISkeletalAnimationBlender
	ISkeletalAnimationController
	ISkyLightShape
	ISoftBucket
	ISoftLight
	ISoftRayContext
	ISoftRenderingContext
	ISoftShaderContext
	IStream
	ISunLightShape
	ITextShape
	ITransformShape
	IUserData
	IViewpoint
	IViewpointRenderList
	IVolumeShape
	IWindow
	LayerSet
	LicenseTime
	Map
	Matrix
	MemoryAllocator
	MemoryLeakTracker
	Mutex
	Noise
	Object
	PassStatistics
	PostProcess
	Product
	Quaternion
	Random
	RayCutoffShader
	RayGIDiffuseShader
	RayGIReflectionColorShader
	RayGIRefractionColorShader
	RayReflectionShader
	RayRefractionShader
	ReflectionShader
	RenderCode
	RenderLayer
	RenderShader
	RenderShaderAAFilter
	RenderShaderAmbient
	RenderShaderAnisotropic
	RenderShaderData
	RenderShaderEdges
	RenderShaderEnvironmental
	RenderShaderLambert
	RenderShaderLogo
	RenderShaderParameter
	RenderShaderPhong
	RenderShaderRefractionEffect
	RenderShaderSectionCut
	RenderShaderSolid
	RenderShaderText
	RenderShaderVertexColor
	RenderShaderViewport
	RNG
	Shader
	ShaderProgramID
	ShaderString
	ShapePath
	SoftFrameBufferSample
	State
	StateShader
	StateShaderPlatformData
	StreamingPolicy
	String
	Thread
	Timer
	UserData
	UserDataRaw
	Vector
	Vector3
	Vector4
	Version
	ViewpointStatistics
	VolumetricEffect
	VolumetricEffectBoxVolume
	VolumetricEffectClouds
	VolumetricEffectLightVolume
	WindowRenderInfo
	`LIST_POS`
	`RENDERING_PROGRESS_STEP`
	`RENDERING_PASS`
	`CLUSTER_GPU_TIME`
	`FONT_TYPE`
	`FONT_RENDER_MODE`
	`FONT_CHARSET`
	`HARDWARE_PLATFORM`
	`OPERATING_SYSTEM`
	`DRIVER_VALIDATION`
	`CHANNEL`
	`FORMAT`
	`TARGET`
	`WRAP_MODE`
	`FILTER_MODE`
	`GREY_OPERATION`
	`LAYER_MODE`
	`ENV_TYPE`
	`RENDER_MODE`
	`ATTENUATION`
	`MATERIAL_PASS`
	`PROPERTY_TYPE`
	`MESH_FORMAT`
	`MESH_CHANNEL`
	`MESH_TEXCOORD_MAPPING`
	`POLYGON_WINDING_RULE`
	`OPTION_VALUE_FORMAT`
	`IO_LOAD_MATERIAL_TYPE`
	`IO_LOAD_TEXTURE_TRANSPARENCY`
	`IO_OBJECT_TYPE`
	`IO_SYSTEM_UNIT`
	`IO_FBX_FILE_VERSION`
	`ROOT_MOTION_COMPONENT`
	`ROOT_MOTION_POLICY`
	`CLOUDS_TYPE`
	`LIGHT_TYPE`
	`ACCESS_MODE`
	`TEXT_ATTACH_POS`
	`VIEWPOINT_TYPE`
	`VRL_SORT`
	`VRL_SIZEPOS`
	`FRAME_TRACING_FEEDBACK`
	`GI_CACHE_MODE`
	`OPTIONS`
	`TONEMAPPING_OPERATOR`
	`PRODUCT`
	`PLATFORM`
	`HOST_PRODUCT`
	`SOFT_GEOMETRY_PRIMITIVE`
	`AA_FILTER`
	`TEXT_ALPHA_MODE`
	`RSV_TYPE`
	`BSDF_REQUEST`
	`BSDF_EVENT`
	`TRANSACTION_MODE`
	`THREAD_PRIORITY`

Type Aliases

unsigned long	`uint64`
long	`int64`
void(*	`ProgressCallback`
`RED_RC` (*	`IChunkInterpreterProto`
`RED_RC` (*	`IMAGE_TOOLS_LOAD_CALLBACK`
bool(*	`INTERRUPT_CALLBACK`
void(*	`BATCH_SYNC_CALLBACK`
void(*	`REDSDK_ERROR_CALLBACK`
void(*	`REDSDK_WARNING_CALLBACK`
void(*	`OPENGL_MATERIAL_CALLBACK`
void(*	`OPENGL_VIEWPOINT_CALLBACK`
void(*	`OPENGL_BUFFER_CALLBACK`
`RED_RC` (*	`USER_SWITCH_CALLBACK`
void(*	`LoadChunkNotificationCallback`
`RED_RC` (*	`INSTANCE_COUNTER_CALLBACK`
`RED_RC` (*	`INSTANCE_COUNTER_IMAGE_CALLBACK`
`RED_RC` (*	`SOFT_PIXEL_ANALYSIS_CALLBACK`
`RED_RC` (*	`SOFT_BUCKET_CALLBACK`
bool(*	`SOFT_RAY_PROCESSING_INTERSECTION_CALLBACK`
`RED_RC` (*	`SOFT_RAY_PROCESSING_SHADING_CALLBACK`
`RED_RC` (*	`RENDERING_PROGRESS_CALLBACK`
`RED_RC` (*	`SOFT_GEOMETRY_SHADER`
`RED_RC` (*	`SOFT_SHADER_CALLBACK`
void (	`THREAD_CALLBACK`

Fields

	`LIST_LAST`
	`LIST_FIRST`
	`RPS_RENDER_NOT_STARTED`
	`RPS_GI_ESTIMATOR_PROCESSING`
	`RPS_GI_CACHE_PROCESSING`
	`RPS_CAUSTICS_PROCESSING`
	`RPS_RAY_TRACING_PROCESSING`
	`RPS_DENOISER_PROCESSING`
	`RPS_HARDWARE_RENDERING`
	`RPS_RENDER_COMPLETE`
	`RPS_WORLD_GI_CACHE_PROCESSING`
	`RPS_SIZE`
	`RPA_UNDEFINED_PASS`
	`RPA_CONTEXT_CULLING`
	`RPA_VISIBILITY_CULLING`
	`RPA_LIGHT_CULLING`
	`RPA_RAY_DATABASE_UPDATE`
	`RPA_PRELIT_OPAQUE`
	`RPA_PRELIT_TRANSPAR`
	`RPA_LIT_OPAQUE`
	`RPA_LIT_TRANSPAR`
	`RPA_POSTLIT_OPAQUE`
	`RPA_POSTLIT_TRANSPAR`
	`RPA_COMPOSITE_IMAGE`
	`RPA_SHADOW_MAP_OPAQUE`
	`RPA_SHADOW_MAP_TRANSPAR`
	`RPA_GI_CACHE_OPAQUE`
	`RPA_GI_CACHE_TRANSPAR`
	`RPA_INDIRECT_PRELIT_OPAQUE`
	`RPA_INDIRECT_PRELIT_TRANSPAR`
	`RPA_INDIRECT_LIT_OPAQUE`
	`RPA_INDIRECT_LIT_TRANSPAR`
	`RPA_INDIRECT_POSTLIT_OPAQUE`
	`RPA_INDIRECT_POSTLIT_TRANSPAR`
	`RPA_INDIRECT_SHADOW_MAP_OPAQUE`
	`RPA_INDIRECT_SHADOW_MAP_TRANSPAR`
	`RPA_INDIRECT_BACKGROUND`
	`RPA_GPU_RAY_TRANSPARENCY`
	`RPA_GPU_RAY_TID`
	`RPA_GPU_RAY_POSITIONS`
	`RPA_GPU_RAY_DIRECTIONS`
	`RPA_GPU_RAY_NORMALS`
	`RPA_GPU_RAY_CUTOFF`
	`RPA_SIZE`
	`CGT_INIT`
	`CGT_EVENT_HANDLING`
	`CGT_STREAMS_UPDATES`
	`CGT_BATCHES_UPDATES`
	`CGT_FONTS_UPDATE`
	`CGT_CUBES_UPDATE`
	`CGT_ALL`
	`CGT_SIZE`
	`FNT_UNDEFINED`
	`FNT_SYSTEM`
	`FNT_CUSTOM`
	`FNT_UNKNOWN`
	`FNT_BITMAP`
	`FNT_TRIANGLE`
	`FNT_LINE`
	`FNT_TEXTURE`
	`FNT_DEFAULT_CHARSET`
	`FNT_ANSI_CHARSET`
	`FNT_SYMBOL_CHARSET`
	`FNT_SHIFTJIS_CHARSET`
	`FNT_HANGEUL_CHARSET`
	`FNT_HANGUL_CHARSET`
	`FNT_GB2312_CHARSET`
	`FNT_CHINESEBIG5_CHARSET`
	`FNT_JOHAB_CHARSET`
	`FNT_HEBREW_CHARSET`
	`FNT_ARABIC_CHARSET`
	`FNT_GREEK_CHARSET`
	`FNT_TURKISH_CHARSET`
	`FNT_VIETNAMESE_CHARSET`
	`FNT_THAI_CHARSET`
	`FNT_EASTEUROPE_CHARSET`
	`FNT_MAC_CHARSET`
	`FNT_BALTIC_CHARSET`
	`HW_GENERIC`
	`HW_NVIDIA_GENERIC`
	`HW_NVIDIA_NV30`
	`HW_NVIDIA_NV40`
	`HW_NVIDIA_G80`
	`HW_NVIDIA_G200`
	`HW_NVIDIA_G400`
	`HW_ATI_GENERIC`
	`HW_ATI_R300`
	`HW_ATI_R400`
	`HW_ATI_R500`
	`HW_ATI_R600`
	`HW_ATI_R700`
	`HW_ATI_R800`
	`HW_INTEL_GENERIC`
	`HW_INTEL_GMA_3000`
	`HW_INTEL_GMA_4000`
	`HW_INTEL_GMA_GEN7`
	`HW_SOFT_TRACER`
	`HW_USER_GENERIC`
	`HW_USER_01`
	`HW_USER_02`
	`HW_USER_03`
	`HW_VIRTUAL_GENERIC`
	`HW_VIRTUAL_01`
	`HW_VIRTUAL_02`
	`HW_VIRTUAL_03`
	`OS_NOT_SUPPORTED`
	`OS_WIN_2000`
	`OS_WIN_XP_32`
	`OS_WIN_XP_64`
	`OS_WIN_VISTA_32`
	`OS_WIN_VISTA_64`
	`OS_WIN_SEVEN_32`
	`OS_WIN_SEVEN_64`
	`OS_WIN_EIGHT_32`
	`OS_WIN_EIGHT_64`
	`OS_WIN_TEN_32`
	`OS_WIN_TEN_64`
	`OS_LIN_32`
	`OS_LIN_64`
	`OS_MAC_OSX_64`
	`DR_OK`
	`DR_OK_NEWER`
	`DR_NOT_CERTIFIED`
	`DR_KNOWN_ERRORS`
	`DR_NO_DRIVER_INSTALLED`
	`DR_OK_SOFTWARE_RENDERING`
	`CHN_RED`
	`CHN_GREEN`
	`CHN_BLUE`
	`CHN_ALPHA`
	`FMT_NODATA`
	`FMT_RGBA`
	`FMT_RGB`
	`FMT_FLOAT`
	`FMT_FLOAT_RGBA`
	`FMT_FLOAT_RGB`
	`FMT_L8`
	`FMT_A8`
	`FMT_RGBA_DXT1`
	`FMT_RGBA_DXT3`
	`FMT_RGBA_DXT5`
	`FMT_RGB_DXT1`
	`FMT_HALF_FLOAT`
	`FMT_HALF_FLOAT_RGBA`
	`FMT_HALF_FLOAT_RGB`
	`FMT_FLOAT_RGBA_AA`
	`TGT_NONE`
	`TGT_TEX_1D`
	`TGT_TEX_2D`
	`TGT_TEX_RECT`
	`TGT_TEX_CUBE`
	`TGT_TEX_3D`
	`WM_REPEAT`
	`WM_MIRRORED_REPEAT`
	`WM_CLAMP`
	`WM_CLAMP_TO_EDGE`
	`WM_CLAMP_TO_BORDER`
	`FM_LINEAR`
	`FM_NEAREST`
	`GOP_GGG1`
	`GOP_GGGG`
	`GOP_000G`
	`GOP_111G`
	`GOP_XXXG`
	`GOP_GGGX`
	`LRM_ALPHA_PLUS_ONE_MINUS_ALPHA`
	`LRM_ONE_PLUS_ONE_MINUS_ALPHA`
	`ENV_SPHERICAL`
	`ENV_CYLINDRICAL`
	`ENV_HEMISPHERICAL`
	`RM_SHADOW_CASTER`
	`RM_TEX_INTENSITY_RAMP_RES`
	`RM_TEX_CUBEMAP_SPOT_RES`
	`RM_TEX_RADIAL_BEAM_RES`
	`RM_SHADOW_MAP`
	`RM_ACTIVATED`
	`RM_DOUBLE_SIDED`
	`RM_CAUSTICS`
	`RM_VISIBLE_GEOMETRY`
	`RM_DEFINE_VOLUME`
	`RM_ENLIGHTEN_VOLUME`
	`RM_BAKED`
	`RM_SINGLE_SIDED_BIAS`
	`RM_USE_EXACT_LIGHT_PROB`
	`RM_USE_MIS`
	`RM_COUNT`
	`ATN_LINQUA`
	`ATN_DMAX2`
	`ATN_NONE`
	`ATN_LINEAR`
	`ATN_QUADRATIC`
	`ATN_CUBIC`
	`ATN_N3DSMAX`
	`ATN_L3DSMAX`
	`ATN_Q3DSMAX`
	`MTL_PRELIT`
	`MTL_LIT`
	`MTL_POSTLIT`
	`MTL_RAYTRACE`
	`MTL_INDIRECT_PRELIT`
	`MTL_INDIRECT_LIT`
	`MTL_INDIRECT_POSTLIT`
	`MTL_ALL`
	`MTL_INTERNAL`
	`PYT_UNDEFINED`
	`PYT_FLOAT`
	`PYT_INTEGER`
	`PYT_BOOLEAN`
	`PYT_COLOR`
	`PYT_TEXTURE2D`
	`PYT_STRING`
	`PYT_TEXTURE3D`
	`PYT_TEXTURECUBE`
	`PYT_VECTOR4`
	`PYT_LAYERSET`
	`PYT_TEXTURECOMPOSITE`
	`MFT_ZERO`
	`MFT_UBYTE`
	`MFT_SHORT`
	`MFT_INT`
	`MFT_FLOAT`
	`MFT_DOUBLE`
	`MFT_HALF_FLOAT`
	`MCL_VERTEX`
	`MCL_USER0`
	`MCL_NORMAL`
	`MCL_COLOR`
	`MCL_USER1`
	`MCL_USER2`
	`MCL_USER3`
	`MCL_USER4`
	`MCL_TEX0`
	`MCL_TEX1`
	`MCL_TEX2`
	`MCL_TEX3`
	`MCL_TEX4`
	`MCL_TEX5`
	`MCL_TEX6`
	`MCL_TEX7`
	`MCL_SIZE`
	`MTCM_PLANAR`
	`MTCM_SPHERICAL`
	`MTCM_CYLINDRICAL`
	`MTCM_CYLINDRICAL_CAP`
	`MTCM_BOX`
	`PWR_ODD`
	`PWR_NON_ZERO`
	`PWR_POSITIVE`
	`PWR_NEGATIVE`
	`PWR_ABS_GEQ_TWO`
	`OPT_UNKNOWN`
	`OPT_BOOLEAN`
	`OPT_DOUBLE`
	`OPT_INTEGER`
	`IOLMT_GENERIC`
	`IOLMT_REALISTIC`
	`IOLTT_ALPHA`
	`IOLTT_RGB`
	`IOOT_NODE`
	`IOOT_MESH`
	`IOOT_LINE`
	`IOOT_MATERIAL`
	`IOOT_TEXTURE`
	`IOOT_LIGHT`
	`IOOT_VIEWPOINT`
	`IOOT_SKINNING`
	`IOOT_ANIMATION`
	`IOOT_ALL`
	`IOSU_MM`
	`IOSU_CM`
	`IOSU_DM`
	`IOSU_M`
	`IOSU_KM`
	`IOSU_INCH`
	`IOSU_FOOT`
	`IOSU_MILE`
	`IOSU_YARD`
	`IOFV_DEFAULT`
	`IOFV_2010`
	`IOFV_2011`
	`IOFV_2012`
	`IOFV_2013`
	`IOFV_2014`
	`IOFV_2016`
	`RMC_ROTATION`
	`RMC_POSITION_X`
	`RMC_POSITION_Y`
	`RMC_POSITION_Z`
	`RMP_DEFAULT`
	`RMP_CUMULATIVE`
	`RMP_DELTA`
	`RMP_ZERO`
	`CT_CUMULUS`
	`CT_STRATUS`
	`CT_CIRRUS_1`
	`CT_CIRRUS_2`
	`CT_CIRRUS_3`
	`CT_CIRRUS_4`
	`CT_CIRRUS_5`
	`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`
	`AM_READ`
	`AM_WRITE`
	`AM_READWRITE_OVER`
	`AM_READWRITE_APPEND`
	`TAP_TOP_LEFT`
	`TAP_TOP`
	`TAP_TOP_RIGHT`
	`TAP_RIGHT`
	`TAP_BOTTOM_RIGHT`
	`TAP_BOTTOM`
	`TAP_BOTTOM_LEFT`
	`TAP_LEFT`
	`TAP_CENTER`
	`TAP_BASELINE_LEFT`
	`TAP_BASELINE_CENTER`
	`TAP_BASELINE_RIGHT`
	`TAP_TOP_LEFT_EDGE`
	`TAP_BOTTOM_LEFT_EDGE`
	`TAP_LEFT_EDGE`
	`TAP_BASELINE_LEFT_EDGE`
	`VPT_PARALLEL`
	`VPT_PERSPECTIVE`
	`VPT_CUSTOM`
	`VST_FRONT`
	`VST_SCENE`
	`VST_BACK`
	`VSP_ANCHOR_FIXED`
	`VSP_ANCHOR_STRETCHED`
	`VSP_SIZE_FIXED`
	`VSP_SIZE_STRETCHED`
	`VSP_SIZE_STRETCHED_AUTO_RATIO`
	`FTF_BY_BLOCKS`
	`FTF_BY_SURFACE_LEVEL_0`
	`FTF_BY_SURFACE_LEVEL_1`
	`FTF_BY_SURFACE_LEVEL_2`
	`FTF_BY_SURFACE_LEVEL_3`
	`FTF_BY_SURFACE_LEVEL_4`
	`FTF_BY_SURFACE_LEVEL_5`
	`FTF_BY_BLOCKS_LEVEL_0`
	`FTF_BY_BLOCKS_LEVEL_1`
	`FTF_BY_BLOCKS_LEVEL_2`
	`FTF_BY_BLOCKS_LEVEL_3`
	`FTF_BY_BLOCKS_LEVEL_4`
	`FTF_BY_BLOCKS_LEVEL_5`
	`FTF_PATH_TRACING`
	`GICM_CAMERA_VIEW`
	`GICM_CAMERA_SPHERICAL`
	`GICM_WORLD`
	`OPTIONS_RAY_PRIMARY`
	`OPTIONS_RAY_SHADOWS`
	`OPTIONS_RAY_REFLECTIONS`
	`OPTIONS_RAY_REFRACTIONS`
	`OPTIONS_RAY_TRANSPARENCY`
	`OPTIONS_RAY_REFRACTIONS_BACK`
	`OPTIONS_RAY_MAX_THREADS`
	`OPTIONS_RAY_CUTOFF`
	`OPTIONS_RAY_ENABLE_GLOSSY_EFFECTS`
	`OPTIONS_RAY_ENABLE_AREA_SAMPLING`
	`OPTIONS_RAY_ENABLE_SOFT_TRACER`
	`OPTIONS_RAY_ENABLE_CAUSTICS`
	`OPTIONS_RAY_CAUSTICS_SAMPLING_RATE`
	`OPTIONS_RAY_CAUSTICS_SEARCH_RADIUS`
	`OPTIONS_RAY_CAUSTICS_SEARCH_COUNT`
	`OPTIONS_RAY_LIGHTS_SAMPLING_RATE`
	`OPTIONS_RAY_GLOSSY_SAMPLING_RATE`
	`OPTIONS_RAY_VOLUME`
	`OPTIONS_RAY_DISPLACEMENT`
	`OPTIONS_RAY_USE_EMBREE`
	`OPTIONS_RAY_FORCE_EMBREE`
	`OPTIONS_RAY_ENABLE_OPEN_IMAGE_DENOISE`
	`OPTIONS_VIEWPOINT_PICKABLE`
	`OPTIONS_SHADOW_MAP_DEPTH`
	`OPTIONS_POLYGON_FILL_MODE`
	`OPTIONS_SHADOW_MAP_TRANSPARENCY`
	`OPTIONS_AUTO_CUBE_ENV_SIZE`
	`OPTIONS_AUTO_CUBE_ENV_UPDATE_MODE`
	`OPTIONS_AUTO_CUBE_ALLOW_RAYTRACER`
	`OPTIONS_GI_CACHE_TRANSPAR_DRAW`
	`OPTIONS_MATERIAL_LAYER_INTERSECT`
	`OPTIONS_TONE_MAPPING_IGNORE_BACKGROUND`
	`OPTIONS_VIEWPOINT_ORTHOGRAPHIC_EYE_AUTO_OFFSET`
	`OPTIONS_REFRESH_INSTANCE_COUNTERS`
	`OPTIONS_WINDOW_HDR`
	`OPTIONS_WINDOW_PICK_AREA`
	`OPTIONS_WINDOW_PICK_AREA_TRIANGLE`
	`OPTIONS_WINDOW_DRAW_SYNC`
	`OPTIONS_DATA_RELEASE_TIMER`
	`OPTIONS_IMMEDIATE_MODE`
	`OPTIONS_LIGHT_CUTOFF`
	`OPTIONS_FORCE_STENCIL`
	`OPTIONS_SAMPLER`
	`OPTIONS_FORCE_COMPRESSED_IMAGES_INTEL`
	`OPTIONS_OPENGL_CONTEXT_MAJOR`
	`OPTIONS_OPENGL_CONTEXT_MINOR`
	`OPTIONS_OPENGL_CONTEXT_DEBUG`
	`OPTIONS_RAY_GI`
	`OPTIONS_RAY_GI_ERROR`
	`OPTIONS_RAY_GI_ESTIMATOR_SAMPLING_RATE`
	`OPTIONS_RAY_GI_CACHE_PASSES_COUNT`
	`OPTIONS_RAY_GI_CACHE_HEMI_SAMPLING_RATE`
	`OPTIONS_RAY_GI_CACHE_INTERP_SAMPLES_COUNT`
	`OPTIONS_RAY_GI_SHOW_SAMPLES`
	`OPTIONS_RAY_GI_ENABLE_VOLUME`
	`OPTIONS_RAY_GI_CACHE_PRECISE`
	`OPTIONS_RAY_GI_FOR_GLOSSINESS`
	`OPTIONS_RAY_GI_FOR_LIGHTING`
	`OPTIONS_RAY_SOFT_SHADOW_MAP_TRANSPARENCY`
	`OPTIONS_RAY_AREA_SHADOW_SPACING`
	`OPTIONS_RAY_AREA_SHADOW_SPREAD`
	`OPTIONS_RAY_CONTEXT_CALLBACK_PERSISTENCE`
	`OPTIONS_RAY_FORCE_TRANSPARENCY`
	`OPTIONS_RAY_SOFT_PREVIEW`
	`OPTIONS_RAY_WORLD_CACHE_SAMPLES_COUNT`
	`OPTIONS_RAY_WORLD_CACHE_SAMPLES_SPREAD`
	`OPTIONS_RAY_TRANSPARENCY_TOLERANCE_GPU`
	`OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD`
	`OPTIONS_RAY_MAX_SECONDARY_RAY_INTENSITY`
	`OPTIONS_RAY_ENABLE_DENOISER`
	`OPTIONS_RAY_DENOISER_STRENGTH`
	`OPTIONS_RAY_DENOISER_RADIUS`
	`OPTIONS_RAY_TRANSPARENCY_FFP_GPU`
	`OPTIONS_RAY_ADAPTIVE_SAMPLING_ALLOWED_TIME`
	`OPTIONS_PATH_GI`
	`OPTIONS_RAY_GI_ESTIMATOR_FULL_PATH`
	`TMO_CLAMP`
	`TMO_PHOTOGRAPHIC`
	`TMO_NEUTRAL`
	`TMO_EXPOSURE`
	`TMO_EXPONENTIAL`
	`PROD_UNKNOWN`
	`PROD_REDEXPORTER_MAX`
	`PROD_REDODADEVICE`
	`PROD_REDSDK`
	`PROD_REDPARASOLID`
	`PROD_REDMATERIALEDITOR`
	`PROD_REDC3D`
	`PROD_REDNET`
	`PROD_REDART`
	`PROD_COUNT`
	`PTM_UNKNOWN`
	`PTM_WINDOWS`
	`PTM_LINUX`
	`PTM_MACOS`
	`PTM_COUNT`
	`HPROD_UNKNOWN`
	`HPROD_AUTODESK_MAX`
	`HPROD_AUTODESK_VIZ`
	`GEO_UNMODIFIED`
	`GEO_POINTS`
	`GEO_LINE_SEGMENTS`
	`GEO_LINE_SEGMENTS_ADJACENCY`
	`GEO_LINE_STRIP`
	`GEO_TRIANGLES`
	`GEO_TRIANGLES_ADJACENCY`
	`AA_NOTHING`
	`AA_AREA_FXAA`
	`TEXT_ALPHA_LINEAR`
	`TEXT_ALPHA_3A2_MINUS_2A3`
	`TEXT_ALPHA_SQRTA`
	`TEXT_ALPHA_LINEAR_DEPTH`
	`TEXT_ALPHA_3A2_MINUS_2A3_DEPTH`
	`TEXT_ALPHA_SQRTA_DEPTH`
	`RSV_TRIANGLE`
	`RSV_LINE`
	`RSV_TRIANGLE_UBYTE_NORMALS`
	`BSDF_REQUEST_UNDEFINED`
	`BSDF_REQUEST_EVAL`
	`BSDF_REQUEST_PDF`
	`BSDF_REQUEST_EMITTED`
	`BSDF_REQUEST_SAMPLE`
	`BSDF_EVENT_UNDEFINED`
	`BSDF_EVENT_DIFFUSION`
	`BSDF_EVENT_REFLECTION`
	`BSDF_EVENT_TRANSMISSION`
	`BSDF_EVENT_ABSORPTION`
	`BSDF_EVENT_ALL`
	`TRANSACTION_OUT`
	`TRANSACTION_IN`
	`TP_LOWEST`
	`TP_LOW`
	`TP_NORMAL`
	`TP_HIGH`
	`TP_HIGHEST`

Functions

`RED_RC` `REDFullExp`	`GetREDErrorMessage`
void `REDFullExp`	`REDBreak`
void `REDFullExp`	`REDWarning`

Detailed Description

namespace RED: Namespace of all REDsdk interfaces and classes.

Type Documentation

enum RED::LIST_POS

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

Values:

enumerator LIST_LAST: Inserts the shader after all other shaders in the list at the time of the call.

enumerator LIST_FIRST: Inserts the shader first before all other shaders in the list at the time of the call.

enum RED::RENDERING_PROGRESS_STEP

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

Values:

enumerator RPS_RENDER_NOT_STARTED: The rendering of the image has not been started yet.

enumerator RPS_GI_ESTIMATOR_PROCESSING: The Global illumination estimator is being processed.

enumerator RPS_GI_CACHE_PROCESSING: The Global illumination cache is being processed.

enumerator RPS_CAUSTICS_PROCESSING: The caustics map is being processed.

enumerator RPS_RAY_TRACING_PROCESSING: The ray-tracing of the image is being processed (including anti-aliasing).

enumerator RPS_DENOISER_PROCESSING: The image denoiser is running after the ray-traced image has been processed.

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

enumerator RPS_RENDER_COMPLETE

enumerator RPS_WORLD_GI_CACHE_PROCESSING: The GI cache definition for the entire scene is being processed. This step comes before other GI cache passes when a world cache is being generated.

enumerator RPS_SIZE

enum RED::RENDERING_PASS

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

Values:

enumerator RPA_UNDEFINED_PASS

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

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

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

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

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

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

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

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

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

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

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

enumerator RPA_SHADOW_MAP_OPAQUE: GPU rendering of a shadow map for opaque elements. The rendering of a shadow map includes several sub-passes. See \ref bk_ap_customized_shadow_mapping for details.

enumerator RPA_SHADOW_MAP_TRANSPAR: GPU rendering of a shadow map for transparent elements. The rendering of a shadow map includes several sub-passes. See \ref bk_ap_customized_shadow_mapping for details.

enumerator RPA_GI_CACHE_OPAQUE: GPU global illumination cache replay pass for opaque objects.

enumerator RPA_GI_CACHE_TRANSPAR: GPU global illumination cache replay pass for transparent objects.

enumerator RPA_INDIRECT_PRELIT_OPAQUE: GPU indirect pre-lighting pass for opaque elements.

enumerator RPA_INDIRECT_PRELIT_TRANSPAR: GPU indirect pre-lighting pass for transparent elements.

enumerator RPA_INDIRECT_LIT_OPAQUE: GPU indirect lighting pass for opaque elements.

enumerator RPA_INDIRECT_LIT_TRANSPAR: GPU indirect lighting pass for transparent elements.

enumerator RPA_INDIRECT_POSTLIT_OPAQUE: GPU indirect post-lighting pass for opaque elements.

enumerator RPA_INDIRECT_POSTLIT_TRANSPAR: GPU indirect post-lighting pass for transparent elements.

enumerator RPA_INDIRECT_SHADOW_MAP_OPAQUE: GPU indirect rendering pass of a shadow map for opaque elements.

enumerator RPA_INDIRECT_SHADOW_MAP_TRANSPAR: GPU indirect rendering pass of a shadow map for transparent elements.

enumerator RPA_INDIRECT_BACKGROUND: GPU indirect rendering pass for background visibility.

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

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

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

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

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

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

enumerator RPA_SIZE: Size of the RED::HARDWARE_RENDERING_PASS enumeration.

enum RED::CLUSTER_GPU_TIME

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

Values:

enumerator CGT_INIT: Initialization sequence of the GPU cluster update.

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

enumerator CGT_STREAMS_UPDATES: Time spent updating GPU scene streams. This is the internal REDsdk view of all scene graphs.

enumerator 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 ).

enumerator CGT_FONTS_UPDATE: Time spent updating modified fonts.

enumerator CGT_CUBES_UPDATE: Time spent updating dynamic cube maps.

enumerator CGT_ALL: This is the total time spending in cluster GPU update. E.g. the sum of all other timers.

enumerator CGT_SIZE: Size of this enumeration.

enum RED::FONT_TYPE

Top level font classification. Indicates the font data source.

Values:

enumerator FNT_UNDEFINED: Indicates a font with undefined contents.

enumerator FNT_SYSTEM: Indicates a system font.

enumerator FNT_CUSTOM: Indicates a custom font.

enum RED::FONT_RENDER_MODE

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

Values:

enumerator FNT_UNKNOWN: Unspecified font rendering mode.

enumerator FNT_BITMAP: Renders a font using bitmaps.

enumerator FNT_TRIANGLE: Renders a font using triangles.

enumerator FNT_LINE: Renders a font using lines.

enumerator FNT_TEXTURE: Renders a font using textures. Used for high quality font display.

enum RED::FONT_CHARSET

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

Values:

enumerator FNT_DEFAULT_CHARSET: Font default system character set. This value redirects to a given charset based on the system’s locale.

enumerator FNT_ANSI_CHARSET: Font character set.

enumerator FNT_SYMBOL_CHARSET: Font character set.

enumerator FNT_SHIFTJIS_CHARSET: Font character set.

enumerator FNT_HANGEUL_CHARSET: Font character set.

enumerator FNT_HANGUL_CHARSET: Font character set.

enumerator FNT_GB2312_CHARSET: Font character set.

enumerator FNT_CHINESEBIG5_CHARSET: Font character set.

enumerator FNT_JOHAB_CHARSET: Font character set.

enumerator FNT_HEBREW_CHARSET: Font character set.

enumerator FNT_ARABIC_CHARSET: Font character set.

enumerator FNT_GREEK_CHARSET: Font character set.

enumerator FNT_TURKISH_CHARSET: Font character set.

enumerator FNT_VIETNAMESE_CHARSET: Font character set.

enumerator FNT_THAI_CHARSET: Font character set.

enumerator FNT_EASTEUROPE_CHARSET: Font character set.

enumerator FNT_MAC_CHARSET: Font character set.

enumerator FNT_BALTIC_CHARSET: Font character set.

enum RED::HARDWARE_PLATFORM

Identification of the hardware platform used by the application.

Values:

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

enumerator HW_INTEL_GMA_GEN7: INTEL hardware platform identifier for integrated “Graphics Media Accelerator” in the Ivy Bridge and Haswell INTEL processors product lines.

enumerator HW_SOFT_TRACER: Software ray-tracing platform identifier. This is the platform identifier for all frames being rendered without any GPU.

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

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

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

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

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

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

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

enumerator HW_VIRTUAL_03: Virtualization software layer platform identifier. If this platform is the runtime platform and if the shader has no configuration for that platform, the RED::HW_VIRTUAL_GENERIC configuration will be searched for.

enum RED::OPERATING_SYSTEM

Lists all REDsdk supported operating systems.

Values:

enumerator OS_NOT_SUPPORTED: RED::IGraphicDevice operating system identifier. Identify any operating system that can’t run REDsdk.

enumerator OS_WIN_2000: RED::IGraphicDevice operating system identifier. Windows 2000.

enumerator OS_WIN_XP_32: RED::IGraphicDevice operating system identifier. Windows XP 32 bits.

enumerator OS_WIN_XP_64: RED::IGraphicDevice operating system identifier. Windows XP 64 bits.

enumerator OS_WIN_VISTA_32: RED::IGraphicDevice operating system identifier. Windows Vista 32 bits.

enumerator OS_WIN_VISTA_64: RED::IGraphicDevice operating system identifier. Windows Vista 64 bits.

enumerator OS_WIN_SEVEN_32: RED::IGraphicDevice operating system identifier. Windows Seven 32 bits.

enumerator OS_WIN_SEVEN_64: RED::IGraphicDevice operating system identifier. Windows Seven 64 bits.

enumerator OS_WIN_EIGHT_32: RED::IGraphicDevice operating system identifier. Windows Eight 32 bits.

enumerator OS_WIN_EIGHT_64: RED::IGraphicDevice operating system identifier. Windows Eight 64 bits.

enumerator OS_WIN_TEN_32: RED::IGraphicDevice operating system identifier. Windows Ten 32 bits.

enumerator OS_WIN_TEN_64: RED::IGraphicDevice operating system identifier. Windows Ten 64 bits.

enumerator OS_LIN_32: RED::IGraphicDevice operating system identifier. All Linux 32 bits editions.

enumerator OS_LIN_64: RED::IGraphicDevice operating system identifier. All Linux 64 bits editions.

enumerator OS_MAC_OSX_64: RED::IGraphicDevice operating system identifier. Macintosh OS X 64 bits edition.

enum RED::DRIVER_VALIDATION

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

Values:

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.

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

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

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

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

enumerator DR_OK_SOFTWARE_RENDERING: Indicates that a software driver is installed on the local computer. This corresponds to REDsdk running in a virtualization environment. No graphic driver is needed in this case and REDsdk must be started in software rendering mode.

enum RED::CHANNEL

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

Values:

enumerator CHN_RED: Red pixel component of an image.

enumerator CHN_GREEN: Green pixel component of an image.

enumerator CHN_BLUE: Blue pixel component of an image.

enumerator CHN_ALPHA: Alpha pixel component of an image.

enum RED::FORMAT

Lists all possible pixel formats for an image.

Values:

enumerator FMT_NODATA: Currently we’ve nothing in the image. Such an image is bound as a black texture for all targets.

enumerator FMT_RGBA: 8 bits per component, 32 bits per pixel, RGBA in memory.

enumerator FMT_RGB: 8 bits per component, 24 bits per pixel, RGB in memory.

enumerator FMT_FLOAT: s1e8m23 IEEE floating point format. 32 bits per pixel.

enumerator FMT_FLOAT_RGBA: 1 float per component, 128 bits per pixel, RGBA in memory.

enumerator FMT_FLOAT_RGB: 1 float per component, 96 bits per pixel, RGB in memory.

enumerator FMT_L8: 8 bits per component, 8 bits per pixel, L in memory. Loaded as a (L,L,L,1) texture on the GPU.

enumerator FMT_A8: 8 bits per component, 8 bits per pixel, A in memory. Loaded as a (0,0,0,A) texture on the GPU.

enumerator FMT_RGBA_DXT1: Compressed image format (lossy). Uses one bit for alpha values. Is the greatest compressed form with the RED::FMT_RGB_DXT1.

enumerator FMT_RGBA_DXT3: Compressed image format (lossy). Uses a better encoding for alpha values. Uses more memory than RED::FMT_RGBA_DXT1.

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

enumerator FMT_RGB_DXT1: Compressed image format (lossy). Is the biggest compression kind with RED::FMT_RGBA_DXT1.

enumerator FMT_HALF_FLOAT: Half-float format. 16 bits per pixel.

enumerator FMT_HALF_FLOAT_RGBA: Half-float RGBA format. 16 bits per component, 64 bits per pixel.

enumerator FMT_HALF_FLOAT_RGB: Half-float RGB format. 16 bits per component, 48 bits per pixel.

enumerator FMT_FLOAT_RGBA_AA: Compressed RGBA format for anti-aliased images. 256 bits per pixel. Can be parsed as a RGBA double format, using 8 bytes per R,G,B,A component.

enum RED::TARGET

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

Values:

enumerator TGT_NONE: The texture is not bound to any valid target. It won’t show up anything on screen.

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

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

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

enumerator 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].

enumerator TGT_TEX_3D: The texture is a three dimensions texture, and can be accessed with three texture coordinates in the [0,1] x [0,1] x [0,1] range. The image bound that way may be POTD or NPOTD textures.

enum RED::WRAP_MODE

Lists the possible texturing wrap modes for a texture.

Values:

enumerator WM_REPEAT: Repeat the texture pattern out of the texture’s limits.

enumerator WM_MIRRORED_REPEAT: Repeat the texture pattern with an inversion of the texture out of the texture’s limits.

enumerator WM_CLAMP: The texture sampling result is zero outside of the texture’s limits.

enumerator WM_CLAMP_TO_EDGE: The texture sampling results remain slightly inside the texture when it’s out of the texture’s limits.

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

enum RED::FILTER_MODE

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

Values:

enumerator FM_LINEAR: The sampling of a texel is interpolated amongst all neighboring texels.

enumerator FM_NEAREST: The sampling of a texel is chosen to be the value of the closest texture pixel.

enum RED::GREY_OPERATION

Defines all possible grey levelling operations.

Values:

enumerator GOP_GGG1: The grey level is replicated on all RGB channels. 1.0 is set in the alpha channel.

enumerator GOP_GGGG: The grey level is replicated on all RGBA channels.

enumerator GOP_000G: The grey level is replicated in the alpha channel. RGB channels are set to 0.0.

enumerator GOP_111G: The grey level is replicated in the alpha channel. RGB channels are set to 1.0.

enumerator GOP_XXXG: The grey level is replicated in the alpha channel. RGB channels are not modified.

enumerator GOP_GGGX: The grey level is replicated in all RGB channels. The alpha channel is not modified.

enum RED::LAYER_MODE

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

Values:

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

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

enum RED::ENV_TYPE

List of the supported environmental projection types.

Values:

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.

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

enumerator ENV_HEMISPHERICAL: Environment mapping type for RED::IImageCube::CreateEnvironmentMap. The source image must be a latitude / longitude hemispherical map. This is similar to the ENV_SPHERICAL mapping considering only the part of the map above the line of horizon. The (u,v) = (0,0) texture map point intersects the X axis of the cube map; the (u,v) = (0,1) texture map point intersects the Z axis of the cube map.

enum RED::RENDER_MODE

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

Values:

enumerator RM_SHADOW_CASTER: Is the light casting shadows or not ?

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

enumerator RM_TEX_CUBEMAP_SPOT_RES: Resolution of the spot’s cube map being used. Default set to 256 x 256 pixels per face.

enumerator RM_TEX_RADIAL_BEAM_RES: Resolution of the radial beam texture being used. Default set to 256 x 256 pixels.

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

enumerator RM_ACTIVATED: Is the light source currently activated ? An inactive light source is ignored for the rendering, but remains in the scene however.

enumerator RM_DOUBLE_SIDED: Is the light source double sided? Apply to physical lights only.

enumerator RM_CAUSTICS: Does the light source generate caustics? Apply to physical lights (including the sun) with no IES profile only.

enumerator RM_VISIBLE_GEOMETRY: If this rendering mode is set to zero, then physical lights geometries and skylight portals will become invisible.

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

enumerator RM_ENLIGHTEN_VOLUME: Does the light enlighten participating media during volumetric rendering?

enumerator 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 \ref bk_sg_light_baking for details on light baking.

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

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

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

enumerator RM_COUNT: Number of terms in this enumeration.

enum RED::ATTENUATION

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

Values:

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.

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

enumerator ATN_NONE: The light intensity does not decrease as the lit point goes farther from the light.

enumerator ATN_LINEAR: I = Imax/d equation. d is the distance between the lit point and the light source.

enumerator ATN_QUADRATIC: I = Imax/(d*d) equation. d is the distance between the lit point and the light source.

enumerator ATN_CUBIC: I = Imax/(d*d*d) equation. d is the distance between the lit point and the light source.

enumerator ATN_N3DSMAX: No attenuation due to distance, but near and far attenuation can still be used (specific to 3DS Max software).

enumerator ATN_L3DSMAX: A linear-like attenuation, I = min(1,att[0]/d). (specific to 3DS Max software).

enumerator ATN_Q3DSMAX: A quadratic-like attenuation, I = min(1,(att[0] * att[0])/(d * d)). (specific to 3DS Max software).

enum RED::MATERIAL_PASS

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

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

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

Values:

enumerator MTL_PRELIT

enumerator MTL_LIT

enumerator MTL_POSTLIT

enumerator MTL_RAYTRACE

enumerator MTL_INDIRECT_PRELIT

enumerator MTL_INDIRECT_LIT

enumerator MTL_INDIRECT_POSTLIT

enumerator MTL_ALL

enumerator MTL_INTERNAL

enum RED::PROPERTY_TYPE

Lists the available type for material controller properties.

Values:

enumerator PYT_UNDEFINED: The property has undefined type. This is the default type for newly created properties.

enumerator PYT_FLOAT: The property is a numerical floating value in [-FLT_MAX, FLT_MAX] (except if the definition range has been modified using SetRange).

enumerator PYT_INTEGER: The property is a numerical integer value in [INT_MIN, INT_MAX] (except if the definition range has been modified using SetRange).

enumerator PYT_BOOLEAN: The property is a boolean value in { true, false }.

enumerator PYT_COLOR: The property is a RGBA color with each component in [0, 1].

enumerator PYT_TEXTURE2D: The property is a pointer to a RED::Object instance implementing RED::IImage2D.

enumerator PYT_STRING: The property is a string.

enumerator PYT_TEXTURE3D: The property is a pointer to a RED::Object instance implementing RED::IImage3D.

enumerator PYT_TEXTURECUBE: The property is a pointer to a RED::Object instance implementing RED::IImageCube.

enumerator PYT_VECTOR4: The property is a four dimensions vector

enumerator PYT_LAYERSET: The property is a layer set.

enumerator PYT_TEXTURECOMPOSITE: The property is a pointer to a RED::Object instance implementing RED::IImageComposite.

enum RED::MESH_FORMAT

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

Values:

enumerator MFT_ZERO: No data in the corresponding channel.

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

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

enumerator MFT_INT: Four bytes per component, int32.

enumerator MFT_FLOAT: Four bytes per component, float32.

enumerator MFT_DOUBLE: Eight bytes per component, float64.

enumerator MFT_HALF_FLOAT: Two bytes per component, half16. Memory alignment on 4 bytes boundaries is usually preferred for optimnal performances.

enum RED::MESH_CHANNEL

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

Values:

enumerator MCL_VERTEX: Usually stores geometry spatial coordinates.

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

enumerator MCL_NORMAL: Usually stores per vertex normals.

enumerator MCL_COLOR

enumerator MCL_USER1

enumerator MCL_USER2

enumerator MCL_USER3

enumerator MCL_USER4

enumerator MCL_TEX0: MCL_TEX0 - 7 are usually storing texture coordinates.

enumerator MCL_TEX1

enumerator MCL_TEX2

enumerator MCL_TEX3

enumerator MCL_TEX4

enumerator MCL_TEX5

enumerator MCL_TEX6

enumerator MCL_TEX7

enumerator MCL_SIZE

enum RED::MESH_TEXCOORD_MAPPING

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

Values:

enumerator MTCM_PLANAR: Defines a planar texture coordinates mapping.

enumerator MTCM_SPHERICAL: Defines a spherical texture coordinates mapping.

enumerator MTCM_CYLINDRICAL: Defines a cylindrical texture coordinates mapping.

enumerator MTCM_CYLINDRICAL_CAP: Defines a cylindrical cap texture coordinates mapping.

enumerator MTCM_BOX: Defines a box texture coordinates mapping.

enum RED::POLYGON_WINDING_RULE

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

Values:

enumerator PWR_ODD: Fill odd numbers, default setting.

enumerator PWR_NON_ZERO: Fill non-zero numbers.

enumerator PWR_POSITIVE: Fill positive numbers.

enumerator PWR_NEGATIVE: Fill negative numbers.

enumerator PWR_ABS_GEQ_TWO: Fill ABSolute values Greater than EQual to TWO.

enum RED::OPTION_VALUE_FORMAT

Identifies all possible formats for an option value.

Values:

enumerator OPT_UNKNOWN: Unknown option format.

enumerator OPT_BOOLEAN: Indicates a boolean value option.

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

enumerator OPT_INTEGER: Indicates an integer value option.

enum RED::IO_LOAD_MATERIAL_TYPE

Lists all possible material types used during IO loading.

Values:

enumerator IOLMT_GENERIC: Create generic material during loading.

enumerator IOLMT_REALISTIC: Create realistic material during loading.

enum RED::IO_LOAD_TEXTURE_TRANSPARENCY

Lists transparency mode in loaded texture.

Values:

enumerator IOLTT_ALPHA: Transparency information is in the alpha channel.

enumerator IOLTT_RGB: Transparency information is in the RGB channels.

enum RED::IO_OBJECT_TYPE

Object types for import/export.

Values:

enumerator IOOT_NODE: Node hierarchy.

enumerator IOOT_MESH: Mesh.

enumerator IOOT_LINE: Line.

enumerator IOOT_MATERIAL: Material.

enumerator IOOT_TEXTURE: Texture.

enumerator IOOT_LIGHT: Light.

enumerator IOOT_VIEWPOINT: Viewpoint.

enumerator IOOT_SKINNING: Skeleton and Skinning data.

enumerator IOOT_ANIMATION: Animations.

enumerator IOOT_ALL: All objects.

enum RED::IO_SYSTEM_UNIT

System unit.

Values:

enumerator IOSU_MM: Millimeter.

enumerator IOSU_CM: Centimeter.

enumerator IOSU_DM: Decimeter.

enumerator IOSU_M: Meter.

enumerator IOSU_KM: Kilometer.

enumerator IOSU_INCH: Inch.

enumerator IOSU_FOOT: Foot.

enumerator IOSU_MILE: Mile.

enumerator IOSU_YARD: Yard.

enum RED::IO_FBX_FILE_VERSION

FBX file version.

Values:

enumerator IOFV_DEFAULT

enumerator IOFV_2010: 2010 compatibility.

enumerator IOFV_2011: 2011 compatibility.

enumerator IOFV_2012: 2012 compatibility.

enumerator IOFV_2013: 2013 compatibility.

enumerator IOFV_2014: 2014 compatibility.

enumerator IOFV_2016: 2016 compatibility.

enum RED::ROOT_MOTION_COMPONENT

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

Values:

enumerator RMC_ROTATION: Rotation root motion option.

enumerator RMC_POSITION_X: Root motion option for the X component of the position.

enumerator RMC_POSITION_Y: Root motion option for the Y component of the position.

enumerator RMC_POSITION_Z: Root motion option for the Z component of the position.

enum RED::ROOT_MOTION_POLICY

Value to give to the root motion options.

Values:

enumerator RMP_DEFAULT: The default value for the root motion component: applies the animation result to the root bone.

enumerator RMP_CUMULATIVE: Cumulates the animation deltas and applies the result to the root bone.

enumerator RMP_DELTA: Sets the animation deltas to the root bone.

enumerator RMP_ZERO: Ignores the animation root motion and sets the root bone transforms to zero.

enum RED::CLOUDS_TYPE

Defines the type of a clouds layer in the sky (see \ref bk_sm_clouds_types).

Values:

enumerator CT_CUMULUS: Puffy clouds with high density and clearly defined edges.

enumerator CT_STRATUS: Flat hazy clouds with low density.

enumerator CT_CIRRUS_1: Thin, wispy clouds visible at high altitude, model 1.

enumerator CT_CIRRUS_2: Thin, wispy clouds visible at high altitude, model 2.

enumerator CT_CIRRUS_3: Thin, wispy clouds visible at high altitude, model 3.

enumerator CT_CIRRUS_4: Thin, wispy clouds visible at high altitude, model 4.

enumerator CT_CIRRUS_5: Thin, wispy clouds visible at high altitude, model 5.

enum RED::LIGHT_TYPE

Defines the type of a light.

Values:

enumerator LT_NONE

enumerator LT_AMBIENT

enumerator LT_DIRECTIONAL

enumerator LT_POINT

enumerator LT_POINT_SPOT

enumerator LT_BEAM

enumerator LT_AREA

enumerator LT_AREA_SPOT

enumerator LT_SUN

enumerator LT_SKY

enumerator LT_PHYSICAL

enumerator LT_MOON

enum RED::ACCESS_MODE

This enumeration lists all stream read / write modes.

Values:

enumerator AM_READ: The stream will be accessed in read only mode.

enumerator AM_WRITE: The stream will be accessed in write only mode. Existing data will be overwritten.

enumerator AM_READWRITE_OVER: The stream will be accessed in read-write mode. If the stream already exists, it will be overwritten.

enumerator AM_READWRITE_APPEND

The stream will be accessed in read-write mode. If the stream already exists:

data will be appended at the end of it if it is a file stream
data will be appended after the most recently written data if it is a memory stream. In order to append data at the end of the memory stream instead, use the Move method to set the writing cursor position at the end of the stream.

enum RED::TEXT_ATTACH_POS

Relative position of a text to its anchoring point: ../_images/API_TEXT_ATTACH_POS.png

Values:

enumerator TAP_TOP_LEFT: The top left corner of the text bounding rectangle will be placed at the anchoring position.

enumerator TAP_TOP: The middle of the top line of the text bounding rectangle will be placed at the anchoring position.

enumerator TAP_TOP_RIGHT: The top right corner of the text bounding rectangle will be placed at the anchoring position.

enumerator TAP_RIGHT: The middle of the right line of the text bounding rectangle will be placed at the anchoring position.

enumerator TAP_BOTTOM_RIGHT: The bottom right corner of the text bounding rectangle will be placed at the anchoring position.

enumerator TAP_BOTTOM: The middle of the bottom line of the text bounding rectangle will be placed at the anchoring position.

enumerator TAP_BOTTOM_LEFT: The bottom left corner of the text bounding rectangle will be placed at the anchoring position.

enumerator TAP_LEFT: The middle of the left line of the text bounding rectangle will be placed at the anchoring position.

enumerator TAP_CENTER: The center of the text bounding rectangle will be placed at the anchoring position.

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

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

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

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

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

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

enumerator TAP_BASELINE_LEFT_EDGE: The leading leftmost vertical edge of the character is used as “left edge” reference. Then, we combine this with the baseline of the text bounding rectangle to get the anchoring position. Technically speaking, we ignore negative glyph origins (gmetrics.gmptGlyphOrigin.x) to anchor the string.

enum RED::VIEWPOINT_TYPE

Lists the possible projections for a viewpoint.

Values:

enumerator VPT_PARALLEL: Orthographic viewpoint projection. See RED::IViewpoint::SetFrustumParallel.

enumerator VPT_PERSPECTIVE: Perspective viewpoint projection. See RED::IViewpoint::SetFrustumPerspective.

enumerator VPT_CUSTOM: Custom viewpoint projection. See RED::IViewpoint::SetFrustumCustom.

enum RED::VRL_SORT

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

Values:

enumerator VST_FRONT: Indicates to target the foreground list of viewpoints in a VRL. Foreground viewpoints are drawn over scene and back viewpoints.

enumerator VST_SCENE: Indicates to target the scene list of viewpoints in a VRL.

enumerator VST_BACK: Indicates to target the background list of viewpoints in a VRL. Background viewpoints are drawn behind scene and foreground viewpoints.

enum RED::VRL_SIZEPOS

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

Values:

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.

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

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

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

enumerator VSP_SIZE_STRETCHED_AUTO_RATIO: Specify this parameter when inserting a viewpoint in a VRL to specify that on a REDWindow::Resize operation, the viewpoint size vary with the vrl size change. The viewpoint height / width (or vertical fov / horizontal fov) ratio is maintained equal to the vrl height / width ratio, meaning that the rendering of a cube remains seen as a cube whatever may be the vrl size it’s in.

enum RED::FRAME_TRACING_FEEDBACK

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

Values:

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.

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

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

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

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

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

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

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

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

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

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

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

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

enumerator FTF_PATH_TRACING: RED::IWindow::FrameTracing will return based on the specified time interval and will use a path tracing-based refinement method to display the image.

enum RED::GI_CACHE_MODE

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

Values:

enumerator GICM_CAMERA_VIEW: The GI cache is computed for the given camera only.

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

enumerator GICM_WORLD: The GI cache is computed for the whole scene, without taking the camera into account.

enum RED::OPTIONS

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

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

Values:

enumerator OPTIONS_RAY_PRIMARY

[boolean]: [false, true].

[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).

enumerator OPTIONS_RAY_SHADOWS

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

enumerator OPTIONS_RAY_REFLECTIONS

[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

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.

enumerator OPTIONS_RAY_REFRACTIONS

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

enumerator OPTIONS_RAY_TRANSPARENCY

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

enumerator OPTIONS_RAY_REFRACTIONS_BACK

[boolean]: [false, true].

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

enumerator OPTIONS_RAY_MAX_THREADS

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

enumerator OPTIONS_RAY_CUTOFF

[double]: [0.0, 1.0].

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

enumerator OPTIONS_RAY_ENABLE_GLOSSY_EFFECTS

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

enumerator OPTIONS_RAY_ENABLE_AREA_SAMPLING

[boolean]: [false, 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.

enumerator OPTIONS_RAY_ENABLE_SOFT_TRACER

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

enumerator OPTIONS_RAY_ENABLE_CAUSTICS

[boolean]: [false, true].

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

enumerator OPTIONS_RAY_CAUSTICS_SAMPLING_RATE

[integer]: [0, 100000].

[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).

enumerator OPTIONS_RAY_CAUSTICS_SEARCH_RADIUS

[double]: [0.0, inf[.

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

enumerator OPTIONS_RAY_CAUSTICS_SEARCH_COUNT

[integer]: [0, 4096].

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

enumerator OPTIONS_RAY_LIGHTS_SAMPLING_RATE

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

enumerator OPTIONS_RAY_GLOSSY_SAMPLING_RATE

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

enumerator OPTIONS_RAY_VOLUME

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

enumerator OPTIONS_RAY_DISPLACEMENT

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

enumerator OPTIONS_RAY_USE_EMBREE

[boolean]: [false, 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.

enumerator OPTIONS_RAY_FORCE_EMBREE

[boolean]: [false, true].

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

enumerator OPTIONS_RAY_ENABLE_OPEN_IMAGE_DENOISE

[scope]: All options instances.

This option turns on the Intel Open Image Denoise that can modify software generated images during a post calculation pass. The denoiser will try to remove noise in the image while preserving all its details.

enumerator OPTIONS_VIEWPOINT_PICKABLE

[boolean]: [false, 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.

enumerator OPTIONS_SHADOW_MAP_DEPTH

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

enumerator OPTIONS_POLYGON_FILL_MODE

[integer]: 0, 1 or 2.

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

enumerator OPTIONS_SHADOW_MAP_TRANSPARENCY

[boolean]: [false, true].

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

enumerator OPTIONS_AUTO_CUBE_ENV_SIZE

[integer]: 1 to maximum texture size. Must be POTD.

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

enumerator OPTIONS_AUTO_CUBE_ENV_UPDATE_MODE

[integer]: 0 or 1.

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

enumerator OPTIONS_AUTO_CUBE_ALLOW_RAYTRACER

[boolean]: [false, true].

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

enumerator OPTIONS_GI_CACHE_TRANSPAR_DRAW

[boolean]: [false, true].

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

enumerator OPTIONS_MATERIAL_LAYER_INTERSECT

[boolean]: [false, true].

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

enumerator OPTIONS_TONE_MAPPING_IGNORE_BACKGROUND

[boolean]: [false, true].

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

enumerator OPTIONS_VIEWPOINT_ORTHOGRAPHIC_EYE_AUTO_OFFSET

[double]: [ 0.0, DBL_MAX [.

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

enumerator OPTIONS_REFRESH_INSTANCE_COUNTERS

[boolean]: [false, true].

[scope]: All options instances.

This option let the user force the update mechanism for instance counters. Instance counters are detailed noticeably there: \ref wf_using_instance_counters. Instance counter values (for both values and images) are only updated when a shape event occurs on the path to the shape instance. It may be wishful to also force a global scene graph refresh of the scene values noticeably if there are material changes and no corresponding scene graph data updates. Enabling this option will refresh instance counter values for the entire scene graph(s) of the camera(s) receiving the option value enabled (either natively or after inheritance).

enumerator OPTIONS_WINDOW_HDR

[integer]: 0 to 2.

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

enumerator OPTIONS_WINDOW_PICK_AREA

[integer]: 0 to 20.

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

enumerator OPTIONS_WINDOW_PICK_AREA_TRIANGLE

[boolean]: [false, 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.

enumerator OPTIONS_WINDOW_DRAW_SYNC

[boolean]: [false, true].

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

enumerator OPTIONS_DATA_RELEASE_TIMER

[integer]: [1,inf[ indicates a number of transactions.

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

enumerator OPTIONS_IMMEDIATE_MODE

[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”.

enumerator OPTIONS_LIGHT_CUTOFF

[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: \ref bk_ap_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.

enumerator OPTIONS_FORCE_STENCIL

[boolean]: [false, true].

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

enumerator OPTIONS_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.

enumerator OPTIONS_FORCE_COMPRESSED_IMAGES_INTEL

[boolean]: [ false, true ].

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

enumerator OPTIONS_OPENGL_CONTEXT_MAJOR

[integer]: [ 0, inf [.

[scope]: Cluster’s resource manager only.

This option can be used before the engine startup to force the version of OpenGL contexts creation. By default, REDsdk does not require any OpenGL context version. On setting up any positive value for this option, contexts will be created using wglCreateContextAttribsARB using the WGL_CONTEXT_PROFILE_MASK_ARB flag and the WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB flags. This option’s value define the major version of the OpenGL context.

enumerator OPTIONS_OPENGL_CONTEXT_MINOR

[integer]: [ 0, inf [.

[scope]: Cluster’s resource manager only.

This option can be used before the engine startup to force the version of OpenGL contexts creation. This option’s value defines the minor version of the OpenGL context. See RED::OPTIONS_OPENGL_CONTEXT_MAJOR for further details.

enumerator OPTIONS_OPENGL_CONTEXT_DEBUG

[boolean]: [ false, true ].

[scope]: Cluster’s resource manager only.

This option can be used before the engine startup to force the debug mode for OpenGL contexts creation. This option is only effective if the OPTIONS_OPENGL_CONTEXT_MAJOR is being set.

enumerator OPTIONS_RAY_GI

[boolean]: [false, true].

[scope]: All options instances.

Enable or disable Global Illumination rendering.

enumerator OPTIONS_RAY_GI_ERROR

[double]: [0.001,1000.0] indicates the error tolerance of the global illumination solution.

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.

enumerator OPTIONS_RAY_GI_ESTIMATOR_SAMPLING_RATE

[integer]: [1,65535[ indicates the squared root of the number of rays used to compute the 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.

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

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

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

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

enumerator OPTIONS_RAY_GI_CACHE_INTERP_SAMPLES_COUNT

[integer]: [1,inf[ indicates the number of samples taken while estimating the indirect illumination using the cache.

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

enumerator OPTIONS_RAY_GI_SHOW_SAMPLES

[integer]: 0, 1, 2 or 4.

[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).

enumerator OPTIONS_RAY_GI_ENABLE_VOLUME

[boolean]: [false, true].

[scope]: All options instances.

Enable or disable the volume rendering during the global illumination process.

enumerator OPTIONS_RAY_GI_CACHE_PRECISE

[boolean]: [false, true].

[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…

enumerator OPTIONS_RAY_GI_FOR_GLOSSINESS

[double]: [0, 32].

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

enumerator OPTIONS_RAY_GI_FOR_LIGHTING

[boolean]: [false, true].

[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).

enumerator OPTIONS_RAY_SOFT_SHADOW_MAP_TRANSPARENCY

[boolean]: [false, true].

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

enumerator OPTIONS_RAY_AREA_SHADOW_SPACING

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

enumerator OPTIONS_RAY_AREA_SHADOW_SPREAD

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

enumerator OPTIONS_RAY_CONTEXT_CALLBACK_PERSISTENCE

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

enumerator OPTIONS_RAY_FORCE_TRANSPARENCY

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

enumerator OPTIONS_RAY_SOFT_PREVIEW

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

enumerator OPTIONS_RAY_WORLD_CACHE_SAMPLES_COUNT

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

enumerator OPTIONS_RAY_WORLD_CACHE_SAMPLES_SPREAD

[double]: [0.001, 1000.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.

enumerator OPTIONS_RAY_TRANSPARENCY_TOLERANCE_GPU

[double]: [0.0, inf[.

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

enumerator OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD

[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 \ref bk_re_adaptive_sampling for a detailed view of adaptive sampling in REDsdk.

enumerator OPTIONS_RAY_MAX_SECONDARY_RAY_INTENSITY

[double]: [ 1.0, DBL_MAX [.

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

enumerator OPTIONS_RAY_ENABLE_DENOISER

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

enumerator OPTIONS_RAY_DENOISER_STRENGTH

[double]: [ 0.01, 10.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.

enumerator OPTIONS_RAY_DENOISER_RADIUS

[integer]: [ 0, 100 ].

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

enumerator OPTIONS_RAY_TRANSPARENCY_FFP_GPU

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

enumerator OPTIONS_RAY_ADAPTIVE_SAMPLING_ALLOWED_TIME

[ double ] : [ 0.0, inf [ in seconds. [ default ] : 0.0.

[ scope ] : All options instances.

This option works when \ref bk_re_adaptive_sampling is enabled for the currently rendered scene. It forces the engine to stop all calculations after the specified amount of time has been spent. This option can be used to drive the quality of the resulting image by specifying an amount of time allowed to calculate it. The engine will optimize the amount of time it’s granted to refine the most noisy areas in an image first, trying to provide the best image quality for the allowed time. This is time driven adaptive sampling;

If the option value is set to 0 seconds, time driven adaptive sampling is turned off and the value of the RED::OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD rules adaptation. If set to any positive value, expressed in seconds, this option overrides the RED::OPTIONS_RAY_ADAPTIVE_SAMPLING_THRESHOLD whose value is ignored as not used in that case.

The minimal amount of time taken to process an image is bound by the time taken to process global illumination plus the time taken to do a first parsing of the image based on rendering settings.

Images processed when this option is turned on are not deterministic as the amount of calculations the engine can issue in a fixed amount of time depends on the target computer number of threads and workload of the system at the time of the processing.

enumerator OPTIONS_PATH_GI

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

enumerator OPTIONS_RAY_GI_ESTIMATOR_FULL_PATH

[ boolean ]: [ false, true ].

[ default ] : false (disabled).

[ scope ]: All options instances.

If turned on, this option modifies the behavior of the GI estimator phase. GI paths that are processed by the system are fully processed until their extinction. This significantly extends the GI estimator phase calculation time, but increases its quality for that extra price. Noticeably, estimator halos that can be visible in very indirectly illuminated scenes tend to be smaller or to disappear and the estimator is more reliable and stable to camera movements and options changes.

Please note that this option should be combined with a high value of RED::OPTIONS_RAY_GI_ESTIMATOR_SAMPLING_RATE. The refinement of the estimator will be better when the estimator sampling rate is increased to high values like 2000, 4000 or even 8000.

enum RED::TONEMAPPING_OPERATOR

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

Values:

enumerator TMO_CLAMP: RGBA color components are clamped to [0.0, 1.0].

enumerator TMO_PHOTOGRAPHIC: Tone mapping operator derived from photographers’ best practices.

enumerator TMO_NEUTRAL: This is the neutral ‘no tone mapping’ operator that does not change any input intensities.

enumerator TMO_EXPOSURE: Tone mapping operator that simply multiplies the input intensities by the exposute parameter value.

enumerator TMO_EXPONENTIAL: Exponential tonemapping operator based on the average luminance in an image.

enum RED::PRODUCT

Aliases for the TechSoft3D products. Internal to TechSoft3D.

TechSoft3D products supported platforms.

Values:

enumerator PROD_UNKNOWN

enumerator PROD_REDEXPORTER_MAX

enumerator PROD_REDODADEVICE

enumerator PROD_REDSDK

enumerator PROD_REDPARASOLID

enumerator PROD_REDMATERIALEDITOR

enumerator PROD_REDC3D

enumerator PROD_REDNET

enumerator PROD_REDART

enumerator PROD_COUNT

enum RED::PLATFORM

Values:

enumerator PTM_UNKNOWN

enumerator PTM_WINDOWS

enumerator PTM_LINUX

enumerator PTM_MACOS

enumerator PTM_COUNT

enum RED::HOST_PRODUCT

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

Values:

enumerator HPROD_UNKNOWN

enumerator HPROD_AUTODESK_MAX

enumerator HPROD_AUTODESK_VIZ

enum RED::SOFT_GEOMETRY_PRIMITIVE

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

Values:

enumerator GEO_UNMODIFIED: Indicates that the source primitive kind is not modified. The source primitive assembly is not modified either.

enumerator GEO_POINTS: The geometry shader receives or generates indexed points.

enumerator GEO_LINE_SEGMENTS: The geometry shader receives or produces indexed line segments.

enumerator GEO_LINE_SEGMENTS_ADJACENCY: The geometry shader receives indexed segments with adjacency.

enumerator GEO_LINE_STRIP: The geometry shader receives or produces one indexed line strip.

enumerator GEO_TRIANGLES: The geometry shader receives or produces indexed triangles.

enumerator GEO_TRIANGLES_ADJACENCY: The geometry shader receives indexed triangles with adjacency.

enum RED::AA_FILTER

Values:

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.

enumerator AA_AREA_FXAA: Anti-aliasing post filter based on the original FXAA algorithm from NVIDIA.

enum RED::TEXT_ALPHA_MODE

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

Values:

enumerator TEXT_ALPHA_LINEAR: Alpha is linearly interpolated.

enumerator TEXT_ALPHA_3A2_MINUS_2A3: Uses an alpha interpolation formula based on the 3*(a*a) - 2*(a*a*a) equation.

enumerator TEXT_ALPHA_SQRTA: Uses an alpha interpolation formula based on sqrt(a).

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

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

enumerator TEXT_ALPHA_SQRTA_DEPTH: Same as TEXT_ALPHA_SQRTA; the text custom depth channel is used to redefine the final depth of the text in the z-buffer.

enum RED::RSV_TYPE

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

Values:

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.

enumerator RSV_LINE: Line-based primitives, i.e primitives without normals.

enumerator RSV_TRIANGLE_UBYTE_NORMALS: Triangle-based primitives. Primitives must have their normals defined using a xyzw RED::MFT_UBYTE encoding. w is unusued, but needed for memory alignment.

enum RED::BSDF_REQUEST

Values:

enumerator BSDF_REQUEST_UNDEFINED

enumerator BSDF_REQUEST_EVAL

enumerator BSDF_REQUEST_PDF

enumerator BSDF_REQUEST_EMITTED

enumerator BSDF_REQUEST_SAMPLE

enum RED::BSDF_EVENT

Values:

enumerator BSDF_EVENT_UNDEFINED

enumerator BSDF_EVENT_DIFFUSION

enumerator BSDF_EVENT_REFLECTION

enumerator BSDF_EVENT_TRANSMISSION

enumerator BSDF_EVENT_ABSORPTION

enumerator BSDF_EVENT_ALL

enum RED::TRANSACTION_MODE

Lists the current transaction mode we’re in.

Values:

enumerator TRANSACTION_OUT: Indicates that we’re outside of a transaction. We can’t modify any state sensitive data in the cluster.

enumerator TRANSACTION_IN: Indicates that we’re inside a transaction. We can modify state sensitive objects in the cluster, using the state instance got from the RED::IResourceManager interface.

enum RED::THREAD_PRIORITY

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

Values:

enumerator TP_LOWEST: Lowest thread priority.

enumerator TP_LOW: Low thread priority.

enumerator TP_NORMAL: Normal thread priority.

enumerator TP_HIGH: High thread priority.

enumerator TP_HIGHEST: Highest thread priority.

Type Alias Documentation

typedef unsigned long RED::uint64

typedef long RED::int64

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

Param iReferenceManager:
	The object instance used to solve all links between chunk parameters (crossed references, shared resources, etc…)
Param iStream:	The source stream.
Param iChunkSignature:
	Chunk number.
Param iChunkSize:
	Byte size of the chunk.
Param oResult:	Created object.
Param iState:	Current transaction.
Return:	RED_OK in case of success, RED_BAD_PARAM for all invalid inputs, RED_ALLOC_FAILURE upon a memory allocation failure, RED_FAIL otherwise.

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

Prototype of the RED image custom format loading.

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

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

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

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.

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

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

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

typedef void (*RED::REDSDK_WARNING_CALLBACK)(RED_RC iRC, const char *iWarning, const char *iMessage, void *iUser)

Prototype of the warning handling callback.

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

The iRC is the warning code. 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. The parameter iUser specifies a user data pointer provided by the user when setting up the callback.

Param iRC:	Warning code.
Param iWarning:	Source warning string.
Param iInfo:	Extra information string.
Param iUser:	User data specified on callback setup.

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

Prototype of the OpenGL material customization callback.

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

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

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

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

Prototype of the OpenGL viewpoint customization callback.

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

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

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

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

Prototype of the OpenGL buffer customization callback.

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

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

Param iUser:	User data specified during the callback setup.

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 \ref wf_using_culling_callbacks_for_visibility_control for a practical callback usage example.

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

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

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 \ref wf_using_instance_counters for a practical example of using instance counters.

Param oReferenceValue:
	The result of the callback.
Param iUid:	The object instance unique ID.
Param 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.
Return:	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 \ref wf_using_instance_counters for a practical example of using instance counters.

Param oReferenceValue:
	The result of the callback.
Param iUid:	The object instance unique ID.
Param 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.
Return:	Any RED_RC is authorized here. RED_OK in case of success.

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.

Param iRayContext:
Param 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.
	Software ray context with informations on the currently hit object.
Param iRenderingContext:
	Rendering context of the image.
Param iUser:	User pointer as specified in RED::IViewpointRenderList::SetPixelAnalysisCallback.
Return:	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 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.

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

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

Param iLayerSet:
Param oTHit:	Parametric length of the ray of the found intersection.
Param oTHit1:	Hit primitive user information.
Param oTHit2:	Hit primitive user information.
Param iE:	Ray starting position.
Param iP:	Ray ending position.
Param iTIn:	Ray starting position by parametric length on [ iE, iP ].
	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.
Param iNumThread:
	Number of the calling thread.
Param ioUserData:
	User data pointer specified during callback setup.
Return:	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 ).

Param 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.
Param 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.
Param oMaterial:
	The material address to use for the shading of the last hit primitive for that thread.
Param 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.
Param iTHit:	Parametric length of the ray at the intersection.
Param iTHit1:	Hit primitive user information.
Param iTHit2:	Hit primitive user information.
Param iE:	Ray starting position.
Param iP:	Ray ending position.
Param iNumThread:
	Number of the calling thread.
Param ioUserData:
	User data pointer specified during callback setup.
Return:	RED_OK if the method has succeeded, RED_FAIL otherwise.

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.

Param iFrameStatistics:
	Calculated frame statistics at the time of the call.
Param iUserData:
	User data associated to the callback.
Return:	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_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’.

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

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

typedef void *(*RED::THREAD_CALLBACK)(void*)

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.

Param iThreadClass:
	The thread class address.
Return:	0 in case of success, any other value in case of error. Thread errors should be set using RED::Thread::StopRun.

RED

Types

Type Aliases

Fields

Functions

Detailed Description

Type Documentation

Type Alias Documentation

Function Documentation