GltfCommon.h

#pragma once
#ifndef GLTF_COMMON_HEADER_HAS_BEEN_INCLUDED_
#define GLTF_COMMON_HEADER_HAS_BEEN_INCLUDED_

#define TINYGLTF_NO_INCLUDE_JSON
#define TINYGLTF_NO_INCLUDE_STB_IMAGE
#define TINYGLTF_NO_INCLUDE_STB_IMAGE_WRITE
#include "TinyGltf/tiny_gltf.h"

#include <stdint.h>
#include <limits>
#include <tuple>
#include <memory>

namespace gltf{


    using Accessor = tinygltf::Accessor;
    using BufferView = tinygltf::BufferView;
    using Buffer = tinygltf::Buffer;

    struct DataAccessBundle
    {
        Accessor accessor;
        BufferView buffer_view;
        std::shared_ptr<const Buffer> bufferPtr = nullptr;
        // Duplicating the buffer was silly and costly sure, but it
        // shouldn't have resulted in a memory leak since it's a vector
        // and the object should get destroyed automatically. Either way
        // using a shared_ptr here is an easy fix. 
    };
    
    enum class DataType : int32_t {
        SCALAR = TINYGLTF_TYPE_SCALAR,
        VEC2 = TINYGLTF_TYPE_VEC2,
        VEC3 = TINYGLTF_TYPE_VEC3,
        VEC4 = TINYGLTF_TYPE_VEC4,
        MAT2 = TINYGLTF_TYPE_MAT2,
        MAT3 = TINYGLTF_TYPE_MAT3,
        MAT4 = TINYGLTF_TYPE_MAT4,
        INVALID =  std::numeric_limits<int32_t>::max()
    };

    enum class ComponentType : int32_t {
        BYTE = TINYGLTF_COMPONENT_TYPE_BYTE,
        UNSIGNED_BYTE = TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE,
        SHORT = TINYGLTF_COMPONENT_TYPE_SHORT,
        UNSIGNED_SHORT = TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT,
        INT = TINYGLTF_COMPONENT_TYPE_INT,
        UNSIGNED_INT = TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT,
        FLOAT = TINYGLTF_COMPONENT_TYPE_FLOAT,
        DOUBLE = TINYGLTF_COMPONENT_TYPE_DOUBLE,
        INVALID =  std::numeric_limits<int32_t>::max()
    };

    struct TypePair{const DataType data_type = DataType::INVALID; const ComponentType component_type = ComponentType::INVALID;};

    template <DataType T_dataType = DataType::INVALID>
    struct DataTypeInfo{
        static inline constexpr size_t count() noexcept {return(0);}
        static inline constexpr bool isScalar() noexcept {return(false);}
        static inline constexpr bool isVector() noexcept {return(false);}
        static inline constexpr bool isMatrix() noexcept {return(false);}
    };

    template <ComponentType T_compType>
    struct ComponentTypeInfo{};
    

    template<>
    struct DataTypeInfo<DataType::SCALAR>{
        static inline constexpr size_t count() noexcept {return(1);}
        static inline constexpr bool isScalar() noexcept {return(true);}
        static inline constexpr bool isVector() noexcept {return(false);}
        static inline constexpr bool isMatrix() noexcept {return(false);}
    };
    template<>
    struct DataTypeInfo<DataType::VEC2>{
        static inline constexpr size_t count() noexcept {return(2);}
        static inline constexpr bool isScalar() noexcept {return(false);}
        static inline constexpr bool isVector() noexcept {return(true);}
        static inline constexpr bool isMatrix() noexcept {return(false);}
    };
    template<>
    struct DataTypeInfo<DataType::VEC3>{
        static inline constexpr size_t count() noexcept {return(3);}
        static inline constexpr bool isScalar() noexcept {return(false);}
        static inline constexpr bool isVector() noexcept {return(true);}
        static inline constexpr bool isMatrix() noexcept {return(false);}
    };
    template<>
    struct DataTypeInfo<DataType::VEC4>{
        static inline constexpr size_t count() noexcept {return(4);}
        static inline constexpr bool isScalar() noexcept {return(false);}
        static inline constexpr bool isVector() noexcept {return(true);}
        static inline constexpr bool isMatrix() noexcept {return(false);}
    };
    template<>
    struct DataTypeInfo<DataType::MAT2>{
        static inline constexpr size_t count() noexcept {return(4);}
        static inline constexpr bool isScalar() noexcept {return(false);}
        static inline constexpr bool isVector() noexcept {return(false);}
        static inline constexpr bool isMatrix() noexcept {return(true);}
    };
    template<>
    struct DataTypeInfo<DataType::MAT3>{
        static inline constexpr size_t count() noexcept {return(9);}
        static inline constexpr bool isScalar() noexcept {return(false);}
        static inline constexpr bool isVector() noexcept {return(false);}
        static inline constexpr bool isMatrix() noexcept {return(true);}
    };
    template<>
    struct DataTypeInfo<DataType::MAT4>{
        static inline constexpr size_t count() noexcept {return(16);}
        static inline constexpr bool isScalar() noexcept {return(false);}
        static inline constexpr bool isVector() noexcept {return(false);}
        static inline constexpr bool isMatrix() noexcept {return(true);}
    };

    template <>
    struct ComponentTypeInfo<ComponentType::BYTE>{
        using data_t = int8_t;
    };
    template <>
    struct ComponentTypeInfo<ComponentType::UNSIGNED_BYTE>{
        using data_t = uint8_t;
    };
    template <>
    struct ComponentTypeInfo<ComponentType::SHORT>{
        using data_t = int16_t;
    };
    template <>
    struct ComponentTypeInfo<ComponentType::UNSIGNED_SHORT>{
        using data_t = uint16_t;
    };
    template <>
    struct ComponentTypeInfo<ComponentType::INT>{
        using data_t = int32_t;
    };
    template <>
    struct ComponentTypeInfo<ComponentType::UNSIGNED_INT>{
        using data_t = uint32_t;
    };
    template <>
    struct ComponentTypeInfo<ComponentType::FLOAT>{
        using data_t = float;
    };
    template <>
    struct ComponentTypeInfo<ComponentType::DOUBLE>{
        using data_t = double;
    };
    

    
    
    
}

#endif