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-2011 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, 00853 ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY, 00857 ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX, 00859 ACT_CUSTOM, 00862 ACT_TIME, 00866 ACT_TIME_0_X, 00868 ACT_COSTIME_0_X, 00870 ACT_SINTIME_0_X, 00872 ACT_TANTIME_0_X, 00876 ACT_TIME_0_X_PACKED, 00881 ACT_TIME_0_1, 00883 ACT_COSTIME_0_1, 00885 ACT_SINTIME_0_1, 00887 ACT_TANTIME_0_1, 00891 ACT_TIME_0_1_PACKED, 00896 ACT_TIME_0_2PI, 00898 ACT_COSTIME_0_2PI, 00900 ACT_SINTIME_0_2PI, 00902 ACT_TANTIME_0_2PI, 00906 ACT_TIME_0_2PI_PACKED, 00908 ACT_FRAME_TIME, 00910 ACT_FPS, 00912 00915 ACT_VIEWPORT_WIDTH, 00919 ACT_VIEWPORT_HEIGHT, 00923 ACT_INVERSE_VIEWPORT_WIDTH, 00927 ACT_INVERSE_VIEWPORT_HEIGHT, 00931 ACT_VIEWPORT_SIZE, 00932 00934 00937 ACT_VIEW_DIRECTION, 00941 ACT_VIEW_SIDE_VECTOR, 00945 ACT_VIEW_UP_VECTOR, 00949 ACT_FOV, 00953 ACT_NEAR_CLIP_DISTANCE, 00957 ACT_FAR_CLIP_DISTANCE, 00958 00962 ACT_PASS_NUMBER, 00963 00968 ACT_PASS_ITERATION_NUMBER, 00969 00970 00974 ACT_ANIMATION_PARAMETRIC, 00975 00981 ACT_TEXEL_OFFSETS, 00982 00987 ACT_SCENE_DEPTH_RANGE, 00988 00994 ACT_SHADOW_SCENE_DEPTH_RANGE, 00995 00999 ACT_SHADOW_COLOUR, 01003 ACT_TEXTURE_SIZE, 01007 ACT_INVERSE_TEXTURE_SIZE, 01011 ACT_PACKED_TEXTURE_SIZE, 01012 01016 ACT_TEXTURE_MATRIX, 01017 01023 ACT_LOD_CAMERA_POSITION, 01029 ACT_LOD_CAMERA_POSITION_OBJECT_SPACE, 01031 ACT_LIGHT_CUSTOM 01032 }; 01033 01037 enum ACDataType { 01039 ACDT_NONE, 01041 ACDT_INT, 01043 ACDT_REAL 01044 }; 01045 01048 enum ElementType { 01049 ET_INT, 01050 ET_REAL 01051 }; 01052 01056 struct AutoConstantDefinition 01057 { 01058 AutoConstantType acType; 01059 String name; 01060 size_t elementCount; 01062 ElementType elementType; 01064 ACDataType dataType; 01065 01066 AutoConstantDefinition(AutoConstantType _acType, const String& _name, 01067 size_t _elementCount, ElementType _elementType, 01068 ACDataType _dataType) 01069 :acType(_acType), name(_name), elementCount(_elementCount), 01070 elementType(_elementType), dataType(_dataType) 01071 { 01072 01073 } 01074 }; 01075 01077 class AutoConstantEntry 01078 { 01079 public: 01081 AutoConstantType paramType; 01083 size_t physicalIndex; 01087 size_t elementCount; 01089 union{ 01090 size_t data; 01091 Real fData; 01092 }; 01094 uint16 variability; 01095 01096 AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, 01097 uint16 theVariability, size_t theElemCount = 4) 01098 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 01099 data(theData), variability(theVariability) {} 01100 01101 AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, 01102 uint16 theVariability, size_t theElemCount = 4) 01103 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 01104 fData(theData), variability(theVariability) {} 01105 01106 }; 01107 // Auto parameter storage 01108 typedef vector<AutoConstantEntry>::type AutoConstantList; 01109 01110 typedef vector<GpuSharedParametersUsage>::type GpuSharedParamUsageList; 01111 01112 protected: 01113 static AutoConstantDefinition AutoConstantDictionary[]; 01115 FloatConstantList mFloatConstants; 01117 IntConstantList mIntConstants; 01120 GpuLogicalBufferStructPtr mFloatLogicalToPhysical; 01123 GpuLogicalBufferStructPtr mIntLogicalToPhysical; 01125 GpuNamedConstantsPtr mNamedConstants; 01127 AutoConstantList mAutoConstants; 01129 uint16 mCombinedVariability; 01131 bool mTransposeMatrices; 01133 bool mIgnoreMissingParams; 01135 size_t mActivePassIterationIndex; 01136 01139 GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability); 01142 GpuLogicalIndexUse* _getIntConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability); 01143 01145 uint16 deriveVariability(AutoConstantType act); 01146 01147 void copySharedParamSetUsage(const GpuSharedParamUsageList& srcList); 01148 01149 GpuSharedParamUsageList mSharedParamSets; 01150 01151 // Optional data the rendersystem might want to store 01152 mutable Any mRenderSystemData; 01153 01154 01155 01156 public: 01157 GpuProgramParameters(); 01158 ~GpuProgramParameters() {} 01159 01161 GpuProgramParameters(const GpuProgramParameters& oth); 01163 GpuProgramParameters& operator=(const GpuProgramParameters& oth); 01164 01166 void _setNamedConstants(const GpuNamedConstantsPtr& constantmap); 01167 01169 void _setLogicalIndexes(const GpuLogicalBufferStructPtr& floatIndexMap, 01170 const GpuLogicalBufferStructPtr& intIndexMap); 01171 01172 01174 bool hasNamedParameters() const { return !mNamedConstants.isNull(); } 01180 bool hasLogicalIndexedParameters() const { return !mFloatLogicalToPhysical.isNull(); } 01181 01187 void setConstant(size_t index, const Vector4& vec); 01195 void setConstant(size_t index, Real val); 01203 void setConstant(size_t index, const Vector3& vec); 01210 void setConstant(size_t index, const Matrix4& m); 01218 void setConstant(size_t index, const Matrix4* m, size_t numEntries); 01225 void setConstant(size_t index, const float *val, size_t count); 01232 void setConstant(size_t index, const double *val, size_t count); 01238 void setConstant(size_t index, const ColourValue& colour); 01239 01254 void setConstant(size_t index, const int *val, size_t count); 01255 01262 void _writeRawConstants(size_t physicalIndex, const float* val, size_t count); 01269 void _writeRawConstants(size_t physicalIndex, const double* val, size_t count); 01276 void _writeRawConstants(size_t physicalIndex, const int* val, size_t count); 01283 void _readRawConstants(size_t physicalIndex, size_t count, float* dest); 01290 void _readRawConstants(size_t physicalIndex, size_t count, int* dest); 01291 01302 void _writeRawConstant(size_t physicalIndex, const Vector4& vec, 01303 size_t count = 4); 01311 void _writeRawConstant(size_t physicalIndex, Real val); 01319 void _writeRawConstant(size_t physicalIndex, int val); 01327 void _writeRawConstant(size_t physicalIndex, const Vector3& vec); 01336 void _writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount); 01344 void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries); 01354 void _writeRawConstant(size_t physicalIndex, const ColourValue& colour, 01355 size_t count = 4); 01356 01357 01363 GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const; 01364 01369 const GpuConstantDefinition& getConstantDefinition(const String& name) const; 01370 01375 const GpuNamedConstants& getConstantDefinitions() const; 01376 01382 const GpuLogicalBufferStructPtr& getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; } 01383 01389 size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex); 01395 size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex); 01396 01402 const GpuLogicalBufferStructPtr& getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; } 01404 const FloatConstantList& getFloatConstantList() const { return mFloatConstants; } 01406 float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; } 01408 const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; } 01410 const IntConstantList& getIntConstantList() const { return mIntConstants; } 01412 int* getIntPointer(size_t pos) { return &mIntConstants[pos]; } 01414 const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; } 01416 const AutoConstantList& getAutoConstantList() const { return mAutoConstants; } 01417 01431 void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0); 01432 void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData); 01433 01448 void setAutoConstant(size_t index, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2); 01449 01453 void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 01454 uint16 variability, size_t elementSize = 4); 01458 void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData, 01459 uint16 variability, size_t elementSize = 4); 01460 01461 01463 void clearAutoConstant(size_t index); 01464 01469 void setConstantFromTime(size_t index, Real factor); 01470 01472 void clearAutoConstants(void); 01473 typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator; 01475 AutoConstantIterator getAutoConstantIterator(void) const; 01477 size_t getAutoConstantCount(void) const { return mAutoConstants.size(); } 01482 AutoConstantEntry* getAutoConstantEntry(const size_t index); 01484 bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); } 01489 const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex); 01494 const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex); 01498 const AutoConstantEntry* findAutoConstantEntry(const String& paramName); 01502 const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex); 01506 const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex); 01507 01512 void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask); 01513 01516 void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; } 01517 01537 void setNamedConstant(const String& name, Real val); 01557 void setNamedConstant(const String& name, int val); 01562 void setNamedConstant(const String& name, const Vector4& vec); 01575 void setNamedConstant(const String& name, const Vector3& vec); 01580 void setNamedConstant(const String& name, const Matrix4& m); 01588 void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries); 01605 void setNamedConstant(const String& name, const float *val, size_t count, 01606 size_t multiple = 4); 01623 void setNamedConstant(const String& name, const double *val, size_t count, 01624 size_t multiple = 4); 01629 void setNamedConstant(const String& name, const ColourValue& colour); 01630 01647 void setNamedConstant(const String& name, const int *val, size_t count, 01648 size_t multiple = 4); 01649 01664 void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0); 01665 void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData); 01666 01682 void setNamedAutoConstant(const String& name, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2); 01683 01691 void setNamedConstantFromTime(const String& name, Real factor); 01692 01694 void clearNamedAutoConstant(const String& name); 01695 01705 const GpuConstantDefinition* _findNamedConstantDefinition( 01706 const String& name, bool throwExceptionIfMissing = false) const; 01713 size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability); 01720 size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability); 01721 01729 void setTransposeMatrices(bool val) { mTransposeMatrices = val; } 01731 bool getTransposeMatrices(void) const { return mTransposeMatrices; } 01732 01739 void copyConstantsFrom(const GpuProgramParameters& source); 01740 01749 void copyMatchingNamedConstantsFrom(const GpuProgramParameters& source); 01750 01754 static const AutoConstantDefinition* getAutoConstantDefinition(const String& name); 01759 static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx); 01762 static size_t getNumAutoConstantDefinitions(void); 01763 01764 01767 void incPassIterationNumber(void); 01769 bool hasPassIterationNumber() const 01770 { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); } 01772 size_t getPassIterationNumberIndex() const 01773 { return mActivePassIterationIndex; } 01774 01775 01781 void addSharedParameters(GpuSharedParametersPtr sharedParams); 01782 01790 void addSharedParameters(const String& sharedParamsName); 01791 01793 bool isUsingSharedParameters(const String& sharedParamsName) const; 01794 01796 void removeSharedParameters(const String& sharedParamsName); 01797 01799 void removeAllSharedParameters(); 01800 01802 const GpuSharedParamUsageList& getSharedParameters() const; 01803 01805 void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; } 01807 const Any& _getRenderSystemData() const { return mRenderSystemData; } 01808 01816 void _copySharedParams(); 01817 01818 01819 01820 }; 01821 01823 typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr; 01824 01827 } 01828 #endif 01829
Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sat Jan 14 2012 18:40:43