OgreGpuProgramParams.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-2009 Torus Knot Software Ltd
00008 
00009 Permission is hereby granted, free of charge, to any person obtaining a copy
00010 of this software and associated documentation files (the "Software"), to deal
00011 in the Software without restriction, including without limitation the rights
00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00013 copies of the Software, and to permit persons to whom the Software is
00014 furnished to do so, subject to the following conditions:
00015 
00016 The above copyright notice and this permission notice shall be included in
00017 all copies or substantial portions of the Software.
00018 
00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00025 THE SOFTWARE.
00026 -----------------------------------------------------------------------------
00027 */
00028 #ifndef __GpuProgramParams_H_
00029 #define __GpuProgramParams_H_
00030 
00031 // Precompiler options
00032 #include "OgrePrerequisites.h"
00033 #include "OgreSharedPtr.h"
00034 #include "OgreIteratorWrappers.h"
00035 #include "OgreSerializer.h"
00036 #include "OgreRenderOperation.h"
00037 #include "OgreAny.h"
00038 
00039 namespace Ogre {
00040 
00052     enum GpuConstantType
00053     {
00054         GCT_FLOAT1 = 1,
00055         GCT_FLOAT2 = 2,
00056         GCT_FLOAT3 = 3,
00057         GCT_FLOAT4 = 4,
00058         GCT_SAMPLER1D = 5,
00059         GCT_SAMPLER2D = 6,
00060         GCT_SAMPLER3D = 7,
00061         GCT_SAMPLERCUBE = 8,
00062         GCT_SAMPLER1DSHADOW = 9,
00063         GCT_SAMPLER2DSHADOW = 10,
00064         GCT_MATRIX_2X2 = 11,
00065         GCT_MATRIX_2X3 = 12,
00066         GCT_MATRIX_2X4 = 13,
00067         GCT_MATRIX_3X2 = 14,
00068         GCT_MATRIX_3X3 = 15,
00069         GCT_MATRIX_3X4 = 16,
00070         GCT_MATRIX_4X2 = 17,
00071         GCT_MATRIX_4X3 = 18,
00072         GCT_MATRIX_4X4 = 19,
00073         GCT_INT1 = 20,
00074         GCT_INT2 = 21,
00075         GCT_INT3 = 22,
00076         GCT_INT4 = 23,
00077         GCT_UNKNOWN = 99
00078     };
00079 
00083     enum GpuParamVariability
00084     {
00086         GPV_GLOBAL = 1, 
00088         GPV_PER_OBJECT = 2, 
00090         GPV_LIGHTS = 4, 
00092         GPV_PASS_ITERATION_NUMBER = 8,
00093 
00094 
00096         GPV_ALL = 0xFFFF
00097 
00098     };
00099 
00104     struct _OgreExport GpuConstantDefinition
00105     {
00107         GpuConstantType constType;
00109         size_t physicalIndex;
00111         size_t logicalIndex;
00114         size_t elementSize;
00116         size_t arraySize;
00118         mutable uint16 variability;
00119 
00120         bool isFloat() const
00121         {
00122             return isFloat(constType);
00123         }
00124 
00125         static bool isFloat(GpuConstantType c)
00126         {
00127             switch(c)
00128             {
00129             case GCT_INT1:
00130             case GCT_INT2:
00131             case GCT_INT3:
00132             case GCT_INT4:
00133             case GCT_SAMPLER1D:
00134             case GCT_SAMPLER2D:
00135             case GCT_SAMPLER3D:
00136             case GCT_SAMPLERCUBE:
00137             case GCT_SAMPLER1DSHADOW:
00138             case GCT_SAMPLER2DSHADOW:
00139                 return false;
00140             default:
00141                 return true;
00142             };
00143 
00144         }
00145 
00146         bool isSampler() const
00147         {
00148             return isSampler(constType);
00149         }
00150 
00151         static bool isSampler(GpuConstantType c)
00152         {
00153             switch(c)
00154             {
00155             case GCT_SAMPLER1D:
00156             case GCT_SAMPLER2D:
00157             case GCT_SAMPLER3D:
00158             case GCT_SAMPLERCUBE:
00159             case GCT_SAMPLER1DSHADOW:
00160             case GCT_SAMPLER2DSHADOW:
00161                 return true;
00162             default:
00163                 return false;
00164             };
00165 
00166         }
00167 
00168 
00172         static size_t getElementSize(GpuConstantType ctype, bool padToMultiplesOf4)
00173         {
00174             if (padToMultiplesOf4)
00175             {
00176                 switch(ctype)
00177                 {
00178                 case GCT_FLOAT1:
00179                 case GCT_INT1:
00180                 case GCT_SAMPLER1D:
00181                 case GCT_SAMPLER2D:
00182                 case GCT_SAMPLER3D:
00183                 case GCT_SAMPLERCUBE:
00184                 case GCT_SAMPLER1DSHADOW:
00185                 case GCT_SAMPLER2DSHADOW:
00186                 case GCT_FLOAT2:
00187                 case GCT_INT2:
00188                 case GCT_FLOAT3:
00189                 case GCT_INT3:
00190                 case GCT_FLOAT4:
00191                 case GCT_INT4:
00192                     return 4;
00193                 case GCT_MATRIX_2X2:
00194                 case GCT_MATRIX_2X3:
00195                 case GCT_MATRIX_2X4:
00196                     return 8; // 2 float4s
00197                 case GCT_MATRIX_3X2:
00198                 case GCT_MATRIX_3X3:
00199                 case GCT_MATRIX_3X4:
00200                     return 12; // 3 float4s
00201                 case GCT_MATRIX_4X2:
00202                 case GCT_MATRIX_4X3:
00203                 case GCT_MATRIX_4X4:
00204                     return 16; // 4 float4s
00205                 default:
00206                     return 4;
00207                 };
00208             }
00209             else
00210             {
00211                 switch(ctype)
00212                 {
00213                 case GCT_FLOAT1:
00214                 case GCT_INT1:
00215                 case GCT_SAMPLER1D:
00216                 case GCT_SAMPLER2D:
00217                 case GCT_SAMPLER3D:
00218                 case GCT_SAMPLERCUBE:
00219                 case GCT_SAMPLER1DSHADOW:
00220                 case GCT_SAMPLER2DSHADOW:
00221                     return 1;
00222                 case GCT_FLOAT2:
00223                 case GCT_INT2:
00224                     return 2;
00225                 case GCT_FLOAT3:
00226                 case GCT_INT3:
00227                     return 3;
00228                 case GCT_FLOAT4:
00229                 case GCT_INT4:
00230                     return 4;
00231                 case GCT_MATRIX_2X2:
00232                     return 4;
00233                 case GCT_MATRIX_2X3:
00234                 case GCT_MATRIX_3X2:
00235                     return 6;
00236                 case GCT_MATRIX_2X4:
00237                 case GCT_MATRIX_4X2:
00238                     return 8; 
00239                 case GCT_MATRIX_3X3:
00240                     return 9;
00241                 case GCT_MATRIX_3X4:
00242                 case GCT_MATRIX_4X3:
00243                     return 12; 
00244                 case GCT_MATRIX_4X4:
00245                     return 16; 
00246                 default:
00247                     return 4;
00248                 };
00249 
00250             }
00251         }
00252 
00253         GpuConstantDefinition()
00254             : constType(GCT_UNKNOWN)
00255             , physicalIndex((std::numeric_limits<size_t>::max)())
00256             , elementSize(0)
00257             , arraySize(1)
00258             , variability(GPV_GLOBAL) {}
00259     };
00260     typedef map<String, GpuConstantDefinition>::type GpuConstantDefinitionMap;
00261     typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator;
00262 
00264     struct _OgreExport GpuNamedConstants : public GpuParamsAlloc
00265     {
00267         size_t floatBufferSize;
00269         size_t intBufferSize;
00271         GpuConstantDefinitionMap map;
00272 
00273         GpuNamedConstants() : floatBufferSize(0), intBufferSize(0) {}
00274 
00286         void generateConstantDefinitionArrayEntries(const String& paramName, 
00287             const GpuConstantDefinition& baseDef);
00288 
00290         static bool getGenerateAllConstantDefinitionArrayEntries();
00291 
00298         static void setGenerateAllConstantDefinitionArrayEntries(bool generateAll);
00299 
00303         void save(const String& filename) const;
00307         void load(DataStreamPtr& stream);
00308 
00309     protected:
00316         static bool msGenerateAllConstantDefinitionArrayEntries;
00317     };
00318     typedef SharedPtr<GpuNamedConstants> GpuNamedConstantsPtr;
00319 
00321     class _OgreExport GpuNamedConstantsSerializer : public Serializer
00322     {
00323     public:
00324         GpuNamedConstantsSerializer();
00325         virtual ~GpuNamedConstantsSerializer();
00326         void exportNamedConstants(const GpuNamedConstants* pConsts, const String& filename,
00327             Endian endianMode = ENDIAN_NATIVE);
00328         void importNamedConstants(DataStreamPtr& stream, GpuNamedConstants* pDest);
00329     };
00330 
00334     struct _OgreExport GpuLogicalIndexUse
00335     {
00337         size_t physicalIndex;
00339         size_t currentSize;
00341         mutable uint16 variability;
00342 
00343         GpuLogicalIndexUse() 
00344             : physicalIndex(99999), currentSize(0), variability(GPV_GLOBAL) {}
00345         GpuLogicalIndexUse(size_t bufIdx, size_t curSz, uint16 v) 
00346             : physicalIndex(bufIdx), currentSize(curSz), variability(v) {}
00347     };
00348     typedef map<size_t, GpuLogicalIndexUse>::type GpuLogicalIndexUseMap;
00350     struct _OgreExport GpuLogicalBufferStruct : public GpuParamsAlloc
00351     {
00352         OGRE_MUTEX(mutex)
00354             GpuLogicalIndexUseMap map;
00356         size_t bufferSize;
00357         GpuLogicalBufferStruct() : bufferSize(0) {}
00358     };
00359     typedef SharedPtr<GpuLogicalBufferStruct> GpuLogicalBufferStructPtr;
00360 
00365     typedef vector<float>::type FloatConstantList;
00370     typedef vector<int>::type IntConstantList;
00371 
00387     class _OgreExport GpuSharedParameters : public GpuParamsAlloc
00388     {
00389     protected:
00390         GpuNamedConstants mNamedConstants;
00391         FloatConstantList mFloatConstants;
00392         IntConstantList mIntConstants;
00393         String mName;
00394 
00395         // Optional data the rendersystem might want to store
00396         mutable Any mRenderSystemData;
00397 
00399         size_t mFrameLastUpdated;
00400 
00402         unsigned long mVersion; 
00403 
00404     public:
00405         GpuSharedParameters(const String& name);
00406         virtual ~GpuSharedParameters();
00407 
00409         const String& getName() { return mName; }
00410 
00418         void addConstantDefinition(const String& name, GpuConstantType constType, size_t arraySize = 1);
00419 
00422         void removeConstantDefinition(const String& name);
00423 
00426         void removeAllConstantDefinitions();
00427 
00431         unsigned long getVersion() const { return mVersion; }
00432 
00438         void _markDirty();
00440         size_t getFrameLastUpdated() const { return mFrameLastUpdated; }
00441 
00445         GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;
00446 
00449         const GpuConstantDefinition& getConstantDefinition(const String& name) const;
00450 
00453         const GpuNamedConstants& getConstantDefinitions() const;
00454     
00456         void setNamedConstant(const String& name, Real val);
00458         void setNamedConstant(const String& name, int val);
00460         void setNamedConstant(const String& name, const Vector4& vec);
00462         void setNamedConstant(const String& name, const Vector3& vec);
00464         void setNamedConstant(const String& name, const Matrix4& m);
00466         void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
00468         void setNamedConstant(const String& name, const float *val, size_t count);
00470         void setNamedConstant(const String& name, const double *val, size_t count);
00472         void setNamedConstant(const String& name, const ColourValue& colour);
00474         void setNamedConstant(const String& name, const int *val, size_t count);
00475 
00477         float* getFloatPointer(size_t pos) { _markDirty(); return &mFloatConstants[pos]; }
00479         const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
00481         int* getIntPointer(size_t pos) { _markDirty(); return &mIntConstants[pos]; }
00483         const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
00484 
00485 
00487         void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
00489         const Any& _getRenderSystemData() const { return mRenderSystemData; }
00490 
00491     };
00492 
00494     typedef SharedPtr<GpuSharedParameters> GpuSharedParametersPtr;
00495 
00496     class GpuProgramParameters;
00497 
00501     class _OgreExport GpuSharedParametersUsage : public GpuParamsAlloc
00502     {
00503     protected:
00504         GpuSharedParametersPtr mSharedParams;
00505         // Not a shared pointer since this is also parent
00506         GpuProgramParameters* mParams;
00507         // list of physical mappings that we are going to bring in
00508         struct CopyDataEntry
00509         {
00510             const GpuConstantDefinition* srcDefinition;
00511             const GpuConstantDefinition* dstDefinition;
00512         };
00513         typedef vector<CopyDataEntry>::type CopyDataList;
00514 
00515         CopyDataList mCopyDataList;
00516 
00517         // Optional data the rendersystem might want to store
00518         mutable Any mRenderSystemData;
00519 
00521         unsigned long mCopyDataVersion;
00522 
00523         void initCopyData();
00524 
00525 
00526     public:
00528         GpuSharedParametersUsage(GpuSharedParametersPtr sharedParams, 
00529             GpuProgramParameters* params);
00530 
00538         void _copySharedParamsToTargetParams();
00539 
00541         const String& getName() const { return mSharedParams->getName(); }
00542 
00543         GpuSharedParametersPtr getSharedParams() const { return mSharedParams; }
00544         GpuProgramParameters* getTargetParams() const { return mParams; }
00545 
00547         void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
00549         const Any& _getRenderSystemData() const { return mRenderSystemData; }
00550 
00551 
00552     };
00553 
00584     class _OgreExport GpuProgramParameters : public GpuParamsAlloc
00585     {
00586     public:
00590         enum AutoConstantType
00591         {
00593             ACT_WORLD_MATRIX,
00595             ACT_INVERSE_WORLD_MATRIX,
00599             ACT_TRANSPOSE_WORLD_MATRIX,
00601             ACT_INVERSE_TRANSPOSE_WORLD_MATRIX,
00602 
00603 
00605             ACT_WORLD_MATRIX_ARRAY_3x4,
00607             ACT_WORLD_MATRIX_ARRAY,
00608 
00610             ACT_VIEW_MATRIX,
00612             ACT_INVERSE_VIEW_MATRIX,
00616             ACT_TRANSPOSE_VIEW_MATRIX,
00620             ACT_INVERSE_TRANSPOSE_VIEW_MATRIX,
00621 
00622 
00624             ACT_PROJECTION_MATRIX,
00628             ACT_INVERSE_PROJECTION_MATRIX,
00632             ACT_TRANSPOSE_PROJECTION_MATRIX,
00636             ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX,
00637 
00638 
00640             ACT_VIEWPROJ_MATRIX,
00644             ACT_INVERSE_VIEWPROJ_MATRIX,
00648             ACT_TRANSPOSE_VIEWPROJ_MATRIX,
00652             ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX,
00653 
00654 
00656             ACT_WORLDVIEW_MATRIX,
00658             ACT_INVERSE_WORLDVIEW_MATRIX,
00662             ACT_TRANSPOSE_WORLDVIEW_MATRIX,
00664             ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX,
00666 
00667 
00669             ACT_WORLDVIEWPROJ_MATRIX,
00673             ACT_INVERSE_WORLDVIEWPROJ_MATRIX,
00677             ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
00681             ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
00682 
00683 
00685 
00688             ACT_RENDER_TARGET_FLIPPING,
00689 
00692             ACT_VERTEX_WINDING,
00693 
00695             ACT_FOG_COLOUR,
00697             ACT_FOG_PARAMS,
00698 
00699 
00701             ACT_SURFACE_AMBIENT_COLOUR,
00703             ACT_SURFACE_DIFFUSE_COLOUR,
00705             ACT_SURFACE_SPECULAR_COLOUR,
00707             ACT_SURFACE_EMISSIVE_COLOUR,
00709             ACT_SURFACE_SHININESS,
00710 
00711 
00713             ACT_LIGHT_COUNT,
00714 
00715 
00717             ACT_AMBIENT_LIGHT_COLOUR, 
00718 
00720             ACT_LIGHT_DIFFUSE_COLOUR,
00722             ACT_LIGHT_SPECULAR_COLOUR,
00724             ACT_LIGHT_ATTENUATION,
00730             ACT_SPOTLIGHT_PARAMS,
00732             ACT_LIGHT_POSITION,
00734             ACT_LIGHT_POSITION_OBJECT_SPACE,
00736             ACT_LIGHT_POSITION_VIEW_SPACE,
00738             ACT_LIGHT_DIRECTION,
00740             ACT_LIGHT_DIRECTION_OBJECT_SPACE,
00742             ACT_LIGHT_DIRECTION_VIEW_SPACE,
00747             ACT_LIGHT_DISTANCE_OBJECT_SPACE,
00749             ACT_LIGHT_POWER_SCALE,
00751             ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED,
00753             ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED,
00755             ACT_LIGHT_DIFFUSE_COLOUR_ARRAY,
00757             ACT_LIGHT_SPECULAR_COLOUR_ARRAY,
00759             ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY,
00761             ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY,
00763             ACT_LIGHT_ATTENUATION_ARRAY,
00765             ACT_LIGHT_POSITION_ARRAY,
00767             ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY,
00769             ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY,
00771             ACT_LIGHT_DIRECTION_ARRAY,
00773             ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY,
00775             ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY,
00780             ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY,
00784             ACT_LIGHT_POWER_SCALE_ARRAY,
00791             ACT_SPOTLIGHT_PARAMS_ARRAY,
00792 
00797             ACT_DERIVED_AMBIENT_LIGHT_COLOUR,
00802             ACT_DERIVED_SCENE_COLOUR,
00803 
00809             ACT_DERIVED_LIGHT_DIFFUSE_COLOUR,
00815             ACT_DERIVED_LIGHT_SPECULAR_COLOUR,
00816 
00818             ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY,
00820             ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY,
00827             ACT_LIGHT_NUMBER,
00829             ACT_LIGHT_CASTS_SHADOWS,
00830 
00831 
00835             ACT_SHADOW_EXTRUSION_DISTANCE,
00837             ACT_CAMERA_POSITION,
00839             ACT_CAMERA_POSITION_OBJECT_SPACE,
00841             ACT_TEXTURE_VIEWPROJ_MATRIX,
00843             ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY,
00847             ACT_TEXTURE_WORLDVIEWPROJ_MATRIX,
00849             ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY,
00851             ACT_SPOTLIGHT_VIEWPROJ_MATRIX,
00855             ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX,
00857             ACT_CUSTOM,
00860             ACT_TIME,
00864             ACT_TIME_0_X,
00866             ACT_COSTIME_0_X,
00868             ACT_SINTIME_0_X,
00870             ACT_TANTIME_0_X,
00874             ACT_TIME_0_X_PACKED,
00879             ACT_TIME_0_1,
00881             ACT_COSTIME_0_1,
00883             ACT_SINTIME_0_1,
00885             ACT_TANTIME_0_1,
00889             ACT_TIME_0_1_PACKED,
00894             ACT_TIME_0_2PI,
00896             ACT_COSTIME_0_2PI,
00898             ACT_SINTIME_0_2PI,
00900             ACT_TANTIME_0_2PI,
00904             ACT_TIME_0_2PI_PACKED,
00906             ACT_FRAME_TIME,
00908             ACT_FPS,
00910 
00913             ACT_VIEWPORT_WIDTH,
00917             ACT_VIEWPORT_HEIGHT,
00921             ACT_INVERSE_VIEWPORT_WIDTH,
00925             ACT_INVERSE_VIEWPORT_HEIGHT,
00929             ACT_VIEWPORT_SIZE,
00930 
00932 
00935             ACT_VIEW_DIRECTION,
00939             ACT_VIEW_SIDE_VECTOR,
00943             ACT_VIEW_UP_VECTOR,
00947             ACT_FOV,
00951             ACT_NEAR_CLIP_DISTANCE,
00955             ACT_FAR_CLIP_DISTANCE,
00956 
00960             ACT_PASS_NUMBER,
00961 
00966             ACT_PASS_ITERATION_NUMBER,
00967 
00968 
00972             ACT_ANIMATION_PARAMETRIC,
00973 
00979             ACT_TEXEL_OFFSETS,
00980 
00985             ACT_SCENE_DEPTH_RANGE,
00986 
00992             ACT_SHADOW_SCENE_DEPTH_RANGE,
00993 
00997             ACT_SHADOW_COLOUR,
01001             ACT_TEXTURE_SIZE,
01005             ACT_INVERSE_TEXTURE_SIZE,
01009             ACT_PACKED_TEXTURE_SIZE,
01010 
01014             ACT_TEXTURE_MATRIX, 
01015 
01021             ACT_LOD_CAMERA_POSITION, 
01027             ACT_LOD_CAMERA_POSITION_OBJECT_SPACE, 
01029             ACT_LIGHT_CUSTOM
01030         };
01031 
01035         enum ACDataType {
01037             ACDT_NONE,
01039             ACDT_INT,
01041             ACDT_REAL
01042         };
01043 
01046         enum ElementType {
01047             ET_INT,
01048             ET_REAL
01049         };
01050 
01054         struct AutoConstantDefinition
01055         {
01056             AutoConstantType acType;
01057             String name;
01058             size_t elementCount;
01060             ElementType elementType;
01062             ACDataType dataType;
01063 
01064             AutoConstantDefinition(AutoConstantType _acType, const String& _name, 
01065                 size_t _elementCount, ElementType _elementType, 
01066                 ACDataType _dataType)
01067                 :acType(_acType), name(_name), elementCount(_elementCount), 
01068                 elementType(_elementType), dataType(_dataType)
01069             {
01070 
01071             }
01072         };
01073 
01075         class AutoConstantEntry
01076         {
01077         public:
01079             AutoConstantType paramType;
01081             size_t physicalIndex;
01085             size_t elementCount;
01087             union{
01088                 size_t data;
01089                 Real fData;
01090             };
01092             uint16 variability;
01093 
01094             AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, 
01095                 uint16 theVariability, size_t theElemCount = 4)
01096                 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 
01097                 data(theData), variability(theVariability) {}
01098 
01099             AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, 
01100                 uint16 theVariability, size_t theElemCount = 4)
01101                 : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 
01102                 fData(theData), variability(theVariability) {}
01103 
01104         };
01105         // Auto parameter storage
01106         typedef vector<AutoConstantEntry>::type AutoConstantList;
01107 
01108         typedef vector<GpuSharedParametersUsage>::type GpuSharedParamUsageList;
01109 
01110     protected:
01111         static AutoConstantDefinition AutoConstantDictionary[];
01113         FloatConstantList mFloatConstants;
01115         IntConstantList mIntConstants;
01118         GpuLogicalBufferStructPtr mFloatLogicalToPhysical;
01121         GpuLogicalBufferStructPtr mIntLogicalToPhysical;
01123         GpuNamedConstantsPtr mNamedConstants;
01125         AutoConstantList mAutoConstants;
01127         uint16 mCombinedVariability;
01129         bool mTransposeMatrices;
01131         bool mIgnoreMissingParams;
01133         size_t mActivePassIterationIndex;
01134 
01137         GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
01140         GpuLogicalIndexUse* _getIntConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
01141 
01143         uint16 deriveVariability(AutoConstantType act);
01144 
01145         void copySharedParamSetUsage(const GpuSharedParamUsageList& srcList);
01146 
01147         GpuSharedParamUsageList mSharedParamSets;
01148 
01149         // Optional data the rendersystem might want to store
01150         mutable Any mRenderSystemData;
01151 
01152 
01153 
01154     public:
01155         GpuProgramParameters();
01156         ~GpuProgramParameters() {}
01157 
01159         GpuProgramParameters(const GpuProgramParameters& oth);
01161         GpuProgramParameters& operator=(const GpuProgramParameters& oth);
01162 
01164         void _setNamedConstants(const GpuNamedConstantsPtr& constantmap);
01165 
01167         void _setLogicalIndexes(const GpuLogicalBufferStructPtr& floatIndexMap, 
01168             const GpuLogicalBufferStructPtr&  intIndexMap);
01169 
01170 
01172         bool hasNamedParameters() const { return !mNamedConstants.isNull(); }
01178         bool hasLogicalIndexedParameters() const { return !mFloatLogicalToPhysical.isNull(); }
01179 
01185         void setConstant(size_t index, const Vector4& vec);
01193         void setConstant(size_t index, Real val);
01201         void setConstant(size_t index, const Vector3& vec);
01208         void setConstant(size_t index, const Matrix4& m);
01216         void setConstant(size_t index, const Matrix4* m, size_t numEntries);
01223         void setConstant(size_t index, const float *val, size_t count);
01230         void setConstant(size_t index, const double *val, size_t count);
01236         void setConstant(size_t index, const ColourValue& colour);
01237 
01252         void setConstant(size_t index, const int *val, size_t count);
01253 
01260         void _writeRawConstants(size_t physicalIndex, const float* val, size_t count);
01267         void _writeRawConstants(size_t physicalIndex, const double* val, size_t count);
01274         void _writeRawConstants(size_t physicalIndex, const int* val, size_t count);
01281         void _readRawConstants(size_t physicalIndex, size_t count, float* dest);
01288         void _readRawConstants(size_t physicalIndex, size_t count, int* dest);
01289 
01300         void _writeRawConstant(size_t physicalIndex, const Vector4& vec, 
01301             size_t count = 4);
01309         void _writeRawConstant(size_t physicalIndex, Real val);
01317         void _writeRawConstant(size_t physicalIndex, int val);
01325         void _writeRawConstant(size_t physicalIndex, const Vector3& vec);
01334         void _writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount);
01342         void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries);
01352         void _writeRawConstant(size_t physicalIndex, const ColourValue& colour, 
01353             size_t count = 4);
01354 
01355 
01361         GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;
01362 
01367         const GpuConstantDefinition& getConstantDefinition(const String& name) const;
01368 
01373         const GpuNamedConstants& getConstantDefinitions() const;
01374 
01380         const GpuLogicalBufferStructPtr& getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; }
01381 
01387         size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex);
01393         size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex);
01394 
01400         const GpuLogicalBufferStructPtr& getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; }
01402         const FloatConstantList& getFloatConstantList() const { return mFloatConstants; }
01404         float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; }
01406         const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
01408         const IntConstantList& getIntConstantList() const { return mIntConstants; }
01410         int* getIntPointer(size_t pos) { return &mIntConstants[pos]; }
01412         const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
01414         const AutoConstantList& getAutoConstantList() const { return mAutoConstants; }
01415 
01429         void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0);
01430         void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData);
01431 
01446         void setAutoConstant(size_t index, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2);
01447 
01451         void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 
01452             uint16 variability, size_t elementSize = 4);
01456         void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData, 
01457             uint16 variability, size_t elementSize = 4);
01458 
01459 
01461         void clearAutoConstant(size_t index);
01462 
01467         void setConstantFromTime(size_t index, Real factor);
01468 
01470         void clearAutoConstants(void);
01471         typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator;
01473         AutoConstantIterator getAutoConstantIterator(void) const;
01475         size_t getAutoConstantCount(void) const { return mAutoConstants.size(); }
01480         AutoConstantEntry* getAutoConstantEntry(const size_t index);
01482         bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); }
01487         const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex);
01492         const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex);
01496         const AutoConstantEntry* findAutoConstantEntry(const String& paramName);
01500         const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex);
01504         const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex);
01505 
01510         void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask);
01511 
01514         void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; }
01515 
01535         void setNamedConstant(const String& name, Real val);
01555         void setNamedConstant(const String& name, int val);
01560         void setNamedConstant(const String& name, const Vector4& vec);
01573         void setNamedConstant(const String& name, const Vector3& vec);
01578         void setNamedConstant(const String& name, const Matrix4& m);
01586         void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
01603         void setNamedConstant(const String& name, const float *val, size_t count, 
01604             size_t multiple = 4);
01621         void setNamedConstant(const String& name, const double *val, size_t count, 
01622             size_t multiple = 4);
01627         void setNamedConstant(const String& name, const ColourValue& colour);
01628 
01645         void setNamedConstant(const String& name, const int *val, size_t count, 
01646             size_t multiple = 4);
01647 
01662         void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0);
01663         void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData);
01664 
01680         void setNamedAutoConstant(const String& name, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2);
01681 
01689         void setNamedConstantFromTime(const String& name, Real factor);
01690 
01692         void clearNamedAutoConstant(const String& name);
01693 
01703         const GpuConstantDefinition* _findNamedConstantDefinition(
01704             const String& name, bool throwExceptionIfMissing = false) const;
01711         size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
01718         size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
01719 
01727         void setTransposeMatrices(bool val) { mTransposeMatrices = val; } 
01729         bool getTransposeMatrices(void) const { return mTransposeMatrices; } 
01730 
01737         void copyConstantsFrom(const GpuProgramParameters& source);
01738 
01747         void copyMatchingNamedConstantsFrom(const GpuProgramParameters& source);
01748 
01752         static const AutoConstantDefinition* getAutoConstantDefinition(const String& name);
01757         static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx);
01760         static size_t getNumAutoConstantDefinitions(void);
01761 
01762 
01765         void incPassIterationNumber(void);
01767         bool hasPassIterationNumber() const 
01768         { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); }
01770         size_t getPassIterationNumberIndex() const 
01771         { return mActivePassIterationIndex; }
01772 
01773 
01779         void addSharedParameters(GpuSharedParametersPtr sharedParams);
01780 
01788         void addSharedParameters(const String& sharedParamsName);
01789 
01791         bool isUsingSharedParameters(const String& sharedParamsName) const;
01792 
01794         void removeSharedParameters(const String& sharedParamsName);
01795 
01797         void removeAllSharedParameters();
01798 
01800         const GpuSharedParamUsageList& getSharedParameters() const;
01801 
01803         void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
01805         const Any& _getRenderSystemData() const { return mRenderSystemData; }
01806 
01814         void _copySharedParams();
01815 
01816 
01817 
01818     };
01819 
01821     typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr;
01822 
01825 }
01826 #endif
01827 

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Wed Nov 3 2010 19:24:51