Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

OgreRenderSystemCapabilities.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 __RenderSystemCapabilities__
00030 #define __RenderSystemCapabilities__ 1
00031 
00032 // Precompiler options
00033 #include "OgrePrerequisites.h"
00034 #include "OgreString.h"
00035 #include "OgreStringConverter.h"
00036 #include "OgreStringVector.h"
00037 #include "OgreResource.h"
00038 #include "OgreLogManager.h"
00039 
00040 // Because there are more than 32 possible Capabilities, more than 1 int is needed to store them all.
00041 // In fact, an array of integers is used to store capabilities. However all the capabilities are defined in the single
00042 // enum. The only way to know which capabilities should be stored where in the array is to use some of the 32 bits
00043 // to record the category of the capability.  These top few bits are used as an index into mCapabilities array
00044 // The lower bits are used to identify each capability individually by setting 1 bit for each
00045 
00046 // Identifies how many bits are reserved for categories
00047 // NOTE: Although 4 bits (currently) are enough
00048 #define CAPS_CATEGORY_SIZE 4
00049 #define OGRE_CAPS_BITSHIFT (32 - CAPS_CATEGORY_SIZE)
00050 #define CAPS_CATEGORY_MASK (((1 << CAPS_CATEGORY_SIZE) - 1) << OGRE_CAPS_BITSHIFT)
00051 #define OGRE_CAPS_VALUE(cat, val) ((cat << OGRE_CAPS_BITSHIFT) | (1 << val))
00052 
00053 namespace Ogre 
00054 {
00056     enum CapabilitiesCategory
00057     {
00058         CAPS_CATEGORY_COMMON = 0,
00059         CAPS_CATEGORY_COMMON_2 = 1,
00060         CAPS_CATEGORY_D3D9 = 2,
00061         CAPS_CATEGORY_GL = 3,
00063         CAPS_CATEGORY_COUNT = 4
00064     };
00065 
00068     // a is the category (which can be from 0 to 15)
00069     // b is the value (from 0 to 27)
00070     enum Capabilities
00071     {
00073         RSC_AUTOMIPMAP              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 0),
00074         RSC_BLENDING                = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 1),
00076         RSC_ANISOTROPY              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 2),
00078         RSC_DOT3                    = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 3),
00080         RSC_CUBEMAPPING             = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 4),
00082         RSC_HWSTENCIL               = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 5),
00084         RSC_VBO                     = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 7),
00086         RSC_VERTEX_PROGRAM          = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 9),
00088         RSC_FRAGMENT_PROGRAM        = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 10),
00090         RSC_SCISSOR_TEST            = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 11),
00092         RSC_TWO_SIDED_STENCIL       = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 12),
00094         RSC_STENCIL_WRAP            = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 13),
00096         RSC_HWOCCLUSION             = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 14),
00098         RSC_USER_CLIP_PLANES        = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 15),
00100         RSC_VERTEX_FORMAT_UBYTE4    = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 16),
00102         RSC_INFINITE_FAR_PLANE      = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 17),
00104         RSC_HWRENDER_TO_TEXTURE     = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 18),
00106         RSC_TEXTURE_FLOAT           = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 19),
00108         RSC_NON_POWER_OF_2_TEXTURES = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 20),
00110         RSC_TEXTURE_3D              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 21),
00112         RSC_POINT_SPRITES           = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 22),
00114         RSC_POINT_EXTENDED_PARAMETERS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 23),
00116         RSC_VERTEX_TEXTURE_FETCH = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 24),
00118         RSC_MIPMAP_LOD_BIAS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 25),
00120         RSC_GEOMETRY_PROGRAM = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 26),
00122         RSC_HWRENDER_TO_VERTEX_BUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 27),
00123 
00125         RSC_TEXTURE_COMPRESSION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 0),
00127         RSC_TEXTURE_COMPRESSION_DXT = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 1),
00129         RSC_TEXTURE_COMPRESSION_VTC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 2),
00131         RSC_FIXED_FUNCTION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 3),
00133         RSC_MRT_DIFFERENT_BIT_DEPTHS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 4),
00135         RSC_ALPHA_TO_COVERAGE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 5),
00136 
00137         // ***** DirectX specific caps *****
00139         RSC_PERSTAGECONSTANT = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 0),
00140 
00141         // ***** GL Specific Caps *****
00143         RSC_GL1_5_NOVBO    = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 1),
00145         RSC_FBO              = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 2),
00147         RSC_FBO_ARB          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 3),
00149         RSC_FBO_ATI          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 4),
00151         RSC_PBUFFER          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 5),
00153         RSC_GL1_5_NOHWOCCLUSION = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 6),
00155         RSC_POINT_EXTENDED_PARAMETERS_ARB = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 7),
00157         RSC_POINT_EXTENDED_PARAMETERS_EXT = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 8),
00158 
00159 
00160     };
00161 
00164     struct _OgreExport DriverVersion 
00165     {
00166         int major;
00167         int minor;
00168         int release;
00169         int build;
00170 
00171         DriverVersion() 
00172         {
00173             major = minor = release = build = 0;
00174         }
00175 
00176         String toString() const 
00177         {
00178             StringUtil::StrStreamType str;
00179             str << major << "." << minor << "." << release << "." << build;
00180             return str.str();
00181         }
00182 
00183         void fromString(const String& versionString)
00184         {
00185             StringVector tokens = StringUtil::split(versionString, ".");
00186             if(!tokens.empty())
00187             {
00188                 major = StringConverter::parseInt(tokens[0]);
00189                 if (tokens.size() > 1)
00190                     minor = StringConverter::parseInt(tokens[1]);
00191                 if (tokens.size() > 2)
00192                     release = StringConverter::parseInt(tokens[2]);
00193                 if (tokens.size() > 3)
00194                     build = StringConverter::parseInt(tokens[3]);
00195             }
00196 
00197         }
00198     };
00199 
00201     enum GPUVendor
00202     {
00203         GPU_UNKNOWN = 0,
00204         GPU_NVIDIA = 1,
00205         GPU_ATI = 2, 
00206         GPU_INTEL = 3,
00207         GPU_S3 = 4,
00208         GPU_MATROX = 5,
00209         GPU_3DLABS = 6,
00211         GPU_VENDOR_COUNT = 7
00212     };
00213 
00219     class _OgreExport RenderSystemCapabilities : public RenderSysAlloc
00220     {
00221 
00222     public:
00223 
00224         typedef std::set<String> ShaderProfiles;
00225     private:
00229         DriverVersion mDriverVersion;
00231         GPUVendor mVendor;
00232 
00233         static StringVector msGPUVendorStrings;
00234         static void initVendorStrings();
00235 
00237         ushort mNumWorldMatrices;
00239         ushort mNumTextureUnits;
00241         ushort mStencilBufferBitDepth;
00243         ushort mNumVertexBlendMatrices;
00245         int mCapabilities[CAPS_CATEGORY_COUNT];
00247         bool mCategoryRelevant[CAPS_CATEGORY_COUNT];
00249         String mDeviceName;
00251         String mRenderSystemName;
00252 
00254         ushort mVertexProgramConstantFloatCount;           
00256         ushort mVertexProgramConstantIntCount;           
00258         ushort mVertexProgramConstantBoolCount;           
00260         ushort mGeometryProgramConstantFloatCount;           
00262         ushort mGeometryProgramConstantIntCount;           
00264         ushort mGeometryProgramConstantBoolCount;           
00266         ushort mFragmentProgramConstantFloatCount;           
00268         ushort mFragmentProgramConstantIntCount;           
00270         ushort mFragmentProgramConstantBoolCount;
00272         ushort mNumMultiRenderTargets;
00274         Real mMaxPointSize;
00276         bool mNonPOW2TexturesLimited;
00278         ushort mNumVertexTextureUnits;
00280         bool mVertexTextureUnitsShared;
00282         int mGeometryProgramNumOutputVertices;
00283 
00284 
00286         ShaderProfiles mSupportedShaderProfiles;
00287 
00288     public: 
00289         RenderSystemCapabilities ();
00290         virtual ~RenderSystemCapabilities ();
00291 
00292         virtual size_t calculateSize() const {return 0;}
00293 
00295         void setDriverVersion(const DriverVersion& version)
00296         {
00297             mDriverVersion = version;
00298         }
00299 
00300         void parseDriverVersionFromString(const String& versionString)
00301         {
00302             DriverVersion version;
00303             version.fromString(versionString);
00304             setDriverVersion(version);
00305         }
00306 
00307 
00308         DriverVersion getDriverVersion() const
00309         {
00310             return mDriverVersion;
00311         }
00312 
00313         GPUVendor getVendor() const
00314         {
00315             return mVendor;
00316         }
00317 
00318         void setVendor(GPUVendor v)
00319         {
00320             mVendor = v;
00321         }
00322 
00324         void parseVendorFromString(const String& vendorString)
00325         {
00326             setVendor(vendorFromString(vendorString));
00327         }
00328 
00330         static GPUVendor vendorFromString(const String& vendorString);
00332         static String vendorToString(GPUVendor v);
00333 
00334         bool isDriverOlderThanVersion(DriverVersion v) const
00335         {
00336             if (mDriverVersion.major < v.major)
00337                 return true;
00338             else if (mDriverVersion.major == v.major && 
00339                 mDriverVersion.minor < v.minor)
00340                 return true;
00341             else if (mDriverVersion.major == v.major && 
00342                 mDriverVersion.minor == v.minor && 
00343                 mDriverVersion.release < v.release)
00344                 return true;
00345             else if (mDriverVersion.major == v.major && 
00346                 mDriverVersion.minor == v.minor && 
00347                 mDriverVersion.release == v.release &&
00348                 mDriverVersion.build < v.build)
00349                 return true;
00350             return false;
00351         }
00352 
00353         void setNumWorldMatrices(ushort num)
00354         {
00355             mNumWorldMatrices = num;
00356         }
00357 
00358         void setNumTextureUnits(ushort num)
00359         {
00360             mNumTextureUnits = num;
00361         }
00362 
00363         void setStencilBufferBitDepth(ushort num)
00364         {
00365             mStencilBufferBitDepth = num;
00366         }
00367 
00368         void setNumVertexBlendMatrices(ushort num)
00369         {
00370             mNumVertexBlendMatrices = num;
00371         }
00372 
00374         void setNumMultiRenderTargets(ushort num)
00375         {
00376             mNumMultiRenderTargets = num;
00377         }
00378 
00379         ushort getNumWorldMatrices(void) const
00380         { 
00381             return mNumWorldMatrices;
00382         }
00383 
00396         ushort getNumTextureUnits(void) const
00397         {
00398             return mNumTextureUnits;
00399         }
00400 
00407         ushort getStencilBufferBitDepth(void) const
00408         {
00409             return mStencilBufferBitDepth;
00410         }
00411 
00414         ushort getNumVertexBlendMatrices(void) const
00415         {
00416             return mNumVertexBlendMatrices;
00417         }
00418 
00420         ushort getNumMultiRenderTargets(void) const
00421         {
00422             return mNumMultiRenderTargets;
00423         }
00424 
00427         bool isCapabilityRenderSystemSpecific(const Capabilities c)
00428         {
00429             int cat = c >> OGRE_CAPS_BITSHIFT;
00430             if(cat == CAPS_CATEGORY_GL || cat == CAPS_CATEGORY_D3D9)
00431                 return true;
00432             return false;
00433         }
00434 
00437         void setCapability(const Capabilities c) 
00438         { 
00439             int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
00440             // zero out the index from the stored capability
00441             mCapabilities[index] |= (c & ~CAPS_CATEGORY_MASK);
00442         }
00443 
00446         void unsetCapability(const Capabilities c) 
00447         { 
00448             int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
00449             // zero out the index from the stored capability
00450             mCapabilities[index] &= (~c | CAPS_CATEGORY_MASK);
00451         }
00452 
00455         bool hasCapability(const Capabilities c) const
00456         {
00457             int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
00458             // test against
00459             if(mCapabilities[index] & (c & ~CAPS_CATEGORY_MASK))
00460             {
00461                 return true;
00462             }
00463             else
00464             {
00465                 return false;
00466             }
00467         }
00468 
00471         void addShaderProfile(const String& profile)
00472         {
00473             mSupportedShaderProfiles.insert(profile);
00474 
00475         }
00476 
00479         void removeShaderProfile(const String& profile)
00480         {
00481             mSupportedShaderProfiles.erase(profile);
00482         }
00483 
00486         bool isShaderProfileSupported(const String& profile) const
00487         {
00488             return (mSupportedShaderProfiles.end() != mSupportedShaderProfiles.find(profile));
00489         }
00490 
00491 
00494         const ShaderProfiles& getSupportedShaderProfiles() const
00495         {
00496             return mSupportedShaderProfiles;
00497         }
00498 
00499 
00501         ushort getVertexProgramConstantFloatCount(void) const
00502         {
00503             return mVertexProgramConstantFloatCount;           
00504         }
00506         ushort getVertexProgramConstantIntCount(void) const
00507         {
00508             return mVertexProgramConstantIntCount;           
00509         }
00511         ushort getVertexProgramConstantBoolCount(void) const
00512         {
00513             return mVertexProgramConstantBoolCount;           
00514         }
00516         ushort getGeometryProgramConstantFloatCount(void) const
00517         {
00518             return mGeometryProgramConstantFloatCount;           
00519         }
00521         ushort getGeometryProgramConstantIntCount(void) const
00522         {
00523             return mGeometryProgramConstantIntCount;           
00524         }
00526         ushort getGeometryProgramConstantBoolCount(void) const
00527         {
00528             return mGeometryProgramConstantBoolCount;           
00529         }
00531         ushort getFragmentProgramConstantFloatCount(void) const
00532         {
00533             return mFragmentProgramConstantFloatCount;           
00534         }
00536         ushort getFragmentProgramConstantIntCount(void) const
00537         {
00538             return mFragmentProgramConstantIntCount;           
00539         }
00541         ushort getFragmentProgramConstantBoolCount(void) const
00542         {
00543             return mFragmentProgramConstantBoolCount;           
00544         }
00545 
00547         void setDeviceName(const String& name)
00548         {
00549             mDeviceName = name;
00550         }
00551 
00553         String getDeviceName() const
00554         {
00555             return mDeviceName;
00556         }
00557 
00559         void setVertexProgramConstantFloatCount(ushort c)
00560         {
00561             mVertexProgramConstantFloatCount = c;           
00562         }
00564         void setVertexProgramConstantIntCount(ushort c)
00565         {
00566             mVertexProgramConstantIntCount = c;           
00567         }
00569         void setVertexProgramConstantBoolCount(ushort c)
00570         {
00571             mVertexProgramConstantBoolCount = c;           
00572         }
00574         void setGeometryProgramConstantFloatCount(ushort c)
00575         {
00576             mGeometryProgramConstantFloatCount = c;           
00577         }
00579         void setGeometryProgramConstantIntCount(ushort c)
00580         {
00581             mGeometryProgramConstantIntCount = c;           
00582         }
00584         void setGeometryProgramConstantBoolCount(ushort c)
00585         {
00586             mGeometryProgramConstantBoolCount = c;           
00587         }
00589         void setFragmentProgramConstantFloatCount(ushort c)
00590         {
00591             mFragmentProgramConstantFloatCount = c;           
00592         }
00594         void setFragmentProgramConstantIntCount(ushort c)
00595         {
00596             mFragmentProgramConstantIntCount = c;           
00597         }
00599         void setFragmentProgramConstantBoolCount(ushort c)
00600         {
00601             mFragmentProgramConstantBoolCount = c;           
00602         }
00604         void setMaxPointSize(Real s)
00605         {
00606             mMaxPointSize = s;
00607         }
00609         Real getMaxPointSize(void) const
00610         {
00611             return mMaxPointSize;
00612         }
00614         void setNonPOW2TexturesLimited(bool l)
00615         {
00616             mNonPOW2TexturesLimited = l;
00617         }
00626         bool getNonPOW2TexturesLimited(void) const
00627         {
00628             return mNonPOW2TexturesLimited;
00629         }
00630 
00632         void setNumVertexTextureUnits(ushort n)
00633         {
00634             mNumVertexTextureUnits = n;
00635         }
00637         ushort getNumVertexTextureUnits(void) const
00638         {
00639             return mNumVertexTextureUnits;
00640         }
00642         void setVertexTextureUnitsShared(bool shared)
00643         {
00644             mVertexTextureUnitsShared = shared;
00645         }
00647         bool getVertexTextureUnitsShared(void) const
00648         {
00649             return mVertexTextureUnitsShared;
00650         }
00651 
00653         void setGeometryProgramNumOutputVertices(int numOutputVertices)
00654         {
00655             mGeometryProgramNumOutputVertices = numOutputVertices;
00656         }
00658         int getGeometryProgramNumOutputVertices(void) const
00659         {
00660             return mGeometryProgramNumOutputVertices;
00661         }
00662 
00664         String getRenderSystemName(void) const
00665         {
00666             return mRenderSystemName;
00667         }
00669         void setRenderSystemName(const String& rs)
00670         {
00671             mRenderSystemName = rs;
00672         }
00673 
00675         void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
00676         {
00677             mCategoryRelevant[cat] = relevant;
00678         }
00679 
00681         bool isCategoryRelevant(CapabilitiesCategory cat)
00682         {
00683             return mCategoryRelevant[cat];
00684         }
00685 
00686 
00687 
00689         void log(Log* pLog);
00690 
00691     };
00692 
00693 } // namespace
00694 
00695 #endif // __RenderSystemCapabilities__
00696 

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sat Apr 11 13:46:42 2009