OgreRenderSystemCapabilities.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __RenderSystemCapabilities__
29 #define __RenderSystemCapabilities__
30 
31 // Precompiler options
32 #include "OgrePrerequisites.h"
33 #include "OgreString.h"
34 #include "OgreStringConverter.h"
35 #include "OgreStringVector.h"
36 #include "OgreResource.h"
37 #include "OgreLogManager.h"
38 #include "OgreHeaderPrefix.h"
39 
40 // Because there are more than 32 possible Capabilities, more than 1 int is needed to store them all.
41 // In fact, an array of integers is used to store capabilities. However all the capabilities are defined in the single
42 // enum. The only way to know which capabilities should be stored where in the array is to use some of the 32 bits
43 // to record the category of the capability. These top few bits are used as an index into mCapabilities array
44 // The lower bits are used to identify each capability individually by setting 1 bit for each
45 
46 // Identifies how many bits are reserved for categories
47 // NOTE: Although 4 bits (currently) are enough
48 #define CAPS_CATEGORY_SIZE 4
49 #define OGRE_CAPS_BITSHIFT (32 - CAPS_CATEGORY_SIZE)
50 #define CAPS_CATEGORY_MASK (((1 << CAPS_CATEGORY_SIZE) - 1) << OGRE_CAPS_BITSHIFT)
51 #define OGRE_CAPS_VALUE(cat, val) ((cat << OGRE_CAPS_BITSHIFT) | (1 << val))
52 
53 namespace Ogre
54 {
64  {
71  };
72 
75  // a is the category (which can be from 0 to 15)
76  // b is the value (from 0 to 27)
78  {
130 
171 
185 
186  // ***** DirectX specific caps *****
189 
190  // ***** GL Specific Caps *****
211  };
212 
216  {
217  int major;
218  int minor;
219  int release;
220  int build;
221 
223  {
224  major = minor = release = build = 0;
225  }
226 
227  String toString() const
228  {
230  str << major << "." << minor << "." << release << "." << build;
231  return str.str();
232  }
233 
234  void fromString(const String& versionString)
235  {
236  StringVector tokens = StringUtil::split(versionString, ".");
237  if(!tokens.empty())
238  {
239  major = StringConverter::parseInt(tokens[0]);
240  if (tokens.size() > 1)
241  minor = StringConverter::parseInt(tokens[1]);
242  if (tokens.size() > 2)
243  release = StringConverter::parseInt(tokens[2]);
244  if (tokens.size() > 3)
245  build = StringConverter::parseInt(tokens[3]);
246  }
247 
248  }
249  };
250 
253  {
256  GPU_AMD = 2,
258  GPU_S3 = 4,
261  GPU_SIS = 7,
263  GPU_APPLE = 9, // Apple Software Renderer
264  GPU_NOKIA = 10,
265  GPU_MS_SOFTWARE = 11, // Microsoft software device
266  GPU_MS_WARP = 12, // Microsoft WARP (Windows Advanced Rasterization Platform) software device - http://msdn.microsoft.com/en-us/library/dd285359.aspx
267  GPU_ARM = 13, // For the Mali chipsets
269 
272  };
273 
280  {
281 
282  public:
283 
285  private:
292 
294  static void initVendorStrings();
295 
305  int mCapabilities[CAPS_CATEGORY_COUNT];
307  bool mCategoryRelevant[CAPS_CATEGORY_COUNT];
312 
345 
346 
349 
350  // Support for new shader stages in shader model 5.0
369 
370 
371 
372  public:
374  virtual ~RenderSystemCapabilities ();
375 
376  virtual size_t calculateSize() const {return 0;}
377 
379  void setDriverVersion(const DriverVersion& version)
380  {
381  mDriverVersion = version;
382  }
383 
384  void parseDriverVersionFromString(const String& versionString)
385  {
386  DriverVersion version;
387  version.fromString(versionString);
388  setDriverVersion(version);
389  }
390 
391 
393  {
394  return mDriverVersion;
395  }
396 
398  {
399  return mVendor;
400  }
401 
403  {
404  mVendor = v;
405  }
406 
408  void parseVendorFromString(const String& vendorString)
409  {
410  setVendor(vendorFromString(vendorString));
411  }
412 
414  static GPUVendor vendorFromString(const String& vendorString);
416  static String vendorToString(GPUVendor v);
417 
419  {
420  if (mDriverVersion.major < v.major)
421  return true;
422  else if (mDriverVersion.major == v.major &&
423  mDriverVersion.minor < v.minor)
424  return true;
425  else if (mDriverVersion.major == v.major &&
426  mDriverVersion.minor == v.minor &&
427  mDriverVersion.release < v.release)
428  return true;
429  else if (mDriverVersion.major == v.major &&
430  mDriverVersion.minor == v.minor &&
431  mDriverVersion.release == v.release &&
432  mDriverVersion.build < v.build)
433  return true;
434  return false;
435  }
436 
438  {
439  mNumWorldMatrices = num;
440  }
441 
443  {
444  mNumTextureUnits = num;
445  }
446 
448  {
449  mStencilBufferBitDepth = num;
450  }
451 
453  {
454  mNumVertexBlendMatrices = num;
455  }
456 
459  {
460  mNumMultiRenderTargets = num;
461  }
462 
464  {
465  return mNumWorldMatrices;
466  }
467 
481  {
482  return mNumTextureUnits;
483  }
484 
492  {
493  return mStencilBufferBitDepth;
494  }
495 
499  {
500  return mNumVertexBlendMatrices;
501  }
502 
505  {
506  return mNumMultiRenderTargets;
507  }
508 
512  {
513  int cat = c >> OGRE_CAPS_BITSHIFT;
514  if(cat == CAPS_CATEGORY_GL || cat == CAPS_CATEGORY_D3D9)
515  return true;
516  return false;
517  }
518 
522  {
523  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
524  // zero out the index from the stored capability
525  mCapabilities[index] |= (c & ~CAPS_CATEGORY_MASK);
526  }
527 
531  {
532  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
533  // zero out the index from the stored capability
534  mCapabilities[index] &= (~c | CAPS_CATEGORY_MASK);
535  }
536 
539  bool hasCapability(const Capabilities c) const
540  {
541  int index = (CAPS_CATEGORY_MASK & c) >> OGRE_CAPS_BITSHIFT;
542  // test against
543  if(mCapabilities[index] & (c & ~CAPS_CATEGORY_MASK))
544  {
545  return true;
546  }
547  else
548  {
549  return false;
550  }
551  }
552 
555  void addShaderProfile(const String& profile)
556  {
557  mSupportedShaderProfiles.insert(profile);
558 
559  }
560 
563  void removeShaderProfile(const String& profile)
564  {
565  mSupportedShaderProfiles.erase(profile);
566  }
567 
570  bool isShaderProfileSupported(const String& profile) const
571  {
572  return (mSupportedShaderProfiles.end() != mSupportedShaderProfiles.find(profile));
573  }
574 
575 
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 

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Wed Oct 23 2013 06:57:25