Shader.hpp

#ifndef SHADER_H
#define SHADER_H

#include <map>
#include <string>
#if AETHER3D_METAL
#import <Metal/Metal.h>
#endif
#if AETHER3D_D3D12
#include <d3d12.h>
#include <d3dcompiler.h>
#endif

namespace ae3d
{
    namespace FileSystem
    {
        struct FileContentsData;
    }
    
    class Shader
    {
    public:
        bool IsValid() const { return id != 0; }
        
        void Load( const char* vertexSource, const char* fragmentSource );

        void Load( const FileSystem::FileContentsData& vertexDataGLSL, const FileSystem::FileContentsData& fragmentDataGLSL,
                   const char* metalVertexShaderName, const char* metalFragmentShaderName,
                   const FileSystem::FileContentsData& vertexDataHLSL, const FileSystem::FileContentsData& fragmentDataHLSL );
        
#if AETHER3D_METAL
        void LoadFromLibrary( const char* vertexShaderName, const char* fragmentShaderName );
#endif

        void Use();

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

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

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

        void SetRenderTexture( const char* name, const 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 AETHER3D_D3D12
        ID3DBlob* blobShaderVertex = nullptr;
        ID3DBlob* blobShaderPixel = nullptr;
#endif

#if AETHER3D_METAL
        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 <MTLBuffer> GetUniformBuffer() { return uniformBuffer; }

        id <MTLFunction> vertexProgram;
        id <MTLFunction> fragmentProgram;
        id <MTLBuffer> uniformBuffer;
#endif
        struct IntDefaultedToMinusOne
        {
            int i = -1;
        };

    private:
#if AETHER3D_D3D12
        void CreateConstantBuffer();
        void ReflectVariables();

        ID3D12Resource* constantBuffer = nullptr;
        void* constantBufferUpload = nullptr;
        ID3D12ShaderReflection* reflector = nullptr;
#endif
        unsigned id = 0;
        std::map<std::string, IntDefaultedToMinusOne > uniformLocations;
    };
}
#endif