assets.cc

#include <vtestbed/assets/convert.hh>
#include <vtestbed/config/real_type.hh>
#include <vtestbed/core/compartment.hh>
#include <vtestbed/core/hull.hh>
#include <vtestbed/geometry/polyhedron.hh>
#include <vtestbed/guile/assets.hh>
#include <vtestbed/guile/base.hh>
#include <vtestbed/guile/macros.hh>
#include <vtestbed/guile/traits.hh>
#include <vtestbed/guile/wrapper.hh>

using polyhedron_type = vtb::geometry::Polyhedron<VTB_REAL_TYPE,3>;
using hull_type = vtb::core::Hull<VTB_REAL_TYPE>;
using compartment_array = vtb::core::Compartment_array<VTB_REAL_TYPE>;
using compartment_type = vtb::core::Compartment<VTB_REAL_TYPE>;
using any_traits_type = vtb::guile::Traits<std::any>;

namespace {
    SCM any_type;
    SCM sym_gnuplot, sym_obj, sym_vsl, sym_bsp, sym_stl, sym_igs, sym_rms;
    SCM kw_format, kw_options;

    void read_options(vtb::assets::Options& options, SCM s_options) {
        using namespace vtb::guile;
        while (s_options != SCM_EOL) {
            SCM pair = scm_car(s_options);
            options.read(to_string(scm_symbol_to_string(scm_car(pair))),
                         to_string(scm_cdr(pair)));
            s_options = scm_cdr(s_options);
        }
    }

}


namespace vtb {

    namespace guile {

        SCM any_traits_type::type() { return ::any_type; }

        SCM import_asset(SCM rest) {
            using namespace vtb::assets;
            SCM s_options = SCM_EOL;
            scm_c_bind_keyword_arguments("import-asset", rest,
                                         scm_t_keyword_arguments_flags{},
                                         kw_options, &s_options, SCM_UNDEFINED);
            Options options;
            read_options(options, s_options);
            return Traits<std::any>::make(import_asset(std::move(options)));
        }

        SCM export_asset(SCM s_asset, SCM rest) {
            using namespace vtb::assets;
            SCM s_options = SCM_EOL;
            scm_c_bind_keyword_arguments("export-asset", rest,
                                         scm_t_keyword_arguments_flags{},
                                         kw_options, &s_options, SCM_UNDEFINED);
            Options options;
            read_options(options, s_options);
            auto&& asset = get_wrapper<std::any>(s_asset)->get();
            export_asset(std::move(asset), std::move(options));
            return SCM_UNSPECIFIED;
        }

        SCM convert_asset(SCM s_asset, SCM rest) {
            using namespace vtb::assets;
            SCM s_options = SCM_EOL;
            scm_c_bind_keyword_arguments("convert-asset", rest,
                                         scm_t_keyword_arguments_flags{},
                                         kw_options, &s_options, SCM_UNDEFINED);
            Options options;
            read_options(options, s_options);
            auto&& asset = get_wrapper<std::any>(s_asset)->get();
            auto&& result = convert(std::move(asset), std::move(options));
            return Traits<std::any>::make(std::move(result));
        }

        SCM import_polyhedron(SCM path, SCM rest) {
            using namespace vtb::assets;
            Format format{};
            SCM s_format = SCM_UNDEFINED, s_options = SCM_EOL;
            scm_c_bind_keyword_arguments("import-polyhedron", rest,
                                         scm_t_keyword_arguments_flags{},
                                         kw_format, &s_format,
                                         kw_options, &s_options, SCM_UNDEFINED);
            auto filename = to_string(path);
            if (is_bound(s_format)) {
                format = string_to_format(to_c_string(scm_symbol_to_string(s_format)).get());
            } else { format = filename_to_format(filename); }
            Options options{{"input-path",filename}, {"input-format",format}};
            read_options(options, s_options);
            const auto& object = import_asset(options);
            auto&& polyhedron = vtb::assets::convert<polyhedron_type>(object, options);
            return Traits<polyhedron_type>::make(std::move(polyhedron));
        }

        SCM export_polyhedron(SCM polyhedron, SCM path, SCM rest) {
            using namespace vtb::assets;
            using vtb::assets::export_asset;
            auto* wrapper = get_wrapper<polyhedron_type>(polyhedron);
            Format format{};
            SCM s_format = SCM_UNDEFINED, s_options = SCM_EOL;
            scm_c_bind_keyword_arguments("export-polyhedron", rest,
                                         scm_t_keyword_arguments_flags{},
                                         kw_format, &s_format,
                                         kw_options, &s_options, SCM_UNDEFINED);
            auto filename = to_string(path);
            if (is_bound(s_format)) {
                format = string_to_format(to_c_string(scm_symbol_to_string(s_format)).get());
            } else { format = filename_to_format(filename); }
            Options options{{"output-path",filename}, {"output-format",format}};
            read_options(options, s_options);
            export_asset<polyhedron_type>(*wrapper->get(), options);
            return SCM_UNSPECIFIED;
        }

        SCM import_hull(SCM path, SCM rest) {
            using namespace vtb::assets;
            Format format{};
            SCM s_format = SCM_UNDEFINED, s_options = SCM_EOL;
            scm_c_bind_keyword_arguments("import-hull", rest,
                                         scm_t_keyword_arguments_flags{},
                                         kw_format, &s_format,
                                         kw_options, &s_options, SCM_UNDEFINED);
            auto filename = to_string(path);
            if (is_bound(s_format)) {
                format = string_to_format(to_c_string(scm_symbol_to_string(s_format)).get());
            } else { format = filename_to_format(filename); }
            Options options{{"input-path",filename}, {"input-format",format}};
            read_options(options, s_options);
            return Traits<hull_type>::make(convert<hull_type>(import_asset(options), options));
        }

        SCM import_compartments(SCM path, SCM rest) {
            using namespace vtb::assets;
            using traits_type = vtb::guile::Traits<compartment_type>;
            Format format{};
            SCM s_format = SCM_UNDEFINED, s_options = SCM_EOL;
            scm_c_bind_keyword_arguments("import-compartments", rest,
                                         scm_t_keyword_arguments_flags{},
                                         kw_format, &s_format,
                                         kw_options, &s_options, SCM_UNDEFINED);
            auto filename = to_string(path);
            if (is_bound(s_format)) {
                format = string_to_format(to_c_string(scm_symbol_to_string(s_format)).get());
            } else { format = filename_to_format(filename); }
            Options options{{"input-path",filename}, {"input-format",format}};
            read_options(options, s_options);
            const auto& object = import_asset(options);
            auto&& rooms = convert<compartment_array>(object, options);
            SCM s_rooms = SCM_EOL;
            for (auto& room : rooms) {
                s_rooms = scm_cons(traits_type::make(std::move(room)), s_rooms);
            }
            s_rooms = scm_reverse(s_rooms);
            return s_rooms;
        }

        void assets_define() {
            ::any_type = define_type<std::any>("<any>");
            sym_gnuplot = scm_from_utf8_symbol("gnuplot");
            sym_obj = scm_from_utf8_symbol("obj");
            sym_stl = scm_from_utf8_symbol("stl");
            sym_vsl = scm_from_utf8_symbol("vsl");
            sym_bsp = scm_from_utf8_symbol("bsp");
            sym_igs = scm_from_utf8_symbol("igs");
            sym_rms = scm_from_utf8_symbol("rms");
            kw_format = scm_from_utf8_keyword("format");
            kw_options = scm_from_utf8_keyword("options");
            define_procedure("import-asset", 0, 0, 1, VTB_GUILE_1(import_asset));
            define_procedure("export-asset", 1, 0, 1, VTB_GUILE_2(export_asset));
            define_procedure("convert-asset", 1, 0, 1, VTB_GUILE_2(convert_asset));
            define_procedure("import-polyhedron", 1, 0, 1, VTB_GUILE_2(import_polyhedron));
            define_procedure("export-polyhedron", 2, 0, 1, VTB_GUILE_3(export_polyhedron));
            define_procedure("import-hull", 1, 0, 1, VTB_GUILE_2(import_hull));
            define_procedure("import-compartments", 1, 0, 1, VTB_GUILE_2(import_compartments));
        }

    }

}