KSG-Framework/GraphicsApi.h

#pragma once

#include "Vec2.h"
#include "Mat4.h"
#include "Ebene3D.h"
#include "Bildschirm.h"

//! DirectX 12 Types

struct ID3D12Debug;
struct ID3D12Device;
struct ID3D12InfoQueue;
struct ID3D12CommandQueue;
struct IDXGISwapChain4;
struct ID3D12DescriptorHeap;
struct ID3D12Resource;
struct ID3D12CommandAllocator;
struct ID3D12GraphicsCommandList;
struct ID3D12Fence;
struct D3D12_VIEWPORT;
struct D3D12_VERTEX_BUFFER_VIEW;
struct D3D12_INDEX_BUFFER_VIEW;
struct ID3D12RootSignature;
struct ID3D12PipelineState;

//! DirectX 11 Types

struct ID3D11Device;
struct ID3D11DeviceContext;
struct IDXGISwapChain;
struct ID3D11Texture2D;
struct ID3D11SamplerState;
struct ID3D11ShaderResourceView;
struct ID3D11RenderTargetView;
struct ID3D11DepthStencilView;
struct ID3D11DepthStencilState;
struct ID3D11RasterizerState;
struct ID3D11BlendState;
struct D3D11_VIEWPORT;

//! DirectX 9 Types

struct IDirect3D9;
struct IDirect3DDevice9;
struct IDirect3DSurface9;
struct _D3DLOCKED_RECT;
struct tagRECT;

namespace Framework
{
    class WFenster;
    class Bild;
    class Textur;
    class DX11PixelShader;
    class DX11VertexShader;
    class TexturModel;
    class Render3D;
    class TexturList;
    class Kam3D;
    class Model3D;
    class DX11Buffer;
    class DX11StructuredBuffer;
    class DX12Buffer;
    class DX12DirectCommandQueue;
    class DX12CopyCommandQueue;
    class DX12ComputeCommandQueue;
    class DX12PixelShader;
    class DX12VertexShader;
    class DX12VertexBuffer;
    class DX12IndexBuffer;
    class Model3DList;
    class DXBuffer;
    class Model3DData;

    enum GraphicApiType;

    struct DiffuseLight
    {
        Vec3<float> direction;
        Vec3<float> color;
    };

    struct PointLight
    {
        Vec3<float> position;
        Vec3<float> color;
        float radius;
    };

    class GraphicsApi : public virtual ReferenceCounter
    {
    protected:
        GraphicApiType typ;
        WFenster* fenster;
        Vec2<int> backBufferSize;
        Model3DList* modelList;
        int nextModelId;
        Critical cs;

        bool fullScreen;

        DLLEXPORT virtual DXBuffer* createIndexBuffer() = 0;
        DLLEXPORT virtual DXBuffer* createVertexBuffer() = 0;

    public:
        DLLEXPORT GraphicsApi( GraphicApiType typ );
        DLLEXPORT virtual ~GraphicsApi();
        DLLEXPORT virtual void initialize( WFenster* fenster, Vec2<int> backBufferSize, bool fullScreen );
        DLLEXPORT virtual void setBackBufferSize( Vec2< int > size );
        DLLEXPORT virtual void setFullScreen( bool fullScreen );
        DLLEXPORT virtual void update() = 0;
        DLLEXPORT virtual void beginFrame( bool fill2D = 0, bool fill3D = 0, int fillColor = 0 );
        DLLEXPORT virtual void renderKamera( Kam3D* zKamera );
        DLLEXPORT virtual void renderKamera( Kam3D* zKamera, Textur* zTarget );
        DLLEXPORT virtual void presentFrame() = 0;
        DLLEXPORT virtual Textur* createOrGetTextur( const char* name, Bild* b = 0 );
        DLLEXPORT GraphicApiType getTyp() const;
        DLLEXPORT Vec2< int > getBackBufferSize() const;
        DLLEXPORT bool isFullScreen() const;
        DLLEXPORT virtual Bild* zUIRenderBild() const = 0;
        // returns the specified model without increased reference counter
        DLLEXPORT virtual Model3DData* zModel( const char* name );
        // returns the specified model with increased reference counter
        DLLEXPORT virtual Model3DData* getModel( const char* name );
        // creates a new empty Model3DData object if the model does not exist yet
        DLLEXPORT virtual Model3DData* createModel( const char* name );
        // check if a model exists
        DLLEXPORT virtual bool hasModel( const char* name );
    };

    class DirectX9 : public GraphicsApi
    {
    private:
        IDirect3D9* pDirect3D;
        IDirect3DDevice9* pDevice;
        IDirect3DSurface9* pBackBuffer;
        _D3DLOCKED_RECT* backRect;
        Bild* uiBild;

        DLLEXPORT virtual DXBuffer* createIndexBuffer() override;
        DLLEXPORT virtual DXBuffer* createVertexBuffer() override;

    public:
        DLLEXPORT DirectX9();
        DLLEXPORT ~DirectX9();
        DLLEXPORT void initialize( WFenster* fenster, Vec2<int> backBufferSize, bool fullScreen ) override;
        DLLEXPORT void update() override;
        DLLEXPORT void beginFrame( bool fill2D, bool fill3D, int fillColor ) override;
        DLLEXPORT void renderKamera( Kam3D* zKamera ) override;
        DLLEXPORT void presentFrame() override;
        DLLEXPORT Textur* createOrGetTextur( const char* name, Bild* b ) override;
        DLLEXPORT Bild* zUIRenderBild() const override;
    };

    class DirectX11 : public GraphicsApi
    {
    private:
        ID3D11Device* d3d11Device;
        ID3D11DeviceContext* d3d11Context;
        IDXGISwapChain* d3d11SpawChain;
        Textur* uiTextur;
        DX11VertexShader* vertexShader;
        DX11PixelShader* pixelShader;
        ID3D11SamplerState* sampleState;
        ID3D11RenderTargetView* rtview;
        ID3D11DepthStencilView* dsView;
        ID3D11Texture2D* depthStencilBuffer;
        ID3D11DepthStencilState* depthStencilState;
        ID3D11DepthStencilState* depthDisabledStencilState;
        ID3D11BlendState* blendStateAlphaBlend;
        D3D11_VIEWPORT* vp;
        TexturModel* texturModel;
        TexturList* texturRegister;
        ID3D11RasterizerState* texturRS;
        ID3D11RasterizerState* meshRS;
        Textur* defaultTextur;
        DX11StructuredBuffer* diffuseLights;
        DX11StructuredBuffer* pointLights;
        Mat4< float > matrixBuffer[ MAX_KNOCHEN_ANZ ];
        Mat4< float > viewAndProj[ 2 ];
        Vec3< float > kamPos;
        Ebene3D< float > frustrum[ 6 ];
        int lastModelId = -1;

        void renderObject( Model3D* zObj );
        //! Überprüft, ob eine Kugel in dem Sichtbaren Raum der Welt liegt und gezeichnet werden muss
        //! \param pos Der Mittelpunkt der Kugel
        //! \param radius Der Radius der Kugel
        //! \param dist Einen Zeiger auf einen float, in dem das quadrat des Abstands zur Kammeraposition gespeichert wird, falls diese Funktion true zurückgiebt und der Zeiger nicht 0 ist
        bool isInFrustrum( const Vec3< float >& pos, float radius, float* dist = 0 ) const;
        DLLEXPORT virtual DXBuffer* createIndexBuffer() override;
        DLLEXPORT virtual DXBuffer* createVertexBuffer() override;

    public:
        DLLEXPORT DirectX11();
        DLLEXPORT ~DirectX11();
        DLLEXPORT void initialize( WFenster* fenster, Vec2<int> backBufferSize, bool fullScreen ) override;
        DLLEXPORT void update() override;
        DLLEXPORT void beginFrame( bool fill2D, bool fill3D, int fillColor ) override;
        DLLEXPORT void renderKamera( Kam3D* zKamera ) override;
        DLLEXPORT void renderKamera( Kam3D* zKamera, Textur* zTarget ) override;
        DLLEXPORT void presentFrame() override;
        DLLEXPORT Textur* createOrGetTextur( const char* name, Bild* b ) override;
        DLLEXPORT Bild* zUIRenderBild() const override;

        DLLEXPORT static bool isAvailable();
    };

    class DirectX12 : public GraphicsApi
    {
    private:
        ID3D12Debug* debug;
        ID3D12Device* device;
        ID3D12InfoQueue* infoQueue;
        DX12DirectCommandQueue* directCommandQueue;
        DX12CopyCommandQueue* copyCommandQueue;
        DX12ComputeCommandQueue* computeCommandQueue;
        IDXGISwapChain4* swapChain;
        ID3D12DescriptorHeap* rtvHeap;
        ID3D12DescriptorHeap* dsvHeap;
        ID3D12DescriptorHeap* shaderBufferHeap;
        ID3D12Resource* depthBuffer;
        ID3D12Resource* backBuffer[ 2 ];
        int backBufferIndex;
        int tearing;
        D3D12_VIEWPORT* viewPort;
        tagRECT* allowedRenderArea;
        D3D12_VERTEX_BUFFER_VIEW* vertexBufferView;
        D3D12_INDEX_BUFFER_VIEW* indexBufferView;
        ID3D12RootSignature* signature;
        ID3D12PipelineState* pipeline;
        Mat4< float > matrixBuffer[ MAX_KNOCHEN_ANZ ];
        Mat4< float > viewAndProj[ 2 ];
        Vec3< float > kamPos;
        Ebene3D< float > frustrum[ 6 ];
        TexturModel* texturModel;
        Textur* uiTextur;
        TexturList* texturRegister;
        DX12VertexShader* vertexShader;
        DX12PixelShader* pixelShader;

        void renderObject( Model3D* zObj );
        //! Überprüft, ob eine Kugel in dem Sichtbaren Raum der Welt liegt und gezeichnet werden muss
        //! \param pos Der Mittelpunkt der Kugel
        //! \param radius Der Radius der Kugel
        //! \param dist Einen Zeiger auf einen float, in dem das quadrat des Abstands zur Kammeraposition gespeichert wird, falls diese Funktion true zurückgiebt und der Zeiger nicht 0 ist
        bool isInFrustrum( const Vec3< float >& pos, float radius, float* dist = 0 ) const;
        DLLEXPORT virtual DXBuffer* createIndexBuffer() override;
        DLLEXPORT virtual DXBuffer* createVertexBuffer() override;

    public:
        DLLEXPORT DirectX12();
        DLLEXPORT ~DirectX12();
        DLLEXPORT void initialize( WFenster* fenster, Vec2<int> backBufferSize, bool fullScreen ) override;
        DLLEXPORT void update() override;
        DLLEXPORT void beginFrame( bool fill2D, bool fill3D, int fillColor ) override;
        DLLEXPORT void renderKamera( Kam3D* zKamera ) override;
        // TODO: DLLEXPORT void renderKamera( Kam3D* zKamera, Textur* zTarget ) override;
        DLLEXPORT void presentFrame() override;
        DLLEXPORT Textur* createOrGetTextur( const char* name, Bild* b ) override;
        DLLEXPORT Bild* zUIRenderBild() const override;

        DLLEXPORT static bool isAvailable();
    };
}