- Main Page
- Namespaces
- Classes
- Files
- Directories
- Related Pages

# 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
    00038 namespace Ogre {
    00039
    00041     enum GpuProgramType
    00042     {
    00043         GPT_VERTEX_PROGRAM,
    00044         GPT_FRAGMENT_PROGRAM
    00045     };
    00046
    00052     enum GpuConstantType
    00053     {
    00054         GCT_FLOAT1,
    00055         GCT_FLOAT2,
    00056         GCT_FLOAT3,
    00057         GCT_FLOAT4,
    00058         GCT_SAMPLER1D,
    00059         GCT_SAMPLER2D,
    00060         GCT_SAMPLER3D,
    00061         GCT_SAMPLERCUBE,
    00062         GCT_SAMPLER1DSHADOW,
    00063         GCT_SAMPLER2DSHADOW,
    00064         GCT_MATRIX_2X2,
    00065         GCT_MATRIX_2X3,
    00066         GCT_MATRIX_2X4,
    00067         GCT_MATRIX_3X2,
    00068         GCT_MATRIX_3X3,
    00069         GCT_MATRIX_3X4,
    00070         GCT_MATRIX_4X2,
    00071         GCT_MATRIX_4X3,
    00072         GCT_MATRIX_4X4,
    00073         GCT_INT1,
    00074         GCT_INT2,
    00075         GCT_INT3,
    00076         GCT_INT4,
    00077         GCT_UNKNOWN
    00078     };
    00079
    00084     struct _OgreExport GpuConstantDefinition
    00085     {
    00087         GpuConstantType constType;
    00089         size_t physicalIndex;
    00092         size_t elementSize;
    00094         size_t arraySize;
    00095
    00096         bool isFloat() const
    00097         {
    00098             switch(constType)
    00099             {
    00100             case GCT_INT1:
    00101             case GCT_INT2:
    00102             case GCT_INT3:
    00103             case GCT_INT4:
    00104             case GCT_SAMPLER1D:
    00105             case GCT_SAMPLER2D:
    00106             case GCT_SAMPLER3D:
    00107             case GCT_SAMPLERCUBE:
    00108             case GCT_SAMPLER1DSHADOW:
    00109             case GCT_SAMPLER2DSHADOW:
    00110                 return false;
    00111             default:
    00112                 return true;
    00113             };
    00114
    00115         }
    00116
    00117         bool isSampler() const
    00118         {
    00119             switch(constType)
    00120             {
    00121             case GCT_SAMPLER1D:
    00122             case GCT_SAMPLER2D:
    00123             case GCT_SAMPLER3D:
    00124             case GCT_SAMPLERCUBE:
    00125             case GCT_SAMPLER1DSHADOW:
    00126             case GCT_SAMPLER2DSHADOW:
    00127                 return true;
    00128             default:
    00129                 return false;
    00130             };
    00131
    00132         }
    00133
    00134         GpuConstantDefinition()
    00135             : constType(GCT_UNKNOWN)
    00136             , physicalIndex((std::numeric_limits<size_t>::max)())
    00137             , elementSize(0)
    00138             , arraySize(1) {}
    00139     };
    00140     typedef std::map<String, GpuConstantDefinition> GpuConstantDefinitionMap;
    00141     typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator;
    00142
    00144     struct _OgreExport GpuNamedConstants
    00145     {
    00147         size_t floatBufferSize;
    00149         size_t intBufferSize;
    00151         GpuConstantDefinitionMap map;
    00152
    00164         void generateConstantDefinitionArrayEntries(const String& paramName,
    00165             const GpuConstantDefinition& baseDef);
    00166
    00167     };
    00168
    00172     struct _OgreExport GpuLogicalIndexUse
    00173     {
    00175         size_t physicalIndex;
    00177         size_t currentSize;
    00178
    00179         GpuLogicalIndexUse(size_t bufIdx, size_t curSz)
    00180             : physicalIndex(bufIdx), currentSize(curSz) {}
    00181     };
    00182     typedef std::map<size_t, GpuLogicalIndexUse> GpuLogicalIndexUseMap;
    00184     struct _OgreExport GpuLogicalBufferStruct
    00185     {
    00186         OGRE_MUTEX(mutex)
    00188         GpuLogicalIndexUseMap map;
    00190         size_t bufferSize;
    00191         GpuLogicalBufferStruct() : bufferSize(0) {}
    00192     };
    00193
    00224     class _OgreExport GpuProgramParameters
    00225     {
    00226     public:
    00230         enum AutoConstantType
    00231         {
    00233             ACT_WORLD_MATRIX,
    00235             ACT_INVERSE_WORLD_MATRIX,
    00239             ACT_TRANSPOSE_WORLD_MATRIX,
    00241             ACT_INVERSE_TRANSPOSE_WORLD_MATRIX,
    00242
    00243
    00245             ACT_WORLD_MATRIX_ARRAY_3x4,
    00247             ACT_WORLD_MATRIX_ARRAY,
    00248
    00250             ACT_VIEW_MATRIX,
    00252             ACT_INVERSE_VIEW_MATRIX,
    00256             ACT_TRANSPOSE_VIEW_MATRIX,
    00260             ACT_INVERSE_TRANSPOSE_VIEW_MATRIX,
    00261
    00262
    00264             ACT_PROJECTION_MATRIX,
    00268             ACT_INVERSE_PROJECTION_MATRIX,
    00272             ACT_TRANSPOSE_PROJECTION_MATRIX,
    00276             ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX,
    00277
    00278
    00280             ACT_VIEWPROJ_MATRIX,
    00284             ACT_INVERSE_VIEWPROJ_MATRIX,
    00288             ACT_TRANSPOSE_VIEWPROJ_MATRIX,
    00292             ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX,
    00293
    00294
    00296             ACT_WORLDVIEW_MATRIX,
    00298             ACT_INVERSE_WORLDVIEW_MATRIX,
    00302             ACT_TRANSPOSE_WORLDVIEW_MATRIX,
    00304             ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX,
    00306
    00307
    00309             ACT_WORLDVIEWPROJ_MATRIX,
    00313             ACT_INVERSE_WORLDVIEWPROJ_MATRIX,
    00317             ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
    00321             ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
    00322
    00323
    00325
    00328             ACT_RENDER_TARGET_FLIPPING,
    00329
    00330
    00332             ACT_FOG_COLOUR,
    00334             ACT_FOG_PARAMS,
    00335
    00336
    00338             ACT_SURFACE_AMBIENT_COLOUR,
    00340             ACT_SURFACE_DIFFUSE_COLOUR,
    00342             ACT_SURFACE_SPECULAR_COLOUR,
    00344             ACT_SURFACE_EMISSIVE_COLOUR,
    00346             ACT_SURFACE_SHININESS,
    00347
    00348
    00350             ACT_AMBIENT_LIGHT_COLOUR,
    00351
    00353             ACT_LIGHT_DIFFUSE_COLOUR,
    00355             ACT_LIGHT_SPECULAR_COLOUR,
    00357             ACT_LIGHT_ATTENUATION,
    00363             ACT_SPOTLIGHT_PARAMS,
    00365             ACT_LIGHT_POSITION,
    00367             ACT_LIGHT_POSITION_OBJECT_SPACE,
    00369             ACT_LIGHT_POSITION_VIEW_SPACE,
    00371             ACT_LIGHT_DIRECTION,
    00373             ACT_LIGHT_DIRECTION_OBJECT_SPACE,
    00375             ACT_LIGHT_DIRECTION_VIEW_SPACE,
    00380             ACT_LIGHT_DISTANCE_OBJECT_SPACE,
    00382             ACT_LIGHT_POWER_SCALE,
    00384             ACT_LIGHT_DIFFUSE_COLOUR_ARRAY,
    00386             ACT_LIGHT_SPECULAR_COLOUR_ARRAY,
    00388             ACT_LIGHT_ATTENUATION_ARRAY,
    00390             ACT_LIGHT_POSITION_ARRAY,
    00392             ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY,
    00394             ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY,
    00396             ACT_LIGHT_DIRECTION_ARRAY,
    00398             ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY,
    00400             ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY,
    00405             ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY,
    00409             ACT_LIGHT_POWER_SCALE_ARRAY,
    00416             ACT_SPOTLIGHT_PARAMS_ARRAY,
    00417
    00422             ACT_DERIVED_AMBIENT_LIGHT_COLOUR,
    00427             ACT_DERIVED_SCENE_COLOUR,
    00428
    00434             ACT_DERIVED_LIGHT_DIFFUSE_COLOUR,
    00440             ACT_DERIVED_LIGHT_SPECULAR_COLOUR,
    00441
    00443             ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY,
    00445             ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY,
    00446
    00447
    00451             ACT_SHADOW_EXTRUSION_DISTANCE,
    00453             ACT_CAMERA_POSITION,
    00455             ACT_CAMERA_POSITION_OBJECT_SPACE,
    00457             ACT_TEXTURE_VIEWPROJ_MATRIX,
    00459             ACT_CUSTOM,
    00462             ACT_TIME,
    00466             ACT_TIME_0_X,
    00468             ACT_COSTIME_0_X,
    00470             ACT_SINTIME_0_X,
    00472             ACT_TANTIME_0_X,
    00476             ACT_TIME_0_X_PACKED,
    00481             ACT_TIME_0_1,
    00483             ACT_COSTIME_0_1,
    00485             ACT_SINTIME_0_1,
    00487             ACT_TANTIME_0_1,
    00491             ACT_TIME_0_1_PACKED,
    00496             ACT_TIME_0_2PI,
    00498             ACT_COSTIME_0_2PI,
    00500             ACT_SINTIME_0_2PI,
    00502             ACT_TANTIME_0_2PI,
    00506             ACT_TIME_0_2PI_PACKED,
    00508             ACT_FRAME_TIME,
    00510             ACT_FPS,
    00512
    00515             ACT_VIEWPORT_WIDTH,
    00519             ACT_VIEWPORT_HEIGHT,
    00523             ACT_INVERSE_VIEWPORT_WIDTH,
    00527             ACT_INVERSE_VIEWPORT_HEIGHT,
    00531             ACT_VIEWPORT_SIZE,
    00532
    00534
    00537             ACT_VIEW_DIRECTION,
    00541             ACT_VIEW_SIDE_VECTOR,
    00545             ACT_VIEW_UP_VECTOR,
    00549             ACT_FOV,
    00553             ACT_NEAR_CLIP_DISTANCE,
    00557             ACT_FAR_CLIP_DISTANCE,
    00558
    00562             ACT_PASS_NUMBER,
    00563
    00568             ACT_PASS_ITERATION_NUMBER,
    00569
    00570
    00574             ACT_ANIMATION_PARAMETRIC,
    00575
    00581             ACT_TEXEL_OFFSETS,
    00582
    00587             ACT_SCENE_DEPTH_RANGE,
    00588
    00594             ACT_SHADOW_SCENE_DEPTH_RANGE,
    00595
    00599             ACT_TEXTURE_SIZE,
    00603             ACT_INVERSE_TEXTURE_SIZE,
    00607             ACT_PACKED_TEXTURE_SIZE,
    00608
    00609
    00610         };
    00611
    00615         enum ACDataType {
    00617             ACDT_NONE,
    00619             ACDT_INT,
    00621             ACDT_REAL
    00622         };
    00623
    00626         enum ElementType {
    00627             ET_INT,
    00628             ET_REAL
    00629         };
    00630
    00634         struct AutoConstantDefinition
    00635         {
    00636             AutoConstantType acType;
    00637             String name;
    00638             size_t elementCount;
    00640             ElementType elementType;
    00642             ACDataType dataType;
    00643
    00644             AutoConstantDefinition(AutoConstantType _acType, const String& _name,
    00645                 size_t _elementCount, ElementType _elementType,
    00646                 ACDataType _dataType)
    00647                 :acType(_acType), name(_name), elementCount(_elementCount),
    00648                 elementType(_elementType), dataType(_dataType)
    00649             {
    00650
    00651             }
    00652         };
    00653
    00655         class AutoConstantEntry
    00656         {
    00657         public:
    00659             AutoConstantType paramType;
    00661             size_t physicalIndex;
    00665             size_t elementCount;
    00667             union{
    00668                 size_t data;
    00669                 Real fData;
    00670             };
    00671
    00672             AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData,
    00673                 size_t theElemCount = 4)
    00674                 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), data(theData) {}
    00675
    00676             AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData,
    00677                 size_t theElemCount = 4)
    00678                 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), fData(theData) {}
    00679
    00680         };
    00681         // Auto parameter storage
    00682         typedef std::vector<AutoConstantEntry> AutoConstantList;
    00683
    00688         typedef std::vector<float> FloatConstantList;
    00693         typedef std::vector<int> IntConstantList;
    00694
    00695     protected:
    00696         static AutoConstantDefinition AutoConstantDictionary[];
    00698         FloatConstantList mFloatConstants;
    00700         IntConstantList mIntConstants;
    00703         GpuLogicalBufferStruct* mFloatLogicalToPhysical;
    00706         GpuLogicalBufferStruct* mIntLogicalToPhysical;
    00708         const GpuNamedConstants* mNamedConstants;
    00710         AutoConstantList mAutoConstants;
    00712         bool mTransposeMatrices;
    00714         bool mIgnoreMissingParams;
    00716         size_t mActivePassIterationIndex;
    00717
    00718     public:
    00719         GpuProgramParameters();
    00720         ~GpuProgramParameters() {}
    00721
    00723         GpuProgramParameters(const GpuProgramParameters& oth);
    00725         GpuProgramParameters& operator=(const GpuProgramParameters& oth);
    00726
    00728         void _setNamedConstants(const GpuNamedConstants* constantmap);
    00729
    00731         void _setLogicalIndexes(GpuLogicalBufferStruct* floatIndexMap,
    00732             GpuLogicalBufferStruct* intIndexMap);
    00733
    00734
    00736         bool hasNamedParameters() const { return mNamedConstants != 0;}
    00742         bool hasLogicalIndexedParameters() const { return mFloatLogicalToPhysical != 0;}
    00743
    00749         void setConstant(size_t index, const Vector4& vec);
    00757         void setConstant(size_t index, Real val);
    00765         void setConstant(size_t index, const Vector3& vec);
    00772         void setConstant(size_t index, const Matrix4& m);
    00780         void setConstant(size_t index, const Matrix4* m, size_t numEntries);
    00787         void setConstant(size_t index, const float *val, size_t count);
    00794         void setConstant(size_t index, const double *val, size_t count);
    00800         void setConstant(size_t index, const ColourValue& colour);
    00801
    00816         void setConstant(size_t index, const int *val, size_t count);
    00817
    00824         void _writeRawConstants(size_t physicalIndex, const float* val, size_t count);
    00831         void _writeRawConstants(size_t physicalIndex, const double* val, size_t count);
    00838         void _writeRawConstants(size_t physicalIndex, const int* val, size_t count);
    00845         void _readRawConstants(size_t physicalIndex, size_t count, float* dest);
    00852         void _readRawConstants(size_t physicalIndex, size_t count, int* dest);
    00853
    00864         void _writeRawConstant(size_t physicalIndex, const Vector4& vec,
    00865             size_t count = 4);
    00873         void _writeRawConstant(size_t physicalIndex, Real val);
    00881         void _writeRawConstant(size_t physicalIndex, int val);
    00889         void _writeRawConstant(size_t physicalIndex, const Vector3& vec);
    00897         void _writeRawConstant(size_t physicalIndex, const Matrix4& m);
    00905         void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries);
    00915         void _writeRawConstant(size_t physicalIndex, const ColourValue& colour,
    00916             size_t count = 4);
    00917
    00918
    00924         GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;
    00925
    00930         const GpuConstantDefinition& getConstantDefinition(const String& name) const;
    00931
    00936         const GpuNamedConstants& getConstantDefinitions() const;
    00937
    00943         const GpuLogicalBufferStruct* getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; }
    00944
    00950         size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex);
    00956         size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex);
    00957
    00963         const GpuLogicalBufferStruct* getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; }
    00965         const FloatConstantList& getFloatConstantList() const { return mFloatConstants; }
    00967         float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; }
    00969         const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
    00971         const IntConstantList& getIntConstantList() const { return mIntConstants; }
    00973         int* getIntPointer(size_t pos) { return &mIntConstants[pos]; }
    00975         const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
    00977         const AutoConstantList& getAutoConstantList() const { return mAutoConstants; }
    00978
    00992         void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0);
    00993         void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData);
    00994
    00998         void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo,
    00999             size_t elementSize = 4);
    01003         void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData,
    01004             size_t elementSize = 4);
    01005
    01006
    01008         void clearAutoConstant(size_t index);
    01009
    01014         void setConstantFromTime(size_t index, Real factor);
    01015
    01017         void clearAutoConstants(void);
    01018         typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator;
    01020         AutoConstantIterator getAutoConstantIterator(void) const;
    01022         size_t getAutoConstantCount(void) const { return mAutoConstants.size(); }
    01027         AutoConstantEntry* getAutoConstantEntry(const size_t index);
    01029         bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); }
    01034         const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex);
    01039         const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex);
    01043         const AutoConstantEntry* findAutoConstantEntry(const String& paramName);
    01047         const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex);
    01051         const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex);
    01052
    01054         void _updateAutoParamsNoLights(const AutoParamDataSource& source);
    01056         void _updateAutoParamsLightsOnly(const AutoParamDataSource& source);
    01057
    01060         void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; }
    01061
    01081         void setNamedConstant(const String& name, Real val);
    01101         void setNamedConstant(const String& name, int val);
    01106         void setNamedConstant(const String& name, const Vector4& vec);
    01119         void setNamedConstant(const String& name, const Vector3& vec);
    01124         void setNamedConstant(const String& name, const Matrix4& m);
    01132         void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
    01149         void setNamedConstant(const String& name, const float *val, size_t count,
    01150             size_t multiple = 4);
    01167         void setNamedConstant(const String& name, const double *val, size_t count,
    01168             size_t multiple = 4);
    01173         void setNamedConstant(const String& name, const ColourValue& colour);
    01174
    01191         void setNamedConstant(const String& name, const int *val, size_t count,
    01192             size_t multiple = 4);
    01193
    01208         void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0);
    01209         void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData);
    01210
    01218         void setNamedConstantFromTime(const String& name, Real factor);
    01219
    01221         void clearNamedAutoConstant(const String& name);
    01222
    01232         const GpuConstantDefinition* _findNamedConstantDefinition(
    01233             const String& name, bool throwExceptionIfMissing = false) const;
    01240         size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize);
    01247         size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize);
    01248
    01249
    01257         void setTransposeMatrices(bool val) { mTransposeMatrices = val; }
    01259         bool getTransposeMatrices(void) const { return mTransposeMatrices; }
    01260
    01264         void copyConstantsFrom(const GpuProgramParameters& source);
    01265
    01269         static const AutoConstantDefinition* getAutoConstantDefinition(const String& name);
    01274         static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx);
    01277         static size_t getNumAutoConstantDefinitions(void);
    01278
    01279
    01282         void incPassIterationNumber(void);
    01284         bool hasPassIterationNumber() const
    01285         { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); }
    01287         size_t getPassIterationNumberIndex() const
    01288         { return mActivePassIterationIndex; }
    01289
    01290
    01291     };
    01292
    01294     typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr;
    01295
    01296     // Forward declaration
    01297     class GpuProgramPtr;
    01298
    01308     class _OgreExport GpuProgram : public Resource
    01309     {
    01310     protected:
    01312         class _OgreExport CmdType : public ParamCommand
    01313         {
    01314         public:
    01315             String doGet(const void* target) const;
    01316             void doSet(void* target, const String& val);
    01317         };
    01318         class _OgreExport CmdSyntax : public ParamCommand
    01319         {
    01320         public:
    01321             String doGet(const void* target) const;
    01322             void doSet(void* target, const String& val);
    01323         };
    01324         class _OgreExport CmdSkeletal : public ParamCommand
    01325         {
    01326         public:
    01327             String doGet(const void* target) const;
    01328             void doSet(void* target, const String& val);
    01329         };
    01330         class _OgreExport CmdMorph : public ParamCommand
    01331         {
    01332         public:
    01333             String doGet(const void* target) const;
    01334             void doSet(void* target, const String& val);
    01335         };
    01336         class _OgreExport CmdPose : public ParamCommand
    01337         {
    01338         public:
    01339             String doGet(const void* target) const;
    01340             void doSet(void* target, const String& val);
    01341         };
    01342         class _OgreExport CmdVTF : public ParamCommand
    01343         {
    01344         public:
    01345             String doGet(const void* target) const;
    01346             void doSet(void* target, const String& val);
    01347         };
    01348         // Command object for setting / getting parameters
    01349         static CmdType msTypeCmd;
    01350         static CmdSyntax msSyntaxCmd;
    01351         static CmdSkeletal msSkeletalCmd;
    01352         static CmdMorph msMorphCmd;
    01353         static CmdPose msPoseCmd;
    01354         static CmdVTF msVTFCmd;
    01355
    01357         GpuProgramType mType;
    01359         String mFilename;
    01361         String mSource;
    01363         bool mLoadFromFile;
    01365         String mSyntaxCode;
    01367         bool mSkeletalAnimation;
    01369         bool mMorphAnimation;
    01371         ushort mPoseAnimation;
    01373         bool mVertexTextureFetch;
    01375         GpuProgramParametersSharedPtr mDefaultParams;
    01377         bool mPassSurfaceAndLightStates;
    01379         bool mCompileError;
    01382         mutable GpuLogicalBufferStruct mFloatLogicalToPhysical;
    01385         mutable GpuLogicalBufferStruct mIntLogicalToPhysical;
    01386
    01395         void setupBaseParamDictionary(void);
    01396
    01399         bool isRequiredCapabilitiesSupported(void) const;
    01400
    01402         size_t calculateSize(void) const { return 0; } // TODO
    01403
    01405         void loadImpl(void);
    01406     public:
    01407
    01408         GpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle,
    01409             const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
    01410
    01411         virtual ~GpuProgram() {}
    01412
    01417         virtual void setSourceFile(const String& filename);
    01418
    01423         virtual void setSource(const String& source);
    01424
    01426         virtual const String& getSyntaxCode(void) const { return mSyntaxCode; }
    01427
    01429         virtual void setSyntaxCode(const String& syntax);
    01430
    01432         virtual const String& getSourceFile(void) const { return mFilename; }
    01434         virtual const String& getSource(void) const { return mSource; }
    01436         virtual void setType(GpuProgramType t);
    01438         virtual GpuProgramType getType(void) const { return mType; }
    01439
    01444         virtual GpuProgram* _getBindingDelegate(void) { return this; }
    01445
    01447         virtual bool isSupported(void) const;
    01448
    01456         virtual GpuProgramParametersSharedPtr createParameters(void);
    01457
    01464         virtual void setSkeletalAnimationIncluded(bool included)
    01465         { mSkeletalAnimation = included; }
    01466
    01473         virtual bool isSkeletalAnimationIncluded(void) const { return mSkeletalAnimation; }
    01474
    01481         virtual void setMorphAnimationIncluded(bool included)
    01482         { mMorphAnimation = included; }
    01483
    01491         virtual void setPoseAnimationIncluded(ushort poseCount)
    01492         { mPoseAnimation = poseCount; }
    01493
    01500         virtual bool isMorphAnimationIncluded(void) const { return mMorphAnimation; }
    01501
    01508         virtual bool isPoseAnimationIncluded(void) const { return mPoseAnimation > 0; }
    01512         virtual ushort getNumberOfPosesIncluded(void) const { return mPoseAnimation; }
    01516         virtual void setVertexTextureFetchRequired(bool r) { mVertexTextureFetch = r; }
    01520         virtual bool isVertexTextureFetchRequired(void) const { return mVertexTextureFetch; }
    01521
    01532         virtual GpuProgramParametersSharedPtr getDefaultParameters(void);
    01533
    01536         virtual bool hasDefaultParameters(void) const { return !mDefaultParams.isNull(); }
    01537
    01546         virtual void setSurfaceAndPassLightStates(bool state)
    01547             { mPassSurfaceAndLightStates = state; }
    01548
    01552         virtual bool getPassSurfaceAndLightStates(void) const { return mPassSurfaceAndLightStates; }
    01553
    01557         virtual const String& getLanguage(void) const;
    01558
    01561         virtual bool hasCompileError(void) const { return mCompileError; }
    01562
    01565         virtual void resetCompileError(void) { mCompileError = false; }
    01566     protected:
    01568         virtual void loadFromSource(void) = 0;
    01569
    01570     };
    01571
    01572
    01579     class _OgreExport GpuProgramPtr : public SharedPtr<GpuProgram>
    01580     {
    01581     public:
    01582         GpuProgramPtr() : SharedPtr<GpuProgram>() {}
    01583         explicit GpuProgramPtr(GpuProgram* rep) : SharedPtr<GpuProgram>(rep) {}
    01584         GpuProgramPtr(const GpuProgramPtr& r) : SharedPtr<GpuProgram>(r) {}
    01585         GpuProgramPtr(const ResourcePtr& r) : SharedPtr<GpuProgram>()
    01586         {
    01587             // lock & copy other mutex pointer
    01588             OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
    01589             {
    01590                 OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
    01591                 OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
    01592                 pRep = static_cast<GpuProgram*>(r.getPointer());
    01593                 pUseCount = r.useCountPointer();
    01594                 if (pUseCount)
    01595                 {
    01596                     ++(*pUseCount);
    01597                 }
    01598             }
    01599         }
    01600
    01602         GpuProgramPtr& operator=(const ResourcePtr& r)
    01603         {
    01604             if (pRep == static_cast<GpuProgram*>(r.getPointer()))
    01605                 return *this;
    01606             release();
    01607             // lock & copy other mutex pointer
    01608             OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
    01609             {
    01610                 OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
    01611                 OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
    01612                 pRep = static_cast<GpuProgram*>(r.getPointer());
    01613                 pUseCount = r.useCountPointer();
    01614                 if (pUseCount)
    01615                 {
    01616                     ++(*pUseCount);
    01617                 }
    01618             }
    01619             else
    01620             {
    01621                 // RHS must be a null pointer
    01622                 assert(r.isNull() && "RHS must be null if it has no mutex!");
    01623                 setNull();
    01624             }
    01625             return *this;
    01626         }
    01628         GpuProgramPtr& operator=(const HighLevelGpuProgramPtr& r);
    01629     };
    01630 }
    01631
    01632 #endif

Copyright © 2000-2005 by The OGRE Team
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Mon Jun 16 12:48:51 2008