#pragma once
//
// mesh_export — CUDA-free port of o_voxel.postprocess.to_glb: take the demo's
// dense per-vertex-PBR mesh and produce a portable glTF 2.0 binary (GLB). The
// reference does this on the GPU (CuMesh simplify/unwrap/BVH, nvdiffrast
// raster, flex_gemm grid_sample); here every stage is pure C++:
//
//   preserve topology -> optional component cleanup -> standard COLOR_0 vertex
//   material + retained custom metallic/roughness attribute -> GLB.
//
// A practical fixed-size atlas cannot give millions of preserved triangles
// enough texels, and the dual-grid geometry is heavily non-manifold. glTF vertex
// colour is therefore both more faithful and substantially smaller. Set
// T2GLB_XATLAS to opt into a conventional image atlas on clean meshes. No ggml /
// CUDA dependency: plain float/int arrays.

#include <cstdint>
#include <string>
#include <vector>

namespace t2glb {

enum class ComponentFilter {
    RemoveTiny = 0,  // preserve meaningful disconnected parts
    KeepLargest = 1, // retain only the component with the most triangles
    KeepAll = 2      // input is already prepared; do not filter again
};

struct MeshExportOptions {
    int   texture_size  = 2048;    // opt-in T2GLB_XATLAS width/height
    int   padding       = 2;       // xatlas chart padding (texels; T2GLB_XATLAS)
    int   dilate        = 6;       // gutter dilation passes (kills UV seams)
    ComponentFilter components = ComponentFilter::RemoveTiny;
};

// Geometry/material streams after the same component filtering used by
// mesh_to_glb. Valid source triangles retain their original polygon density.
struct PreparedMesh {
    std::vector<float>   verts;
    std::vector<float>   normals;
    std::vector<int32_t> tris;
    std::vector<float>   pbr;
};

bool prepare_mesh(const float * verts, int nv,
                  const int32_t * tris, int nt,
                  const float * pbr,
                  const MeshExportOptions & opt,
                  PreparedMesh & out,
                  std::string & err);

// Optional CPU print-remesh path backed by CGAL Alpha Wrap 3. The ratios are
// fractions of the component-filtered mesh's bounding-box diagonal. The result
// is guaranteed by Alpha Wrap to be closed, oriented, intersection-free and
// 2-manifold. Wrapping creates a new enclosing surface, so a textured source is
// sampled onto the wrap vertices (approximate per-vertex preview); the sharper
// per-texel rebake stays in mesh_to_projected_glb for the GLB download.
bool print_remesh_available();
bool prepare_print_mesh(const float * verts, int nv,
                        const int32_t * tris, int nt,
                        const float * pbr,
                        const MeshExportOptions & opt,
                        float alpha_ratio, float offset_ratio,
                        PreparedMesh & out,
                        std::string & err);

// Export a dense per-vertex-PBR mesh as a standard vertex-coloured GLB.
//
//   verts   3*nv  vertex positions (mesh/world space, as fdg::extract emits)
//   tris    3*nt  triangle vertex indices
//   pbr     6*nv  base_color rgb, metallic, roughness, alpha
//                 (null -> untextured grey)
//
// On success fills `out` with the GLB bytes and returns true. On failure returns
// false with a message in `err`. Not reentrant (Simplify.h uses global state):
// serialized internally by a mutex.
bool mesh_to_glb(const float * verts, int nv,
                 const int32_t * tris, int nt,
                 const float * pbr,
                 const MeshExportOptions & opt,
                 std::vector<uint8_t> & out,
                 std::string & err);

// UV-unwrap `target` and bake its atlas by projecting each covered texel onto
// the closest triangle of the dense PBR `source`.  Intended for assigning the
// generated material to Alpha Wrap geometry; always uses xatlas and the CGAL
// CPU closest-surface backend regardless of T2GLB_XATLAS.
bool mesh_to_projected_glb(const float * target_verts, int target_nv,
                           const int32_t * target_tris, int target_nt,
                           const float * source_verts, int source_nv,
                           const int32_t * source_tris, int source_nt,
                           const float * source_pbr,
                           const MeshExportOptions & opt,
                           std::vector<uint8_t> & out,
                           std::string & err);

} // namespace t2glb