StateShader

Fields

BACK
FRONT
NONE
NEVER
LESS
LEQUAL
GREATER
GEQUAL
EQUAL
NOTEQUAL
ALWAYS
DEPTH_SKIP
ON
OFF
STENCIL_ON
STENCIL_OFF
STENCIL_OP_KEEP
STENCIL_OP_ZERO
STENCIL_OP_REPLACE
STENCIL_OP_INCR
STENCIL_OP_DECR
STENCIL_OP_INVERT
SKIP
NO_BLENDING
ADDITIVE
SUBTRACTIVE
MULTIPLICATIVE
CUSTOM
ADD
SUBTRACT
REVERSE_SUBTRACT
MIN
MAX
EQ_ENUM_SIZE
ZERO
ONE
SRC_COLOR
ONE_MINUS_SRC_COLOR
DST_COLOR
ONE_MINUS_DST_COLOR
SRC_ALPHA
ONE_MINUS_SRC_ALPHA
DST_ALPHA
ONE_MINUS_DST_ALPHA
SRC_ALPHA_SATURATE
CONSTANT_COLOR
ONE_MINUS_CONSTANT_COLOR
CONSTANT_ALPHA
ONE_MINUS_CONSTANT_ALPHA
FUNC_ENUM_SIZE
NO_TRANSPARENCY
MASKED_TRANSPARENCY
SORTED_TRANSPARENCY
SORTED_AND_MASKED_TRANSPARENCY

Functions

SET_CID
IMPLEMENT_AS
SET_CHUNK_SIGNATURE
IMPLEMENT_CHUNKINTERPRETER
StateShader
Shader * Clone
~StateShader
RED_RC SetNoTransparency
RED_RC SetMaskedTransparency
RED_RC SetSortedTransparency
RED_RC SetSortedTransparency
RED_RC SetSortedAndMaskedTransparency
RED_RC SetAlphaThreshold
RED_RC SetFaceCulling
RED_RC SetBlendingMode
RED_RC SetBlendingMode
RED_RC SetBlendingConstant
RED_RC SetBlendingMode
RED_RC SetDoubleSided
RED_RC SetDepthFunction
RED_RC SetDepthTest
RED_RC SetDepthMask
RED_RC SetLineWidth
RED_RC SetLineStipple
RED_RC SetLineStipplePattern
RED_RC SetLineSmoothing
RED_RC SetPointSmoothing
RED_RC SetPointSize
RED_RC SetPolygonOffset
RED_RC SetPolygonOffsetValue
RED_RC SetColorMask
RED_RC SetMatte
RED_RC SetDisplacement
RED_RC SetStencilTest
RED_RC SetStencilFunction
RED_RC SetStencilOperation
RED_RC SetStencilMask
RED_RC SetReflectiveCaustics
RED_RC SetRefractiveCaustics
RED_RC GetPlatformsCount
RED_RC GetPlatformList
RED_RC GetTransparencyMode
RED_RC GetTransparencyImage
RED_RC GetTransparencyColor
RED_RC GetAlphaThreshold
RED_RC GetBlendingMode
RED_RC GetBlendingMode
RED_RC GetBlendingMode
RED_RC GetFaceCulling
RED_RC GetDoubleSided
RED_RC GetDepthFunction
RED_RC GetDepthTest
RED_RC GetDepthMask
RED_RC GetLineWidth
RED_RC GetLineStipple
RED_RC GetLineStipplePattern
RED_RC GetLineSmoothing
RED_RC GetPointSmoothing
RED_RC GetPointSize
RED_RC GetPolygonOffset
RED_RC GetPolygonOffsetValue
RED_RC GetColorMask
RED_RC GetMatte
RED_RC GetDisplacement
RED_RC GetStencilTest
RED_RC GetStencilFunction
RED_RC GetStencilOperation
RED_RC GetStencilMask
RED_RC GetReflectiveCaustics
RED_RC GetRefractiveCaustics
RED_RC UpdateFrom
RED_RC GetOperationStream
RED_RC Solve
RED_RC Save

Detailed Description

class StateShader : public RED::Shader

Rendering pipeline configuration shader class.

@related Writing a Custom Material, Configuring a Render Shader Using a State Shader, class RED::IMaterial, class RED::RenderShader, class RED::RenderCode

The RED::StateShader is used to configure the rendering pipeline for all shaders that are rendered after it in a list of shaders in a material. Hardware and software state parameters are managed using this shader. State parameters include all the parameters typically involved in the setup of a rendering pass, such as depth equation, blending mode, stencil, lines or point shapes, etc…

Transparency should be consistent across all state shaders within a material. Ray-traced transparency information will be based on an analysis of the state shaders of the material.

Default state shader parameters are set to:

  • BACK face culling.
  • SKIP blending mode.
  • SKIP depth testing mode.
  • SKIP depth writing mode.
  • NO_TRANSPARENCY transparency.
  • 1 pixel line width.
  • Disabled line stipple,
  • No polygon offset,
  • Color writes enabled,
  • Line and point smoothing off,
  • Line thickness and point sizes set to 1,
  • No displacement map,
  • OFF stencil mode.
  • Stencil ref = 0.0, stencil mask = 0xffffffff, stencil writemask = 0xffffffff,
  • Stencil operations: all STENCIL_OP_KEEP.

The RED::StateShader supports multiple hardware platforms, as the RED::RenderShader do. On setting up a given platform for the first time, the state shader clones any more generic platform that was setup before. For example if the shader uses a give polygon offset setup for RED::HW_GENERIC platform, on setting up a parameter for the RED::HW_NVIDIA_G400 platform, all values from the RED::HW_GENERIC platform will be copied. However, once the two platform exist, there’s no more copy of any setting: modifying the RED::HW_GENERIC platform will not change the RED::HW_NVIDIA_G400 platform parameters.

Public Types

enum CULLING_MODE

Select the side of a triangle that is to be visible during the rendering: BACK or FRONT. To render both faces of a polygon, use NONE.

Values:

enumerator BACK

Culls back faces of the rendered geometry.

enumerator FRONT

Culls front faces of the rendered geometry.

enumerator NONE

Culls neither front nor back faces of the rendered geometry.

enum FUNCTION

Enumeration of a depth or stencil test function.

Values:

enumerator NEVER

Never pass the depth or stencil test for any fragment.

enumerator LESS

Pass the depth or stencil test if the incoming fragment’s depth is less than the current buffer depth or stencil at the fragment’s coordinates.

enumerator LEQUAL

Pass the depth or stencil test if the incoming fragment’s depth is less than or equal to the current buffer depth or stencil at the fragment’s coordinates.

enumerator GREATER

Pass the depth or stencil test if the incoming fragment’s depth is greater than the current buffer depth or stencil at the fragment’s coordinates.

enumerator GEQUAL

Pass the depth or stencil test if the incoming fragment’s depth is greater than or equal to the current buffer depth or stencil at the fragment’s coordinates.

enumerator EQUAL

Pass the depth or stencil test if the incoming fragment’s depth is equal to the current buffer depth or stencil at the fragment’s coordinates.

enumerator NOTEQUAL

Pass the depth or stencil test if the incoming fragment’s depth is not equal to the current buffer depth or stencil at the fragment’s coordinates.

enumerator ALWAYS

Always pass the depth or stencil test for any fragment (default).

enum DEPTH_MODE

Enable or disable z testing or writing.

Values:

enumerator DEPTH_SKIP

Let the current depth testing or writing mode unchanged (default).

enumerator ON

Enable depth testing using the specified depth comparison function or enable depth writing.

enumerator OFF

Disable depth testing or writing.

enum STENCIL_MODE

Enable or disable stencil testing.

Values:

enumerator STENCIL_ON

Enable stencil testing.

enumerator STENCIL_OFF

Disable stencil testing.

enum STENCIL_OPERATION

Lists all possible stencil operations.

Values:

enumerator STENCIL_OP_KEEP

Stencil operation. Keep existing stencil value unchanged.

enumerator STENCIL_OP_ZERO

Stencil operation. Set stencil value to zero.

enumerator STENCIL_OP_REPLACE

Stencil operation. Replace stencil value by incoming stencil value.

enumerator STENCIL_OP_INCR

Stencil operation. Increment stencil buffer by 1.

enumerator STENCIL_OP_DECR

Stencil operation. Decrement stencil buffer by 1.

enumerator STENCIL_OP_INVERT

Stencil operation. Invert bits in stencil buffer values.

enum BLENDING_MODE

Select the blending mode for all incoming geometries.

Values:

enumerator SKIP

Means that we do not affect the current blending statement.

enumerator NO_BLENDING
enumerator ADDITIVE

color = (src_color * src_alpha) + (dest_color * (1 - src_alpha)).

enumerator SUBTRACTIVE

color = (src_color * src_alpha) - (dest_color * (1 - src_alpha)).

enumerator MULTIPLICATIVE

color = src_color * dest_color.

enumerator CUSTOM

color = function1( src_color ) operand function2( dest_color ).

enum BLENDING_EQUATION

Lists all possible blending operations mixing the incoming fragment color and the destination fragment color.

Values:

enumerator ADD

color = src_color + dest_color.

enumerator SUBTRACT

color = src_color - dest_color.

enumerator REVERSE_SUBTRACT

color = dest_color - src_color.

enumerator MIN

color = min( src_color, dest_color ).

enumerator MAX

color = max( src_color, dest_color ).

enumerator EQ_ENUM_SIZE

Size of this enumeration.

enum BLENDING_FUNCTION

Lists all functions that can apply to the source or destination colors in the blending equation. The blending formula is always ‘func1(src_color) operation func2(dest_color)’.

Values:

enumerator ZERO
enumerator ONE
enumerator SRC_COLOR
enumerator ONE_MINUS_SRC_COLOR
enumerator DST_COLOR
enumerator ONE_MINUS_DST_COLOR
enumerator SRC_ALPHA
enumerator ONE_MINUS_SRC_ALPHA
enumerator DST_ALPHA
enumerator ONE_MINUS_DST_ALPHA
enumerator SRC_ALPHA_SATURATE
enumerator CONSTANT_COLOR
enumerator ONE_MINUS_CONSTANT_COLOR
enumerator CONSTANT_ALPHA
enumerator ONE_MINUS_CONSTANT_ALPHA
enumerator FUNC_ENUM_SIZE
enum TRANSPARENCY_MODE

Select the kind of transparency we should use for the shader.

Values:

enumerator NO_TRANSPARENCY

The name says it.

enumerator MASKED_TRANSPARENCY

This is a fake transparency. The texture specified in RED::StateShader::SetMaskedTransparency is used as a filter for the fragments to render. There’s no blending at all as the transparency result is a binary 0 / 1 value. Ray-traced shadows are defined by the masking texture’s alpha intensity.

enumerator SORTED_TRANSPARENCY

Blended transparency. The color or transparency texture is specified by RED::StateShader::SetSortedTransparency. Ray-traced shadows are defined by the color of the transparency, or by the texture’s color modulated by the texture’s alpha.

enumerator SORTED_AND_MASKED_TRANSPARENCY

The texture’s alpha value is used to mask the pixel regions where the fragments are rendered. This combines both transparency modes, using the single texture specified with RED::StateShader::SetSortedAndMaskedTransparency. Ray-traced shadows are computed as for the RED::StateShader::SORTED_TRANSPARENCY mode.

Public Functions

SET_CID(CID_class_REDStateShader)
IMPLEMENT_AS()
SET_CHUNK_SIGNATURE (0x00000707)
IMPLEMENT_CHUNKINTERPRETER()
StateShader()

Construction method.

The StateShader is using a RED::HARDWARE_PLATFORM identifier for all data setup & access, in all ways similarly to the RED::RenderShader, so that the same state shader instance can behave differently on different hardware.

A state shader uses the default RED::Object ID set at its creation time.

virtual RED::Shader *Clone() const

Object duplication.

Returns:An allocated copy of ‘this’.
virtual ~StateShader()

Destruction method.

RED_RC SetNoTransparency(RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Indicates that we are not transparent at all.

This is the default of a state shader.

Parameters:iPlatformID – Platform identifier.
Returns:RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.
RED_RC SetMaskedTransparency(const RED::Object *iAlphaImage, RED::MESH_CHANNEL iAlphaChannel, const RED::Matrix &iAlphaMatrix, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines a mask based transparency.

See \ref bk_bm_custom_state_alphamask for details.

Parameters:
  • iAlphaImage – Specify the address of the alpha masking texture.
  • iAlphaChannel – Mesh channel source of the UV for the alpha mapping transparency texture sampling.
  • iAlphaMatrix – Texture matrix for iAlphaImage.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetSortedTransparency(const RED::Color &iOpacityColor, const RED::Object *iOpacityTexture, RED::MESH_CHANNEL iOpacityUV, const RED::Matrix &iOpacityMatrix, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines a per pixel depth sorted transparency.

We may use an opacity color or an opacity texture in this configuration. We are not alpha masked by the texture’s alpha values.

See also \ref bk_improving_cad_graphics.

Parameters:
  • iOpacityColor – Opacity color.
  • iOpacityTexture – Opacity texture. Overrides iOpacityColor when set.
  • iOpacityUV – UV channel to use if we have a, opacity texture.
  • iOpacityMatrix – Opacity texture matrix.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed.

RED_RC SetSortedTransparency(const RED::Color &iOpacityColor, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines a per pixel depth sorted transparency.

We may use an opacity color here. This call is equivalent to setting a sorted transparency without texture using:

RED::StateShader::SetSortedTransparency( iOpacityColor,
                                         NULL,
                                         RED::MCL_TEX0,
                                         RED::Matrix::IDENTITY,
                                         iPlatformID );

Parameters:
  • iOpacityColor – Opacity color.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed.

RED_RC SetSortedAndMaskedTransparency(const RED::Object *iOpacityTexture, RED::MESH_CHANNEL iOpacityUV, const RED::Matrix &iOpacityMatrix, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines a depth sorted transparency with an alpha mask.

We use an opacity texture in this configuration. The texture’s color is used as the opacity color, and the texture’s alpha is used as alpha mask for the rendering.

Parameters:
  • iOpacityTexture – Opacity texture.
  • iOpacityUV – UV channel to use to sample the opacity texture.
  • iOpacityMatrix – Opacity texture matrix.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetAlphaThreshold(float iAlphaThreshold, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the alpha masking threshold.

This value is used to define the alpha masking ratio for alpha masked transparency.

See \ref bk_bm_custom_state_alphamask for details.

Parameters:
  • iAlphaThreshold – New value [0.0f,1.0f].
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetFaceCulling(CULLING_MODE iCullingMode, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Sets the face culling mode.

Sets the culling mode for all incoming geometries.

Parameters:
  • iCullingMode – Face culling mode.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetBlendingMode(BLENDING_MODE iBlendingMode, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the color blending mode.

Sets the blending mode for all incoming geometry. The RED::StateShader::SKIP blending mode indicates that the state shader will not interfere with the current blending parameters.

See \ref bk_bm_custom_state_transpar and \ref bk_bm_custom_state_blend for details on blending and transparency.

Parameters:
  • iBlendingMode – The blending mode to use.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetBlendingMode(BLENDING_MODE iBlendingMode, BLENDING_FUNCTION iFunction1, BLENDING_EQUATION iOperation, BLENDING_FUNCTION iFunction2, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the color blending mode.

Sets the blending mode for all incoming geometry. All parameters of the blending equation are set by this call.

See \ref bk_bm_custom_state_transpar and \ref bk_bm_custom_state_blend for details on blending and transparency.

Parameters:
  • iBlendingMode – The blending mode to use.
  • iFunction1 – Function applied to the incoming fragment color.
  • iOperation – Operation combining the two colors.
  • iFunction2 – Function applied to the buffer fragment color.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetBlendingConstant(const RED::Color &iConstant, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Sets the constant colors/alpha usable in the blending.

Sets the constant color that can be used in a blending equation, for functions using one of the following BLENDING_FUNCTIONs:

  • CONSTANT_COLOR,
  • ONE_MINUS_CONSTANT_COLOR,
  • CONSTANT_ALPHA,
  • ONE_MINUS_CONSTANT_ALPHA.

See \ref bk_bm_custom_state_transpar and \ref bk_bm_custom_state_blend for details on blending and transparency.

Parameters:
  • iConstant – Source and destination color constant.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetBlendingMode(int iNumBuffer, BLENDING_FUNCTION iFunction1, BLENDING_EQUATION iOperation, BLENDING_FUNCTION iFunction2, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the color blending mode for a single drawing buffer of a multiple render target VRL.

Requires blending to be activated using RED::StateShader::SetBlendingMode and the rendering to occur in a multiple render target VRL, created using RED::IWindow::CreateMultiRenderTargetVRL.

A first call to RED::StateShader::SetBlendingMode will turn on blending for all drawing buffers available in the VRL. Then, per buffer blending operations can be configured using this call.

See \ref bk_bm_custom_state_transpar and \ref bk_bm_custom_state_blend for details on blending and transparency.

Note that your hardware must support the ARB_draw_buffers_blend OpenGL extension, otherwise, the operation is ignored.

Parameters:
  • iNumBuffer – The number of the buffer being targeted.
  • iFunction1 – Function applied to the incoming fragment color.
  • iOperation – Operation combining the two colors.
  • iFunction2 – Function applied to the buffer fragment color.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetDoubleSided(bool iDoubleSided, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Renders the geometry once or twice.

Renders the geometry once if iDoubleSided is false, and renders the geometry twice if iDoubleSided is true. The polygon facing reference RED::RenderShaderParameter::REF_POLYGON_FACING can be used to identify which object side is currently being rendered.

Parameters:
  • iDoubleSided – Are we double sided ?
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetDepthFunction(FUNCTION iFunc, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Specifies the depth function to use.

Depth testing must be enabled for this function to be effectively set.

Parameters:
  • iFunc – The new depth test function.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetDepthTest(DEPTH_MODE iTest, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Specifies the depth testing mode.

SKIP lets the previous state shader or pass startup mode unmodified.

Note that in standard OpenGL if the depth test is disabled, then there won’t be any depth write that will occur, even if the depth mask is enabled.

Parameters:
  • iTest – The new depth test mode.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetDepthMask(DEPTH_MODE iMask, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Specifies the depth masking (write) mode.

SKIP lets the previous state shader or pass startup mode unmodified.

Parameters:
  • iMask – The new depth write mode.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetLineWidth(float iWidth, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Specifies the pixel width of rendered lines.

Define the pixel width of rendered lines. Note that enabling engine anti-aliasing reduces the size of rendered lines because of the super sampling method used. When engine AA is enabled, it may be necessary to increase the specified line width.

The rendering of thick lines is supported by the GPU rendering but is not supported by the software ray-tracer. However, 1 pixel wide lines can be rendered by the software ray-tracer.

Parameters:
  • iWidth – Pixel width of lines.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetLineStipple(bool iOnOff, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Enables or disables line stipple.

See \ref wf_hidden_lines_removal_a_real_time_example for a practical example of line stipple.

Parameters:
  • iOnOff – Enable or disable line stipple.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetLineStipplePattern(int iFactor, short iPattern, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the line stipple parameters.

See \ref wf_hidden_lines_removal_a_real_time_example for a practical example of line stipple.

Parameters:
  • iFactor – Line stipple factor. This is the scaling applied to the line stipple pattern. Input value is clamped to [1,256]. For example, using a factor of 3 repeats three times each bit equal to 1 defined in the pattern.
  • iPattern – Line stipple pattern. This is a mask of 16 bits that define the line pattern used to draw lines.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetLineSmoothing(bool iOnOff, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Enables or disables line smoothing.

Uses OpenGL line smoothing capabilities, improving the quality of thick lines being rendered with a line stipple pattern.

Parameters:
  • iOnOff – Enable or disable line smoothing.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetPointSmoothing(bool iOnOff, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Enables or disables point smoothing.

Uses OpenGL point smoothing capabilities, improving the quality of points being rendered with a point size greater than 1. If activated, points are rendered round instead of square.

Parameters:
  • iOnOff – Enable or disable point smoothing.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetPointSize(float iSize, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the point size.

Define the OpenGL point size. This is the diameter of the point size.

Parameters:
  • iSize – Diameter of rendered points.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetPolygonOffset(bool iOnOff, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Enables or disables polygon offset.

Only triangle based data may be depth offseted using the polygon offset. Other primitives may not be offseted.

The polygon offset is useful to avoid geometry stitching artifacts and is widely used to prevent edges of a mesh to be z-fighting with the geometry they represent.

Parameters:
  • iOnOff – Enable or disable polygon offset.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetPolygonOffsetValue(float iFactor, float iUnits, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the polygon offset parameters.

The polygon offset is useful to avoid geometry stitching artifacts and is widely used to prevent edges of a mesh to be z-fighting with the geometry they represent.

Usually, ‘iFactor’ starts at 1.0 and is below 10.0; ‘iUnits’ starts at 1.0 and may be up to 100.0+ depending on the viewing conditions.

Parameters:
  • iFactor – Angular factor used in the polygon offset equation.
  • iUnits – Number of biasing units in the polygon offset equation.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetColorMask(bool iWriteR, bool iWriteG, bool iWriteB, bool iWriteA, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the color write mode.

Parameters:
  • iWriteR – Authorized to write red color component?
  • iWriteG – Authorized to write green color component?
  • iWriteB – Authorized to write blue color component?
  • iWriteA – Authorized to write alpha color component?
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed.

RED_RC SetMatte(bool iMatte, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the matte mode.

When a material has the matte mode set to true, it is considered as not being lit directly. Instead, it receives shadows cast by the other objects in the scene as well as their global illumination contribution.

Matte objects are useful when rendering synthetic objects into real-world photographs for example.

Parameters:
  • iMatte – Enable (true) or disable (false) matte mode.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed.

RED_RC SetDisplacement(float iDispHeight, const RED::Object *iDispTexture, const RED::Matrix &iDispMatrix, RED::MESH_CHANNEL iDispUV, float iDispOffset, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines a displacement map for the rendering of the object.

Defines a displacement map for the object. A displacement map is used to define a surface elevation at each texel on the rendered geometry. Texel triangles are created in a transient manner during the rendering to increase the detail of rendered geometries.

The height of the displacement map is the .x coordinate read from the texture map. The displacement map must be a RED::TGT_TEX_2D texture. The RED::FMT_L8 is best to use for the texture storage.

Displacement mapping can be removed by calling SetDisplacement with NULL as displacement texture.

Displacement mapping can be enabled or disabled for the ray-tracer by setting the wished RED::OPTIONS_RAY_DISPLACEMENT value.

Displacement mapping is ignored in hardware rendering.

See \ref wf_displacement for a displacement mapping example.

Parameters:
  • iDispHeight – Maximal height of the displacement in model units. This value must be positive. To have a displacement “below” the displaced surface, please use a negative ‘iDispOffset’ value and a positive ‘iDispHeight’.
  • iDispTexture – Displacement texture. Must be a valid 2D image or NULL to disable displacement.
  • iDispMatrix – Displacement texture matrix.
  • iDispUV – UV channel to use to sample the displacement texture. Must be in the [ RED::MCL_TEX0, RED::MCL_TEX7 ] range.
  • iDispOffset – Displacement offset. This is a global translation of the displacement region. Setting a negative offset value for example equal to ‘iDispHeight’ generates a displacement surface that appears below the actual original surface level.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed.

RED_RC SetStencilTest(STENCIL_MODE iTest, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Enables or disables stencil testing.

RED::StateShader::STENCIL_OFF is the default. See \ref bk_ba_no_stencil_buffer_on_auxiliary_vrls for details on using stencil buffer on various hardware.

Parameters:
  • iTest – Specify the stencil test mode.
  • iPlatformID – Platform identifier.
Returns:

RED_OK is the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed.

RED_RC SetStencilFunction(FUNCTION iFunc, int iRef, int iMask, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines the stencil function.

Defines the standard OpenGL stencil test: ( iRef & iMask ) iFunc ( stencil_buffer & iMask ) See \ref bk_ba_no_stencil_buffer_on_auxiliary_vrls for details on using stencil buffer on various hardware.

Parameters:
  • iFunc – The new stencil test function.
  • iRef – Reference value for the stencil test.
  • iMask – Bitwise AND mask for stencil test.
  • iPlatformID – Platform identifier.
Returns:

RED_OK is the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed.

RED_RC SetStencilOperation(STENCIL_OPERATION iFailOp, STENCIL_OPERATION iZFailOp, STENCIL_OPERATION iZPassOp, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Defines all stencil operations.

See \ref bk_ba_no_stencil_buffer_on_auxiliary_vrls for details on using stencil buffer on various hardware.

Parameters:
  • iFailOp – Stencil operation that occurs when the stencil test fails.
  • iZFailOp – Stencil operation that occurs when the stencil test passes and the depth test fails.
  • iZPassOp – Stencil operation that occurs when the stencil test and the depth test passes.
  • iPlatformID – Platform identifier.
Returns:

RED_OK is the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed.

RED_RC SetStencilMask(int iMask, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Specifies the stencil writemask value.

See \ref bk_ba_no_stencil_buffer_on_auxiliary_vrls for details on using stencil buffer on various hardware.

Parameters:
  • iMask – The new stencil mask value.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetReflectiveCaustics(bool iReflectiveCaustics, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Enables/disables reflective caustics.

True to enable the generation of reflective caustics.

Parameters:
  • iReflectiveCaustics – Are reflective caustics enabled?
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC SetRefractiveCaustics(bool iRefractiveCaustics, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC)

Enables/disables refractive caustics.

True to enable the generation of refractive caustics.

Parameters:
  • iRefractiveCaustics – Are refractive caustics enabled?
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC GetPlatformsCount(int &oCount) const

Gets the number of platforms used by this shader.

This method returns the number of hardware platforms that have been configured for this shader.

Parameters:oCount – Number of hardware platforms used by the shader.
Returns:RED_OK when the method has succeeded,

RED_FAIL otherwise.
RED_RC GetPlatformList(RED::Vector<RED::HARDWARE_PLATFORM> &oPlatformList) const

Gets the list of hardware platforms used by the shader.

This method fills a RED::Vector with the list of hardware platforms that are used by the shader.

Parameters:oPlatformList – The list of hardware platforms.
Returns:RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetTransparencyMode(TRANSPARENCY_MODE &oTransparency, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the kind of transparency we manage.

Parameters:
  • oTransparency – The transparency mode for all shaders after this one in its rendering pass.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetTransparencyImage(RED::Object **oImage, RED::MESH_CHANNEL &oUVChannel, RED::Matrix &oMatrix, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Retrieves transparency texture parameters.

Parameters:
  • oImage – Address of the transparency / alpha texture if it exists.
  • oUVChannel – Mesh channel used to sample ‘oImage’.
  • oMatrix – Texture matrix for ‘oImage’.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetTransparencyColor(RED::Color &oTransparColor, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the color of the transparency.

Parameters:
  • oTransparColor – Transparency color.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetAlphaThreshold(float &oAlpha, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the alpha masking threshold.

Parameters:
  • oAlpha – The alpha threshold value for all shaders after this one.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetBlendingMode(BLENDING_MODE &oBlend, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the state shader blending mode.

Parameters:
  • oBlend – The blending mode for the shader.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetBlendingMode(BLENDING_MODE &oBlend, BLENDING_FUNCTION &oFunction1, BLENDING_EQUATION &oEquation, BLENDING_FUNCTION &oFunction2, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the detailed state shader blending mode.

Parameters:
  • oBlend – The blending mode for the shader.
  • oFunction1 – Function applied to the incoming fragment color.
  • oEquation – Operation combining the two colors.
  • oFunction2 – Function applied to the buffer fragment color.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetBlendingMode(BLENDING_FUNCTION &oFunction1, BLENDING_EQUATION &oEquation, BLENDING_FUNCTION &oFunction2, int iNumBuffer, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the detailed state shader blending mode for a specified iNumBuffer.

Parameters:
  • oFunction1 – Function applied to the incoming fragment color.
  • oEquation – Operation combining the two colors.
  • oFunction2 – Function applied to the buffer fragment color.
  • iNumBuffer – The number of the buffer being targeted in the VRL.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetFaceCulling(CULLING_MODE &oCullMode, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the face culling mode.

Parameters:
  • oCullMode – Face culling mode.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetDoubleSided(bool &oDoubleSided, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Should the rendering be double sided?

Parameters:
  • oDoubleSided – true if we are double sided.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetDepthFunction(FUNCTION &oFunc, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the depth function.

Parameters:
  • oFunc – The depth function for the shader.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetDepthTest(DEPTH_MODE &oDepth, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the depth testing mode.

Parameters:
  • oDepth – The depth testing mode for the shader.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetDepthMask(DEPTH_MODE &oMask, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the depth masking mode.

Parameters:
  • oMask – The depth masking mode for the shader.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetLineWidth(float &oWidth, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the pixel width of rendered lines.

Parameters:
  • oWidth – Pixel width of lines.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetLineStipple(bool &oOnOff, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets line stipple activation status.

Parameters:
  • oOnOff – Is line stipple enabled ?
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetLineStipplePattern(int &oFactor, short &oPattern, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the line stipple parameters.

Parameters:
  • oFactor – Line stipple factor. This is the scaling applied to the line stipple pattern.
  • oPattern – Line stipple pattern. This is a mask of 16 bits that define the line pattern used to draw lines.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetLineSmoothing(bool &oOnOff, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the line smoothing activation status.

Parameters:
  • oOnOff – Is line smoothing enabled ?
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetPointSmoothing(bool &oOnOff, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the point smoothing activation status.

Parameters:
  • oOnOff – Is point smoothing enabled ?
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetPointSize(float &oPointSize, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the point size.

Parameters:
  • oPointSize – Return the point size diameter.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetPolygonOffset(bool &oOnOff, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the polygon offset activation status.

Parameters:
  • oOnOff – Is polygon offset enabled ?
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetPolygonOffsetValue(float &oFactor, float &oUnits, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the polygon offset parameters.

Parameters:
  • oFactor – Angular factor used in the polygon offset equation.
  • oUnits – Number of biasing units in the polygon offset equation.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetColorMask(bool &oWriteR, bool &oWriteG, bool &oWriteB, bool &oWriteA, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the color masking mode.

Parameters:
  • oWriteR – Authorized to write red color component?
  • oWriteG – Authorized to write green color component?
  • oWriteB – Authorized to write blue color component?
  • oWriteA – Authorized to write alpha color component?
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetMatte(bool &oMatte, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Gets the matte mode (see SetMatte for details).

Parameters:
  • oMatte – matte mode enabled?
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetDisplacement(float &oDispHeight, RED::Object *&oDispTexture, RED::Matrix &oDispMatrix, RED::MESH_CHANNEL &oDispUV, float &oDispOffset, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Retrieves the displacement mapping parameters.

Parameters:
  • oDispHeight – Maximal displacement height in model units.
  • oDispMatrix – Displacement texture matrix.
  • oDispTexture – Displacement texture.
  • oDispUV – Displacement UV channel.
  • oDispOffset – Displacement offset translation.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetStencilTest(STENCIL_MODE &oStencil, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the stencil testing mode.

Parameters:
  • oStencil – The stencil testing mode for the shader.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetStencilFunction(FUNCTION &oFunc, int &oRef, int &oMask, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the stencil function.

Parameters:
  • oFunc – The stencil function set in this shader.
  • oRef – Reference value for the stencil test.
  • oMask – Bitwise AND mask for stencil test.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetStencilOperation(STENCIL_OPERATION &oFailOp, STENCIL_OPERATION &oZFailOp, STENCIL_OPERATION &oZPassOp, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the stencil operations.

Parameters:
  • oFailOp – Stencil operation that occurs when the stencil test fails.
  • oZFailOp – Stencil operation that occurs when the stencil test passes and the depth test fails.
  • oZPassOp – Stencil operation that occurs when the stencil test and the depth test passes.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetStencilMask(int &oMask, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the stencil writemask.

Parameters:
  • oMask – The stencil writemask.
  • iPlatformID – Platform identifier.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.
RED_RC GetReflectiveCaustics(bool &oReflectiveCaustics, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the reflective caustics enabled status.

Parameters:
  • oReflectiveCaustics – Reflective caustics enabled status.
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

RED_RC GetRefractiveCaustics(bool &oRefractiveCaustics, RED::HARDWARE_PLATFORM iPlatformID = RED::HW_GENERIC) const

Returns the refractive enabled caustics status.

Parameters:
  • oRefractiveCaustics – Are refractive caustics enabled?
  • iPlatformID – Platform identifier.
Returns:

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation did fail.

virtual RED_RC UpdateFrom(const RED::Object &iShader, const RED::State &iState, int iSrcStateNumber)

Internal update event method.

Parameters:
  • iShader – Source shader.
  • iState – Current transaction parameter.
  • iSrcStateNumber – Source state number.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL otherwise.
virtual RED_RC GetOperationStream(const RED::Object *iCaller, RED::Vector<int> &ioStream, RED::HARDWARE_PLATFORM iPlatformID) const

Internal access to the operation stream of a shader.

Internal RED usage method. Writes down the shader stream.

Parameters:
  • iCaller – Pointer to the method caller.
  • ioStream – Stream to write to.
  • iPlatformID – Target hardware platform identifier.
Returns:

RED_OK when the shader could have its operation stream written down,

RED_ALLOC_FAILURE if an internal allocation did fail,

RED_FAIL otherwise.

RED_RC Solve(RED::IReferenceManager *iReferenceManager, const RED::State &iState)

Shader texture reference solving.

Parameters:
  • iReferenceManager – Reference repository.
  • iState – Current transaction parameter.
virtual RED_RC Save(RED::IStream *iStream, StreamingPolicy &iPolicy, int iState = -1) const

Internal class streaming.

Parameters:
  • iStream – The target stream.
  • iPolicy – The streaming policy.
  • iState – The written transaction number.
Returns:

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL otherwise.