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-2012 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 __RenderSystemCapabilities__
    00029 #define __RenderSystemCapabilities__
    00030
    00031 // Precompiler options
    00032 #include "OgrePrerequisites.h"
    00033 #include "OgreString.h"
    00034 #include "OgreStringConverter.h"
    00035 #include "OgreStringVector.h"
    00036 #include "OgreResource.h"
    00037 #include "OgreLogManager.h"
    00038
    00039 // Because there are more than 32 possible Capabilities, more than 1 int is needed to store them all.
    00040 // In fact, an array of integers is used to store capabilities. However all the capabilities are defined in the single
    00041 // enum. The only way to know which capabilities should be stored where in the array is to use some of the 32 bits
    00042 // to record the category of the capability.  These top few bits are used as an index into mCapabilities array
    00043 // The lower bits are used to identify each capability individually by setting 1 bit for each
    00044
    00045 // Identifies how many bits are reserved for categories
    00046 // NOTE: Although 4 bits (currently) are enough
    00047 #define CAPS_CATEGORY_SIZE 4
    00048 #define OGRE_CAPS_BITSHIFT (32 - CAPS_CATEGORY_SIZE)
    00049 #define CAPS_CATEGORY_MASK (((1 << CAPS_CATEGORY_SIZE) - 1) << OGRE_CAPS_BITSHIFT)
    00050 #define OGRE_CAPS_VALUE(cat, val) ((cat << OGRE_CAPS_BITSHIFT) | (1 << val))
    00051
    00052 namespace Ogre
    00053 {
    00061
    00062     enum CapabilitiesCategory
    00063     {
    00064         CAPS_CATEGORY_COMMON = 0,
    00065         CAPS_CATEGORY_COMMON_2 = 1,
    00066         CAPS_CATEGORY_D3D9 = 2,
    00067         CAPS_CATEGORY_GL = 3,
    00069         CAPS_CATEGORY_COUNT = 4
    00070     };
    00071
    00074     // a is the category (which can be from 0 to 15)
    00075     // b is the value (from 0 to 27)
    00076     enum Capabilities
    00077     {
    00079         RSC_AUTOMIPMAP              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 0),
    00080         RSC_BLENDING                = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 1),
    00082         RSC_ANISOTROPY              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 2),
    00084         RSC_DOT3                    = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 3),
    00086         RSC_CUBEMAPPING             = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 4),
    00088         RSC_HWSTENCIL               = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 5),
    00090         RSC_VBO                     = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 7),
    00092         RSC_VERTEX_PROGRAM          = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 9),
    00094         RSC_FRAGMENT_PROGRAM        = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 10),
    00096         RSC_SCISSOR_TEST            = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 11),
    00098         RSC_TWO_SIDED_STENCIL       = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 12),
    00100         RSC_STENCIL_WRAP            = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 13),
    00102         RSC_HWOCCLUSION             = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 14),
    00104         RSC_USER_CLIP_PLANES        = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 15),
    00106         RSC_VERTEX_FORMAT_UBYTE4    = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 16),
    00108         RSC_INFINITE_FAR_PLANE      = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 17),
    00110         RSC_HWRENDER_TO_TEXTURE     = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 18),
    00112         RSC_TEXTURE_FLOAT           = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 19),
    00114         RSC_NON_POWER_OF_2_TEXTURES = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 20),
    00116         RSC_TEXTURE_3D              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 21),
    00118         RSC_POINT_SPRITES           = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 22),
    00120         RSC_POINT_EXTENDED_PARAMETERS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 23),
    00122         RSC_VERTEX_TEXTURE_FETCH = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 24),
    00124         RSC_MIPMAP_LOD_BIAS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 25),
    00126         RSC_GEOMETRY_PROGRAM = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 26),
    00128         RSC_HWRENDER_TO_VERTEX_BUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 27),
    00129
    00131         RSC_TEXTURE_COMPRESSION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 0),
    00133         RSC_TEXTURE_COMPRESSION_DXT = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 1),
    00135         RSC_TEXTURE_COMPRESSION_VTC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 2),
    00137         RSC_TEXTURE_COMPRESSION_PVRTC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 3),
    00139         RSC_FIXED_FUNCTION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 4),
    00141         RSC_MRT_DIFFERENT_BIT_DEPTHS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 5),
    00143         RSC_ALPHA_TO_COVERAGE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 6),
    00145         RSC_ADVANCED_BLEND_OPERATIONS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 7),
    00147         RSC_RTT_SEPARATE_DEPTHBUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 8),
    00150         RSC_RTT_MAIN_DEPTHBUFFER_ATTACHABLE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 9),
    00153         RSC_RTT_DEPTHBUFFER_RESOLUTION_LESSEQUAL = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 10),
    00155         RSC_VERTEX_BUFFER_INSTANCE_DATA = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 11),
    00157         RSC_CAN_GET_COMPILED_SHADER_BUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 12),
    00158
    00159         // ***** DirectX specific caps *****
    00161         RSC_PERSTAGECONSTANT = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 0),
    00162
    00163         // ***** GL Specific Caps *****
    00165         RSC_GL1_5_NOVBO    = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 1),
    00167         RSC_FBO              = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 2),
    00169         RSC_FBO_ARB          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 3),
    00171         RSC_FBO_ATI          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 4),
    00173         RSC_PBUFFER          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 5),
    00175         RSC_GL1_5_NOHWOCCLUSION = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 6),
    00177         RSC_POINT_EXTENDED_PARAMETERS_ARB = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 7),
    00179         RSC_POINT_EXTENDED_PARAMETERS_EXT = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 8),
    00181         RSC_SEPARATE_SHADER_OBJECTS = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 9)
    00182     };
    00183
    00186     struct _OgreExport DriverVersion
    00187     {
    00188         int major;
    00189         int minor;
    00190         int release;
    00191         int build;
    00192
    00193         DriverVersion()
    00194         {
    00195             major = minor = release = build = 0;
    00196         }
    00197
    00198         String toString() const
    00199         {
    00200             StringUtil::StrStreamType str;
    00201             str << major << "." << minor << "." << release << "." << build;
    00202             return str.str();
    00203         }
    00204
    00205         void fromString(const String& versionString)
    00206         {
    00207             StringVector tokens = StringUtil::split(versionString, ".");
    00208             if(!tokens.empty())
    00209             {
    00210                 major = StringConverter::parseInt(tokens[0]);
    00211                 if (tokens.size() > 1)
    00212                     minor = StringConverter::parseInt(tokens[1]);
    00213                 if (tokens.size() > 2)
    00214                     release = StringConverter::parseInt(tokens[2]);
    00215                 if (tokens.size() > 3)
    00216                     build = StringConverter::parseInt(tokens[3]);
    00217             }
    00218
    00219         }
    00220     };
    00221
    00223     enum GPUVendor
    00224     {
    00225         GPU_UNKNOWN = 0,
    00226         GPU_NVIDIA = 1,
    00227         GPU_ATI = 2,
    00228         GPU_INTEL = 3,
    00229         GPU_S3 = 4,
    00230         GPU_MATROX = 5,
    00231         GPU_3DLABS = 6,
    00232         GPU_SIS = 7,
    00233         GPU_IMAGINATION_TECHNOLOGIES = 8,
    00234         GPU_APPLE = 9,  // Apple Software Renderer
    00235         GPU_NOKIA = 10,
    00236         GPU_MS_SOFTWARE = 11, // Microsoft software device
    00237         GPU_MS_WARP = 12, // Microsoft WARP (Windows Advanced Rasterization Platform) software device - http://msdn.microsoft.com/en-us/library/dd285359.aspx
    00238
    00240         GPU_VENDOR_COUNT = 13
    00241     };
    00242
    00248     class _OgreExport RenderSystemCapabilities : public RenderSysAlloc
    00249     {
    00250
    00251     public:
    00252
    00253         typedef set<String>::type ShaderProfiles;
    00254     private:
    00258         DriverVersion mDriverVersion;
    00260         GPUVendor mVendor;
    00261
    00262         static StringVector msGPUVendorStrings;
    00263         static void initVendorStrings();
    00264
    00266         ushort mNumWorldMatrices;
    00268         ushort mNumTextureUnits;
    00270         ushort mStencilBufferBitDepth;
    00272         ushort mNumVertexBlendMatrices;
    00274         int mCapabilities[CAPS_CATEGORY_COUNT];
    00276         bool mCategoryRelevant[CAPS_CATEGORY_COUNT];
    00278         String mDeviceName;
    00280         String mRenderSystemName;
    00281
    00283         ushort mVertexProgramConstantFloatCount;
    00285         ushort mVertexProgramConstantIntCount;
    00287         ushort mVertexProgramConstantBoolCount;
    00289         ushort mGeometryProgramConstantFloatCount;
    00291         ushort mGeometryProgramConstantIntCount;
    00293         ushort mGeometryProgramConstantBoolCount;
    00295         ushort mFragmentProgramConstantFloatCount;
    00297         ushort mFragmentProgramConstantIntCount;
    00299         ushort mFragmentProgramConstantBoolCount;
    00301         ushort mNumMultiRenderTargets;
    00303         Real mMaxPointSize;
    00305         bool mNonPOW2TexturesLimited;
    00307         ushort mNumVertexTextureUnits;
    00309         bool mVertexTextureUnitsShared;
    00311         int mGeometryProgramNumOutputVertices;
    00312
    00313
    00315         ShaderProfiles mSupportedShaderProfiles;
    00316
    00317     public:
    00318         RenderSystemCapabilities ();
    00319         virtual ~RenderSystemCapabilities ();
    00320
    00321         virtual size_t calculateSize() const {return 0;}
    00322
    00324         void setDriverVersion(const DriverVersion& version)
    00325         {
    00326             mDriverVersion = version;
    00327         }
    00328
    00329         void parseDriverVersionFromString(const String& versionString)
    00330         {
    00331             DriverVersion version;
    00332             version.fromString(versionString);
    00333             setDriverVersion(version);
    00334         }
    00335
    00336
    00337         DriverVersion getDriverVersion() const
    00338         {
    00339             return mDriverVersion;
    00340         }
    00341
    00342         GPUVendor getVendor() const
    00343         {
    00344             return mVendor;
    00345         }
    00346
    00347         void setVendor(GPUVendor v)
    00348         {
    00349             mVendor = v;
    00350         }
    00351
    00353         void parseVendorFromString(const String& vendorString)
    00354         {
    00355             setVendor(vendorFromString(vendorString));
    00356         }
    00357
    00359         static GPUVendor vendorFromString(const String& vendorString);
    00361         static String vendorToString(GPUVendor v);
    00362
    00363         bool isDriverOlderThanVersion(DriverVersion v) const
    00364         {
    00365             if (mDriverVersion.major < v.major)
    00366                 return true;
    00367             else if (mDriverVersion.major == v.major &&
    00368                 mDriverVersion.minor < v.minor)
    00369                 return true;
    00370             else if (mDriverVersion.major == v.major &&
    00371                 mDriverVersion.minor == v.minor &&
    00372                 mDriverVersion.release < v.release)
    00373                 return true;
    00374             else if (mDriverVersion.major == v.major &&
    00375                 mDriverVersion.minor == v.minor &&
    00376                 mDriverVersion.release == v.release &&
    00377                 mDriverVersion.build < v.build)
    00378                 return true;
    00379             return false;
    00380         }
    00381
    00382         void setNumWorldMatrices(ushort num)
    00383         {
    00384             mNumWorldMatrices = num;
    00385         }
    00386
    00387         void setNumTextureUnits(ushort num)
    00388         {
    00389             mNumTextureUnits = num;
    00390         }
    00391
    00392         void setStencilBufferBitDepth(ushort num)
    00393         {
    00394             mStencilBufferBitDepth = num;
    00395         }
    00396
    00397         void setNumVertexBlendMatrices(ushort num)
    00398         {
    00399             mNumVertexBlendMatrices = num;
    00400         }
    00401
    00403         void setNumMultiRenderTargets(ushort num)
    00404         {
    00405             mNumMultiRenderTargets = num;
    00406         }
    00407
    00408         ushort getNumWorldMatrices(void) const
    00409         {
    00410             return mNumWorldMatrices;
    00411         }
    00412
    00425         ushort getNumTextureUnits(void) const
    00426         {
    00427             return mNumTextureUnits;
    00428         }
    00429
    00436         ushort getStencilBufferBitDepth(void) const
    00437         {
    00438             return mStencilBufferBitDepth;
    00439         }
    00440
    00443         ushort getNumVertexBlendMatrices(void) const
    00444         {
    00445             return mNumVertexBlendMatrices;
    00446         }
    00447
    00449         ushort getNumMultiRenderTargets(void) const
    00450         {
    00451             return mNumMultiRenderTargets;
    00452         }
    00453
    00456         bool isCapabilityRenderSystemSpecific(const Capabilities c) const
    00457         {
    00458             int cat = c >> OGRE_CAPS_BITSHIFT;
    00459             if(cat == CAPS_CATEGORY_GL || cat == CAPS_CATEGORY_D3D9)
    00460                 return true;
    00461             return false;
    00462         }
    00463
    00466         void setCapability(const Capabilities c)
    00467         {
    00468             int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
    00469             // zero out the index from the stored capability
    00470             mCapabilities[index] |= (c & ~CAPS_CATEGORY_MASK);
    00471         }
    00472
    00475         void unsetCapability(const Capabilities c)
    00476         {
    00477             int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
    00478             // zero out the index from the stored capability
    00479             mCapabilities[index] &= (~c | CAPS_CATEGORY_MASK);
    00480         }
    00481
    00484         bool hasCapability(const Capabilities c) const
    00485         {
    00486             int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
    00487             // test against
    00488             if(mCapabilities[index] & (c & ~CAPS_CATEGORY_MASK))
    00489             {
    00490                 return true;
    00491             }
    00492             else
    00493             {
    00494                 return false;
    00495             }
    00496         }
    00497
    00500         void addShaderProfile(const String& profile)
    00501         {
    00502             mSupportedShaderProfiles.insert(profile);
    00503
    00504         }
    00505
    00508         void removeShaderProfile(const String& profile)
    00509         {
    00510             mSupportedShaderProfiles.erase(profile);
    00511         }
    00512
    00515         bool isShaderProfileSupported(const String& profile) const
    00516         {
    00517             return (mSupportedShaderProfiles.end() != mSupportedShaderProfiles.find(profile));
    00518         }
    00519
    00520
    00523         const ShaderProfiles& getSupportedShaderProfiles() const
    00524         {
    00525             return mSupportedShaderProfiles;
    00526         }
    00527
    00528
    00530         ushort getVertexProgramConstantFloatCount(void) const
    00531         {
    00532             return mVertexProgramConstantFloatCount;
    00533         }
    00535         ushort getVertexProgramConstantIntCount(void) const
    00536         {
    00537             return mVertexProgramConstantIntCount;
    00538         }
    00540         ushort getVertexProgramConstantBoolCount(void) const
    00541         {
    00542             return mVertexProgramConstantBoolCount;
    00543         }
    00545         ushort getGeometryProgramConstantFloatCount(void) const
    00546         {
    00547             return mGeometryProgramConstantFloatCount;
    00548         }
    00550         ushort getGeometryProgramConstantIntCount(void) const
    00551         {
    00552             return mGeometryProgramConstantIntCount;
    00553         }
    00555         ushort getGeometryProgramConstantBoolCount(void) const
    00556         {
    00557             return mGeometryProgramConstantBoolCount;
    00558         }
    00560         ushort getFragmentProgramConstantFloatCount(void) const
    00561         {
    00562             return mFragmentProgramConstantFloatCount;
    00563         }
    00565         ushort getFragmentProgramConstantIntCount(void) const
    00566         {
    00567             return mFragmentProgramConstantIntCount;
    00568         }
    00570         ushort getFragmentProgramConstantBoolCount(void) const
    00571         {
    00572             return mFragmentProgramConstantBoolCount;
    00573         }
    00574
    00576         void setDeviceName(const String& name)
    00577         {
    00578             mDeviceName = name;
    00579         }
    00580
    00582         String getDeviceName() const
    00583         {
    00584             return mDeviceName;
    00585         }
    00586
    00588         void setVertexProgramConstantFloatCount(ushort c)
    00589         {
    00590             mVertexProgramConstantFloatCount = c;
    00591         }
    00593         void setVertexProgramConstantIntCount(ushort c)
    00594         {
    00595             mVertexProgramConstantIntCount = c;
    00596         }
    00598         void setVertexProgramConstantBoolCount(ushort c)
    00599         {
    00600             mVertexProgramConstantBoolCount = c;
    00601         }
    00603         void setGeometryProgramConstantFloatCount(ushort c)
    00604         {
    00605             mGeometryProgramConstantFloatCount = c;
    00606         }
    00608         void setGeometryProgramConstantIntCount(ushort c)
    00609         {
    00610             mGeometryProgramConstantIntCount = c;
    00611         }
    00613         void setGeometryProgramConstantBoolCount(ushort c)
    00614         {
    00615             mGeometryProgramConstantBoolCount = c;
    00616         }
    00618         void setFragmentProgramConstantFloatCount(ushort c)
    00619         {
    00620             mFragmentProgramConstantFloatCount = c;
    00621         }
    00623         void setFragmentProgramConstantIntCount(ushort c)
    00624         {
    00625             mFragmentProgramConstantIntCount = c;
    00626         }
    00628         void setFragmentProgramConstantBoolCount(ushort c)
    00629         {
    00630             mFragmentProgramConstantBoolCount = c;
    00631         }
    00633         void setMaxPointSize(Real s)
    00634         {
    00635             mMaxPointSize = s;
    00636         }
    00638         Real getMaxPointSize(void) const
    00639         {
    00640             return mMaxPointSize;
    00641         }
    00643         void setNonPOW2TexturesLimited(bool l)
    00644         {
    00645             mNonPOW2TexturesLimited = l;
    00646         }
    00655         bool getNonPOW2TexturesLimited(void) const
    00656         {
    00657             return mNonPOW2TexturesLimited;
    00658         }
    00659
    00661         void setNumVertexTextureUnits(ushort n)
    00662         {
    00663             mNumVertexTextureUnits = n;
    00664         }
    00666         ushort getNumVertexTextureUnits(void) const
    00667         {
    00668             return mNumVertexTextureUnits;
    00669         }
    00671         void setVertexTextureUnitsShared(bool shared)
    00672         {
    00673             mVertexTextureUnitsShared = shared;
    00674         }
    00676         bool getVertexTextureUnitsShared(void) const
    00677         {
    00678             return mVertexTextureUnitsShared;
    00679         }
    00680
    00682         void setGeometryProgramNumOutputVertices(int numOutputVertices)
    00683         {
    00684             mGeometryProgramNumOutputVertices = numOutputVertices;
    00685         }
    00687         int getGeometryProgramNumOutputVertices(void) const
    00688         {
    00689             return mGeometryProgramNumOutputVertices;
    00690         }
    00691
    00693         String getRenderSystemName(void) const
    00694         {
    00695             return mRenderSystemName;
    00696         }
    00698         void setRenderSystemName(const String& rs)
    00699         {
    00700             mRenderSystemName = rs;
    00701         }
    00702
    00704         void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
    00705         {
    00706             mCategoryRelevant[cat] = relevant;
    00707         }
    00708
    00710         bool isCategoryRelevant(CapabilitiesCategory cat)
    00711         {
    00712             return mCategoryRelevant[cat];
    00713         }
    00714
    00715
    00716
    00718         void log(Log* pLog);
    00719
    00720     };
    00721
    00724 } // namespace
    00725
    00726 #endif // __RenderSystemCapabilities__
    00727

Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sun Sep 2 2012 07:27:23