00001 /* 00002 ----------------------------------------------------------------------------- 00003 This source file is part of OGRE 00004 (Object-oriented Graphics Rendering Engine) 00005 For the latest info, see http://www.ogre3d.org 00006 00007 Copyright (c) 2000-2009 Torus Knot Software Ltd 00008 00009 Permission is hereby granted, free of charge, to any person obtaining a copy 00010 of this software and associated documentation files (the "Software"), to deal 00011 in the Software without restriction, including without limitation the rights 00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 00013 copies of the Software, and to permit persons to whom the Software is 00014 furnished to do so, subject to the following conditions: 00015 00016 The above copyright notice and this permission notice shall be included in 00017 all copies or substantial portions of the Software. 00018 00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 00025 THE SOFTWARE. 00026 ----------------------------------------------------------------------------- 00027 */ 00028 #ifndef __GpuProgramParams_H_ 00029 #define __GpuProgramParams_H_ 00030 00031 // Precompiler options 00032 #include "OgrePrerequisites.h" 00033 #include "OgreSharedPtr.h" 00034 #include "OgreIteratorWrappers.h" 00035 #include "OgreSerializer.h" 00036 #include "OgreRenderOperation.h" 00037 #include "OgreAny.h" 00038 00039 namespace Ogre { 00040 00052 enum GpuConstantType 00053 { 00054 GCT_FLOAT1 = 1, 00055 GCT_FLOAT2 = 2, 00056 GCT_FLOAT3 = 3, 00057 GCT_FLOAT4 = 4, 00058 GCT_SAMPLER1D = 5, 00059 GCT_SAMPLER2D = 6, 00060 GCT_SAMPLER3D = 7, 00061 GCT_SAMPLERCUBE = 8, 00062 GCT_SAMPLER1DSHADOW = 9, 00063 GCT_SAMPLER2DSHADOW = 10, 00064 GCT_MATRIX_2X2 = 11, 00065 GCT_MATRIX_2X3 = 12, 00066 GCT_MATRIX_2X4 = 13, 00067 GCT_MATRIX_3X2 = 14, 00068 GCT_MATRIX_3X3 = 15, 00069 GCT_MATRIX_3X4 = 16, 00070 GCT_MATRIX_4X2 = 17, 00071 GCT_MATRIX_4X3 = 18, 00072 GCT_MATRIX_4X4 = 19, 00073 GCT_INT1 = 20, 00074 GCT_INT2 = 21, 00075 GCT_INT3 = 22, 00076 GCT_INT4 = 23, 00077 GCT_UNKNOWN = 99 00078 }; 00079 00083 enum GpuParamVariability 00084 { 00086 GPV_GLOBAL = 1, 00088 GPV_PER_OBJECT = 2, 00090 GPV_LIGHTS = 4, 00092 GPV_PASS_ITERATION_NUMBER = 8, 00093 00094 00096 GPV_ALL = 0xFFFF 00097 00098 }; 00099 00104 struct _OgreExport GpuConstantDefinition 00105 { 00107 GpuConstantType constType; 00109 size_t physicalIndex; 00111 size_t logicalIndex; 00114 size_t elementSize; 00116 size_t arraySize; 00118 mutable uint16 variability; 00119 00120 bool isFloat() const 00121 { 00122 return isFloat(constType); 00123 } 00124 00125 static bool isFloat(GpuConstantType c) 00126 { 00127 switch(c) 00128 { 00129 case GCT_INT1: 00130 case GCT_INT2: 00131 case GCT_INT3: 00132 case GCT_INT4: 00133 case GCT_SAMPLER1D: 00134 case GCT_SAMPLER2D: 00135 case GCT_SAMPLER3D: 00136 case GCT_SAMPLERCUBE: 00137 case GCT_SAMPLER1DSHADOW: 00138 case GCT_SAMPLER2DSHADOW: 00139 return false; 00140 default: 00141 return true; 00142 }; 00143 00144 } 00145 00146 bool isSampler() const 00147 { 00148 return isSampler(constType); 00149 } 00150 00151 static bool isSampler(GpuConstantType c) 00152 { 00153 switch(c) 00154 { 00155 case GCT_SAMPLER1D: 00156 case GCT_SAMPLER2D: 00157 case GCT_SAMPLER3D: 00158 case GCT_SAMPLERCUBE: 00159 case GCT_SAMPLER1DSHADOW: 00160 case GCT_SAMPLER2DSHADOW: 00161 return true; 00162 default: 00163 return false; 00164 }; 00165 00166 } 00167 00168 00172 static size_t getElementSize(GpuConstantType ctype, bool padToMultiplesOf4) 00173 { 00174 if (padToMultiplesOf4) 00175 { 00176 switch(ctype) 00177 { 00178 case GCT_FLOAT1: 00179 case GCT_INT1: 00180 case GCT_SAMPLER1D: 00181 case GCT_SAMPLER2D: 00182 case GCT_SAMPLER3D: 00183 case GCT_SAMPLERCUBE: 00184 case GCT_SAMPLER1DSHADOW: 00185 case GCT_SAMPLER2DSHADOW: 00186 case GCT_FLOAT2: 00187 case GCT_INT2: 00188 case GCT_FLOAT3: 00189 case GCT_INT3: 00190 case GCT_FLOAT4: 00191 case GCT_INT4: 00192 return 4; 00193 case GCT_MATRIX_2X2: 00194 case GCT_MATRIX_2X3: 00195 case GCT_MATRIX_2X4: 00196 return 8; // 2 float4s 00197 case GCT_MATRIX_3X2: 00198 case GCT_MATRIX_3X3: 00199 case GCT_MATRIX_3X4: 00200 return 12; // 3 float4s 00201 case GCT_MATRIX_4X2: 00202 case GCT_MATRIX_4X3: 00203 case GCT_MATRIX_4X4: 00204 return 16; // 4 float4s 00205 default: 00206 return 4; 00207 }; 00208 } 00209 else 00210 { 00211 switch(ctype) 00212 { 00213 case GCT_FLOAT1: 00214 case GCT_INT1: 00215 case GCT_SAMPLER1D: 00216 case GCT_SAMPLER2D: 00217 case GCT_SAMPLER3D: 00218 case GCT_SAMPLERCUBE: 00219 case GCT_SAMPLER1DSHADOW: 00220 case GCT_SAMPLER2DSHADOW: 00221 return 1; 00222 case GCT_FLOAT2: 00223 case GCT_INT2: 00224 return 2; 00225 case GCT_FLOAT3: 00226 case GCT_INT3: 00227 return 3; 00228 case GCT_FLOAT4: 00229 case GCT_INT4: 00230 return 4; 00231 case GCT_MATRIX_2X2: 00232 return 4; 00233 case GCT_MATRIX_2X3: 00234 case GCT_MATRIX_3X2: 00235 return 6; 00236 case GCT_MATRIX_2X4: 00237 case GCT_MATRIX_4X2: 00238 return 8; 00239 case GCT_MATRIX_3X3: 00240 return 9; 00241 case GCT_MATRIX_3X4: 00242 case GCT_MATRIX_4X3: 00243 return 12; 00244 case GCT_MATRIX_4X4: 00245 return 16; 00246 default: 00247 return 4; 00248 }; 00249 00250 } 00251 } 00252 00253 GpuConstantDefinition() 00254 : constType(GCT_UNKNOWN) 00255 , physicalIndex((std::numeric_limits<size_t>::max)()) 00256 , elementSize(0) 00257 , arraySize(1) 00258 , variability(GPV_GLOBAL) {} 00259 }; 00260 typedef map<String, GpuConstantDefinition>::type GpuConstantDefinitionMap; 00261 typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator; 00262 00264 struct _OgreExport GpuNamedConstants : public GpuParamsAlloc 00265 { 00267 size_t floatBufferSize; 00269 size_t intBufferSize; 00271 GpuConstantDefinitionMap map; 00272 00273 GpuNamedConstants() : floatBufferSize(0), intBufferSize(0) {} 00274 00286 void generateConstantDefinitionArrayEntries(const String& paramName, 00287 const GpuConstantDefinition& baseDef); 00288 00290 static bool getGenerateAllConstantDefinitionArrayEntries(); 00291 00298 static void setGenerateAllConstantDefinitionArrayEntries(bool generateAll); 00299 00303 void save(const String& filename) const; 00307 void load(DataStreamPtr& stream); 00308 00309 protected: 00316 static bool msGenerateAllConstantDefinitionArrayEntries; 00317 }; 00318 typedef SharedPtr<GpuNamedConstants> GpuNamedConstantsPtr; 00319 00321 class _OgreExport GpuNamedConstantsSerializer : public Serializer 00322 { 00323 public: 00324 GpuNamedConstantsSerializer(); 00325 virtual ~GpuNamedConstantsSerializer(); 00326 void exportNamedConstants(const GpuNamedConstants* pConsts, const String& filename, 00327 Endian endianMode = ENDIAN_NATIVE); 00328 void importNamedConstants(DataStreamPtr& stream, GpuNamedConstants* pDest); 00329 }; 00330 00334 struct _OgreExport GpuLogicalIndexUse 00335 { 00337 size_t physicalIndex; 00339 size_t currentSize; 00341 mutable uint16 variability; 00342 00343 GpuLogicalIndexUse() 00344 : physicalIndex(99999), currentSize(0), variability(GPV_GLOBAL) {} 00345 GpuLogicalIndexUse(size_t bufIdx, size_t curSz, uint16 v) 00346 : physicalIndex(bufIdx), currentSize(curSz), variability(v) {} 00347 }; 00348 typedef map<size_t, GpuLogicalIndexUse>::type GpuLogicalIndexUseMap; 00350 struct _OgreExport GpuLogicalBufferStruct : public GpuParamsAlloc 00351 { 00352 OGRE_MUTEX(mutex) 00354 GpuLogicalIndexUseMap map; 00356 size_t bufferSize; 00357 GpuLogicalBufferStruct() : bufferSize(0) {} 00358 }; 00359 typedef SharedPtr<GpuLogicalBufferStruct> GpuLogicalBufferStructPtr; 00360 00365 typedef vector<float>::type FloatConstantList; 00370 typedef vector<int>::type IntConstantList; 00371 00387 class _OgreExport GpuSharedParameters : public GpuParamsAlloc 00388 { 00389 protected: 00390 GpuNamedConstants mNamedConstants; 00391 FloatConstantList mFloatConstants; 00392 IntConstantList mIntConstants; 00393 String mName; 00394 00395 // Optional data the rendersystem might want to store 00396 mutable Any mRenderSystemData; 00397 00399 size_t mFrameLastUpdated; 00400 00402 unsigned long mVersion; 00403 00404 public: 00405 GpuSharedParameters(const String& name); 00406 virtual ~GpuSharedParameters(); 00407 00409 const String& getName() { return mName; } 00410 00418 void addConstantDefinition(const String& name, GpuConstantType constType, size_t arraySize = 1); 00419 00422 void removeConstantDefinition(const String& name); 00423 00426 void removeAllConstantDefinitions(); 00427 00431 unsigned long getVersion() const { return mVersion; } 00432 00438 void _markDirty(); 00440 size_t getFrameLastUpdated() const { return mFrameLastUpdated; } 00441 00445 GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const; 00446 00449 const GpuConstantDefinition& getConstantDefinition(const String& name) const; 00450 00453 const GpuNamedConstants& getConstantDefinitions() const; 00454 00456 void setNamedConstant(const String& name, Real val); 00458 void setNamedConstant(const String& name, int val); 00460 void setNamedConstant(const String& name, const Vector4& vec); 00462 void setNamedConstant(const String& name, const Vector3& vec); 00464 void setNamedConstant(const String& name, const Matrix4& m); 00466 void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries); 00468 void setNamedConstant(const String& name, const float *val, size_t count); 00470 void setNamedConstant(const String& name, const double *val, size_t count); 00472 void setNamedConstant(const String& name, const ColourValue& colour); 00474 void setNamedConstant(const String& name, const int *val, size_t count); 00475 00477 float* getFloatPointer(size_t pos) { _markDirty(); return &mFloatConstants[pos]; } 00479 const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; } 00481 int* getIntPointer(size_t pos) { _markDirty(); return &mIntConstants[pos]; } 00483 const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; } 00484 00485 00487 void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; } 00489 const Any& _getRenderSystemData() const { return mRenderSystemData; } 00490 00491 }; 00492 00494 typedef SharedPtr<GpuSharedParameters> GpuSharedParametersPtr; 00495 00496 class GpuProgramParameters; 00497 00501 class _OgreExport GpuSharedParametersUsage : public GpuParamsAlloc 00502 { 00503 protected: 00504 GpuSharedParametersPtr mSharedParams; 00505 // Not a shared pointer since this is also parent 00506 GpuProgramParameters* mParams; 00507 // list of physical mappings that we are going to bring in 00508 struct CopyDataEntry 00509 { 00510 const GpuConstantDefinition* srcDefinition; 00511 const GpuConstantDefinition* dstDefinition; 00512 }; 00513 typedef vector<CopyDataEntry>::type CopyDataList; 00514 00515 CopyDataList mCopyDataList; 00516 00517 // Optional data the rendersystem might want to store 00518 mutable Any mRenderSystemData; 00519 00521 unsigned long mCopyDataVersion; 00522 00523 void initCopyData(); 00524 00525 00526 public: 00528 GpuSharedParametersUsage(GpuSharedParametersPtr sharedParams, 00529 GpuProgramParameters* params); 00530 00538 void _copySharedParamsToTargetParams(); 00539 00541 const String& getName() const { return mSharedParams->getName(); } 00542 00543 GpuSharedParametersPtr getSharedParams() const { return mSharedParams; } 00544 GpuProgramParameters* getTargetParams() const { return mParams; } 00545 00547 void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; } 00549 const Any& _getRenderSystemData() const { return mRenderSystemData; } 00550 00551 00552 }; 00553 00584 class _OgreExport GpuProgramParameters : public GpuParamsAlloc 00585 { 00586 public: 00590 enum AutoConstantType 00591 { 00593 ACT_WORLD_MATRIX, 00595 ACT_INVERSE_WORLD_MATRIX, 00599 ACT_TRANSPOSE_WORLD_MATRIX, 00601 ACT_INVERSE_TRANSPOSE_WORLD_MATRIX, 00602 00603 00605 ACT_WORLD_MATRIX_ARRAY_3x4, 00607 ACT_WORLD_MATRIX_ARRAY, 00608 00610 ACT_VIEW_MATRIX, 00612 ACT_INVERSE_VIEW_MATRIX, 00616 ACT_TRANSPOSE_VIEW_MATRIX, 00620 ACT_INVERSE_TRANSPOSE_VIEW_MATRIX, 00621 00622 00624 ACT_PROJECTION_MATRIX, 00628 ACT_INVERSE_PROJECTION_MATRIX, 00632 ACT_TRANSPOSE_PROJECTION_MATRIX, 00636 ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX, 00637 00638 00640 ACT_VIEWPROJ_MATRIX, 00644 ACT_INVERSE_VIEWPROJ_MATRIX, 00648 ACT_TRANSPOSE_VIEWPROJ_MATRIX, 00652 ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX, 00653 00654 00656 ACT_WORLDVIEW_MATRIX, 00658 ACT_INVERSE_WORLDVIEW_MATRIX, 00662 ACT_TRANSPOSE_WORLDVIEW_MATRIX, 00664 ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX, 00666 00667 00669 ACT_WORLDVIEWPROJ_MATRIX, 00673 ACT_INVERSE_WORLDVIEWPROJ_MATRIX, 00677 ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX, 00681 ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX, 00682 00683 00685 00688 ACT_RENDER_TARGET_FLIPPING, 00689 00692 ACT_VERTEX_WINDING, 00693 00695 ACT_FOG_COLOUR, 00697 ACT_FOG_PARAMS, 00698 00699 00701 ACT_SURFACE_AMBIENT_COLOUR, 00703 ACT_SURFACE_DIFFUSE_COLOUR, 00705 ACT_SURFACE_SPECULAR_COLOUR, 00707 ACT_SURFACE_EMISSIVE_COLOUR, 00709 ACT_SURFACE_SHININESS, 00710 00711 00713 ACT_LIGHT_COUNT, 00714 00715 00717 ACT_AMBIENT_LIGHT_COLOUR, 00718 00720 ACT_LIGHT_DIFFUSE_COLOUR, 00722 ACT_LIGHT_SPECULAR_COLOUR, 00724 ACT_LIGHT_ATTENUATION, 00730 ACT_SPOTLIGHT_PARAMS, 00732 ACT_LIGHT_POSITION, 00734 ACT_LIGHT_POSITION_OBJECT_SPACE, 00736 ACT_LIGHT_POSITION_VIEW_SPACE, 00738 ACT_LIGHT_DIRECTION, 00740 ACT_LIGHT_DIRECTION_OBJECT_SPACE, 00742 ACT_LIGHT_DIRECTION_VIEW_SPACE, 00747 ACT_LIGHT_DISTANCE_OBJECT_SPACE, 00749 ACT_LIGHT_POWER_SCALE, 00751 ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED, 00753 ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED, 00755 ACT_LIGHT_DIFFUSE_COLOUR_ARRAY, 00757 ACT_LIGHT_SPECULAR_COLOUR_ARRAY, 00759 ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY, 00761 ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY, 00763 ACT_LIGHT_ATTENUATION_ARRAY, 00765 ACT_LIGHT_POSITION_ARRAY, 00767 ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY, 00769 ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY, 00771 ACT_LIGHT_DIRECTION_ARRAY, 00773 ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY, 00775 ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY, 00780 ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY, 00784 ACT_LIGHT_POWER_SCALE_ARRAY, 00791 ACT_SPOTLIGHT_PARAMS_ARRAY, 00792 00797 ACT_DERIVED_AMBIENT_LIGHT_COLOUR, 00802 ACT_DERIVED_SCENE_COLOUR, 00803 00809 ACT_DERIVED_LIGHT_DIFFUSE_COLOUR, 00815 ACT_DERIVED_LIGHT_SPECULAR_COLOUR, 00816 00818 ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY, 00820 ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY, 00827 ACT_LIGHT_NUMBER, 00829 ACT_LIGHT_CASTS_SHADOWS, 00830 00831 00835 ACT_SHADOW_EXTRUSION_DISTANCE, 00837 ACT_CAMERA_POSITION, 00839 ACT_CAMERA_POSITION_OBJECT_SPACE, 00841 ACT_TEXTURE_VIEWPROJ_MATRIX, 00843 ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY, 00847 ACT_TEXTURE_WORLDVIEWPROJ_MATRIX, 00849 ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY, 00851 ACT_SPOTLIGHT_VIEWPROJ_MATRIX, 00855 ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX, 00857 ACT_CUSTOM, 00860 ACT_TIME, 00864 ACT_TIME_0_X, 00866 ACT_COSTIME_0_X, 00868 ACT_SINTIME_0_X, 00870 ACT_TANTIME_0_X, 00874 ACT_TIME_0_X_PACKED, 00879 ACT_TIME_0_1, 00881 ACT_COSTIME_0_1, 00883 ACT_SINTIME_0_1, 00885 ACT_TANTIME_0_1, 00889 ACT_TIME_0_1_PACKED, 00894 ACT_TIME_0_2PI, 00896 ACT_COSTIME_0_2PI, 00898 ACT_SINTIME_0_2PI, 00900 ACT_TANTIME_0_2PI, 00904 ACT_TIME_0_2PI_PACKED, 00906 ACT_FRAME_TIME, 00908 ACT_FPS, 00910 00913 ACT_VIEWPORT_WIDTH, 00917 ACT_VIEWPORT_HEIGHT, 00921 ACT_INVERSE_VIEWPORT_WIDTH, 00925 ACT_INVERSE_VIEWPORT_HEIGHT, 00929 ACT_VIEWPORT_SIZE, 00930 00932 00935 ACT_VIEW_DIRECTION, 00939 ACT_VIEW_SIDE_VECTOR, 00943 ACT_VIEW_UP_VECTOR, 00947 ACT_FOV, 00951 ACT_NEAR_CLIP_DISTANCE, 00955 ACT_FAR_CLIP_DISTANCE, 00956 00960 ACT_PASS_NUMBER, 00961 00966 ACT_PASS_ITERATION_NUMBER, 00967 00968 00972 ACT_ANIMATION_PARAMETRIC, 00973 00979 ACT_TEXEL_OFFSETS, 00980 00985 ACT_SCENE_DEPTH_RANGE, 00986 00992 ACT_SHADOW_SCENE_DEPTH_RANGE, 00993 00997 ACT_SHADOW_COLOUR, 01001 ACT_TEXTURE_SIZE, 01005 ACT_INVERSE_TEXTURE_SIZE, 01009 ACT_PACKED_TEXTURE_SIZE, 01010 01014 ACT_TEXTURE_MATRIX, 01015 01021 ACT_LOD_CAMERA_POSITION, 01027 ACT_LOD_CAMERA_POSITION_OBJECT_SPACE, 01029 ACT_LIGHT_CUSTOM 01030 }; 01031 01035 enum ACDataType { 01037 ACDT_NONE, 01039 ACDT_INT, 01041 ACDT_REAL 01042 }; 01043 01046 enum ElementType { 01047 ET_INT, 01048 ET_REAL 01049 }; 01050 01054 struct AutoConstantDefinition 01055 { 01056 AutoConstantType acType; 01057 String name; 01058 size_t elementCount; 01060 ElementType elementType; 01062 ACDataType dataType; 01063 01064 AutoConstantDefinition(AutoConstantType _acType, const String& _name, 01065 size_t _elementCount, ElementType _elementType, 01066 ACDataType _dataType) 01067 :acType(_acType), name(_name), elementCount(_elementCount), 01068 elementType(_elementType), dataType(_dataType) 01069 { 01070 01071 } 01072 }; 01073 01075 class AutoConstantEntry 01076 { 01077 public: 01079 AutoConstantType paramType; 01081 size_t physicalIndex; 01085 size_t elementCount; 01087 union{ 01088 size_t data; 01089 Real fData; 01090 }; 01092 uint16 variability; 01093 01094 AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, 01095 uint16 theVariability, size_t theElemCount = 4) 01096 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 01097 data(theData), variability(theVariability) {} 01098 01099 AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, 01100 uint16 theVariability, size_t theElemCount = 4) 01101 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 01102 fData(theData), variability(theVariability) {} 01103 01104 }; 01105 // Auto parameter storage 01106 typedef vector<AutoConstantEntry>::type AutoConstantList; 01107 01108 typedef vector<GpuSharedParametersUsage>::type GpuSharedParamUsageList; 01109 01110 protected: 01111 static AutoConstantDefinition AutoConstantDictionary[]; 01113 FloatConstantList mFloatConstants; 01115 IntConstantList mIntConstants; 01118 GpuLogicalBufferStructPtr mFloatLogicalToPhysical; 01121 GpuLogicalBufferStructPtr mIntLogicalToPhysical; 01123 GpuNamedConstantsPtr mNamedConstants; 01125 AutoConstantList mAutoConstants; 01127 uint16 mCombinedVariability; 01129 bool mTransposeMatrices; 01131 bool mIgnoreMissingParams; 01133 size_t mActivePassIterationIndex; 01134 01137 GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability); 01140 GpuLogicalIndexUse* _getIntConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability); 01141 01143 uint16 deriveVariability(AutoConstantType act); 01144 01145 void copySharedParamSetUsage(const GpuSharedParamUsageList& srcList); 01146 01147 GpuSharedParamUsageList mSharedParamSets; 01148 01149 // Optional data the rendersystem might want to store 01150 mutable Any mRenderSystemData; 01151 01152 01153 01154 public: 01155 GpuProgramParameters(); 01156 ~GpuProgramParameters() {} 01157 01159 GpuProgramParameters(const GpuProgramParameters& oth); 01161 GpuProgramParameters& operator=(const GpuProgramParameters& oth); 01162 01164 void _setNamedConstants(const GpuNamedConstantsPtr& constantmap); 01165 01167 void _setLogicalIndexes(const GpuLogicalBufferStructPtr& floatIndexMap, 01168 const GpuLogicalBufferStructPtr& intIndexMap); 01169 01170 01172 bool hasNamedParameters() const { return !mNamedConstants.isNull(); } 01178 bool hasLogicalIndexedParameters() const { return !mFloatLogicalToPhysical.isNull(); } 01179 01185 void setConstant(size_t index, const Vector4& vec); 01193 void setConstant(size_t index, Real val); 01201 void setConstant(size_t index, const Vector3& vec); 01208 void setConstant(size_t index, const Matrix4& m); 01216 void setConstant(size_t index, const Matrix4* m, size_t numEntries); 01223 void setConstant(size_t index, const float *val, size_t count); 01230 void setConstant(size_t index, const double *val, size_t count); 01236 void setConstant(size_t index, const ColourValue& colour); 01237 01252 void setConstant(size_t index, const int *val, size_t count); 01253 01260 void _writeRawConstants(size_t physicalIndex, const float* val, size_t count); 01267 void _writeRawConstants(size_t physicalIndex, const double* val, size_t count); 01274 void _writeRawConstants(size_t physicalIndex, const int* val, size_t count); 01281 void _readRawConstants(size_t physicalIndex, size_t count, float* dest); 01288 void _readRawConstants(size_t physicalIndex, size_t count, int* dest); 01289 01300 void _writeRawConstant(size_t physicalIndex, const Vector4& vec, 01301 size_t count = 4); 01309 void _writeRawConstant(size_t physicalIndex, Real val); 01317 void _writeRawConstant(size_t physicalIndex, int val); 01325 void _writeRawConstant(size_t physicalIndex, const Vector3& vec); 01334 void _writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount); 01342 void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries); 01352 void _writeRawConstant(size_t physicalIndex, const ColourValue& colour, 01353 size_t count = 4); 01354 01355 01361 GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const; 01362 01367 const GpuConstantDefinition& getConstantDefinition(const String& name) const; 01368 01373 const GpuNamedConstants& getConstantDefinitions() const; 01374 01380 const GpuLogicalBufferStructPtr& getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; } 01381 01387 size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex); 01393 size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex); 01394 01400 const GpuLogicalBufferStructPtr& getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; } 01402 const FloatConstantList& getFloatConstantList() const { return mFloatConstants; } 01404 float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; } 01406 const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; } 01408 const IntConstantList& getIntConstantList() const { return mIntConstants; } 01410 int* getIntPointer(size_t pos) { return &mIntConstants[pos]; } 01412 const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; } 01414 const AutoConstantList& getAutoConstantList() const { return mAutoConstants; } 01415 01429 void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0); 01430 void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData); 01431 01446 void setAutoConstant(size_t index, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2); 01447 01451 void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 01452 uint16 variability, size_t elementSize = 4); 01456 void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData, 01457 uint16 variability, size_t elementSize = 4); 01458 01459 01461 void clearAutoConstant(size_t index); 01462 01467 void setConstantFromTime(size_t index, Real factor); 01468 01470 void clearAutoConstants(void); 01471 typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator; 01473 AutoConstantIterator getAutoConstantIterator(void) const; 01475 size_t getAutoConstantCount(void) const { return mAutoConstants.size(); } 01480 AutoConstantEntry* getAutoConstantEntry(const size_t index); 01482 bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); } 01487 const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex); 01492 const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex); 01496 const AutoConstantEntry* findAutoConstantEntry(const String& paramName); 01500 const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex); 01504 const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex); 01505 01510 void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask); 01511 01514 void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; } 01515 01535 void setNamedConstant(const String& name, Real val); 01555 void setNamedConstant(const String& name, int val); 01560 void setNamedConstant(const String& name, const Vector4& vec); 01573 void setNamedConstant(const String& name, const Vector3& vec); 01578 void setNamedConstant(const String& name, const Matrix4& m); 01586 void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries); 01603 void setNamedConstant(const String& name, const float *val, size_t count, 01604 size_t multiple = 4); 01621 void setNamedConstant(const String& name, const double *val, size_t count, 01622 size_t multiple = 4); 01627 void setNamedConstant(const String& name, const ColourValue& colour); 01628 01645 void setNamedConstant(const String& name, const int *val, size_t count, 01646 size_t multiple = 4); 01647 01662 void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0); 01663 void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData); 01664 01680 void setNamedAutoConstant(const String& name, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2); 01681 01689 void setNamedConstantFromTime(const String& name, Real factor); 01690 01692 void clearNamedAutoConstant(const String& name); 01693 01703 const GpuConstantDefinition* _findNamedConstantDefinition( 01704 const String& name, bool throwExceptionIfMissing = false) const; 01711 size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability); 01718 size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability); 01719 01727 void setTransposeMatrices(bool val) { mTransposeMatrices = val; } 01729 bool getTransposeMatrices(void) const { return mTransposeMatrices; } 01730 01737 void copyConstantsFrom(const GpuProgramParameters& source); 01738 01747 void copyMatchingNamedConstantsFrom(const GpuProgramParameters& source); 01748 01752 static const AutoConstantDefinition* getAutoConstantDefinition(const String& name); 01757 static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx); 01760 static size_t getNumAutoConstantDefinitions(void); 01761 01762 01765 void incPassIterationNumber(void); 01767 bool hasPassIterationNumber() const 01768 { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); } 01770 size_t getPassIterationNumberIndex() const 01771 { return mActivePassIterationIndex; } 01772 01773 01779 void addSharedParameters(GpuSharedParametersPtr sharedParams); 01780 01788 void addSharedParameters(const String& sharedParamsName); 01789 01791 bool isUsingSharedParameters(const String& sharedParamsName) const; 01792 01794 void removeSharedParameters(const String& sharedParamsName); 01795 01797 void removeAllSharedParameters(); 01798 01800 const GpuSharedParamUsageList& getSharedParameters() const; 01801 01803 void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; } 01805 const Any& _getRenderSystemData() const { return mRenderSystemData; } 01806 01814 void _copySharedParams(); 01815 01816 01817 01818 }; 01819 01821 typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr; 01822 01825 } 01826 #endif 01827
Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Wed Nov 3 2010 19:24:51