KSG-Framework/Shader.h

#pragma once

#include "Array.h"

struct ID3D10Blob;
struct ID3D11PixelShader;
struct ID3D11VertexShader;
struct ID3D11Device;
struct ID3D11DeviceContext;
struct D3D11_INPUT_ELEMENT_DESC;
struct ID3D11Buffer;
struct ID3D11InputLayout;

struct ID3D12Device2;
struct ID3D12GraphicsCommandList2;
struct D3D12_INPUT_ELEMENT_DESC;
struct D3D12_ROOT_PARAMETER1;
struct D3D12_CONSTANT_BUFFER_VIEW_DESC;

namespace Framework
{
    class Text;
    class DXBuffer;
    class DX12CopyCommandQueue;
    class DX12DirectCommandQueue;

    enum ShaderType
    {
        UNBEKANNT,
        VERTEX,
        PIXEL
    };

    // Eine Shader Klasse, die alle Constanten Buffers eines Shaders verwaltet
    class Shader
    {
    protected:
        ShaderType type;
        RCArray< DXBuffer > *constBuffers;
        int ref;

    public:
        // Konstruktor
        Shader();
        // Destruktor
        virtual ~Shader();
        // Setzt den Compilierten Shader
        //  zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
        //  bytes: Die Bytes des compilierten codes
        //  length: die Länge des bytearrays
        //  return: true, wenn bytes gültig ist, false sonst
        virtual bool setCompiledByteArray( unsigned char *bytes, int length ) = 0;
        // Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
        //  zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
        virtual void benutzeShader() = 0;
        // erstellt ein constanten Buffer, der constante daten an den Shader übergibt
        // es können maximal 14 Buffer erstellt werden
        //  zD3d11Device: Das Device, mit dem der Buffer erstellt werden soll
        //  size: Die größe des buffers in byte
        //  index: Die position des Buffers im Buffer Array. Bereits vorhanderner Buffer wird ersetzt. Buffer 1 kann nicht erstellt werden, wenn Buffer 0 noch nicht erstellt wurde usw.
        virtual bool erstelleConstBuffer( int size, int index ) = 0;
        // Löscht einen constanten Buffer
        //  index: der Index des Buffers, der gelöscht werden soll. Buffer 0 kann nicht gelöscht werden, solange Buffer 1 noch existiert usw.
        bool removeConstBuffer( int index );
        // Kopiert daten in einen constanten buffer
        //  zD3d11Context: Das Context Objekt, das zum kopieren verwendt werden soll
        //  data: Einen zeiger auf en byte Array der größe des Buffers
        //  index: Der Index des Buffers
        //  len: Die Länge der Daten in Bytes (-1 für die maximale größe des Buffers)
        bool füllConstBuffer( char *data, int index, int len = -1 );
        // Gibt die Länge eines constanten Buffers zurück
        //  index: Der Index des Buffers
        int getConstBufferLänge( int index ) const;
        // Gibt den Shadertyp zurück
        ShaderType getType() const;
        // Erhöht den Reference Counter um 1
        //  Return: Ein zeiger auf diesen Shader
        Shader *getThis();
        // Verringert den Reference Counter und löscht den Shader, falls der Refeence Counter auf 0 ist
        //  Return: 0
        Shader *release();
    };

    class DX11Shader : public Shader
    {
    protected:
        ID3D11Device *device;
        ID3D11DeviceContext *context;

    public:
        DX11Shader( ID3D11Device *device, ID3D11DeviceContext *context );
        virtual ~DX11Shader();
        // erstellt ein constanten Buffer, der constante daten an den Shader übergibt
        // es können maximal 14 Buffer erstellt werden
        //  zD3d11Device: Das Device, mit dem der Buffer erstellt werden soll
        //  size: Die größe des buffers in byte
        //  index: Die position des Buffers im Buffer Array. Bereits vorhanderner Buffer wird ersetzt. Buffer 1 kann nicht erstellt werden, wenn Buffer 0 noch nicht erstellt wurde usw.
        virtual bool erstelleConstBuffer( int size, int index ) override;
    };

    // Verwaltet einen Pixel Shader
    class DX11PixelShader : public DX11Shader
    {
    private:
        ID3D11PixelShader *pixelShader;

    public:
        // Konstruktor
        DX11PixelShader( ID3D11Device *device, ID3D11DeviceContext *context );
        // Destruktor
        ~DX11PixelShader();
        // Setzt den Compilierten Shader
        //  zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
        //  bytes: Die Bytes des compilierten codes
        //  length: die Länge des bytearrays
        //  return: true, wenn bytes gültig ist, false sonst
        bool setCompiledByteArray( unsigned char *bytes, int length ) override;
        // Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
        //  zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
        void benutzeShader() override;
    };

    // Verwaltet einen Vertex Shader
    class DX11VertexShader : public DX11Shader
    {
    private:
        ID3D11VertexShader *vertexShader;
        ID3D11InputLayout *inputLayout;
        unsigned char *shaderByteBuffer;
        int byteBufferSize;

    public:
        // Konstruktor
        DX11VertexShader( ID3D11Device *device, ID3D11DeviceContext *context );
        // Destruktor
        ~DX11VertexShader();
        // Setzt den Compilierten Shader
        //  zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
        //  bytes: Die Bytes des compilierten codes
        //  length: die Länge des bytearrays
        //  return: true, wenn bytes gültig ist, false sonst
        bool setCompiledByteArray( unsigned char *bytes, int length ) override;
        // erstellt ein InputLayout für den Shader
        // Darf erst nach compile aufgerufen werden
        //  zD3d11Device: Das Device, mit dem das Layout erstellt werden soll
        //  descArray: Ein Array mit initialisierungsdaten
        //  anz: Die Anzahl der Elemente im Array
        bool erstelleInputLayout( D3D11_INPUT_ELEMENT_DESC *descArray, int anz );
        // Nach dem Aufruf dieser Funktion wird dieser Shader als Vertex Shader benutzt
        //  zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
        void benutzeShader() override;
    };

    class DX12Shader : public Shader
    {
    protected:
        ID3D12Device2 *device;
        DX12CopyCommandQueue *copy;
        DX12DirectCommandQueue *direct;
        unsigned char *shaderByteBuffer;
        int byteBufferSize;

    public:
        DX12Shader( ID3D12Device2 *device, DX12CopyCommandQueue *copy, DX12DirectCommandQueue *direct );
        virtual ~DX12Shader();
        // erstellt ein constanten Buffer, der constante daten an den Shader übergibt
        // es können maximal 14 Buffer erstellt werden
        //  zD3d11Device: Das Device, mit dem der Buffer erstellt werden soll
        //  size: Die größe des buffers in byte
        //  index: Die position des Buffers im Buffer Array. Bereits vorhanderner Buffer wird ersetzt. Buffer 1 kann nicht erstellt werden, wenn Buffer 0 noch nicht erstellt wurde usw.
        virtual bool erstelleConstBuffer( int size, int index ) override;
        // Setzt den Compilierten Shader
        //  zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
        //  bytes: Die Bytes des compilierten codes
        //  length: die Länge des bytearrays
        //  return: true, wenn bytes gültig ist, false sonst
        bool setCompiledByteArray( unsigned char *bytes, int length ) override;
        // Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
        //  zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
        void benutzeShader() override;
        // gibt die compilierten bytes zurück
        unsigned char *getCompiledShader() const;
        // gitbt die anzahl der compilierten bytes zurück
        int getCompiledLength() const;
        // Erstellt den RootParameter zu einem constanten buffer
        //  index: Der Index des Buffers
        //  view: enthält nach dem Aufruf die position und größe des buffers im speicher
        virtual void getViewDesc( int index, D3D12_CONSTANT_BUFFER_VIEW_DESC &view );
    };

    class DX12PixelShader : public DX12Shader
    {
    public:
        DX12PixelShader( ID3D12Device2 *device, DX12CopyCommandQueue *copy, DX12DirectCommandQueue *direct );
    };

    class DX12VertexShader : public DX12Shader
    {
    private:
        D3D12_INPUT_ELEMENT_DESC *inputLayout;
        int inputLayoutSize;

    public:
        // Konstruktor
        DX12VertexShader( ID3D12Device2 *device, DX12CopyCommandQueue *copy, DX12DirectCommandQueue *direct );
        // Destruktor
        ~DX12VertexShader();
        // erstellt ein InputLayout für den Shader
        // Darf erst nach compile aufgerufen werden
        //  zD3d11Device: Das Device, mit dem das Layout erstellt werden soll
        //  descArray: Ein Array mit initialisierungsdaten
        //  anz: Die Anzahl der Elemente im Array
        bool erstelleInputLayout( D3D12_INPUT_ELEMENT_DESC *descArray, int anz );
        // Gint die Anzahl an eingabeparametern des Shaders zurück
        int getInputLayoutSize() const;
        // Gibt eine Liste mit formaten für jeden Eingabewert zurück
        D3D12_INPUT_ELEMENT_DESC *zInputLayout() const;
    };
}