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 }; 00697 00701 enum ACDataType { 00703 ACDT_NONE, 00705 ACDT_INT, 00707 ACDT_REAL 00708 }; 00709 00712 enum ElementType { 00713 ET_INT, 00714 ET_REAL 00715 }; 00716 00720 struct AutoConstantDefinition 00721 { 00722 AutoConstantType acType; 00723 String name; 00724 size_t elementCount; 00726 ElementType elementType; 00728 ACDataType dataType; 00729 00730 AutoConstantDefinition(AutoConstantType _acType, const String& _name, 00731 size_t _elementCount, ElementType _elementType, 00732 ACDataType _dataType) 00733 :acType(_acType), name(_name), elementCount(_elementCount), 00734 elementType(_elementType), dataType(_dataType) 00735 { 00736 00737 } 00738 }; 00739 00741 class AutoConstantEntry 00742 { 00743 public: 00745 AutoConstantType paramType; 00747 size_t physicalIndex; 00751 size_t elementCount; 00753 union{ 00754 size_t data; 00755 Real fData; 00756 }; 00757 00758 AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, 00759 size_t theElemCount = 4) 00760 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), data(theData) {} 00761 00762 AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, 00763 size_t theElemCount = 4) 00764 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), fData(theData) {} 00765 00766 }; 00767 // Auto parameter storage 00768 typedef std::vector<AutoConstantEntry> AutoConstantList; 00769 00774 typedef std::vector<float> FloatConstantList; 00779 typedef std::vector<int> IntConstantList; 00780 00781 protected: 00782 static AutoConstantDefinition AutoConstantDictionary[]; 00784 FloatConstantList mFloatConstants; 00786 IntConstantList mIntConstants; 00789 GpuLogicalBufferStruct* mFloatLogicalToPhysical; 00792 GpuLogicalBufferStruct* mIntLogicalToPhysical; 00794 const GpuNamedConstants* mNamedConstants; 00796 AutoConstantList mAutoConstants; 00798 bool mTransposeMatrices; 00800 bool mIgnoreMissingParams; 00802 size_t mActivePassIterationIndex; 00803 00804 public: 00805 GpuProgramParameters(); 00806 ~GpuProgramParameters() {} 00807 00809 GpuProgramParameters(const GpuProgramParameters& oth); 00811 GpuProgramParameters& operator=(const GpuProgramParameters& oth); 00812 00814 void _setNamedConstants(const GpuNamedConstants* constantmap); 00815 00817 void _setLogicalIndexes(GpuLogicalBufferStruct* floatIndexMap, 00818 GpuLogicalBufferStruct* intIndexMap); 00819 00820 00822 bool hasNamedParameters() const { return mNamedConstants != 0;} 00828 bool hasLogicalIndexedParameters() const { return mFloatLogicalToPhysical != 0;} 00829 00835 void setConstant(size_t index, const Vector4& vec); 00843 void setConstant(size_t index, Real val); 00851 void setConstant(size_t index, const Vector3& vec); 00858 void setConstant(size_t index, const Matrix4& m); 00866 void setConstant(size_t index, const Matrix4* m, size_t numEntries); 00873 void setConstant(size_t index, const float *val, size_t count); 00880 void setConstant(size_t index, const double *val, size_t count); 00886 void setConstant(size_t index, const ColourValue& colour); 00887 00902 void setConstant(size_t index, const int *val, size_t count); 00903 00910 void _writeRawConstants(size_t physicalIndex, const float* val, size_t count); 00917 void _writeRawConstants(size_t physicalIndex, const double* val, size_t count); 00924 void _writeRawConstants(size_t physicalIndex, const int* val, size_t count); 00931 void _readRawConstants(size_t physicalIndex, size_t count, float* dest); 00938 void _readRawConstants(size_t physicalIndex, size_t count, int* dest); 00939 00950 void _writeRawConstant(size_t physicalIndex, const Vector4& vec, 00951 size_t count = 4); 00959 void _writeRawConstant(size_t physicalIndex, Real val); 00967 void _writeRawConstant(size_t physicalIndex, int val); 00975 void _writeRawConstant(size_t physicalIndex, const Vector3& vec); 00983 void _writeRawConstant(size_t physicalIndex, const Matrix4& m); 00991 void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries); 01001 void _writeRawConstant(size_t physicalIndex, const ColourValue& colour, 01002 size_t count = 4); 01003 01004 01010 GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const; 01011 01016 const GpuConstantDefinition& getConstantDefinition(const String& name) const; 01017 01022 const GpuNamedConstants& getConstantDefinitions() const; 01023 01029 const GpuLogicalBufferStruct* getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; } 01030 01036 size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex); 01042 size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex); 01043 01049 const GpuLogicalBufferStruct* getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; } 01051 const FloatConstantList& getFloatConstantList() const { return mFloatConstants; } 01053 float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; } 01055 const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; } 01057 const IntConstantList& getIntConstantList() const { return mIntConstants; } 01059 int* getIntPointer(size_t pos) { return &mIntConstants[pos]; } 01061 const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; } 01063 const AutoConstantList& getAutoConstantList() const { return mAutoConstants; } 01064 01078 void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0); 01079 void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData); 01080 01084 void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 01085 size_t elementSize = 4); 01089 void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData, 01090 size_t elementSize = 4); 01091 01092 01094 void clearAutoConstant(size_t index); 01095 01100 void setConstantFromTime(size_t index, Real factor); 01101 01103 void clearAutoConstants(void); 01104 typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator; 01106 AutoConstantIterator getAutoConstantIterator(void) const; 01108 size_t getAutoConstantCount(void) const { return mAutoConstants.size(); } 01113 AutoConstantEntry* getAutoConstantEntry(const size_t index); 01115 bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); } 01120 const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex); 01125 const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex); 01129 const AutoConstantEntry* findAutoConstantEntry(const String& paramName); 01133 const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex); 01137 const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex); 01138 01140 void _updateAutoParamsNoLights(const AutoParamDataSource* source); 01142 void _updateAutoParamsLightsOnly(const AutoParamDataSource* source); 01143 01146 void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; } 01147 01167 void setNamedConstant(const String& name, Real val); 01187 void setNamedConstant(const String& name, int val); 01192 void setNamedConstant(const String& name, const Vector4& vec); 01205 void setNamedConstant(const String& name, const Vector3& vec); 01210 void setNamedConstant(const String& name, const Matrix4& m); 01218 void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries); 01235 void setNamedConstant(const String& name, const float *val, size_t count, 01236 size_t multiple = 4); 01253 void setNamedConstant(const String& name, const double *val, size_t count, 01254 size_t multiple = 4); 01259 void setNamedConstant(const String& name, const ColourValue& colour); 01260 01277 void setNamedConstant(const String& name, const int *val, size_t count, 01278 size_t multiple = 4); 01279 01294 void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0); 01295 void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData); 01296 01304 void setNamedConstantFromTime(const String& name, Real factor); 01305 01307 void clearNamedAutoConstant(const String& name); 01308 01318 const GpuConstantDefinition* _findNamedConstantDefinition( 01319 const String& name, bool throwExceptionIfMissing = false) const; 01326 size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize); 01333 size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize); 01334 01335 01343 void setTransposeMatrices(bool val) { mTransposeMatrices = val; } 01345 bool getTransposeMatrices(void) const { return mTransposeMatrices; } 01346 01350 void copyConstantsFrom(const GpuProgramParameters& source); 01351 01355 static const AutoConstantDefinition* getAutoConstantDefinition(const String& name); 01360 static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx); 01363 static size_t getNumAutoConstantDefinitions(void); 01364 01365 01368 void incPassIterationNumber(void); 01370 bool hasPassIterationNumber() const 01371 { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); } 01373 size_t getPassIterationNumberIndex() const 01374 { return mActivePassIterationIndex; } 01375 01376 01377 }; 01378 01380 typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr; 01381 01382 // Forward declaration 01383 class GpuProgramPtr; 01384 01394 class _OgreExport GpuProgram : public Resource 01395 { 01396 protected: 01398 class _OgreExport CmdType : public ParamCommand 01399 { 01400 public: 01401 String doGet(const void* target) const; 01402 void doSet(void* target, const String& val); 01403 }; 01404 class _OgreExport CmdSyntax : public ParamCommand 01405 { 01406 public: 01407 String doGet(const void* target) const; 01408 void doSet(void* target, const String& val); 01409 }; 01410 class _OgreExport CmdSkeletal : public ParamCommand 01411 { 01412 public: 01413 String doGet(const void* target) const; 01414 void doSet(void* target, const String& val); 01415 }; 01416 class _OgreExport CmdMorph : public ParamCommand 01417 { 01418 public: 01419 String doGet(const void* target) const; 01420 void doSet(void* target, const String& val); 01421 }; 01422 class _OgreExport CmdPose : public ParamCommand 01423 { 01424 public: 01425 String doGet(const void* target) const; 01426 void doSet(void* target, const String& val); 01427 }; 01428 class _OgreExport CmdVTF : public ParamCommand 01429 { 01430 public: 01431 String doGet(const void* target) const; 01432 void doSet(void* target, const String& val); 01433 }; 01434 class _OgreExport CmdManualNamedConstsFile : public ParamCommand 01435 { 01436 public: 01437 String doGet(const void* target) const; 01438 void doSet(void* target, const String& val); 01439 }; 01440 class _OgreExport CmdAdjacency : public ParamCommand 01441 { 01442 public: 01443 String doGet(const void* target) const; 01444 void doSet(void* target, const String& val); 01445 }; 01446 // Command object for setting / getting parameters 01447 static CmdType msTypeCmd; 01448 static CmdSyntax msSyntaxCmd; 01449 static CmdSkeletal msSkeletalCmd; 01450 static CmdMorph msMorphCmd; 01451 static CmdPose msPoseCmd; 01452 static CmdVTF msVTFCmd; 01453 static CmdManualNamedConstsFile msManNamedConstsFileCmd; 01454 static CmdAdjacency msAdjacencyCmd; 01456 GpuProgramType mType; 01458 String mFilename; 01460 String mSource; 01462 bool mLoadFromFile; 01464 String mSyntaxCode; 01466 bool mSkeletalAnimation; 01468 bool mMorphAnimation; 01470 ushort mPoseAnimation; 01472 bool mVertexTextureFetch; 01474 bool mNeedsAdjacencyInfo; 01476 GpuProgramParametersSharedPtr mDefaultParams; 01478 bool mPassSurfaceAndLightStates; 01480 bool mCompileError; 01483 mutable GpuLogicalBufferStruct mFloatLogicalToPhysical; 01486 mutable GpuLogicalBufferStruct mIntLogicalToPhysical; 01488 mutable GpuNamedConstants mConstantDefs; 01490 String mManualNamedConstantsFile; 01491 bool mLoadedManualNamedConstants; 01492 01493 01502 void setupBaseParamDictionary(void); 01503 01506 bool isRequiredCapabilitiesSupported(void) const; 01507 01509 size_t calculateSize(void) const { return 0; } // TODO 01510 01512 void loadImpl(void); 01513 public: 01514 01515 GpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle, 01516 const String& group, bool isManual = false, ManualResourceLoader* loader = 0); 01517 01518 virtual ~GpuProgram() {} 01519 01524 virtual void setSourceFile(const String& filename); 01525 01530 virtual void setSource(const String& source); 01531 01533 virtual const String& getSyntaxCode(void) const { return mSyntaxCode; } 01534 01536 virtual void setSyntaxCode(const String& syntax); 01537 01539 virtual const String& getSourceFile(void) const { return mFilename; } 01541 virtual const String& getSource(void) const { return mSource; } 01543 virtual void setType(GpuProgramType t); 01545 virtual GpuProgramType getType(void) const { return mType; } 01546 01551 virtual GpuProgram* _getBindingDelegate(void) { return this; } 01552 01554 virtual bool isSupported(void) const; 01555 01563 virtual GpuProgramParametersSharedPtr createParameters(void); 01564 01571 virtual void setSkeletalAnimationIncluded(bool included) 01572 { mSkeletalAnimation = included; } 01573 01580 virtual bool isSkeletalAnimationIncluded(void) const { return mSkeletalAnimation; } 01581 01588 virtual void setMorphAnimationIncluded(bool included) 01589 { mMorphAnimation = included; } 01590 01598 virtual void setPoseAnimationIncluded(ushort poseCount) 01599 { mPoseAnimation = poseCount; } 01600 01607 virtual bool isMorphAnimationIncluded(void) const { return mMorphAnimation; } 01608 01615 virtual bool isPoseAnimationIncluded(void) const { return mPoseAnimation > 0; } 01619 virtual ushort getNumberOfPosesIncluded(void) const { return mPoseAnimation; } 01623 virtual void setVertexTextureFetchRequired(bool r) { mVertexTextureFetch = r; } 01627 virtual bool isVertexTextureFetchRequired(void) const { return mVertexTextureFetch; } 01628 01632 virtual void setAdjacencyInfoRequired(bool r) { mNeedsAdjacencyInfo = r; } 01636 virtual bool isAdjacencyInfoRequired(void) const { return mNeedsAdjacencyInfo; } 01637 01648 virtual GpuProgramParametersSharedPtr getDefaultParameters(void); 01649 01652 virtual bool hasDefaultParameters(void) const { return !mDefaultParams.isNull(); } 01653 01662 virtual void setSurfaceAndPassLightStates(bool state) 01663 { mPassSurfaceAndLightStates = state; } 01664 01668 virtual bool getPassSurfaceAndLightStates(void) const { return mPassSurfaceAndLightStates; } 01669 01673 virtual const String& getLanguage(void) const; 01674 01677 virtual bool hasCompileError(void) const { return mCompileError; } 01678 01681 virtual void resetCompileError(void) { mCompileError = false; } 01682 01691 virtual void setManualNamedConstants(const GpuNamedConstants& namedConstants); 01692 01694 virtual const GpuNamedConstants& getNamedConstants() const { return mConstantDefs; } 01695 01706 virtual void setManualNamedConstantsFile(const String& paramDefFile); 01707 01711 virtual const String& getManualNamedConstantsFile() const { return mManualNamedConstantsFile; } 01718 virtual const GpuNamedConstants& getConstantDefinitions() const { return mConstantDefs; } 01719 01720 01721 protected: 01723 virtual void loadFromSource(void) = 0; 01724 01725 }; 01726 01727 01734 class _OgreExport GpuProgramPtr : public SharedPtr<GpuProgram> 01735 { 01736 public: 01737 GpuProgramPtr() : SharedPtr<GpuProgram>() {} 01738 explicit GpuProgramPtr(GpuProgram* rep) : SharedPtr<GpuProgram>(rep) {} 01739 GpuProgramPtr(const GpuProgramPtr& r) : SharedPtr<GpuProgram>(r) {} 01740 GpuProgramPtr(const ResourcePtr& r) : SharedPtr<GpuProgram>() 01741 { 01742 // lock & copy other mutex pointer 01743 OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME) 01744 { 01745 OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME) 01746 OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME) 01747 pRep = static_cast<GpuProgram*>(r.getPointer()); 01748 pUseCount = r.useCountPointer(); 01749 if (pUseCount) 01750 { 01751 ++(*pUseCount); 01752 } 01753 } 01754 } 01755 01757 GpuProgramPtr& operator=(const ResourcePtr& r) 01758 { 01759 if (pRep == static_cast<GpuProgram*>(r.getPointer())) 01760 return *this; 01761 release(); 01762 // lock & copy other mutex pointer 01763 OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME) 01764 { 01765 OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME) 01766 OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME) 01767 pRep = static_cast<GpuProgram*>(r.getPointer()); 01768 pUseCount = r.useCountPointer(); 01769 if (pUseCount) 01770 { 01771 ++(*pUseCount); 01772 } 01773 } 01774 else 01775 { 01776 // RHS must be a null pointer 01777 assert(r.isNull() && "RHS must be null if it has no mutex!"); 01778 setNull(); 01779 } 01780 return *this; 01781 } 01783 GpuProgramPtr& operator=(const HighLevelGpuProgramPtr& r); 01784 }; 01785 } 01786 01787 #endif
Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Thu Aug 28 20:53:47 2008