OgreGpuProgram.h

Go to the documentation of this file.
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
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Thu Aug 28 20:53:47 2008