#include <glslstruct/glslstruct.hpp>
#include <iostream>
#include <vector>
#include <glm/glm.hpp> // Is used for vectors and matrixes

using namespace glslstruct;

// 1. Define your C++ structure
std140_struct SceneSettings {
    glsl_value<glm::mat4>("viewProjection"),
    glsl_value<glm::vec3>("cameraPosition"),
    glsl_value<float>("globalTime"),
    glsl_value<int>("renderMode")
};

int main() {    
    // Total aligned size of the structure
    std::cout << "Total UBO size (std140): " << SceneSettings.size() 
        << " bytes." << std::endl; // Should be a multiple of 16 bytes
    
    // Offset for a specific field using a literal string
    std::cout << "Offset for 'cameraPosition': " << SceneSettings.get_offset("cameraPosition") 
        << " bytes." << std::endl;
    
    // Get data for uploading to UBO
    std::vector<std::byte> data_to_upload = SceneSettings.data();

    // Set variable
    SceneSettings.set("cameraPosition", glm::vec3{ 1.f, 0.f, 5.f });

    // Get variable
    glm::vec3 cameraPosition = SceneSettings.get("cameraPosition");

    // Get type
    base_type_handle value_type = SceneSettings.get_type("cameraPosition");
    vec_type_handle vec_value_type = static_type_cast<vec_type>(value_type);

    std::cout << "Vector type: " << to_string(vec_value_type->get_type()) 
        << " length: " << vec_value_type->get_length() << std::endl;

    return 0;
}

#include <glslstruct/glslstruct.hpp>
#include <iostream>
#include <string>
#include <string_view>
#include <glm/glm.hpp>
#include <fmt/fmt.h>

using namespace glslstruct;

std140_struct SceneSettings {
    glsl_value<glm::mat4>("viewProjection"),
    glsl_value<glm::vec3>("cameraPosition"),
    glsl_value<float>("globalTime"),
    glsl_value<int>("renderMode")
};

// Visitor Definition
class draw_visitor {
private:
    std::string _varName;

public:
    void setVarName(const std::string_view name) {
        _varName = name;
    }

    void visit(const scalar_type& type) {
        switch(type.get_type()) {
        case ValueType::Int:
            // Some simple GUI draw function
            draw_int(_varName, SceneSettings.get<int>(_varName));
            break;
        case ValueType::Float:
            // Some simple GUI draw function
            draw_float(_varName, SceneSettings.get<float>(_varName));
            break;
        }
    }
    void visit(const vec_type& type) {
        if (type.get_type() == ValueType::Float && 
            type.get_length() == 3) {
            // Some simple GUI draw function
            draw_vec3(_valueName, SceneSettings.get<glm::vec3>(_varName));
        }
    }
    void visit(const mat_type& type) {
        if (type.get_type() == ValueType::Float && 
            type.get_cols() == 4 && 
            type.get_rows() == 4) {
            // Some simple GUI draw function
            draw_mat4(_valueName, SceneSettings.get<glm::mat4>(_varName));
        }
    }
    void visit(const struct_type& type) {
        const std::string structName = _valueName;
    
        draw_begin_sub_menu(structName);
        for (const auto& [name, varData] : type->get_top_level_variables()) {
            _valueName = fmt::format("{}.{}", structName, name);
            varData.get_type()->accept(*this);
        }
        draw_end_sub_menu();
    }
    void visit(const array_type& type) {
        const std::string arrayName = _valueName;
    
        draw_begin_list(arrayName);
        for (size_t i = 0; i < type.get_count(); ++i) {
            _valueName = fmt::format("{}[{}]", arrayName, i);
            type.get_type()->accept(*this);
        }
        draw_end_list();
    }
}

int main() {

    draw_visitor visitor{};
    for (const auto& [name, varData] : SceneSettings.get_top_level_variables()) {
        visitor.setValueName(name);
        varData.get_type()->accept(visitor);
    }

    return 0;
}