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-2006 Torus Knot Software Ltd 00008 Also see acknowledgements in Readme.html 00009 00010 This program is free software; you can redistribute it and/or modify it under 00011 the terms of the GNU Lesser General Public License as published by the Free Software 00012 Foundation; either version 2 of the License, or (at your option) any later 00013 version. 00014 00015 This program is distributed in the hope that it will be useful, but WITHOUT 00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. 00018 00019 You should have received a copy of the GNU Lesser General Public License along with 00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple 00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to 00022 http://www.gnu.org/copyleft/lesser.txt. 00023 00024 You may alternatively use this source under the terms of a specific version of 00025 the OGRE Unrestricted License provided you have obtained such a license from 00026 Torus Knot Software Ltd. 00027 ----------------------------------------------------------------------------- 00028 */ 00029 #ifndef __GpuProgram_H_ 00030 #define __GpuProgram_H_ 00031 00032 // Precompiler options 00033 #include "OgrePrerequisites.h" 00034 #include "OgreResource.h" 00035 #include "OgreSharedPtr.h" 00036 #include "OgreIteratorWrappers.h" 00037 #include "OgreSerializer.h" 00038 #include "OgreRenderOperation.h" 00039 00040 namespace Ogre { 00041 00043 enum GpuProgramType 00044 { 00045 GPT_VERTEX_PROGRAM, 00046 GPT_FRAGMENT_PROGRAM, 00047 GPT_GEOMETRY_PROGRAM 00048 }; 00049 00055 enum GpuConstantType 00056 { 00057 GCT_FLOAT1 = 1, 00058 GCT_FLOAT2 = 2, 00059 GCT_FLOAT3 = 3, 00060 GCT_FLOAT4 = 4, 00061 GCT_SAMPLER1D = 5, 00062 GCT_SAMPLER2D = 6, 00063 GCT_SAMPLER3D = 7, 00064 GCT_SAMPLERCUBE = 8, 00065 GCT_SAMPLER1DSHADOW = 9, 00066 GCT_SAMPLER2DSHADOW = 10, 00067 GCT_MATRIX_2X2 = 11, 00068 GCT_MATRIX_2X3 = 12, 00069 GCT_MATRIX_2X4 = 13, 00070 GCT_MATRIX_3X2 = 14, 00071 GCT_MATRIX_3X3 = 15, 00072 GCT_MATRIX_3X4 = 16, 00073 GCT_MATRIX_4X2 = 17, 00074 GCT_MATRIX_4X3 = 18, 00075 GCT_MATRIX_4X4 = 19, 00076 GCT_INT1 = 20, 00077 GCT_INT2 = 21, 00078 GCT_INT3 = 22, 00079 GCT_INT4 = 23, 00080 GCT_UNKNOWN = 99 00081 }; 00082 00087 struct _OgreExport GpuConstantDefinition 00088 { 00090 GpuConstantType constType; 00092 size_t physicalIndex; 00094 size_t logicalIndex; 00097 size_t elementSize; 00099 size_t arraySize; 00100 00101 bool isFloat() const 00102 { 00103 switch(constType) 00104 { 00105 case GCT_INT1: 00106 case GCT_INT2: 00107 case GCT_INT3: 00108 case GCT_INT4: 00109 case GCT_SAMPLER1D: 00110 case GCT_SAMPLER2D: 00111 case GCT_SAMPLER3D: 00112 case GCT_SAMPLERCUBE: 00113 case GCT_SAMPLER1DSHADOW: 00114 case GCT_SAMPLER2DSHADOW: 00115 return false; 00116 default: 00117 return true; 00118 }; 00119 00120 } 00121 00122 bool isSampler() const 00123 { 00124 switch(constType) 00125 { 00126 case GCT_SAMPLER1D: 00127 case GCT_SAMPLER2D: 00128 case GCT_SAMPLER3D: 00129 case GCT_SAMPLERCUBE: 00130 case GCT_SAMPLER1DSHADOW: 00131 case GCT_SAMPLER2DSHADOW: 00132 return true; 00133 default: 00134 return false; 00135 }; 00136 00137 } 00138 00139 GpuConstantDefinition() 00140 : constType(GCT_UNKNOWN) 00141 , physicalIndex((std::numeric_limits<size_t>::max)()) 00142 , elementSize(0) 00143 , arraySize(1) {} 00144 }; 00145 typedef std::map<String, GpuConstantDefinition> GpuConstantDefinitionMap; 00146 typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator; 00147 00149 struct _OgreExport GpuNamedConstants 00150 { 00152 size_t floatBufferSize; 00154 size_t intBufferSize; 00156 GpuConstantDefinitionMap map; 00157 00169 void generateConstantDefinitionArrayEntries(const String& paramName, 00170 const GpuConstantDefinition& baseDef); 00171 00173 static bool getGenerateAllConstantDefinitionArrayEntries(); 00174 00181 static void setGenerateAllConstantDefinitionArrayEntries(bool generateAll); 00182 00186 void save(const String& filename) const; 00190 void load(DataStreamPtr& stream); 00191 00192 protected: 00199 static bool msGenerateAllConstantDefinitionArrayEntries; 00200 }; 00201 00203 class _OgreExport GpuNamedConstantsSerializer : public Serializer 00204 { 00205 public: 00206 GpuNamedConstantsSerializer(); 00207 virtual ~GpuNamedConstantsSerializer(); 00208 void exportNamedConstants(const GpuNamedConstants* pConsts, const String& filename, 00209 Endian endianMode = ENDIAN_NATIVE); 00210 void importNamedConstants(DataStreamPtr& stream, GpuNamedConstants* pDest); 00211 }; 00212 00216 struct _OgreExport GpuLogicalIndexUse 00217 { 00219 size_t physicalIndex; 00221 size_t currentSize; 00222 00223 GpuLogicalIndexUse(size_t bufIdx, size_t curSz) 00224 : physicalIndex(bufIdx), currentSize(curSz) {} 00225 }; 00226 typedef std::map<size_t, GpuLogicalIndexUse> GpuLogicalIndexUseMap; 00228 struct _OgreExport GpuLogicalBufferStruct 00229 { 00230 OGRE_MUTEX(mutex) 00232 GpuLogicalIndexUseMap map; 00234 size_t bufferSize; 00235 GpuLogicalBufferStruct() : bufferSize(0) {} 00236 }; 00237 00268 class _OgreExport GpuProgramParameters : public GpuParamsAlloc 00269 { 00270 public: 00274 enum AutoConstantType 00275 { 00277 ACT_WORLD_MATRIX, 00279 ACT_INVERSE_WORLD_MATRIX, 00283 ACT_TRANSPOSE_WORLD_MATRIX, 00285 ACT_INVERSE_TRANSPOSE_WORLD_MATRIX, 00286 00287 00289 ACT_WORLD_MATRIX_ARRAY_3x4, 00291 ACT_WORLD_MATRIX_ARRAY, 00292 00294 ACT_VIEW_MATRIX, 00296 ACT_INVERSE_VIEW_MATRIX, 00300 ACT_TRANSPOSE_VIEW_MATRIX, 00304 ACT_INVERSE_TRANSPOSE_VIEW_MATRIX, 00305 00306 00308 ACT_PROJECTION_MATRIX, 00312 ACT_INVERSE_PROJECTION_MATRIX, 00316 ACT_TRANSPOSE_PROJECTION_MATRIX, 00320 ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX, 00321 00322 00324 ACT_VIEWPROJ_MATRIX, 00328 ACT_INVERSE_VIEWPROJ_MATRIX, 00332 ACT_TRANSPOSE_VIEWPROJ_MATRIX, 00336 ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX, 00337 00338 00340 ACT_WORLDVIEW_MATRIX, 00342 ACT_INVERSE_WORLDVIEW_MATRIX, 00346 ACT_TRANSPOSE_WORLDVIEW_MATRIX, 00348 ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX, 00350 00351 00353 ACT_WORLDVIEWPROJ_MATRIX, 00357 ACT_INVERSE_WORLDVIEWPROJ_MATRIX, 00361 ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX, 00365 ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX, 00366 00367 00369 00372 ACT_RENDER_TARGET_FLIPPING, 00373 00374 00376 ACT_FOG_COLOUR, 00378 ACT_FOG_PARAMS, 00379 00380 00382 ACT_SURFACE_AMBIENT_COLOUR, 00384 ACT_SURFACE_DIFFUSE_COLOUR, 00386 ACT_SURFACE_SPECULAR_COLOUR, 00388 ACT_SURFACE_EMISSIVE_COLOUR, 00390 ACT_SURFACE_SHININESS, 00391 00392 00394 ACT_LIGHT_COUNT, 00395 00396 00398 ACT_AMBIENT_LIGHT_COLOUR, 00399 00401 ACT_LIGHT_DIFFUSE_COLOUR, 00403 ACT_LIGHT_SPECULAR_COLOUR, 00405 ACT_LIGHT_ATTENUATION, 00411 ACT_SPOTLIGHT_PARAMS, 00413 ACT_LIGHT_POSITION, 00415 ACT_LIGHT_POSITION_OBJECT_SPACE, 00417 ACT_LIGHT_POSITION_VIEW_SPACE, 00419 ACT_LIGHT_DIRECTION, 00421 ACT_LIGHT_DIRECTION_OBJECT_SPACE, 00423 ACT_LIGHT_DIRECTION_VIEW_SPACE, 00428 ACT_LIGHT_DISTANCE_OBJECT_SPACE, 00430 ACT_LIGHT_POWER_SCALE, 00432 ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED, 00434 ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED, 00436 ACT_LIGHT_DIFFUSE_COLOUR_ARRAY, 00438 ACT_LIGHT_SPECULAR_COLOUR_ARRAY, 00440 ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY, 00442 ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY, 00444 ACT_LIGHT_ATTENUATION_ARRAY, 00446 ACT_LIGHT_POSITION_ARRAY, 00448 ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY, 00450 ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY, 00452 ACT_LIGHT_DIRECTION_ARRAY, 00454 ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY, 00456 ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY, 00461 ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY, 00465 ACT_LIGHT_POWER_SCALE_ARRAY, 00472 ACT_SPOTLIGHT_PARAMS_ARRAY, 00473 00478 ACT_DERIVED_AMBIENT_LIGHT_COLOUR, 00483 ACT_DERIVED_SCENE_COLOUR, 00484 00490 ACT_DERIVED_LIGHT_DIFFUSE_COLOUR, 00496 ACT_DERIVED_LIGHT_SPECULAR_COLOUR, 00497 00499 ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY, 00501 ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY, 00508 ACT_LIGHT_NUMBER, 00510 ACT_LIGHT_CASTS_SHADOWS, 00511 00512 00516 ACT_SHADOW_EXTRUSION_DISTANCE, 00518 ACT_CAMERA_POSITION, 00520 ACT_CAMERA_POSITION_OBJECT_SPACE, 00522 ACT_TEXTURE_VIEWPROJ_MATRIX, 00524 ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY, 00528 ACT_TEXTURE_WORLDVIEWPROJ_MATRIX, 00530 ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY, 00532 ACT_SPOTLIGHT_VIEWPROJ_MATRIX, 00536 ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX, 00538 ACT_CUSTOM, 00541 ACT_TIME, 00545 ACT_TIME_0_X, 00547 ACT_COSTIME_0_X, 00549 ACT_SINTIME_0_X, 00551 ACT_TANTIME_0_X, 00555 ACT_TIME_0_X_PACKED, 00560 ACT_TIME_0_1, 00562 ACT_COSTIME_0_1, 00564 ACT_SINTIME_0_1, 00566 ACT_TANTIME_0_1, 00570 ACT_TIME_0_1_PACKED, 00575 ACT_TIME_0_2PI, 00577 ACT_COSTIME_0_2PI, 00579 ACT_SINTIME_0_2PI, 00581 ACT_TANTIME_0_2PI, 00585 ACT_TIME_0_2PI_PACKED, 00587 ACT_FRAME_TIME, 00589 ACT_FPS, 00591 00594 ACT_VIEWPORT_WIDTH, 00598 ACT_VIEWPORT_HEIGHT, 00602 ACT_INVERSE_VIEWPORT_WIDTH, 00606 ACT_INVERSE_VIEWPORT_HEIGHT, 00610 ACT_VIEWPORT_SIZE, 00611 00613 00616 ACT_VIEW_DIRECTION, 00620 ACT_VIEW_SIDE_VECTOR, 00624 ACT_VIEW_UP_VECTOR, 00628 ACT_FOV, 00632 ACT_NEAR_CLIP_DISTANCE, 00636 ACT_FAR_CLIP_DISTANCE, 00637 00641 ACT_PASS_NUMBER, 00642 00647 ACT_PASS_ITERATION_NUMBER, 00648 00649 00653 ACT_ANIMATION_PARAMETRIC, 00654 00660 ACT_TEXEL_OFFSETS, 00661 00666 ACT_SCENE_DEPTH_RANGE, 00667 00673 ACT_SHADOW_SCENE_DEPTH_RANGE, 00674 00678 ACT_SHADOW_COLOUR, 00682 ACT_TEXTURE_SIZE, 00686 ACT_INVERSE_TEXTURE_SIZE, 00690 ACT_PACKED_TEXTURE_SIZE, 00691 00695 ACT_TEXTURE_MATRIX, 00696 00702 ACT_LOD_CAMERA_POSITION, 00708 ACT_LOD_CAMERA_POSITION_OBJECT_SPACE, 00709 }; 00710 00714 enum ACDataType { 00716 ACDT_NONE, 00718 ACDT_INT, 00720 ACDT_REAL 00721 }; 00722 00725 enum ElementType { 00726 ET_INT, 00727 ET_REAL 00728 }; 00729 00733 struct AutoConstantDefinition 00734 { 00735 AutoConstantType acType; 00736 String name; 00737 size_t elementCount; 00739 ElementType elementType; 00741 ACDataType dataType; 00742 00743 AutoConstantDefinition(AutoConstantType _acType, const String& _name, 00744 size_t _elementCount, ElementType _elementType, 00745 ACDataType _dataType) 00746 :acType(_acType), name(_name), elementCount(_elementCount), 00747 elementType(_elementType), dataType(_dataType) 00748 { 00749 00750 } 00751 }; 00752 00754 class AutoConstantEntry 00755 { 00756 public: 00758 AutoConstantType paramType; 00760 size_t physicalIndex; 00764 size_t elementCount; 00766 union{ 00767 size_t data; 00768 Real fData; 00769 }; 00770 00771 AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, 00772 size_t theElemCount = 4) 00773 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), data(theData) {} 00774 00775 AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, 00776 size_t theElemCount = 4) 00777 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), fData(theData) {} 00778 00779 }; 00780 // Auto parameter storage 00781 typedef std::vector<AutoConstantEntry> AutoConstantList; 00782 00787 typedef std::vector<float> FloatConstantList; 00792 typedef std::vector<int> IntConstantList; 00793 00794 protected: 00795 static AutoConstantDefinition AutoConstantDictionary[]; 00797 FloatConstantList mFloatConstants; 00799 IntConstantList mIntConstants; 00802 GpuLogicalBufferStruct* mFloatLogicalToPhysical; 00805 GpuLogicalBufferStruct* mIntLogicalToPhysical; 00807 const GpuNamedConstants* mNamedConstants; 00809 AutoConstantList mAutoConstants; 00811 bool mTransposeMatrices; 00813 bool mIgnoreMissingParams; 00815 size_t mActivePassIterationIndex; 00816 00817 public: 00818 GpuProgramParameters(); 00819 ~GpuProgramParameters() {} 00820 00822 GpuProgramParameters(const GpuProgramParameters& oth); 00824 GpuProgramParameters& operator=(const GpuProgramParameters& oth); 00825 00827 void _setNamedConstants(const GpuNamedConstants* constantmap); 00828 00830 void _setLogicalIndexes(GpuLogicalBufferStruct* floatIndexMap, 00831 GpuLogicalBufferStruct* intIndexMap); 00832 00833 00835 bool hasNamedParameters() const { return mNamedConstants != 0;} 00841 bool hasLogicalIndexedParameters() const { return mFloatLogicalToPhysical != 0;} 00842 00848 void setConstant(size_t index, const Vector4& vec); 00856 void setConstant(size_t index, Real val); 00864 void setConstant(size_t index, const Vector3& vec); 00871 void setConstant(size_t index, const Matrix4& m); 00879 void setConstant(size_t index, const Matrix4* m, size_t numEntries); 00886 void setConstant(size_t index, const float *val, size_t count); 00893 void setConstant(size_t index, const double *val, size_t count); 00899 void setConstant(size_t index, const ColourValue& colour); 00900 00915 void setConstant(size_t index, const int *val, size_t count); 00916 00923 void _writeRawConstants(size_t physicalIndex, const float* val, size_t count); 00930 void _writeRawConstants(size_t physicalIndex, const double* val, size_t count); 00937 void _writeRawConstants(size_t physicalIndex, const int* val, size_t count); 00944 void _readRawConstants(size_t physicalIndex, size_t count, float* dest); 00951 void _readRawConstants(size_t physicalIndex, size_t count, int* dest); 00952 00963 void _writeRawConstant(size_t physicalIndex, const Vector4& vec, 00964 size_t count = 4); 00972 void _writeRawConstant(size_t physicalIndex, Real val); 00980 void _writeRawConstant(size_t physicalIndex, int val); 00988 void _writeRawConstant(size_t physicalIndex, const Vector3& vec); 00997 void _writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount = 16); 01005 void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries); 01015 void _writeRawConstant(size_t physicalIndex, const ColourValue& colour, 01016 size_t count = 4); 01017 01018 01024 GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const; 01025 01030 const GpuConstantDefinition& getConstantDefinition(const String& name) const; 01031 01036 const GpuNamedConstants& getConstantDefinitions() const; 01037 01043 const GpuLogicalBufferStruct* getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; } 01044 01050 size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex); 01056 size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex); 01057 01063 const GpuLogicalBufferStruct* getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; } 01065 const FloatConstantList& getFloatConstantList() const { return mFloatConstants; } 01067 float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; } 01069 const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; } 01071 const IntConstantList& getIntConstantList() const { return mIntConstants; } 01073 int* getIntPointer(size_t pos) { return &mIntConstants[pos]; } 01075 const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; } 01077 const AutoConstantList& getAutoConstantList() const { return mAutoConstants; } 01078 01092 void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0); 01093 void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData); 01094 01098 void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 01099 size_t elementSize = 4); 01103 void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData, 01104 size_t elementSize = 4); 01105 01106 01108 void clearAutoConstant(size_t index); 01109 01114 void setConstantFromTime(size_t index, Real factor); 01115 01117 void clearAutoConstants(void); 01118 typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator; 01120 AutoConstantIterator getAutoConstantIterator(void) const; 01122 size_t getAutoConstantCount(void) const { return mAutoConstants.size(); } 01127 AutoConstantEntry* getAutoConstantEntry(const size_t index); 01129 bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); } 01134 const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex); 01139 const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex); 01143 const AutoConstantEntry* findAutoConstantEntry(const String& paramName); 01147 const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex); 01151 const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex); 01152 01154 void _updateAutoParamsNoLights(const AutoParamDataSource* source); 01156 void _updateAutoParamsLightsOnly(const AutoParamDataSource* source); 01157 01160 void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; } 01161 01181 void setNamedConstant(const String& name, Real val); 01201 void setNamedConstant(const String& name, int val); 01206 void setNamedConstant(const String& name, const Vector4& vec); 01219 void setNamedConstant(const String& name, const Vector3& vec); 01224 void setNamedConstant(const String& name, const Matrix4& m); 01232 void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries); 01249 void setNamedConstant(const String& name, const float *val, size_t count, 01250 size_t multiple = 4); 01267 void setNamedConstant(const String& name, const double *val, size_t count, 01268 size_t multiple = 4); 01273 void setNamedConstant(const String& name, const ColourValue& colour); 01274 01291 void setNamedConstant(const String& name, const int *val, size_t count, 01292 size_t multiple = 4); 01293 01308 void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0); 01309 void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData); 01310 01318 void setNamedConstantFromTime(const String& name, Real factor); 01319 01321 void clearNamedAutoConstant(const String& name); 01322 01332 const GpuConstantDefinition* _findNamedConstantDefinition( 01333 const String& name, bool throwExceptionIfMissing = false) const; 01340 size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize); 01347 size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize); 01348 01349 01357 void setTransposeMatrices(bool val) { mTransposeMatrices = val; } 01359 bool getTransposeMatrices(void) const { return mTransposeMatrices; } 01360 01364 void copyConstantsFrom(const GpuProgramParameters& source); 01365 01369 static const AutoConstantDefinition* getAutoConstantDefinition(const String& name); 01374 static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx); 01377 static size_t getNumAutoConstantDefinitions(void); 01378 01379 01382 void incPassIterationNumber(void); 01384 bool hasPassIterationNumber() const 01385 { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); } 01387 size_t getPassIterationNumberIndex() const 01388 { return mActivePassIterationIndex; } 01389 01390 01391 }; 01392 01394 typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr; 01395 01396 // Forward declaration 01397 class GpuProgramPtr; 01398 01408 class _OgreExport GpuProgram : public Resource 01409 { 01410 protected: 01412 class _OgreExport CmdType : public ParamCommand 01413 { 01414 public: 01415 String doGet(const void* target) const; 01416 void doSet(void* target, const String& val); 01417 }; 01418 class _OgreExport CmdSyntax : public ParamCommand 01419 { 01420 public: 01421 String doGet(const void* target) const; 01422 void doSet(void* target, const String& val); 01423 }; 01424 class _OgreExport CmdSkeletal : public ParamCommand 01425 { 01426 public: 01427 String doGet(const void* target) const; 01428 void doSet(void* target, const String& val); 01429 }; 01430 class _OgreExport CmdMorph : public ParamCommand 01431 { 01432 public: 01433 String doGet(const void* target) const; 01434 void doSet(void* target, const String& val); 01435 }; 01436 class _OgreExport CmdPose : public ParamCommand 01437 { 01438 public: 01439 String doGet(const void* target) const; 01440 void doSet(void* target, const String& val); 01441 }; 01442 class _OgreExport CmdVTF : public ParamCommand 01443 { 01444 public: 01445 String doGet(const void* target) const; 01446 void doSet(void* target, const String& val); 01447 }; 01448 class _OgreExport CmdManualNamedConstsFile : public ParamCommand 01449 { 01450 public: 01451 String doGet(const void* target) const; 01452 void doSet(void* target, const String& val); 01453 }; 01454 class _OgreExport CmdAdjacency : public ParamCommand 01455 { 01456 public: 01457 String doGet(const void* target) const; 01458 void doSet(void* target, const String& val); 01459 }; 01460 // Command object for setting / getting parameters 01461 static CmdType msTypeCmd; 01462 static CmdSyntax msSyntaxCmd; 01463 static CmdSkeletal msSkeletalCmd; 01464 static CmdMorph msMorphCmd; 01465 static CmdPose msPoseCmd; 01466 static CmdVTF msVTFCmd; 01467 static CmdManualNamedConstsFile msManNamedConstsFileCmd; 01468 static CmdAdjacency msAdjacencyCmd; 01470 GpuProgramType mType; 01472 String mFilename; 01474 String mSource; 01476 bool mLoadFromFile; 01478 String mSyntaxCode; 01480 bool mSkeletalAnimation; 01482 bool mMorphAnimation; 01484 ushort mPoseAnimation; 01486 bool mVertexTextureFetch; 01488 bool mNeedsAdjacencyInfo; 01490 GpuProgramParametersSharedPtr mDefaultParams; 01492 bool mPassSurfaceAndLightStates; 01494 bool mCompileError; 01497 mutable GpuLogicalBufferStruct mFloatLogicalToPhysical; 01500 mutable GpuLogicalBufferStruct mIntLogicalToPhysical; 01502 mutable GpuNamedConstants mConstantDefs; 01504 String mManualNamedConstantsFile; 01505 bool mLoadedManualNamedConstants; 01506 01507 01516 void setupBaseParamDictionary(void); 01517 01520 bool isRequiredCapabilitiesSupported(void) const; 01521 01523 size_t calculateSize(void) const { return 0; } // TODO 01524 01526 void loadImpl(void); 01527 public: 01528 01529 GpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle, 01530 const String& group, bool isManual = false, ManualResourceLoader* loader = 0); 01531 01532 virtual ~GpuProgram() {} 01533 01538 virtual void setSourceFile(const String& filename); 01539 01544 virtual void setSource(const String& source); 01545 01547 virtual const String& getSyntaxCode(void) const { return mSyntaxCode; } 01548 01550 virtual void setSyntaxCode(const String& syntax); 01551 01553 virtual const String& getSourceFile(void) const { return mFilename; } 01555 virtual const String& getSource(void) const { return mSource; } 01557 virtual void setType(GpuProgramType t); 01559 virtual GpuProgramType getType(void) const { return mType; } 01560 01565 virtual GpuProgram* _getBindingDelegate(void) { return this; } 01566 01568 virtual bool isSupported(void) const; 01569 01577 virtual GpuProgramParametersSharedPtr createParameters(void); 01578 01585 virtual void setSkeletalAnimationIncluded(bool included) 01586 { mSkeletalAnimation = included; } 01587 01594 virtual bool isSkeletalAnimationIncluded(void) const { return mSkeletalAnimation; } 01595 01602 virtual void setMorphAnimationIncluded(bool included) 01603 { mMorphAnimation = included; } 01604 01612 virtual void setPoseAnimationIncluded(ushort poseCount) 01613 { mPoseAnimation = poseCount; } 01614 01621 virtual bool isMorphAnimationIncluded(void) const { return mMorphAnimation; } 01622 01629 virtual bool isPoseAnimationIncluded(void) const { return mPoseAnimation > 0; } 01633 virtual ushort getNumberOfPosesIncluded(void) const { return mPoseAnimation; } 01637 virtual void setVertexTextureFetchRequired(bool r) { mVertexTextureFetch = r; } 01641 virtual bool isVertexTextureFetchRequired(void) const { return mVertexTextureFetch; } 01642 01646 virtual void setAdjacencyInfoRequired(bool r) { mNeedsAdjacencyInfo = r; } 01650 virtual bool isAdjacencyInfoRequired(void) const { return mNeedsAdjacencyInfo; } 01651 01662 virtual GpuProgramParametersSharedPtr getDefaultParameters(void); 01663 01666 virtual bool hasDefaultParameters(void) const { return !mDefaultParams.isNull(); } 01667 01676 virtual void setSurfaceAndPassLightStates(bool state) 01677 { mPassSurfaceAndLightStates = state; } 01678 01682 virtual bool getPassSurfaceAndLightStates(void) const { return mPassSurfaceAndLightStates; } 01683 01687 virtual const String& getLanguage(void) const; 01688 01691 virtual bool hasCompileError(void) const { return mCompileError; } 01692 01695 virtual void resetCompileError(void) { mCompileError = false; } 01696 01705 virtual void setManualNamedConstants(const GpuNamedConstants& namedConstants); 01706 01708 virtual const GpuNamedConstants& getNamedConstants() const { return mConstantDefs; } 01709 01720 virtual void setManualNamedConstantsFile(const String& paramDefFile); 01721 01725 virtual const String& getManualNamedConstantsFile() const { return mManualNamedConstantsFile; } 01732 virtual const GpuNamedConstants& getConstantDefinitions() const { return mConstantDefs; } 01733 01734 01735 protected: 01737 virtual void loadFromSource(void) = 0; 01738 01739 }; 01740 01741 01748 class _OgreExport GpuProgramPtr : public SharedPtr<GpuProgram> 01749 { 01750 public: 01751 GpuProgramPtr() : SharedPtr<GpuProgram>() {} 01752 explicit GpuProgramPtr(GpuProgram* rep) : SharedPtr<GpuProgram>(rep) {} 01753 GpuProgramPtr(const GpuProgramPtr& r) : SharedPtr<GpuProgram>(r) {} 01754 GpuProgramPtr(const ResourcePtr& r) : SharedPtr<GpuProgram>() 01755 { 01756 // lock & copy other mutex pointer 01757 OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME) 01758 { 01759 OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME) 01760 OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME) 01761 pRep = static_cast<GpuProgram*>(r.getPointer()); 01762 pUseCount = r.useCountPointer(); 01763 if (pUseCount) 01764 { 01765 ++(*pUseCount); 01766 } 01767 } 01768 } 01769 01771 GpuProgramPtr& operator=(const ResourcePtr& r) 01772 { 01773 if (pRep == static_cast<GpuProgram*>(r.getPointer())) 01774 return *this; 01775 release(); 01776 // lock & copy other mutex pointer 01777 OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME) 01778 { 01779 OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME) 01780 OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME) 01781 pRep = static_cast<GpuProgram*>(r.getPointer()); 01782 pUseCount = r.useCountPointer(); 01783 if (pUseCount) 01784 { 01785 ++(*pUseCount); 01786 } 01787 } 01788 else 01789 { 01790 // RHS must be a null pointer 01791 assert(r.isNull() && "RHS must be null if it has no mutex!"); 01792 setNull(); 01793 } 01794 return *this; 01795 } 01797 GpuProgramPtr& operator=(const HighLevelGpuProgramPtr& r); 01798 }; 01799 } 01800 01801 #endif
Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 27 22:02:23 2009