Material.hpp

#pragma once
#ifndef __H__OCULAR_GRAPHICS_GRAPHICS_MATERIAL_H__
#define __H__OCULAR_GRAPHICS_GRAPHICS_MATERIAL_H__

#include "Graphics/Shader/Uniform/UniformBuffer.hpp"
#include "Graphics/RenderState/RasterState.hpp"
#include "Renderer/RenderPriority.hpp"

#include "Resources/Resource.hpp"
#include "ObjectIO/ObjectIO.hpp"
#include "Math/Matrix4x4.hpp"

#include <unordered_map>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Graphics
    {
        class Texture;
        class VertexShader;
        class GeometryShader;
        class FragmentShader;
        class PreTessellationShader;
        class PostTessellationShader;

        struct TextureSamplerInfo
        {
            Texture* texture;
            std::string samplerName;
            uint32_t samplerRegister;
        };

        class Material : public Core::Resource, public Core::ObjectIO
        {
        public:

            Material();
            virtual ~Material();

            virtual void bind();
            virtual void unbind();

            virtual void unload() override;

            //------------------------------------------------------------
            // Inherited Methods
            //------------------------------------------------------------

            virtual void onLoad(Core::BuilderNode const* node) override;
            virtual void onSave(Core::BuilderNode* node) const override;

            //------------------------------------------------------------
            // Texture Methods
            //------------------------------------------------------------

            virtual bool setTexture(uint32_t index, std::string const& name, Texture* texture);

            Texture* getTexture(uint32_t index) const;

            virtual void removeTexture(uint32_t index);

            uint32_t getNumTextures() const;

            std::vector<TextureSamplerInfo> const* getTextures() const;

            //------------------------------------------------------------
            // Shader Methods
            //------------------------------------------------------------

            bool setVertexShader(std::string const& name);

            void setVertexShader(VertexShader* shader);

            bool setGeometryShader(std::string const& name);

            void setGeometryShader(GeometryShader* shader);

            bool setFragmentShader(std::string const& name);

            void setFragmentShader(FragmentShader* shader);

            bool setPreTessellationShader(std::string const& name);

            void setPreTessellationShader(PreTessellationShader* shader);

            bool setPostTessellationShader(std::string const& name);

            void setPostTessellationShader(PostTessellationShader* shader);

            VertexShader* getVertexShader() const;

            GeometryShader* getGeometryShader() const;

            FragmentShader* getFragmentShader() const;

            PreTessellationShader* getPreTessellationShader() const;

            PostTessellationShader* getPostTessellationShader() const;

            //------------------------------------------------------------
            // Uniform Methods
            //------------------------------------------------------------

            virtual void setUniform(std::string const& name, uint32_t registerIndex, float value);

            virtual bool getUniform(std::string const& name, float& value);

            virtual void setUniform(std::string const& name, uint32_t registerIndex, Math::Vector4f const& value, std::string const& type = Utils::TypeName<Math::Vector4f>::name);

            virtual bool getUniform(std::string const& name, Math::Vector4f& value);

            virtual void setUniform(std::string const& name, uint32_t registerIndex, Math::Matrix3x3 const& value);

            virtual bool getUniform(std::string const& name, Math::Matrix3x3& value);

            virtual void setUniform(std::string const& name, uint32_t registerIndex, Math::Matrix4x4 const& value);

            virtual bool getUniform(std::string const& name, Math::Matrix4x4& value);

            UniformBuffer const* getUniformBuffer() const;

            //------------------------------------------------------------
            // Render State Changes
            //------------------------------------------------------------

            void setPrimitiveStyle(PrimitiveStyle style);

            PrimitiveStyle getPrimitiveStyle() const;

            void setFillMode(FillMode mode);

            FillMode getFillMode() const;

            void setRenderPriority(uint32_t priority);

            uint32_t getRenderPriority() const;

            //------------------------------------------------------------
            // Node Names (used for saving and loading)

            static const std::string ShaderNodeName;
            static const std::string TextureNodeName;
            static const std::string UniformNodeName;
            static const std::string RenderStateNodeName;

        protected:

            void setDefaults();

            void bindShaders();
            void unbindShaders();

            void bindStateChanges();
            void unbindStateChanges();

            //------------------------------------------------------------

            VertexShader*           m_VertexShader;
            GeometryShader*         m_GeometryShader;
            FragmentShader*         m_FragmentShader;
            PreTessellationShader*  m_PreTessellationShader;
            PostTessellationShader* m_PostTessellationShader;

            RasterState m_StoredRasterState;

            std::vector<TextureSamplerInfo> m_Textures;
            UniformBuffer* m_UniformBuffer;

            uint32_t m_RenderPriority;

        private:
        };
    }
}
//------------------------------------------------------------------------------------------

#endif