28 #ifndef __GpuProgramParams_H_
29 #define __GpuProgramParams_H_
122 return isFloat(constType);
148 return isSampler(constType);
174 if (padToMultiplesOf4)
255 , physicalIndex((std::numeric_limits<size_t>::max)())
286 void generateConstantDefinitionArrayEntries(
const String& paramName,
290 static bool getGenerateAllConstantDefinitionArrayEntries();
298 static void setGenerateAllConstantDefinitionArrayEntries(
bool generateAll);
303 void save(
const String& filename)
const;
327 Endian endianMode = ENDIAN_NATIVE);
344 : physicalIndex(99999), currentSize(0), variability(
GPV_GLOBAL) {}
346 : physicalIndex(bufIdx), currentSize(curSz), variability(v) {}
422 void removeConstantDefinition(
const String& name);
426 void removeAllConstantDefinitions();
456 void setNamedConstant(
const String& name,
Real val);
458 void setNamedConstant(
const String& name,
int val);
460 void setNamedConstant(
const String& name,
const Vector4& vec);
462 void setNamedConstant(
const String& name,
const Vector3& vec);
466 void setNamedConstant(
const String& name,
const Matrix4* m,
size_t numEntries);
468 void setNamedConstant(
const String& name,
const float *val,
size_t count);
470 void setNamedConstant(
const String& name,
const double *val,
size_t count);
474 void setNamedConstant(
const String& name,
const int *val,
size_t count);
481 int*
getIntPointer(
size_t pos) { _markDirty();
return &mIntConstants[pos]; }
538 void _copySharedParamsToTargetParams();
1069 :acType(_acType), name(_name), elementCount(_elementCount),
1070 elementType(_elementType), dataType(_dataType)
1097 uint16 theVariability,
size_t theElemCount = 4)
1098 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount),
1099 data(theData), variability(theVariability) {}
1102 uint16 theVariability,
size_t theElemCount = 4)
1103 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount),
1104 fData(theData), variability(theVariability) {}
1139 GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(
size_t logicalIndex,
size_t requestedSize,
uint16 variability);
1187 void setConstant(
size_t index,
const Vector4& vec);
1195 void setConstant(
size_t index,
Real val);
1203 void setConstant(
size_t index,
const Vector3& vec);
1210 void setConstant(
size_t index,
const Matrix4& m);
1218 void setConstant(
size_t index,
const Matrix4* m,
size_t numEntries);
1225 void setConstant(
size_t index,
const float *val,
size_t count);
1232 void setConstant(
size_t index,
const double *val,
size_t count);
1238 void setConstant(
size_t index,
const ColourValue& colour);
1254 void setConstant(
size_t index,
const int *val,
size_t count);
1262 void _writeRawConstants(
size_t physicalIndex,
const float* val,
size_t count);
1269 void _writeRawConstants(
size_t physicalIndex,
const double* val,
size_t count);
1276 void _writeRawConstants(
size_t physicalIndex,
const int* val,
size_t count);
1283 void _readRawConstants(
size_t physicalIndex,
size_t count,
float* dest);
1290 void _readRawConstants(
size_t physicalIndex,
size_t count,
int* dest);
1302 void _writeRawConstant(
size_t physicalIndex,
const Vector4& vec,
1311 void _writeRawConstant(
size_t physicalIndex,
Real val);
1319 void _writeRawConstant(
size_t physicalIndex,
int val);
1327 void _writeRawConstant(
size_t physicalIndex,
const Vector3& vec);
1336 void _writeRawConstant(
size_t physicalIndex,
const Matrix4& m,
size_t elementCount);
1344 void _writeRawConstant(
size_t physicalIndex,
const Matrix4* m,
size_t numEntries);
1354 void _writeRawConstant(
size_t physicalIndex,
const ColourValue& colour,
1389 size_t getFloatLogicalIndexForPhysicalIndex(
size_t physicalIndex);
1395 size_t getIntLogicalIndexForPhysicalIndex(
size_t physicalIndex);
1431 void setAutoConstant(
size_t index, AutoConstantType acType,
size_t extraInfo = 0);
1432 void setAutoConstantReal(
size_t index, AutoConstantType acType,
Real rData);
1448 void setAutoConstant(
size_t index, AutoConstantType acType,
uint16 extraInfo1,
uint16 extraInfo2);
1453 void _setRawAutoConstant(
size_t physicalIndex, AutoConstantType acType,
size_t extraInfo,
1454 uint16 variability,
size_t elementSize = 4);
1458 void _setRawAutoConstantReal(
size_t physicalIndex, AutoConstantType acType,
Real rData,
1459 uint16 variability,
size_t elementSize = 4);
1463 void clearAutoConstant(
size_t index);
1469 void setConstantFromTime(
size_t index,
Real factor);
1472 void clearAutoConstants(
void);
1482 AutoConstantEntry* getAutoConstantEntry(
const size_t index);
1489 const AutoConstantEntry* findFloatAutoConstantEntry(
size_t logicalIndex);
1494 const AutoConstantEntry* findIntAutoConstantEntry(
size_t logicalIndex);
1498 const AutoConstantEntry* findAutoConstantEntry(
const String& paramName);
1502 const AutoConstantEntry* _findRawAutoConstantEntryFloat(
size_t physicalIndex);
1506 const AutoConstantEntry* _findRawAutoConstantEntryInt(
size_t physicalIndex);
1537 void setNamedConstant(
const String& name,
Real val);
1557 void setNamedConstant(
const String& name,
int val);
1562 void setNamedConstant(
const String& name,
const Vector4& vec);
1575 void setNamedConstant(
const String& name,
const Vector3& vec);
1580 void setNamedConstant(
const String& name,
const Matrix4& m);
1588 void setNamedConstant(
const String& name,
const Matrix4* m,
size_t numEntries);
1605 void setNamedConstant(
const String& name,
const float *val,
size_t count,
1606 size_t multiple = 4);
1623 void setNamedConstant(
const String& name,
const double *val,
size_t count,
1624 size_t multiple = 4);
1647 void setNamedConstant(
const String& name,
const int *val,
size_t count,
1648 size_t multiple = 4);
1664 void setNamedAutoConstant(
const String& name, AutoConstantType acType,
size_t extraInfo = 0);
1665 void setNamedAutoConstantReal(
const String& name, AutoConstantType acType,
Real rData);
1682 void setNamedAutoConstant(
const String& name, AutoConstantType acType,
uint16 extraInfo1,
uint16 extraInfo2);
1691 void setNamedConstantFromTime(
const String& name,
Real factor);
1694 void clearNamedAutoConstant(
const String& name);
1706 const String& name,
bool throwExceptionIfMissing =
false)
const;
1713 size_t _getFloatConstantPhysicalIndex(
size_t logicalIndex,
size_t requestedSize,
uint16 variability);
1720 size_t _getIntConstantPhysicalIndex(
size_t logicalIndex,
size_t requestedSize,
uint16 variability);
1754 static const AutoConstantDefinition* getAutoConstantDefinition(
const String& name);
1759 static const AutoConstantDefinition* getAutoConstantDefinition(
const size_t idx);
1762 static size_t getNumAutoConstantDefinitions(
void);
1767 void incPassIterationNumber(
void);
1770 {
return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); }
1773 {
return mActivePassIterationIndex; }
1790 void addSharedParameters(
const String& sharedParamsName);
1793 bool isUsingSharedParameters(
const String& sharedParamsName)
const;
1796 void removeSharedParameters(
const String& sharedParamsName);
1799 void removeAllSharedParameters();
1802 const GpuSharedParamUsageList& getSharedParameters()
const;
1816 void _copySharedParams();
Array of light diffuse colours scaled by light power (count set by extra param)
The derived scene colour, with 'r', 'g' and 'b' components filled with sum of derived ambient light c...
The current view & projection matrices concatenated.
Sine of "Time0_1". Equivalent to RenderMonkey's "SinTime0_1".
static bool isFloat(GpuConstantType c)
size_t intBufferSize
Total size of the int buffer required.
uint16 mCombinedVariability
The combined variability masks of all parameters.
Class encapsulating a standard 4x4 homogeneous matrix.
GpuConstantDefinitionMap map
Map of parameter names to GpuConstantDefinition.
bool mIgnoreMissingParams
flag to indicate if names not found will be ignored
The ambient light colour set in the scene.
The current world matrix, inverted & transposed.
const Any & _getRenderSystemData() const
Internal method that the RenderSystem might use to store optional data.
unsigned long getVersion() const
Get the version number of this shared parameter set, can be used to identify when changes have occurr...
size_t elementSize
Number of raw buffer slots per element (some programs pack each array element to float4, some do not)
static size_t getElementSize(GpuConstantType ctype, bool padToMultiplesOf4)
Get the element size of a given type, including whether to pad the elements into multiples of 4 (e...
GpuLogicalIndexUse(size_t bufIdx, size_t curSz, uint16 v)
size_t mFrameLastUpdated
Not used when copying data, but might be useful to RS using shared buffers.
Structure recording the use of a physical buffer by a logical parameter index.
size_t mActivePassIterationIndex
physical index for active pass iteration parameter real constant entry;
float Real
Software floating point type.
This variable provides the view side vector (world space).
Array of light attenuation parameters, Vector4(range, constant, linear, quadric) (count set by extra ...
render target related values
const float * getFloatPointer(size_t pos) const
Get a pointer to the 'nth' item in the float buffer.
size_t elementCount
The number of elements per individual entry in this constant Used in case people used packed elements...
This variable represents 1.0/ViewportHeight.
Provides information about the depth range of the scene as viewed from the current camera...
Single float value, which represents scaled time value [0..1], which repeats itself based on given as...
Variant type that can hold Any other type.
Cosine of "Time0_1". Equivalent to RenderMonkey's "CosTime0_1".
GpuProgramParameters * mParams
size_t logicalIndex
Logical index - used to communicate this constant to the rendersystem.
A light position in object space (index determined by setAutoConstant call)
Array of view/projection matrices of the first n texture projection frustums.
Provides transpose of concatenated view and projection matrices.
This variable provides the far clip distance as a floating point value.
size_t getAutoConstantCount(void) const
Gets the number of int constants that have been set.
Generic class for serialising data to / from binary stream-based files.
The current world & view matrices concatenated, then inverted & transposed.
Fog params: density, linear start, linear end, 1/(end-start)
Provides transpose of world matrix.
Array of distances of the lights from the center of the object a useful approximation as an alternati...
The distance of the light from the center of the object a useful approximation as an alternative to p...
float * getFloatPointer(size_t pos)
Get a pointer to the 'nth' item in the float buffer.
GpuParamVariability
The variability of a GPU parameter, as derived from auto-params targetting it.
Array of derived light specular colours (count set by extra param)
Class representing colour.
A custom parameter which will come from the renderable, using 'data' as the identifier.
size_t floatBufferSize
Total size of the float buffer required.
IntConstantList mIntConstants
Packed list of integer constants (physical indexing)
Provides the fixed shadow colour as configured via SceneManager::setShadowColour; useful for integrat...
Provides inverse transpose of view matrix.
The view/projection matrix of the assigned texture projection frustum, combined with the current worl...
A light position in view space (index determined by setAutoConstant call)
The current camera's position in object space.
const Any & _getRenderSystemData() const
Internal method that the RenderSystem might use to store optional data.
Provides the position of the LOD camera in world space, allowing you to perform separate LOD calculat...
vector< GpuSharedParametersUsage >::type GpuSharedParamUsageList
void setTransposeMatrices(bool val)
Sets whether or not we need to transpose the matrices passed in from the rest of OGRE.
AutoConstantType paramType
The type of parameter.
Array of light directions in world space (count set by extra param)
const GpuConstantDefinition * srcDefinition
SharedPtr< GpuProgramParameters > GpuProgramParametersSharedPtr
Shared pointer used to hold references to GpuProgramParameters instances.
Surface specular colour, as set in Pass::setSpecular.
Single float value, which repeats itself based on given as parameter "cycle time".
Surface shininess, as set in Pass::setShininess.
Provides inverse of concatenated view and projection matrices.
A group of manually updated parameters that are shared between many parameter sets.
GpuSharedParametersPtr getSharedParams() const
The view/projection matrix of a given spotlight projection frustum, combined with the current world m...
static bool msGenerateAllConstantDefinitionArrayEntries
Indicates whether all array entries will be generated and added to the definitions map...
size_t physicalIndex
Physical start index in buffer (either float or int buffer)
AutoConstantList mAutoConstants
List of automatically updated parameters.
const GpuConstantDefinition * dstDefinition
bool getTransposeMatrices(void) const
Gets whether or not matrices are to be transposed when set.
void _setRenderSystemData(const Any &data) const
Internal method that the RenderSystem might use to store optional data.
This variable provides the view up vector (world space).
The distance a shadow volume should be extruded when using finite extrusion programs.
Provides transpose of view matrix.
ACDataType
Defines the type of the extra data item used by the auto constant.
Provides texture size of the texture unit (index determined by setAutoConstant call).
A light position in world space (index determined by setAutoConstant call)
GpuSharedParametersPtr mSharedParams
GpuConstantType constType
Data type.
Surface ambient colour, as set in Pass::setAmbient.
uint16 variability
The variability of this parameter (see GpuParamVariability)
The derived light specular colour (index determined by setAutoConstant call), with 'r'...
Array of light specular colours scaled by light power (count set by extra param)
Returns (int) 1 if the given light casts shadows, 0 otherwise (index set in extra param) ...
bool mTransposeMatrices
Do we need to transpose matrices?
Sine of "Time0_2PI". Equivalent to RenderMonkey's "SinTime0_2PI".
The current array of world matrices, used for blending.
A light direction in object space (index determined by setAutoConstant call)
Provides inverse of concatenated world, view and projection matrices.
Structure recording the use of an automatic parameter.
Array of view/projection matrix of a given spotlight.
This variable provides the near clip distance as a floating point value.
GpuSharedParamUsageList mSharedParamSets
Provides the texel offsets required by this rendersystem to map texels to pixels. ...
provides the calculated frames per second, returned as a floating point value.
The view/projection matrix of the assigned texture projection frustum.
AutoConstantType
Defines the types of automatically updated values that may be bound to GpuProgram parameters...
vector< AutoConstantEntry >::type AutoConstantList
The derived light diffuse colour (index determined by setAutoConstant call), with 'r'...
Array of light specular colours (count set by extra param)
bool hasNamedParameters() const
Does this parameter set include named parameters?
Provides inverse of projection matrix.
Array of light power levels, a single scalar as set in Light::setPowerScale (count set by extra param...
Cosine of "Time0_X". Equivalent to RenderMonkey's "CosTime0_X".
map< size_t, GpuLogicalIndexUse >::type GpuLogicalIndexUseMap
Vector of "Time0_X", "SinTime0_X", "CosTime0_X", "TanTime0_X".
GpuConstantType
Enumeration of the types of constant we may encounter in programs.
provides the current iteration number of the pass.
size_t currentSize
Current physical size allocation.
Light power level, a single scalar as set in Light::setPowerScale (index determined by setAutoConstan...
ConstVectorIterator< AutoConstantList > AutoConstantIterator
static bool isSampler(GpuConstantType c)
bool hasLogicalIndexedParameters() const
Does this parameter set include logically indexed parameters?
vector< CopyDataEntry >::type CopyDataList
size_t physicalIndex
Physical buffer index.
const AutoConstantList & getAutoConstantList() const
Get a reference to the list of auto constant bindings.
Structure defining an auto constant that's available for use in a parameters object.
GpuLogicalBufferStructPtr mIntLogicalToPhysical
Logical index to physical index map - for low-level programs or high-level programs which pass params...
Container struct to allow params to safely & update shared list of logical buffer assignments...
Struct collecting together the information for named constants.
Endian
The endianness of written files.
Concrete IteratorWrapper for const access to the underlying container.
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
The current projection matrix.
Collects together the program parameters used for a GpuProgram.
Tangent of "Time0_1". Equivalent to RenderMonkey's "TanTime0_1".
const IntConstantList & getIntConstantList() const
Get a reference to the list of int constants.
AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, uint16 theVariability, size_t theElemCount=4)
SharedPtr< GpuNamedConstants > GpuNamedConstantsPtr
This variable represents 1.0/ViewportWidth.
CopyDataList mCopyDataList
float * getFloatPointer(size_t pos)
Get a pointer to the 'nth' item in the float buffer.
uint16 variability
How this parameter varies (bitwise combination of GpuProgramVariability)
Surface emissive colour, as set in Pass::setSelfIllumination.
the auto constant requires data of type int
Array of light diffuse colours (count set by extra param)
Provides transpose of concatenated world and view matrices.
The current world & view matrices concatenated, then inverted.
const String & getName()
Get the name of this shared parameter set.
The derived ambient light colour, with 'r', 'g', 'b' components filled with product of surface ambien...
The view/projection matrix of a given spotlight.
GpuProgramParameters * getTargetParams() const
uint16 variability
How the contents of this slot vary.
void setIgnoreMissingParams(bool state)
Tells the program whether to ignore missing parameters or not.
Array of light positions in world space (count set by extra param)
Light specular colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call) ...
The current world matrix, inverted.
Light diffuse colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call) ...
Standard 3-dimensional vector.
Provides information about the depth range of the scene as viewed from a given shadow camera...
bool hasAutoConstants(void) const
Returns true if this instance has any automatic constants.
The current view matrix, inverted.
Varies per object (based on an auto param usually), but not per light setup.
Light specular colour (index determined by setAutoConstant call)
void _setRenderSystemData(const Any &data) const
Internal method that the RenderSystem might use to store optional data.
void _setRenderSystemData(const Any &data) const
Internal method that the RenderSystem might use to store optional data.
Varies with pass iteration number.
-1 if the winding has been inverted (e.g.
This variable provides the field of view as a floating point value.
int * getIntPointer(size_t pos)
Get a pointer to the 'nth' item in the int buffer.
Surface diffuse colour, as set in Pass::setDiffuse.
Array of world/view/projection matrices of the first n texture projection frustums.
Light attenuation parameters, Vector4(range, constant, linear, quadric)
const GpuLogicalBufferStructPtr & getFloatLogicalBufferStruct() const
Get the current list of mappings from low-level logical param indexes to physical buffer locations in...
Cosine of "Time0_2PI". Equivalent to RenderMonkey's "CosTime0_2PI".
const float * getFloatPointer(size_t pos) const
Get a pointer to the 'nth' item in the float buffer.
Sine of "Time0_X". Equivalent to RenderMonkey's "SinTime0_X".
No variation except by manual setting - the default.
FloatConstantList mFloatConstants
SharedPtr< GpuLogicalBufferStruct > GpuLogicalBufferStructPtr
Array of light directions in view space (count set by extra param)
const String & getName() const
Get the name of the shared parameter set.
unsigned long mCopyDataVersion
Version of shared params we based the copydata on.
Packed of "ViewportWidth", "ViewportHeight", "ViewportWidthInverse", "ViewportHeightInverse".
AutoConstantDefinition(AutoConstantType _acType, const String &_name, size_t _elementCount, ElementType _elementType, ACDataType _dataType)
map< String, GpuConstantDefinition >::type GpuConstantDefinitionMap
provides current elapsed time
Array of light positions in object space (count set by extra param)
Concrete IteratorWrapper for const access to the underlying key-value container.
size_t arraySize
Length of array.
Single float value, which represents scaled time value [0..2*Pi], which repeats itself based on given...
A light direction in world space (index determined by setAutoConstant call)
provides the pass index number within the technique of the active materil.
Provides the position of the LOD camera in object space, allowing you to perform separate LOD calcula...
Provides the current transform matrix of the texture unit (index determined by setAutoConstant call)...
vector< int >::type IntConstantList
Definition of container that holds the current float constants.
size_t getFrameLastUpdated() const
Get the frame in which this shared parameter set was last updated.
The current array of world matrices, as a 3x4 matrix, used for blending.
The number of active light sources (better than gl_MaxLights)
AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, uint16 theVariability, size_t theElemCount=4)
GpuNamedConstantsPtr mNamedConstants
Mapping from parameter names to def - high-level programs are expected to populate this...
Information about predefined program constants.
Vector of "Time0_1", "SinTime0_1", "CosTime0_1", "TanTime0_1".
The current world matrix.
SharedPtr< GpuSharedParameters > GpuSharedParametersPtr
Shared pointer used to hold references to GpuProgramParameters instances.
Provides packed texture size of the texture unit (index determined by setAutoConstant call)...
size_t getPassIterationNumberIndex() const
Get the physical buffer index of the pass iteration number constant.
vector< float >::type FloatConstantList
Definition of container that holds the current float constants.
unsigned long mVersion
Version number of the definitions in this buffer.
ConstMapIterator< GpuConstantDefinitionMap > GpuConstantDefinitionIterator
ACDataType dataType
The type of any extra data.
GpuNamedConstants mNamedConstants
4-dimensional homogeneous vector.
Provides transpose of projection matrix.
ElementType
Defines the base element type of the auto constant.
provides the scaled frame time, returned as a floating point value.
Provides a parametric animation value [0..1], only available where the renderable specifically implem...
int * getIntPointer(size_t pos)
Get a pointer to the 'nth' item in the int buffer.
GpuLogicalBufferStructPtr mFloatLogicalToPhysical
Logical index to physical index map - for low-level programs or high-level programs which pass params...
bool hasPassIterationNumber() const
Does this parameters object have a pass iteration number constant?
Provides transpose of concatenated world, view and projection matrices.
Tangent of "Time0_2PI". Equivalent to RenderMonkey's "TanTime0_2PI".
Array of light directions in object space (count set by extra param)
Tangent of "Time0_X". Equivalent to RenderMonkey's "TanTime0_X".
ElementType elementType
The type of the constant in the program.
const FloatConstantList & getFloatConstantList() const
Get a reference to the list of float constants.
Array of light positions in view space (count set by extra param)
Light diffuse colour (index determined by setAutoConstant call)
size_t physicalIndex
The target (physical) constant index.
Spotlight parameters, Vector4(innerFactor, outerFactor, falloff, isSpot) innerFactor and outerFactor ...
Provides inverse texture size of the texture unit (index determined by setAutoConstant call)...
This class records the usage of a set of shared parameters in a concrete set of GpuProgramParameters...
Provides inverse transpose of concatenated world, view and projection matrices.
A light direction in view space (index determined by setAutoConstant call)
The absolute light number of a local light index.
const int * getIntPointer(size_t pos) const
Get a pointer to the 'nth' item in the int buffer.
The current camera's position in world space.
The current world & view matrices concatenated.
Array of derived light diffuse colours (count set by extra param)
const Any & _getRenderSystemData() const
Internal method that the RenderSystem might use to store optional data.
This utility class is used to hold the information used to generate the matrices and other informatio...
Simple class for loading / saving GpuNamedConstants.
IntConstantList mIntConstants
const int * getIntPointer(size_t pos) const
Get a pointer to the 'nth' item in the int buffer.
FloatConstantList mFloatConstants
Packed list of floating-point constants (physical indexing)
const GpuLogicalBufferStructPtr & getIntLogicalBufferStruct() const
Get the current list of mappings from low-level logical param indexes to physical buffer locations in...
Spotlight parameters array of Vector4(innerFactor, outerFactor, falloff, isSpot) innerFactor and oute...
Vector of "Time0_2PI", "SinTime0_2PI", "CosTime0_2PI", "TanTime0_2PI".
Current viewport height (in pixels) as floating point value.
Provides inverse transpose of projection matrix.
Provides inverse transpose of concatenated view and projection matrices.