Material.hpp

#pragma once 
#ifndef KJY_OBJECT_ORIENTED_OPENGL_MATERIAL_HPP_
#define KJY_OBJECT_ORIENTED_OPENGL_MATERIAL_HPP_
#include "../OOOGL_Core.hpp"
#include "../GLobjects/Texture.hpp"
#include <glm/glm.hpp>
#include "../GLSL.hpp"
#include "MaterialAttribute.hpp"
#include <unordered_map>

namespace OOOGL{

struct AttributeTypeMismatchException : public exception{
    const char* what() const noexcept override{
        return("Attempted to assign material attribute with mismatching type");
    }
};

/* For now these materials will be pretty bare bones. However I'd eventually
 * like to integrate a bunch of utilities for automatically formatting material
 * information into the correct layout for use with all sorts of GLSL aggregate
 * type. */
class MaterialInterface : public ObjectTag{
 public:

   /* Uploads material information as uniforms, binds textures, ect... Leaving
   * the given shader program in the correct state for rendering with the given
   * material. */
   virtual void configureShader(GLuint program) const = 0;

   /* Upload material information to program as uniforms. */
   virtual void uploadUniforms(GLuint program) const = 0;

   /* Get a description of the way material data gets layed out in GLSL code */
   virtual const GLSLBlockLayoutConstPtr getMaterialGLSLLayout() const = 0;

   virtual bool hasAttribute(const std::string& attr_name) const = 0;
   virtual const MaterialAttribute& getAttribute(const std::string& attr_name) const = 0;
   virtual void setAttribute(const std::string& attr_name, const MaterialAttribute& attr) = 0;

};

class WavefrontObjPhongMaterial : public MaterialInterface{
 public:

    virtual void configureShader(GLuint program) const override;

   /* Bind textures starting at texture unit 'texture_binding_offset'. Then
   * attempt to automatically upload material parameters as uniform data by
   * passing program to uploadUniforms */
    virtual void configureShader(GLuint program, GLuint textured_binding_offset) const;


    virtual void uploadUniforms(GLuint pid) const override;
    virtual const GLSLBlockLayoutConstPtr getMaterialGLSLLayout() const override;

   
   virtual bool hasAttribute(const std::string& attr_name) const override;
   virtual const MaterialAttribute& getAttribute(const std::string& attr_name) const override;
   virtual void setAttribute(const std::string& attr_name, const MaterialAttribute& attr) override;



    /* Bind textures starting at texture unit 'texture_binding_offset'. Then
    * attempt to automatically upload material parameters as uniform data by
    * passing program to uploadUniforms.
    * 
    * Returns: The texture unit following the last unit bound by the function. 
    * */
    GLuint autoBindTextures(GLuint program, GLuint texture_binding_offset = 0) const;

    /* Bind textures to the provided texture unit indices. Negative indices are ignored */
    void bindTexturesExplicit(GLuint map_Ka_index, GLuint map_Kd_index, GLuint map_Ks_index, GLuint map_bump_index, GLuint map_d_index, GLuint map_disp_index) const;

    static const GLSLBlockLayoutConstPtr getMaterialGLSLLayout_static() {return(&_glsl_layout_);}

 protected:

    std::unordered_map<std::string, MaterialAttribute> _attributes = {
        {"Ka", MaterialAttribute(glm::vec3())},
        {"Kd", MaterialAttribute(glm::vec3())},
        {"Ks", MaterialAttribute(glm::vec3())},
        {"Ns", MaterialAttribute(0.0f)},
        {"d", MaterialAttribute(0.0f)},
        {"illum", MaterialAttribute(0)},
        {"map_Ka", MaterialAttribute(OptionalSimpleTexture2D())},
        {"map_Kd", MaterialAttribute(OptionalSimpleTexture2D())},
        {"map_Ks", MaterialAttribute(OptionalSimpleTexture2D())},
        {"map_bump", MaterialAttribute(OptionalSimpleTexture2D())},
        {"map_d", MaterialAttribute(OptionalSimpleTexture2D())},
        {"map_disp", MaterialAttribute(OptionalSimpleTexture2D())}
    };

 private:

    void _bind_textures_(GLuint Ka, GLuint Kd, GLuint Ks, GLuint bump, GLuint d, GLuint disp) const;
    static const TemporaryHardCodedLayout _glsl_layout_;

};

class GltfMetallicRoughness : public MaterialInterface{
 public:

   /* Uploads material information as uniforms, binds textures, ect... Leaving
   * the given shader program in the correct state for rendering with the given
   * material. */
   virtual void configureShader(GLuint program) const override;

   /* Upload material information to program as uniforms. */
   virtual void uploadUniforms(GLuint program) const override;

   /* Get a description of the way material data gets layed out in GLSL code */
   virtual const GLSLBlockLayoutConstPtr getMaterialGLSLLayout() const override;

   virtual bool hasAttribute(const std::string& attr_name) const override;
   virtual const MaterialAttribute& getAttribute(const std::string& attr_name) const override;
   virtual void setAttribute(const std::string& attr_name, const MaterialAttribute& attr) override;

   virtual void printMaterial() const;
   

   static const GLSLBlockLayoutConstPtr getMaterialGLSLLayout_static() {return(&_glsl_layout_);}

 protected:

     std::unordered_map<std::string, MaterialAttribute> _attributes = {
        {"emissiveFactor", MaterialAttribute(glm::vec3(0.0))},
        {"baseColorFactor", MaterialAttribute(glm::vec3(0.0))},
        {"metallicFactor", MaterialAttribute(0.0f)},
        {"roughnessFactor", MaterialAttribute(0.0f)},

        {"baseColorTexture", MaterialAttribute(OptionalSimpleTexture2D())},
        {"metallicRoughnessTexture", MaterialAttribute(OptionalSimpleTexture2D())},
        {"normalTexture", MaterialAttribute(OptionalSimpleTexture2D())},
        {"occlusionTexture", MaterialAttribute(OptionalSimpleTexture2D())},
        {"emissiveTexture", MaterialAttribute(OptionalSimpleTexture2D())}
    };

 private:

    static const TemporaryHardCodedLayout _glsl_layout_;

};

}

#endif