TinyObj.hpp

#pragma once
#include <boost/container/vector.hpp>
#include <halp/controls.hpp>
#include <halp/geometry.hpp>
#include <halp/meta.hpp>
#include <ossia/detail/pod_vector.hpp>
 
#include <QMatrix4x4>
#include <QQuaternion>
 
#include <cstring>
#include <vector>
 
#include <string_view>
namespace Threedim
{
using float_vec = boost::container::vector<float, ossia::pod_allocator<float>>;
 
struct extra_attribute {
  int64_t offset{}; // in elements (floats), not bytes
  halp::attribute_semantic semantic{};
  halp::attribute_format format{};
  int components{}; // 1-4 floats
  std::string name; // For custom semantics; empty = use semantic name
};
 
struct mesh {
  int64_t vertices{};
  // offset are in "elements", not bytes
  int64_t pos_offset{}, texcoord_offset{}, normal_offset{}, color_offset{}, tangent_offset{};
  bool texcoord{};
  bool normals{};
  bool colors{};
  // How many floats per vertex the colour stream actually carries. PLY writes
  // three, the vcg importers write four, and a consumer that assumes either one
  // reads every vertex after the first at the wrong offset.
  int color_components{3};
  bool tangents{};
  bool points{};
  std::vector<extra_attribute> extras;
};
 
std::vector<mesh> ObjFromString(
    std::string_view obj_data
    , std::string_view mtl_data
    , float_vec& data);
 
std::vector<mesh> ObjFromString(
    std::string_view obj_data
    , float_vec& data);
 
template <std::size_t N>
static void fromGL(float (&from)[N], auto& to)
{
  memcpy(to.data(), from, sizeof(float[N]));
}
template <std::size_t N>
static void toGL(auto& from, float (&to)[N])
{
  memcpy(to, from.data(), sizeof(float[N]));
}
 
inline void rebuild_transform(auto& inputs, auto& outputs)
{
  QMatrix4x4 model{};
 
  if constexpr(requires { inputs.position; })
  {
    auto& pos = inputs.position;
    model.translate(pos.value.x, pos.value.y, pos.value.z);
  }
 
  if constexpr(requires { inputs.rotation; })
  {
    auto& rot = inputs.rotation;
    model.rotate(QQuaternion::fromEulerAngles(rot.value.x, rot.value.y, rot.value.z));
  }
 
  if constexpr(requires { inputs.scale; })
  {
    auto& sc = inputs.scale;
    model.scale(sc.value.x, sc.value.y, sc.value.z);
  }
 
  // Legacy path: writes into the halp::mesh-style `geometry` output.
  // Scene-only loaders (GltfParser/FbxParser) have no `outputs.geometry`;
  // there the Position/Rotation/Scale controls are a no-op.
  if constexpr(requires {
                 outputs.geometry.transform;
                 outputs.geometry.dirty_transform;
               })
  {
    toGL(model, outputs.geometry.transform);
    outputs.geometry.dirty_transform = true;
  }
}
struct PositionControl : halp::xyz_spinboxes_f32<"Position", halp::free_range_min<>>
{
  void update(auto& o) { rebuild_transform(o.inputs, o.outputs); }
};
struct RotationControl
    : halp::xyz_spinboxes_f32<"Rotation", halp::range{0., 359.9999999, 0.}>
{
  void update(auto& o) { rebuild_transform(o.inputs, o.outputs); }
};
struct ScaleControl : halp::xyz_spinboxes_f32<"Scale", halp::range{0.00001, 1000., 1.}>
{
  void update(auto& o) { rebuild_transform(o.inputs, o.outputs); }
};
 
struct Update
{
  void update(auto& obj) { obj.update(); }
};
 
struct PrimitiveOutputs
{
  struct
  {
    halp_meta(name, "Geometry");
    halp::position_normals_texcoords_geometry_volume mesh;
    float transform[16]{};
    bool dirty_mesh = false;
    bool dirty_transform = false;
  } geometry;
};
}