This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Mon Jul 27 2020 13:40:43
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-2013 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 #include "Threading/OgreThreadHeaders.h" 00039 #include "OgreHeaderPrefix.h" 00040 00041 namespace Ogre { 00042 00054 enum GpuConstantType 00055 { 00056 GCT_FLOAT1 = 1, 00057 GCT_FLOAT2 = 2, 00058 GCT_FLOAT3 = 3, 00059 GCT_FLOAT4 = 4, 00060 GCT_SAMPLER1D = 5, 00061 GCT_SAMPLER2D = 6, 00062 GCT_SAMPLER3D = 7, 00063 GCT_SAMPLERCUBE = 8, 00064 GCT_SAMPLERRECT = 9, 00065 GCT_SAMPLER1DSHADOW = 10, 00066 GCT_SAMPLER2DSHADOW = 11, 00067 GCT_SAMPLER2DARRAY = 12, 00068 GCT_MATRIX_2X2 = 13, 00069 GCT_MATRIX_2X3 = 14, 00070 GCT_MATRIX_2X4 = 15, 00071 GCT_MATRIX_3X2 = 16, 00072 GCT_MATRIX_3X3 = 17, 00073 GCT_MATRIX_3X4 = 18, 00074 GCT_MATRIX_4X2 = 19, 00075 GCT_MATRIX_4X3 = 20, 00076 GCT_MATRIX_4X4 = 21, 00077 GCT_INT1 = 22, 00078 GCT_INT2 = 23, 00079 GCT_INT3 = 24, 00080 GCT_INT4 = 25, 00081 GCT_SUBROUTINE = 26, 00082 GCT_DOUBLE1 = 27, 00083 GCT_DOUBLE2 = 28, 00084 GCT_DOUBLE3 = 29, 00085 GCT_DOUBLE4 = 30, 00086 GCT_MATRIX_DOUBLE_2X2 = 31, 00087 GCT_MATRIX_DOUBLE_2X3 = 32, 00088 GCT_MATRIX_DOUBLE_2X4 = 33, 00089 GCT_MATRIX_DOUBLE_3X2 = 34, 00090 GCT_MATRIX_DOUBLE_3X3 = 35, 00091 GCT_MATRIX_DOUBLE_3X4 = 36, 00092 GCT_MATRIX_DOUBLE_4X2 = 37, 00093 GCT_MATRIX_DOUBLE_4X3 = 38, 00094 GCT_MATRIX_DOUBLE_4X4 = 39, 00095 GCT_UNKNOWN = 99 00096 }; 00097 00101 enum GpuParamVariability 00102 { 00104 GPV_GLOBAL = 1, 00106 GPV_PER_OBJECT = 2, 00108 GPV_LIGHTS = 4, 00110 GPV_PASS_ITERATION_NUMBER = 8, 00111 00112 00114 GPV_ALL = 0xFFFF 00115 00116 }; 00117 00122 struct _OgreExport GpuConstantDefinition 00123 { 00125 GpuConstantType constType; 00127 size_t physicalIndex; 00129 size_t logicalIndex; 00132 size_t elementSize; 00134 size_t arraySize; 00136 mutable uint16 variability; 00137 00138 bool isFloat() const 00139 { 00140 return isFloat(constType); 00141 } 00142 00143 static bool isFloat(GpuConstantType c) 00144 { 00145 switch(c) 00146 { 00147 case GCT_INT1: 00148 case GCT_INT2: 00149 case GCT_INT3: 00150 case GCT_INT4: 00151 case GCT_SAMPLER1D: 00152 case GCT_SAMPLER2D: 00153 case GCT_SAMPLER2DARRAY: 00154 case GCT_SAMPLER3D: 00155 case GCT_SAMPLERCUBE: 00156 case GCT_SAMPLER1DSHADOW: 00157 case GCT_SAMPLER2DSHADOW: 00158 return false; 00159 default: 00160 return true; 00161 }; 00162 00163 } 00164 00165 bool isDouble() const 00166 { 00167 return isDouble(constType); 00168 } 00169 00170 static bool isDouble(GpuConstantType c) 00171 { 00172 switch(c) 00173 { 00174 case GCT_INT1: 00175 case GCT_INT2: 00176 case GCT_INT3: 00177 case GCT_INT4: 00178 case GCT_FLOAT1: 00179 case GCT_FLOAT2: 00180 case GCT_FLOAT3: 00181 case GCT_FLOAT4: 00182 case GCT_SAMPLER1D: 00183 case GCT_SAMPLER2D: 00184 case GCT_SAMPLER2DARRAY: 00185 case GCT_SAMPLER3D: 00186 case GCT_SAMPLERCUBE: 00187 case GCT_SAMPLER1DSHADOW: 00188 case GCT_SAMPLER2DSHADOW: 00189 return false; 00190 default: 00191 return true; 00192 }; 00193 00194 } 00195 00196 bool isSampler() const 00197 { 00198 return isSampler(constType); 00199 } 00200 00201 static bool isSampler(GpuConstantType c) 00202 { 00203 switch(c) 00204 { 00205 case GCT_SAMPLER1D: 00206 case GCT_SAMPLER2D: 00207 case GCT_SAMPLER2DARRAY: 00208 case GCT_SAMPLER3D: 00209 case GCT_SAMPLERCUBE: 00210 case GCT_SAMPLER1DSHADOW: 00211 case GCT_SAMPLER2DSHADOW: 00212 return true; 00213 default: 00214 return false; 00215 }; 00216 00217 } 00218 00219 bool isSubroutine() const 00220 { 00221 return isSubroutine(constType); 00222 } 00223 00224 static bool isSubroutine(GpuConstantType c) 00225 { 00226 return c == GCT_SUBROUTINE; 00227 } 00228 00232 static size_t getElementSize(GpuConstantType ctype, bool padToMultiplesOf4) 00233 { 00234 if (padToMultiplesOf4) 00235 { 00236 switch(ctype) 00237 { 00238 case GCT_FLOAT1: 00239 case GCT_INT1: 00240 case GCT_SAMPLER1D: 00241 case GCT_SAMPLER2D: 00242 case GCT_SAMPLER2DARRAY: 00243 case GCT_SAMPLER3D: 00244 case GCT_SAMPLERCUBE: 00245 case GCT_SAMPLER1DSHADOW: 00246 case GCT_SAMPLER2DSHADOW: 00247 case GCT_FLOAT2: 00248 case GCT_INT2: 00249 case GCT_FLOAT3: 00250 case GCT_INT3: 00251 case GCT_FLOAT4: 00252 case GCT_INT4: 00253 return 4; 00254 case GCT_MATRIX_2X2: 00255 case GCT_MATRIX_2X3: 00256 case GCT_MATRIX_2X4: 00257 case GCT_DOUBLE1: 00258 case GCT_DOUBLE2: 00259 case GCT_DOUBLE3: 00260 case GCT_DOUBLE4: 00261 return 8; // 2 float4s 00262 case GCT_MATRIX_3X2: 00263 case GCT_MATRIX_3X3: 00264 case GCT_MATRIX_3X4: 00265 return 12; // 3 float4s 00266 case GCT_MATRIX_4X2: 00267 case GCT_MATRIX_4X3: 00268 case GCT_MATRIX_4X4: 00269 case GCT_MATRIX_DOUBLE_2X2: 00270 case GCT_MATRIX_DOUBLE_2X3: 00271 case GCT_MATRIX_DOUBLE_2X4: 00272 return 16; // 4 float4s 00273 case GCT_MATRIX_DOUBLE_3X2: 00274 case GCT_MATRIX_DOUBLE_3X3: 00275 case GCT_MATRIX_DOUBLE_3X4: 00276 return 24; 00277 case GCT_MATRIX_DOUBLE_4X2: 00278 case GCT_MATRIX_DOUBLE_4X3: 00279 case GCT_MATRIX_DOUBLE_4X4: 00280 return 32; 00281 default: 00282 return 4; 00283 }; 00284 } 00285 else 00286 { 00287 switch(ctype) 00288 { 00289 case GCT_FLOAT1: 00290 case GCT_DOUBLE1: 00291 case GCT_INT1: 00292 case GCT_SAMPLER1D: 00293 case GCT_SAMPLER2D: 00294 case GCT_SAMPLER2DARRAY: 00295 case GCT_SAMPLER3D: 00296 case GCT_SAMPLERCUBE: 00297 case GCT_SAMPLER1DSHADOW: 00298 case GCT_SAMPLER2DSHADOW: 00299 return 1; 00300 case GCT_FLOAT2: 00301 case GCT_INT2: 00302 case GCT_DOUBLE2: 00303 return 2; 00304 case GCT_FLOAT3: 00305 case GCT_INT3: 00306 case GCT_DOUBLE3: 00307 return 3; 00308 case GCT_FLOAT4: 00309 case GCT_INT4: 00310 case GCT_DOUBLE4: 00311 return 4; 00312 case GCT_MATRIX_2X2: 00313 case GCT_MATRIX_DOUBLE_2X2: 00314 return 4; 00315 case GCT_MATRIX_2X3: 00316 case GCT_MATRIX_3X2: 00317 case GCT_MATRIX_DOUBLE_2X3: 00318 case GCT_MATRIX_DOUBLE_3X2: 00319 return 6; 00320 case GCT_MATRIX_2X4: 00321 case GCT_MATRIX_4X2: 00322 case GCT_MATRIX_DOUBLE_2X4: 00323 case GCT_MATRIX_DOUBLE_4X2: 00324 return 8; 00325 case GCT_MATRIX_3X3: 00326 case GCT_MATRIX_DOUBLE_3X3: 00327 return 9; 00328 case GCT_MATRIX_3X4: 00329 case GCT_MATRIX_4X3: 00330 case GCT_MATRIX_DOUBLE_3X4: 00331 case GCT_MATRIX_DOUBLE_4X3: 00332 return 12; 00333 case GCT_MATRIX_4X4: 00334 case GCT_MATRIX_DOUBLE_4X4: 00335 return 16; 00336 default: 00337 return 4; 00338 }; 00339 00340 } 00341 } 00342 00343 GpuConstantDefinition() 00344 : constType(GCT_UNKNOWN) 00345 , physicalIndex((std::numeric_limits<size_t>::max)()) 00346 , logicalIndex(0) 00347 , elementSize(0) 00348 , arraySize(1) 00349 , variability(GPV_GLOBAL) {} 00350 }; 00351 typedef map<String, GpuConstantDefinition>::type GpuConstantDefinitionMap; 00352 typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator; 00353 00355 struct _OgreExport GpuNamedConstants : public GpuParamsAlloc 00356 { 00358 size_t floatBufferSize; 00360 size_t doubleBufferSize; 00362 size_t intBufferSize; 00364 GpuConstantDefinitionMap map; 00365 00366 GpuNamedConstants() : floatBufferSize(0), doubleBufferSize(0), intBufferSize(0) {} 00367 00379 void generateConstantDefinitionArrayEntries(const String& paramName, 00380 const GpuConstantDefinition& baseDef); 00381 00383 static bool getGenerateAllConstantDefinitionArrayEntries(); 00384 00391 static void setGenerateAllConstantDefinitionArrayEntries(bool generateAll); 00392 00396 void save(const String& filename) const; 00400 void load(DataStreamPtr& stream); 00401 00402 size_t calculateSize(void) const; 00403 00404 protected: 00411 static bool msGenerateAllConstantDefinitionArrayEntries; 00412 }; 00413 typedef SharedPtr<GpuNamedConstants> GpuNamedConstantsPtr; 00414 00416 class _OgreExport GpuNamedConstantsSerializer : public Serializer 00417 { 00418 public: 00419 GpuNamedConstantsSerializer(); 00420 virtual ~GpuNamedConstantsSerializer(); 00421 void exportNamedConstants(const GpuNamedConstants* pConsts, const String& filename, 00422 Endian endianMode = ENDIAN_NATIVE); 00423 void exportNamedConstants(const GpuNamedConstants* pConsts, DataStreamPtr stream, 00424 Endian endianMode = ENDIAN_NATIVE); 00425 void importNamedConstants(DataStreamPtr& stream, GpuNamedConstants* pDest); 00426 }; 00427 00431 struct _OgreExport GpuLogicalIndexUse 00432 { 00434 size_t physicalIndex; 00436 size_t currentSize; 00438 mutable uint16 variability; 00439 00440 GpuLogicalIndexUse() 00441 : physicalIndex(99999), currentSize(0), variability(GPV_GLOBAL) {} 00442 GpuLogicalIndexUse(size_t bufIdx, size_t curSz, uint16 v) 00443 : physicalIndex(bufIdx), currentSize(curSz), variability(v) {} 00444 }; 00445 typedef map<size_t, GpuLogicalIndexUse>::type GpuLogicalIndexUseMap; 00447 struct _OgreExport GpuLogicalBufferStruct : public GpuParamsAlloc 00448 { 00449 OGRE_MUTEX(mutex); 00450 00452 GpuLogicalIndexUseMap map; 00454 size_t bufferSize; 00455 GpuLogicalBufferStruct() : bufferSize(0) {} 00456 }; 00457 typedef SharedPtr<GpuLogicalBufferStruct> GpuLogicalBufferStructPtr; 00458 00463 typedef vector<float>::type FloatConstantList; 00468 typedef vector<double>::type DoubleConstantList; 00473 typedef vector<int>::type IntConstantList; 00474 00490 class _OgreExport GpuSharedParameters : public GpuParamsAlloc 00491 { 00492 protected: 00493 GpuNamedConstants mNamedConstants; 00494 FloatConstantList mFloatConstants; 00495 DoubleConstantList mDoubleConstants; 00496 IntConstantList mIntConstants; 00497 String mName; 00498 00499 // Optional data the rendersystem might want to store 00500 mutable Any mRenderSystemData; 00501 00503 size_t mFrameLastUpdated; 00504 00506 unsigned long mVersion; 00507 00508 public: 00509 GpuSharedParameters(const String& name); 00510 virtual ~GpuSharedParameters(); 00511 00513 const String& getName() { return mName; } 00514 00522 void addConstantDefinition(const String& name, GpuConstantType constType, size_t arraySize = 1); 00523 00526 void removeConstantDefinition(const String& name); 00527 00530 void removeAllConstantDefinitions(); 00531 00535 unsigned long getVersion() const { return mVersion; } 00536 00537 size_t calculateSize(void) const; 00538 00544 void _markDirty(); 00546 size_t getFrameLastUpdated() const { return mFrameLastUpdated; } 00547 00551 GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const; 00552 00555 const GpuConstantDefinition& getConstantDefinition(const String& name) const; 00556 00559 const GpuNamedConstants& getConstantDefinitions() const; 00560 00562 void setNamedConstant(const String& name, Real val); 00564 void setNamedConstant(const String& name, int val); 00566 void setNamedConstant(const String& name, const Vector4& vec); 00568 void setNamedConstant(const String& name, const Vector3& vec); 00570 void setNamedConstant(const String& name, const Vector2& vec); 00572 void setNamedConstant(const String& name, const Matrix4& m); 00574 void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries); 00576 void setNamedConstant(const String& name, const float *val, size_t count); 00578 void setNamedConstant(const String& name, const double *val, size_t count); 00580 void setNamedConstant(const String& name, const ColourValue& colour); 00582 void setNamedConstant(const String& name, const int *val, size_t count); 00583 00585 float* getFloatPointer(size_t pos) { _markDirty(); return &mFloatConstants[pos]; } 00587 const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; } 00589 double* getDoublePointer(size_t pos) { _markDirty(); return &mDoubleConstants[pos]; } 00591 const double* getDoublePointer(size_t pos) const { return &mDoubleConstants[pos]; } 00593 int* getIntPointer(size_t pos) { _markDirty(); return &mIntConstants[pos]; } 00595 const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; } 00596 00598 const FloatConstantList& getFloatConstantList() const { return mFloatConstants; } 00600 const DoubleConstantList& getDoubleConstantList() const { return mDoubleConstants; } 00602 const IntConstantList& getIntConstantList() const { return mIntConstants; } 00603 00605 void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; } 00607 const Any& _getRenderSystemData() const { return mRenderSystemData; } 00608 00609 }; 00610 00612 typedef SharedPtr<GpuSharedParameters> GpuSharedParametersPtr; 00613 00614 class GpuProgramParameters; 00615 00619 class _OgreExport GpuSharedParametersUsage : public GpuParamsAlloc 00620 { 00621 protected: 00622 GpuSharedParametersPtr mSharedParams; 00623 // Not a shared pointer since this is also parent 00624 GpuProgramParameters* mParams; 00625 // list of physical mappings that we are going to bring in 00626 struct CopyDataEntry 00627 { 00628 const GpuConstantDefinition* srcDefinition; 00629 const GpuConstantDefinition* dstDefinition; 00630 }; 00631 typedef vector<CopyDataEntry>::type CopyDataList; 00632 00633 CopyDataList mCopyDataList; 00634 00635 // Optional data the rendersystem might want to store 00636 mutable Any mRenderSystemData; 00637 00639 unsigned long mCopyDataVersion; 00640 00641 void initCopyData(); 00642 00643 00644 public: 00646 GpuSharedParametersUsage(GpuSharedParametersPtr sharedParams, 00647 GpuProgramParameters* params); 00648 00656 void _copySharedParamsToTargetParams(); 00657 00659 const String& getName() const { return mSharedParams->getName(); } 00660 00661 GpuSharedParametersPtr getSharedParams() const { return mSharedParams; } 00662 GpuProgramParameters* getTargetParams() const { return mParams; } 00663 00665 void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; } 00667 const Any& _getRenderSystemData() const { return mRenderSystemData; } 00668 00669 00670 }; 00671 00702 class _OgreExport GpuProgramParameters : public GpuParamsAlloc 00703 { 00704 public: 00708 enum AutoConstantType 00709 { 00711 ACT_WORLD_MATRIX, 00713 ACT_INVERSE_WORLD_MATRIX, 00717 ACT_TRANSPOSE_WORLD_MATRIX, 00719 ACT_INVERSE_TRANSPOSE_WORLD_MATRIX, 00720 00722 ACT_WORLD_MATRIX_ARRAY_3x4, 00724 ACT_WORLD_MATRIX_ARRAY, 00726 ACT_WORLD_DUALQUATERNION_ARRAY_2x4, 00728 ACT_WORLD_SCALE_SHEAR_MATRIX_ARRAY_3x4, 00729 00731 ACT_VIEW_MATRIX, 00733 ACT_INVERSE_VIEW_MATRIX, 00737 ACT_TRANSPOSE_VIEW_MATRIX, 00741 ACT_INVERSE_TRANSPOSE_VIEW_MATRIX, 00742 00743 00745 ACT_PROJECTION_MATRIX, 00749 ACT_INVERSE_PROJECTION_MATRIX, 00753 ACT_TRANSPOSE_PROJECTION_MATRIX, 00757 ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX, 00758 00759 00761 ACT_VIEWPROJ_MATRIX, 00765 ACT_INVERSE_VIEWPROJ_MATRIX, 00769 ACT_TRANSPOSE_VIEWPROJ_MATRIX, 00773 ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX, 00774 00775 00777 ACT_WORLDVIEW_MATRIX, 00779 ACT_INVERSE_WORLDVIEW_MATRIX, 00783 ACT_TRANSPOSE_WORLDVIEW_MATRIX, 00785 ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX, 00787 00788 00790 ACT_WORLDVIEWPROJ_MATRIX, 00794 ACT_INVERSE_WORLDVIEWPROJ_MATRIX, 00798 ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX, 00802 ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX, 00803 00804 00806 00809 ACT_RENDER_TARGET_FLIPPING, 00810 00813 ACT_VERTEX_WINDING, 00814 00816 ACT_FOG_COLOUR, 00818 ACT_FOG_PARAMS, 00819 00820 00822 ACT_SURFACE_AMBIENT_COLOUR, 00824 ACT_SURFACE_DIFFUSE_COLOUR, 00826 ACT_SURFACE_SPECULAR_COLOUR, 00828 ACT_SURFACE_EMISSIVE_COLOUR, 00830 ACT_SURFACE_SHININESS, 00832 ACT_SURFACE_ALPHA_REJECTION_VALUE, 00833 00834 00836 ACT_LIGHT_COUNT, 00837 00838 00840 ACT_AMBIENT_LIGHT_COLOUR, 00841 00843 ACT_LIGHT_DIFFUSE_COLOUR, 00845 ACT_LIGHT_SPECULAR_COLOUR, 00847 ACT_LIGHT_ATTENUATION, 00853 ACT_SPOTLIGHT_PARAMS, 00855 ACT_LIGHT_POSITION, 00857 ACT_LIGHT_POSITION_OBJECT_SPACE, 00859 ACT_LIGHT_POSITION_VIEW_SPACE, 00861 ACT_LIGHT_DIRECTION, 00863 ACT_LIGHT_DIRECTION_OBJECT_SPACE, 00865 ACT_LIGHT_DIRECTION_VIEW_SPACE, 00870 ACT_LIGHT_DISTANCE_OBJECT_SPACE, 00872 ACT_LIGHT_POWER_SCALE, 00874 ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED, 00876 ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED, 00878 ACT_LIGHT_DIFFUSE_COLOUR_ARRAY, 00880 ACT_LIGHT_SPECULAR_COLOUR_ARRAY, 00882 ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY, 00884 ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY, 00886 ACT_LIGHT_ATTENUATION_ARRAY, 00888 ACT_LIGHT_POSITION_ARRAY, 00890 ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY, 00892 ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY, 00894 ACT_LIGHT_DIRECTION_ARRAY, 00896 ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY, 00898 ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY, 00903 ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY, 00907 ACT_LIGHT_POWER_SCALE_ARRAY, 00914 ACT_SPOTLIGHT_PARAMS_ARRAY, 00915 00920 ACT_DERIVED_AMBIENT_LIGHT_COLOUR, 00925 ACT_DERIVED_SCENE_COLOUR, 00926 00932 ACT_DERIVED_LIGHT_DIFFUSE_COLOUR, 00938 ACT_DERIVED_LIGHT_SPECULAR_COLOUR, 00939 00941 ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY, 00943 ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY, 00950 ACT_LIGHT_NUMBER, 00952 ACT_LIGHT_CASTS_SHADOWS, 00954 ACT_LIGHT_CASTS_SHADOWS_ARRAY, 00955 00956 00960 ACT_SHADOW_EXTRUSION_DISTANCE, 00962 ACT_CAMERA_POSITION, 00964 ACT_CAMERA_POSITION_OBJECT_SPACE, 00966 ACT_TEXTURE_VIEWPROJ_MATRIX, 00968 ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY, 00972 ACT_TEXTURE_WORLDVIEWPROJ_MATRIX, 00974 ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY, 00976 ACT_SPOTLIGHT_VIEWPROJ_MATRIX, 00978 ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY, 00982 ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX, 00986 ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX_ARRAY, 00988 ACT_CUSTOM, 00991 ACT_TIME, 00995 ACT_TIME_0_X, 00997 ACT_COSTIME_0_X, 00999 ACT_SINTIME_0_X, 01001 ACT_TANTIME_0_X, 01005 ACT_TIME_0_X_PACKED, 01010 ACT_TIME_0_1, 01012 ACT_COSTIME_0_1, 01014 ACT_SINTIME_0_1, 01016 ACT_TANTIME_0_1, 01020 ACT_TIME_0_1_PACKED, 01025 ACT_TIME_0_2PI, 01027 ACT_COSTIME_0_2PI, 01029 ACT_SINTIME_0_2PI, 01031 ACT_TANTIME_0_2PI, 01035 ACT_TIME_0_2PI_PACKED, 01037 ACT_FRAME_TIME, 01039 ACT_FPS, 01041 01044 ACT_VIEWPORT_WIDTH, 01048 ACT_VIEWPORT_HEIGHT, 01052 ACT_INVERSE_VIEWPORT_WIDTH, 01056 ACT_INVERSE_VIEWPORT_HEIGHT, 01060 ACT_VIEWPORT_SIZE, 01061 01063 01066 ACT_VIEW_DIRECTION, 01070 ACT_VIEW_SIDE_VECTOR, 01074 ACT_VIEW_UP_VECTOR, 01078 ACT_FOV, 01082 ACT_NEAR_CLIP_DISTANCE, 01086 ACT_FAR_CLIP_DISTANCE, 01087 01091 ACT_PASS_NUMBER, 01092 01097 ACT_PASS_ITERATION_NUMBER, 01098 01099 01103 ACT_ANIMATION_PARAMETRIC, 01104 01110 ACT_TEXEL_OFFSETS, 01111 01116 ACT_SCENE_DEPTH_RANGE, 01117 01123 ACT_SHADOW_SCENE_DEPTH_RANGE, 01124 01130 ACT_SHADOW_SCENE_DEPTH_RANGE_ARRAY, 01131 01135 ACT_SHADOW_COLOUR, 01139 ACT_TEXTURE_SIZE, 01143 ACT_INVERSE_TEXTURE_SIZE, 01147 ACT_PACKED_TEXTURE_SIZE, 01148 01152 ACT_TEXTURE_MATRIX, 01153 01159 ACT_LOD_CAMERA_POSITION, 01165 ACT_LOD_CAMERA_POSITION_OBJECT_SPACE, 01167 ACT_LIGHT_CUSTOM, 01168 01169 ACT_UNKNOWN = 999 01170 }; 01171 01175 enum ACDataType { 01177 ACDT_NONE, 01179 ACDT_INT, 01181 ACDT_REAL 01182 }; 01183 01186 enum ElementType { 01187 ET_INT, 01188 ET_REAL 01189 }; 01190 01194 struct AutoConstantDefinition 01195 { 01196 AutoConstantType acType; 01197 String name; 01198 size_t elementCount; 01200 ElementType elementType; 01202 ACDataType dataType; 01203 01204 AutoConstantDefinition(AutoConstantType _acType, const String& _name, 01205 size_t _elementCount, ElementType _elementType, 01206 ACDataType _dataType) 01207 :acType(_acType), name(_name), elementCount(_elementCount), 01208 elementType(_elementType), dataType(_dataType) 01209 { 01210 01211 } 01212 }; 01213 01215 class AutoConstantEntry 01216 { 01217 public: 01219 AutoConstantType paramType; 01221 size_t physicalIndex; 01225 size_t elementCount; 01227 union{ 01228 size_t data; 01229 Real fData; 01230 }; 01232 uint16 variability; 01233 01234 AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, 01235 uint16 theVariability, size_t theElemCount = 4) 01236 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 01237 data(theData), variability(theVariability) {} 01238 01239 AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, 01240 uint16 theVariability, size_t theElemCount = 4) 01241 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 01242 fData(theData), variability(theVariability) {} 01243 01244 }; 01245 // Auto parameter storage 01246 typedef vector<AutoConstantEntry>::type AutoConstantList; 01247 01248 typedef vector<GpuSharedParametersUsage>::type GpuSharedParamUsageList; 01249 01250 // Map that store subroutines associated with slots 01251 typedef HashMap<unsigned int, String> SubroutineMap; 01252 typedef HashMap<unsigned int, String>::const_iterator SubroutineIterator; 01253 01254 protected: 01255 SubroutineMap mSubroutineMap; 01256 01257 static AutoConstantDefinition AutoConstantDictionary[]; 01259 FloatConstantList mFloatConstants; 01261 DoubleConstantList mDoubleConstants; 01263 IntConstantList mIntConstants; 01266 GpuLogicalBufferStructPtr mFloatLogicalToPhysical; 01269 GpuLogicalBufferStructPtr mDoubleLogicalToPhysical; 01272 GpuLogicalBufferStructPtr mIntLogicalToPhysical; 01274 GpuNamedConstantsPtr mNamedConstants; 01276 AutoConstantList mAutoConstants; 01278 uint16 mCombinedVariability; 01280 bool mTransposeMatrices; 01282 bool mIgnoreMissingParams; 01284 size_t mActivePassIterationIndex; 01285 01288 GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability); 01291 GpuLogicalIndexUse* _getDoubleConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability); 01294 GpuLogicalIndexUse* _getIntConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability); 01295 01297 uint16 deriveVariability(AutoConstantType act); 01298 01299 void copySharedParamSetUsage(const GpuSharedParamUsageList& srcList); 01300 01301 GpuSharedParamUsageList mSharedParamSets; 01302 01303 // Optional data the rendersystem might want to store 01304 mutable Any mRenderSystemData; 01305 01306 01307 01308 public: 01309 GpuProgramParameters(); 01310 ~GpuProgramParameters() {} 01311 01313 GpuProgramParameters(const GpuProgramParameters& oth); 01315 GpuProgramParameters& operator=(const GpuProgramParameters& oth); 01316 01318 void _setNamedConstants(const GpuNamedConstantsPtr& constantmap); 01319 01321 void _setLogicalIndexes(const GpuLogicalBufferStructPtr& floatIndexMap, const GpuLogicalBufferStructPtr& doubleIndexMap, 01322 const GpuLogicalBufferStructPtr& intIndexMap); 01323 01324 01326 bool hasNamedParameters() const { return !mNamedConstants.isNull(); } 01332 bool hasLogicalIndexedParameters() const { return !mFloatLogicalToPhysical.isNull(); } 01333 01339 void setConstant(size_t index, const Vector4& vec); 01347 void setConstant(size_t index, Real val); 01355 void setConstant(size_t index, const Vector3& vec); 01363 void setConstant(size_t index, const Vector2& vec); 01370 void setConstant(size_t index, const Matrix4& m); 01378 void setConstant(size_t index, const Matrix4* m, size_t numEntries); 01385 void setConstant(size_t index, const float *val, size_t count); 01392 void setConstant(size_t index, const double *val, size_t count); 01398 void setConstant(size_t index, const ColourValue& colour); 01399 01414 void setConstant(size_t index, const int *val, size_t count); 01415 01422 void _writeRawConstants(size_t physicalIndex, const float* val, size_t count); 01429 void _writeRawConstants(size_t physicalIndex, const double* val, size_t count); 01436 void _writeRawConstants(size_t physicalIndex, const int* val, size_t count); 01443 void _readRawConstants(size_t physicalIndex, size_t count, float* dest); 01450 void _readRawConstants(size_t physicalIndex, size_t count, int* dest); 01451 01462 void _writeRawConstant(size_t physicalIndex, const Vector4& vec, 01463 size_t count = 4); 01471 void _writeRawConstant(size_t physicalIndex, Real val); 01479 void _writeRawConstant(size_t physicalIndex, Real val, size_t count); 01487 void _writeRawConstant(size_t physicalIndex, int val); 01495 void _writeRawConstant(size_t physicalIndex, const Vector3& vec); 01503 void _writeRawConstant(size_t physicalIndex, const Vector2& vec); 01512 void _writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount); 01520 void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries); 01530 void _writeRawConstant(size_t physicalIndex, const ColourValue& colour, 01531 size_t count = 4); 01532 01533 01539 GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const; 01540 01545 const GpuConstantDefinition& getConstantDefinition(const String& name) const; 01546 01551 const GpuNamedConstants& getConstantDefinitions() const; 01552 01558 const GpuLogicalBufferStructPtr& getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; } 01559 01565 size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex); 01576 const GpuLogicalBufferStructPtr& getDoubleLogicalBufferStruct() const { return mDoubleLogicalToPhysical; } 01577 01583 size_t getDoubleLogicalIndexForPhysicalIndex(size_t physicalIndex); 01589 size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex); 01590 01596 const GpuLogicalBufferStructPtr& getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; } 01598 const FloatConstantList& getFloatConstantList() const { return mFloatConstants; } 01600 float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; } 01602 const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; } 01604 const DoubleConstantList& getDoubleConstantList() const { return mDoubleConstants; } 01606 double* getDoublePointer(size_t pos) { return &mDoubleConstants[pos]; } 01608 const double* getDoublePointer(size_t pos) const { return &mDoubleConstants[pos]; } 01610 const IntConstantList& getIntConstantList() const { return mIntConstants; } 01612 int* getIntPointer(size_t pos) { return &mIntConstants[pos]; } 01614 const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; } 01616 const AutoConstantList& getAutoConstantList() const { return mAutoConstants; } 01617 01631 void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0); 01632 void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData); 01633 01648 void setAutoConstant(size_t index, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2); 01649 01653 void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 01654 uint16 variability, size_t elementSize = 4); 01658 void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData, 01659 uint16 variability, size_t elementSize = 4); 01660 01661 01663 void clearAutoConstant(size_t index); 01664 01669 void setConstantFromTime(size_t index, Real factor); 01670 01672 void clearAutoConstants(void); 01673 typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator; 01675 AutoConstantIterator getAutoConstantIterator(void) const; 01677 size_t getAutoConstantCount(void) const { return mAutoConstants.size(); } 01682 AutoConstantEntry* getAutoConstantEntry(const size_t index); 01684 bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); } 01689 const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex); 01694 const AutoConstantEntry* findDoubleAutoConstantEntry(size_t logicalIndex); 01699 const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex); 01703 const AutoConstantEntry* findAutoConstantEntry(const String& paramName); 01707 const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex); 01711 const AutoConstantEntry* _findRawAutoConstantEntryDouble(size_t physicalIndex); 01715 const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex); 01716 01721 void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask); 01722 01725 void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; } 01726 01746 void setNamedConstant(const String& name, Real val); 01766 void setNamedConstant(const String& name, int val); 01771 void setNamedConstant(const String& name, const Vector4& vec); 01779 void setNamedConstant(const String& name, const Vector3& vec); 01784 void setNamedConstant(const String& name, const Vector2& vec); 01789 void setNamedConstant(const String& name, const Matrix4& m); 01797 void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries); 01814 void setNamedConstant(const String& name, const float *val, size_t count, 01815 size_t multiple = 4); 01832 void setNamedConstant(const String& name, const double *val, size_t count, 01833 size_t multiple = 4); 01838 void setNamedConstant(const String& name, const ColourValue& colour); 01839 01856 void setNamedConstant(const String& name, const int *val, size_t count, 01857 size_t multiple = 4); 01858 01873 void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0); 01874 void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData); 01875 01891 void setNamedAutoConstant(const String& name, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2); 01892 01900 void setNamedConstantFromTime(const String& name, Real factor); 01901 01903 void clearNamedAutoConstant(const String& name); 01904 01914 const GpuConstantDefinition* _findNamedConstantDefinition( 01915 const String& name, bool throwExceptionIfMissing = false) const; 01922 size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability); 01929 size_t _getDoubleConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability); 01936 size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability); 01937 01945 void setTransposeMatrices(bool val) { mTransposeMatrices = val; } 01947 bool getTransposeMatrices(void) const { return mTransposeMatrices; } 01948 01955 void copyConstantsFrom(const GpuProgramParameters& source); 01956 01965 void copyMatchingNamedConstantsFrom(const GpuProgramParameters& source); 01966 01970 static const AutoConstantDefinition* getAutoConstantDefinition(const String& name); 01975 static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx); 01978 static size_t getNumAutoConstantDefinitions(void); 01979 01980 01983 void incPassIterationNumber(void); 01985 bool hasPassIterationNumber() const 01986 { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); } 01988 size_t getPassIterationNumberIndex() const 01989 { return mActivePassIterationIndex; } 01990 01991 01997 void addSharedParameters(GpuSharedParametersPtr sharedParams); 01998 02006 void addSharedParameters(const String& sharedParamsName); 02007 02009 bool isUsingSharedParameters(const String& sharedParamsName) const; 02010 02012 void removeSharedParameters(const String& sharedParamsName); 02013 02015 void removeAllSharedParameters(); 02016 02018 const GpuSharedParamUsageList& getSharedParameters() const; 02019 02021 void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; } 02023 const Any& _getRenderSystemData() const { return mRenderSystemData; } 02024 02032 void _copySharedParams(); 02033 02034 size_t calculateSize(void) const; 02035 02038 void setNamedSubroutine(const String& subroutineSlot, const String& subroutine); 02039 02042 void setSubroutine(size_t index, const String& subroutine); 02043 02046 const SubroutineMap& getSubroutineMap() const { return mSubroutineMap; } 02047 }; 02048 02050 typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr; 02051 02054 } 02055 02056 #include "OgreHeaderSuffix.h" 02057 02058 #endif 02059
Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Mon Jul 27 2020 13:40:43