Shader.hpp

#ifndef SHADER_H
#define SHADER_H

#include <map>
#include <string>
#if RENDERER_METAL
#import <Metal/Metal.h>
#endif
#if RENDERER_D3D12
#include <d3d12.h>
#include <d3dcompiler.h>
#endif
#if RENDERER_VULKAN
#include <vulkan/vulkan.h>
#include <cstdint>
#endif

namespace ae3d
{
    namespace FileSystem
    {
        struct FileContentsData;
    }
    
    class Shader
    {
    public:
        void Load( const char* vertexSource, const char* fragmentSource );
#if RENDERER_VULKAN
        bool IsValid() const { return true; }

        void LoadSPIRV( const FileSystem::FileContentsData& vertexData, const FileSystem::FileContentsData& fragmentData );
#endif
        void Load( const FileSystem::FileContentsData& vertexDataGLSL, const FileSystem::FileContentsData& fragmentDataGLSL,
                   const char* metalVertexShaderName, const char* metalFragmentShaderName,
                   const FileSystem::FileContentsData& vertexDataHLSL, const FileSystem::FileContentsData& fragmentDataHLSL,
                   const FileSystem::FileContentsData& vertexDataSPIRV, const FileSystem::FileContentsData& fragmentDataSPIRV );
        
#if RENDERER_METAL
        void LoadFromLibrary( const char* vertexShaderName, const char* fragmentShaderName );
#endif
#if RENDERER_OPENGL
        bool IsValid() const { return handle != 0; }
        unsigned GetHandle() const { return handle; }
#endif
        
        void Use();

        void SetMatrix( const char* name, const float* matrix4x4 );

        void SetTexture( const char* name, class Texture2D* texture, int textureUnit );

        void SetTexture( const char* name, class TextureCube* texture, int textureUnit );

        void SetRenderTexture( const char* name, class RenderTexture* renderTexture, int textureUnit );

        void SetInt( const char* name, int value );

        void SetFloat( const char* name, float value );

        void SetVector3( const char* name, const float* vec3 );

        void SetVector4( const char* name, const float* vec4 );

#if RENDERER_NULL
        bool IsValid() const { return true; }
#endif
#if RENDERER_D3D12
        bool IsValid() const { return blobShaderVertex != nullptr; }
        ID3DBlob* blobShaderVertex = nullptr;
        ID3DBlob* blobShaderPixel = nullptr;
#endif

#if RENDERER_METAL
        bool IsValid() const { return vertexProgram != nullptr; }

        enum class UniformType { Float, Float2, Float3, Float4, Matrix4x4 };
        
        struct Uniform
        {
            UniformType type = UniformType::Float;
            unsigned long offsetFromBufferStart = 0;
            float floatValue[ 4 ];
            float matrix4x4[ 16 ];
        };
        
        std::map< std::string, Uniform > uniforms;
        
        void LoadUniforms( MTLRenderPipelineReflection* reflection );

        id <MTLFunction> vertexProgram;
        id <MTLFunction> fragmentProgram;
#endif
#if RENDERER_VULKAN
        VkPipelineShaderStageCreateInfo& GetVertexInfo() { return vertexInfo; }
        VkPipelineShaderStageCreateInfo& GetFragmentInfo() { return fragmentInfo; }
#endif
        struct IntDefaultedToMinusOne
        {
            int i = -1;
        };

    private:
        std::string fragmentPath;

#if RENDERER_D3D12
        void ReflectVariables();

        ID3D12ShaderReflection* reflector = nullptr;
        std::map<std::string, IntDefaultedToMinusOne > uniformLocations;
#endif
#if RENDERER_VULKAN
        VkPipelineShaderStageCreateInfo vertexInfo;
        VkPipelineShaderStageCreateInfo fragmentInfo;        
#endif
#if RENDERER_OPENGL
        unsigned handle = 0;
        std::map<std::string, IntDefaultedToMinusOne > uniformLocations;
#endif
    };
}
#endif