ImplicitSurfaceNetwork/frontend/src/io_primitive.cpp

#include <data/data_center.hpp>

#include "io_primitive.h"

EXTERN_C_BEGIN

API primitive_data_center_t* create_primitive_data_center() noexcept { return new primitive_data_center_t(); }

API void destroy_primitive_data_center(primitive_data_center_t* data_center) noexcept
{
    if (data_center == nullptr) return;
    delete data_center;
}

API primitive* create_primitive(void* data_center, primitive_type type)
{
    if (data_center == nullptr) return nullptr;
    // if (primitive_ptr != nullptr) primitive_ptr->initialize(*static_cast<primitive_data_center_t*>(data_center));
    return internal::new_primitive(type, static_cast<primitive_data_center_t*>(data_center));
}

API primitive* create_param_primitive(const extend_axis_object_t* axis,
                                      const pattern_object_t*     pattern,
                                      void*                       data_center,
                                      primitive_type              type) noexcept(false)
{
    if (type < PRIMITIVE_TYPE_EXTRUDE) throw std::logic_error("not primitive with param, please use simpler create function.");
    return internal::new_param_primitive(axis->object,
                                         axis->is_closed,
                                         convert_mat3x4d(axis->axis_to_world),
                                         *pattern,
                                         type,
                                         static_cast<primitive_data_center_t*>(data_center));
}

API void destroy_primitive(primitive* primitive_ptr)
{
    if (primitive_ptr == nullptr) return;
    // use dtor may cause pure virtual function error here
    primitive_ptr->destroy();
    delete primitive_ptr;
}

API void primitive_apply_scale(primitive* primitive_ptr, vector3d scale)
{
    if (primitive_ptr == nullptr) return;
    Eigen::Vector4d scale_eigen{0, 0, 0, 1};
    std::move(&scale.x, &scale.x + 3, scale_eigen.data());
    primitive_ptr->apply_transform(internal::transform_type::scale, scale_eigen);
}

API void primitive_apply_rotation(primitive* primitive_ptr, vector4d quaternion)
{
    if (primitive_ptr == nullptr) return;
    Eigen::Vector4d quat_eigen;
    std::move(&quaternion.x, &quaternion.x + 4, quat_eigen.data());
    primitive_ptr->apply_transform(internal::transform_type::rotation, quat_eigen);
}

API void primitive_apply_translation(primitive* primitive_ptr, vector3d translation)
{
    if (primitive_ptr == nullptr) return;
    Eigen::Vector4d translation_eigen;
    std::move(&translation.x, &translation.x + 3, translation_eigen.data());
    primitive_ptr->apply_transform(internal::transform_type::translation, translation_eigen);
}

API primitive* duplicate_primitive(const primitive* primitive_ptr)
{
    return internal::copy_primitive(const_cast<primitive*>(primitive_ptr));
}

EXTERN_C_END