OGRE  1.9.0
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-2014 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  {
132 
173 
187 
188  // ***** DirectX specific caps *****
191 
192  // ***** GL Specific Caps *****
213  };
214 
218  {
219  int major;
220  int minor;
221  int release;
222  int build;
223 
225  {
226  major = minor = release = build = 0;
227  }
228 
229  String toString() const
230  {
232  str << major << "." << minor << "." << release << "." << build;
233  return str.str();
234  }
235 
236  void fromString(const String& versionString)
237  {
238  StringVector tokens = StringUtil::split(versionString, ".");
239  if(!tokens.empty())
240  {
241  major = StringConverter::parseInt(tokens[0]);
242  if (tokens.size() > 1)
243  minor = StringConverter::parseInt(tokens[1]);
244  if (tokens.size() > 2)
245  release = StringConverter::parseInt(tokens[2]);
246  if (tokens.size() > 3)
247  build = StringConverter::parseInt(tokens[3]);
248  }
249 
250  }
251  };
252 
255  {
258  GPU_AMD = 2,
260  GPU_S3 = 4,
263  GPU_SIS = 7,
265  GPU_APPLE = 9, // Apple Software Renderer
266  GPU_NOKIA = 10,
267  GPU_MS_SOFTWARE = 11, // Microsoft software device
268  GPU_MS_WARP = 12, // Microsoft WARP (Windows Advanced Rasterization Platform) software device - http://msdn.microsoft.com/en-us/library/dd285359.aspx
269  GPU_ARM = 13, // For the Mali chipsets
271 
274  };
275 
282  {
283 
284  public:
285 
287  private:
294 
296  static void initVendorStrings();
297 
307  int mCapabilities[CAPS_CATEGORY_COUNT];
309  bool mCategoryRelevant[CAPS_CATEGORY_COUNT];
314 
347 
348 
351 
352  // Support for new shader stages in shader model 5.0
371 
372 
373 
374  public:
376  virtual ~RenderSystemCapabilities ();
377 
378  virtual size_t calculateSize() const {return 0;}
379 
381  void setDriverVersion(const DriverVersion& version)
382  {
383  mDriverVersion = version;
384  }
385 
386  void parseDriverVersionFromString(const String& versionString)
387  {
388  DriverVersion version;
389  version.fromString(versionString);
390  setDriverVersion(version);
391  }
392 
393 
395  {
396  return mDriverVersion;
397  }
398 
400  {
401  return mVendor;
402  }
403 
405  {
406  mVendor = v;
407  }
408 
410  void parseVendorFromString(const String& vendorString)
411  {
412  setVendor(vendorFromString(vendorString));
413  }
414 
416  static GPUVendor vendorFromString(const String& vendorString);
418  static String vendorToString(GPUVendor v);
419 
421  {
422  if (mDriverVersion.major < v.major)
423  return true;
424  else if (mDriverVersion.major == v.major &&
425  mDriverVersion.minor < v.minor)
426  return true;
427  else if (mDriverVersion.major == v.major &&
428  mDriverVersion.minor == v.minor &&
429  mDriverVersion.release < v.release)
430  return true;
431  else if (mDriverVersion.major == v.major &&
432  mDriverVersion.minor == v.minor &&
433  mDriverVersion.release == v.release &&
434  mDriverVersion.build < v.build)
435  return true;
436  return false;
437  }
438 
440  {
441  mNumWorldMatrices = num;
442  }
443 
445  {
446  mNumTextureUnits = num;
447  }
448 
450  {
451  mStencilBufferBitDepth = num;
452  }
453 
455  {
456  mNumVertexBlendMatrices = num;
457  }
458 
461  {
462  mNumMultiRenderTargets = num;
463  }
464 
466  {
467  return mNumWorldMatrices;
468  }
469 
483  {
484  return mNumTextureUnits;
485  }
486 
494  {
495  return mStencilBufferBitDepth;
496  }
497 
501  {
502  return mNumVertexBlendMatrices;
503  }
504 
507  {
508  return mNumMultiRenderTargets;
509  }
510 
514  {
515  int cat = c >> OGRE_CAPS_BITSHIFT;
516  if(cat == CAPS_CATEGORY_GL || cat == CAPS_CATEGORY_D3D9)
517  return true;
518  return false;
519  }
520 
524  {
525  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
526  // zero out the index from the stored capability
527  mCapabilities[index] |= (c & ~CAPS_CATEGORY_MASK);
528  }
529 
533  {
534  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
535  // zero out the index from the stored capability
536  mCapabilities[index] &= (~c | CAPS_CATEGORY_MASK);
537  }
538 
541  bool hasCapability(const Capabilities c) const
542  {
543  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
544  // test against
545  if(mCapabilities[index] & (c & ~CAPS_CATEGORY_MASK))
546  {
547  return true;
548  }
549  else
550  {
551  return false;
552  }
553  }
554 
557  void addShaderProfile(const String& profile)
558  {
559  mSupportedShaderProfiles.insert(profile);
560 
561  }
562 
565  void removeShaderProfile(const String& profile)
566  {
567  mSupportedShaderProfiles.erase(profile);
568  }
569 
572  bool isShaderProfileSupported(const String& profile) const
573  {
574  return (mSupportedShaderProfiles.end() != mSupportedShaderProfiles.find(profile));
575  }
576 
577 
581  {
582  return mSupportedShaderProfiles;
583  }
584 
585 
588  {
589  return mVertexProgramConstantFloatCount;
590  }
593  {
594  return mVertexProgramConstantIntCount;
595  }
598  {
599  return mVertexProgramConstantBoolCount;
600  }
603  {
604  return mGeometryProgramConstantFloatCount;
605  }
608  {
609  return mGeometryProgramConstantIntCount;
610  }
613  {
614  return mGeometryProgramConstantBoolCount;
615  }
618  {
619  return mFragmentProgramConstantFloatCount;
620  }
623  {
624  return mFragmentProgramConstantIntCount;
625  }
628  {
629  return mFragmentProgramConstantBoolCount;
630  }
631 
633  void setDeviceName(const String& name)
634  {
635  mDeviceName = name;
636  }
637 
640  {
641  return mDeviceName;
642  }
643 
646  {
647  mVertexProgramConstantFloatCount = c;
648  }
651  {
652  mVertexProgramConstantIntCount = c;
653  }
656  {
657  mVertexProgramConstantBoolCount = c;
658  }
661  {
662  mGeometryProgramConstantFloatCount = c;
663  }
666  {
667  mGeometryProgramConstantIntCount = c;
668  }
671  {
672  mGeometryProgramConstantBoolCount = c;
673  }
676  {
677  mFragmentProgramConstantFloatCount = c;
678  }
681  {
682  mFragmentProgramConstantIntCount = c;
683  }
686  {
687  mFragmentProgramConstantBoolCount = c;
688  }
691  {
692  mMaxPointSize = s;
693  }
695  Real getMaxPointSize(void) const
696  {
697  return mMaxPointSize;
698  }
701  {
702  mNonPOW2TexturesLimited = l;
703  }
712  bool getNonPOW2TexturesLimited(void) const
713  {
714  return mNonPOW2TexturesLimited;
715  }
718  {
719  mMaxSupportedAnisotropy = s;
720  }
723  {
724  return mMaxSupportedAnisotropy;
725  }
726 
729  {
730  mNumVertexTextureUnits = n;
731  }
734  {
735  return mNumVertexTextureUnits;
736  }
738  void setVertexTextureUnitsShared(bool shared)
739  {
740  mVertexTextureUnitsShared = shared;
741  }
744  {
745  return mVertexTextureUnitsShared;
746  }
747 
749  void setGeometryProgramNumOutputVertices(int numOutputVertices)
750  {
751  mGeometryProgramNumOutputVertices = numOutputVertices;
752  }
755  {
756  return mGeometryProgramNumOutputVertices;
757  }
758 
761  {
762  return mRenderSystemName;
763  }
765  void setRenderSystemName(const String& rs)
766  {
767  mRenderSystemName = rs;
768  }
769 
771  void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
772  {
773  mCategoryRelevant[cat] = relevant;
774  }
775 
778  {
779  return mCategoryRelevant[cat];
780  }
781 
782 
783 
785  void log(Log* pLog);
786 
787  // Support for new shader stages in shader model 5.0
790  {
791  mTesselationHullProgramConstantFloatCount = c;
792  }
795  {
796  mTesselationHullProgramConstantIntCount = c;
797  }
800  {
801  mTesselationHullProgramConstantBoolCount = c;
802  }
805  {
806  return mTesselationHullProgramConstantFloatCount;
807  }
810  {
811  return mTesselationHullProgramConstantIntCount;
812  }
815  {
816  return mTesselationHullProgramConstantBoolCount;
817  }
818 
821  {
822  mTesselationDomainProgramConstantFloatCount = c;
823  }
826  {
827  mTesselationDomainProgramConstantIntCount = c;
828  }
831  {
832  mTesselationDomainProgramConstantBoolCount = c;
833  }
836  {
837  return mTesselationDomainProgramConstantFloatCount;
838  }
841  {
842  return mTesselationDomainProgramConstantIntCount;
843  }
846  {
847  return mTesselationDomainProgramConstantBoolCount;
848  }
849 
852  {
853  mComputeProgramConstantFloatCount = c;
854  }
857  {
858  mComputeProgramConstantIntCount = c;
859  }
862  {
863  mComputeProgramConstantBoolCount = c;
864  }
867  {
868  return mComputeProgramConstantFloatCount;
869  }
872  {
873  return mComputeProgramConstantIntCount;
874  }
877  {
878  return mComputeProgramConstantBoolCount;
879  }
880 
881  };
882 
885 } // namespace
886 
887 
888 #include "OgreHeaderSuffix.h"
889 
890 #endif // __RenderSystemCapabilities__
891 
ushort getStencilBufferBitDepth(void) const
Determines the bit depth of the hardware accelerated stencil buffer, if supported.
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.
bool isCapabilityRenderSystemSpecific(const Capabilities c) const
Returns true if capability is render system specific.
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.
bool hasCapability(const Capabilities c) const
Checks for a capability.
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.
bool getVertexTextureUnitsShared(void) const
Get whether the vertex texture units are shared with the fragment processor.
Supports user clipping planes.
#define _OgreExport
Definition: OgrePlatform.h:260
Supports 3d (volume) textures.
ushort mGeometryProgramConstantFloatCount
The number of floating-point constants geometry programs support.
ushort getGeometryProgramConstantIntCount(void) const
The number of integer constants geometry programs support.
String getDeviceName() const
gets the device name for render system
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.
ushort getFragmentProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
Supports non-power of two textures.
Supports fixed-function DOT3 texture blend.
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.
Supports dynamic linkage/shader subroutine.
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)
ushort getVertexProgramConstantIntCount(void) const
The number of integer constants vertex programs support.
Supports wrapping the stencil value at the range extremeties.
bool isCategoryRelevant(CapabilitiesCategory cat)
Return whether a category is 'relevant' or not, ie will it be reported.
const ShaderProfiles & getSupportedShaderProfiles() const
Returns a set of all supported shader profiles.
Supports 32bit hardware index buffers.
String mDeviceName
The name of the device as reported by the render system.
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.
CapabilitiesCategory
Enumerates the categories of capabilities.
void setRenderSystemName(const String &rs)
Set the identifier of the rendersystem from which these capabilities were generated.
int getGeometryProgramNumOutputVertices(void) const
Get the number of vertices a single geometry program run can emit.
String getRenderSystemName(void) const
Get the identifier of the rendersystem from which these capabilities were generated.
ushort getNumTextureUnits(void) const
Returns the number of texture units the current output hardware supports.
ushort getNumVertexBlendMatrices(void) const
Returns the number of matrices available to hardware vertex blending for this rendering system.
ushort getTesselationHullProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
ushort mFragmentProgramConstantBoolCount
The number of boolean constants fragment programs support.
ushort mGeometryProgramConstantIntCount
The number of integer constants vertex geometry support.
ushort getVertexProgramConstantBoolCount(void) const
The number of boolean constants vertex programs support.
Supports mipmap LOD biasing.
Supports generating mipmaps in hardware.
Supports hardware vertex and index buffers.
DriverVersion mDriverVersion
This is used to build a database of RSC's if a RSC with same name, but newer version is introduced,...
ushort getNumVertexTextureUnits(void) const
Get the number of vertex texture units supported.
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's.
ushort mNumVertexBlendMatrices
The number of matrices available for hardware blending.
void setTesselationDomainProgramConstantIntCount(ushort c)
The number of integer constants tesselation Domain programs support.
bool getNonPOW2TexturesLimited(void) const
Are non-power of two textures limited in features?
#define OGRE_CAPS_VALUE(cat, val)
ushort getFragmentProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
Supports compressed textures in the ATC format.
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 getVertexProgramConstantFloatCount(void) const
The number of floating-point constants vertex programs support.
ushort getTesselationHullProgramConstantIntCount(void) const
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 getMaxPointSize(void) const
Maximum point screen size in pixels.
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.
ushort getComputeProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
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)
Supports using vertex buffers for instance data.
ushort getTesselationDomainProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
bool isShaderProfileSupported(const String &profile) const
Returns true if profile is in the list of supported profiles.
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 getComputeProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
ushort mNumMultiRenderTargets
The number of simultaneous render targets supported.
Supports float textures and render targets.
ushort getNumMultiRenderTargets(void) const
The number of simultaneous render targets supported.
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.
void setGeometryProgramConstantIntCount(ushort c)
The number of integer constants geometry programs support.
_StringBase String
ushort mComputeProgramConstantFloatCount
The number of floating-point constants compute programs support.
ushort getGeometryProgramConstantFloatCount(void) const
The number of floating-point constants geometry programs support.
Supports asynchronous hardware occlusion queries.
ushort mStencilBufferBitDepth
The stencil buffer bit depth.
ushort mNumTextureUnits
The number of texture units available.
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 getComputeProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
Is DirectX feature "per stage constants" supported.
Supports compressed textures in BC6H and BC7 format (DirectX feature level 11_0)
ushort getTesselationHullProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
Capabilities
Enum describing the different hardware capabilities we want to check for OGRE_CAPS_VALUE(a,...
void setFragmentProgramConstantFloatCount(ushort c)
The number of floating-point constants fragment programs support.
void fromString(const String &versionString)
ushort getTesselationDomainProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
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.
Support for Separate Shader Objects.
Supports hardware compute programs.
void parseDriverVersionFromString(const String &versionString)
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.
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.
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...
ushort getFragmentProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
Supports fragment programs (pixel shaders)
ushort getTesselationDomainProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
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 'relevant' or not, ie will it be reported.
Supports the VET_UBYTE4 vertex element type.
Supports asynchronous hardware occlusion queries.
bool isDriverOlderThanVersion(DriverVersion v) const
Supports hardware render-to-texture (bigger than framebuffer)
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.
Supports hardware occlusion queries.
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.