 |
OGRE 14.3
Object-Oriented Graphics Rendering Engine
|
|
OGRE 14.3
Object-Oriented Graphics Rendering Engine
|
In order to use a vertex, geometry or fragment program in your materials, you first have to define them. A single program definition can be used by any number of materials, the only prerequisite is that a program must be defined before being referenced in the pass section of a material.
The definition of a program can either be embedded in the .material script itself (in which case it must precede any references to it in the script), or if you wish to use the same program across multiple .material files, you can define it in an external .program script. You define the program in exactly the same way whether you use a .program script or a .material script, the only difference is that all .program scripts are guaranteed to have been parsed before all .material scripts, so you can guarantee that your program has been defined before any .material script that might use it. Just like .material scripts, .program scripts will be read from any location which is on your resource path, and you can define many programs in a single script.
Vertex, geometry and fragment programs can be low-level (i.e. assembler code written to the specification of a given low level syntax such as vs_1_1 or arbfp1) or high-level such as DirectX HLSL and OpenGL GLSL. High level languages give you a number of advantages, such as being able to write more intuitive code, and possibly being able to target multiple architectures in a single program (for example, the same Cg program might be able to be used in both D3D and GL, whilst the equivalent low-level programs would require separate techniques, each targeting a different API). High-level programs also allow you to use named parameters instead of simply indexed ones, although parameters are not defined here, they are used in the Pass.
Here is an example of a definition of a low-level vertex program:
As you can see, that’s very simple, and defining a fragment or geometry program is exactly the same, just with vertex_program replaced with fragment_program or geometry_program, respectively. Likewise, for tessellation and compute programs, use tessellation_hull_program, tessellation_domain_program, and compute_program.
You give the program a name in the header, followed by the word spirv to indicate the syntax being used. Inside the braces, you specify where the source is going to come from (and this is loaded from any of the resource locations as with other media). The syntax specification is necessary for the engine to know what syntax the program is in before reading it. During the compilation of the material, it is important to quickly skip programs that use unsupported syntax to avoid loading the program first.
While defining a vertex, geometry or fragment program, you can also specify the default parameters to be used for materials which use it, unless they specifically override them. You do this by including a nested ’default_params’ section, like so:
The syntax of the parameter definition is exactly the same as when you define parameters when using programs, See Parameter specification. Defining default parameters allows you to avoid rebinding common parameters repeatedly (clearly in the above example, all but ’shininess’ are unlikely to change between uses of the program) which makes your material declarations shorter.
Support for high level vertex and fragment programs is provided through plugins; this is to make sure that an application using OGRE can use as little or as much of the high-level program functionality as they like. OGRE supports multiple high-level program types. Notably DirectX HLSL, and OpenGL GLSL. HLSL can only be used with the DirectX rendersystem, and GLSL can only be used with the GL and Vulkan rendersystems.
One way to support both HLSL and GLSL is to include separate techniques in the material script, each one referencing separate programs. However, if the programs are basically the same, with the same parameters, and the techniques are complex this can bloat your material scripts with duplication fairly quickly. Instead, if the only difference is the language of the vertex & fragment program you can use OGRE’s Unified High-level Programs to automatically pick a program suitable for your rendersystem whilst using a single technique.
There is also Cg which is deprecated, but allows to use the same Shader code across different APIs - although experience has shown that more advanced programs, particularly fragment programs which perform a lot of texture fetches, can produce better code in the rendersystem-specific shader language. The better alternative to Cg is to use Multi-language Programs with OgreUnifiedShader.h. This achieves the same goal as Cg, but uses only a few straightforward preprocessor macros.
Both GLSL and HLSL support using preprocessor definitions in your code - some are defined by the implementation, but you can also define your own, say in order to use the same source code for a few different variants of the same technique. In order to use this feature, include preprocessor conditions in your code, of the kind #ifdef SYMBOL, #if SYMBOL==2 etc. Then in your program definition, use the preprocessor_defines option, following it with a string of definitions. Definitions are separated by ; or , and may optionally have a = operator within them to specify a definition value. Those without an = will implicitly have a definition of 1.
This way you can use the same source code but still include small variations, each one defined as a different Ogre program name but based on the same source code.
#ifdef directives compared to the standard - e.g. you can #ifdef #version. However this means that defines specified in GLSL extensions are not present.The parameter entry_point, specifies the name of a function which will be the first one called as part of the program. Unlike assembler programs, which just run top-to-bottom, high-level programs can include multiple functions and as such you must specify the one which start the ball rolling. If you omit this line, Ogre will default to looking for a function called main.
entry_point is required to be mainGLSL is the native shading language of the OpenGL API and requires no plugins there. Additionally, you can use it with Vulkan by loading the Plugin_GLSLangProgramManager. Declaring a OpenGL GLSL program is similar to Cg but simpler. Here’s an example:
The type glsl works with the GL and GL3+ RenderSystems, while with the GLES2 RenderSystem you must specify glsles instead. For Vulkan, you must specify glslang so the GLSLang Plugin is used. This also works with GL3+, in case you prefer not to use the GLSL compiler of your driver. If your shader is designed for this, you can also specify all of those at once. See Multi-language Programs.
In GLSL, no entry point needs to be defined since it is always main() and there is no target definition since GLSL source is compiled into native GPU code and not intermediate assembly.
For modularity Ogre supports the non-standard #include <something.glsl> directive in GLSL. It also works with OpenGL ES and resembles what is available with HLSL and Cg.
Vertex attributes must be declared in the shader, for the vertex data bound to it by Ogre.
refer to the following table for the location indices and names to use:
| Semantic | Custom name | Binding location | Legacy OpenGL built-in |
|---|---|---|---|
| Ogre::VES_POSITION | vertex | 0 | gl_Vertex |
| Ogre::VES_BLEND_WEIGHTS | blendWeights | 1 | n/a |
| Ogre::VES_NORMAL | normal | 2 | gl_Normal |
| Ogre::VES_COLOUR | colour | 3 | gl_Color |
| Ogre::VES_COLOUR2 | secondary_colour | 4 | gl_SecondaryColor |
| Ogre::VES_BLEND_INDICES | blendIndices | 7 | n/a |
| Ogre::VES_TEXTURE_COORDINATES | uv0 - uv7 | 8-15 | gl_MultiTexCoord0 - gl_MultiTexCoord7 |
| Ogre::VES_TANGENT | tangent | 14 | n/a |
| Ogre::VES_BINORMAL | binormal | 15 | n/a |
With mesh shaders the input assembly stage is skipped and hence the vertex attributes are not available. Instead, Ogre will bind the vertex buffers as SSBOs to a binding point defined by the Ogre::VertexBufferBinding index, offset by 3.
In the shader you can access the buffer as follows:
To bind samplers to texture unit indices from the material scripts, you can either use the explicit binding with GL4.2+ or set the sampler via a int type named parameter.
Binding the sampler in material script:
An index value of 0 refers to the first texture unit in the pass, an index value of 1 refers to the second unit in the pass and so on.
Here are some examples of passing matrices to GLSL mat2, mat3, mat4 uniforms:
mat[0] is the first column in GLSL, but the first row in HLSL and Ogre. Ogre takes care of transposing square matrices before uploading them with GLSL, so matrix-vector multiplication M*v just works and mat[0] will return the same data. However, with non-square matrices transposing would change their GLSL type from e.g. mat2x4 (two columns, four rows) to mat4x2 (two rows, four columns) and consequently what mat[0] would return. Therefore Ogre just passes such matrices unchanged and you have to handle this case (notably in skinning) yourself by either transposing the matrix in the shader or column-wise access.If supported by the RenderSystem, you can opt-in to use uniform buffers for parameter storage. This is done by declaring the parameters in a uniform block named OgreUniforms
Similarly to vertex attributes, the transform feedback varyings are bound by name. Only interleaved output to a single buffer is supported. The offsets are given by the Ogre::VertexDeclaration. The available varyings are:
| Semantic | Varying name |
|---|---|
| Ogre::VES_POSITION | xfb_position |
| Ogre::VES_NORMAL | xfb_normal |
| Ogre::VES_COLOUR | xfb_colour |
| Ogre::VES_COLOUR2 | xfb_colour2 |
| Ogre::VES_TEXTURE_COORDINATES | xfb_uv0 - xfb_uv7 |
The following features are only available when using the legacy OpenGL profile. Notably they are not available with GL3+ or GLES2.
GLSL can access most of the GL states directly so you do not need to pass these states through param_named_auto in the material script. This includes lights, material state, and all the matrices used in the openGL state i.e. model view matrix, worldview projection matrix etc.
GLSL natively supports automatic binding of the most common incoming per-vertex attributes (e.g. gl_Vertex, gl_Normal, gl_MultiTexCoord0 etc) as described in section 7.3 of the GLSL manual. There are some drivers that do not behave correctly when mixing built-in vertex attributes like gl_Normal and custom vertex attributes, so for maximum compatibility you should use all custom attributes
GLSL allows the same shader to run on different types of geometry primitives. In order to properly link the shaders together, you have to specify which primitives it will receive as input, which primitives it will emit and how many vertices a single run of the shader can generate. The GLSL geometry_program definition requires three additional parameters
| input_operation_type | The operation type of the geometry that the shader will receive. Can be ’point_list’, ’line_list’, ’line_strip’, ’triangle_list’, ’triangle_strip’ or ’triangle_fan’. |
| output_operation_type | The operation type of the geometry that the shader will emit. Can be ’point_list’, ’line_strip’ or ’triangle_strip’. |
| max_output_vertices | The maximum number of vertices that the shader can emit. There is an upper limit for this value, it is exposed in the render system capabilities. |
With GL3+ these values are specified using the layout modifier.
The attach keyword allows creating GLSL shaders from multiple shader modules of the same type. The referencing shader has to forward-declare the functions it intends to use
attach keyword for multi-module shaders is not supported on OpenGL ES and therefore deprecated in favor of the #include directiveIn order to define Cg programs, you have to have to load Plugin_CgProgramManager at startup, either through plugins.cfg or through your own plugin loading code. They are very easy to define:
There are a few differences between this and the assembler program - to begin with, we declare that the fragment program is of type cg rather than spirv, which indicates that it’s a high-level program using Cg. The source parameter is the same, except this time it’s referencing a Cg source file instead of a file of assembler.
Here is where things start to change. Instead of a fixed syntax parameter, you specify one or more profiles; profiles are how Cg compiles a program down to the low-level assembler. The profiles have the same names as the assembler syntax codes mentioned above; the main difference is that you can list more than one, thus allowing the program to be compiled down to more low-level syntaxes so you can write a single high-level program which runs on both D3D and GL. You are advised to just enter the simplest profiles under which your programs can be compiled in order to give it the maximum compatibility. The ordering also matters; if a card supports more than one syntax then the one listed first will be used.
preprocessor_defines Cg uses the compile_arguments option where you can specify arguments exactly as you would to the cgc command-line compiler. While this gives you more flexibility, it means that you must specify the defines as -DSYMBOL separated by spaces. Keep this in mind when copying program definitions across the supported languages.DirectX HLSL has an almost identical language syntax to Cg but is tied to the DirectX API. The benefit over Cg is that it only requires the DirectX render system plugin, not any additional plugins. Declaring a DirectX HLSL program is very similar to Cg. Here’s an example:
As you can see, the main syntax is almost identical, except that instead of profiles with a list of assembler formats, you have a target parameter which allows a single assembler target to be specified - obviously this has to be a DirectX assembler format syntax code.
float3x4 / matrix3x4 type in your shader, bound to an OGRE auto-definition (such as bone matrices) you should use the column_major_matrices = false option (discussed below) in your program definition. This is because OGRE passes float3x4 as row-major to save constant space (3 float4’s rather than 4 float4’s with only the top 3 values used) and this tells OGRE to pass all matrices like this, so that you can use mul(m,v) consistently for all calculations. OGRE will also to tell the shader to compile in row-major form (you don’t have to set the /Zpr compile option or #pragma pack(row-major) option, OGRE does this for you). Note that passing bones in float4x3 form is not supported by OGRE, but you don’t need it given the above.Advanced options
The default for this option is ’true’ so that OGRE passes matrices auto-bound matrices in a form where mul(m,v) works. Setting this option to false does 2 things - it transpose auto-bound 4x4 matrices and also sets the /Zpr (row-major) option on the shader compilation. This means you can still use mul(m,v), but the matrix layout is row-major instead. This is only useful if you need to use bone matrices (float3x4) in a shader since it saves a float4 constant for every bone involved.
Set the optimisation level, which can be one of ’default’, ’none’, ’0’, ’1’, ’2’, or ’3’. This corresponds to the /O parameter of fxc.exe, except that in ’default’ mode, optimisation is disabled in debug mode and set to 1 in release mode (fxc.exe uses 1 all the time). Unsurprisingly the default value is ’default’. You may want to change this if you want to tweak the optimisation, for example if your shader gets so complex that it will not longer compile without some minimum level of optimisation.
The current supported syntaxes are:
The assembly language used by Vulkan
SPIRV variant exposed by ARB_gl_spirv
These is are the DirectX vertex shader assembler syntaxes.
This is the OpenGL standard assembler format for vertex programs. It’s roughly equivalent to DirectX vs_1_1.
These are nVidia-specific OpenGL vertex shader syntax which is a superset of vs_1_1_, that have otherwise no equivalent in OpenGL.
DirectX pixel shader (i.e. fragment program) assembler syntax.
This is the OpenGL standard assembler format for fragment programs. It’s roughly equivalent to ps_2_0, which means that not all cards that support basic pixel shaders under DirectX support arbfp1 (for example neither the GeForce3 or GeForce4 support arbfp1, but they do support ps_1_1).
This is an nVidia-specific OpenGL fragment syntax which is a superset of ps 1.3. It allows you to use the nvparse format for basic fragment programs. It actually uses NV_texture_shader and NV_register_combiners to provide functionality equivalent to DirectX’s ps_1_1 under GL, but only for nVidia cards. However, since ATI cards adopted arbfp1 a little earlier than nVidia, it is mainly nVidia cards like the GeForce3 and GeForce4 that this will be useful for.
Another nVidia-specific OpenGL fragment shader syntax.
An nVidia-specific OpenGL geometry shader syntax.
Supported cards: nVidia GeForce FX8 series
You can get a definitive list of the syntaxes supported by the current card by calling Ogre::GpuProgramManager::getSupportedSyntax().
Assembler shaders don’t have named constants (also called uniform parameters) because the language does not support them - however if you for example decided to precompile your shaders from a high-level language down to assembler for performance or obscurity, you might still want to use the named parameters. Well, you actually can - GpuNamedConstants which contains the named parameter mappings has a ’save’ method which you can use to write this data to disk, where you can reference it later using the manual_named_constants directive inside your assembler program declaration, e.g.
In this case myVertexProgram.constants has been created by calling Ogre::GpuNamedConstants::save("myVertexProgram.constants"); sometime earlier as preparation, from the original high-level program. Once you’ve used this directive, you can use named parameters here even though the assembler program itself has no knowledge of them.
Basic programs, like the example.frag stated above, are compatible with GLSL and GLSLES. To avoid duplicating the whole program declaration, you can simply specify all the language types the program is compatible with as:
You can even write programs compatible with both HLSL and GLSL by using #include <OgreUnifiedShader.h> in the shader which provides cross-language macros to help with this. See Cross-platform Shaders for more information.
As mentioned above, it can often be useful to write both HLSL and GLSL programs to specifically target each platform, but if you do this via multiple material techniques this can cause a bloated material definition when the only difference is the program language. Well, there is another option. You can ’wrap’ multiple programs in a ’unified’ program definition, which will automatically choose one of a series of ’delegate’ programs depending on the rendersystem and hardware support.
This works for both vertex and fragment programs, and you can list as many delegates as you like - the first one to be supported by the current rendersystem & hardware will be used as the real program. This is almost like a mini-technique system, but for a single program and with a much tighter purpose. You can only use this where the programs take all the same inputs, particularly textures and other pass / sampler state. Where the only difference between the programs is the language (or possibly the target in HLSL - you can include multiple HLSL programs with different targets in a single unified program too if you want, or indeed any number of other high-level programs), this can become a very powerful feature. For example, without this feature here’s how you’d have to define a programmable material which supported HLSL and GLSL:
And that’s a really small example. Everything you added to the HLSL technique, you’d have to duplicate in the GLSL technique too. So instead, here’s how you’d do it with unified program definitions:
At runtime, when myVertexProgram or myFragmentProgram are used, OGRE automatically picks a real program to delegate to based on what’s supported on the current hardware / rendersystem. If none of the delegates are supported, the entire technique referencing the unified program is marked as unsupported and the next technique in the material is checked for fallback, just like normal. As your materials get larger, and you find you need to support HLSL and GLSL specifically (or need to write multiple interface-compatible versions of a program for whatever other reason), unified programs can really help reduce duplication.
Parameters can be specified using one of 4 commands as shown below. The same syntax is used whether you are defining a parameter just for this particular use of the program, or when specifying the Default Program Parameters. Parameters set in the specific use of the program override the defaults.
This command sets the value of an indexed parameter.
| index | simply a number representing the position in the parameter list which the value should be written, and you should derive this from your program definition. The index is relative to the way constants are stored on the card, which is in 4-element blocks. For example if you defined a float4 parameter at index 0, the next index would be 1. If you defined a matrix4x4 at index 0, the next usable index would be 4, since a 4x4 matrix takes up 4 indexes. |
| type | can be float4, matrix4x4, float<n>, int4, int<n>. Note that ’int’ parameters are only available on some more advanced program syntaxes, check the D3D or GL vertex / fragment program documentation for full details. Typically the most useful ones will be float4 and matrix4x4. Note that if you use a type which is not a multiple of 4, then the remaining values up to the multiple of 4 will be filled with zeroes for you (since GPUs always use banks of 4 floats per constant even if only one is used). |
| value | a space or tab-delimited list of values which can be converted into the type you have specified. |
This command tells Ogre to automatically update a given parameter with a derived value. This frees you from writing code to update program parameters every frame when they are always changing.
| index | has the same meaning as param_indexed; note this time you do not have to specify the size of the parameter because the engine knows this already. In the example, the world/view/projection matrix is being used so this is implicitly a matrix4x4. |
| autoConstType,extraInfo | is one of Ogre::GpuProgramParameters::AutoConstantType without the ACT_ prefix. E.g. ACT_WORLD_MATRIX becomes world_matrix. |
This is the same as param_indexed, but uses a named parameter instead of an index. This can only be used with high-level programs which include parameter names; if you’re using an assembler program then you have no choice but to use indexes. Note that you can use indexed parameters for high-level programs too, but it is less portable since if you reorder your parameters in the high-level program the indexes will change.
The type is required because the program is not compiled and loaded when the material script is parsed, so at this stage we have no idea what types the parameters are. Programs are only loaded and compiled when they are used, to save memory.
This is the named equivalent of param_indexed_auto, for use with high-level programs.
The allowed autoConstType and the meaning of extraInfo are detailed in param_indexed_auto.
This option allows you to reference shared parameter sets as defined in Declaring Shared Parameters.
The only required parameter is a name, which must be the name of an already defined shared parameter set. All named parameters which are present in both the program and the shared parameter set will be linked, and the shared parameters values will be used.
Often, not every parameter you want to pass to a shader is unique to that program, and perhaps you want to give the same value to a number of different programs, and a number of different materials using that program. Shared parameter sets allow you to define a ’holding area’ for shared parameters that can then be referenced when you need them in particular shaders, while keeping the definition of that value in one place. To define a set of shared parameters, you do this:
As you can see, you need to use the keyword ’shared_params’ and follow it with the name that you will use to identify these shared parameters. Inside the curly braces, you can define one parameter per line, in a way which is very similar to the param_named syntax. The definition of these lines is:
| param_name | must be unique within the set |
| param_type | can be any one of float, float2, float3, float4, int, int2, int3, int4, matrix2x2, matrix2x3, matrix2x4, matrix3x2, matrix3x3, matrix3x4, matrix4x2, matrix4x3 and matrix4x4. |
| array_size | allows you to define arrays of param_type should you wish, and if present must be a number enclosed in square brackets (and note, must be separated from the param_type with whitespace). |
| initial_values | If you wish, you can also initialise the parameters by providing a list of values. |
Once you have defined the shared parameters, you can reference them inside default_params and params blocks using shared_params_ref. You can also obtain a reference to them in your code via Ogre::GpuProgramManager::getSharedParameters, and update the values for all instances using them.
Furthermore, shared_params can be mapped to hardware buffers, if supported by the RenderSystem. To enable this, you have to provide a matching declaration in your shader.
For HLSL, that would be a constant buffer defined as
and for GLSL a uniform block defined as
When using Shadows, the use of vertex programs can add some additional complexities, because Ogre can only automatically deal with everything when using the fixed-function pipeline. If you use vertex programs, and you are also using shadows, you may need to make some adjustments.
Basically you specify an alternate material to use when rendering the object into the shadow texture:
When rendering a shadow caster, Ogre will automatically use the alternate material. You can bind the same or different parameters to the program - the most important thing is that you bind *ambient_light_colour*, since this determines the colour of the shadow in modulative texture shadows. If you don’t supply an alternate material, Ogre will fall back on a fixed-function material which will not reflect any vertex deformation you do in your vertex or geometry programs.
In addition, when rendering the shadow receivers with shadow textures, Ogre needs to project the shadow texture. It does this automatically in fixed function mode, but if the receivers use vertex programs, they need to have a shadow receiver material which does the usual vertex deformation, but also generates projective texture coordinates.
The alternative material is linked into the technique - similarly to the caster material - like:
For the purposes of writing the alternate program, there is an automatic parameter binding of texture_worldviewproj_matrix which provides the program with texture projection parameters. The vertex program should do its normal vertex processing, and generate texture coordinates using this matrix and place them in texture coord sets 0 and 1, since some shadow techniques use 2 texture units. The colour of the vertices output by this vertex program must always be white, so as not to affect the final colour of the rendered shadow.
When using additive texture shadows, the shadow_receiver_material replaces the lighting render, so if you perform any fragment program lighting you also need to pull in a custom fragment program:
You should pass the projected shadow coordinates from the custom vertex program. As for textures, define a texture_unit with content_type shadow to pull the shadow texture. Your shadow receiver fragment program is likely to be the same as the bare lighting pass of your normal material, except that you insert an extra texture sampler for the shadow texture, which you will use to adjust the result by (modulating diffuse and specular components).
You can implement hardware instancing by writing a vertex program which reads the world matrix of each instance from a float3x4 vertex attribute. However, you need to communicate this support to Ogre so it batches the instances instead of rendering them individually. You do this by adding the following attribute to your vertex_program definition:
When you do this, all SubEntities with the same material will be batched together. Ogre will create and populate an instance buffer with the world matrices of the instances. This buffer is provided in the TEXCOORD1 attribute (also consuming TEXCOORD2 and TEXCOORD3) to the vertex shader.
When batching, all instances are rendered in a single draw-call. All per-renderable operations are only performed with the first SubMesh of the batch.
Therefore the following features are not supported:
start_light and iteration (all instances share the same lights)You can implement skeletal animation in hardware by writing a vertex program which uses the per-vertex blending indices and blending weights, together with an array of world matrices (which will be provided for you by Ogre if you bind the automatic parameter ’world_matrix_array_3x4’). However, you need to communicate this support to Ogre so it does not perform skeletal animation in software for you. You do this by adding the following attribute to your vertex_program definition:
When you do this, any skeletally animated entity which uses this material will forgo the usual animation blend and will expect the vertex program to do it, for both vertex positions and normals. Note that ALL submeshes must be assigned a material which implements this, and that if you combine skeletal animation with vertex animation (See Animation) then all techniques must be hardware accelerated for any to be.
You can implement morph animation in hardware by writing a vertex program which linearly blends between the first and second position keyframes passed as positions and the first free texture coordinate set, and by binding the animation_parametric value to a parameter (which tells you how far to interpolate between the two). However, you need to communicate this support to Ogre so it does not perform morph animation in software for you. You do this by adding the following attribute to your vertex_program definition:
When you do this, any skeletally animated entity which uses this material will forgo the usual software morph and will expect the vertex program to do it. Note that if your model includes both skeletal animation and morph animation, they must both be implemented in the vertex program if either is to be hardware acceleration. Note that ALL submeshes must be assigned a material which implements this, and that if you combine skeletal animation with vertex animation (See Animation) then all techniques must be hardware accelerated for any to be.
You can implement pose animation (blending between multiple poses based on weight) in a vertex program by pulling in the original vertex data (bound to position), and as many pose offset buffers as you’ve defined in your ’includes_pose_animation’ declaration, which will be in the first free texture unit upwards. You must also use the animation_parametric parameter to define the starting point of the constants which will contain the pose weights; they will start at the parameter you define and fill ’n’ constants, where ’n’ is the max number of poses this shader can blend, i.e. the parameter to includes_pose_animation.
Note that ALL submeshes must be assigned a material which implements this, and that if you combine skeletal animation with vertex animation (See Animation) then all techniques must be hardware accelerated for any to be.
More recent generations of video card allow you to perform a read from a texture in the vertex program rather than just the fragment program, as is traditional. This allows you to, for example, read the contents of a texture and displace vertices based on the intensity of the colour contained within.
If your vertex program makes use of Vertex Texture Fetch, you should declare that as
Since hardware support for vertex texture fetching is not ubiquitous, you should use the directive when declaring your vertex programs which use vertex textures, so that if it is not supported, technique fallback can be enabled. This is not strictly necessary for DirectX-targeted shaders, since vertex texture fetching is only supported in vs_3_0, which can be stated as a required syntax in your shader definition, but for OpenGL (GLSL), there are cards which support GLSL but not vertex textures, so you should be explicit about your need for them.
Shader Model 3.0 (SM3.0) hardware under DirectX9 includes 4 sampler bindings for the purposes of vertex textures. Ogre assigns the first 4 texture units to these bindings - therefore you should put fragment-only textures last.
Again as at the time of writing, the types of texture you can use in a vertex program are limited to 1- or 4-component, full precision floating point formats. In code that equates to PF_FLOAT32_R or PF_FLOAT32_RGBA. No other formats are supported. In addition, the textures must be regular 2D textures (no cube or volume maps) and mipmapping and filtering is not supported, although you can perform filtering in your vertex program if you wish by sampling multiple times.
As at the time of writing (early Q3 2006), ATI do not support texture fetch in their current crop of cards (Radeon X1n00). nVidia do support it in both their 6n00 and 7n00 range. ATI support an alternative called ’Render to Vertex Buffer’, but this is not standardised at this time and is very much different in its implementation, so cannot be considered to be a drop-in replacement. This is the case even though the Radeon X1n00 cards claim to support vs_3_0 (which requires vertex texture fetch).
In case you need to create GPU Programs programmatically, see the following example for how the script is mapped to the API.
becomes
1.9.8