28 #ifndef __GpuProgramParams_H_
29 #define __GpuProgramParams_H_
140 return isFloat(constType);
167 return isDouble(constType);
198 return isSampler(constType);
221 return isSubroutine(constType);
234 if (padToMultiplesOf4)
345 , physicalIndex((
std::numeric_limits<size_t>::max)())
364 GpuConstantDefinitionMap
map;
379 void generateConstantDefinitionArrayEntries(
const String& paramName,
383 static bool getGenerateAllConstantDefinitionArrayEntries();
391 static void setGenerateAllConstantDefinitionArrayEntries(
bool generateAll);
396 void save(
const String& filename)
const;
402 size_t calculateSize(
void)
const;
422 Endian endianMode = ENDIAN_NATIVE);
424 Endian endianMode = ENDIAN_NATIVE);
441 : physicalIndex(99999), currentSize(0), variability(
GPV_GLOBAL) {}
443 : physicalIndex(bufIdx), currentSize(curSz), variability(v) {}
452 GpuLogicalIndexUseMap
map;
526 void removeConstantDefinition(
const String& name);
530 void removeAllConstantDefinitions();
537 size_t calculateSize(
void)
const;
551 GpuConstantDefinitionIterator getConstantDefinitionIterator(
void)
const;
562 void setNamedConstant(
const String& name,
Real val);
564 void setNamedConstant(
const String& name,
int val);
566 void setNamedConstant(
const String& name,
const Vector4& vec);
568 void setNamedConstant(
const String& name,
const Vector3& vec);
570 void setNamedConstant(
const String& name,
const Vector2& vec);
574 void setNamedConstant(
const String& name,
const Matrix4* m,
size_t numEntries);
576 void setNamedConstant(
const String& name,
const float *val,
size_t count);
578 void setNamedConstant(
const String& name,
const double *val,
size_t count);
582 void setNamedConstant(
const String& name,
const int *val,
size_t count);
593 int*
getIntPointer(
size_t pos) { _markDirty();
return &mIntConstants[pos]; }
656 void _copySharedParamsToTargetParams();
1207 :acType(_acType), name(_name), elementCount(_elementCount),
1208 elementType(_elementType), dataType(_dataType)
1235 uint16 theVariability,
size_t theElemCount = 4)
1236 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount),
1237 data(theData), variability(theVariability) {}
1240 uint16 theVariability,
size_t theElemCount = 4)
1241 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount),
1242 fData(theData), variability(theVariability) {}
1288 GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(
size_t logicalIndex,
size_t requestedSize,
uint16 variability);
1291 GpuLogicalIndexUse* _getDoubleConstantLogicalIndexUse(
size_t logicalIndex,
size_t requestedSize,
uint16 variability);
1299 void copySharedParamSetUsage(
const GpuSharedParamUsageList& srcList);
1318 void _setNamedConstants(
const GpuNamedConstantsPtr& constantmap);
1321 void _setLogicalIndexes(
const GpuLogicalBufferStructPtr& floatIndexMap,
const GpuLogicalBufferStructPtr& doubleIndexMap,
1322 const GpuLogicalBufferStructPtr& intIndexMap);
1339 void setConstant(
size_t index,
const Vector4& vec);
1347 void setConstant(
size_t index,
Real val);
1355 void setConstant(
size_t index,
const Vector3& vec);
1363 void setConstant(
size_t index,
const Vector2& vec);
1370 void setConstant(
size_t index,
const Matrix4& m);
1378 void setConstant(
size_t index,
const Matrix4* m,
size_t numEntries);
1385 void setConstant(
size_t index,
const float *val,
size_t count);
1392 void setConstant(
size_t index,
const double *val,
size_t count);
1398 void setConstant(
size_t index,
const ColourValue& colour);
1414 void setConstant(
size_t index,
const int *val,
size_t count);
1422 void _writeRawConstants(
size_t physicalIndex,
const float* val,
size_t count);
1429 void _writeRawConstants(
size_t physicalIndex,
const double* val,
size_t count);
1436 void _writeRawConstants(
size_t physicalIndex,
const int* val,
size_t count);
1443 void _readRawConstants(
size_t physicalIndex,
size_t count,
float* dest);
1450 void _readRawConstants(
size_t physicalIndex,
size_t count,
int* dest);
1462 void _writeRawConstant(
size_t physicalIndex,
const Vector4& vec,
1471 void _writeRawConstant(
size_t physicalIndex,
Real val);
1479 void _writeRawConstant(
size_t physicalIndex,
Real val,
size_t count);
1487 void _writeRawConstant(
size_t physicalIndex,
int val);
1495 void _writeRawConstant(
size_t physicalIndex,
const Vector3& vec);
1503 void _writeRawConstant(
size_t physicalIndex,
const Vector2& vec);
1512 void _writeRawConstant(
size_t physicalIndex,
const Matrix4& m,
size_t elementCount);
1520 void _writeRawConstant(
size_t physicalIndex,
const Matrix4* m,
size_t numEntries);
1530 void _writeRawConstant(
size_t physicalIndex,
const ColourValue& colour,
1539 GpuConstantDefinitionIterator getConstantDefinitionIterator(
void)
const;
1565 size_t getFloatLogicalIndexForPhysicalIndex(
size_t physicalIndex);
1583 size_t getDoubleLogicalIndexForPhysicalIndex(
size_t physicalIndex);
1589 size_t getIntLogicalIndexForPhysicalIndex(
size_t physicalIndex);
1631 void setAutoConstant(
size_t index, AutoConstantType acType,
size_t extraInfo = 0);
1632 void setAutoConstantReal(
size_t index, AutoConstantType acType,
Real rData);
1648 void setAutoConstant(
size_t index, AutoConstantType acType,
uint16 extraInfo1,
uint16 extraInfo2);
1653 void _setRawAutoConstant(
size_t physicalIndex, AutoConstantType acType,
size_t extraInfo,
1654 uint16 variability,
size_t elementSize = 4);
1658 void _setRawAutoConstantReal(
size_t physicalIndex, AutoConstantType acType,
Real rData,
1659 uint16 variability,
size_t elementSize = 4);
1663 void clearAutoConstant(
size_t index);
1669 void setConstantFromTime(
size_t index,
Real factor);
1672 void clearAutoConstants(
void);
1675 AutoConstantIterator getAutoConstantIterator(
void)
const;
1682 AutoConstantEntry* getAutoConstantEntry(
const size_t index);
1689 const AutoConstantEntry* findFloatAutoConstantEntry(
size_t logicalIndex);
1694 const AutoConstantEntry* findDoubleAutoConstantEntry(
size_t logicalIndex);
1699 const AutoConstantEntry* findIntAutoConstantEntry(
size_t logicalIndex);
1703 const AutoConstantEntry* findAutoConstantEntry(
const String& paramName);
1707 const AutoConstantEntry* _findRawAutoConstantEntryFloat(
size_t physicalIndex);
1711 const AutoConstantEntry* _findRawAutoConstantEntryDouble(
size_t physicalIndex);
1715 const AutoConstantEntry* _findRawAutoConstantEntryInt(
size_t physicalIndex);
1746 void setNamedConstant(
const String& name,
Real val);
1766 void setNamedConstant(
const String& name,
int val);
1771 void setNamedConstant(
const String& name,
const Vector4& vec);
1779 void setNamedConstant(
const String& name,
const Vector3& vec);
1784 void setNamedConstant(
const String& name,
const Vector2& vec);
1789 void setNamedConstant(
const String& name,
const Matrix4& m);
1797 void setNamedConstant(
const String& name,
const Matrix4* m,
size_t numEntries);
1814 void setNamedConstant(
const String& name,
const float *val,
size_t count,
1815 size_t multiple = 4);
1832 void setNamedConstant(
const String& name,
const double *val,
size_t count,
1833 size_t multiple = 4);
1856 void setNamedConstant(
const String& name,
const int *val,
size_t count,
1857 size_t multiple = 4);
1873 void setNamedAutoConstant(
const String& name, AutoConstantType acType,
size_t extraInfo = 0);
1874 void setNamedAutoConstantReal(
const String& name, AutoConstantType acType,
Real rData);
1891 void setNamedAutoConstant(
const String& name, AutoConstantType acType,
uint16 extraInfo1,
uint16 extraInfo2);
1900 void setNamedConstantFromTime(
const String& name,
Real factor);
1903 void clearNamedAutoConstant(
const String& name);
1915 const String& name,
bool throwExceptionIfMissing =
false)
const;
1922 size_t _getFloatConstantPhysicalIndex(
size_t logicalIndex,
size_t requestedSize,
uint16 variability);
1929 size_t _getDoubleConstantPhysicalIndex(
size_t logicalIndex,
size_t requestedSize,
uint16 variability);
1936 size_t _getIntConstantPhysicalIndex(
size_t logicalIndex,
size_t requestedSize,
uint16 variability);
1970 static const AutoConstantDefinition* getAutoConstantDefinition(
const String& name);
1975 static const AutoConstantDefinition* getAutoConstantDefinition(
const size_t idx);
1978 static size_t getNumAutoConstantDefinitions(
void);
1983 void incPassIterationNumber(
void);
1986 {
return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); }
1989 {
return mActivePassIterationIndex; }
1997 void addSharedParameters(GpuSharedParametersPtr sharedParams);
2006 void addSharedParameters(
const String& sharedParamsName);
2009 bool isUsingSharedParameters(
const String& sharedParamsName)
const;
2012 void removeSharedParameters(
const String& sharedParamsName);
2015 void removeAllSharedParameters();
2018 const GpuSharedParamUsageList& getSharedParameters()
const;
2032 void _copySharedParams();
2034 size_t calculateSize(
void)
const;
2038 void setNamedSubroutine(
const String& subroutineSlot,
const String& subroutine);
2042 void setSubroutine(
size_t index,
const String& subroutine);
Light diffuse colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call) ...
Cosine of "Time0_2PI". Equivalent to RenderMonkey's "CosTime0_2PI".
size_t logicalIndex
Logical index - used to communicate this constant to the rendersystem.
Array of light positions in world space (count set by extra param)
GpuSharedParamUsageList mSharedParamSets
This variable provides the view up vector (world space).
Provides transpose of concatenated view and projection matrices.
The current array of world matrices transformed to an array of dual quaternions, represented as a 2x4...
int * getIntPointer(size_t pos)
Get a pointer to the 'nth' item in the int buffer.
static bool isSubroutine(GpuConstantType c)
Light specular colour (index determined by setAutoConstant call)
const GpuConstantDefinition * srcDefinition
Array of light power levels, a single scalar as set in Light::setPowerScale (count set by extra param...
Varies with pass iteration number.
GpuConstantDefinitionMap map
Map of parameter names to GpuConstantDefinition.
const DoubleConstantList & getDoubleConstantList() const
Get a reference to the list of double constants.
The current world & view matrices concatenated, then inverted & transposed.
size_t physicalIndex
Physical buffer index.
float * getFloatPointer(size_t pos)
Get a pointer to the 'nth' item in the float buffer.
void _setRenderSystemData(const Any &data) const
Internal method that the RenderSystem might use to store optional data.
GpuLogicalBufferStructPtr mFloatLogicalToPhysical
Logical index to physical index map - for low-level programs or high-level programs which pass params...
HashMap< unsigned int, String > SubroutineMap
Sine of "Time0_1". Equivalent to RenderMonkey's "SinTime0_1".
Tangent of "Time0_X". Equivalent to RenderMonkey's "TanTime0_X".
ConstMapIterator< GpuConstantDefinitionMap > GpuConstantDefinitionIterator
const AutoConstantList & getAutoConstantList() const
Get a reference to the list of auto constant bindings.
GpuParamVariability
The variability of a GPU parameter, as derived from auto-params targeting it.
Generic class for serialising data to / from binary stream-based files.
bool hasNamedParameters() const
Does this parameter set include named parameters?
Provides the position of the LOD camera in world space, allowing you to perform separate LOD calculat...
Array of light specular colours (count set by extra param)
SharedPtr< GpuNamedConstants > GpuNamedConstantsPtr
Structure recording the use of a physical buffer by a logical parameter index.
GpuProgramParameters * getTargetParams() const
The current array of world matrices, used for blending.
The view/projection matrix of a given spotlight.
bool hasPassIterationNumber() const
Does this parameters object have a pass iteration number constant?
The current array of world matrices, as a 3x4 matrix, used for blending.
SharedPtr< GpuSharedParameters > GpuSharedParametersPtr
Shared pointer used to hold references to GpuProgramParameters instances.
Struct collecting together the information for named constants.
GpuLogicalBufferStructPtr mIntLogicalToPhysical
Logical index to physical index map - for low-level programs or high-level programs which pass params...
Array of light directions in world space (count set by extra param)
GpuSharedParametersPtr mSharedParams
Single float value, which repeats itself based on given as parameter "cycle time".
Provides inverse of concatenated view and projection matrices.
The current view matrix, inverted.
Provides inverse transpose of concatenated world, view and projection matrices.
A light direction in view space (index determined by setAutoConstant call)
Vector of "Time0_2PI", "SinTime0_2PI", "CosTime0_2PI", "TanTime0_2PI".
Array of view/projection matrices of the first n texture projection frustums.
const GpuLogicalBufferStructPtr & getIntLogicalBufferStruct() const
Get the current list of mappings from low-level logical param indexes to physical buffer locations in...
size_t doubleBufferSize
Total size of the double buffer required.
FloatConstantList mFloatConstants
Packed list of floating-point constants (physical indexing)
vector< float >::type FloatConstantList
Definition of container that holds the current float constants.
A light position in view space (index determined by setAutoConstant call)
4-dimensional homogeneous vector.
provides the scaled frame time, returned as a floating point value.
Concrete IteratorWrapper for const access to the underlying key-value container.
void _setRenderSystemData(const Any &data) const
Internal method that the RenderSystem might use to store optional data.
Single float value, which represents scaled time value [0..2*Pi], which repeats itself based on given...
IntConstantList mIntConstants
Binds custom per-light constants to the shaders.
Standard 2-dimensional vector.
Simple class for loading / saving GpuNamedConstants.
size_t intBufferSize
Total size of the int buffer required.
Class representing colour.
float Real
Software floating point type.
Cosine of "Time0_1". Equivalent to RenderMonkey's "CosTime0_1".
This variable provides the near clip distance as a floating point value.
size_t physicalIndex
Physical start index in buffer (either float, double or int buffer)
const float * getFloatPointer(size_t pos) const
Get a pointer to the 'nth' item in the float buffer.
const Any & _getRenderSystemData() const
Internal method that the RenderSystem might use to store optional data.
GpuLogicalIndexUse(size_t bufIdx, size_t curSz, uint16 v)
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...
size_t bufferSize
Shortcut to know the buffer size needs.
DoubleConstantList mDoubleConstants
Tangent of "Time0_2PI". Equivalent to RenderMonkey's "TanTime0_2PI".
AutoConstantList mAutoConstants
List of automatically updated parameters.
const GpuLogicalBufferStructPtr & getFloatLogicalBufferStruct() const
Get the current list of mappings from low-level logical param indexes to physical buffer locations in...
Array of light attenuation parameters, Vector4(range, constant, linear, quadric) (count set by extra ...
Surface emissive colour, as set in Pass::setSelfIllumination.
Structure recording the use of an automatic parameter.
bool isSubroutine() const
Provides transpose of view matrix.
This variable provides the view side vector (world space).
Array of light positions in object space (count set by extra param)
This variable represents 1.0/ViewportWidth.
const String & getName()
Get the name of this shared parameter set.
bool hasLogicalIndexedParameters() const
Does this parameter set include logically indexed parameters?
The current world & view matrices concatenated.
provides the pass index number within the technique of the active materil.
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...
A custom parameter which will come from the renderable, using 'data' as the identifier.
vector< CopyDataEntry >::type CopyDataList
unsigned long mVersion
Version number of the definitions in this buffer.
Provides inverse texture size of the texture unit (index determined by setAutoConstant call)...
SharedPtr< GpuProgramParameters > GpuProgramParametersSharedPtr
Shared pointer used to hold references to GpuProgramParameters instances.
Variant type that can hold Any other type.
HashMap< unsigned int, String >::const_iterator SubroutineIterator
Spotlight parameters, Vector4(innerFactor, outerFactor, falloff, isSpot) innerFactor and outerFactor ...
DoubleConstantList mDoubleConstants
Packed list of double-point constants (physical indexing)
int * getIntPointer(size_t pos)
Get a pointer to the 'nth' item in the int buffer.
size_t getAutoConstantCount(void) const
Gets the number of int constants that have been set.
const double * getDoublePointer(size_t pos) const
Get a pointer to the 'nth' item in the double buffer.
Array of derived light diffuse colours (count set by extra param)
Provides transpose of concatenated world and view matrices.
AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, uint16 theVariability, size_t theElemCount=4)
GpuSharedParametersPtr getSharedParams() const
Provides inverse of projection matrix.
size_t physicalIndex
The target (physical) constant index.
GpuProgramParameters * mParams
Provides packed texture size of the texture unit (index determined by setAutoConstant call)...
Class encapsulating a standard 4x4 homogeneous matrix.
Standard 3-dimensional vector.
The derived light specular colour (index determined by setAutoConstant call), with 'r'...
This variable represents 1.0/ViewportHeight.
const FloatConstantList & getFloatConstantList() const
Get a reference to the list of float constants.
A light position in world space (index determined by setAutoConstant call)
Array of light diffuse colours (count set by extra param)
map< String, GpuConstantDefinition >::type GpuConstantDefinitionMap
const SubroutineMap & getSubroutineMap() const
Get map with.
float * getFloatPointer(size_t pos)
Get a pointer to the 'nth' item in the float buffer.
uint16 variability
The variability of this parameter (see GpuParamVariability)
uint16 variability
How the contents of this slot vary.
Returns (int) 1 if the given light casts shadows, 0 otherwise (index set in extra param) ...
double * getDoublePointer(size_t pos)
Get a pointer to the 'nth' item in the double buffer.
size_t getPassIterationNumberIndex() const
Get the physical buffer index of the pass iteration number constant.
The scale and shear components of the current array of world matrices.
const double * getDoublePointer(size_t pos) const
Get a pointer to the 'nth' item in the double buffer.
The derived light diffuse colour (index determined by setAutoConstant call), with 'r'...
Spotlight parameters array of Vector4(innerFactor, outerFactor, falloff, isSpot) innerFactor and oute...
const int * getIntPointer(size_t pos) const
Get a pointer to the 'nth' item in the int buffer.
GpuLogicalBufferStructPtr mDoubleLogicalToPhysical
Logical index to physical index map - for low-level programs or high-level programs which pass params...
Sine of "Time0_2PI". Equivalent to RenderMonkey's "SinTime0_2PI".
FloatConstantList mFloatConstants
ConstVectorIterator< AutoConstantList > AutoConstantIterator
AutoConstantType
Defines the types of automatically updated values that may be bound to GpuProgram parameters...
unsigned long getVersion() const
Get the version number of this shared parameter set, can be used to identify when changes have occurr...
Provides an array of information about the depth range of the scene as viewed from a given shadow cam...
Surface specular colour, as set in Pass::setSpecular.
This class records the usage of a set of shared parameters in a concrete set of GpuProgramParameters...
No variation except by manual setting - the default.
render target related values
Structure defining an auto constant that's available for use in a parameters object.
The absolute light number of a local light index.
CopyDataList mCopyDataList
Provides inverse of concatenated world, view and projection matrices.
Array of view/projection matrix of a given spotlight.
GpuNamedConstantsPtr mNamedConstants
Mapping from parameter names to def - high-level programs are expected to populate this...
SubroutineMap mSubroutineMap
ACDataType
Defines the type of the extra data item used by the auto constant.
The current projection matrix.
ElementType
Defines the base element type of the auto constant.
Single float value, which represents scaled time value [0..1], which repeats itself based on given as...
static bool msGenerateAllConstantDefinitionArrayEntries
Indicates whether all array entries will be generated and added to the definitions map...
The derived scene colour, with 'r', 'g' and 'b' components filled with sum of derived ambient light c...
The number of active light sources (better than gl_MaxLights)
Provides the texel offsets required by this rendersystem to map texels to pixels. ...
double * getDoublePointer(size_t pos)
Get a pointer to the 'nth' item in the double buffer.
ACDataType dataType
The type of any extra data.
Container struct to allow params to safely & update shared list of logical buffer assignments...
the auto constant requires data of type int
unsigned long mCopyDataVersion
Version of shared params we based the copydata on.
ElementType elementType
The type of the constant in the program.
const Any & _getRenderSystemData() const
Internal method that the RenderSystem might use to store optional data.
Surface shininess, as set in Pass::setShininess.
const GpuLogicalBufferStructPtr & getDoubleLogicalBufferStruct() const
Retrieves the logical index relating to a physical index in the int buffer, for programs which suppor...
Array of derived light specular colours (count set by extra param)
A group of manually updated parameters that are shared between many parameter sets.
const GpuConstantDefinition * dstDefinition
Packed of "ViewportWidth", "ViewportHeight", "ViewportWidthInverse", "ViewportHeightInverse".
Provides inverse transpose of projection matrix.
Current viewport height (in pixels) as floating point value.
provides current elapsed time
Light power level, a single scalar as set in Light::setPowerScale (index determined by setAutoConstan...
GpuConstantType constType
Data type.
The current world matrix.
Vector of "Time0_X", "SinTime0_X", "CosTime0_X", "TanTime0_X".
The current view & projection matrices concatenated.
provides the current iteration number of the pass.
This variable provides the field of view as a floating point value.
bool mIgnoreMissingParams
flag to indicate if names not found will be ignored
void setIgnoreMissingParams(bool state)
Tells the program whether to ignore missing parameters or not.
Array of world/view/projection matrices of the first n texture projection frustums.
const int * getIntPointer(size_t pos) const
Get a pointer to the 'nth' item in the int buffer.
vector< AutoConstantEntry >::type AutoConstantList
Provides transpose of projection matrix.
Fog params: density, linear start, linear end, 1/(end-start)
AutoConstantType paramType
The type of parameter.
size_t currentSize
Current physical size allocation.
Endian
The endianness of written files.
The current world matrix, inverted & transposed.
Array of light directions in view space (count set by extra param)
The view/projection matrix of a given spotlight projection frustum, combined with the current world m...
size_t arraySize
Length of array.
static bool isDouble(GpuConstantType c)
A light direction in world space (index determined by setAutoConstant call)
const FloatConstantList & getFloatConstantList() const
Get a reference to the list of float constants.
uint16 variability
How this parameter varies (bitwise combination of GpuProgramVariability)
SharedPtr< GpuLogicalBufferStruct > GpuLogicalBufferStructPtr
vector< double >::type DoubleConstantList
Definition of container that holds the current double constants.
Light diffuse colour (index determined by setAutoConstant call)
Sine of "Time0_X". Equivalent to RenderMonkey's "SinTime0_X".
-1 if the winding has been inverted (e.g.
An array of the view/projection matrix of a given spotlight projection frustum, combined with the cur...
A light position in object space (index determined by setAutoConstant call)
size_t floatBufferSize
Total size of the float buffer required.
const IntConstantList & getIntConstantList() const
Get a reference to the list of int constants.
Provides texture size of the texture unit (index determined by setAutoConstant call).
static bool isFloat(GpuConstantType c)
Provides information about the depth range of the scene as viewed from the current camera...
Surface ambient colour, as set in Pass::setAmbient.
GpuNamedConstants mNamedConstants
The ambient light colour set in the scene.
Provides inverse transpose of view matrix.
void _setRenderSystemData(const Any &data) const
Internal method that the RenderSystem might use to store optional data.
Light attenuation parameters, Vector4(range, constant, linear, quadric)
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.
size_t elementSize
Number of raw buffer slots per element (some programs pack each array element to float4, some do not)
Surface alpha rejection value, not as set in Pass::setAlphaRejectionValue, but a floating number betw...
Provides the fixed shadow colour as configured via SceneManager::setShadowColour; useful for integrat...
Returns (int) 1 if the given light casts shadows, 0 otherwise (index set in extra param) ...
GpuConstantType
Enumeration of the types of constant we may encounter in programs.
The current camera's position in world space.
The current world matrix, inverted.
Concrete IteratorWrapper for const access to the underlying container.
GpuLogicalIndexUseMap map
Map from logical index to physical buffer location.
Provides a parametric animation value [0..1], only available where the renderable specifically implem...
Provides the current transform matrix of the texture unit (index determined by setAutoConstant call)...
const Any & _getRenderSystemData() const
Internal method that the RenderSystem might use to store optional data.
Array of light positions in view space (count set by extra param)
The current world & view matrices concatenated, then inverted.
Array of light specular colours scaled by light power (count set by extra param)
The derived ambient light colour, with 'r', 'g', 'b' components filled with product of surface ambien...
The distance a shadow volume should be extruded when using finite extrusion programs.
Cosine of "Time0_X". Equivalent to RenderMonkey's "CosTime0_X".
The current camera's position in object space.
A light direction in object space (index determined by setAutoConstant call)
bool hasAutoConstants(void) const
Returns true if this instance has any automatic constants.
Provides the position of the LOD camera in object space, allowing you to perform separate LOD calcula...
size_t getFrameLastUpdated() const
Get the frame in which this shared parameter set was last updated.
AutoConstantDefinition(AutoConstantType _acType, const String &_name, size_t _elementCount, ElementType _elementType, ACDataType _dataType)
Provides inverse transpose of concatenated view and projection matrices.
Information about predefined program constants.
This utility class is used to hold the information used to generate the matrices and other informatio...
Array of distances of the lights from the center of the object a useful approximation as an alternati...
vector< int >::type IntConstantList
Definition of container that holds the current float constants.
AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, uint16 theVariability, size_t theElemCount=4)
Light specular colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call) ...
Array of light directions in object space (count set by extra param)
The view/projection matrix of the assigned texture projection frustum, combined with the current worl...
Provides transpose of world matrix.
Vector of "Time0_1", "SinTime0_1", "CosTime0_1", "TanTime0_1".
const String & getName() const
Get the name of the shared parameter set.
size_t mActivePassIterationIndex
physical index for active pass iteration parameter real constant entry;
Array of light diffuse colours scaled by light power (count set by extra param)
Varies per object (based on an auto param usually), but not per light setup.
Tangent of "Time0_1". Equivalent to RenderMonkey's "TanTime0_1".
This variable provides the far clip distance as a floating point value.
bool getTransposeMatrices(void) const
Gets whether or not matrices are to be transposed when set.
The distance of the light from the center of the object a useful approximation as an alternative to p...
size_t mFrameLastUpdated
Not used when copying data, but might be useful to RS using shared buffers.
provides the calculated frames per second, returned as a floating point value.
Provides information about the depth range of the scene as viewed from a given shadow camera...
Surface diffuse colour, as set in Pass::setDiffuse.
const DoubleConstantList & getDoubleConstantList() const
Get a reference to the list of double constants.
IntConstantList mIntConstants
Packed list of integer constants (physical indexing)
map< size_t, GpuLogicalIndexUse >::type GpuLogicalIndexUseMap
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
The view/projection matrix of the assigned texture projection frustum.
Collects together the program parameters used for a GpuProgram.
Provides transpose of concatenated world, view and projection matrices.
const IntConstantList & getIntConstantList() const
Get a reference to the list of int constants.
uint16 mCombinedVariability
The combined variability masks of all parameters.
static bool isSampler(GpuConstantType c)
bool mTransposeMatrices
Do we need to transpose matrices?