Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

Ogre::GpuProgramParameters Class Reference

Collects together the program parameters used for a GpuProgram. More...

#include <OgreGpuProgram.h>

List of all members.

Public Types

typedef std::vector< AutoConstantEntryAutoConstantList
typedef std::vector< float > FloatConstantList
 Definition of container that holds the current float constants.
typedef std::vector< int > IntConstantList
 Definition of container that holds the current float constants.
typedef ConstVectorIterator<
AutoConstantList
AutoConstantIterator
enum  AutoConstantType {
  ACT_WORLD_MATRIX, ACT_INVERSE_WORLD_MATRIX, ACT_TRANSPOSE_WORLD_MATRIX, ACT_INVERSE_TRANSPOSE_WORLD_MATRIX,
  ACT_WORLD_MATRIX_ARRAY_3x4, ACT_WORLD_MATRIX_ARRAY, ACT_VIEW_MATRIX, ACT_INVERSE_VIEW_MATRIX,
  ACT_TRANSPOSE_VIEW_MATRIX, ACT_INVERSE_TRANSPOSE_VIEW_MATRIX, ACT_PROJECTION_MATRIX, ACT_INVERSE_PROJECTION_MATRIX,
  ACT_TRANSPOSE_PROJECTION_MATRIX, ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX, ACT_VIEWPROJ_MATRIX, ACT_INVERSE_VIEWPROJ_MATRIX,
  ACT_TRANSPOSE_VIEWPROJ_MATRIX, ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX, ACT_WORLDVIEW_MATRIX, ACT_INVERSE_WORLDVIEW_MATRIX,
  ACT_TRANSPOSE_WORLDVIEW_MATRIX, ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX, ACT_WORLDVIEWPROJ_MATRIX, ACT_INVERSE_WORLDVIEWPROJ_MATRIX,
  ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX, ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX, ACT_RENDER_TARGET_FLIPPING, ACT_FOG_COLOUR,
  ACT_FOG_PARAMS, ACT_SURFACE_AMBIENT_COLOUR, ACT_SURFACE_DIFFUSE_COLOUR, ACT_SURFACE_SPECULAR_COLOUR,
  ACT_SURFACE_EMISSIVE_COLOUR, ACT_SURFACE_SHININESS, ACT_AMBIENT_LIGHT_COLOUR, ACT_LIGHT_DIFFUSE_COLOUR,
  ACT_LIGHT_SPECULAR_COLOUR, ACT_LIGHT_ATTENUATION, ACT_SPOTLIGHT_PARAMS, ACT_LIGHT_POSITION,
  ACT_LIGHT_POSITION_OBJECT_SPACE, ACT_LIGHT_POSITION_VIEW_SPACE, ACT_LIGHT_DIRECTION, ACT_LIGHT_DIRECTION_OBJECT_SPACE,
  ACT_LIGHT_DIRECTION_VIEW_SPACE, ACT_LIGHT_DISTANCE_OBJECT_SPACE, ACT_LIGHT_POWER_SCALE, ACT_LIGHT_DIFFUSE_COLOUR_ARRAY,
  ACT_LIGHT_SPECULAR_COLOUR_ARRAY, ACT_LIGHT_ATTENUATION_ARRAY, ACT_LIGHT_POSITION_ARRAY, ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY,
  ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY, ACT_LIGHT_DIRECTION_ARRAY, ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY, ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY,
  ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY, ACT_LIGHT_POWER_SCALE_ARRAY, ACT_SPOTLIGHT_PARAMS_ARRAY, ACT_DERIVED_AMBIENT_LIGHT_COLOUR,
  ACT_DERIVED_SCENE_COLOUR, ACT_DERIVED_LIGHT_DIFFUSE_COLOUR, ACT_DERIVED_LIGHT_SPECULAR_COLOUR, ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY,
  ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY, ACT_SHADOW_EXTRUSION_DISTANCE, ACT_CAMERA_POSITION, ACT_CAMERA_POSITION_OBJECT_SPACE,
  ACT_TEXTURE_VIEWPROJ_MATRIX, ACT_CUSTOM, ACT_TIME, ACT_TIME_0_X,
  ACT_COSTIME_0_X, ACT_SINTIME_0_X, ACT_TANTIME_0_X, ACT_TIME_0_X_PACKED,
  ACT_TIME_0_1, ACT_COSTIME_0_1, ACT_SINTIME_0_1, ACT_TANTIME_0_1,
  ACT_TIME_0_1_PACKED, ACT_TIME_0_2PI, ACT_COSTIME_0_2PI, ACT_SINTIME_0_2PI,
  ACT_TANTIME_0_2PI, ACT_TIME_0_2PI_PACKED, ACT_FRAME_TIME, ACT_FPS,
  ACT_VIEWPORT_WIDTH, ACT_VIEWPORT_HEIGHT, ACT_INVERSE_VIEWPORT_WIDTH, ACT_INVERSE_VIEWPORT_HEIGHT,
  ACT_VIEWPORT_SIZE, ACT_VIEW_DIRECTION, ACT_VIEW_SIDE_VECTOR, ACT_VIEW_UP_VECTOR,
  ACT_FOV, ACT_NEAR_CLIP_DISTANCE, ACT_FAR_CLIP_DISTANCE, ACT_PASS_NUMBER,
  ACT_PASS_ITERATION_NUMBER, ACT_ANIMATION_PARAMETRIC, ACT_TEXEL_OFFSETS, ACT_SCENE_DEPTH_RANGE,
  ACT_SHADOW_SCENE_DEPTH_RANGE, ACT_TEXTURE_SIZE, ACT_INVERSE_TEXTURE_SIZE, ACT_PACKED_TEXTURE_SIZE
}
 Defines the types of automatically updated values that may be bound to GpuProgram parameters, or used to modify parameters on a per-object basis. More...
enum  ACDataType { ACDT_NONE, ACDT_INT, ACDT_REAL }
 Defines the type of the extra data item used by the auto constant. More...
enum  ElementType { ET_INT, ET_REAL }
 Defines the base element type of the auto constant. More...

Public Member Functions

 GpuProgramParameters ()
 ~GpuProgramParameters ()
 GpuProgramParameters (const GpuProgramParameters &oth)
 Copy constructor.
GpuProgramParametersoperator= (const GpuProgramParameters &oth)
 Operator = overload.
void _setNamedConstants (const GpuNamedConstants *constantmap)
 Internal method for providing a link to a name->definition map for parameters.
void _setLogicalIndexes (GpuLogicalBufferStruct *floatIndexMap, GpuLogicalBufferStruct *intIndexMap)
 Internal method for providing a link to a logical index->physical index map for parameters.
bool hasNamedParameters () const
 Does this parameter set include named parameters?
bool hasLogicalIndexedParameters () const
 Does this parameter set include logically indexed parameters?
void setConstant (size_t index, const Vector4 &vec)
 Sets a 4-element floating-point parameter to the program.
void setConstant (size_t index, Real val)
 Sets a single floating-point parameter to the program.
void setConstant (size_t index, const Vector3 &vec)
 Sets a 4-element floating-point parameter to the program via Vector3.
void setConstant (size_t index, const Matrix4 &m)
 Sets a Matrix4 parameter to the program.
void setConstant (size_t index, const Matrix4 *m, size_t numEntries)
 Sets a list of Matrix4 parameters to the program.
void setConstant (size_t index, const float *val, size_t count)
 Sets a multiple value constant floating-point parameter to the program.
void setConstant (size_t index, const double *val, size_t count)
 Sets a multiple value constant floating-point parameter to the program.
void setConstant (size_t index, const ColourValue &colour)
 Sets a ColourValue parameter to the program.
void setConstant (size_t index, const int *val, size_t count)
 Sets a multiple value constant integer parameter to the program.
void _writeRawConstants (size_t physicalIndex, const float *val, size_t count)
 Write a series of floating point values into the underlying float constant buffer at the given physical index.
void _writeRawConstants (size_t physicalIndex, const double *val, size_t count)
 Write a series of floating point values into the underlying float constant buffer at the given physical index.
void _writeRawConstants (size_t physicalIndex, const int *val, size_t count)
 Write a series of integer values into the underlying integer constant buffer at the given physical index.
void _readRawConstants (size_t physicalIndex, size_t count, float *dest)
 Read a series of floating point values from the underlying float constant buffer at the given physical index.
void _readRawConstants (size_t physicalIndex, size_t count, int *dest)
 Read a series of integer values from the underlying integer constant buffer at the given physical index.
void _writeRawConstant (size_t physicalIndex, const Vector4 &vec, size_t count=4)
 Write a 4-element floating-point parameter to the program directly to the underlying constants buffer.
void _writeRawConstant (size_t physicalIndex, Real val)
 Write a single floating-point parameter to the program.
void _writeRawConstant (size_t physicalIndex, int val)
 Write a single integer parameter to the program.
void _writeRawConstant (size_t physicalIndex, const Vector3 &vec)
 Write a 3-element floating-point parameter to the program via Vector3.
void _writeRawConstant (size_t physicalIndex, const Matrix4 &m)
 Write a Matrix4 parameter to the program.
void _writeRawConstant (size_t physicalIndex, const Matrix4 *m, size_t numEntries)
 Write a list of Matrix4 parameters to the program.
void _writeRawConstant (size_t physicalIndex, const ColourValue &colour, size_t count=4)
 Write a ColourValue parameter to the program.
GpuConstantDefinitionIterator getConstantDefinitionIterator (void) const
 Gets an iterator over the named GpuConstantDefinition instances as defined by the program for which these parameters exist.
const GpuConstantDefinitiongetConstantDefinition (const String &name) const
 Get a specific GpuConstantDefinition for a named parameter.
const GpuNamedConstantsgetConstantDefinitions () const
 Get the full list of GpuConstantDefinition instances.
const GpuLogicalBufferStructgetFloatLogicalBufferStruct () const
 Get the current list of mappings from low-level logical param indexes to physical buffer locations in the float buffer.
size_t getFloatLogicalIndexForPhysicalIndex (size_t physicalIndex)
 Retrieves the logical index relating to a physical index in the float buffer, for programs which support that (low-level programs and high-level programs which use logical parameter indexes).
size_t getIntLogicalIndexForPhysicalIndex (size_t physicalIndex)
 Retrieves the logical index relating to a physical index in the int buffer, for programs which support that (low-level programs and high-level programs which use logical parameter indexes).
const GpuLogicalBufferStructgetIntLogicalBufferStruct () const
 Get the current list of mappings from low-level logical param indexes to physical buffer locations in the integer buffer.
const FloatConstantListgetFloatConstantList () const
 Get a reference to the list of float constants.
float * getFloatPointer (size_t pos)
 Get a pointer to the 'nth' item in the float buffer.
const float * getFloatPointer (size_t pos) const
 Get a pointer to the 'nth' item in the float buffer.
const IntConstantListgetIntConstantList () const
 Get a reference to the list of int constants.
int * getIntPointer (size_t pos)
 Get a pointer to the 'nth' item in the int buffer.
const int * getIntPointer (size_t pos) const
 Get a pointer to the 'nth' item in the int buffer.
const AutoConstantListgetAutoConstantList () const
 Get a reference to the list of auto constant bindings.
void setAutoConstant (size_t index, AutoConstantType acType, size_t extraInfo=0)
 Sets up a constant which will automatically be updated by the system.
void setAutoConstantReal (size_t index, AutoConstantType acType, Real rData)
void _setRawAutoConstant (size_t physicalIndex, AutoConstantType acType, size_t extraInfo, size_t elementSize=4)
 As setAutoConstant, but sets up the auto constant directly against a physical buffer index.
void _setRawAutoConstantReal (size_t physicalIndex, AutoConstantType acType, Real rData, size_t elementSize=4)
 As setAutoConstantReal, but sets up the auto constant directly against a physical buffer index.
void clearAutoConstant (size_t index)
 Unbind an auto constant so that the constant is manually controlled again.
void setConstantFromTime (size_t index, Real factor)
 Sets a named parameter up to track a derivation of the current time.
void clearAutoConstants (void)
 Clears all the existing automatic constants.
AutoConstantIterator getAutoConstantIterator (void) const
 Gets an iterator over the automatic constant bindings currently in place.
size_t getAutoConstantCount (void) const
 Gets the number of int constants that have been set.
AutoConstantEntrygetAutoConstantEntry (const size_t index)
 Gets a specific Auto Constant entry if index is in valid range otherwise returns a NULL.
bool hasAutoConstants (void) const
 Returns true if this instance has any automatic constants.
const AutoConstantEntryfindFloatAutoConstantEntry (size_t logicalIndex)
 Finds an auto constant that's affecting a given logical parameter index for floating-point values.
const AutoConstantEntryfindIntAutoConstantEntry (size_t logicalIndex)
 Finds an auto constant that's affecting a given logical parameter index for integer values.
const AutoConstantEntryfindAutoConstantEntry (const String &paramName)
 Finds an auto constant that's affecting a given named parameter index.
const AutoConstantEntry_findRawAutoConstantEntryFloat (size_t physicalIndex)
 Finds an auto constant that's affecting a given physical position in the floating-point buffer.
const AutoConstantEntry_findRawAutoConstantEntryInt (size_t physicalIndex)
 Finds an auto constant that's affecting a given physical position in the integer buffer.
void _updateAutoParamsNoLights (const AutoParamDataSource &source)
 Updates the automatic parameters (except lights) based on the details provided.
void _updateAutoParamsLightsOnly (const AutoParamDataSource &source)
 Updates the automatic parameters for lights based on the details provided.
void setIgnoreMissingParams (bool state)
 Tells the program whether to ignore missing parameters or not.
void setNamedConstant (const String &name, Real val)
 Sets a single value constant floating-point parameter to the program.
void setNamedConstant (const String &name, int val)
 Sets a single value constant integer parameter to the program.
void setNamedConstant (const String &name, const Vector4 &vec)
 Sets a Vector4 parameter to the program.
void setNamedConstant (const String &name, const Vector3 &vec)
 Sets a Vector3 parameter to the program.
void setNamedConstant (const String &name, const Matrix4 &m)
 Sets a Matrix4 parameter to the program.
void setNamedConstant (const String &name, const Matrix4 *m, size_t numEntries)
 Sets a list of Matrix4 parameters to the program.
void setNamedConstant (const String &name, const float *val, size_t count, size_t multiple=4)
 Sets a multiple value constant floating-point parameter to the program.
void setNamedConstant (const String &name, const double *val, size_t count, size_t multiple=4)
 Sets a multiple value constant floating-point parameter to the program.
void setNamedConstant (const String &name, const ColourValue &colour)
 Sets a ColourValue parameter to the program.
void setNamedConstant (const String &name, const int *val, size_t count, size_t multiple=4)
 Sets a multiple value constant floating-point parameter to the program.
void setNamedAutoConstant (const String &name, AutoConstantType acType, size_t extraInfo=0)
 Sets up a constant which will automatically be updated by the system.
void setNamedAutoConstantReal (const String &name, AutoConstantType acType, Real rData)
void setNamedConstantFromTime (const String &name, Real factor)
 Sets a named parameter up to track a derivation of the current time.
void clearNamedAutoConstant (const String &name)
 Unbind an auto constant so that the constant is manually controlled again.
const GpuConstantDefinition_findNamedConstantDefinition (const String &name, bool throwExceptionIfMissing=false) const
 Find a constant definition for a named parameter.
size_t _getFloatConstantPhysicalIndex (size_t logicalIndex, size_t requestedSize)
 Gets the physical buffer index associated with a logical float constant index.
size_t _getIntConstantPhysicalIndex (size_t logicalIndex, size_t requestedSize)
 Gets the physical buffer index associated with a logical int constant index.
void setTransposeMatrices (bool val)
 Sets whether or not we need to transpose the matrices passed in from the rest of OGRE.
bool getTransposeMatrices (void) const
 Gets whether or not matrices are to be transposed when set.
void copyConstantsFrom (const GpuProgramParameters &source)
 Copies the values of all constants (including auto constants) from another GpuProgramParameters object.
void incPassIterationNumber (void)
 increments the multipass number entry by 1 if it exists
bool hasPassIterationNumber () const
 Does this parameters object have a pass iteration number constant?
size_t getPassIterationNumberIndex () const
 Get the physical buffer index of the pass iteration number constant.

Static Public Member Functions

static const AutoConstantDefinitiongetAutoConstantDefinition (const String &name)
 gets the auto constant definition associated with name if found else returns NULL
static const AutoConstantDefinitiongetAutoConstantDefinition (const size_t idx)
 gets the auto constant definition using an index into the auto constant definition array.
static size_t getNumAutoConstantDefinitions (void)
 Returns the number of auto constant definitions.

Protected Attributes

FloatConstantList mFloatConstants
 Packed list of floating-point constants (physical indexing).
IntConstantList mIntConstants
 Packed list of integer constants (physical indexing).
GpuLogicalBufferStructmFloatLogicalToPhysical
 Logical index to physical index map - for low-level programs or high-level programs which pass params this way.
GpuLogicalBufferStructmIntLogicalToPhysical
 Logical index to physical index map - for low-level programs or high-level programs which pass params this way.
const GpuNamedConstantsmNamedConstants
 Mapping from parameter names to def - high-level programs are expected to populate this.
AutoConstantList mAutoConstants
 List of automatically updated parameters.
bool mTransposeMatrices
 Do we need to transpose matrices?
bool mIgnoreMissingParams
 flag to indicate if names not found will be ignored
size_t mActivePassIterationIndex
 physical index for active pass iteration parameter real constant entry;

Static Protected Attributes

static AutoConstantDefinition AutoConstantDictionary []

Classes

struct  AutoConstantDefinition
 Structure defining an auto constant that's available for use in a parameters object. More...
class  AutoConstantEntry
 Structure recording the use of an automatic parameter. More...


Detailed Description

Collects together the program parameters used for a GpuProgram.

Remarks:
Gpu program state includes constant parameters used by the program, and bindings to render system state which is propagated into the constants by the engine automatically if requested.
GpuProgramParameters objects should be created through the GpuProgram and may be shared between multiple Pass instances. For this reason they are managed using a shared pointer, which will ensure they are automatically deleted when no Pass is using them anymore.
High-level programs use named parameters (uniforms), low-level programs use indexed constants. This class supports both, but you can tell whether named constants are supported by calling hasNamedParameters(). There are references in the documentation below to 'logical' and 'physical' indexes; logical indexes are the indexes used by low-level programs and represent indexes into an array of float4's, some of which may be settable, some of which may be predefined constants in the program. We only store those constants which have actually been set, therefore our buffer could have gaps if we used the logical indexes in our own buffers. So instead we map these logical indexes to physical indexes in our buffer. When using high-level programs, logical indexes don't necessarily exist, although they might if the high-level program has a direct, exposed mapping from parameter names to logical indexes. In addition, high-level languages may or may not pack arrays of elements that are smaller than float4 (e.g. float2/vec2) contiguously. This kind of information is held in the ConstantDefinition structure which is only populated for high-level programs. You don't have to worry about any of this unless you intend to read parameters back from this structure rather than just setting them.

Definition at line 224 of file OgreGpuProgram.h.


Member Typedef Documentation

typedef ConstVectorIterator<AutoConstantList> Ogre::GpuProgramParameters::AutoConstantIterator
 

Definition at line 1018 of file OgreGpuProgram.h.

typedef std::vector<AutoConstantEntry> Ogre::GpuProgramParameters::AutoConstantList
 

Definition at line 682 of file OgreGpuProgram.h.

typedef std::vector<float> Ogre::GpuProgramParameters::FloatConstantList
 

Definition of container that holds the current float constants.

Note:
Not necessarily in direct index order to constant indexes, logical to physical index map is derived from GpuProgram

Definition at line 688 of file OgreGpuProgram.h.

typedef std::vector<int> Ogre::GpuProgramParameters::IntConstantList
 

Definition of container that holds the current float constants.

Note:
Not necessarily in direct index order to constant indexes, logical to physical index map is derived from GpuProgram

Definition at line 693 of file OgreGpuProgram.h.


Member Enumeration Documentation

enum Ogre::GpuProgramParameters::ACDataType
 

Defines the type of the extra data item used by the auto constant.

Enumeration values:
ACDT_NONE  no data is required
ACDT_INT  the auto constant requires data of type int
ACDT_REAL  the auto constant requires data of type real

Definition at line 615 of file OgreGpuProgram.h.

enum Ogre::GpuProgramParameters::AutoConstantType
 

Defines the types of automatically updated values that may be bound to GpuProgram parameters, or used to modify parameters on a per-object basis.

Enumeration values:
ACT_WORLD_MATRIX  The current world matrix.
ACT_INVERSE_WORLD_MATRIX  The current world matrix, inverted.
ACT_TRANSPOSE_WORLD_MATRIX  Provides transpose of world matrix.

Equivalent to RenderMonkey's "WorldTranspose".

ACT_INVERSE_TRANSPOSE_WORLD_MATRIX  The current world matrix, inverted & transposed.
ACT_WORLD_MATRIX_ARRAY_3x4  The current array of world matrices, as a 3x4 matrix, used for blending.
ACT_WORLD_MATRIX_ARRAY  The current array of world matrices, used for blending.
ACT_VIEW_MATRIX  The current view matrix.
ACT_INVERSE_VIEW_MATRIX  The current view matrix, inverted.
ACT_TRANSPOSE_VIEW_MATRIX  Provides transpose of view matrix.

Equivalent to RenderMonkey's "ViewTranspose".

ACT_INVERSE_TRANSPOSE_VIEW_MATRIX  Provides inverse transpose of view matrix.

Equivalent to RenderMonkey's "ViewInverseTranspose".

ACT_PROJECTION_MATRIX  The current projection matrix.
ACT_INVERSE_PROJECTION_MATRIX  Provides inverse of projection matrix.

Equivalent to RenderMonkey's "ProjectionInverse".

ACT_TRANSPOSE_PROJECTION_MATRIX  Provides transpose of projection matrix.

Equivalent to RenderMonkey's "ProjectionTranspose".

ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX  Provides inverse transpose of projection matrix.

Equivalent to RenderMonkey's "ProjectionInverseTranspose".

ACT_VIEWPROJ_MATRIX  The current view & projection matrices concatenated.
ACT_INVERSE_VIEWPROJ_MATRIX  Provides inverse of concatenated view and projection matrices.

Equivalent to RenderMonkey's "ViewProjectionInverse".

ACT_TRANSPOSE_VIEWPROJ_MATRIX  Provides transpose of concatenated view and projection matrices.

Equivalent to RenderMonkey's "ViewProjectionTranspose".

ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX  Provides inverse transpose of concatenated view and projection matrices.

Equivalent to RenderMonkey's "ViewProjectionInverseTranspose".

ACT_WORLDVIEW_MATRIX  The current world & view matrices concatenated.
ACT_INVERSE_WORLDVIEW_MATRIX  The current world & view matrices concatenated, then inverted.
ACT_TRANSPOSE_WORLDVIEW_MATRIX  Provides transpose of concatenated world and view matrices.

Equivalent to RenderMonkey's "WorldViewTranspose".

ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX  The current world & view matrices concatenated, then inverted & tranposed.
ACT_WORLDVIEWPROJ_MATRIX  view matrices. The current world, view & projection matrices concatenated
ACT_INVERSE_WORLDVIEWPROJ_MATRIX  Provides inverse of concatenated world, view and projection matrices.

Equivalent to RenderMonkey's "WorldViewProjectionInverse".

ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX  Provides transpose of concatenated world, view and projection matrices.

Equivalent to RenderMonkey's "WorldViewProjectionTranspose".

ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX  Provides inverse transpose of concatenated world, view and projection matrices.

Equivalent to RenderMonkey's "WorldViewProjectionInverseTranspose".

ACT_RENDER_TARGET_FLIPPING  -1 if requires texture flipping, +1 otherwise.

It's useful when you bypassed projection matrix transform, still able use this value to adjust transformed y position.

ACT_FOG_COLOUR  Fog colour.
ACT_FOG_PARAMS  Fog params: density, linear start, linear end, 1/(end-start).
ACT_SURFACE_AMBIENT_COLOUR  Surface ambient colour, as set in Pass::setAmbient.
ACT_SURFACE_DIFFUSE_COLOUR  Surface diffuse colour, as set in Pass::setDiffuse.
ACT_SURFACE_SPECULAR_COLOUR  Surface specular colour, as set in Pass::setSpecular.
ACT_SURFACE_EMISSIVE_COLOUR  Surface emissive colour, as set in Pass::setSelfIllumination.
ACT_SURFACE_SHININESS  Surface shininess, as set in Pass::setShininess.
ACT_AMBIENT_LIGHT_COLOUR  The ambient light colour set in the scene.
ACT_LIGHT_DIFFUSE_COLOUR  Light diffuse colour (index determined by setAutoConstant call).
ACT_LIGHT_SPECULAR_COLOUR  Light specular colour (index determined by setAutoConstant call).
ACT_LIGHT_ATTENUATION  Light attenuation parameters, Vector4(range, constant, linear, quadric).
ACT_SPOTLIGHT_PARAMS  Spotlight parameters, Vector4(innerFactor, outerFactor, falloff, isSpot) innerFactor and outerFactor are cos(angle/2) The isSpot parameter is 0.0f for non-spotlights, 1.0f for spotlights.

Also for non-spotlights the inner and outer factors are 1 and nearly 1 respectively

ACT_LIGHT_POSITION  A light position in world space (index determined by setAutoConstant call).
ACT_LIGHT_POSITION_OBJECT_SPACE  A light position in object space (index determined by setAutoConstant call).
ACT_LIGHT_POSITION_VIEW_SPACE  A light position in view space (index determined by setAutoConstant call).
ACT_LIGHT_DIRECTION  A light direction in world space (index determined by setAutoConstant call).
ACT_LIGHT_DIRECTION_OBJECT_SPACE  A light direction in object space (index determined by setAutoConstant call).
ACT_LIGHT_DIRECTION_VIEW_SPACE  A light direction in view space (index determined by setAutoConstant call).
ACT_LIGHT_DISTANCE_OBJECT_SPACE  The distance of the light from the center of the object a useful approximation as an alternative to per-vertex distance calculations.

ACT_LIGHT_POWER_SCALE  Light power level, a single scalar as set in Light::setPowerScale (index determined by setAutoConstant call).
ACT_LIGHT_DIFFUSE_COLOUR_ARRAY  Array of light diffuse colours (count set by extra param).
ACT_LIGHT_SPECULAR_COLOUR_ARRAY  Array of light specular colours (count set by extra param).
ACT_LIGHT_ATTENUATION_ARRAY  Array of light attenuation parameters, Vector4(range, constant, linear, quadric) (count set by extra param).
ACT_LIGHT_POSITION_ARRAY  Array of light positions in world space (count set by extra param).
ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY  Array of light positions in object space (count set by extra param).
ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY  Array of light positions in view space (count set by extra param).
ACT_LIGHT_DIRECTION_ARRAY  Array of light directions in world space (count set by extra param).
ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY  Array of light directions in object space (count set by extra param).
ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY  Array of light directions in view space (count set by extra param).
ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY  Array of distances of the lights from the center of the object a useful approximation as an alternative to per-vertex distance calculations.

(count set by extra param)

ACT_LIGHT_POWER_SCALE_ARRAY  Array of light power levels, a single scalar as set in Light::setPowerScale (count set by extra param).
ACT_SPOTLIGHT_PARAMS_ARRAY  Spotlight parameters array of Vector4(innerFactor, outerFactor, falloff, isSpot) innerFactor and outerFactor are cos(angle/2) The isSpot parameter is 0.0f for non-spotlights, 1.0f for spotlights.

Also for non-spotlights the inner and outer factors are 1 and nearly 1 respectively. (count set by extra param)

ACT_DERIVED_AMBIENT_LIGHT_COLOUR  The derived ambient light colour, with 'r', 'g', 'b' components filled with product of surface ambient colour and ambient light colour, respectively, and 'a' component filled with surface ambient alpha component.
ACT_DERIVED_SCENE_COLOUR  The derived scene colour, with 'r', 'g' and 'b' components filled with sum of derived ambient light colour and surface emissive colour, respectively, and 'a' component filled with surface diffuse alpha component.
ACT_DERIVED_LIGHT_DIFFUSE_COLOUR  The derived light diffuse colour (index determined by setAutoConstant call), with 'r', 'g' and 'b' components filled with product of surface diffuse colour and light diffuse colour, respectively, and 'a' component filled with surface diffuse alpha component.
ACT_DERIVED_LIGHT_SPECULAR_COLOUR  The derived light specular colour (index determined by setAutoConstant call), with 'r', 'g' and 'b' components filled with product of surface specular colour and light specular colour, respectively, and 'a' component filled with surface specular alpha component.
ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY  Array of derived light diffuse colours (count set by extra param).
ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY  Array of derived light specular colours (count set by extra param).
ACT_SHADOW_EXTRUSION_DISTANCE  The distance a shadow volume should be extruded when using finite extrusion programs.

ACT_CAMERA_POSITION  The current camera's position in world space.
ACT_CAMERA_POSITION_OBJECT_SPACE  The current camera's position in object space.
ACT_TEXTURE_VIEWPROJ_MATRIX  The view/projection matrix of the assigned texture projection frustum.
ACT_CUSTOM  A custom parameter which will come from the renderable, using 'data' as the identifier.
ACT_TIME  provides current elapsed time
ACT_TIME_0_X  Single float value, which repeats itself based on given as parameter "cycle time".

Equivalent to RenderMonkey's "Time0_X".

ACT_COSTIME_0_X  Cosine of "Time0_X". Equivalent to RenderMonkey's "CosTime0_X".
ACT_SINTIME_0_X  Sine of "Time0_X". Equivalent to RenderMonkey's "SinTime0_X".
ACT_TANTIME_0_X  Tangent of "Time0_X". Equivalent to RenderMonkey's "TanTime0_X".
ACT_TIME_0_X_PACKED  Vector of "Time0_X", "SinTime0_X", "CosTime0_X", "TanTime0_X".

Equivalent to RenderMonkey's "Time0_X_Packed".

ACT_TIME_0_1  Single float value, which represents scaled time value [0..1], which repeats itself based on given as parameter "cycle time".

Equivalent to RenderMonkey's "Time0_1".

ACT_COSTIME_0_1  Cosine of "Time0_1". Equivalent to RenderMonkey's "CosTime0_1".
ACT_SINTIME_0_1  Sine of "Time0_1". Equivalent to RenderMonkey's "SinTime0_1".
ACT_TANTIME_0_1  Tangent of "Time0_1". Equivalent to RenderMonkey's "TanTime0_1".
ACT_TIME_0_1_PACKED  Vector of "Time0_1", "SinTime0_1", "CosTime0_1", "TanTime0_1".

Equivalent to RenderMonkey's "Time0_1_Packed".

ACT_TIME_0_2PI  Single float value, which represents scaled time value [0..2*Pi], which repeats itself based on given as parameter "cycle time".

Equivalent to RenderMonkey's "Time0_2PI".

ACT_COSTIME_0_2PI  Cosine of "Time0_2PI". Equivalent to RenderMonkey's "CosTime0_2PI".
ACT_SINTIME_0_2PI  Sine of "Time0_2PI". Equivalent to RenderMonkey's "SinTime0_2PI".
ACT_TANTIME_0_2PI  Tangent of "Time0_2PI". Equivalent to RenderMonkey's "TanTime0_2PI".
ACT_TIME_0_2PI_PACKED  Vector of "Time0_2PI", "SinTime0_2PI", "CosTime0_2PI", "TanTime0_2PI".

Equivalent to RenderMonkey's "Time0_2PI_Packed".

ACT_FRAME_TIME  provides the scaled frame time, returned as a floating point value.
ACT_FPS  provides the calculated frames per second, returned as a floating point value.
ACT_VIEWPORT_WIDTH  Current viewport width (in pixels) as floating point value.

Equivalent to RenderMonkey's "ViewportWidth".

ACT_VIEWPORT_HEIGHT  Current viewport height (in pixels) as floating point value.

Equivalent to RenderMonkey's "ViewportHeight".

ACT_INVERSE_VIEWPORT_WIDTH  This variable represents 1.0/ViewportWidth.

Equivalent to RenderMonkey's "ViewportWidthInverse".

ACT_INVERSE_VIEWPORT_HEIGHT  This variable represents 1.0/ViewportHeight.

Equivalent to RenderMonkey's "ViewportHeightInverse".

ACT_VIEWPORT_SIZE  Packed of "ViewportWidth", "ViewportHeight", "ViewportWidthInverse", "ViewportHeightInverse".
ACT_VIEW_DIRECTION  This variable provides the view direction vector (world space).

Equivalent to RenderMonkey's "ViewDirection".

ACT_VIEW_SIDE_VECTOR  This variable provides the view side vector (world space).

Equivalent to RenderMonkey's "ViewSideVector".

ACT_VIEW_UP_VECTOR  This variable provides the view up vector (world space).

Equivalent to RenderMonkey's "ViewUpVector".

ACT_FOV  This variable provides the field of view as a floating point value.

Equivalent to RenderMonkey's "FOV".

ACT_NEAR_CLIP_DISTANCE  This variable provides the near clip distance as a floating point value.

Equivalent to RenderMonkey's "NearClipPlane".

ACT_FAR_CLIP_DISTANCE  This variable provides the far clip distance as a floating point value.

Equivalent to RenderMonkey's "FarClipPlane".

ACT_PASS_NUMBER  provides the pass index number within the technique of the active materil.
ACT_PASS_ITERATION_NUMBER  provides the current iteration number of the pass.

The iteration number is the number of times the current render operation has been drawn for the acitve pass.

ACT_ANIMATION_PARAMETRIC  Provides a parametric animation value [0..1], only available where the renderable specifically implements it.

ACT_TEXEL_OFFSETS  Provides the texel offsets required by this rendersystem to map texels to pixels.

Packed as float4(absoluteHorizontalOffset, absoluteVerticalOffset, horizontalOffset / viewportWidth, verticalOffset / viewportHeight)

ACT_SCENE_DEPTH_RANGE  Provides information about the depth range of the scene as viewed from the current camera.

Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)

ACT_SHADOW_SCENE_DEPTH_RANGE  Provides information about the depth range of the scene as viewed from a given shadow camera.

Requires an index parameter which maps to a light index relative to the current light list. Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)

ACT_TEXTURE_SIZE  Provides texture size of the texture unit (index determined by setAutoConstant call).

Packed as float4(width, height, depth, 1)

ACT_INVERSE_TEXTURE_SIZE  Provides inverse texture size of the texture unit (index determined by setAutoConstant call).

Packed as float4(1 / width, 1 / height, 1 / depth, 1)

ACT_PACKED_TEXTURE_SIZE  Provides packed texture size of the texture unit (index determined by setAutoConstant call).

Packed as float4(width, height, 1 / width, 1 / height)

Definition at line 230 of file OgreGpuProgram.h.

enum Ogre::GpuProgramParameters::ElementType
 

Defines the base element type of the auto constant.

Enumeration values:
ET_INT 
ET_REAL 

Definition at line 626 of file OgreGpuProgram.h.


Constructor & Destructor Documentation

Ogre::GpuProgramParameters::GpuProgramParameters  ) 
 

Ogre::GpuProgramParameters::~GpuProgramParameters  ) 
 

Definition at line 720 of file OgreGpuProgram.h.

Ogre::GpuProgramParameters::GpuProgramParameters const GpuProgramParameters oth  ) 
 

Copy constructor.


Member Function Documentation

const GpuConstantDefinition* Ogre::GpuProgramParameters::_findNamedConstantDefinition const String name,
bool  throwExceptionIfMissing = false
const
 

Find a constant definition for a named parameter.

Remarks:
This method returns null if the named parameter did not exist, unlike getConstantDefinition which is more strict; unless you set the last parameter to true.
Parameters:
name The name to look up
throwExceptionIfMissing If set to true, failure to find an entry will throw an exception.

const AutoConstantEntry* Ogre::GpuProgramParameters::_findRawAutoConstantEntryFloat size_t  physicalIndex  ) 
 

Finds an auto constant that's affecting a given physical position in the floating-point buffer.

const AutoConstantEntry* Ogre::GpuProgramParameters::_findRawAutoConstantEntryInt size_t  physicalIndex  ) 
 

Finds an auto constant that's affecting a given physical position in the integer buffer.

size_t Ogre::GpuProgramParameters::_getFloatConstantPhysicalIndex size_t  logicalIndex,
size_t  requestedSize
 

Gets the physical buffer index associated with a logical float constant index.

Note:
Only applicable to low-level programs.
Parameters:
logicalIndex The logical parameter index
requestedSize The requested size - pass 0 to ignore missing entries and return std::numeric_limits<size_t>::max()

size_t Ogre::GpuProgramParameters::_getIntConstantPhysicalIndex size_t  logicalIndex,
size_t  requestedSize
 

Gets the physical buffer index associated with a logical int constant index.

Note:
Only applicable to low-level programs.
Parameters:
logicalIndex The logical parameter index
requestedSize The requested size - pass 0 to ignore missing entries and return std::numeric_limits<size_t>::max()

void Ogre::GpuProgramParameters::_readRawConstants size_t  physicalIndex,
size_t  count,
int *  dest
 

Read a series of integer values from the underlying integer constant buffer at the given physical index.

Parameters:
physicalIndex The buffer position to start reading
count The number of ints to read
dest Pointer to a buffer to receive the values

void Ogre::GpuProgramParameters::_readRawConstants size_t  physicalIndex,
size_t  count,
float *  dest
 

Read a series of floating point values from the underlying float constant buffer at the given physical index.

Parameters:
physicalIndex The buffer position to start reading
count The number of floats to read
dest Pointer to a buffer to receive the values

void Ogre::GpuProgramParameters::_setLogicalIndexes GpuLogicalBufferStruct floatIndexMap,
GpuLogicalBufferStruct intIndexMap
 

Internal method for providing a link to a logical index->physical index map for parameters.

void Ogre::GpuProgramParameters::_setNamedConstants const GpuNamedConstants constantmap  ) 
 

Internal method for providing a link to a name->definition map for parameters.

void Ogre::GpuProgramParameters::_setRawAutoConstant size_t  physicalIndex,
AutoConstantType  acType,
size_t  extraInfo,
size_t  elementSize = 4
 

As setAutoConstant, but sets up the auto constant directly against a physical buffer index.

void Ogre::GpuProgramParameters::_setRawAutoConstantReal size_t  physicalIndex,
AutoConstantType  acType,
Real  rData,
size_t  elementSize = 4
 

As setAutoConstantReal, but sets up the auto constant directly against a physical buffer index.

void Ogre::GpuProgramParameters::_updateAutoParamsLightsOnly const AutoParamDataSource source  ) 
 

Updates the automatic parameters for lights based on the details provided.

void Ogre::GpuProgramParameters::_updateAutoParamsNoLights const AutoParamDataSource source  ) 
 

Updates the automatic parameters (except lights) based on the details provided.

void Ogre::GpuProgramParameters::_writeRawConstant size_t  physicalIndex,
const ColourValue colour,
size_t  count = 4
 

Write a ColourValue parameter to the program.

Note:
You can use these methods if you have already derived the physical constant buffer location, for a slight speed improvement over using the named / logical index versions.
Parameters:
physicalIndex The physical buffer index at which to place the parameter
colour The value to set
count The number of floats to write; if for example the uniform constant 'slot' is smaller than a Vector4

void Ogre::GpuProgramParameters::_writeRawConstant size_t  physicalIndex,
const Matrix4 m,
size_t  numEntries
 

Write a list of Matrix4 parameters to the program.

Note:
You can use these methods if you have already derived the physical constant buffer location, for a slight speed improvement over using the named / logical index versions.
Parameters:
physicalIndex The physical buffer index at which to place the parameter
numEntries Number of Matrix4 entries

void Ogre::GpuProgramParameters::_writeRawConstant size_t  physicalIndex,
const Matrix4 m
 

Write a Matrix4 parameter to the program.

Note:
You can use these methods if you have already derived the physical constant buffer location, for a slight speed improvement over using the named / logical index versions.
Parameters:
physicalIndex The physical buffer index at which to place the parameter
m The value to set

void Ogre::GpuProgramParameters::_writeRawConstant size_t  physicalIndex,
const Vector3 vec
 

Write a 3-element floating-point parameter to the program via Vector3.

Note:
You can use these methods if you have already derived the physical constant buffer location, for a slight speed improvement over using the named / logical index versions.
Parameters:
physicalIndex The physical buffer index at which to place the parameter
vec The value to set

void Ogre::GpuProgramParameters::_writeRawConstant size_t  physicalIndex,
int  val
 

Write a single integer parameter to the program.

Note:
You can use these methods if you have already derived the physical constant buffer location, for a slight speed improvement over using the named / logical index versions.
Parameters:
physicalIndex The physical buffer index at which to place the parameter
val The value to set

void Ogre::GpuProgramParameters::_writeRawConstant size_t  physicalIndex,
Real  val
 

Write a single floating-point parameter to the program.

Note:
You can use these methods if you have already derived the physical constant buffer location, for a slight speed improvement over using the named / logical index versions.
Parameters:
physicalIndex The physical buffer index at which to place the parameter
val The value to set

void Ogre::GpuProgramParameters::_writeRawConstant size_t  physicalIndex,
const Vector4 vec,
size_t  count = 4
 

Write a 4-element floating-point parameter to the program directly to the underlying constants buffer.

Note:
You can use these methods if you have already derived the physical constant buffer location, for a slight speed improvement over using the named / logical index versions.
Parameters:
physicalIndex The physical buffer index at which to place the parameter
vec The value to set
count The number of floats to write; if for example the uniform constant 'slot' is smaller than a Vector4

void Ogre::GpuProgramParameters::_writeRawConstants size_t  physicalIndex,
const int *  val,
size_t  count
 

Write a series of integer values into the underlying integer constant buffer at the given physical index.

Parameters:
physicalIndex The buffer position to start writing
val Pointer to a list of values to write
count The number of ints to write

void Ogre::GpuProgramParameters::_writeRawConstants size_t  physicalIndex,
const double *  val,
size_t  count
 

Write a series of floating point values into the underlying float constant buffer at the given physical index.

Parameters:
physicalIndex The buffer position to start writing
val Pointer to a list of values to write
count The number of floats to write

void Ogre::GpuProgramParameters::_writeRawConstants size_t  physicalIndex,
const float *  val,
size_t  count
 

Write a series of floating point values into the underlying float constant buffer at the given physical index.

Parameters:
physicalIndex The buffer position to start writing
val Pointer to a list of values to write
count The number of floats to write

void Ogre::GpuProgramParameters::clearAutoConstant size_t  index  ) 
 

Unbind an auto constant so that the constant is manually controlled again.

void Ogre::GpuProgramParameters::clearAutoConstants void   ) 
 

Clears all the existing automatic constants.

void Ogre::GpuProgramParameters::clearNamedAutoConstant const String name  ) 
 

Unbind an auto constant so that the constant is manually controlled again.

void Ogre::GpuProgramParameters::copyConstantsFrom const GpuProgramParameters source  ) 
 

Copies the values of all constants (including auto constants) from another GpuProgramParameters object.

const AutoConstantEntry* Ogre::GpuProgramParameters::findAutoConstantEntry const String paramName  ) 
 

Finds an auto constant that's affecting a given named parameter index.

Note:
Only applicable to high-level programs.

const AutoConstantEntry* Ogre::GpuProgramParameters::findFloatAutoConstantEntry size_t  logicalIndex  ) 
 

Finds an auto constant that's affecting a given logical parameter index for floating-point values.

Note:
Only applicable for low-level programs.

const AutoConstantEntry* Ogre::GpuProgramParameters::findIntAutoConstantEntry size_t  logicalIndex  ) 
 

Finds an auto constant that's affecting a given logical parameter index for integer values.

Note:
Only applicable for low-level programs.

size_t Ogre::GpuProgramParameters::getAutoConstantCount void   )  const
 

Gets the number of int constants that have been set.

Definition at line 1022 of file OgreGpuProgram.h.

static const AutoConstantDefinition* Ogre::GpuProgramParameters::getAutoConstantDefinition const size_t  idx  )  [static]
 

gets the auto constant definition using an index into the auto constant definition array.

If the index is out of bounds then NULL is returned;

Parameters:
idx The auto constant index

static const AutoConstantDefinition* Ogre::GpuProgramParameters::getAutoConstantDefinition const String name  )  [static]
 

gets the auto constant definition associated with name if found else returns NULL

Parameters:
name The name of the auto constant

AutoConstantEntry* Ogre::GpuProgramParameters::getAutoConstantEntry const size_t  index  ) 
 

Gets a specific Auto Constant entry if index is in valid range otherwise returns a NULL.

index which entry is to be retrieved

AutoConstantIterator Ogre::GpuProgramParameters::getAutoConstantIterator void   )  const
 

Gets an iterator over the automatic constant bindings currently in place.

const AutoConstantList& Ogre::GpuProgramParameters::getAutoConstantList  )  const
 

Get a reference to the list of auto constant bindings.

Definition at line 977 of file OgreGpuProgram.h.

const GpuConstantDefinition& Ogre::GpuProgramParameters::getConstantDefinition const String name  )  const
 

Get a specific GpuConstantDefinition for a named parameter.

Note:
Only available if this parameters object has named parameters.

GpuConstantDefinitionIterator Ogre::GpuProgramParameters::getConstantDefinitionIterator void   )  const
 

Gets an iterator over the named GpuConstantDefinition instances as defined by the program for which these parameters exist.

Note:
Only available if this parameters object has named parameters.

const GpuNamedConstants& Ogre::GpuProgramParameters::getConstantDefinitions  )  const
 

Get the full list of GpuConstantDefinition instances.

Note:
Only available if this parameters object has named parameters.

const FloatConstantList& Ogre::GpuProgramParameters::getFloatConstantList  )  const
 

Get a reference to the list of float constants.

Definition at line 965 of file OgreGpuProgram.h.

const GpuLogicalBufferStruct* Ogre::GpuProgramParameters::getFloatLogicalBufferStruct  )  const
 

Get the current list of mappings from low-level logical param indexes to physical buffer locations in the float buffer.

Note:
Only applicable to low-level programs.

Definition at line 943 of file OgreGpuProgram.h.

size_t Ogre::GpuProgramParameters::getFloatLogicalIndexForPhysicalIndex size_t  physicalIndex  ) 
 

Retrieves the logical index relating to a physical index in the float buffer, for programs which support that (low-level programs and high-level programs which use logical parameter indexes).

Returns:
std::numeric_limits<size_t>::max() if not found

const float* Ogre::GpuProgramParameters::getFloatPointer size_t  pos  )  const
 

Get a pointer to the 'nth' item in the float buffer.

Definition at line 969 of file OgreGpuProgram.h.

float* Ogre::GpuProgramParameters::getFloatPointer size_t  pos  ) 
 

Get a pointer to the 'nth' item in the float buffer.

Definition at line 967 of file OgreGpuProgram.h.

const IntConstantList& Ogre::GpuProgramParameters::getIntConstantList  )  const
 

Get a reference to the list of int constants.

Definition at line 971 of file OgreGpuProgram.h.

const GpuLogicalBufferStruct* Ogre::GpuProgramParameters::getIntLogicalBufferStruct  )  const
 

Get the current list of mappings from low-level logical param indexes to physical buffer locations in the integer buffer.

Note:
Only applicable to low-level programs.

Definition at line 963 of file OgreGpuProgram.h.

size_t Ogre::GpuProgramParameters::getIntLogicalIndexForPhysicalIndex size_t  physicalIndex  ) 
 

Retrieves the logical index relating to a physical index in the int buffer, for programs which support that (low-level programs and high-level programs which use logical parameter indexes).

Returns:
std::numeric_limits<size_t>::max() if not found

const int* Ogre::GpuProgramParameters::getIntPointer size_t  pos  )  const
 

Get a pointer to the 'nth' item in the int buffer.

Definition at line 975 of file OgreGpuProgram.h.

int* Ogre::GpuProgramParameters::getIntPointer size_t  pos  ) 
 

Get a pointer to the 'nth' item in the int buffer.

Definition at line 973 of file OgreGpuProgram.h.

static size_t Ogre::GpuProgramParameters::getNumAutoConstantDefinitions void   )  [static]
 

Returns the number of auto constant definitions.

size_t Ogre::GpuProgramParameters::getPassIterationNumberIndex  )  const
 

Get the physical buffer index of the pass iteration number constant.

Definition at line 1287 of file OgreGpuProgram.h.

bool Ogre::GpuProgramParameters::getTransposeMatrices void   )  const
 

Gets whether or not matrices are to be transposed when set.

Definition at line 1259 of file OgreGpuProgram.h.

bool Ogre::GpuProgramParameters::hasAutoConstants void   )  const
 

Returns true if this instance has any automatic constants.

Definition at line 1029 of file OgreGpuProgram.h.

bool Ogre::GpuProgramParameters::hasLogicalIndexedParameters  )  const
 

Does this parameter set include logically indexed parameters?

Note:
Not mutually exclusive with hasNamedParameters since some high-level programs still use logical indexes to set the parameters on the rendersystem.

Definition at line 742 of file OgreGpuProgram.h.

bool Ogre::GpuProgramParameters::hasNamedParameters  )  const
 

Does this parameter set include named parameters?

Definition at line 736 of file OgreGpuProgram.h.

bool Ogre::GpuProgramParameters::hasPassIterationNumber  )  const
 

Does this parameters object have a pass iteration number constant?

Definition at line 1284 of file OgreGpuProgram.h.

void Ogre::GpuProgramParameters::incPassIterationNumber void   ) 
 

increments the multipass number entry by 1 if it exists

GpuProgramParameters& Ogre::GpuProgramParameters::operator= const GpuProgramParameters oth  ) 
 

Operator = overload.

void Ogre::GpuProgramParameters::setAutoConstant size_t  index,
AutoConstantType  acType,
size_t  extraInfo = 0
 

Sets up a constant which will automatically be updated by the system.

Remarks:
Vertex and fragment programs often need parameters which are to do with the current render state, or particular values which may very well change over time, and often between objects which are being rendered. This feature allows you to set up a certain number of predefined parameter mappings that are kept up to date for you.
Parameters:
index The location in the constant list to place this updated constant every time it is changed. Note that because of the nature of the types, we know how big the parameter details will be so you don't need to set that like you do for manual constants.
acType The type of automatic constant to set
extraInfo If the constant type needs more information (like a light index) put it here.

void Ogre::GpuProgramParameters::setAutoConstantReal size_t  index,
AutoConstantType  acType,
Real  rData
 

void Ogre::GpuProgramParameters::setConstant size_t  index,
const int *  val,
size_t  count
 

Sets a multiple value constant integer parameter to the program.

Remarks:
Different types of GPU programs support different types of constant parameters. For example, it's relatively common to find that vertex programs only support floating point constants, and that fragment programs only support integer (fixed point) parameters. This can vary depending on the program version supported by the graphics card being used. You should consult the documentation for the type of low level program you are using, or alternatively use the methods provided on RenderSystemCapabilities to determine the options.
Parameters:
index The logical constant index at which to place the parameter (each constant is a 4D integer)
val Pointer to the values to write, must contain 4*count ints
count The number of groups of 4 ints to write

void Ogre::GpuProgramParameters::setConstant size_t  index,
const ColourValue colour
 

Sets a ColourValue parameter to the program.

Parameters:
index The logical constant index at which to place the parameter (each constant is a 4D float)
colour The value to set

void Ogre::GpuProgramParameters::setConstant size_t  index,
const double *  val,
size_t  count
 

Sets a multiple value constant floating-point parameter to the program.

Parameters:
index The logical constant index at which to start placing parameters (each constant is a 4D float)
val Pointer to the values to write, must contain 4*count floats
count The number of groups of 4 floats to write

void Ogre::GpuProgramParameters::setConstant size_t  index,
const float *  val,
size_t  count
 

Sets a multiple value constant floating-point parameter to the program.

Parameters:
index The logical constant index at which to start placing parameters (each constant is a 4D float)
val Pointer to the values to write, must contain 4*count floats
count The number of groups of 4 floats to write

void Ogre::GpuProgramParameters::setConstant size_t  index,
const Matrix4 m,
size_t  numEntries
 

Sets a list of Matrix4 parameters to the program.

Parameters:
index The logical constant index at which to start placing the parameter (each constant is a 4D float). NB since a Matrix4 is 16 floats long, so each entry will take up 4 indexes.
m Pointer to an array of matrices to set
numEntries Number of Matrix4 entries

void Ogre::GpuProgramParameters::setConstant size_t  index,
const Matrix4 m
 

Sets a Matrix4 parameter to the program.

Parameters:
index The logical constant index at which to place the parameter (each constant is a 4D float). NB since a Matrix4 is 16 floats long, this parameter will take up 4 indexes.
m The value to set

void Ogre::GpuProgramParameters::setConstant size_t  index,
const Vector3 vec
 

Sets a 4-element floating-point parameter to the program via Vector3.

Parameters:
index The logical constant index at which to place the parameter (each constant is a 4D float). Note that since you're passing a Vector3, the last element of the 4-element value will be set to 1 (a homogenous vector)
vec The value to set

void Ogre::GpuProgramParameters::setConstant size_t  index,
Real  val
 

Sets a single floating-point parameter to the program.

Note:
This is actually equivalent to calling setConstant(index Vector4(val, 0, 0, 0)) since all constants are 4D.
Parameters:
index The logical constant index at which to place the parameter (each constant is a 4D float)
val The value to set

void Ogre::GpuProgramParameters::setConstant size_t  index,
const Vector4 vec
 

Sets a 4-element floating-point parameter to the program.

Parameters:
index The logical constant index at which to place the parameter (each constant is a 4D float)
vec The value to set

void Ogre::GpuProgramParameters::setConstantFromTime size_t  index,
Real  factor
 

Sets a named parameter up to track a derivation of the current time.

Parameters:
index The index of the parameter
factor The amount by which to scale the time value

void Ogre::GpuProgramParameters::setIgnoreMissingParams bool  state  ) 
 

Tells the program whether to ignore missing parameters or not.

Definition at line 1060 of file OgreGpuProgram.h.

void Ogre::GpuProgramParameters::setNamedAutoConstant const String name,
AutoConstantType  acType,
size_t  extraInfo = 0
 

Sets up a constant which will automatically be updated by the system.

Remarks:
Vertex and fragment programs often need parameters which are to do with the current render state, or particular values which may very well change over time, and often between objects which are being rendered. This feature allows you to set up a certain number of predefined parameter mappings that are kept up to date for you.
Note:
This named option will only work if you are using a parameters object created from a high-level program (HighLevelGpuProgram).
Parameters:
name The name of the parameter
acType The type of automatic constant to set
extraInfo If the constant type needs more information (like a light index) put it here.

void Ogre::GpuProgramParameters::setNamedAutoConstantReal const String name,
AutoConstantType  acType,
Real  rData
 

void Ogre::GpuProgramParameters::setNamedConstant const String name,
const int *  val,
size_t  count,
size_t  multiple = 4
 

Sets a multiple value constant floating-point parameter to the program.

Some systems only allow constants to be set on certain boundaries, e.g. in sets of 4 values for example. The 'multiple' parameter allows you to control that although you should only change it if you know your chosen language supports that (at the time of writing, only GLSL allows constants which are not a multiple of 4).
Note:
This named option will only work if you are using a parameters object created from a high-level program (HighLevelGpuProgram).
Parameters:
name The name of the parameter
val Pointer to the values to write
count The number of 'multiples' of floats to write
multiple The number of raw entries in each element to write, the default is 4 so count = 1 would write 4 floats.

void Ogre::GpuProgramParameters::setNamedConstant const String name,
const ColourValue colour
 

Sets a ColourValue parameter to the program.

Parameters:
name The name of the parameter
colour The value to set

void Ogre::GpuProgramParameters::setNamedConstant const String name,
const double *  val,
size_t  count,
size_t  multiple = 4
 

Sets a multiple value constant floating-point parameter to the program.

Some systems only allow constants to be set on certain boundaries, e.g. in sets of 4 values for example. The 'multiple' parameter allows you to control that although you should only change it if you know your chosen language supports that (at the time of writing, only GLSL allows constants which are not a multiple of 4).
Note:
This named option will only work if you are using a parameters object created from a high-level program (HighLevelGpuProgram).
Parameters:
name The name of the parameter
val Pointer to the values to write
count The number of 'multiples' of floats to write
multiple The number of raw entries in each element to write, the default is 4 so count = 1 would write 4 floats.

void Ogre::GpuProgramParameters::setNamedConstant const String name,
const float *  val,
size_t  count,
size_t  multiple = 4
 

Sets a multiple value constant floating-point parameter to the program.

Some systems only allow constants to be set on certain boundaries, e.g. in sets of 4 values for example. The 'multiple' parameter allows you to control that although you should only change it if you know your chosen language supports that (at the time of writing, only GLSL allows constants which are not a multiple of 4).
Note:
This named option will only work if you are using a parameters object created from a high-level program (HighLevelGpuProgram).
Parameters:
name The name of the parameter
val Pointer to the values to write
count The number of 'multiples' of floats to write
multiple The number of raw entries in each element to write, the default is 4 so count = 1 would write 4 floats.

void Ogre::GpuProgramParameters::setNamedConstant const String name,
const Matrix4 m,
size_t  numEntries
 

Sets a list of Matrix4 parameters to the program.

Parameters:
name The name of the parameter; this must be the first index of an array, for examples 'matrices[0]' NB since a Matrix4 is 16 floats long, so each entry will take up 4 indexes.
m Pointer to an array of matrices to set
numEntries Number of Matrix4 entries

void Ogre::GpuProgramParameters::setNamedConstant const String name,
const Matrix4 m
 

Sets a Matrix4 parameter to the program.

Parameters:
name The name of the parameter
m The value to set

void Ogre::GpuProgramParameters::setNamedConstant const String name,
const Vector3 vec
 

Sets a Vector3 parameter to the program.

Note:
This named option will only work if you are using a parameters object created from a high-level program (HighLevelGpuProgram).
Parameters:
index The index at which to place the parameter NB this index refers to the number of floats, so a Vector3 is 3. Note that many rendersystems & programs assume that every floating point parameter is passed in as a vector of 4 items, so you are strongly advised to check with RenderSystemCapabilities before using this version - if in doubt use Vector4 or ColourValue instead (both are 4D).
vec The value to set

void Ogre::GpuProgramParameters::setNamedConstant const String name,
const Vector4 vec
 

Sets a Vector4 parameter to the program.

Parameters:
name The name of the parameter
vec The value to set

void Ogre::GpuProgramParameters::setNamedConstant const String name,
int  val
 

Sets a single value constant integer parameter to the program.

Remarks:
Different types of GPU programs support different types of constant parameters. For example, it's relatively common to find that vertex programs only support floating point constants, and that fragment programs only support integer (fixed point) parameters. This can vary depending on the program version supported by the graphics card being used. You should consult the documentation for the type of low level program you are using, or alternatively use the methods provided on RenderSystemCapabilities to determine the options.
Another possible limitation is that some systems only allow constants to be set on certain boundaries, e.g. in sets of 4 values for example. Again, see RenderSystemCapabilities for full details.
Note:
This named option will only work if you are using a parameters object created from a high-level program (HighLevelGpuProgram).
Parameters:
name The name of the parameter
val The value to set

void Ogre::GpuProgramParameters::setNamedConstant const String name,
Real  val
 

Sets a single value constant floating-point parameter to the program.

Remarks:
Different types of GPU programs support different types of constant parameters. For example, it's relatively common to find that vertex programs only support floating point constants, and that fragment programs only support integer (fixed point) parameters. This can vary depending on the program version supported by the graphics card being used. You should consult the documentation for the type of low level program you are using, or alternatively use the methods provided on RenderSystemCapabilities to determine the options.
Another possible limitation is that some systems only allow constants to be set on certain boundaries, e.g. in sets of 4 values for example. Again, see RenderSystemCapabilities for full details.
Note:
This named option will only work if you are using a parameters object created from a high-level program (HighLevelGpuProgram).
Parameters:
name The name of the parameter
val The value to set

void Ogre::GpuProgramParameters::setNamedConstantFromTime const String name,
Real  factor
 

Sets a named parameter up to track a derivation of the current time.

Note:
This named option will only work if you are using a parameters object created from a high-level program (HighLevelGpuProgram).
Parameters:
name The name of the parameter
factor The amount by which to scale the time value

void Ogre::GpuProgramParameters::setTransposeMatrices bool  val  ) 
 

Sets whether or not we need to transpose the matrices passed in from the rest of OGRE.

Remarks:
D3D uses transposed matrices compared to GL and OGRE; this is not important when you use programs which are written to process row-major matrices, such as those generated by Cg, but if you use a program written to D3D's matrix layout you will need to enable this flag.

Definition at line 1257 of file OgreGpuProgram.h.


Member Data Documentation

AutoConstantDefinition Ogre::GpuProgramParameters::AutoConstantDictionary[] [static, protected]
 

Definition at line 696 of file OgreGpuProgram.h.

size_t Ogre::GpuProgramParameters::mActivePassIterationIndex [protected]
 

physical index for active pass iteration parameter real constant entry;

Definition at line 716 of file OgreGpuProgram.h.

AutoConstantList Ogre::GpuProgramParameters::mAutoConstants [protected]
 

List of automatically updated parameters.

Definition at line 710 of file OgreGpuProgram.h.

FloatConstantList Ogre::GpuProgramParameters::mFloatConstants [protected]
 

Packed list of floating-point constants (physical indexing).

Definition at line 698 of file OgreGpuProgram.h.

GpuLogicalBufferStruct* Ogre::GpuProgramParameters::mFloatLogicalToPhysical [protected]
 

Logical index to physical index map - for low-level programs or high-level programs which pass params this way.

Definition at line 703 of file OgreGpuProgram.h.

bool Ogre::GpuProgramParameters::mIgnoreMissingParams [protected]
 

flag to indicate if names not found will be ignored

Definition at line 714 of file OgreGpuProgram.h.

IntConstantList Ogre::GpuProgramParameters::mIntConstants [protected]
 

Packed list of integer constants (physical indexing).

Definition at line 700 of file OgreGpuProgram.h.

GpuLogicalBufferStruct* Ogre::GpuProgramParameters::mIntLogicalToPhysical [protected]
 

Logical index to physical index map - for low-level programs or high-level programs which pass params this way.

Definition at line 706 of file OgreGpuProgram.h.

const GpuNamedConstants* Ogre::GpuProgramParameters::mNamedConstants [protected]
 

Mapping from parameter names to def - high-level programs are expected to populate this.

Definition at line 708 of file OgreGpuProgram.h.

bool Ogre::GpuProgramParameters::mTransposeMatrices [protected]
 

Do we need to transpose matrices?

Definition at line 712 of file OgreGpuProgram.h.


The documentation for this class was generated from the following file:

Copyright © 2000-2005 by The OGRE Team
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Thu Dec 27 15:19:49 2007