MaterialAttribute.hpp

#pragma once 
#ifndef KJY_OBJECT_ORIENTED_OPENGL_MATERIAL_ATTRIBUTE_HPP_
#define KJY_OBJECT_ORIENTED_OPENGL_MATERIAL_ATTRIBUTE_HPP_

#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glad/glad.h>
#include <cstdint>
#include <cassert>
#include <vector>
#include <cstdio>
#include <stdexcept>
#include "../GLobjects/Texture.hpp"

/* Check if given template parameter is a glm vector type using SFINAE. See docs for std::void_t and SFINAE.*/
template<typename, typename = std::void_t<>, typename = std::void_t<>>
struct is_glm_vector : std::false_type{};

/* Check if given template parameter is a glm matrix type using SFINAE. See docs for std::void_t and SFINAE.*/
template<typename T>
struct is_glm_vector<T, std::void_t<typename T::value_type>, std::void_t<typename T::length_type>> : std::true_type{};

/* Check if given template parameter is a glm vector type using SFINAE. See docs for std::void_t and SFINAE.*/
template<typename, typename = std::void_t<>, typename = std::void_t<>>
struct is_glm_matrix : std::false_type{};

/* Check if given template parameter is a glm matrix type using SFINAE. See docs for std::void_t and SFINAE.*/
template<typename T>
struct is_glm_matrix<T, std::void_t<typename T::col_type>, std::void_t<typename T::row_type>> : std::true_type{};

namespace OOOGL{

/*    0    0000 000
 * (1)^ (2)^ (3)^
 * 
 * 1: Unused
 * 2: Dimension Type (e.g scalar vs vec3 vs mat4...)
 * 3: Component Type (e.g float vs bool, vs double...)
 */
struct _MatAttribType {
    const unsigned char dim_shift = 4;
    const unsigned char component_type_mask = 0x03;
    const unsigned char dimension_type_mask = 0xF << dim_shift;

    const unsigned char a_floating = 0x00;
    const unsigned char a_integral = 0x01;
    const unsigned char a_boolean = 0x02;
    const unsigned char a_double = 0x03;
    const unsigned char a_unsigned = 0x04;
    const unsigned char a_opaque = 0x08;

    const unsigned char a_scalar = 0x01 << dim_shift;
    const unsigned char a_vec2 = 0x02 << dim_shift;
    const unsigned char a_vec3 = 0x03 << dim_shift;
    const unsigned char a_vec4 = 0x04 << dim_shift;

    const unsigned char a_mat2 = 0x05 << dim_shift;
    const unsigned char a_mat3 = 0x06 << dim_shift;
    const unsigned char a_mat4 = 0x07 << dim_shift;
    const unsigned char a_tex = 0x08 << dim_shift;

};
const static _MatAttribType MatAttribType; 



class MaterialAttribute{
 public:

    MaterialAttribute(bool value) : MaterialAttribute((GLboolean) value) {}
    MaterialAttribute(GLint value) : _attrib_type(MatAttribType.a_integral | MatAttribType.a_scalar) {memcpy(&_scalar, &value, sizeof(uint64_t));}
    MaterialAttribute(GLdouble value) : _attrib_type(MatAttribType.a_double | MatAttribType.a_scalar) {memcpy(&_scalar, &value, sizeof(uint64_t));}
    explicit MaterialAttribute(GLuint value) : _attrib_type(MatAttribType.a_integral | MatAttribType.a_unsigned | MatAttribType.a_scalar) {memcpy(&_scalar, &value, sizeof(uint64_t));}
    explicit MaterialAttribute(GLfloat value) : _attrib_type(MatAttribType.a_floating | MatAttribType.a_scalar) {memcpy(&_scalar, &value, sizeof(uint64_t));}
    explicit MaterialAttribute(GLboolean value) : _attrib_type(MatAttribType.a_boolean | MatAttribType.a_scalar) {memcpy(&_scalar, &value, sizeof(uint64_t));}
    explicit MaterialAttribute(SimpleTexture2D tex) : _attrib_type(MatAttribType.a_tex | MatAttribType.a_opaque), _tex(tex) {}
    explicit MaterialAttribute(const OptionalSimpleTexture2D& tex) : _attrib_type(MatAttribType.a_tex | MatAttribType.a_opaque), _tex(tex) {}

    
    template<typename GenericT>
    explicit MaterialAttribute(const GenericT& value){
        using value_type = typename GenericT::value_type;
        unsigned char component_type = ~0;
        static_assert(std::is_fundamental<value_type>::value);
        if constexpr(std::is_same<value_type, bool>::value){
            component_type = MatAttribType.a_boolean;
        }else if constexpr(std::is_integral<value_type>::value){
            component_type = MatAttribType.a_integral | ((std::is_unsigned<value_type>::value && std::is_same<value_type, bool>::value) ? MatAttribType.a_unsigned : 0);
        }else if constexpr(std::is_same<value_type, glm::f64>::value){
            component_type = MatAttribType.a_double;
        }else if constexpr(std::is_same<value_type, glm::f32>::value){
            component_type = MatAttribType.a_floating;
        }else{
            fprintf(stderr, "Error: Generic type given for MaterialArgument has an unexpected value_type");
            assert(false);
        }

        if constexpr(is_glm_vector<GenericT>::value){
            unsigned char dimension_type = ((MatAttribType.a_scalar >> MatAttribType.dim_shift) + GenericT::length()-1) << MatAttribType.dim_shift;
            _attrib_type = component_type | dimension_type;
        }else if constexpr(is_glm_matrix<GenericT>::value){
            static_assert(std::is_same<GenericT, typename GenericT::transpose_type>::value); // Assert that this matrix is square 
            unsigned char dimension_type = ((MatAttribType.a_mat2 >> MatAttribType.dim_shift) + GenericT::length()-2) << MatAttribType.dim_shift;
            _attrib_type = component_type | dimension_type;
        }else{
            fprintf(stderr, "Error: Generic type given for Material attribute must be a glm 'vec' or 'mat'");
            assert(false);
        }

        _data.resize(sizeof(GenericT));
        memcpy(_data.data(), glm::value_ptr(value), sizeof(GenericT));
    }


    template<typename GenericT>
    GenericT getValue() const{
        GenericT value;
        getValue<GenericT>(value);
        return(value);
    }

    template<typename GenericT>
    void getValue(GenericT& value_out) const{
        if constexpr(is_glm_vector<GenericT>::value){
            memcpy(&value_out[0], _data.data(), sizeof(GenericT));
            return;
        }else if constexpr(is_glm_matrix<GenericT>::value){
            memcpy(&value_out[0][0], _data.data(), sizeof(GenericT));
            return;
        }else{
            // Specialization is not working for some reason, so we have to hail mary here.
            _getScalarValue(value_out);
            return;
        }
        throw std::runtime_error("MaterialAttribute getValue<" + std::string(typeid(GenericT).name()) + ">() executed unusually and reached a point which should be unreachable");
    }

    OptionalSimpleTexture2D getTexture() const {return(_tex);}

    bool typeEquals(const MaterialAttribute& other) const {return(this->_attrib_type == other._attrib_type);}

    bool isUnsigned() const {return((_attrib_type & MatAttribType.a_unsigned) == MatAttribType.a_unsigned);}
    bool isBoolean() const {return((_attrib_type & MatAttribType.component_type_mask) == MatAttribType.a_boolean);}
    bool isIntegral() const {return((_attrib_type & MatAttribType.component_type_mask) == MatAttribType.a_integral);}
    bool isFloat32() const {return((_attrib_type & MatAttribType.component_type_mask) == MatAttribType.a_floating && ((_attrib_type & MatAttribType.a_opaque) == 0));}
    bool isFloat64() const {return((_attrib_type & MatAttribType.component_type_mask) == MatAttribType.a_double);}
    bool isOpaque() const {return((_attrib_type & MatAttribType.a_opaque) == MatAttribType.a_opaque);}
    bool isScalar() const {return((_attrib_type & MatAttribType.dimension_type_mask) == MatAttribType.a_scalar);}
    bool isVec2() const {return((_attrib_type & MatAttribType.dimension_type_mask) == MatAttribType.a_vec2);}
    bool isVec3() const {return((_attrib_type & MatAttribType.dimension_type_mask) == MatAttribType.a_vec3);}
    bool isVec4() const {return((_attrib_type & MatAttribType.dimension_type_mask) == MatAttribType.a_vec4);}
    bool isMat2() const {return((_attrib_type & MatAttribType.dimension_type_mask) == MatAttribType.a_mat2);}
    bool isMat3() const {return((_attrib_type & MatAttribType.dimension_type_mask) == MatAttribType.a_mat3);}
    bool isMat4() const {return((_attrib_type & MatAttribType.dimension_type_mask) == MatAttribType.a_mat4);}
    bool isTex() const {return((_attrib_type & MatAttribType.dimension_type_mask) == MatAttribType.a_tex);}

 private:

   template<typename GenericT>
   void _getScalarValue(GenericT& value_out) const{
        memcpy(&value_out, &_scalar, sizeof(GenericT));
    }

   uint64_t _scalar;
   std::vector<uint8_t> _data;
   OptionalSimpleTexture2D _tex;

   unsigned char _attrib_type;
};


}

#endif