OGRE  1.9
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 "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 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.
ushort mTesselationHullProgramConstantIntCount
The number of integer constants tesselation Hull programs support.
#define OGRE_CAPS_VALUE(cat, val)
Supports hardware tesselation hull programs.
Support for Separate Shader Objects.
ushort getTesselationDomainProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
float Real
Software floating point type.
#define _OgreExport
Definition: OgrePlatform.h:260
ushort getTesselationHullProgramConstantFloatCount(void) const
The number of floating-point constants fragment programs support.
void setGeometryProgramConstantBoolCount(ushort c)
The number of boolean constants geometry programs support.
Support for Frame Buffer Objects ARB implementation (regular FBO is higher precedence) ...
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
ushort getTesselationHullProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
void setVertexProgramConstantBoolCount(ushort c)
The number of boolean constants vertex programs support.
bool isDriverOlderThanVersion(DriverVersion v) const
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 setFragmentProgramConstantIntCount(ushort c)
The number of integer constants fragment programs support.
StringStream StrStreamType
Definition: OgreString.h:78
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.
void setTesselationHullProgramConstantIntCount(ushort c)
The number of integer constants tesselation 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.
void setTesselationHullProgramConstantBoolCount(ushort c)
The number of boolean constants tesselation Domain 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.
ushort mTesselationDomainProgramConstantBoolCount
The number of boolean constants tesselation Domain programs support.
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.
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.
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 mNumVertexTextureUnits
The number of vertex texture units supported.
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.
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.
ushort getTesselationDomainProgramConstantIntCount(void) const
The number of integer constants fragment programs support.
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.
ushort mTesselationHullProgramConstantBoolCount
The number of boolean constants tesselation Hull 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.
ushort mTesselationDomainProgramConstantIntCount
The number of integer constants tesselation Domain programs support.
void unsetCapability(const Capabilities c)
Remove a capability flag.
Supports compressed textures in the ATC format.
ushort getTesselationDomainProgramConstantBoolCount(void) const
The number of boolean constants fragment programs support.
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.
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.
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)
void setTesselationHullProgramConstantFloatCount(ushort c)
The number of floating-point constants tesselation Hull programs support.
ushort mStencilBufferBitDepth
The stencil buffer bit depth.
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
ushort mTesselationDomainProgramConstantFloatCount
The number of floating-point constants tesselation Domain programs support.
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.
Supports compressed textures in the DXT/ST3C formats.
Supports separate stencil updates for both front and back faces.
Supports Blending operations other than +.
ushort mTesselationHullProgramConstantFloatCount
The number of floating-point constants tesselation Hull programs support.
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 getTesselationHullProgramConstantBoolCount(void) const
The number of boolean 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 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
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.
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.
void setTesselationDomainProgramConstantBoolCount(ushort c)
The number of boolean constants tesselation Domain programs support.
Supports fixed-function DOT3 texture blend.
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.
#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.
void setTesselationDomainProgramConstantIntCount(ushort c)
The number of integer constants tesselation Domain programs support.
Supports hardware tesselation domain programs.
ShaderProfiles mSupportedShaderProfiles
The list of supported shader profiles.
void setTesselationDomainProgramConstantFloatCount(ushort c)
The number of floating-point constants tesselation Domain programs support.
Supports compressed textures in the ETC1 format.
Supports asynchronous hardware occlusion queries.
Supports compressed textures in the ETC2 format.