IGraphicsDevice.h

#pragma once
 
#include <string>
#include <vector>
 
#include "Common.h"
#include "DataFormat.h"
 
namespace Cogs
{
  struct IBuffers;
  struct ICapabilities;
  struct IContext;
  struct IEffects;
  struct IPipelineStates;
  struct IRenderTargets;
  struct ISyncObjects;
  struct ITextures;
  struct ResourceCountersWebGPU;
  struct ResourceStatistics;
  struct WindowData;
 
  class ISwapChain;
 
  enum GraphicsDeviceFlags : int
  {
    None = 0x0000,
    Debug = 1 << 0,
    EnableDiagnostics = 1 << 1,
    EnableShaderCache = 1 << 2,
    EnableTraceLogging = 1 << 3,
    DumpShaderContents = 1 << 4,
    ForceSoftwareRendering = 1 << 5,
    UseSharedSurface = 1 << 6,
    UseESCompatibility = 1 << 7,
    UseSwapEffectDiscard = 1 << 8,
 
    UseOpenGLClipControl = 1<<9,
  };
 
  struct IIOHandler;
 
  struct GraphicsDeviceSettings
  {
    int featureLevelMajor;
 
    int featureLevelMinor;
 
    TextureFormat colorFormat = TextureFormat::R8G8B8A8_UNORM_SRGB;
 
    TextureFormat depthFormat = TextureFormat::D32_FLOAT;
 
    int numSamples = 1;
 
    int flags = GraphicsDeviceFlags::None;
 
    struct WindowData* windowData;
 
    void ** sharedSurface = nullptr;
 
    IIOHandler * ioHandler;
  };
 
  struct SharedGraphicsContext;
 
  class IGraphicsDevice
  {
  public:
    virtual ~IGraphicsDevice() = default;
 
    virtual bool initializeThread() { return true; }
 
    virtual SharedGraphicsContext * createSharedContext() { return nullptr; }
 
    virtual void activateSharedContext(SharedGraphicsContext *) {}
 
    virtual void releaseSharedContext(SharedGraphicsContext *) {}
 
    virtual bool initialize() = 0;
 
    virtual bool isInitializationFinished() { return true; }
 
    virtual ResourceCountersWebGPU getResourceCountersWebGPU();
 
    virtual ResourceStatistics getResourceStatistics();
 
    virtual std::string getIdentifier() const { return "Unknown"; }
 
    virtual GraphicsDeviceType getType() const { return GraphicsDeviceType::Unknown; }
 
    virtual void setSize(int width, int height) = 0;
 
    virtual bool getSize(int& width, int& height) const = 0;
 
    virtual void beginFrame() = 0;
 
    virtual void endFrame(uint32_t syncInterval = 0, PresentFlags presentFlags = PresentFlags::None) = 0;
 
    virtual void waitForCommandSync() {}
 
    virtual void releaseResources() = 0;
 
    virtual ISwapChain* createSwapChain(struct WindowData* /*windowData*/) { return nullptr; }
 
    virtual void deleteSwapChain(ISwapChain* /*swapChain*/) {}
 
    virtual IContext * getImmediateContext() = 0;
 
    virtual IBuffers * getBuffers() = 0;
 
    virtual ITextures * getTextures() = 0;
 
    virtual IRenderTargets * getRenderTargets() = 0;
 
    virtual IEffects * getEffects() = 0;
 
    virtual IPipelineStates * getPipelineStates() = 0;
 
    virtual ICapabilities * getCapabilities() = 0;
 
    virtual ISwapChain * getDefaultSwapChain() = 0;
 
    virtual ISyncObjects* getSyncObjects() = 0;
 
    virtual void* getNativeDevice() { return nullptr; }
    virtual void* getNativeQueue() { return nullptr; }
 
    virtual bool setSettings(const GraphicsDeviceSettings& newSettings)    { settings = newSettings; return true; }
 
    const GraphicsDeviceSettings & getSettings() const            { return settings; }
 
    // FIXME: Remove this function when WindowData will be moved to Cogs.Desktop.
    static void fillGraphicsSettings(struct WindowData* windowData, int requestedSampleCount);
 
  protected:
    GraphicsDeviceSettings settings;
    std::vector<ISwapChain*> swapChains;
  };
}