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 
271  GPU_VENDOR_COUNT = 15
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 
349 
350  // Support for new shader stages in shader model 5.0
369 
370 
371 
372  public:
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);
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 
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 
#define _OgreExport
Definition: OgrePlatform.h:257
#define OGRE_CAPS_BITSHIFT
#define CAPS_CATEGORY_MASK
#define OGRE_CAPS_VALUE(cat, val)
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
singleton class for storing the capabilities of the graphics card.
void setFragmentProgramConstantBoolCount(ushort c)
The number of boolean constants fragment programs support.
bool getVertexTextureUnitsShared(void) const
Get whether the vertex texture units are shared with the fragment processor.
int mGeometryProgramNumOutputVertices
The number of vertices a geometry program can emit in a single run.
ushort getFragmentProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
ushort getFragmentProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
const ShaderProfiles & getSupportedShaderProfiles() const
Returns a set of all supported shader profiles.
ushort getGeometryProgramConstantFloatCount(void) const
The number of floating-point constants geometry programs support.
void setMaxPointSize(Real s)
Maximum point screen size in pixels.
String getRenderSystemName(void) const
Get the identifier of the rendersystem from which these capabilities were generated.
Real mMaxPointSize
The maximum point size.
void setVertexProgramConstantFloatCount(ushort c)
The number of floating-point constants vertex programs support.
void setTesselationDomainProgramConstantIntCount(ushort c)
The number of integer constants tesselation Domain programs support.
bool isShaderProfileSupported(const String &profile) const
Returns true if profile is in the list of supported profiles.
void setGeometryProgramConstantFloatCount(ushort c)
The number of floating-point constants geometry programs support.
bool getNonPOW2TexturesLimited(void) const
Are non-power of two textures limited in features?
ushort mVertexProgramConstantBoolCount
The number of boolean constants vertex programs support.
ushort mFragmentProgramConstantBoolCount
The number of boolean constants fragment programs support.
ushort mComputeProgramConstantFloatCount
The number of floating-point constants compute programs support.
void setRenderSystemName(const String &rs)
Set the identifier of the rendersystem from which these capabilities were generated.
ushort getGeometryProgramConstantIntCount(void) const
The number of integer constants geometry programs support.
void setMaxSupportedAnisotropy(Real s)
Set the maximum supported anisotropic filtering.
ushort mFragmentProgramConstantFloatCount
The number of floating-point constants fragment programs support.
bool isCategoryRelevant(CapabilitiesCategory cat)
Return whether a category is 'relevant' or not, ie will it be reported.
ushort mGeometryProgramConstantFloatCount
The number of floating-point constants geometry programs support.
void parseVendorFromString(const String &vendorString)
Parse and set vendor.
void setComputeProgramConstantIntCount(ushort c)
The number of integer constants compute programs support.
void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
Mark a category as 'relevant' or not, ie will it be reported.
Real getMaxPointSize(void) const
Maximum point screen size in pixels.
static GPUVendor vendorFromString(const String &vendorString)
Convert a vendor string to an enum.
void setGeometryProgramConstantIntCount(ushort c)
The number of integer constants geometry programs support.
bool mVertexTextureUnitsShared
Are vertex texture units shared with fragment processor?
ushort mNumTextureUnits
The number of texture units available.
bool mNonPOW2TexturesLimited
Are non-POW2 textures feature-limited?
ushort mStencilBufferBitDepth
The stencil buffer bit depth.
void setGeometryProgramNumOutputVertices(int numOutputVertices)
Set the number of vertices a single geometry program run can emit.
ShaderProfiles mSupportedShaderProfiles
The list of supported shader profiles.
ushort mTesselationDomainProgramConstantFloatCount
The number of floating-point constants tesselation Domain programs support.
ushort getTesselationHullProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
bool isCapabilityRenderSystemSpecific(const Capabilities c) const
Returns true if capability is render system specific.
ushort mTesselationHullProgramConstantBoolCount
The number of boolean constants tesselation Hull programs support.
ushort getTesselationHullProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
void setVertexProgramConstantBoolCount(ushort c)
The number of boolean constants vertex programs support.
ushort mTesselationDomainProgramConstantIntCount
The number of integer constants tesselation Domain programs support.
ushort getNumMultiRenderTargets(void) const
The number of simultaneous render targets supported.
ushort mNumWorldMatrices
The number of world matrices available.
void setDriverVersion(const DriverVersion &version)
Set the driver version.
String mRenderSystemName
The identifier associated with the render system for which these capabilities are valid.
static String vendorToString(GPUVendor v)
Convert a vendor enum to a string.
ushort getNumVertexTextureUnits(void) const
Get the number of vertex texture units supported.
void setVertexTextureUnitsShared(bool shared)
Set whether the vertex texture units are shared with the fragment processor.
DriverVersion mDriverVersion
This is used to build a database of RSC's if a RSC with same name, but newer version is introduced,...
Real mMaxSupportedAnisotropy
The maximum supported anisotropy.
ushort getTesselationDomainProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
ushort getVertexProgramConstantBoolCount(void) const
The number of boolean constants vertex programs support.
void setTesselationDomainProgramConstantFloatCount(ushort c)
The number of floating-point constants tesselation Domain programs support.
ushort getComputeProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
ushort mGeometryProgramConstantIntCount
The number of integer constants vertex geometry support.
void removeShaderProfile(const String &profile)
Remove a given shader profile, if present.
String getDeviceName() const
gets the device name for render system
Real getMaxSupportedAnisotropy()
Get the maximum supported anisotropic filtering.
ushort getComputeProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
ushort getNumTextureUnits(void) const
Returns the number of texture units the current output hardware supports.
ushort mGeometryProgramConstantBoolCount
The number of boolean constants vertex geometry support.
ushort mComputeProgramConstantBoolCount
The number of boolean constants compute programs support.
ushort mFragmentProgramConstantIntCount
The number of integer constants fragment programs support.
void setNonPOW2TexturesLimited(bool l)
Non-POW2 textures limited.
ushort getFragmentProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
void parseDriverVersionFromString(const String &versionString)
void setComputeProgramConstantFloatCount(ushort c)
The number of floating-point constants compute programs support.
ushort getGeometryProgramConstantBoolCount(void) const
The number of boolean constants geometry programs support.
ushort mNumMultiRenderTargets
The number of simultaneous render targets supported.
void setTesselationDomainProgramConstantBoolCount(ushort c)
The number of boolean constants tesselation Domain programs support.
ushort mVertexProgramConstantIntCount
The number of integer constants vertex programs support.
ushort getTesselationDomainProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
ushort mNumVertexBlendMatrices
The number of matrices available for hardware blending.
ushort getTesselationHullProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
void setFragmentProgramConstantIntCount(ushort c)
The number of integer constants fragment programs support.
ushort mTesselationHullProgramConstantFloatCount
The number of floating-point constants tesselation Hull programs support.
ushort mTesselationDomainProgramConstantBoolCount
The number of boolean constants tesselation Domain programs support.
ushort mVertexProgramConstantFloatCount
The number of floating-point constants vertex programs support.
void setNumVertexTextureUnits(ushort n)
Set the number of vertex texture units supported.
ushort getVertexProgramConstantIntCount(void) const
The number of integer constants vertex programs support.
void setTesselationHullProgramConstantBoolCount(ushort c)
The number of boolean constants tesselation Domain programs support.
ushort mComputeProgramConstantIntCount
The number of integer constants compute programs support.
void setVertexProgramConstantIntCount(ushort c)
The number of integer constants vertex programs support.
void setTesselationHullProgramConstantIntCount(ushort c)
The number of integer constants tesselation Domain programs support.
void unsetCapability(const Capabilities c)
Remove a capability flag.
bool isDriverOlderThanVersion(DriverVersion v) const
void setComputeProgramConstantBoolCount(ushort c)
The number of boolean constants compute programs support.
ushort getTesselationDomainProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
bool hasCapability(const Capabilities c) const
Checks for a capability.
ushort getNumVertexBlendMatrices(void) const
Returns the number of matrices available to hardware vertex blending for this rendering system.
ushort getComputeProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
ushort mNumVertexTextureUnits
The number of vertex texture units supported.
void setFragmentProgramConstantFloatCount(ushort c)
The number of floating-point constants fragment programs support.
ushort mTesselationHullProgramConstantIntCount
The number of integer constants tesselation Hull programs support.
int getGeometryProgramNumOutputVertices(void) const
Get the number of vertices a single geometry program run can emit.
void setTesselationHullProgramConstantFloatCount(ushort c)
The number of floating-point constants tesselation Hull programs support.
void setCapability(const Capabilities c)
Adds a capability flag.
void setNumMultiRenderTargets(ushort num)
The number of simultaneous render targets supported.
ushort getVertexProgramConstantFloatCount(void) const
The number of floating-point constants vertex programs support.
ushort getStencilBufferBitDepth(void) const
Determines the bit depth of the hardware accelerated stencil buffer, if supported.
void log(Log *pLog)
Write the capabilities to the pass in Log.
void setGeometryProgramConstantBoolCount(ushort c)
The number of boolean constants geometry programs support.
void setDeviceName(const String &name)
sets the device name for Render system
void addShaderProfile(const String &profile)
Adds the profile to the list of supported profiles.
String mDeviceName
The name of the device as reported by the render system.
static int parseInt(const String &val, int defaultValue=0)
Converts a String to a whole number.
StringStream StrStreamType
Definition: OgreString.h:78
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...
vector< String >::type StringVector
Capabilities
Enum describing the different hardware capabilities we want to check for OGRE_CAPS_VALUE(a,...
CapabilitiesCategory
Enumerates the categories of capabilities.
GPUVendor
Enumeration of GPU vendors.
@ RSC_VERTEX_PROGRAM
Supports vertex programs (vertex shaders)
@ RSC_TWO_SIDED_STENCIL
Supports separate stencil updates for both front and back faces.
@ RSC_SCISSOR_TEST
Supports performing a scissor test to exclude areas of the screen.
@ RSC_TEXTURE_COMPRESSION_PVRTC
Supports compressed textures in the PVRTC format.
@ RSC_MIPMAP_LOD_BIAS
Supports mipmap LOD biasing.
@ RSC_CAN_GET_COMPILED_SHADER_BUFFER
Supports using vertex buffers for instance data.
@ RSC_STENCIL_WRAP
Supports wrapping the stencil value at the range extremeties.
@ RSC_FRAGMENT_PROGRAM
Supports fragment programs (pixel shaders)
@ RSC_MRT_DIFFERENT_BIT_DEPTHS
Supports MRTs with different bit depths.
@ RSC_POINT_EXTENDED_PARAMETERS_ARB
Support for point parameters ARB implementation.
@ RSC_TEXTURE_COMPRESSION_ETC2
Supports compressed textures in the ETC2 format.
@ RSC_TEXTURE_COMPRESSION_ETC1
Supports compressed textures in the ETC1 format.
@ RSC_VAO
Support for Vertex Array Objects (VAOs)
@ RSC_VBO
Supports hardware vertex and index buffers.
@ RSC_VERTEX_FORMAT_UBYTE4
Supports the VET_UBYTE4 vertex element type.
@ RSC_TEXTURE_FLOAT
Supports float textures and render targets.
@ RSC_ADVANCED_BLEND_OPERATIONS
Supports Blending operations other than +.
@ RSC_AUTOMIPMAP
Supports generating mipmaps in hardware.
@ RSC_TESSELATION_HULL_PROGRAM
Supports hardware tesselation hull programs.
@ RSC_ANISOTROPY
Supports anisotropic texture filtering.
@ RSC_PERSTAGECONSTANT
Is DirectX feature "per stage constants" supported.
@ RSC_TEXTURE_COMPRESSION_BC6H_BC7
Supports compressed textures in BC6H and BC7 format (DirectX feature level 11_0)
@ RSC_FIXED_FUNCTION
Supports fixed-function pipeline.
@ RSC_FBO_ATI
Support for Frame Buffer Objects ATI implementation (ARB FBO is higher precedence)
@ RSC_PBUFFER
Support for PBuffer.
@ RSC_TEXTURE_COMPRESSION
Supports compressed textures.
@ RSC_RTT_DEPTHBUFFER_RESOLUTION_LESSEQUAL
Supports attaching a depth buffer to an RTT that has width & height less or equal than RTT's.
@ RSC_SEPARATE_SHADER_OBJECTS
Support for Separate Shader Objects.
@ RSC_HWRENDER_TO_TEXTURE
Supports hardware render-to-texture (bigger than framebuffer)
@ RSC_HWOCCLUSION
Supports hardware occlusion queries.
@ RSC_USER_CLIP_PLANES
Supports user clipping planes.
@ RSC_RTT_MAIN_DEPTHBUFFER_ATTACHABLE
Supports using the MAIN depth buffer for RTTs.
@ RSC_POINT_SPRITES
Supports basic point sprite rendering.
@ RSC_ATOMIC_COUNTERS
Supports asynchronous hardware occlusion queries.
@ RSC_INFINITE_FAR_PLANE
Supports infinite far plane projection.
@ RSC_TEXTURE_COMPRESSION_ATC
Supports compressed textures in the ATC format.
@ RSC_FBO
Support for Frame Buffer Objects (FBOs)
@ RSC_FBO_ARB
Support for Frame Buffer Objects ARB implementation (regular FBO is higher precedence)
@ RSC_TEXTURE_COMPRESSION_DXT
Supports compressed textures in the DXT/ST3C formats.
@ RSC_RTT_SEPARATE_DEPTHBUFFER
Supports a separate depth buffer for RTTs. D3D 9 & 10, OGL w/FBO (RSC_FBO implies this flag)
@ RSC_HWSTENCIL
Supports hardware stencil buffer.
@ RSC_VERTEX_TEXTURE_FETCH
Supports vertex texture fetch.
@ RSC_CUBEMAPPING
Supports cube mapping.
@ RSC_HWOCCLUSION_ASYNCHRONOUS
Supports asynchronous hardware occlusion queries.
@ RSC_VERTEX_BUFFER_INSTANCE_DATA
Supports using vertex buffers for instance data.
@ RSC_DOT3
Supports fixed-function DOT3 texture blend.
@ RSC_ALPHA_TO_COVERAGE
Supports Alpha to Coverage (A2C)
@ RSC_SHADER_SUBROUTINE
Supports dynamic linkage/shader subroutine.
@ RSC_HWRENDER_TO_VERTEX_BUFFER
Supports rendering to vertex buffers.
@ RSC_TEXTURE_COMPRESSION_VTC
Supports compressed textures in the VTC format.
@ RSC_NON_POWER_OF_2_TEXTURES
Supports non-power of two textures.
@ RSC_POINT_EXTENDED_PARAMETERS_EXT
Support for point parameters EXT implementation.
@ RSC_TEXTURE_COMPRESSION_BC4_BC5
Supports compressed textures in BC4 and BC5 format (DirectX feature level 10_0)
@ RSC_TESSELATION_DOMAIN_PROGRAM
Supports hardware tesselation domain programs.
@ RSC_GEOMETRY_PROGRAM
Supports hardware geometry programs.
@ RSC_GL1_5_NOHWOCCLUSION
Support for GL 1.5 but without HW occlusion workaround.
@ RSC_TEXTURE_1D
Supports 1d textures.
@ RSC_TEXTURE_3D
Supports 3d (volume) textures.
@ RSC_GL1_5_NOVBO
Supports OpenGL version 1.5.
@ RSC_POINT_EXTENDED_PARAMETERS
Supports extra point parameters (minsize, maxsize, attenuation)
@ RSC_COMPUTE_PROGRAM
Supports hardware compute programs.
@ CAPS_CATEGORY_COUNT
Placeholder for max value.
@ GPU_VENDOR_COUNT
placeholder
float Real
Software floating point type.
_StringBase String
unsigned short ushort
DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the cu...
void fromString(const String &versionString)

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