C# Class Axiom.Graphics.TextureUnitState

Generic method for setting up texture effects.

Allows you to specify effects directly by using the TextureEffectType enumeration. The arguments that go with it depend on the effect type. Only one effect of each type can be applied to a texture layer.

This method is used internally, but it is better generally for applications to use the more intuitive specialized methods such as SetEnvironmentMap and SetScroll.

Applies texture names to Texture Unit State with matching texture name aliases. If no matching aliases are found then the TUS state does not change.

Cubic, 1d, 2d, and 3d textures are determined from current state of the Texture Unit. Assumes animated frames are sequentially numbered in the name. If matching texture aliases are found then true is returned.

Used to clone a texture layer. Mainly used during a call to Clone on a Material or Pass.

Used to clone a texture layer. Mainly used during a call to Clone on a Material.

Gets the texture effect at the specified index.

Gets the name of the texture associated with a frame.

Applies to both fixed-function and programmable pipeline.

Gets the texture filtering for the given type.

Internal method for loading this texture stage as part of Material.Load.

Notifies the parent that it needs recompilation.

Removes all effects from this texture stage.

Removes the specified effect from the list of effects being applied during this texture stage.

Overloaded method.

Sets the alpha operation to be applied to this texture.

This works in exactly the same way as SetColorOperation, except that the effect is applied to the level of alpha (i.e. transparency) of the texture rather than its color. When the alpha of a texel (a pixel on a texture) is 1.0, it is opaque, wheras it is fully transparent if the alpha is 0.0. Please refer to the SetColorOperation method for more info.

Sets the names of the texture images for an animated texture.

Animated textures are just a series of images making up the frames of the animation. All the images must be the same size, and their names must have a frame number appended before the extension, e.g. if you specify a name of "wall.jpg" with 3 frames, the image names must be "wall_1.jpg" and "wall_2.jpg".

You can change the active frame on a texture layer by setting the CurrentFrame property.

Note: If you can't make your texture images conform to the naming standard layed out here, you can call the alternative SetAnimatedTextureName method which takes an array of names instead.

Sets the multipass fallback operation for this layer, if you used TextureUnitState.SetColorOperationEx and not enough multitexturing hardware is available.

Because some effects exposed using TextureUnitState.SetColorOperationEx are only supported under multitexturing hardware, if the hardware is lacking the system must fallback on multipass rendering, which unfortunately doesn't support as many effects. This method is for you to specify the fallback operation which most suits you.

You'll notice that the interface is the same as the Material.SetSceneBlending method; this is because multipass rendering IS effectively scene blending, since each layer is rendered on top of the last using the same mechanism as making an object transparent, it's just being rendered in the same place repeatedly to get the multitexture effect.

If you use the simpler (and hence less flexible) TextureUnitState.SetColorOperation method you don't need to call this as the system sets up the fallback for you.

This option has no effect in the programmable pipeline, because there is no multipass fallback and multitexture blending is handled by the fragment shader.

Determines how this texture layer is combined with the one below it (or the diffuse color of the geometry if this is layer 0).

This method is the simplest way to blend tetxure layers, because it requires only one parameter, gives you the most common blending types, and automatically sets up 2 blending methods: one for if single-pass multitexturing hardware is available, and another for if it is not and the blending must be achieved through multiple rendering passes. It is, however, quite limited and does not expose the more flexible multitexturing operations, simply because these can't be automatically supported in multipass fallback mode. If want to use the fancier options, use , but you'll either have to be sure that enough multitexturing units will be available, or you should explicitly set a fallback using TextureUnitState.SetColorOpMultipassFallback.

The default method is LayerBlendOperation.Modulate for all layers.

This option has no effect in the programmable pipeline.

Overloaded method.

Overloaded method.

Overloaded method.

For setting advanced blending options.

This is an extended version of the TextureUnitState.SetColorOperation method which allows extremely detailed control over the blending applied between this and earlier layers. See the IMPORTANT note below about the issues between mulitpass and multitexturing that using this method can create.

Texture color operations determine how the final color of the surface appears when rendered. Texture units are used to combine color values from various sources (ie. the diffuse color of the surface from lighting calculations, combined with the color of the texture). This method allows you to specify the 'operation' to be used, ie. the calculation such as adds or multiplies, and which values to use as arguments, such as a fixed value or a value from a previous calculation.

The defaults for each layer are:

• op = Modulate
• source1 = Texture
• source2 = Current

Because of the limitations on some underlying APIs (Direct3D included) the Texture argument can only be used as the first argument, not the second.

The final 3 parameters are only required if you decide to pass values manually into the operation, i.e. you want one or more of the inputs to the color calculation to come from a fixed value that you supply. Hence you only need to fill these in if you supply Manual to the corresponding source, or use the BlendManual operation.

The engine tries to use multitexturing hardware to blend texture layers together. However, if it runs out of texturing units (e.g. 2 of a GeForce2, 4 on a GeForce3) it has to fall back on multipass rendering, i.e. rendering the same object multiple times with different textures. This is both less efficient and there is a smaller range of blending operations which can be performed. For this reason, if you use this method you MUST also call TextureUnitState.SetColorOpMultipassFallback to specify which effect you want to fall back on if sufficient hardware is not available.

If you wish to avoid having to do this, use the simpler TextureUnitState.SetColorOperation method which allows less flexible blending options but sets up the multipass fallback automatically, since it only allows operations which have direct multipass equivalents.

This has no effect in the programmable pipeline.

Sets this texture layer to use a combination of 6 texture maps, each one relating to a face of a cube.

Cubic textures are made up of 6 separate texture images. Each one of these is an orthoganal view of the world with a FOV of 90 degrees and an aspect ratio of 1:1. You can generate these from 3D Studio by rendering a scene to a reflection map of a transparent cube and saving the output files.

Cubic maps can be used either for skyboxes (complete wrap-around skies, like space) or as environment maps to simulate reflections. The system deals with these 2 scenarios in different ways:

1. For cubic environment maps, the 6 textures are combined into a single 'cubic' texture map which is then addressed using 3D texture coordinates. This is required because you don't know what face of the box you're going to need to address when you render an object, and typically you need to reflect more than one face on the one object, so all 6 textures are needed to be 'active' at once. Cubic environment maps are enabled by calling this method with the forUVW parameter set to true, and then calling SetEnvironmentMap(true).

   Note that not all cards support cubic environment mapping.

2. For skyboxes, the 6 textures are kept separate and used independently for each face of the skybox. This is done because not all cards support 3D cubic maps and skyboxes do not need to use 3D texture coordinates so it is simpler to render each face of the box with 2D coordinates, changing texture between faces.

   Skyboxes are created by calling SceneManager.SetSkyBox.

Applies to both fixed-function and programmable pipeline.

Overloaded method.

Turns on/off texture coordinate effect that makes this layer an environment map.

Environment maps make an object look reflective by using the object's vertex normals relative to the camera view to generate texture coordinates.

The vectors generated can either be used to address a single 2D texture which is a 'fish-eye' lens view of a scene, or a 3D cubic environment map which requires 6 textures for each side of the inside of a cube. The type depends on what texture you set up - if you use the setTextureName method then a 2D fisheye lens texture is required, whereas if you used setCubicTextureName then a cubic environemnt map will be used.

This effect works best if the object has lots of gradually changing normals. The texture also has to be designed for this effect - see the example spheremap.png included with the sample application for a 2D environment map; a cubic map can be generated by rendering 6 views of a scene to each of the cube faces with orthoganal views.

Enabling this disables any other texture coordinate generation effects. However it can be combined with texture coordinate modification functions, which then operate on the generated coordinates rather than static model texture coordinates.

This option has no effect in the programmable pipeline.

Enables or disables projective texturing on this texture unit.

Projective texturing allows you to generate texture coordinates based on a Frustum, which gives the impression that a texture is being projected onto the surface. Note that once you have called this method, the texture unit continues to monitor the Frustum you passed in and the projection will change if you can alter it. It also means that the Frustum object you pass remains in existence for as long as this TextureUnitState does.

This effect cannot be combined with other texture generation effects, such as environment mapping. It also has no effect on passes which have a vertex program enabled - projective texturing has to be done in the vertex program instead.

Sets up an animated texture rotation for this layer.

Useful for constant rotations (for varying rotations, SetTransformAnimation).

This option has no effect in the programmable pipeline.

Sets up an animated scroll for the texture layer.

Useful for creating constant scrolling effects on a texture layer (for varying scrolls, SetTransformAnimation).

This option has no effect in the programmable pipeline.

Sets the texture addressing mode, i.e. what happens at uv values above 1.0.

The default is TAM_WRAP i.e. the texture repeats over values of 1.0. This is a shortcut method which sets the addressing mode for all coordinates at once; you can also call the more specific method to set the addressing mode per coordinate. This applies for both the fixed-function and programmable pipelines.

Sets the texture addressing mode, i.e. what happens at uv values above 1.0.

The default is TAM_WRAP i.e. the texture repeats over values of 1.0. This applies for both the fixed-function and programmable pipelines.

Sets the texture addressing mode, i.e. what happens at uv values above 1.0.

The default is TAM_WRAP i.e. the texture repeats over values of 1.0. This applies for both the fixed-function and programmable pipelines.

Set a the detailed filtering options on this texture unit.

Set a single filtering option on this texture unit.

Set the texture filtering for this unit, using the simplified interface.

You also have the option of specifying the minification, magnification and mip filter individually if you want more control over filtering options. See the SetTextureFiltering overloads for details.

Note: This option applies in both the fixed function and programmable pipeline.

Sets this texture layer to use a single texture, given the name of the texture to use on this layer.

Applies to both fixed-function and programmable pipeline.

Sets this texture layer to use a single texture, given the name of the texture to use on this layer.

Applies to both fixed-function and programmable pipeline.

Sets the counter-clockwise rotation factor applied to texture coordinates.

This sets a fixed rotation angle - if you wish to animate this, see the ControllerManager.CreateTextureRotator method.

Has no effect in the programmable pipeline.

Sets the scaling factor of the texture.

This method sets the scale element of the texture transformation, and is easier to use than setTextureTransform if you are combining translation, scaling and rotation in your texture transformation. Again if you want to animate these values you need to use a Controller (see ControllerManager and it's methods for more information).

Has no effect in the programmable pipeline.

Same as in SetTextureScale, but sets only U value.

Has no effect in the programmable pipeline.

Same as in SetTextureScale, but sets only V value.

Has no effect in the programmable pipeline.

Sets the translation offset of the texture, ie scrolls the texture.

This method sets the translation element of the texture transformation, and is easier to use than setTextureTransform if you are combining translation, scaling and rotation in your texture transformation. Again if you want to animate these values you need to use a Controller

Has no effect in the programmable pipeline.

Same as in SetTextureScroll, but sets only U value.

Has no effect in the programmable pipeline.

Same as in SetTextureScroll, but sets only V value.

Has no effect in the programmable pipeline.

Sets up a general time-relative texture modification effect.

This can be called multiple times for different values of transType, but only the latest effect applies if called multiple time for the same transType.

This option has no effect in the programmable pipeline.

Default constructor.

Name based constructor.

Constructor.

Internal method for unloading this object as part of Material.Unload.

Creates an animation controller if needed for this texture unit.

Used internally to create a new controller for this layer given the requested effect.

Used to update the texture matrix if need be.

Removes effects of the specified type from this layers effect list.