/* ----------------------------------------------------------------------------- This source file is part of OGRE (Object-oriented Graphics Rendering Engine) For the latest info, see http://www.ogre3d.org/ Copyright (c) 2000-2014 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 "OgreStringVector.h" #include "OgreStringConverter.h" #include "OgreHeaderPrefix.h" #include "OgreGpuProgram.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 { /** \addtogroup Core * @{ */ /** \addtogroup RenderSystem * @{ */ /// Enumerates the categories of capabilities enum CapabilitiesCategory { CAPS_CATEGORY_COMMON = 0, CAPS_CATEGORY_COMMON_2 = 1, CAPS_CATEGORY_D3D9 = 2, CAPS_CATEGORY_GL = 3, CAPS_CATEGORY_COMMON_3 = 4, /// Placeholder for max value CAPS_CATEGORY_COUNT = 5 }; /// Enum describing the different hardware capabilities we want to check for /// OGRE_CAPS_VALUE(a, b) defines each capability /// a is the category (which can be from 0 to 15) /// b is the value (from 0 to 27) enum Capabilities { /// specifying a "-1" in the index buffer starts a new draw command. RSC_PRIMITIVE_RESTART = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 0), /// GL ES2/ES3 does not support generating mipmaps for compressed formats in hardware RSC_AUTOMIPMAP_COMPRESSED = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 1), /// Supports anisotropic texture filtering RSC_ANISOTROPY = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 2), /// Supports depth clamping RSC_DEPTH_CLAMP = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 3), /// Supports linewidth != 1.0 RSC_WIDE_LINES = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 4), /// Supports hardware stencil buffer RSC_HWSTENCIL = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 5), /// Supports read/write buffers with atomic counters (e.g. RWStructuredBuffer or SSBO) RSC_READ_WRITE_BUFFERS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 6), /// Supports compressed textures in the ASTC format RSC_TEXTURE_COMPRESSION_ASTC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 7), /// Supports 32bit hardware index buffers RSC_32BIT_INDEX = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 8), /// Supports vertex programs (vertex shaders) /// @deprecated All targeted APIs by Ogre support this feature RSC_VERTEX_PROGRAM = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 9), /// Supports tessellation domain and hull programs RSC_TESSELLATION_PROGRAM = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 10), /// Supports 2D Texture Arrays RSC_TEXTURE_2D_ARRAY = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 11), /// Supports separate stencil updates for both front and back faces RSC_TWO_SIDED_STENCIL = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 12), /// Supports wrapping the stencil value at the range extremeties RSC_STENCIL_WRAP = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 13), /// Supports hardware occlusion queries RSC_HWOCCLUSION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 14), /// Supports user clipping planes RSC_USER_CLIP_PLANES = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 15), /// Supports hardware compute programs RSC_COMPUTE_PROGRAM = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 16), /// Supports 1d textures RSC_TEXTURE_1D = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 17), /// Supports hardware render-to-texture (bigger than framebuffer) RSC_HWRENDER_TO_TEXTURE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 18), /// Supports float textures and render targets RSC_TEXTURE_FLOAT = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 19), /// Supports non-power of two textures RSC_NON_POWER_OF_2_TEXTURES = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 20), /// Supports 3d (volume) textures RSC_TEXTURE_3D = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 21), /// Supports basic point sprite rendering RSC_POINT_SPRITES = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 22), /// @deprecated same as RSC_POINT_SPRITES RSC_POINT_EXTENDED_PARAMETERS = RSC_POINT_SPRITES, /// Supports rendering to vertex buffers RSC_HWRENDER_TO_VERTEX_BUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 23), /// @deprecated use getNumVertexTextureUnits() RSC_VERTEX_TEXTURE_FETCH = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 24), /// Supports mipmap LOD biasing RSC_MIPMAP_LOD_BIAS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 25), /// Supports hardware geometry programs RSC_GEOMETRY_PROGRAM = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 26), /// Supports unaligned #VET_HALF3, #VET_SHORT3, #VET_USHORT3 formats RSC_VERTEX_FORMAT_16X3 = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON, 27), /// Supports compressed textures RSC_TEXTURE_COMPRESSION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 0), /// Supports compressed textures in the DXT/ST3C formats RSC_TEXTURE_COMPRESSION_DXT = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 1), /// Supports compressed textures in the VTC format RSC_TEXTURE_COMPRESSION_VTC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 2), /// Supports compressed textures in the PVRTC format RSC_TEXTURE_COMPRESSION_PVRTC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 3), /// Supports compressed textures in the ATC format RSC_TEXTURE_COMPRESSION_ATC = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 4), /// Supports compressed textures in the ETC1 format RSC_TEXTURE_COMPRESSION_ETC1 = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 5), /// Supports compressed textures in the ETC2 format RSC_TEXTURE_COMPRESSION_ETC2 = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 6), /// Supports compressed textures in BC4 and BC5 format (DirectX feature level 10_0) RSC_TEXTURE_COMPRESSION_BC4_BC5 = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 7), /// Supports compressed textures in BC6H and BC7 format (DirectX feature level 11_0) RSC_TEXTURE_COMPRESSION_BC6H_BC7 = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 8), /// Supports fixed-function pipeline RSC_FIXED_FUNCTION = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 9), /// Supports #VET_INT_10_10_10_2_NORM RSC_VERTEX_FORMAT_INT_10_10_10_2 = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 10), /// Supports Alpha to Coverage (A2C) RSC_ALPHA_TO_COVERAGE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 11), /// Supports reading back compiled shaders RSC_CAN_GET_COMPILED_SHADER_BUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 12), /// Supports HW gamma, both in the framebuffer and as texture. RSC_HW_GAMMA = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 13), /// @deprecated do not use RSC_RTT_MAIN_DEPTHBUFFER_ATTACHABLE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 14), /// Supports attaching a buffer to a render target that is smaller than the buffer. /// Otherwise must be of _exact_ same resolution. D3D 9, OGL 3.0 (not 2.0, not D3D10) RSC_RTT_INDEPENDENT_BUFFER_SIZE = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 15), /// @deprecated use RSC_RTT_INDEPENDENT_BUFFER_SIZE RSC_RTT_DEPTHBUFFER_RESOLUTION_LESSEQUAL = RSC_RTT_INDEPENDENT_BUFFER_SIZE, /// Supports using vertex buffers for instance data RSC_VERTEX_BUFFER_INSTANCE_DATA = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 16), /// Supports mesh and task programs RSC_MESH_PROGRAM = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 17), /// Supports setting viewport and rendertarget array index from any shader stage RSC_VP_RT_INDEX_ANY_SHADER = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 18), /// Supports backing GpuSharedParameters by a hardware constant/uniform buffer (UBO / cbuffer) RSC_UNIFORM_BUFFERS = OGRE_CAPS_VALUE(CAPS_CATEGORY_COMMON_2, 19), // ***** DirectX specific caps ***** /// Is DirectX feature "per stage constants" supported RSC_PERSTAGECONSTANT = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 0), /// D3D11: supports reading back the inactive depth-stencil buffer as texture RSC_READ_BACK_AS_TEXTURE = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 1), /// the renderer will try to use W-buffers when available /// W-buffers are enabled by default for 16bit depth buffers and disabled for all other /// depths. RSC_WBUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 2), /// D3D11: Supports asynchronous hardware occlusion queries RSC_HWOCCLUSION_ASYNCHRONOUS = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 3), RSC_HWRENDER_TO_TEXTURE_3D = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 4), /// All MRTs must have same bit depths RSC_MRT_SAME_BIT_DEPTHS = OGRE_CAPS_VALUE(CAPS_CATEGORY_D3D9, 5), // ***** GL Specific Caps ***** /// Support for PBuffer RSC_PBUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 0), /// Support for Separate Shader Objects RSC_SEPARATE_SHADER_OBJECTS = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 1), /// Support for Vertex Array Objects (VAOs) RSC_VAO = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 2), /// with Separate Shader Objects the gl_PerVertex interface block must be redeclared /// but some drivers misbehave and do not compile if we do so RSC_GLSL_SSO_REDECLARE = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 3), /// Supports debugging/ profiling events RSC_DEBUG = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 4), /// RS can map driver buffer storage directly instead of using a shadow buffer RSC_MAPBUFFER = OGRE_CAPS_VALUE(CAPS_CATEGORY_GL, 5), // deprecated caps, all aliasing to RSC_VERTEX_PROGRAM /// @deprecated assume present RSC_INFINITE_FAR_PLANE = RSC_VERTEX_PROGRAM, /// @deprecated assume present RSC_FRAGMENT_PROGRAM = RSC_VERTEX_PROGRAM, RSC_TESSELLATION_DOMAIN_PROGRAM = RSC_TESSELLATION_PROGRAM, RSC_TESSELLATION_HULL_PROGRAM = RSC_TESSELLATION_PROGRAM }; /// DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 /// to store the version of the current GPU driver struct _OgreExport DriverVersion { int major; int minor; int release; int build; DriverVersion() { major = minor = release = build = 0; } String toString() const; void fromString(const String& versionString); }; /** Enumeration of GPU vendors. */ enum GPUVendor { GPU_UNKNOWN = 0, GPU_NVIDIA, GPU_AMD, GPU_INTEL, GPU_IMAGINATION_TECHNOLOGIES, GPU_APPLE, //!< Apple Software Renderer GPU_NOKIA, GPU_MS_SOFTWARE, //!< Microsoft software device GPU_MS_WARP, //!< Microsoft WARP (Windows Advanced Rasterization Platform) software device - http://msdn.microsoft.com/en-us/library/dd285359.aspx GPU_ARM, //!< For the Mali chipsets GPU_QUALCOMM, GPU_MOZILLA, //!< WebGL on Mozilla/Firefox based browser GPU_WEBKIT, //!< WebGL on WebKit/Chrome base browser /// placeholder GPU_VENDOR_COUNT }; /** This class stores the capabilities of the graphics card. This information is set by the individual render systems. */ class _OgreExport RenderSystemCapabilities : public RenderSysAlloc { public: typedef std::set ShaderProfiles; private: /// This is used to build a database of RSC's /// if a RSC with same name, but newer version is introduced, the older one /// will be removed DriverVersion mDriverVersion; /// GPU Vendor GPUVendor mVendor; static String msGPUVendorStrings[GPU_VENDOR_COUNT]; static void initVendorStrings(); /// The number of texture units available ushort mNumTextureUnits; /// The stencil buffer bit depth ushort mStencilBufferBitDepth; /// Stores the capabilities flags. int mCapabilities[CAPS_CATEGORY_COUNT]; /// Which categories are relevant bool mCategoryRelevant[CAPS_CATEGORY_COUNT]; /// The name of the device as reported by the render system String mDeviceName; /// The identifier associated with the render system for which these capabilities are valid String mRenderSystemName; /// The number of floating-point 4-vector constants ushort mConstantFloatCount[GPT_COUNT]; /// The number of simultaneous render targets supported ushort mNumMultiRenderTargets; /// The maximum point size Real mMaxPointSize; /// Are non-POW2 textures feature-limited? bool mNonPOW2TexturesLimited; /// The maximum supported anisotropy Real mMaxSupportedAnisotropy; /// The number of vertex texture units supported ushort mNumVertexTextureUnits; /// The number of vertices a geometry program can emit in a single run int mGeometryProgramNumOutputVertices; /// The list of supported shader profiles ShaderProfiles mSupportedShaderProfiles; /// The number of vertex attributes available ushort mNumVertexAttributes; public: RenderSystemCapabilities (); /** Set the driver version. */ 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; } /// Parse and set vendor void parseVendorFromString(const String& vendorString) { setVendor(vendorFromString(vendorString)); } /// Convert a vendor string to an enum static GPUVendor vendorFromString(const String& vendorString); /// Convert a vendor enum to a string static const String& vendorToString(GPUVendor v); bool isDriverOlderThanVersion(const 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 setNumTextureUnits(ushort num) { mNumTextureUnits = num; } /// @deprecated do not use void setStencilBufferBitDepth(ushort num) { mStencilBufferBitDepth = num; } /// The number of simultaneous render targets supported void setNumMultiRenderTargets(ushort num) { mNumMultiRenderTargets = num; } void setNumVertexAttributes(ushort num) { mNumVertexAttributes = num; } ushort getNumVertexAttributes(void) const { return mNumVertexAttributes; } /** Returns the number of texture units the current output hardware supports. For use in rendering, this determines how many texture units the are available for multitexturing (i.e. rendering multiple textures in a single pass). Where a Material has multiple texture layers, it will try to use multitexturing where available, and where it is not available, will perform multipass rendering to achieve the same effect. This property only applies to the fixed-function pipeline, the number available to the programmable pipeline depends on the shader model in use. */ ushort getNumTextureUnits(void) const { return mNumTextureUnits; } /// @deprecated assume 8-bit stencil buffer ushort getStencilBufferBitDepth(void) const { return mStencilBufferBitDepth; } /// The number of simultaneous render targets supported ushort getNumMultiRenderTargets(void) const { return mNumMultiRenderTargets; } /** Returns true if capability is render system specific */ 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; } /** Adds a capability flag */ 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); } /** Remove a capability flag */ 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); } /** Checks for a capability */ 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; } } /** Adds the profile to the list of supported profiles */ void addShaderProfile(const String& profile); /** Remove a given shader profile, if present. */ void removeShaderProfile(const String& profile); /** Returns true if profile is in the list of supported profiles */ bool isShaderProfileSupported(const String& profile) const; /** Returns a set of all supported shader profiles * */ const ShaderProfiles& getSupportedShaderProfiles() const { return mSupportedShaderProfiles; } /// The number of floating-point 4-vector constants vertex programs support ushort getConstantFloatCount(GpuProgramType programType) const { return mConstantFloatCount[programType]; } /// sets the device name for Render system void setDeviceName(const String& name) { mDeviceName = name; } /// gets the device name for render system String getDeviceName() const { return mDeviceName; } /// The number of floating-point 4-vector constants vertex programs support void setVertexProgramConstantFloatCount(ushort c) { mConstantFloatCount[GPT_VERTEX_PROGRAM] = c; } /// The number of floating-point 4-vector constants geometry programs support void setGeometryProgramConstantFloatCount(ushort c) { mConstantFloatCount[GPT_GEOMETRY_PROGRAM] = c; } /// The number of floating-point 4-vector constants fragment programs support void setFragmentProgramConstantFloatCount(ushort c) { mConstantFloatCount[GPT_FRAGMENT_PROGRAM] = c; } /// Maximum point screen size in pixels void setMaxPointSize(Real s) { mMaxPointSize = s; } /// Maximum point screen size in pixels Real getMaxPointSize(void) const { return mMaxPointSize; } /// Non-POW2 textures limited void setNonPOW2TexturesLimited(bool l) { mNonPOW2TexturesLimited = l; } /** Are non-power of two textures limited in features? If the RSC_NON_POWER_OF_2_TEXTURES capability is set, but this method returns true, you can use non power of 2 textures only if: */ bool getNonPOW2TexturesLimited(void) const { return mNonPOW2TexturesLimited; } /// Set the maximum supported anisotropic filtering void setMaxSupportedAnisotropy(Real s) { mMaxSupportedAnisotropy = s; } /// Get the maximum supported anisotropic filtering Real getMaxSupportedAnisotropy() const { return mMaxSupportedAnisotropy; } /// Set the number of vertex texture units supported void setNumVertexTextureUnits(ushort n) { mNumVertexTextureUnits = n; } /// Get the number of vertex texture units supported ushort getNumVertexTextureUnits(void) const { return mNumVertexTextureUnits; } /// Set the number of vertices a single geometry program run can emit void setGeometryProgramNumOutputVertices(int numOutputVertices) { mGeometryProgramNumOutputVertices = numOutputVertices; } /// Get the number of vertices a single geometry program run can emit int getGeometryProgramNumOutputVertices(void) const { return mGeometryProgramNumOutputVertices; } /// Get the identifier of the rendersystem from which these capabilities were generated const String& getRenderSystemName(void) const { return mRenderSystemName; } /// Set the identifier of the rendersystem from which these capabilities were generated void setRenderSystemName(const String& rs) { mRenderSystemName = rs; } /// Mark a category as 'relevant' or not, ie will it be reported void setCategoryRelevant(CapabilitiesCategory cat, bool relevant) { mCategoryRelevant[cat] = relevant; } /// Return whether a category is 'relevant' or not, ie will it be reported bool isCategoryRelevant(CapabilitiesCategory cat) { return mCategoryRelevant[cat]; } /** Write the capabilities to the pass in Log */ void log(Log* pLog) const; /// The number of floating-point 4-vector constants compute programs support void setComputeProgramConstantFloatCount(ushort c) { mConstantFloatCount[GPT_COMPUTE_PROGRAM] = c; } /// The number of floating-point 4-vector constants tessellation Domain programs support void setTessellationDomainProgramConstantFloatCount(ushort c) { mConstantFloatCount[GPT_DOMAIN_PROGRAM] = c; } /// The number of floating-point 4-vector constants tessellation Hull programs support void setTessellationHullProgramConstantFloatCount(ushort c) { mConstantFloatCount[GPT_HULL_PROGRAM] = c; } }; inline String to_string(GPUVendor v) { return RenderSystemCapabilities::vendorToString(v); } inline String to_string(const DriverVersion& v) { return v.toString(); } /** @} */ /** @} */ } // namespace #include "OgreHeaderSuffix.h" #endif // __RenderSystemCapabilities__