GraphicsDevice.h

#ifndef NXNA_GRAPHICS_GRAPHICSDEVICE_H
#define NXNA_GRAPHICS_GRAPHICSDEVICE_H

#ifdef NXNA_ENABLE_DIRECT3D11
#include <d3d11.h>
#endif

#ifdef NXNA_ENABLE_MATH
#include "../Vector3.h"
#include "../Matrix.h"
#endif

#include "PipelineState.h"


namespace Nxna
{
    namespace Graphics
    {
        enum class GraphicsDeviceType
        {
            None, 

            OpenGl41,

            OpenGLES3,
            
            Direct3D11,

#ifndef NDEBUG
            LAST
#endif
        };
        
        union Capabilities
        {
            struct
            {
                bool SupportsS3tcTextureCompression;
            } OpenGLCaps;
        };

        enum class Usage
        {
            Default,

            Immutable,

            Dynamic
        };

        enum class PrimitiveType
        {
            TriangleList,

            TriangleStrip
        };

        enum class IndexElementSize
        {
            SixteenBits = 2,

            ThirtyTwoBits = 4
        };

        struct IndexBuffer
        {
            union
            {
                struct
                {
                    unsigned int ByteLength;
                    unsigned int Buffer;
                } OpenGL;
#ifdef NXNA_ENABLE_DIRECT3D11
                struct
                {
                    ID3D11Buffer* Buffer;
                } Direct3D11;
#endif
            };

            IndexElementSize ElementSize;

#ifndef NXNA_DISABLE_VALIDATION
            unsigned int ByteLength;
            Usage BufferUsage;
#endif
        };

        struct VertexBuffer
        {
            union
            {
                struct
                {
                    unsigned int ByteLength;
                    unsigned int Buffer;
                    unsigned int VAO;
                } OpenGL;
#ifdef NXNA_ENABLE_DIRECT3D11
                struct
                {
                    ID3D11Buffer* Buffer;
                } Direct3D11;
#endif
            };

#ifndef NXNA_DISABLE_VALIDATION
            unsigned int ByteLength;
            Usage BufferUsage;
#endif
        };

        struct ConstantBuffer
        {
            union
            {
                struct
                {
                    unsigned int ByteLength;
                    unsigned int UniformBuffer;
                } OpenGL;
#ifdef NXNA_ENABLE_DIRECT3D11
                struct
                {
                    ID3D11Buffer* Buffer;
                } Direct3D11;
#endif
            };

#ifndef NXNA_DISABLE_VALIDATION
            Usage BufferUsage;
            unsigned int ByteLength;
#endif
        };

        enum class BufferType
        {
            Index,

            Vertex,

            Constant
        };

        struct Buffer
        {
            union
            {
                struct
                {
                    unsigned int BufferHandle;
                } OpenGL;
#ifdef NXNA_ENABLE_DIRECT3D11
                struct
                {
                    ID3D11Buffer* BufferPtr;
                } Direct3D11;
#endif
            };

#ifndef NXNA_DISABLE_VALIDATION
            BufferType Type;
            Usage BufferUsage;
            unsigned int ByteLength;
#endif
        };
        

        struct Viewport
        {
            Viewport()
            {
                X = 0;
                Y = 0;
                Width = 0;
                Height = 0;
            }

            Viewport(int x, int y, int width, int height)
            {
                X = x;
                Y = y;
                Width = width;
                Height = height;
            }

            float GetAspectRatio() const { return Width / (float)Height; }

#ifdef NXNA_ENABLE_MATH
            Vector3 Project(const Vector3& source,
                const Matrix& project,
                const Matrix& view,
                const Matrix& world);
#endif
            void Project(const float* source3f, 
                const float* projectMatrix16f, 
                const float* viewMatrix16f,
                const float* worldMatrix16f,
                float* result3f);

#ifdef NXNA_ENABLE_MATH
            Vector3 Unproject(const Vector3& source,
                const Matrix& projection,
                const Matrix& view,
                const Matrix& world);
#endif

#ifdef NXNA_ENABLE_MATH
            Rectangle GetBounds()
            {
                return Rectangle(X, Y, Width, Height);
            }
#endif

            int X, Y, Width, Height;
        };

        struct GraphicsDeviceDebugMessage
        {
            GraphicsDeviceType DeviceType;
            const char* Message;
        };

        enum class ShaderType
        {
            Vertex,
            Pixel
        };

        typedef void (*GraphicsDeviceMessageCallback)(GraphicsDeviceDebugMessage);

        struct GraphicsDeviceDesc
        {
            GraphicsDeviceType Type;
            int ScreenWidth;
            int ScreenHeight;

            union
            {
                struct
                {
                    // nothing
                } OpenGL;
#ifdef NXNA_ENABLE_DIRECT3D11
                struct
                {
                    ID3D11Device* Device;
                    ID3D11DeviceContext* DeviceContext;
                    ID3D11RenderTargetView* RenderTargetView;
                    IDXGISwapChain* SwapChain;
                } Direct3D11;
#endif
            };
        };

#ifdef NXNA_ENABLE_DIRECT3D11
        struct D3D11DeviceState
        {
            ID3D11Device* Device;
            ID3D11DeviceContext* Context;
            ID3D11RenderTargetView* RenderTargetView;
            IDXGISwapChain* SwapChain;
        };
#endif

        enum class SurfaceFormat
        {
            Color,
            Bgr565,
            Bgra5551,
            Bgra4444,
            Dxt1,
            Dxt3,
            Dxt5,

            // the following are not supported by XNA. These are our own
            // extensions so that iOS devices can have compressed textures too.
            Pvrtc4
        };

        struct TextureCreationDesc
        {
            int Width;
            int Height;
            int MipLevels;
            Usage TextureUsage;
            SurfaceFormat Format;

            void* InitialData;
            unsigned int InitialDataByteCount;
        };

        struct Texture2D
        {
            union
            {
                struct
                {
                    unsigned int Handle;
                } OpenGL;
#ifdef NXNA_ENABLE_DIRECT3D11
                struct
                {
                    ID3D11ShaderResourceView* m_shaderResourceView;
                    ID3D11Texture2D* m_texture;
                } Direct3D11;
#endif
            };
        };

        struct Texture2DExtra
        {
            Texture2D Texture;
            int Width;
            int Height;
        };

        struct IndexBufferDesc
        {
            IndexElementSize ElementSize;
            int NumElements;
            Usage BufferUsage;

            void* InitialData;
            unsigned int InitialDataByteCount;
        };

        struct VertexBufferDesc
        {
            int NumVertices;
            Usage BufferUsage;
            InputElement* InputElements;
            int NumInputElements;
            int StrideBytes;

            void* InitialData;
            unsigned int InitialDataByteCount;
        };

        struct ConstantBufferDesc
        {
            Usage BufferUsage;
            unsigned int ByteCount;

            void* InitialData;
        };

        enum class MapType
        {
            Write,
            WriteDiscard,
            WriteNoOverwrite
        };

        class GraphicsDevice
        {
            GraphicsDeviceType m_type;
            Capabilities m_caps;
            int m_screenWidth, m_screenHeight;

            IndexBuffer m_indices;
            VertexBuffer m_vertices;
            ShaderPipeline* m_shaderPipeline;
            BlendState* m_blendState;
            RasterizerState* m_rasterizerState;

            NxnaResultDetails m_errorDetails;

#ifdef NXNA_ENABLE_DIRECT3D11
            D3D11DeviceState m_d3d11State;
#endif

        public:
            static NxnaResult CreateGraphicsDevice(const GraphicsDeviceDesc* params, GraphicsDevice* result);
            static void DestroyGraphicsDevice(GraphicsDevice* device);

            void SetMessageCallback(GraphicsDeviceMessageCallback callback);

#ifndef NXNA_ENABLE_DIRECT3D11
            constexpr GraphicsDeviceType GetType() { return m_type; }
#else
            GraphicsDeviceType GetType() { return m_type; }
#endif
            const NxnaResultDetails* GetErrorDetails() { return &m_errorDetails; }

            Capabilities* GetCaps() { return &m_caps; }

            void SetViewport(int x, int y, int width, int height);
            void SetViewport(Viewport viewport);

            NxnaResult CreateShader(ShaderType type, const void* bytecode, int bytecodeLength, Shader* result);

            void DestroyShader(Shader* shader);

            NxnaResult CreateTexture2D(const TextureCreationDesc* desc, Texture2D* result);
            void BindTexture(Texture2D* texture, int textureUnit);

            void DestroyTexture2D(Texture2D* texture);

            NxnaResult CreateShaderPipeline(const ShaderPipelineDesc* desc, ShaderPipeline* result);
            void SetShaderPipeline(ShaderPipeline* pipeline);

            void DestroyShaderPipeline(ShaderPipeline* pipeline);

            NxnaResult CreateBlendState(const BlendStateDesc* desc, BlendState* result);
            void SetBlendState(BlendState* state);

            void DestroyBlendState(BlendState* state);

            NxnaResult CreateRasterizerState(const RasterizerStateDesc* desc, RasterizerState* result);
            void SetRasterizerState(RasterizerState* state);
            void DestroyRasterizerState(RasterizerState* state);

            NxnaResult CreateIndexBuffer(const IndexBufferDesc* desc, IndexBuffer* result);
            void DestroyIndexBuffer(IndexBuffer buffer);
            void UpdateIndexBuffer(IndexBuffer buffer, unsigned int startOffset, void* data, unsigned int dataLengthInBytes);
            void SetIndices(IndexBuffer indices);

            NxnaResult CreateVertexBuffer(const VertexBufferDesc* desc, VertexBuffer* result);
            void DestroyVertexBuffer(VertexBuffer buffer);
            void UpdateVertexBuffer(VertexBuffer buffer, unsigned int startOffset, void* data, unsigned int dataLengthInBytes);
            void SetVertexBuffer(VertexBuffer vertexBuffer, unsigned int offset, unsigned int stride);

            NxnaResult CreateConstantBuffer(const ConstantBufferDesc* desc, ConstantBuffer* result);
            void UpdateConstantBuffer(ConstantBuffer buffer, void* data, unsigned int dataLengthInBytes);
            void SetConstantBuffer(ConstantBuffer buffer, int index);
            void DestroyConstantBuffer(ConstantBuffer* buffer);

            void* MapBuffer(IndexBuffer buffer, MapType type);
            void* MapBuffer(VertexBuffer buffer, MapType type);
            void* MapBuffer(ConstantBuffer buffer, MapType type);

            void UnmapBuffer(IndexBuffer buffer);
            void UnmapBuffer(VertexBuffer buffer);
            void UnmapBuffer(ConstantBuffer buffer);

            void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices, int startIndex, int primitiveCount);
            void DrawPrimitives(PrimitiveType primitiveType, int startVertex, int primitiveCount);

            void Clear(float r, float g, float b, float a);
            void Present();

#ifdef NXNA_ENABLE_DIRECT3D11
            const D3D11DeviceState* GetD3D11DeviceState() { return &m_d3d11State; }
#endif

        private:
            void applyDirtyStates();
        };
    }
}

#endif // NXNA_GRAPHICS_GRAPHICSDEVICE_H