OgreRenderSystemCapabilities.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __RenderSystemCapabilities__
#define __RenderSystemCapabilities__

// Precompiler options
#include "OgrePrerequisites.h"
#include "OgreString.h"
#include "OgreStringConverter.h"
#include "OgreStringVector.h"
#include "OgreResource.h"
#include "OgreLogManager.h"

// Because there are more than 32 possible Capabilities, more than 1 int is needed to store them all.
// In fact, an array of integers is used to store capabilities. However all the capabilities are defined in the single
// enum. The only way to know which capabilities should be stored where in the array is to use some of the 32 bits
// to record the category of the capability.  These top few bits are used as an index into mCapabilities array
// The lower bits are used to identify each capability individually by setting 1 bit for each

// Identifies how many bits are reserved for categories
// NOTE: Although 4 bits (currently) are enough
#define CAPS_CATEGORY_SIZE 4
#define OGRE_CAPS_BITSHIFT (32 - CAPS_CATEGORY_SIZE)
#define CAPS_CATEGORY_MASK (((1 << CAPS_CATEGORY_SIZE) - 1) << OGRE_CAPS_BITSHIFT)
#define OGRE_CAPS_VALUE(cat, val) ((cat << OGRE_CAPS_BITSHIFT) | (1 << val))

namespace Ogre 
{

    enum CapabilitiesCategory
    {
        CAPS_CATEGORY_COMMON = 0,
        CAPS_CATEGORY_COMMON_2 = 1,
        CAPS_CATEGORY_D3D9 = 2,
        CAPS_CATEGORY_GL = 3,
        CAPS_CATEGORY_COUNT = 4
    };

    // a is the category (which can be from 0 to 15)
    // b is the value (from 0 to 27)
    enum Capabilities
    {
        RSC_AUTOMIPMAP              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 0),
        RSC_BLENDING                = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 1),
        RSC_ANISOTROPY              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 2),
        RSC_DOT3                    = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 3),
        RSC_CUBEMAPPING             = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 4),
        RSC_HWSTENCIL               = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 5),
        RSC_VBO                     = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 7),
        RSC_VERTEX_PROGRAM          = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 9),
        RSC_FRAGMENT_PROGRAM        = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 10),
        RSC_SCISSOR_TEST            = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 11),
        RSC_TWO_SIDED_STENCIL       = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 12),
        RSC_STENCIL_WRAP            = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 13),
        RSC_HWOCCLUSION             = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 14),
        RSC_USER_CLIP_PLANES        = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 15),
        RSC_VERTEX_FORMAT_UBYTE4    = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 16),
        RSC_INFINITE_FAR_PLANE      = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 17),
        RSC_HWRENDER_TO_TEXTURE     = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 18),
        RSC_TEXTURE_FLOAT           = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 19),
        RSC_NON_POWER_OF_2_TEXTURES = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 20),
        RSC_TEXTURE_3D              = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 21),
        RSC_POINT_SPRITES           = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 22),
        RSC_POINT_EXTENDED_PARAMETERS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 23),
        RSC_VERTEX_TEXTURE_FETCH = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 24),
        RSC_MIPMAP_LOD_BIAS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 25),
        RSC_GEOMETRY_PROGRAM = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 26),
        RSC_HWRENDER_TO_VERTEX_BUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 27),

        RSC_TEXTURE_COMPRESSION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 0),
        RSC_TEXTURE_COMPRESSION_DXT = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 1),
        RSC_TEXTURE_COMPRESSION_VTC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 2),
        RSC_TEXTURE_COMPRESSION_PVRTC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 3),
        RSC_FIXED_FUNCTION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 4),
        RSC_MRT_DIFFERENT_BIT_DEPTHS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 5),
        RSC_ALPHA_TO_COVERAGE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 6),
        RSC_ADVANCED_BLEND_OPERATIONS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 7),
        RSC_RTT_SEPARATE_DEPTHBUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 8),
        RSC_RTT_MAIN_DEPTHBUFFER_ATTACHABLE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 9),
        RSC_RTT_DEPTHBUFFER_RESOLUTION_LESSEQUAL = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 10),
        RSC_VERTEX_BUFFER_INSTANCE_DATA = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 11),
        RSC_CAN_GET_COMPILED_SHADER_BUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 12),

        // ***** DirectX specific caps *****
        RSC_PERSTAGECONSTANT = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 0),

        // ***** GL Specific Caps *****
        RSC_GL1_5_NOVBO    = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 1),
        RSC_FBO              = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 2),
        RSC_FBO_ARB          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 3),
        RSC_FBO_ATI          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 4),
        RSC_PBUFFER          = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 5),
        RSC_GL1_5_NOHWOCCLUSION = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 6),
        RSC_POINT_EXTENDED_PARAMETERS_ARB = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 7),
        RSC_POINT_EXTENDED_PARAMETERS_EXT = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 8),
        RSC_SEPARATE_SHADER_OBJECTS = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 9)
    };

    struct _OgreExport DriverVersion 
    {
        int major;
        int minor;
        int release;
        int build;

        DriverVersion() 
        {
            major = minor = release = build = 0;
        }

        String toString() const 
        {
            StringUtil::StrStreamType str;
            str << major << "." << minor << "." << release << "." << build;
            return str.str();
        }

        void fromString(const String& versionString)
        {
            StringVector tokens = StringUtil::split(versionString, ".");
            if(!tokens.empty())
            {
                major = StringConverter::parseInt(tokens[0]);
                if (tokens.size() > 1)
                    minor = StringConverter::parseInt(tokens[1]);
                if (tokens.size() > 2)
                    release = StringConverter::parseInt(tokens[2]);
                if (tokens.size() > 3)
                    build = StringConverter::parseInt(tokens[3]);
            }

        }
    };

    enum GPUVendor
    {
        GPU_UNKNOWN = 0,
        GPU_NVIDIA = 1,
        GPU_ATI = 2, 
        GPU_INTEL = 3,
        GPU_S3 = 4,
        GPU_MATROX = 5,
        GPU_3DLABS = 6,
        GPU_SIS = 7,
        GPU_IMAGINATION_TECHNOLOGIES = 8,
        GPU_APPLE = 9,  // Apple Software Renderer
        GPU_NOKIA = 10,
        GPU_MS_SOFTWARE = 11, // Microsoft software device
        GPU_MS_WARP = 12, // Microsoft WARP (Windows Advanced Rasterization Platform) software device - http://msdn.microsoft.com/en-us/library/dd285359.aspx

        GPU_VENDOR_COUNT = 13
    };

    class _OgreExport RenderSystemCapabilities : public RenderSysAlloc
    {

    public:

        typedef set<String>::type ShaderProfiles;
    private:
        DriverVersion mDriverVersion;
        GPUVendor mVendor;

        static StringVector msGPUVendorStrings;
        static void initVendorStrings();

        ushort mNumWorldMatrices;
        ushort mNumTextureUnits;
        ushort mStencilBufferBitDepth;
        ushort mNumVertexBlendMatrices;
        int mCapabilities[CAPS_CATEGORY_COUNT];
        bool mCategoryRelevant[CAPS_CATEGORY_COUNT];
        String mDeviceName;
        String mRenderSystemName;

        ushort mVertexProgramConstantFloatCount;           
        ushort mVertexProgramConstantIntCount;           
        ushort mVertexProgramConstantBoolCount;           
        ushort mGeometryProgramConstantFloatCount;           
        ushort mGeometryProgramConstantIntCount;           
        ushort mGeometryProgramConstantBoolCount;           
        ushort mFragmentProgramConstantFloatCount;           
        ushort mFragmentProgramConstantIntCount;           
        ushort mFragmentProgramConstantBoolCount;
        ushort mNumMultiRenderTargets;
        Real mMaxPointSize;
        bool mNonPOW2TexturesLimited;
        ushort mNumVertexTextureUnits;
        bool mVertexTextureUnitsShared;
        int mGeometryProgramNumOutputVertices;


        ShaderProfiles mSupportedShaderProfiles;

    public: 
        RenderSystemCapabilities ();
        virtual ~RenderSystemCapabilities ();

        virtual size_t calculateSize() const {return 0;}

        void setDriverVersion(const DriverVersion& version)
        {
            mDriverVersion = version;
        }

        void parseDriverVersionFromString(const String& versionString)
        {
            DriverVersion version;
            version.fromString(versionString);
            setDriverVersion(version);
        }


        DriverVersion getDriverVersion() const
        {
            return mDriverVersion;
        }

        GPUVendor getVendor() const
        {
            return mVendor;
        }

        void setVendor(GPUVendor v)
        {
            mVendor = v;
        }

        void parseVendorFromString(const String& vendorString)
        {
            setVendor(vendorFromString(vendorString));
        }

        static GPUVendor vendorFromString(const String& vendorString);
        static String vendorToString(GPUVendor v);

        bool isDriverOlderThanVersion(DriverVersion v) const
        {
            if (mDriverVersion.major < v.major)
                return true;
            else if (mDriverVersion.major == v.major && 
                mDriverVersion.minor < v.minor)
                return true;
            else if (mDriverVersion.major == v.major && 
                mDriverVersion.minor == v.minor && 
                mDriverVersion.release < v.release)
                return true;
            else if (mDriverVersion.major == v.major && 
                mDriverVersion.minor == v.minor && 
                mDriverVersion.release == v.release &&
                mDriverVersion.build < v.build)
                return true;
            return false;
        }

        void setNumWorldMatrices(ushort num)
        {
            mNumWorldMatrices = num;
        }

        void setNumTextureUnits(ushort num)
        {
            mNumTextureUnits = num;
        }

        void setStencilBufferBitDepth(ushort num)
        {
            mStencilBufferBitDepth = num;
        }

        void setNumVertexBlendMatrices(ushort num)
        {
            mNumVertexBlendMatrices = num;
        }

        void setNumMultiRenderTargets(ushort num)
        {
            mNumMultiRenderTargets = num;
        }

        ushort getNumWorldMatrices(void) const
        { 
            return mNumWorldMatrices;
        }

        ushort getNumTextureUnits(void) const
        {
            return mNumTextureUnits;
        }

        ushort getStencilBufferBitDepth(void) const
        {
            return mStencilBufferBitDepth;
        }

        ushort getNumVertexBlendMatrices(void) const
        {
            return mNumVertexBlendMatrices;
        }

        ushort getNumMultiRenderTargets(void) const
        {
            return mNumMultiRenderTargets;
        }

        bool isCapabilityRenderSystemSpecific(const Capabilities c) const
        {
            int cat = c >> OGRE_CAPS_BITSHIFT;
            if(cat == CAPS_CATEGORY_GL || cat == CAPS_CATEGORY_D3D9)
                return true;
            return false;
        }

        void setCapability(const Capabilities c) 
        { 
            int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
            // zero out the index from the stored capability
            mCapabilities[index] |= (c & ~CAPS_CATEGORY_MASK);
        }

        void unsetCapability(const Capabilities c) 
        { 
            int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
            // zero out the index from the stored capability
            mCapabilities[index] &= (~c | CAPS_CATEGORY_MASK);
        }

        bool hasCapability(const Capabilities c) const
        {
            int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
            // test against
            if(mCapabilities[index] & (c & ~CAPS_CATEGORY_MASK))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        void addShaderProfile(const String& profile)
        {
            mSupportedShaderProfiles.insert(profile);

        }

        void removeShaderProfile(const String& profile)
        {
            mSupportedShaderProfiles.erase(profile);
        }

        bool isShaderProfileSupported(const String& profile) const
        {
            return (mSupportedShaderProfiles.end() != mSupportedShaderProfiles.find(profile));
        }


        const ShaderProfiles& getSupportedShaderProfiles() const
        {
            return mSupportedShaderProfiles;
        }


        ushort getVertexProgramConstantFloatCount(void) const
        {
            return mVertexProgramConstantFloatCount;           
        }
        ushort getVertexProgramConstantIntCount(void) const
        {
            return mVertexProgramConstantIntCount;           
        }
        ushort getVertexProgramConstantBoolCount(void) const
        {
            return mVertexProgramConstantBoolCount;           
        }
        ushort getGeometryProgramConstantFloatCount(void) const
        {
            return mGeometryProgramConstantFloatCount;           
        }
        ushort getGeometryProgramConstantIntCount(void) const
        {
            return mGeometryProgramConstantIntCount;           
        }
        ushort getGeometryProgramConstantBoolCount(void) const
        {
            return mGeometryProgramConstantBoolCount;           
        }
        ushort getFragmentProgramConstantFloatCount(void) const
        {
            return mFragmentProgramConstantFloatCount;           
        }
        ushort getFragmentProgramConstantIntCount(void) const
        {
            return mFragmentProgramConstantIntCount;           
        }
        ushort getFragmentProgramConstantBoolCount(void) const
        {
            return mFragmentProgramConstantBoolCount;           
        }

        void setDeviceName(const String& name)
        {
            mDeviceName = name;
        }

        String getDeviceName() const
        {
            return mDeviceName;
        }

        void setVertexProgramConstantFloatCount(ushort c)
        {
            mVertexProgramConstantFloatCount = c;           
        }
        void setVertexProgramConstantIntCount(ushort c)
        {
            mVertexProgramConstantIntCount = c;           
        }
        void setVertexProgramConstantBoolCount(ushort c)
        {
            mVertexProgramConstantBoolCount = c;           
        }
        void setGeometryProgramConstantFloatCount(ushort c)
        {
            mGeometryProgramConstantFloatCount = c;           
        }
        void setGeometryProgramConstantIntCount(ushort c)
        {
            mGeometryProgramConstantIntCount = c;           
        }
        void setGeometryProgramConstantBoolCount(ushort c)
        {
            mGeometryProgramConstantBoolCount = c;           
        }
        void setFragmentProgramConstantFloatCount(ushort c)
        {
            mFragmentProgramConstantFloatCount = c;           
        }
        void setFragmentProgramConstantIntCount(ushort c)
        {
            mFragmentProgramConstantIntCount = c;           
        }
        void setFragmentProgramConstantBoolCount(ushort c)
        {
            mFragmentProgramConstantBoolCount = c;           
        }
        void setMaxPointSize(Real s)
        {
            mMaxPointSize = s;
        }
        Real getMaxPointSize(void) const
        {
            return mMaxPointSize;
        }
        void setNonPOW2TexturesLimited(bool l)
        {
            mNonPOW2TexturesLimited = l;
        }
        bool getNonPOW2TexturesLimited(void) const
        {
            return mNonPOW2TexturesLimited;
        }

        void setNumVertexTextureUnits(ushort n)
        {
            mNumVertexTextureUnits = n;
        }
        ushort getNumVertexTextureUnits(void) const
        {
            return mNumVertexTextureUnits;
        }
        void setVertexTextureUnitsShared(bool shared)
        {
            mVertexTextureUnitsShared = shared;
        }
        bool getVertexTextureUnitsShared(void) const
        {
            return mVertexTextureUnitsShared;
        }

        void setGeometryProgramNumOutputVertices(int numOutputVertices)
        {
            mGeometryProgramNumOutputVertices = numOutputVertices;
        }
        int getGeometryProgramNumOutputVertices(void) const
        {
            return mGeometryProgramNumOutputVertices;
        }

        String getRenderSystemName(void) const
        {
            return mRenderSystemName;
        }
        void setRenderSystemName(const String& rs)
        {
            mRenderSystemName = rs;
        }

        void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
        {
            mCategoryRelevant[cat] = relevant;
        }

        bool isCategoryRelevant(CapabilitiesCategory cat)
        {
            return mCategoryRelevant[cat];
        }



        void log(Log* pLog);

    };

} // namespace

#endif // __RenderSystemCapabilities__