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(*

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

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:

  1. data will be appended at the end of it if it is a file stream

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

enum RED::TEXT_ATTACH_POS

Relative position of a text to its anchoring point: ../build/doxygen/RED/xml/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

  1. Activation of reflection forces the activation of the primary ray option. The value of this option indicates the depth of the reflection calculation process in the ray-tracing tree.

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

Param iImageFormat

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 iRC

Error code.

Param iCaller

Name of the calling method or function.

Param iObject

Relevant object address for the error.

Param iExpression

Called source expression 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 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.

Param iViewpoint

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 iWindow

The RED::IWindow being rendered.

Param iVRL

The RED::IViewpointRenderList being rendered.

Param iViewpoint

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

Param iRayContext

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

Param iLayerSet

Layerset to consider that may be set by REDsdk during the processing of shadow rays. If a valid RED::LayerSet address is received by the callback, then the intersection callback should discard all custom geometries that don’t match iLayerSet from its results.

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.

Function Documentation

Warning

doxygenfunction: Unable to resolve function “GetREDErrorMessage” with arguments “None”. Candidate function could not be parsed. Parsing error is Error when parsing function declaration. If the function has no return type: Error in declarator or parameters-and-qualifiers Invalid C++ declaration: Expecting “(” in parameters-and-qualifiers. [error at 7] RED_RC REDFullExp GetREDErrorMessage (RED::String &oErrorMessage, RED_RC iRC) ——-^ If the function has a return type: Error in declarator or parameters-and-qualifiers If pointer to member declarator: Invalid C++ declaration: Expected ‘::’ in pointer to member (function). [error at 18] RED_RC REDFullExp GetREDErrorMessage (RED::String &oErrorMessage, RED_RC iRC) ——————^ If declarator-id: Invalid C++ declaration: Expecting “(” in parameters-and-qualifiers. [error at 18] RED_RC REDFullExp GetREDErrorMessage (RED::String &oErrorMessage, RED_RC iRC) ——————^

Warning

doxygenfunction: Unable to resolve function “REDBreak” with arguments “None”. Candidate function could not be parsed. Parsing error is Error when parsing function declaration. If the function has no return type: Error in declarator or parameters-and-qualifiers Invalid C++ declaration: Expected identifier in nested name, got keyword: void [error at 4] void REDFullExp REDBreak (RED_RC iRC, const char *iCaller, const void *iObject, const char *iExpression, const char *iInfo) —-^ If the function has a return type: Error in declarator or parameters-and-qualifiers If pointer to member declarator: Invalid C++ declaration: Expected ‘::’ in pointer to member (function). [error at 16] void REDFullExp REDBreak (RED_RC iRC, const char *iCaller, const void *iObject, const char *iExpression, const char *iInfo) —————-^ If declarator-id: Invalid C++ declaration: Expecting “(” in parameters-and-qualifiers. [error at 16] void REDFullExp REDBreak (RED_RC iRC, const char *iCaller, const void *iObject, const char *iExpression, const char *iInfo) —————-^