GraphicsDeviceD3D11.h

#pragma once
 
#include "../IGraphicsDevice.h"
 
#include "BuffersD3D11.h"
#include "CapabilitiesD3D11.h"
#include "ContextD3D11.h"
#include "EffectsD3D11.h"
#include "RenderTargetsD3D11.h"
#include "SwapChainD3D11.h"
#include "TexturesD3D11.h"
#include "SyncObjectsD3D11.h"
 
#include "Foundation/Memory/Allocator.h"
 
namespace Cogs
{
  struct GraphicsDeviceD3D11 : public IGraphicsDevice
  {
  public:
    GraphicsDeviceD3D11(RenderingAllocatorInfo * allocator);
    ~GraphicsDeviceD3D11() = default;
 
    bool initialize();
 
    std::string getIdentifier() const override { return "Direct3D11"; }
    GraphicsDeviceType getType() const override { return GraphicsDeviceType::Direct3D11; }
 
    void beginFrame();
    void endFrame(uint32_t syncInterval = 0, uint32_t presentFlags = PresentFlags::None);
 
    void releaseResources();
 
    virtual ISwapChain* createSwapChain(struct WindowData* windowData) override;
    virtual void deleteSwapChain(ISwapChain* swapChain) override;
 
    void setSize(int newWidth, int newHeight);
    bool getSize(int& w, int& h) const override;
    bool resizeSharedSurfaces();
 
    IBuffers * getBuffers() { return &buffers; }
    ITextures * getTextures() { return &textures; }
    IContext * getImmediateContext() { return &context; }
    IEffects * getEffects() { return &effects; }
    IPipelineStates* getPipelineStates() { return nullptr; }
    IRenderTargets * getRenderTargets() { return &renderTargets; }
    ICapabilities * getCapabilities() { return &capabilities; }
    ISyncObjects* getSyncObjects() override { return &syncObjects; }
    SwapChainD3D11 * getDefaultSwapChain() override { return &defaultSwapChain; }
 
    virtual void* getNativeDevice() override { return device; }
    ResourcePointer<ID3D11Device>& getDevice() { return device; }
    Memory::Allocator * getResourceAllocator() { return resourceAllocator.get(); }
    ResourceStatistics getResourceStatistics() override;
 
  private:
    bool initializeDeviceAndSwapChain();
    bool initializeDeviceShared();
 
    void setupDebugging();
 
    // Note: Allocator needs to be declared _before_ resources, so it
    // is destroyed _after_ the resources (that uses this allocator)
    // has been destroyed.
    std::unique_ptr<Memory::Allocator> resourceAllocator;
 
#ifdef COGS_RENDERING_D3D9SUPPORT
    std::unique_ptr<struct SharedResources> sharedResources;
#endif
 
    ResourcePointer<ID3D11Device> device;
    ResourcePointer<ID3D11Device1> device1;
    ResourcePointer<ID3D11Device5> device5;
    ResourcePointer<ID3D11InfoQueue> infoQueue;
 
    SwapChainD3D11 defaultSwapChain;
    ContextD3D11 context;
    CapabilitiesD3D11 capabilities;
    BuffersD3D11 buffers;
    TexturesD3D11 textures;
    EffectsD3D11 effects;
    RenderTargetsD3D11 renderTargets;
    SyncObjectsD3D11 syncObjects;
 
    bool inFrame = false;
 
    HRESULT createDevice(IDXGIAdapter*                         adapter,
                         D3D_DRIVER_TYPE                       driverType,
                         UINT                                  flags,
                         const std::vector<D3D_FEATURE_LEVEL>& featureLevelsRequested,
                         D3D_FEATURE_LEVEL&                    apiFeatureLevel);
  };
}