OGRE  2.0
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
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 "OgreStringVector.h"
34 #include "OgreStringConverter.h"
35 #include "OgreHeaderPrefix.h"
36 
37 // Because there are more than 32 possible Capabilities, more than 1 int is needed to store them all.
38 // In fact, an array of integers is used to store capabilities. However all the capabilities are defined in the single
39 // enum. The only way to know which capabilities should be stored where in the array is to use some of the 32 bits
40 // to record the category of the capability. These top few bits are used as an index into mCapabilities array
41 // The lower bits are used to identify each capability individually by setting 1 bit for each
42 
43 // Identifies how many bits are reserved for categories
44 // NOTE: Although 4 bits (currently) are enough
45 #define CAPS_CATEGORY_SIZE 4
46 #define OGRE_CAPS_BITSHIFT (32 - CAPS_CATEGORY_SIZE)
47 #define CAPS_CATEGORY_MASK (((1 << CAPS_CATEGORY_SIZE) - 1) << OGRE_CAPS_BITSHIFT)
48 #define OGRE_CAPS_VALUE(cat, val) ((cat << OGRE_CAPS_BITSHIFT) | (1 << val))
49 
50 namespace Ogre
51 {
61  {
68  };
69 
72  // a is the category (which can be from 0 to 15)
73  // b is the value (from 0 to 27)
75  {
131 
172 
190 
191  // ***** DirectX specific caps *****
194 
195  // ***** GL Specific Caps *****
216  };
217 
221  {
222  int major;
223  int minor;
224  int release;
225  int build;
226 
228  {
229  major = minor = release = build = 0;
230  }
231 
232  String toString() const
233  {
234  StringStream str;
235  str << major << "." << minor << "." << release << "." << build;
236  return str.str();
237  }
238 
239  void fromString(const String& versionString)
240  {
241  StringVector tokens = StringUtil::split(versionString, ".");
242  if(!tokens.empty())
243  {
244  major = StringConverter::parseInt(tokens[0]);
245  if (tokens.size() > 1)
246  minor = StringConverter::parseInt(tokens[1]);
247  if (tokens.size() > 2)
248  release = StringConverter::parseInt(tokens[2]);
249  if (tokens.size() > 3)
250  build = StringConverter::parseInt(tokens[3]);
251  }
252 
253  }
254  };
255 
258  {
261  GPU_AMD = 2,
263  GPU_S3 = 4,
266  GPU_SIS = 7,
268  GPU_APPLE = 9, // Apple Software Renderer
269  GPU_NOKIA = 10,
270  GPU_MS_SOFTWARE = 11, // Microsoft software device
271  GPU_MS_WARP = 12, // Microsoft WARP (Windows Advanced Rasterization Platform) software device - http://msdn.microsoft.com/en-us/library/dd285359.aspx
272  GPU_ARM = 13, // For the Mali chipsets
274 
277  };
278 
285  {
286 
287  public:
288 
290  private:
297 
299  static void initVendorStrings();
300 
310  int mCapabilities[CAPS_CATEGORY_COUNT];
312  bool mCategoryRelevant[CAPS_CATEGORY_COUNT];
317 
350 
351 
354 
355  // Support for new shader stages in shader model 5.0
374 
375 
376 
377  public:
379  virtual ~RenderSystemCapabilities ();
380 
381  virtual size_t calculateSize() const {return 0;}
382 
384  void setDriverVersion(const DriverVersion& version)
385  {
386  mDriverVersion = version;
387  }
388 
389  void parseDriverVersionFromString(const String& versionString)
390  {
391  DriverVersion version;
392  version.fromString(versionString);
393  setDriverVersion(version);
394  }
395 
396 
398  {
399  return mDriverVersion;
400  }
401 
403  {
404  return mVendor;
405  }
406 
408  {
409  mVendor = v;
410  }
411 
413  void parseVendorFromString(const String& vendorString)
414  {
415  setVendor(vendorFromString(vendorString));
416  }
417 
419  static GPUVendor vendorFromString(const String& vendorString);
421  static String vendorToString(GPUVendor v);
422 
424  {
425  if (mDriverVersion.major < v.major)
426  return true;
427  else if (mDriverVersion.major == v.major &&
428  mDriverVersion.minor < v.minor)
429  return true;
430  else if (mDriverVersion.major == v.major &&
431  mDriverVersion.minor == v.minor &&
432  mDriverVersion.release < v.release)
433  return true;
434  else if (mDriverVersion.major == v.major &&
435  mDriverVersion.minor == v.minor &&
436  mDriverVersion.release == v.release &&
437  mDriverVersion.build < v.build)
438  return true;
439  return false;
440  }
441 
443  {
444  mNumWorldMatrices = num;
445  }
446 
448  {
449  mNumTextureUnits = num;
450  }
451 
453  {
454  mStencilBufferBitDepth = num;
455  }
456 
458  {
459  mNumVertexBlendMatrices = num;
460  }
461 
464  {
465  mNumMultiRenderTargets = num;
466  }
467 
469  {
470  return mNumWorldMatrices;
471  }
472 
486  {
487  return mNumTextureUnits;
488  }
489 
497  {
498  return mStencilBufferBitDepth;
499  }
500 
504  {
505  return mNumVertexBlendMatrices;
506  }
507 
510  {
511  return mNumMultiRenderTargets;
512  }
513 
517  {
518  int cat = c >> OGRE_CAPS_BITSHIFT;
519  if(cat == CAPS_CATEGORY_GL || cat == CAPS_CATEGORY_D3D9)
520  return true;
521  return false;
522  }
523 
527  {
528  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
529  // zero out the index from the stored capability
530  mCapabilities[index] |= (c & ~CAPS_CATEGORY_MASK);
531  }
532 
536  {
537  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
538  // zero out the index from the stored capability
539  mCapabilities[index] &= (~c | CAPS_CATEGORY_MASK);
540  }
541 
544  bool hasCapability(const Capabilities c) const
545  {
546  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
547  // test against
548  if(mCapabilities[index] & (c & ~CAPS_CATEGORY_MASK))
549  {
550  return true;
551  }
552  else
553  {
554  return false;
555  }
556  }
557 
560  void addShaderProfile(const String& profile)
561  {
562  mSupportedShaderProfiles.insert(profile);
563 
564  }
565 
568  void removeShaderProfile(const String& profile)
569  {
570  mSupportedShaderProfiles.erase(profile);
571  }
572 
575  bool isShaderProfileSupported(const String& profile) const
576  {
577  return (mSupportedShaderProfiles.end() != mSupportedShaderProfiles.find(profile));
578  }
579 
580 
584  {
585  return mSupportedShaderProfiles;
586  }
587 
588 
591  {
592  return mVertexProgramConstantFloatCount;
593  }
596  {
597  return mVertexProgramConstantIntCount;
598  }
601  {
602  return mVertexProgramConstantBoolCount;
603  }
606  {
607  return mGeometryProgramConstantFloatCount;
608  }
611  {
612  return mGeometryProgramConstantIntCount;
613  }
616  {
617  return mGeometryProgramConstantBoolCount;
618  }
621  {
622  return mFragmentProgramConstantFloatCount;
623  }
626  {
627  return mFragmentProgramConstantIntCount;
628  }
631  {
632  return mFragmentProgramConstantBoolCount;
633  }
634 
636  void setDeviceName(const String& name)
637  {
638  mDeviceName = name;
639  }
640 
643  {
644  return mDeviceName;
645  }
646 
649  {
650  mVertexProgramConstantFloatCount = c;
651  }
654  {
655  mVertexProgramConstantIntCount = c;
656  }
659  {
660  mVertexProgramConstantBoolCount = c;
661  }
664  {
665  mGeometryProgramConstantFloatCount = c;
666  }
669  {
670  mGeometryProgramConstantIntCount = c;
671  }
674  {
675  mGeometryProgramConstantBoolCount = c;
676  }
679  {
680  mFragmentProgramConstantFloatCount = c;
681  }
684  {
685  mFragmentProgramConstantIntCount = c;
686  }
689  {
690  mFragmentProgramConstantBoolCount = c;
691  }
694  {
695  mMaxPointSize = s;
696  }
698  Real getMaxPointSize(void) const
699  {
700  return mMaxPointSize;
701  }
704  {
705  mNonPOW2TexturesLimited = l;
706  }
715  bool getNonPOW2TexturesLimited(void) const
716  {
717  return mNonPOW2TexturesLimited;
718  }
721  {
722  mMaxSupportedAnisotropy = s;
723  }
726  {
727  return mMaxSupportedAnisotropy;
728  }
729 
732  {
733  mNumVertexTextureUnits = n;
734  }
737  {
738  return mNumVertexTextureUnits;
739  }
741  void setVertexTextureUnitsShared(bool shared)
742  {
743  mVertexTextureUnitsShared = shared;
744  }
747  {
748  return mVertexTextureUnitsShared;
749  }
750 
752  void setGeometryProgramNumOutputVertices(int numOutputVertices)
753  {
754  mGeometryProgramNumOutputVertices = numOutputVertices;
755  }
758  {
759  return mGeometryProgramNumOutputVertices;
760  }
761 
764  {
765  return mRenderSystemName;
766  }
768  void setRenderSystemName(const String& rs)
769  {
770  mRenderSystemName = rs;
771  }
772 
774  void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
775  {
776  mCategoryRelevant[cat] = relevant;
777  }
778 
781  {
782  return mCategoryRelevant[cat];
783  }
784 
785 
786 
788  void log(Log* pLog);
789 
790  // Support for new shader stages in shader model 5.0
793  {
794  mTessellationHullProgramConstantFloatCount = c;
795  }
798  {
799  mTessellationHullProgramConstantIntCount = c;
800  }
803  {
804  mTessellationHullProgramConstantBoolCount = c;
805  }
808  {
809  return mTessellationHullProgramConstantFloatCount;
810  }
813  {
814  return mTessellationHullProgramConstantIntCount;
815  }
818  {
819  return mTessellationHullProgramConstantBoolCount;
820  }
821 
824  {
825  mTessellationDomainProgramConstantFloatCount = c;
826  }
829  {
830  mTessellationDomainProgramConstantIntCount = c;
831  }
834  {
835  mTessellationDomainProgramConstantBoolCount = c;
836  }
839  {
840  return mTessellationDomainProgramConstantFloatCount;
841  }
844  {
845  return mTessellationDomainProgramConstantIntCount;
846  }
849  {
850  return mTessellationDomainProgramConstantBoolCount;
851  }
852 
855  {
856  mComputeProgramConstantFloatCount = c;
857  }
860  {
861  mComputeProgramConstantIntCount = c;
862  }
865  {
866  mComputeProgramConstantBoolCount = c;
867  }
870  {
871  return mComputeProgramConstantFloatCount;
872  }
875  {
876  return mComputeProgramConstantIntCount;
877  }
880  {
881  return mComputeProgramConstantBoolCount;
882  }
883 
884  };
885 
888 } // namespace
889 
890 
891 #include "OgreHeaderSuffix.h"
892 
893 #endif // __RenderSystemCapabilities__
894 
ushort mGeometryProgramConstantBoolCount
The number of boolean constants vertex geometry support.
Supports compressed textures in the VTC format.
void addShaderProfile(const String &profile)
Adds the profile to the list of supported profiles.
DriverVersion mDriverVersion
This is used to build a database of RSC's if a RSC with same name, but newer version is introduced...
static int parseInt(const String &val, int defaultValue=0)
Converts a String to a whole number.
#define OGRE_CAPS_VALUE(cat, val)
ushort getTessellationHullProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
Support for Separate Shader Objects.
float Real
Software floating point type.
#define _OgreExport
Definition: OgrePlatform.h:255
void setGeometryProgramConstantBoolCount(ushort c)
The number of boolean constants geometry programs support.
Support for Frame Buffer Objects ARB implementation (regular FBO is higher precedence) ...
Supports hardware tessellation hull programs.
void setNumMultiRenderTargets(ushort num)
The number of simultaneous render targets supported.
ushort mVertexProgramConstantFloatCount
The number of floating-point constants vertex programs support.
void setVertexProgramConstantIntCount(ushort c)
The number of integer constants vertex programs support.
Supports compressed textures.
ushort getFragmentProgramConstantBoolCount(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 getVertexProgramConstantFloatCount(void) const
The number of floating-point constants vertex programs support.
String getDeviceName() const
gets the device name for render system
void setVertexProgramConstantBoolCount(ushort c)
The number of boolean constants vertex programs support.
Supports user clipping planes.
ushort mVertexProgramConstantBoolCount
The number of boolean constants vertex programs support.
Supports using the MAIN depth buffer for RTTs.
Supports performing a scissor test to exclude areas of the screen.
Real getMaxPointSize(void) const
Maximum point screen size in pixels.
ushort getStencilBufferBitDepth(void) const
Determines the bit depth of the hardware accelerated stencil buffer, if supported.
ushort getComputeProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
Support for Vertex Array Objects (VAOs)
void setVertexProgramConstantFloatCount(ushort c)
The number of floating-point constants vertex programs support.
Real mMaxSupportedAnisotropy
The maximum supported anisotropy.
void setTessellationDomainProgramConstantBoolCount(ushort c)
The number of boolean constants tessellation Domain programs support.
void setTessellationHullProgramConstantFloatCount(ushort c)
The number of floating-point constants tessellation Hull programs support.
void setFragmentProgramConstantIntCount(ushort c)
The number of integer constants fragment programs support.
bool isDriverOlderThanVersion(const DriverVersion &v) const
bool getNonPOW2TexturesLimited(void) const
Are non-power of two textures limited in features?
bool getVertexTextureUnitsShared(void) const
Get whether the vertex texture units are shared with the fragment processor.
ushort mTessellationDomainProgramConstantIntCount
The number of integer constants tessellation Domain programs support.
void removeShaderProfile(const String &profile)
Remove a given shader profile, if present.
ushort getGeometryProgramConstantIntCount(void) const
The number of integer constants geometry programs support.
Supports attaching a depth buffer to an RTT that has width & height less or equal than RTT's...
Supports the VET_UBYTE4 vertex element type.
void setGeometryProgramConstantIntCount(ushort c)
The number of integer constants geometry programs support.
Support for Frame Buffer Objects (FBOs)
void setMaxPointSize(Real s)
Maximum point screen size in pixels.
Supports rendering to vertex buffers.
Supports hardware render-to-texture (bigger than framebuffer)
ushort mFragmentProgramConstantIntCount
The number of integer constants fragment programs support.
Supports hardware stencil buffer.
String mDeviceName
The name of the device as reported by the render system.
Supports OpenGL version 1.5.
Supports MRTs with different bit depths.
_StringStreamBase StringStream
ushort getNumVertexBlendMatrices(void) const
Returns the number of matrices available to hardware vertex blending for this rendering system...
ushort getVertexProgramConstantIntCount(void) const
The number of integer constants vertex programs support.
String mRenderSystemName
The identifier associated with the render system for which these capabilities are valid...
bool isCapabilityRenderSystemSpecific(const Capabilities c) const
Returns true if capability is render system specific.
bool mNonPOW2TexturesLimited
Are non-POW2 textures feature-limited?
void setMaxSupportedAnisotropy(Real s)
Set the maximum supported anisotropic filtering.
void setRenderSystemName(const String &rs)
Set the identifier of the rendersystem from which these capabilities were generated.
void setTessellationHullProgramConstantBoolCount(ushort c)
The number of boolean constants tessellation Domain programs support.
CapabilitiesCategory
Enumerates the categories of capabilities.
Supports hardware vertex and index buffers.
Supports fixed-function pipeline.
Capabilities
Enum describing the different hardware capabilities we want to check for OGRE_CAPS_VALUE(a, b) defines each capability.
ushort mTessellationHullProgramConstantBoolCount
The number of boolean constants tessellation Hull programs support.
ushort mNumVertexTextureUnits
The number of vertex texture units supported.
Supports reading back the inactive depth-stencil buffer as texture.
Supports using vertex buffers for instance data.
Real getMaxSupportedAnisotropy()
Get the maximum supported anisotropic filtering.
Supports vertex programs (vertex shaders)
bool isCategoryRelevant(CapabilitiesCategory cat)
Return whether a category is 'relevant' or not, ie will it be reported.
ushort mFragmentProgramConstantBoolCount
The number of boolean constants fragment programs support.
Support for point parameters EXT implementation.
int getGeometryProgramNumOutputVertices(void) const
Get the number of vertices a single geometry program run can emit.
ushort mTessellationHullProgramConstantIntCount
The number of integer constants tessellation Hull programs support.
ushort getTessellationHullProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
Support for GL 1.5 but without HW occlusion workaround.
Supports hardware compute programs.
void setComputeProgramConstantFloatCount(ushort c)
The number of floating-point constants compute programs support.
Supports float textures and render targets.
DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the cu...
Supports generating mipmaps in hardware.
ushort mNumTextureUnits
The number of texture units available.
void setTessellationHullProgramConstantIntCount(ushort c)
The number of integer constants tessellation Domain programs support.
void setFragmentProgramConstantBoolCount(ushort c)
The number of boolean constants fragment programs support.
void setGeometryProgramConstantFloatCount(ushort c)
The number of floating-point constants geometry programs support.
void unsetCapability(const Capabilities c)
Remove a capability flag.
Supports compressed textures in the ATC format.
ushort mComputeProgramConstantBoolCount
The number of boolean constants compute programs support.
Supports compressed textures in BC6H and BC7 format (DirectX feature level 11_0)
ushort getVertexProgramConstantBoolCount(void) const
The number of boolean constants vertex programs support.
Supports hardware tessellation domain programs.
void setCategoryRelevant(CapabilitiesCategory cat, bool relevant)
Mark a category as 'relevant' or not, ie will it be reported.
void parseVendorFromString(const String &vendorString)
Parse and set vendor.
Supports fragment programs (pixel shaders)
void parseDriverVersionFromString(const String &versionString)
void setNumVertexTextureUnits(ushort n)
Set the number of vertex texture units supported.
ushort mNumVertexBlendMatrices
The number of matrices available for hardware blending.
ushort mTessellationDomainProgramConstantFloatCount
The number of floating-point constants tessellation Domain programs support.
bool isShaderProfileSupported(const String &profile) const
Returns true if profile is in the list of supported profiles.
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Supports extra point parameters (minsize, maxsize, attenuation)
int mGeometryProgramNumOutputVertices
The number of vertices a geometry program can emit in a single run.
Supports compressed textures in BC4 and BC5 format (DirectX feature level 10_0)
ushort mStencilBufferBitDepth
The stencil buffer bit depth.
Explicit FSAA resolves (i.e. sample MSAA textures directly in the shader without resolving) ...
ushort mComputeProgramConstantFloatCount
The number of floating-point constants compute programs support.
ushort mNumMultiRenderTargets
The number of simultaneous render targets supported.
ushort mGeometryProgramConstantIntCount
The number of integer constants vertex geometry support.
vector< String >::type StringVector
GPUVendor
Enumeration of GPU vendors.
Supports wrapping the stencil value at the range extremeties.
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...
void setCapability(const Capabilities c)
Adds a capability flag.
ushort mTessellationDomainProgramConstantBoolCount
The number of boolean constants tessellation Domain programs support.
Supports compressed textures in the DXT/ST3C formats.
Supports separate stencil updates for both front and back faces.
ushort getTessellationDomainProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
Supports Blending operations other than +.
Support for point parameters ARB implementation.
void setComputeProgramConstantIntCount(ushort c)
The number of integer constants compute programs support.
unsigned short ushort
Supports infinite far plane projection.
void setComputeProgramConstantBoolCount(ushort c)
The number of boolean constants compute programs support.
Supports using vertex buffers for instance data.
Supports non-power of two textures.
ushort getFragmentProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
ushort mNumWorldMatrices
The number of world matrices available.
bool mVertexTextureUnitsShared
Are vertex texture units shared with fragment processor?
Supports anisotropic texture filtering.
ushort getTessellationDomainProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
Supports hardware occlusion queries.
ushort getComputeProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
Supports dynamic linkage/shader subroutine.
void setNonPOW2TexturesLimited(bool l)
Non-POW2 textures limited.
void setFragmentProgramConstantFloatCount(ushort c)
The number of floating-point constants fragment programs support.
Supports different texture bindings.
Supports 32bit hardware index buffers.
const ShaderProfiles & getSupportedShaderProfiles() const
Returns a set of all supported shader profiles.
Supports mipmap LOD biasing.
Supports hardware geometry programs.
Is DirectX feature "per stage constants" supported.
Supports 3d (volume) textures.
Supports Alpha to Coverage (A2C)
void setDeviceName(const String &name)
sets the device name for Render system
void setGeometryProgramNumOutputVertices(int numOutputVertices)
Set the number of vertices a single geometry program run can emit.
singleton class for storing the capabilities of the graphics card.
void setDriverVersion(const DriverVersion &version)
Set the driver version.
Real mMaxPointSize
The maximum point size.
ushort getGeometryProgramConstantBoolCount(void) const
The number of boolean constants geometry programs support.
_StringBase String
Definition: OgreCommon.h:53
String getRenderSystemName(void) const
Get the identifier of the rendersystem from which these capabilities were generated.
Support for Frame Buffer Objects ATI implementation (ARB FBO is higher precedence) ...
Supports asynchronous hardware occlusion queries.
ushort getTessellationHullProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
Supports a separate depth buffer for RTTs. D3D 9 & 10, OGL w/FBO (RSC_FBO implies this flag) ...
void setVertexTextureUnitsShared(bool shared)
Set whether the vertex texture units are shared with the fragment processor.
ushort getGeometryProgramConstantFloatCount(void) const
The number of floating-point constants geometry programs support.
Supports fixed-function DOT3 texture blend.
void setTessellationDomainProgramConstantFloatCount(ushort c)
The number of floating-point constants tessellation Domain programs support.
bool hasCapability(const Capabilities c) const
Checks for a capability.
ushort getFragmentProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
void fromString(const String &versionString)
Supports basic point sprite rendering.
ushort getNumMultiRenderTargets(void) const
The number of simultaneous render targets supported.
Supports vertex texture fetch.
ushort mTessellationHullProgramConstantFloatCount
The number of floating-point constants tessellation Hull programs support.
#define CAPS_CATEGORY_MASK
ushort getNumVertexTextureUnits(void) const
Get the number of vertex texture units supported.
ushort mFragmentProgramConstantFloatCount
The number of floating-point constants fragment programs support.
ushort getComputeProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
ushort mComputeProgramConstantIntCount
The number of integer constants compute programs support.
#define OGRE_CAPS_BITSHIFT
ushort mGeometryProgramConstantFloatCount
The number of floating-point constants geometry programs support.
ushort mVertexProgramConstantIntCount
The number of integer constants vertex programs support.
Supports compressed textures in the PVRTC format.
Placeholder for max value.
ShaderProfiles mSupportedShaderProfiles
The list of supported shader profiles.
Supports compressed textures in the ETC1 format.
Supports asynchronous hardware occlusion queries.
ushort getTessellationDomainProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
void setTessellationDomainProgramConstantIntCount(ushort c)
The number of integer constants tessellation Domain programs support.
Supports compressed textures in the ETC2 format.