class RED::RenderShaderParameter

Parameter targeting the vertex program.

Parameter targeting the pixel program.

Parameter targeting the geometry program.

(x,y,z,w) Program parameter value extracted from a RED::Vector4.

(x,y,z,1.0) ARB or (x,y,z) GLSL. Defined by a SetValue call with a RED::Vector3 parameter. The value of the vector3 is stored in a RED::Vector4 and returned as a (x,y,z,1.0f) RED::Vector4 upon access.

(r,g,b,a). Defined by a SetValue call with a RED::Color parameter. Returned as a RED::Color upon access.

(f,f,f,f) ARB or (f) GLSL. Defined by a SetValue call with a simple float parameter. The value of the float is stored in a RED::Vector4 and returned replicated 4 times for every component of the vector as a RED::Vector4 upon access.

(b,b,b,b) ARB of (b) GLSL. Defined by a SetValue call with a simple bool parameter. The value of the bool is stored as 0.0f (false) or 1.0f (true) and returned as a RED::Vector4 replicated 4 times for every component of the vector.

(texture) Program bound texture.

(matrix) Program parameter value extracted from a RED::Matrix, using the line major convention for ARB shaders and using the row major convention for GLSL shaders.

(x,y,z,w) ARB or (vec4) GLSL. Position of the camera in world space coordinates. The floating origin of the camera is applied to the value sent to the shader.

(x,y,z,w) ARB or (vec4) GLSL. Ambient light color.

(x,y,z,w) ARB or (vec4) GLSL. Position of the current light source in view space coordinates.

(x,y,z,w) ARB or (vec4) GLSL. Position of the current light source in world space coordinates.

(x,y,z,w) ARB or (vec4) GLSL. Current light source diffuse color.

(x,y,z,w) ARB or (vec4) GLSL. Current light source specular color.

(x,y,z,w) ARB or (vec4) GLSL. Current light source effect distance.
x = Light intensity texture ramp pixel size / Light effect distance.
y = 0.0f.
z = Light intensity texture ramp pixel size.
w = Light effect distance.

(x,y,z,w) ARB or (vec4) GLSL. Sight vector of the current light source in view space coordinates.

(x,y,z,w) ARB or (vec4) GLSL. Sight vector of the current light source in world space coordinates.

(x,y,z,w) ARB or (vec4) GLSL. Top vector of the current light source in view space coordinates.

(x,y,z,w) ARB or (vec4) GLSL. Top vector of the current light source in world space coordinates.

(x,y,z,w) ARB or (vec4) GLSL. Right vector of the current light source in view space coordinates.

(x,y,z,w) ARB or (vec4) GLSL. Right vector of the current light source in world space coordinates.

(x,y,z,w) ARB or (vec4) GLSL. Either (1,1,1,1) or (-1,-1,-1,-1). Whenever a material is declared as surfacic by a RED::StateShader, the polygon facing reference's value is +1 for the rendering of the first side of an object's polygons, and -1 for the rendering of the second side of an object's polygons.

(image) Screen space texture sized to the rendered VRL dimensions. This image contains the per pixel shadow intensity to apply for the current rendering pass with the current light.

(image) Intensity ramp for the current light. The size of the ramp is specified on the RED::ILightShape interface, and accessed using the RenderShaderParameter::REF_LIGHT_RANGE reference.

(cube image) Cube image containing the directional spot intensity falloff.

(image) Texture containing the radial intensity falloff for a beam light.

(matrix) Projection matrix to wrap onto the radial texture of a beam light, provided (uv) coordinates in the (right,top) referential of the light source.

(image) Screen space ray starting positions in indirect lighting. This image does not exist for rays fired from the camera. Ray positions are expressed in world space coordinates.

(image) Screen space ray ending positions in indirect lighting. This image does not exist for ray fired from the camera. Ray positions are expressed in world space coordinates.

(image) Screen space image containing reflected rays ending positions after a ray bounce. Ray positions are expressed in world space coordinates.

(image) Screen space image containing refracted rays ending positions after a ray bounce. Ray positions are expressed in world space coordinates.

(image) Screen space incident ray directions in indirect lighting. This image does not exist for rays fired from the camera. An incident ray will split in reflected and refracted rays whose directions will be REF_RAY_REFLECTED_DIR_IMAGE and REF_RAY_REFRACTED_DIR_IMAGE. Ray directions are expressed in world space coordinates.

(image) Screen space reflected ray directions in indirect lighting after a ray bounce at our current ray ending position. The texture contains:

• image.xyz = reflection direction in WCS.
• image.w = refraction index of the material we're currently in.
  

(image) Screen space refracted ray directions in indirect lighting after a ray bounce at our current ray ending position. The texture contains:

• image.xyz = refraction direction in WCS.
• image.w = refraction index of the material we'll step in after crossing our hit interface.

(image) Screen space triangle identifiers image used for the shader pixel ownership test, that identify who has been really hit for each pixel. This image does not exist for rays fired from the camera.

(image) Screen space triangle identifiers image identifying hit triangles after a reflection bounce at our current ray ending position.

(image) Screen space triangle identifiers image identifying hit triangles after a refraction bounce at our current ray ending position.

(image) Screen space image that contains the reflection color that should be applied to reflective objects to complete their lighting.

(x,y,z,w) ARB or (vec4) GLSL. Value of the VRL clear color.

(x,y,z,w) ARB or (vec4) GLSL. Value of the VRL clear depth. x = 0.0;
y = 0.0;
z = clear depth.
w = 1.0;

(imageCUBE) Cube image that may has been specified in the RED::IViewpointRenderList::SetBackgroundImages call.

(matrix) Additional transformation matrix that has been specified in the RED::IViewpointRenderList::SetBackgroundImages call.

(image) Screen space image of the back buffer color. This image is generated before the startup of each rendering pass (RED::MTL_LIT or RED::MTL_POSTLIT) that is requesting it. The contents of the image is the color of all previous rendering passes before the one asking for it.

(image) Screen space image of the back buffer depth. This image is generated before the startup of each rendering pass (RED::MTL_LIT or RED::MTL_POSTLIT) that is requesting it. The contents of the image is the depth of all previous rendering passes before the one asking for it.

(x,y,z,w) ARB or (vec4) GLSL. Dimensions of the current VRL we are rendering into. Note that these values are modified by the engine anti-aliasing setting value used by the current VRL. The real VRL size is its pixel size times its engine anti-aliasing setup.
x = 1.0f / VRL pixel width.
y = 1.0f / VRL pixel height.
z = VRL pixel width.
w = VRL pixel height.

(x,y,z,w) ARB or (vec4) GLSL. Origin of the lower left pixel of the VRL we are rendering into. The engine may use many internal tiles to render a single VRL in separate pieces. This reference is to be added to the fragment.position value when the absolute coordinate of a pixel is to be retrieved.
x = VRL x origin.
y = VRL y origin.
z = 0.0f.
w = 0.0f.

(x,y,z,w) ARB or (vec4) GLSL. Engine anti-aliasing setup for the rendered VRL. This reference value may be used to scale pixel coordinates for screen space related texture sampling.
x = 1.0f / VRL engine anti alias.
y = 1.0f / VRL engine anti alias.
z = VRL engine anti alias.
w = VRL engine anti alias.

(x,y,z,w) ARB or (vec4) GLSL. Ray tracer reference used to simulate polygon back face culling within the ray-traced shaders. This reference is part of the ray-tracer binding package needed to process indirect lighting workflows.

(x,y,z,w) ARB or (vec4) GLSL. Current viewpoint sight vector in world space coordinates. The floating origin of the camera is applied to the value sent to the shader.

(x,y,z,w) ARB or (vec4) GLSL. Current viewpoint top vector in world space coordinates. The floating origin of the camera is applied to the value sent to the shader.

(x,y,z,w) ARB or (vec4) GLSL. Current viewpoint right vector in world space coordinates. The floating origin of the camera is applied to the value sent to the shader.

(image) Direct access to the shadow map image of a given light. This reference is only valid for beam and spot lights. The texture has a depth texture setup on NVIDIA GPUs and has no depth texture setup on ATI GPUs.

(matrix) World space to device space frustum matrix for the view of the light source for a shadow image. This matrix is for usage with REF_SHADOW_MAP_TEX.

(image) This reference associates a user defined image value to each object instance being rendered with a shader that is using the reference. The mapping table between an instance and the reference value is made by RED::IViewpoint::SetInstanceCounterImageCallback.

(image) Screen space ray hit points ending normals in indirect lighting. This image does not exist for ray fired from the camera. Ray hit points normals are expressed in world space coordinates.

(x,y,z,w) Value of the RED::OPTIONS_RAY_WORLD_CACHE_SAMPLE_SPREAD. x = (float)value.
y = 1.0f / (float)value.
z = 0.0f.
w = 1.0f.

(image) This reference is used to bind area sample information for a pixel shader. Refer to the product documentation for details and example usage of this reference.

(image 2D) This reference contains pre-rendered textures for all font characters (glyphs) that are used for a given font that is rendered using textured quads (RED::FNT_TEXTURE fonts).
This shader reference is not accessible in GLSL. It's usually accessed through the RED::RenderShaderText display shader.

(x,y,z,w) ARB only. This reference contains the size of the font glyph texture.
z = glyph texture pixel width. w = glyph texture pixel height. x = 1.0f / z. y = 1.0f / w.

(image) This reference contains the per pixel ray attenuation at the currently processed ray tree level. It can only be accessed by a shader in the RED::MTL_RAYTRACE pass that targets one of the possible indirect cutoffs targets:

• RED_SHAD_TARGET_INDIRECT_REFLECTION_CUTOFF,
• RED_SHAD_TARGET_INDIRECT_REFRACTION_CUTOFF.
  The next level cutoff should multiply the current level ray attenuation by the cumulated attenuation value stored in this texture.

(RED::Vector4) Ray tracer parameter value. Defines the spread angle used for the calculations of glossy ray-traced reflections or refractions, depending on the shader target used to register the parameter.
We use the '.x' value of the provided vector that specify the glossiness angle in radians between 0.0f and RED_PI / 2.0f.

(RED::Vector4) Ray tracer parameter value. Defines the number of rays that'll be fired in the cone of glossy reflections or refraction for the shader that is using this parameter. Reflections or refractions are selected based on the shader target used to register the parameter.
We use the '.x' value of the provided vector to define that number of rays being fired. If the value is 0.0f or below, then the ray-tracer automatically selects the number of samples to shoot, based on the RAY_GLOSSY_ANGLE specified by the shader.

(image) This reference converts a screen coordinates defined by 'fragment.position' into a random number in the [0,2048] range. This reference is only accessible if glossy effects are enabled.

(image) This reference offsets a ray direction in the glossiness calculation basis. Too long to explain here in detail. Contact us if you need to compute glossiness by yourself. Otherwise, this reference is used by the ray-tracer shaders for all glossiness effects calculations.

(RED::Vector4) Number of the glossy sample being currently rendered. .x = number of the sample. .y = number of the sample / 255.0f. .z = 0.0f. .w = 0.0f.

(image cube) This reference launches the automatic calculation of a cube image that can be then accessed in shader programs. The cube image is calculated for each scene in which the material using this reference is used. The center of the cube image is set to the barycentric coordinates of all points of all objects using the material that is using this reference.
All objects using the reference through their material are discarded for the cube image rendering. Please note that using this reference has a clear impact on rendering performances.

(RED::Vector4) This reference is associated to REF_AUTO_CUBE_MAP. It stores the coordinates of the point that has been used to compute the REF_AUTO_CUBE_MAP image. It's used for example to correct parallax errors for real-time approximated effects. The floating origin of the viewpoint is applied in the resulting matrix.

(RED::Vector4) Ray tracer parameter value. This value is similar to the RED::RenderShaderParameter::RAY_GLOSSY_ANGLE except that it defines a second angular value that can be used to define an anisotropic basis for the calculation of glossiness spreading. We use the '.x' value of the provided vector that specify this glossiness angle in radians between 0.0f and RED_PI / 2.0f.

(image RECT) Floating point texture of 2048 x 1 texels. Texel[0] is expf(0.0f); Texel[2047] is expf(-20.0f). This exponent ramp is used as a mathematical built-in exponent table for all shaders that need it.

(RED::Vector4) This reference associates a user defined RED::Vector4 value to each object instance being rendered with a shader that is using the reference. The mapping table between an instance and the reference value is made by RED::IViewpoint::SetInstanceCounterCallback.

(image RECT) Screen space image containing the irradiance cache color that can be used to display a pre-processed global illumination contribution to the scene. See RED::IWindow::FrameDrawingGICache. The RED::RenderShaderAmbient uses this reference for automatic GI replay.

(x,y,z,w) ARB or (vec4) GLSL. Dimensions of the current viewport we are rendering into. These are the dimensions of the viewpoint being rendered as it was anchored inside the VRL hosting it. Note that these values are modified by the engine anti- aliasing setting value used by the current VRL. The real viewport size is its pixel size times the engine anti-aliasing setup for the VRL that contains it.
x = 1.0f / Viewport pixel width.
y = 1.0f / Viewport pixel height.
z = Viewport pixel width.
w = Viewport pixel height.

(x,y,z,w) ARB or (vec4) GLSL. Origin of the lower left pixel of the viewport we are rendering into. This is the position of the lower left pixel of the viewpoint being rendered as it was anchored inside the VRL hosting it. Note that the engine may use many internal tiles to render a single VRL in separate pieces. The viewport origin is calculated relatively to the current origin of the VRL tile as expressed by the RED::RenderShaderParameter::REF_VRL_ORIGIN reference. This reference value is to be subtracted from the fragment.position value when the coordinate of a pixel in the viewport are to be retrieved: viewport_coordinates = fragment.position - viewport_origin.
x = Viewport x origin.
y = Viewport y origin.
z = 0.0f.
w = 0.0f.

(image RECT) This reference points to the sky texture image that was supplied to the RED::ISkyLightShape::SetSkyTexture method during the construction of a skylight.

(image CUBE) This reference is a small cube image being generated from the sky texture of the skylight. This is a downsampled and blurred version of the original sky texture, turned into a cube texture. This is used as a noise reduction technique for the calculation of the diffuse shading of the skylight. This reference is only available on the GPU.

(imageCUBE) 2D image that may has been specified in the RED::IViewpointRenderList::SetBackgroundImages call.

(matrix) Additional transformation matrix that has been specified in the RED::IViewpointRenderList::SetBackgroundImages call.

(RED::Vector4) This reference stores an integer value in the first coordinate of the vector. The value can be set using RED::RenderShaderParameter::SetCameraParameterValue and retrieved using RED::RenderShaderParameter::GetCameraParameterValue. A camera parameter stores a reference to a parameter registered in a RED::IViewpoint, using RED::IViewpoint::AddRenderShaderParameter.

(matrix) This reference returns the matrix that can be accessed otherwise using RED::IViewpointRenderList::GetFloatingViewProjectionViewportMatrix, for the current camera in the current VRL. The floating origin of the viewpoint is applied in the resulting matrix.

(matrix) This reference returns the current matrix corresponding to the matrix set for the currently rendered object. The reference is valid only if the RED::RenderCode of the corresponding shader has enabled the model matrix. This reference is not available in software rendering.

(matrix) This reference returns the current modelview matrix corresponding to the matrix set for the currently rendered object ( inverse viewing matrix x model matrix ). The reference is valid only if the RED::RenderCode of the corresponding shader has enabled the modelview matrix. The floating origin of the viewpoint is applied in the resulting matrix. This reference is not available in software rendering.

(matrix) This reference returns the current modelview projection matrix corresponding to the matrix set for the currently rendered object ( projection x inverse viewing matrix x model matrix ). The reference is valid only if the RED::RenderCode of the corresponding shader has enabled the modelview projection matrix. The floating origin of the viewpoint is applied in the resulting matrix. This reference is not available in software rendering.

(matrix) This reference returns the current view matrix corresponding to the camera being currently rendered. The floating origin of the viewpoint is applied in the resulting matrix. That reference is not available in software rendering for which the RED::ISoftRenderingContext::GetViewingMatrix can be directly used instead to retrieve the matrix.

(matrix) This reference returns the matrix that can be accessed otherwise using RED::IViewpointRenderList::GetFloatingViewProjectionMatrix, for the current camera in the current VRL. The floating origin of the viewpoint is applied in the resulting matrix. That reference is not available in software rendering for which the RED::ISoftRenderingContext::GetViewProjectionMatrix can be directly used instead to retrieve the matrix.

(matrix) This reference returns the matrix that can be accessed otherwise using RED::IViewpointRenderList::GetViewportMatrix, for the current camera in the current VRL. That reference is not available in software rendering for which the RED::ISoftRenderingContext::GetViewportMatrix can be directly used instead to retrieve the matrix.

(matrix) Inverse of RED::RenderShaderParameter::REF_VRL_VIEW_PROJECTION_VIEWPORT_MATRIX.

(matrix) Inverse of RED::RenderShaderParameter::REF_VRL_MODEL_MATRIX.

(matrix) Inverse of RED::RenderShaderParameter::REF_VRL_MODELVIEW_MATRIX.

(matrix) Inverse of RED::RenderShaderParameter::REF_VRL_MODELVIEW_PROJECTION_MATRIX.

(matrix) Inverse of RED::RenderShaderParameter::REF_VRL_VIEW_MATRIX.

(matrix) Inverse of RED::RenderShaderParameter::REF_VRL_VIEW_PROJECTION_MATRIX.

(matrix) Inverse of RED::RenderShaderParameter::REF_VRL_VIEWPORT_MATRIX.

(matrix) This reference returns the matrix that can be accessed otherwise using RED::IViewpoint::GetProjectionMatrix, for the current camera in the current VRL. That reference is not available in software rendering for which the value can be accessed from the camera retrieved from RED::ISoftRayContext::GetCamera.

(matrix) Inverse of RED::RenderShaderParameter::REF_VRL_PROJECTION_MATRIX.

(x,y,z,w) ARB or (vec4) GLSL. Contains the 2D intensity scale value supplied to RED::IViewpointRenderList::SetBackgroundImages.

(x,y,z,w) ARB or (vec4) GLSL. Contains the Cube image intensity scale value supplied to RED::IViewpointRenderList::SetBackgroundImages.