ICapabilities.h

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
namespace Cogs
{
  struct Vendors
  {
    enum EVendors
    {
      Unknown,
      AMD,
      nVidia,
      Intel,
      Apple,
    };
  };
 
  struct Series
  {
    enum ESeries
    {
      Unknown,
      // AMD
      RadeonX,
      RadeonHD,
      FireGL,
      // nVidia,
      geForce,
      Quadro,
      QuadroFX,
      HD,
      Iris,
      IrisPro
    };
  };
 
  static int UnknownModel = -1;
 
  struct GraphicsDeviceCapabilities
  {
    static constexpr size_t unknownAmount = ~static_cast<size_t>(0);
 
    int featureLevelMajor = -1;
    int featureLevelMinor = -1;
 
    int MaxTextureSlots = 0;
    int MaxVertexInputElements = 32;
    unsigned MaxSamples = 8;
    unsigned MaxMultiViews = 0;
    float MaxAnisotropy = 1.f;
    unsigned ConstantBufferOffsetAlignment = 256; 
 
    uint32_t MaxTexture2DSize = 16384;      
    uint32_t MaxTexture3DSize = 2048;       
    uint32_t MaxTextureCubeSize = 16384;    
    uint32_t MaxTextureArrayLayers = 2048;  
 
    bool RenderPass = false;
    bool SyncObjects = false;               
    bool GeometryShaders = false;
    bool TessellationShaders = false;
    bool ComputeShaders = false;
    bool ConstantBufferRange = false;   
    bool IndependentSamplerState = true;  
    bool SupportsHlsl = true;
    bool Instancing = true;             
    bool StartInstance = true;          
    bool UnsignedIntIndexes = true;
    bool FloatTextures = true;
    bool TextureCompressionS3TC = false;
    bool TextureCompressionRGTC = false;
    bool TextureCompressionBPTC = false;
    bool TextureCompressionETC = false;
    bool TextureCompressionPVRTC = false;
    bool TextureCompressionASTC = false;
    bool FragDepth = true;              
    bool VertexAndIndexDataInSharedBuffers = true;
    bool SupportsMultipleThreads = true;
    bool TextureCubeArrays = true;      
    bool VertexArrayObjects = false;    
    bool MultiView = false;
    bool MultiSampleMultiView = false;
    bool OriginOnTop = true;                
    bool DepthNegativeOneToOne = false; 
 
    bool DefaultColorTargetHasLinearEncoding = true;
 
    size_t DedicatedVideoMemory = unknownAmount;
    size_t DedicatedSystemMemory = unknownAmount;
    size_t SharedSystemMemory = unknownAmount;
 
    bool CheckFeatureLevel(int major, int minor) const
    {
      if(major > featureLevelMajor) return true;
      if(major == featureLevelMajor && minor >= featureLevelMinor) return true;
      return false;
    }
  };
 
  struct ICapabilities
  {
    virtual Vendors::EVendors getVendor() const { return Vendors::Unknown; }
 
    virtual Series::ESeries getSeries() const { return Series::Unknown; }
 
    virtual int getModel() const { return UnknownModel; };
 
    virtual bool supportsInstancing() const { return false; };
 
    virtual int getMaxTextureSlots() const { return 0; }
 
    virtual const GraphicsDeviceCapabilities & getDeviceCapabilities() const { return none; }
 
  private:
    GraphicsDeviceCapabilities none;
  };
}