class RED::ShaderString

ShaderString construction method.

ShaderString destruction method.

Reimplements: RED::String::GetClassID.

Renames a parameter.

  ALIAS iAlias = iParam;

Parameters:

Starts an Apple Metal pixel shader string.

Clears the string contents and adds the pixel shader header.

See RED::ShaderString::AppleMetalVertexShaderAddHeader for details.

Starts an Apple Metal vertex shader string.

Clears the string contents and adds the vertex shader header.

The following Metal Shading Languages definitions are added. They provide access to the data provided by REDsdk in the shader code.

 !!REDShaderAppleMetal
 
 // This structure provides access to the REDsdk transform matrices
 struct REDStateMatrixData {
     metal::float4x4 modelview;
     metal::float4x4 projection;
     metal::float4x4 mvp;
     metal::float4x4 program[4];
     
     metal::float4x4 modelview_inv;
     metal::float4x4 projection_inv;
     metal::float4x4 mvp_inv;
     metal::float4x4 program_inv[4];
     
     metal::float4x4 modelview_trans;
     metal::float4x4 projection_trans;
     metal::float4x4 mvp_trans;
     metal::float4x4 program_trans[4];
     
     metal::float4x4 modelview_invtrans;
     metal::float4x4 projection_invtrans;
     metal::float4x4 mvp_invtrans;
     metal::float4x4 program_invtrans[4];
 }
 REDStateMatrixData;
 
 // This structure provides access to the REDsdk shader parameters
 #define REDMETAL_MAX_PROGRAM_ENV_PARAMETERS ...
 struct REDProgramLocalsData
    float4 value[REDMETAL_MAX_PROGRAM_ENV_PARAMETERS];
 };
 
 // This structure provides access to the REDsdk inputs
 #define REDMETAL_STATEMATRIXDATA_IDX ...
 #define REDMETAL_PROGRAMLOCALDATA_IDX ...
 struct REDContext {
    constant REDStateMatrixData &state_matrix [[buffer(REDMETAL_STATEMATRIXDATA_IDX)]];
    constant REDProgramLocalsData &program_local [[buffer(REDMETAL_PROGRAMLOCALDATA_IDX)]];
 };
 
 // These values provides access to the REDsdk vertex buffer locations (vertex shader only)
 enum RED_VSH_INPUT { RED_VSH_VERTEX  = 0,
                      RED_VSH_USER0   = 1,
                      RED_VSH_NORMAL  = 2,
                      RED_VSH_COLOR   = 3,
                      RED_VSH_USER1   = 4,
                      RED_VSH_USER2   = 5,
                      RED_VSH_USER3   = 6,
                      RED_VSH_USER4   = 7,
                      RED_VSH_TEX0    = 8,
                      RED_VSH_TEX1    = 9,
                      RED_VSH_TEX2    = 10,
                      RED_VSH_TEX3    = 11,
                      RED_VSH_TEX4    = 12,
                      RED_VSH_TEX5    = 13,
                      RED_VSH_TEX6    = 14,
                      RED_VSH_TEX7    = 15 };
 
 // These function_constants are true is vertex buffer data is available (vertex shader only)
 constant bool RED_VSH_VERTEX_enabled [[function_constant(...)]];
 constant bool RED_VSH_USER0_enabled  [[function_constant(...)]];
 constant bool RED_VSH_NORMAL_enabled [[function_constant(...)]];
 ...
 constant bool RED_VSH_TEX7_enabled [[function_constant(...)]];
 
 // These macros allow to access REDsdk texture samplers
 #define RED_DECLARE_SAMPLERS ...
 #define RED_DEFINE_SAMPLERS ...
 #define RED_GET_SAMPLER(texunit) ...
 
 // This value is the 'main' shader entry point name
 #define REDMETAL_MAIN_FUNC ...

Some special comments must be used in shader source code. They allow REDsdk to know which resources are used by the shader.

 RED_USE_VERTEX_ATTRIB(<RED_VSH_INPUT_value>)
 RED_USE_TEXTURE(<textureUnit>,<RED_TEX_(1D|2D|3D|CUBE|RECT)>)

A vertex shader can be written as follows.

 struct Attributes {
    // RED_USE_VERTEX_ATTRIB(RED_VSH_VERTEX)
    float4 vertexpos [[attribute(RED_VSH_VERTEX), function_constant(RED_VSH_VERTEX_enabled)]];
    // RED_USE_VERTEX_ATTRIB(RED_VSH_NORMAL)
    float3 normal    [[attribute(RED_VSH_NORMAL), function_constant(RED_VSH_NORMAL_enabled)]];
 };
 struct Varyings {
    float4 pos [[position]];
    float3 normal;
 };
 
 vertex Varyings REDMETAL_MAIN_FUNC(
    Attributes in [[stage_in]],
    REDContext red
 ) {
     float4 in_pos = RED_VSH_VERTEX_enabled ? in.pos : 0.0;
     Varyings result;
     result.pos = red.state_matrix.mvp * in_pos;
     result.normal = RED_VSH_NORMAL_enabled ? in.normal : 0.0;
     return result;
 }

A fragment shader can be written as follows.

 fragment FragmentOutput REDMETAL_MAIN_FUNC(
    Varyings in [[stage_in]],
    // RED_USE_TEXTURE(0,RED_TEX_2D)
    metal::texture2d<float> someTexture [[texture(0)]],
    REDContext red, RED_DECLARE_SAMPLERS)
 {
     RED_DEFINE_SAMPLERS;
     const metal::sampler someTexture_sampler = RED_GET_SAMPLER(0);
     ...
     color = someTexture.sample(someTexture_sampler, uv);
     ...
 }

As Apple Metal does support Geometry Shaders, two special comments allow to change the way geometry is drawn.

 RED_EXPAND_INDICES_TO_TRIANGLES(<vertexCountPerIndex>)
 RED_EXPAND_INDICES_TO_TRIANGLESTRIPS(<vertexCountPerIndex>)

When these features are used, it is up to the shader code to *pull* the vertex data from the buffers, based on the current vertex_id / instance_id values.

The following example uses RED_EXPAND_INDICES_TO_TRIANGLESTRIPS to expand points geometry to hexagons. In this case, hardware instancing is used to draw multiple strips. instance_id gives the original point index value, vertex_id is the vertex index in the current strip.

 // RED_EXPAND_INDICES_TO_TRIANGLESTRIPS(6) // 6-vertex strip for each input index
 // RED_USE_VERTEX_ATTRIB(RED_VSH_VERTEX)
 vertex Varyings REDMETAL_MAIN_FUNC(
    REDContext red,
    // There is implicit no conversion when using a 'device pointer'
    //   the type must match the input buffer layout (N.B. 'packed_')
    const device packed_float3* vertexpos_buf [[buffer(RED_VSH_VERTEX)]],
    uint v_id [[vertex_id]],
    uint v_instance [[instance_id]]
 ) {
    Varyings result;
    // Emitting a screen space hexagon, adjust the current vertex position based on the vertex_id
    //
    //     3 -- 1     To be emitted as a strip: 0, 1, 2, 3, 4, 5
    //    /      \
    //   5        0
    //    \      /
    //     4 -- 2
    uint in_point_id = v_instance;
    uint hex_vtx_id  = v_id;
    const float2 OFFSETS[6] = ...
    float4 a_vertexpos = RED_VSH_VERTEX_enabled ? float4(vertexpos_buf[in_point_id], 1.0) : float4(0.0);
    ...
    a_vertexpos += r * OFFSETS[hex_vtx_id].x * right;
    a_vertexpos += r * OFFSETS[hex_vtx_id].y * top;
    ...
 }

When using RED_EXPAND_INDICES_TO_TRIANGLES, only vertex_id value is used and have to be decoded to reconstruct resulting individual triangles geometry.

Computes the light direction for an area light.

This is the fragment position to central light position vector.

Uses parameters:

• RED_SHADER_LIGHT_POS bound to RED_PSH_BINDPOS_LIGHT_POS.

Parameters:

Computes the diffuse and attenuation terms for an area light.

This method computes a diffuse and attenuation terms for an area light. Both terms are combined by the calculation method and are returned in the oDotNL value.

Declared temporaries:

• av0, av1, av2, av3, acorner, adecay,
• an0, an1, an2, an3, aldir, adot,
• xi, xn, acs, xpos, xneg, acsneg,
• aintensity.

Parameters:

Converts the object to an instance of the given type.

Parameters:

Returns:

Reimplements: RED::String::As.

Template version of the as const method.

Simply set T to be the class you want to retrieve an interface to.

Returns:

Reimplements: RED::String::As.

Converts the object to an instance of the given type.

Parameters:

Returns:

Reimplements: RED::String::As.

Template version of the as method.

Simply set T to be the class you want to retrieve an interface to.

Returns:

Reimplements: RED::String::As.

Renames a program parameter.

  ATTRIB iAttrib = iParam;

Parameters:

Computes the attenuation for a beam light with a radial texture lookup.

Calculates the attenuation for a beam light intensity falloff.

Uses:

• R0,
• RED_SHADER_LIGHT_RANGE,
• RED_SHADER_LIGHT_RANGE_BINDPOS,
• RED_SHADER_LIGHT_SIGHT,
• RED_SHADER_LIGHT_SIGHT_BINDPOS,

  LightAttenuation(oRAtt,iLightVector,iTEXatt);
  
  PARAM RED_SHADER_LIGHT_SIGHT = program.local[RED_SHADER_LIGHT_SIGHT_BINDPOS];
  
  DP3 R0.x, RED_SHADER_LIGHT_SIGHT, iLightVector;
  SGE R0.x, R0.x, {0}.x;   // Clamps all fragments behind our lighting area.
  MUL oRAtt.x, oRAtt.x, R0.x;
  TEX R0.x, iProjectorUV, iTEXr, 2D;
  MUL oRAtt.x, oRAtt.x, R0.x;

Parameters:

Declaration of three parameters for an indirect mesh channel.

  PARAM iName0 = program.local[iLocal];
  TEMP iName1;
  TEMP iName2;
  ADD iName1, program.local[iLocal + 1], -iName0;
  ADD iName2, program.local[iLocal + 2], -iName0;

Parameters:

Declares and transforms an input UV send as local.

Calculates oUV, given three consecutive program.local[iLocalBind] and a possible matrix bind slot.

Uses:

• R0, R1, R2.

  MOV R0, program.local[iLocalBind];
  ADD R1, program.local[iLocalBind + 1], -R0;
  ADD R2, program.local[iLocalBind + 2], -R0;
  if( matx_bind == -1 )
  {
    Interpolate( oUV, iTUV, "R0", "R1", "R2" );
  }
  else
  {
    Interpolate( oUV, iTUV, "R0", "R1", "R2" );
    UVTransform( oUV, oUV, matx_bind );
  }

Parameters:

ConvertUVInCubeFaceVector.

Converts the contents in iRUV (normalized in [0,1]x[0,1]) in a vector to perform a lookup in a CUBE texture for the iNumFace cube image face.

This method can be used to extract texels in a cube face.

  switch(iNumFace)
  {
    case 0:
    {
      // oR = [1,(1-2*V),(1-2*U)]
      MUL oR, iRUV.wyxw, {0,-2,-2,0};
      ADD oR, oR, {1,1,1,0};
      break;
    }
    case 1:
    {
      // oR = [-1,(1-2*V),(-1+2*U)]
      MUL oR, iRUV.wyxw, {0,-2,2,0};
      ADD oR, oR, {-1,1,-1,0};
      break;
    }
    case 2:
    {
      // oR = [(-1+2*U),1,(-1+2*V)]
      MUL oR, iRUV.xwyw, {2,0,2,0};
      ADD oR, oR, {-1,1,-1,0};
      break;
    }
    case 3:
    {
      // oR = [(-1+2*U),-1,(1-2*V)]
      MUL oR, iRUV.xwyw, {2,0,-2,0};
      ADD oR, oR, {-1,-1,1,0};
      break;
    }
    case 4:
    {
      // oR = [(-1+2*U),(1-2*V),1]
      MUL oR, iRUV.xyww, {2,-2,0,0};
      ADD oR, oR, {-1,1,1,0};
      break;
    }
    case 5:
    {
      // oR = [(1-2*U),(1-2*V),-1]
      MUL oR, iRUV.xyww, {-2,-2,0,0};
      ADD oR, oR, {1,1,-1,0};
      break;
    }
  }

Parameters:

Cross product of two operand vectors.

  MUL oRD.xyz, iR1.zxyz, iR2.yzxy;
  MAD oRD.xyz, iR1.yzxy, iR2.zxyz, -oRD.xyzx;

Parameters:

Computes the attenuation for a directional light.

Calculates the attenuation for a directional light intensity falloff. Note that the same routine is used for indirect rendering workflows.

Uses:

• RED_SHADER_LIGHT_SIGHT,
• RED_SHADER_LIGHT_SIGHT_BINDPOS.

  TEX oRAtt, {1,0,0,0}, iTEXatt, RECT;
  PARAM RED_SHADER_LIGHT_SIGHT = program.local[RED_SHADER_LIGHT_SIGHT_BINDPOS];
  MOV oLightVector, -RED_SHADER_LIGHT_SIGHT;

Parameters:

Starts a custom geometry vertex shader.

  !!REDShaderGeometry:iLibrary:iLabel:iVersion

Clears the string and adds the shader startup label for a custom geometry vertex shader rendered in software. The iLabel method must point to a function whose prototype is defined according to the geometry shader vertex shading prototype.

This kind of shader is needed for the rendering of double precision geometries on legacy RED::HARDWARE_PLATFORM graphic cards that have no native double precision support. It can also be used for displacement mapping purposes or dynamic geometry handling.

Parameters:

Returns:

Gets the point hit on the triangle.

Parameters:

Normalizes UVs resulting of a RayVsTriangle call.

UVs resulting of a RayVsTriangle need to be divided by 'det'.

Parameters:

Computes the deviation of a ray for ray-traced glossiness.

This routines modifies the specified vector ioR according to the values provided by the engine for the glossiness references.

Uses:

• R0,R1,R2 (temporaries)

Parameters:

Computes the indirect attenuation for a beam light.

Calculates the attenuation for a beam light, for an indirect lighting workflow.

Uses:

• R0 (temporary),
• RED_SHADER_LIGHT_RANGE,
• RED_SHADER_LIGHT_RANGE_BINDPOS,
• RED_SHADER_LIGHT_POS,
• RED_SHADER_LIGHT_POS_BINDPOS,
• RED_SHADER_LIGHT_SIGHT,
• RED_SHADER_LIGHT_SIGHT_BINDPOS,
• RED_SHADER_LIGHT_TOP,
• RED_SHADER_LIGHT_TOP_BINDPOS,
• RED_SHADER_LIGHT_RIGHT,
• RED_SHADER_LIGHT_RIGHT_BINDPOS.
• RED_SHADER_LIGHT_PROJUV.

Parameters:

Computes the indirect attenuation for a point light.

Calculates the attenuation for a point light during an indirect rendering workflow.

Uses:

• RED_SHADER_LIGHT_RANGE,
• RED_SHADER_LIGHT_RANGE_BINDPOS,
• RED_SHADER_LIGHT_POS,
• RED_SHADER_LIGHT_POS_BINDPOS.

Parameters:

Computes the indirect attenuation for a spot light.

Calculates the attenuation for a spot light during an indirect rendering workflow.

Uses:

• R0 (temporary),
• RED_SHADER_LIGHT_RANGE,
• RED_SHADER_LIGHT_RANGE_BINDPOS,
• RED_SHADER_LIGHT_POS,
• RED_SHADER_LIGHT_POS_BINDPOS,
• RED_SHADER_LIGHT_SIGHT,
• RED_SHADER_LIGHT_SIGHT_BINDPOS,
• RED_SHADER_LIGHT_TOP,
• RED_SHADER_LIGHT_TOP_BINDPOS,
• RED_SHADER_LIGHT_RIGHT,
• RED_SHADER_LIGHT_RIGHT_BINDPOS.

Parameters:

Interpolates a vector at a triangle's corners.

Parameters:

Performs a ray vs triangle intersection.

This routine preserves the partial derivatives over the whole triangle surface, so that texture sampling can leverage LODs and anisotropic filtering.

Uses:

• R0,R1,R2 (temporaries),
• RED_SHADER_INDIRECT_RAY_POS_BINDTEX texture.
• RED_SHADER_INDIRECT_RAY_DIR_BINDTEX texture.

Parameters:

Computes the attenuation of a light.

This is the attenuation resulting of a light source intensity falloff.

Uses built-in parameters:

• RED_SHADER_LIGHT_RANGE,
• RED_SHADER_LIGHT_RANGE_BINDPOS.

  PARAM RED_SHADER_LIGHT_RANGE = program.local[RED_SHADER_LIGHT_RANGE_BINDPOS];
  
  DP3 oRAtt, iLightVector.xyzx, iLightVector.xyzx;
  RSQ oRAtt, oRAtt.x;
  RCP oRAtt.xzw, oRAtt.x;
  MUL oRAtt.zw, oRAtt, RED_SHADER_LIGHT_RANGE.xxxy;
  TEX oRAtt.x, oRAtt.zwxx, iTEXn, RECT;

Parameters:

Multiplies a vector by a matrix.

Multiplies iV by the matrix [iM0,iM1,iM2], sent with each of its column vectors.

Uses: R0.

  oR.x = iM0.x * iV.x + iM1.x * iV.y + iM2.x * iV.z;
  oR.y = iM0.y * iV.x + iM1.y * iV.y + iM2.y * iV.z;
  oR.z = iM0.z * iV.x + iM1.z * iV.y + iM2.z * iV.z;

Parameters:

Normalizes a vector or register.

  DP3 oRUnitVector.w, iVector, iVector;
  MAX oRUnitVector.w, oRUnitVector.w, { 1e-12 }.x;
  RSQ oRUnitVector.w, oRUnitVector.w;
  MUL oRUnitVector.xyz, iVector, oRUnitVector.w;

Normalizes iVector, stores the result in oRUnitVector. The same vector can be used as input and output. iVector.w is ignored.
Note that oRUnitVector can't be a shader output register such as 'result.color' or 'result.depth'.

Parameters:

Declares a parameter name from a program local.

  PARAM iName = program.local[iLocal];

See also Cartoon shading.

The iName parameter will be declared once per program, so repeated call to Temp with several times same iName will have no effect.

Parameters:

Returns:

Start an ARB 1.0 pixel shader string.

  !!ARBfp1.0

Clears the string and adds the pixel shader header.

See also Cartoon shading.

Computes the attenuation for a point light.

Calculates the attenuation for a point light intensity falloff.

Uses built-in parameters:

• RED_SHADER_LIGHT_RANGE,
• RED_SHADER_LIGHT_RANGE_BINDPOS.

  LightAttenuation( oRAtt, iLightVector, iTEXatt );
  MUL oLightVector, iLightVector, oRAtt.yyyy;

Parameters:

Retrieves a vector from a bumpmap.

Parameters:

Marks the end of the shader.

  END

Adds the shader termination tag to the string contents.

See also Cartoon shading.

Returns:

Blur the shadows of a shadow map.

Uses: R0 and R1.

Parameters:

Lookups the skylight intensity.

This is the constant intensity multiplier of the skylight that is retrieved here.

Parameters:

Computes the diffuse term for an skylight.

This method computes a diffuse term for a skylight, by taking a number of directional samples over the skylight and by weighting the diffuse contribution for each sample.

Parameters:

Performs smooth Hermite interpolation. Equivalent to GLSL smoothstep function.

Parameters:

Returns:

Helper method to declare a built-in soft shader.

Parameters:

Returns:

Starts a built-in software shader.

  !!REDShader:iLibrary:iLabel:iVersion

Clears the string and adds the soft shader startup label. The iLabel method must point to a function whose prototype is defined according to the software tracer shading prototype:

  typedef RED_RC (*SOFT_SHADER_CALLBACK)( RED::SoftFrameBufferSample        ioFrameBufferSample,
                                          const RED::ISoftRayContext&       iRayContext,
                                          const RED::ISoftShaderContext&    iShaderContext,
                                          const RED::ISoftRenderingContext& iRenderingContext,
                                          const RED::Version&               iVersion );

Note that iLibrary and iLabel can't contain any ':' character as this would cause a misleading interpretation of the shader header.

If both iLibrary and iLabel are defined, the engine will try to load the dynamic library named iLibrary and look for the iLabel entry point in it. This will be our shading function.

If iLibrary is set to an empty string and iLabel is defined, the engine will look for a registered shading callback called iLabel in the resource manager (users can register their own shading callbacks using RED::IResourceManager::RegisterShadingCallback).

See also Cartoon shading.

Parameters:

Returns:

Computes the attenuation for a spot light.

Calculates the attenuation for a spot light intensity falloff.

Uses:

• R0 (temporary),
• RED_SHADER_LIGHT_RANGE,
• RED_SHADER_LIGHT_RANGE_BINDPOS,
• RED_SHADER_LIGHT_SIGHT,
• RED_SHADER_LIGHT_SIGHT_BINDPOS,
• RED_SHADER_LIGHT_TOP,
• RED_SHADER_LIGHT_TOP_BINDPOS,
• RED_SHADER_LIGHT_RIGHT,
• RED_SHADER_LIGHT_RIGHT_BINDPOS.

  LightAttenuation( oRAtt, iLightVector, iTEXatt );
  MUL oLightVector, iLightVector, oRAtt.yyyy;
  
  PARAM RED_SHADER_LIGHT_SIGHT = program.local[RED_SHADER_LIGHT_SIGHT_BINDPOS];
  PARAM RED_SHADER_LIGHT_TOP   = program.local[RED_SHADER_LIGHT_TOP_BINDPOS];
  PARAM RED_SHADER_LIGHT_RIGHT = program.local[ RED_SHADER_LIGHT_RIGHT_BINDPOS];
  
  DP3 R0.x, RED_SHADER_LIGHT_SIGHT, -oLightVector;
  DP3 R0.y, RED_SHADER_LIGHT_TOP,   -oLightVector;
  DP3 R0.z, RED_SHADER_LIGHT_RIGHT, -oLightVector;
  TEX R0.x, R0.xyzx, iTEXs, CUBE;
  MUL oRAtt.x, oRAtt.x, R0.x;

Parameters:

Calculates the angular falloff decay.

This method calculates the intensity decay that result of a spotlight's angular falloff. The method works either in VCS or WCS assuming that all references are bound in the same space.

  PARAM RED_SHADER_LIGHT_SIGHT = RED_PSH_BINDPOS_LIGHT_SIGHT;
  PARAM RED_SHADER_LIGHT_TOP   = RED_PSH_BINDPOS_LIGHT_TOP;
  PARAM RED_SHADER_LIGHT_RIGHT = RED_PSH_BINDPOS_LIGHT_RIGHT;
  
  TEMP lsproj;
  
  DP3 lsproj.x, RED_SHADER_LIGHT_SIGHT, -iLightDir;
  DP3 lsproj.y, RED_SHADER_LIGHT_TOP,   -iLightDir;
  DP3 lsproj.z, RED_SHADER_LIGHT_RIGHT, -iLightDir;
  TEX oDecay lsproj, TEXs, CUBE;

Parameters:

Declares a temporary parameter.

  TEMP iName;

The iName parameter will be declared once per program, so repeated call to Temp with several times same iName will have no effect.

See also Cartoon shading.

Parameters:

Returns:

Sample a texture, for various possible inputs.

Parameters:

Sample a texture, for various possible inputs.

Parameters:

Transfers the triangle identifier to the pixel shader.

Transfers the triangle identifier sent by the indirect lighting rendering pipeline to the pixel shader, considering the different hardware channels capabilities & numerical tolerancies.

The vertex.attrib[1] input channel is reserved for triangle ID transmission in indirect lighting.

Parameters:

Returns:

Rejects fragments calculated for a wrong triangle.

Tests whether we are doing an indirect rendering of a triangle that is the triangle really visible for that pass or not.

Uses:

• R0, R1 (temporaries),
• RED_SHADER_INDIRECT_RAY_TRIANGLE_BINDTEX,
• fragment.color.primary (NVIDIA),
• program.local[RED_SHADER_INDIRECT_ATI_TRIANGLE_ID_BINDPOS] (ATI).

Parameters:

Returns:

Homogeneous transformation of UV coordinates by a 4x4 matrix.

The matrix is provided by row vectors, starting at the program local constant iN. We only use the two first matrix rows as we are only transforming iV.xy.

  DP4 oRx, program.local[iN], iUV;
  DP4 oRy, program.local[iN+1], iUV;

Parameters:

Matrix transformation of an UV coordinate set.

Uses

• R0 (temporary).

  MOV R0, iRUV;
  MOV R0.zw, {0,0,0,1};
  DP4 oRUV.x, program.local[iMatrixRowBindPos], R0;
  DP4 oRUV.y, program.local[iMatrixRowBindPos+1], R0;

Parameters:

Computes the length of a vector.

  DP3 oLength.x, iVector, iVector;
  RSQ oLength.x, oLength.x;
  RCP oLength.x, oLength.x;

Parameters:

Transformation of a vector by a 3x3 matrix.

  DP3 oR.x, iM.row[0], iV;
  DP3 oR.y, iM.row[1], iV;
  DP3 oR.z, iM.row[2], iV;

Parameters:

Transformation of a vector by a 3x3 matrix.

  DP3 oR.x, program.local[iN], iV;
  DP3 oR.y, program.local[iN+1], iV;
  DP3 oR.z, program.local[iN+2], iV;

Parameters:

Transformation of a vector by a 3x3 matrix.

  DP3 oR.x, iRow0, iV;
  DP3 oR.y, iRow1, iV;
  DP3 oR.z, iRow2, iV;

Parameters:

Homogeneous transformation of a vertex by a 3x4 matrix.

  DPH oR.x, iV, iM.row[0];
  DPH oR.y, iV, iM.row[1];
  DPH oR.z, iV, iM.row[2];

Parameters:

Starts an ARB 1.0 vertex shader string.

  !!ARBvp1.0

Clears the string contents and adds the vertex shader header.

See also Cartoon shading.

Homogeneous transformation of a vector by a 4x4 matrix.

  DP4 oR.x, program.local[iN], iV;
  DP4 oR.y, program.local[iN+1], iV;
  DP4 oR.z, program.local[iN+2], iV;
  DP4 oR.w, program.local[iN+3], iV;

See also Cartoon shading.

Parameters:

Homogeneous transformation of a vector by a 4x4 matrix.

  oR.x = iM0.x * iV.x + iM1.x * iV.y + iM2.x * iV.z + iM3.x * iV.w;
  oR.y = iM0.y * iV.x + iM1.y * iV.y + iM2.y * iV.z + iM3.y * iV.w;
  oR.z = iM0.z * iV.x + iM1.z * iV.y + iM2.z * iV.z + iM3.z * iV.w;
  oR.w = iM0.w * iV.x + iM1.w * iV.y + iM2.w * iV.z + iM3.w * iV.w;

Declares and used the register 'R0'.

See also Cartoon shading.

Parameters:

Homogeneous transformation of a vector by a 4x4 matrix.

  DP4 oR.x, iM.row[0], iV;
  DP4 oR.y, iM.row[1], iV;
  DP4 oR.z, iM.row[2], iV;
  DP4 oR.w, iM.row[3], iV;

See also Cartoon shading.

Parameters:

Homogeneous transformation of a vector by a 3x4 matrix.

  DP4 oR.x, iM.row[0], iV;
  DP4 oR.y, iM.row[1], iV;
  DP4 oR.z, iM.row[2], iV;

See also Cartoon shading.

Parameters:

_params: List of parameters that have been declared for the current shader.