OgreRenderSystemCapabilities.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __RenderSystemCapabilities__
29 #define __RenderSystemCapabilities__
30 
31 // Precompiler options
32 #include "OgrePrerequisites.h"
33 #include "OgreString.h"
34 #include "OgreStringConverter.h"
35 #include "OgreStringVector.h"
36 #include "OgreResource.h"
37 #include "OgreLogManager.h"
38 #include "OgreHeaderPrefix.h"
39 
40 // Because there are more than 32 possible Capabilities, more than 1 int is needed to store them all.
41 // In fact, an array of integers is used to store capabilities. However all the capabilities are defined in the single
42 // enum. The only way to know which capabilities should be stored where in the array is to use some of the 32 bits
43 // to record the category of the capability. These top few bits are used as an index into mCapabilities array
44 // The lower bits are used to identify each capability individually by setting 1 bit for each
45 
46 // Identifies how many bits are reserved for categories
47 // NOTE: Although 4 bits (currently) are enough
48 #define CAPS_CATEGORY_SIZE 4
49 #define OGRE_CAPS_BITSHIFT (32 - CAPS_CATEGORY_SIZE)
50 #define CAPS_CATEGORY_MASK (((1 << CAPS_CATEGORY_SIZE) - 1) << OGRE_CAPS_BITSHIFT)
51 #define OGRE_CAPS_VALUE(cat, val) ((cat << OGRE_CAPS_BITSHIFT) | (1 << val))
52 
53 namespace Ogre
54 {
64  {
71  };
72 
75  // a is the category (which can be from 0 to 15)
76  // b is the value (from 0 to 27)
78  {
130 
171 
185 
186  // ***** DirectX specific caps *****
189 
190  // ***** GL Specific Caps *****
211  };
212 
216  {
217  int major;
218  int minor;
219  int release;
220  int build;
221 
223  {
224  major = minor = release = build = 0;
225  }
226 
227  String toString() const
228  {
230  str << major << "." << minor << "." << release << "." << build;
231  return str.str();
232  }
233 
234  void fromString(const String& versionString)
235  {
236  StringVector tokens = StringUtil::split(versionString, ".");
237  if(!tokens.empty())
238  {
239  major = StringConverter::parseInt(tokens[0]);
240  if (tokens.size() > 1)
241  minor = StringConverter::parseInt(tokens[1]);
242  if (tokens.size() > 2)
243  release = StringConverter::parseInt(tokens[2]);
244  if (tokens.size() > 3)
245  build = StringConverter::parseInt(tokens[3]);
246  }
247 
248  }
249  };
250 
253  {
256  GPU_AMD = 2,
258  GPU_S3 = 4,
261  GPU_SIS = 7,
263  GPU_APPLE = 9, // Apple Software Renderer
264  GPU_NOKIA = 10,
265  GPU_MS_SOFTWARE = 11, // Microsoft software device
266  GPU_MS_WARP = 12, // Microsoft WARP (Windows Advanced Rasterization Platform) software device - http://msdn.microsoft.com/en-us/library/dd285359.aspx
267  GPU_ARM = 13, // For the Mali chipsets
269 
272  };
273 
280  {
281 
282  public:
283 
285  private:
292 
294  static void initVendorStrings();
295 
305  int mCapabilities[CAPS_CATEGORY_COUNT];
307  bool mCategoryRelevant[CAPS_CATEGORY_COUNT];
312 
345 
346 
348  ShaderProfiles mSupportedShaderProfiles;
349 
350  // Support for new shader stages in shader model 5.0
369 
370 
371 
372  public:
374  virtual ~RenderSystemCapabilities ();
375 
376  virtual size_t calculateSize() const {return 0;}
377 
379  void setDriverVersion(const DriverVersion& version)
380  {
381  mDriverVersion = version;
382  }
383 
384  void parseDriverVersionFromString(const String& versionString)
385  {
386  DriverVersion version;
387  version.fromString(versionString);
388  setDriverVersion(version);
389  }
390 
391 
393  {
394  return mDriverVersion;
395  }
396 
398  {
399  return mVendor;
400  }
401 
403  {
404  mVendor = v;
405  }
406 
408  void parseVendorFromString(const String& vendorString)
409  {
410  setVendor(vendorFromString(vendorString));
411  }
412 
414  static GPUVendor vendorFromString(const String& vendorString);
416  static String vendorToString(GPUVendor v);
417 
419  {
420  if (mDriverVersion.major < v.major)
421  return true;
422  else if (mDriverVersion.major == v.major &&
423  mDriverVersion.minor < v.minor)
424  return true;
425  else if (mDriverVersion.major == v.major &&
426  mDriverVersion.minor == v.minor &&
427  mDriverVersion.release < v.release)
428  return true;
429  else if (mDriverVersion.major == v.major &&
430  mDriverVersion.minor == v.minor &&
431  mDriverVersion.release == v.release &&
432  mDriverVersion.build < v.build)
433  return true;
434  return false;
435  }
436 
438  {
439  mNumWorldMatrices = num;
440  }
441 
443  {
444  mNumTextureUnits = num;
445  }
446 
448  {
449  mStencilBufferBitDepth = num;
450  }
451 
453  {
454  mNumVertexBlendMatrices = num;
455  }
456 
459  {
460  mNumMultiRenderTargets = num;
461  }
462 
464  {
465  return mNumWorldMatrices;
466  }
467 
481  {
482  return mNumTextureUnits;
483  }
484 
492  {
493  return mStencilBufferBitDepth;
494  }
495 
499  {
500  return mNumVertexBlendMatrices;
501  }
502 
505  {
506  return mNumMultiRenderTargets;
507  }
508 
512  {
513  int cat = c >> OGRE_CAPS_BITSHIFT;
514  if(cat == CAPS_CATEGORY_GL || cat == CAPS_CATEGORY_D3D9)
515  return true;
516  return false;
517  }
518 
522  {
523  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
524  // zero out the index from the stored capability
525  mCapabilities[index] |= (c & ~CAPS_CATEGORY_MASK);
526  }
527 
531  {
532  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
533  // zero out the index from the stored capability
534  mCapabilities[index] &= (~c | CAPS_CATEGORY_MASK);
535  }
536 
539  bool hasCapability(const Capabilities c) const
540  {
541  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
542  // test against
543  if(mCapabilities[index] & (c & ~CAPS_CATEGORY_MASK))
544  {
545  return true;
546  }
547  else
548  {
549  return false;
550  }
551  }
552 
555  void addShaderProfile(const String& profile)
556  {
557  mSupportedShaderProfiles.insert(profile);
558 
559  }
560 
563  void removeShaderProfile(const String& profile)
564  {
565  mSupportedShaderProfiles.erase(profile);
566  }
567 
570  bool isShaderProfileSupported(const String& profile) const
571  {
572  return (mSupportedShaderProfiles.end() != mSupportedShaderProfiles.find(profile));
573  }
574 
575 
578  const ShaderProfiles& getSupportedShaderProfiles() const
579  {
580  return mSupportedShaderProfiles;
581  }
582 
583 
586  {
587  return mVertexProgramConstantFloatCount;
588  }
591  {
592  return mVertexProgramConstantIntCount;
593  }
596  {
597  return mVertexProgramConstantBoolCount;
598  }
601  {
602  return mGeometryProgramConstantFloatCount;
603  }
606  {
607  return mGeometryProgramConstantIntCount;
608  }
611  {
612  return mGeometryProgramConstantBoolCount;
613  }
616  {
617  return mFragmentProgramConstantFloatCount;
618  }
621  {
622  return mFragmentProgramConstantIntCount;
623  }
626  {
627  return mFragmentProgramConstantBoolCount;
628  }
629 
631  void setDeviceName(const String& name)
632  {
633  mDeviceName = name;
634  }
635 
638  {
639  return mDeviceName;
640  }
641 
644  {
645  mVertexProgramConstantFloatCount = c;
646  }
649  {
650  mVertexProgramConstantIntCount = c;
651  }
654  {
655  mVertexProgramConstantBoolCount = c;
656  }
659  {
660  mGeometryProgramConstantFloatCount = c;
661  }
664  {
665  mGeometryProgramConstantIntCount = c;
666  }
669  {
670  mGeometryProgramConstantBoolCount = c;
671  }
674  {
675  mFragmentProgramConstantFloatCount = c;
676  }
679  {
680  mFragmentProgramConstantIntCount = c;
681  }
684  {
685  mFragmentProgramConstantBoolCount = c;
686  }
689  {
690  mMaxPointSize = s;
691  }
693  Real getMaxPointSize(void) const
694  {
695  return mMaxPointSize;
696  }
699  {
700  mNonPOW2TexturesLimited = l;
701  }
710  bool getNonPOW2TexturesLimited(void) const
711  {
712  return mNonPOW2TexturesLimited;
713  }
716  {
717  mMaxSupportedAnisotropy = s;
718  }
721  {
722  return mMaxSupportedAnisotropy;
723  }
724 
727  {
728  mNumVertexTextureUnits = n;
729  }
732  {
733  return mNumVertexTextureUnits;
734  }
736  void setVertexTextureUnitsShared(bool shared)
737  {
738  mVertexTextureUnitsShared = shared;
739  }
742  {
743  return mVertexTextureUnitsShared;
744  }
745 
747  void setGeometryProgramNumOutputVertices(int numOutputVertices)
748  {
749  mGeometryProgramNumOutputVertices = numOutputVertices;
750  }
753  {
754  return mGeometryProgramNumOutputVertices;
755  }
756 
759  {
760  return mRenderSystemName;
761  }
763  void setRenderSystemName(const String& rs)
764  {
765  mRenderSystemName = rs;
766  }
767 
769  void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
770  {
771  mCategoryRelevant[cat] = relevant;
772  }
773 
776  {
777  return mCategoryRelevant[cat];
778  }
779 
780 
781 
783  void log(Log* pLog);
784 
785  // Support for new shader stages in shader model 5.0
788  {
789  mTesselationHullProgramConstantFloatCount = c;
790  }
793  {
794  mTesselationHullProgramConstantIntCount = c;
795  }
798  {
799  mTesselationHullProgramConstantBoolCount = c;
800  }
803  {
804  return mTesselationHullProgramConstantFloatCount;
805  }
808  {
809  return mTesselationHullProgramConstantIntCount;
810  }
813  {
814  return mTesselationHullProgramConstantBoolCount;
815  }
816 
819  {
820  mTesselationDomainProgramConstantFloatCount = c;
821  }
824  {
825  mTesselationDomainProgramConstantIntCount = c;
826  }
829  {
830  mTesselationDomainProgramConstantBoolCount = c;
831  }
834  {
835  return mTesselationDomainProgramConstantFloatCount;
836  }
839  {
840  return mTesselationDomainProgramConstantIntCount;
841  }
844  {
845  return mTesselationDomainProgramConstantBoolCount;
846  }
847 
850  {
851  mComputeProgramConstantFloatCount = c;
852  }
855  {
856  mComputeProgramConstantIntCount = c;
857  }
860  {
861  mComputeProgramConstantBoolCount = c;
862  }
865  {
866  return mComputeProgramConstantFloatCount;
867  }
870  {
871  return mComputeProgramConstantIntCount;
872  }
875  {
876  return mComputeProgramConstantBoolCount;
877  }
878 
879  };
880 
883 } // namespace
884 
885 
886 #include "OgreHeaderSuffix.h"
887 
888 #endif // __RenderSystemCapabilities__
889 
Support for point parameters EXT implementation.
Supports compressed textures in the ETC2 format.
void setNumVertexTextureUnits(ushort n)
Set the number of vertex texture units supported.
const ShaderProfiles & getSupportedShaderProfiles() const
Returns a set of all supported shader profiles.
void setVertexTextureUnitsShared(bool shared)
Set whether the vertex texture units are shared with the fragment processor.
ushort getGeometryProgramConstantBoolCount(void) const
The number of boolean constants geometry programs support.
ushort getComputeProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
ushort getTesselationHullProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
bool isCapabilityRenderSystemSpecific(const Capabilities c) const
Returns true if capability is render system specific.
Supports extra point parameters (minsize, maxsize, attenuation)
void setVertexProgramConstantFloatCount(ushort c)
The number of floating-point constants vertex programs support.
ushort mFragmentProgramConstantFloatCount
The number of floating-point constants fragment programs support.
Supports user clipping planes.
#define _OgreExport
Definition: OgrePlatform.h:257
bool hasCapability(const Capabilities c) const
Checks for a capability.
Supports 3d (volume) textures.
ushort mGeometryProgramConstantFloatCount
The number of floating-point constants geometry programs support.
void setComputeProgramConstantBoolCount(ushort c)
The number of boolean constants compute programs support.
ushort mVertexProgramConstantIntCount
The number of integer constants vertex programs support.
Supports rendering to vertex buffers.
Supports non-power of two textures.
ushort getStencilBufferBitDepth(void) const
Determines the bit depth of the hardware accelerated stencil buffer, if supported.
Supports fixed-function DOT3 texture blend.
ushort getTesselationDomainProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
Supports basic point sprite rendering.
#define CAPS_CATEGORY_MASK
void setNonPOW2TexturesLimited(bool l)
Non-POW2 textures limited.
void setVertexProgramConstantIntCount(ushort c)
The number of integer constants vertex programs support.
void setMaxSupportedAnisotropy(Real s)
Set the maximum supported anisotropic filtering.
ushort getComputeProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
Supports dynamic linkage/shader subroutine.
ushort getTesselationHullProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
void addShaderProfile(const String &profile)
Adds the profile to the list of supported profiles.
Support for Frame Buffer Objects ATI implementation (ARB FBO is higher precedence) ...
Supports wrapping the stencil value at the range extremeties.
bool isCategoryRelevant(CapabilitiesCategory cat)
Return whether a category is &#39;relevant&#39; or not, ie will it be reported.
String mDeviceName
The name of the device as reported by the render system.
bool isShaderProfileSupported(const String &profile) const
Returns true if profile is in the list of supported profiles.
float Real
Software floating point type.
Support for Frame Buffer Objects (FBOs)
Supports hardware tesselation hull programs.
void setGeometryProgramConstantBoolCount(ushort c)
The number of boolean constants geometry programs support.
vector< String >::type StringVector
Supports compressed textures in the PVRTC format.
Supports performing a scissor test to exclude areas of the screen.
StringStream StrStreamType
Definition: OgreString.h:78
void setVertexProgramConstantBoolCount(ushort c)
The number of boolean constants vertex programs support.
void setDeviceName(const String &name)
sets the device name for Render system
bool mVertexTextureUnitsShared
Are vertex texture units shared with fragment processor?
void setMaxPointSize(Real s)
Maximum point screen size in pixels.
bool isDriverOlderThanVersion(DriverVersion v) const
CapabilitiesCategory
Enumerates the categories of capabilities.
void setRenderSystemName(const String &rs)
Set the identifier of the rendersystem from which these capabilities were generated.
Real getMaxPointSize(void) const
Maximum point screen size in pixels.
ushort getTesselationHullProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
ushort mFragmentProgramConstantBoolCount
The number of boolean constants fragment programs support.
ushort mGeometryProgramConstantIntCount
The number of integer constants vertex geometry support.
Supports mipmap LOD biasing.
Supports generating mipmaps in hardware.
Supports hardware vertex and index buffers.
ushort getTesselationDomainProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
DriverVersion mDriverVersion
This is used to build a database of RSC&#39;s if a RSC with same name, but newer version is introduced...
ushort getGeometryProgramConstantIntCount(void) const
The number of integer constants geometry programs support.
ushort mVertexProgramConstantFloatCount
The number of floating-point constants vertex programs support.
Supports hardware stencil buffer.
#define OGRE_CAPS_BITSHIFT
Supports attaching a depth buffer to an RTT that has width & height less or equal than RTT&#39;s...
ushort mNumVertexBlendMatrices
The number of matrices available for hardware blending.
void setTesselationDomainProgramConstantIntCount(ushort c)
The number of integer constants tesselation Domain programs support.
#define OGRE_CAPS_VALUE(cat, val)
ushort getVertexProgramConstantBoolCount(void) const
The number of boolean constants vertex programs support.
Supports compressed textures in the ATC format.
ushort getComputeProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
ushort mNumWorldMatrices
The number of world matrices available.
Supports hardware geometry programs.
void setFragmentProgramConstantIntCount(ushort c)
The number of integer constants fragment programs support.
ushort mTesselationDomainProgramConstantFloatCount
The number of floating-point constants tesselation Domain programs support.
Supports fixed-function pipeline.
Supports compressed textures in the DXT/ST3C formats.
Supports anisotropic texture filtering.
void parseVendorFromString(const String &vendorString)
Parse and set vendor.
Real mMaxPointSize
The maximum point size.
void setTesselationDomainProgramConstantFloatCount(ushort c)
The number of floating-point constants tesselation Domain programs support.
Supports using the MAIN depth buffer for RTTs.
Supports compressed textures in the ETC1 format.
Support for GL 1.5 but without HW occlusion workaround.
Supports hardware tesselation domain programs.
Supports compressed textures in BC4 and BC5 format (DirectX feature level 10_0)
ushort mComputeProgramConstantBoolCount
The number of boolean constants compute programs support.
void setComputeProgramConstantIntCount(ushort c)
The number of integer constants compute programs support.
Support for Vertex Array Objects (VAOs)
ushort getFragmentProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
ushort getNumTextureUnits(void) const
Returns the number of texture units the current output hardware supports.
Supports using vertex buffers for instance data.
Supports vertex texture fetch.
void unsetCapability(const Capabilities c)
Remove a capability flag.
ushort mTesselationHullProgramConstantFloatCount
The number of floating-point constants tesselation Hull programs support.
Real getMaxSupportedAnisotropy()
Get the maximum supported anisotropic filtering.
ushort getVertexProgramConstantIntCount(void) const
The number of integer constants vertex programs support.
ushort mNumMultiRenderTargets
The number of simultaneous render targets supported.
Supports float textures and render targets.
Support for Frame Buffer Objects ARB implementation (regular FBO is higher precedence) ...
Real mMaxSupportedAnisotropy
The maximum supported anisotropy.
ShaderProfiles mSupportedShaderProfiles
The list of supported shader profiles.
Supports separate stencil updates for both front and back faces.
void removeShaderProfile(const String &profile)
Remove a given shader profile, if present.
bool getNonPOW2TexturesLimited(void) const
Are non-power of two textures limited in features?
void setGeometryProgramConstantIntCount(ushort c)
The number of integer constants geometry programs support.
ushort getNumVertexBlendMatrices(void) const
Returns the number of matrices available to hardware vertex blending for this rendering system...
_StringBase String
ushort mComputeProgramConstantFloatCount
The number of floating-point constants compute programs support.
int getGeometryProgramNumOutputVertices(void) const
Get the number of vertices a single geometry program run can emit.
Supports asynchronous hardware occlusion queries.
ushort mStencilBufferBitDepth
The stencil buffer bit depth.
ushort mNumTextureUnits
The number of texture units available.
ushort getVertexProgramConstantFloatCount(void) const
The number of floating-point constants vertex programs support.
ushort mTesselationHullProgramConstantBoolCount
The number of boolean constants tesselation Hull programs support.
ushort mNumVertexTextureUnits
The number of vertex texture units supported.
singleton class for storing the capabilities of the graphics card.
void setTesselationDomainProgramConstantBoolCount(ushort c)
The number of boolean constants tesselation Domain programs support.
void setNumMultiRenderTargets(ushort num)
The number of simultaneous render targets supported.
Supports OpenGL version 1.5.
Supports vertex programs (vertex shaders)
void setGeometryProgramNumOutputVertices(int numOutputVertices)
Set the number of vertices a single geometry program run can emit.
ushort getNumVertexTextureUnits(void) const
Get the number of vertex texture units supported.
Is DirectX feature "per stage constants" supported.
Supports compressed textures in BC6H and BC7 format (DirectX feature level 11_0)
Capabilities
Enum describing the different hardware capabilities we want to check for OGRE_CAPS_VALUE(a, b) defines each capability.
void setFragmentProgramConstantFloatCount(ushort c)
The number of floating-point constants fragment programs support.
void fromString(const String &versionString)
void setTesselationHullProgramConstantBoolCount(ushort c)
The number of boolean constants tesselation Domain programs support.
void setDriverVersion(const DriverVersion &version)
Set the driver version.
ushort mTesselationDomainProgramConstantIntCount
The number of integer constants tesselation Domain programs support.
Supports compressed textures.
Support for Separate Shader Objects.
Supports hardware compute programs.
bool getVertexTextureUnitsShared(void) const
Get whether the vertex texture units are shared with the fragment processor.
void parseDriverVersionFromString(const String &versionString)
ushort getGeometryProgramConstantFloatCount(void) const
The number of floating-point constants geometry programs support.
bool mNonPOW2TexturesLimited
Are non-POW2 textures feature-limited?
static vector< String >::type split(const String &str, const String &delims="\t\n ", unsigned int maxSplits=0, bool preserveDelims=false)
Returns a StringVector that contains all the substrings delimited by the characters in the passed del...
ushort mTesselationHullProgramConstantIntCount
The number of integer constants tesselation Hull programs support.
void setComputeProgramConstantFloatCount(ushort c)
The number of floating-point constants compute programs support.
Placeholder for max value.
static int parseInt(const String &val, int defaultValue=0)
Converts a String to a whole number.
ushort mTesselationDomainProgramConstantBoolCount
The number of boolean constants tesselation Domain programs support.
GPUVendor
Enumeration of GPU vendors.
void setGeometryProgramConstantFloatCount(ushort c)
The number of floating-point constants geometry programs support.
ushort mFragmentProgramConstantIntCount
The number of integer constants fragment programs support.
ushort getNumMultiRenderTargets(void) const
The number of simultaneous render targets supported.
Supports Alpha to Coverage (A2C)
int mGeometryProgramNumOutputVertices
The number of vertices a geometry program can emit in a single run.
ushort mGeometryProgramConstantBoolCount
The number of boolean constants vertex geometry support.
DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the cu...
Supports fragment programs (pixel shaders)
unsigned short ushort
Supports a separate depth buffer for RTTs. D3D 9 & 10, OGL w/FBO (RSC_FBO implies this flag) ...
Supports using vertex buffers for instance data.
void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
Mark a category as &#39;relevant&#39; or not, ie will it be reported.
Supports the VET_UBYTE4 vertex element type.
Supports asynchronous hardware occlusion queries.
String getDeviceName() const
gets the device name for render system
Supports hardware render-to-texture (bigger than framebuffer)
ushort getFragmentProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
Supports compressed textures in the VTC format.
ushort mComputeProgramConstantIntCount
The number of integer constants compute programs support.
Supports Blending operations other than +.
void setTesselationHullProgramConstantFloatCount(ushort c)
The number of floating-point constants tesselation Hull programs support.
void setTesselationHullProgramConstantIntCount(ushort c)
The number of integer constants tesselation Domain programs support.
Supports MRTs with different bit depths.
ushort getFragmentProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
Supports hardware occlusion queries.
String getRenderSystemName(void) const
Get the identifier of the rendersystem from which these capabilities were generated.
Supports infinite far plane projection.
ushort mVertexProgramConstantBoolCount
The number of boolean constants vertex programs support.
String mRenderSystemName
The identifier associated with the render system for which these capabilities are valid...
void setCapability(const Capabilities c)
Adds a capability flag.
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
void setFragmentProgramConstantBoolCount(ushort c)
The number of boolean constants fragment programs support.
Support for point parameters ARB implementation.
ushort getTesselationDomainProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.