civ/trellis2-ROCm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7ade4e11529ca9a1e43eec6c2cea21378d70958c
trellis2-ROCm/trellis2_capi.cpp
T
civ 7ade4e1152 Initial release
2026-08-16 18:33:03 +07:00

1054 lines
50 KiB
C++
Raw Blame History

// Flat C ABI wrapper around the trellis2 C++ API (see trellis2_capi.h).
//
// Owns the image-bytes decode (stb_image) so hosts can hand us untrusted
// uploads directly; everything past decode reuses the validated C++ pipeline:
// decode -> preprocess -> DINOv3 -> SS-flow sample -> SS-dec -> marching cubes
#include "trellis2_capi.h"
#include "trellis2.h"
#include "mesh_export.h"
#include "pbr_utils.h"
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#include "marching_cubes.h"
#include "flexible_dual_grid.h"
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
namespace {
void copy_err(char * err, int err_len, const std::string & msg) {
if (!err || err_len <= 0) return;
std::snprintf(err, (size_t) err_len, "%s", msg.c_str());
}
// Rough peak VRAM the shape decode's transient buffers need at each tier
// (measured on the reference image: ~2.4 GB at 512³, ~6.75 GB for the 1024³
// level-3 conv output; rounded up for headroom). Mesh-dependent, so treated as
// a threshold, not an exact reservation — the free-flows fallback then gives a
// several-GB cushion if the estimate is low.
size_t decode_vram_peak(int pipeline_type) {
const double GB = (double) (1ULL << 30);
return (size_t) ((pipeline_type == T2_PIPE_1024 ? 7.5 : 3.0) * GB);
}
} // namespace
struct t2_pipeline {
trellis2_dino_model * dino = nullptr;
trellis2_ss_flow_model * flow = nullptr;
trellis2_ss_dec_model * dec = nullptr;
trellis2_slat_flow_model * slat = nullptr; // 512 model (fine path)
trellis2_slat_flow_model * slat_hr = nullptr; // 1024 model (cascade)
trellis2_shape_dec_model * shapedec = nullptr; // shared by 512 + cascade
std::string backend;
bool fine = false; // 512 dual-grid available
bool cascade = false; // 1024 cascade available
bool texture = false; // PBR texturing available (shape_enc + tex_dec + tex_flow)
int flags = 0;
bool shapedec_gpu = false; // shape decoder placed on the GPU (VRAM permitting)
// gguf paths, so the flow DiTs can be freed to make VRAM room for a GPU
// decode and lazily reloaded on the next generate (see ensure_decode_vram).
std::string ss_flow_path, slat_path, slat_hr_path;
// Texture-stage gguf paths. The tex models (~4 GB) are loaded lazily inside
// the texture stage — after the geometry flow DiTs are freed — and freed
// again, so they never coexist in VRAM with the geometry flows.
std::string shapeenc_path, texdec_path, texflow_path, texflow_hr_path;
};
// A generated mesh: verts (3/vertex), normals (3/vertex), tris (3/tri), and
// optional per-vertex PBR (6/vertex: base_color rgb, metallic, roughness, alpha).
struct t2_mesh_result {
std::vector<float> verts;
std::vector<float> normals;
std::vector<int> tris;
std::vector<float> pbr; // empty when untextured
};
namespace {
// Reload any flow DiT freed by a previous GPU decode (see ensure_decode_vram).
// No-op the common case where nothing was freed (pointers still set).
bool reload_flows(t2_pipeline * p, std::string & e) {
if (!p->flow && !p->ss_flow_path.empty()) {
p->flow = trellis2_ss_flow_load(p->ss_flow_path.c_str(), true, &e);
if (!p->flow) return false;
}
if (!p->slat && !p->slat_path.empty()) {
p->slat = trellis2_slat_flow_load(p->slat_path.c_str(), true, &e);
if (!p->slat) return false;
}
if (!p->slat_hr && !p->slat_hr_path.empty()) {
p->slat_hr = trellis2_slat_flow_load(p->slat_hr_path.c_str(), true, &e);
if (!p->slat_hr) return false;
}
return true;
}
// Before a GPU shape decode, make room: if the decode's transient buffers would
// not fit in current free VRAM, free the flow DiTs (all finished by decode time)
// to reclaim their ~5-7 GB. reload_flows() brings them back on the next
// generate. No-op for a CPU decoder or when the decode already fits.
void ensure_decode_vram(t2_pipeline * p, int pipeline_type) {
if (!p->shapedec_gpu) return;
if (trellis2_gpu_free_vram() >= decode_vram_peak(pipeline_type)) return;
trellis2_ss_flow_free(p->flow); p->flow = nullptr;
trellis2_slat_flow_free(p->slat); p->slat = nullptr;
trellis2_slat_flow_free(p->slat_hr); p->slat_hr = nullptr;
}
// ── live intermediate 3D previews (voxel sets) ───────────────────────────────
//
// A preview is a self-describing "T2VOX01" blob the host streams to its viewer:
// char magic[8] = "T2VOX01\0"; u32 res; u32 nvox; u16 coords[3*nvox] in [0,res)
// Voxels bound the payload (occupancy is sparse) and read as clearly "coarse"
// against the final smooth mesh — the stages stay visually distinct.
// Collect the occupied cells (logit > 0) of a dense [res^3] occupancy grid.
void collect_occupied(const float * occ, int res, std::vector<int32_t> & cells) {
cells.clear();
for (int x = 0; x < res; ++x)
for (int y = 0; y < res; ++y)
for (int z = 0; z < res; ++z) {
if (occ[((size_t) x * res + y) * res + z] > 0.0f) {
cells.push_back(x); cells.push_back(y); cells.push_back(z);
}
}
}
// Pack a flat [x,y,z,...] cell list (each in [0,res)) into a T2VOX01 blob.
void pack_voxels(int res, const std::vector<int32_t> & cells, std::vector<uint8_t> & blob) {
const uint32_t nvox = (uint32_t) (cells.size() / 3);
const uint32_t r = (uint32_t) res;
blob.resize(8 + 4 + 4 + (size_t) nvox * 3 * 2);
std::memcpy(blob.data(), "T2VOX01", 8); // 7 chars + NUL
std::memcpy(blob.data() + 8, &r, 4);
std::memcpy(blob.data() + 12, &nvox, 4);
uint8_t * dst = blob.data() + 16;
for (uint32_t i = 0; i < nvox * 3; ++i) {
const uint16_t c = (uint16_t) cells[i];
std::memcpy(dst, &c, 2); dst += 2;
}
}
// Pack + hand a voxel preview to the host callback. Best-effort: never fatal.
void emit_voxels(t2_preview_fn fn, void * user, int stage, int step, int total,
int res, const std::vector<int32_t> & cells) {
if (!fn) return;
std::vector<uint8_t> blob;
pack_voxels(res, cells, blob);
fn(user, stage, step, total, blob.data(), (int) blob.size());
}
// ── intermediate shape-SLAT mesh keyframes (opt-in) ──────────────────────────
//
// A keyframe is a coarse marching-cubes mesh (T2MESH01 blob, same layout as the
// final /api/mesh) of an intermediate shape-flow x_0 estimate — so the surface
// can be watched forming during the otherwise-invisible SLAT stage. Decoding
// mid-flow would OOM the 16 GB budget (the flow DiT is resident and can't be
// freed while its sampler is running), so we CAPTURE the cheap latents during
// the flow and REPLAY them into meshes AFTER the final decode, when the flow
// DiTs are freed and the shape decoder owns VRAM.
// Pack an MC mesh into a T2MESH01 blob: magic[8] u32 nv u32 nt
// f32[3nv] verts f32[3nv] normals i32[3nt] tris (little-endian).
void pack_mesh(const mc::Mesh & m, std::vector<uint8_t> & blob) {
const uint32_t nv = (uint32_t) (m.verts.size() / 3);
const uint32_t nt = (uint32_t) (m.tris.size() / 3);
blob.resize(16 + (size_t) nv * 24 + (size_t) nt * 12);
std::memcpy(blob.data(), "T2MESH01", 8);
std::memcpy(blob.data() + 8, &nv, 4);
std::memcpy(blob.data() + 12, &nt, 4);
size_t o = 16;
std::memcpy(blob.data() + o, m.verts.data(), (size_t) nv * 12); o += (size_t) nv * 12;
std::memcpy(blob.data() + o, m.normals.data(), (size_t) nv * 12); o += (size_t) nv * 12;
std::memcpy(blob.data() + o, m.tris.data(), (size_t) nt * 12);
}
// One shape-flow stage's captured intermediate x_0 latents (denormalized) plus
// the scaffold they sit on, awaiting post-decode replay.
struct kf_capture {
int stage = 0; // T2_STAGE_SLAT_FLOW or T2_STAGE_SLAT_FLOW_HR
int res_in = 0; // scaffold resolution (32 LR / 64 HR)
int levels = 0; // upsample levels to the ~128^3 keyframe grid
int stride = 1; // capture every `stride` steps (plus the last)
int channels = 0; // latent channels (32)
const float * norm_mean = nullptr;
const float * norm_std = nullptr;
std::vector<int32_t> coords; // scaffold coords, copied once
std::vector<int> steps, totals; // per capture, for labelling
std::vector<std::vector<float>> latents; // denormalized [L*channels] each
};
// Sampler preview trampoline: denormalize + stash the step's x_0 estimate.
void kf_capture_cb(void * u, int step, int total, const float * latent, int n) {
auto * c = (kf_capture *) u;
if (c->stride < 1) return;
if (step != total && (step % c->stride) != 0) return; // stride, plus the last step
const int C = c->channels;
std::vector<float> den((size_t) n);
for (int i = 0; i < n; ++i) den[i] = latent[i] * c->norm_std[i % C] + c->norm_mean[i % C];
c->steps.push_back(step);
c->totals.push_back(total);
c->latents.push_back(std::move(den));
}
// Replay captured latents into coarse MC-mesh keyframes and stream each. Runs
// after the final decode (decoder owns VRAM). Best-effort: skips on any failure.
void emit_keyframes(trellis2_shape_dec_model * dec, kf_capture & kf,
t2_preview_fn fn, void * user) {
if (!fn || kf.latents.empty() || !dec) return;
const int L = (int) (kf.coords.size() / 3);
const int tgt = kf.res_in << kf.levels; // keyframe grid (128^3)
for (size_t k = 0; k < kf.latents.size(); ++k) {
std::vector<int32_t> up;
std::string e;
if (!trellis2_shape_dec_upsample(dec, kf.latents[k].data(), L, kf.coords.data(),
kf.levels, up, &e))
continue;
std::vector<float> field((size_t) tgt * tgt * tgt, 0.0f);
for (size_t i = 0; i + 2 < up.size(); i += 3) {
const int x = up[i], y = up[i + 1], z = up[i + 2];
if (x >= 0 && x < tgt && y >= 0 && y < tgt && z >= 0 && z < tgt)
field[((size_t) x * tgt + y) * tgt + z] = 1.0f;
}
mc::Mesh m = mc::extract(field.data(), tgt, tgt, tgt, 0.5f);
if (m.verts.empty()) continue;
const float inv = 1.0f / (float) tgt;
for (auto & v : m.verts) v = v * inv - 0.5f; // -> centered unit cube
std::vector<uint8_t> blob;
pack_mesh(m, blob);
fn(user, kf.stage, kf.steps[k], kf.totals[k], blob.data(), (int) blob.size());
}
}
// Per-step SS preview cadence: T2_PREVIEW_STRIDE if set, else ~4 across the run.
int preview_stride(int steps) {
if (const char * e = std::getenv("T2_PREVIEW_STRIDE")) {
const int s = std::atoi(e);
if (s > 0) return s;
}
return std::max(1, steps / 4);
}
// Context for the (capture-less) SS-sampler preview trampoline: decode the
// handed-out x_0 estimate into a 64^3 occupancy and stream it as voxels.
struct ss_preview_ctx {
t2_preview_fn fn = nullptr;
void * user = nullptr;
trellis2_ss_dec_model * dec = nullptr;
int res = 0;
int stride = 1;
std::vector<float> * occ = nullptr; // scratch [res^3], caller-owned
};
// PBR-texture stage on the freshly decoded dual grid. Encoding the decoder
// output again is less direct than replaying the shape decoder's subdivisions,
// but it is the numerically validated path used by test_texture. In particular,
// it avoids the all-saturated material regression seen with the first integrated
// subdivision-guide implementation. The decoded PBR volume is still sampled at
// the actual mesh vertices rather than copied by voxel index.
bool run_texture_stage(t2_pipeline * p,
const std::vector<float> & dec_feats,
const std::vector<int32_t> & dec_coords,
const std::vector<float> & mesh_verts, int grid, int pt,
const trellis2_dino_cond & cond, uint64_t seed,
int texture_steps,
t2_progress_fn progress, void * user,
std::vector<float> & pbr_out, std::string & e) {
const int nvox = (int) (dec_coords.size() / 3);
if (nvox <= 0 || dec_feats.size() != (size_t) nvox * 7) {
e = "invalid decoded dual grid"; return false;
}
// Shape-encoder input from the seven-channel dual grid: learned dual-vertex
// offset plus the three intersection flags. This matches the standalone
// texturing pipeline fixture and preserves its exact subdivision replay.
const float mg = 0.5f;
std::vector<float> in6((size_t) nvox * 6);
for (int v = 0; v < nvox; ++v) {
const float * f = dec_feats.data() + (size_t) v * 7;
for (int c = 0; c < 3; ++c) {
const float s = 1.0f / (1.0f + std::exp(-f[c]));
in6[(size_t) v * 6 + c] = (1.0f + 2.0f * mg) * s - mg;
in6[(size_t) v * 6 + 3 + c] = f[3 + c] > 0.0f ? 1.0f : 0.0f;
}
}
if (progress) progress(user, T2_STAGE_TEXTURE, 0, texture_steps > 0 ? texture_steps : 12);
trellis2_shape_enc_model * enc = trellis2_shape_enc_load(p->shapeenc_path.c_str(), true, &e);
if (!enc) { e = "shape_enc load: " + e; return false; }
std::vector<float> shape_slat;
std::vector<int32_t> lat_coords;
std::vector<trellis2_subdiv_level> subs;
bool ok = trellis2_shape_enc_encode(enc, in6.data(), nvox, dec_coords.data(),
shape_slat, lat_coords, subs, nullptr, &e);
trellis2_shape_enc_free(enc);
if (!ok) { e = "shape encode: " + e; return false; }
const int Nl = (int) (lat_coords.size() / 3);
if (Nl <= 0 || shape_slat.size() != (size_t) Nl * 32) {
e = "invalid generated shape SLAT"; return false;
}
if (subs.empty()) { e = "missing shape decoder subdivision guide"; return false; }
// A 64^3/1024 shape SLAT must use the 1024 material model; feeding it to the
// 32^3/512 model is not a valid fallback.
if (pt == T2_PIPE_1024 && p->texflow_hr_path.empty()) {
e = "1024 texture flow model is not loaded"; return false;
}
const std::string & fp = pt == T2_PIPE_1024 ? p->texflow_hr_path : p->texflow_path;
trellis2_slat_flow_model * flow = trellis2_slat_flow_load(fp.c_str(), true, &e);
if (!flow) { e = "tex_flow load: " + e; return false; }
std::vector<float> tex_slat((size_t) Nl * 32);
trellis2_ss_sampler_params tp; // texturing_pipeline.json tex_slat_sampler
tp.steps = texture_steps > 0 ? texture_steps : 12;
tp.guidance_strength = 1.0f; tp.guidance_rescale = 0.0f;
tp.guidance_interval_min = 0.6f; tp.guidance_interval_max = 0.9f; tp.rescale_t = 3.0f;
tp.seed = seed ^ 0x7e00ULL; tp.verbose = false;
struct tex_progress_ctx { t2_progress_fn fn; void * user; } pc{progress, user};
if (progress) {
progress(user, T2_STAGE_TEXTURE, 0, tp.steps);
tp.progress = [](void * u, int step, int total) {
auto * c = (tex_progress_ctx *) u;
c->fn(c->user, T2_STAGE_TEXTURE, step, total);
};
tp.progress_user = &pc;
}
ok = trellis2_slat_flow_sample_tex(flow, Nl, lat_coords.data(),
cond.data.data(), (int) cond.tokens(), (int) cond.channels(),
shape_slat.data(), &tp, nullptr, /*denormalize*/ true,
tex_slat.data(), &e);
trellis2_slat_flow_free(flow);
if (!ok) { e = "tex sample: " + e; return false; }
// Texture decoder -> sparse six-channel PBR, replaying the shape decoder's
// subdivision hierarchy (upstream's guide_subs).
trellis2_shape_dec_model * texdec = trellis2_tex_dec_load(p->texdec_path.c_str(), true, &e);
if (!texdec) { e = "tex_dec load: " + e; return false; }
std::vector<float> pbr; std::vector<int32_t> pbr_coords;
ok = trellis2_tex_dec_decode(texdec, tex_slat.data(), Nl, lat_coords.data(),
subs, pbr, pbr_coords, &e);
trellis2_shape_dec_free(texdec);
if (!ok) { e = "tex decode: " + e; return false; }
// Sample at the actual dual-grid vertex positions, not their parent voxel
// coordinates. q = (xyz + 0.5) * grid is upstream's MeshWithVoxel query.
const int M = (int) (pbr_coords.size() / 3);
if (M <= 0 || pbr.size() != (size_t) M * 6) {
e = "texture decoder returned an invalid PBR volume"; return false;
}
const int nv = (int) (mesh_verts.size() / 3);
std::vector<float> query((size_t) nv * 3), weights((size_t) nv);
for (int v = 0; v < nv; ++v)
for (int c = 0; c < 3; ++c)
query[(size_t) v * 3 + c] = (mesh_verts[(size_t) v * 3 + c] + 0.5f) * grid;
pbr_out.resize((size_t) nv * 6);
t2pbr::sample_sparse_trilinear(pbr.data(), M, 6, pbr_coords.data(),
query.data(), nv, pbr_out.data(), weights.data());
for (int v = 0; v < nv; ++v) {
float * d = pbr_out.data() + (size_t) v * 6;
if (weights[(size_t) v] <= 1e-6f) {
d[0] = d[1] = d[2] = 0.5f;
d[3] = 0.0f; d[4] = 0.5f; d[5] = 1.0f;
} else {
for (int c = 0; c < 6; ++c) d[c] = std::max(0.0f, std::min(1.0f, d[c]));
}
}
// An opaque material can legitimately be white, metallic, or rough, but a
// decoder result with essentially every one of the six channels pinned to
// one is a collapsed latent, not a usable texture. Never silently persist
// that as a successful textured generation again.
if (t2pbr::is_collapsed_saturated(pbr_out.data(), nv)) {
pbr_out.clear();
e = "texture decoder produced a collapsed saturated material";
return false;
}
return true;
}
} // namespace
extern "C" {
int t2_abi_version(void) { return T2_CAPI_ABI_VERSION; }
t2_pipeline * t2_pipeline_load(const char * dino_gguf,
const char * ss_flow_gguf,
const char * ss_dec_gguf,
const char * slat_flow_gguf,
const char * slat_hr_flow_gguf,
const char * shape_dec_gguf,
const char * shape_enc_gguf,
const char * tex_dec_gguf,
const char * tex_flow_gguf,
const char * tex_flow_hr_gguf,
int flags,
char * err, int err_len) {
std::string e;
auto * p = new t2_pipeline();
p->flags = flags;
p->dino = trellis2_dino_load(dino_gguf, true, &e);
if (!p->dino) { copy_err(err, err_len, "dino: " + e); t2_pipeline_free(p); return nullptr; }
// Free VRAM before the flow DiTs are loaded == the VRAM reclaimable by
// freeing them again at decode time. Drives the shape-decoder placement.
const size_t free_pre_flows = trellis2_gpu_free_vram();
p->flow = trellis2_ss_flow_load(ss_flow_gguf, true, &e);
if (!p->flow) { copy_err(err, err_len, "ss_flow: " + e); t2_pipeline_free(p); return nullptr; }
// The SS occupancy decoder uses a genuine dense CONV_3D, for which ggml has
// no CUDA kernel, so it stays on the CPU (it is only ~3 s / 4 % anyway).
p->dec = trellis2_ss_dec_load(ss_dec_gguf, true, &e, "cpu");
if (!p->dec) { copy_err(err, err_len, "ss_dec: " + e); t2_pipeline_free(p); return nullptr; }
auto present = [](const char * s) { return s && s[0]; };
if (present(slat_flow_gguf) && present(shape_dec_gguf)) {
p->slat = trellis2_slat_flow_load(slat_flow_gguf, true, &e);
if (!p->slat) { copy_err(err, err_len, "slat_flow: " + e); t2_pipeline_free(p); return nullptr; }
const bool will_cascade = present(slat_hr_flow_gguf);
// Remember the flow-DiT gguf paths so a GPU decode can free them for VRAM
// and reload them next generate (ensure_decode_vram / reload_flows).
p->ss_flow_path = ss_flow_gguf ? ss_flow_gguf : "";
p->slat_path = slat_flow_gguf;
p->slat_hr_path = will_cascade ? slat_hr_flow_gguf : "";
// Auto-place the shape (FlexiDualGrid VAE) decoder — the biggest fine-path
// stage (~44 s CPU / 59 %). Its mask-based submanifold conv runs ~20x
// faster on the GPU (~2 s), but the decode's transient buffers need the
// flow DiTs' VRAM freed first (done per-request in ensure_decode_vram).
// Put it on the GPU when the card can hold that decode once the flows are
// freed — i.e. free_pre_flows covers the tier's decode peak plus the
// decoder weights (~1 GB) and a margin. TRELLIS2_SHAPE_DEC_{GPU,CPU}
// force it. On the CPU (no GPU) or too small a card it stays on the CPU,
// so there is never a mid-generation OOM.
bool sd_gpu;
if (std::getenv("TRELLIS2_SHAPE_DEC_CPU")) sd_gpu = false;
else if (std::getenv("TRELLIS2_SHAPE_DEC_GPU")) sd_gpu = free_pre_flows > 0;
else if (free_pre_flows == 0) sd_gpu = false; // no GPU
else {
const size_t margin = (size_t) 3 << 29; // ~1.5 GB (weights + slack)
sd_gpu = free_pre_flows >= decode_vram_peak(will_cascade ? T2_PIPE_1024
: T2_PIPE_512) + margin;
}
p->shapedec = trellis2_shape_dec_load(shape_dec_gguf, true, &e, sd_gpu ? nullptr : "cpu");
if (!p->shapedec && sd_gpu) { // unexpected GPU load OOM — fall back to CPU
sd_gpu = false;
p->shapedec = trellis2_shape_dec_load(shape_dec_gguf, true, &e, "cpu");
}
if (!p->shapedec) { copy_err(err, err_len, "shape_dec: " + e); t2_pipeline_free(p); return nullptr; }
p->shapedec_gpu = sd_gpu;
p->fine = true;
// The 1024 model is optional; when present the cascade path is enabled
// and reuses p->shapedec for both the upsample and the 1024^3 decode.
if (will_cascade) {
p->slat_hr = trellis2_slat_flow_load(slat_hr_flow_gguf, true, &e);
if (!p->slat_hr) { copy_err(err, err_len, "slat_hr_flow: " + e); t2_pipeline_free(p); return nullptr; }
p->cascade = true;
}
// PBR texturing: enabled when the shape encoder, texture decoder, and
// (at least the 512) texture flow are present. The tex models are loaded
// lazily per-generate (run_texture_stage), so only their paths are kept.
if (present(shape_enc_gguf) && present(tex_dec_gguf) && present(tex_flow_gguf)) {
std::string ve;
trellis2_shape_enc_model * te = trellis2_shape_enc_load(shape_enc_gguf, false, &ve);
if (!te) { copy_err(err, err_len, "shape_enc: " + ve); t2_pipeline_free(p); return nullptr; }
trellis2_shape_enc_free(te);
trellis2_shape_dec_model * td = trellis2_tex_dec_load(tex_dec_gguf, false, &ve);
if (!td) { copy_err(err, err_len, "tex_dec: " + ve); t2_pipeline_free(p); return nullptr; }
if (trellis2_shape_dec_hparams_of(td).out_channels != 6) {
trellis2_shape_dec_free(td);
copy_err(err, err_len, "tex_dec: expected 6 output channels");
t2_pipeline_free(p); return nullptr;
}
trellis2_shape_dec_free(td);
trellis2_slat_flow_model * tf = trellis2_slat_flow_load(tex_flow_gguf, false, &ve);
if (!tf) { copy_err(err, err_len, "tex_flow: " + ve); t2_pipeline_free(p); return nullptr; }
if (trellis2_slat_flow_hparams_of(tf).concat_cond_channels != 32) {
trellis2_slat_flow_free(tf);
copy_err(err, err_len, "tex_flow: expected 32 concat-conditioning channels");
t2_pipeline_free(p); return nullptr;
}
trellis2_slat_flow_free(tf);
if (present(tex_flow_hr_gguf)) {
tf = trellis2_slat_flow_load(tex_flow_hr_gguf, false, &ve);
if (!tf) { copy_err(err, err_len, "tex_flow_hr: " + ve); t2_pipeline_free(p); return nullptr; }
if (trellis2_slat_flow_hparams_of(tf).concat_cond_channels != 32) {
trellis2_slat_flow_free(tf);
copy_err(err, err_len, "tex_flow_hr: expected 32 concat-conditioning channels");
t2_pipeline_free(p); return nullptr;
}
trellis2_slat_flow_free(tf);
}
p->shapeenc_path = shape_enc_gguf;
p->texdec_path = tex_dec_gguf;
p->texflow_path = tex_flow_gguf;
p->texflow_hr_path = present(tex_flow_hr_gguf) ? tex_flow_hr_gguf : "";
p->texture = true;
}
}
p->backend = trellis2_ss_flow_backend_name(p->flow);
return p;
}
int t2_pipeline_caps(t2_pipeline * p) {
if (!p) return 0;
int c = T2_CAP_COARSE;
if (p->fine) c |= T2_CAP_512;
if (p->cascade) c |= T2_CAP_1024;
if (p->texture) c |= T2_CAP_TEXTURE;
return c;
}
int t2_pipeline_is_fine(t2_pipeline * p) { return p && (p->fine || p->cascade) ? 1 : 0; }
void t2_pipeline_free(t2_pipeline * p) {
if (!p) return;
trellis2_dino_free(p->dino);
trellis2_ss_flow_free(p->flow);
trellis2_ss_dec_free(p->dec);
trellis2_slat_flow_free(p->slat);
trellis2_slat_flow_free(p->slat_hr);
trellis2_shape_dec_free(p->shapedec);
delete p;
}
const char * t2_pipeline_backend(t2_pipeline * p) {
return p ? p->backend.c_str() : "none";
}
static int preprocess_image_bytes_mode(const void * image_bytes, int image_len,
int out_size, unsigned char * out_rgb,
int background_mode,
char * err, int err_len) {
if (!image_bytes || image_len <= 0 || out_size <= 0 || !out_rgb) {
copy_err(err, err_len, "invalid arguments");
return 1;
}
// Reject absurd dimensions before decoding (upload DoS / decompression
// bombs): 16 MPixel is far beyond anything useful at a 512^2 target.
int w = 0, h = 0, comp = 0;
if (!stbi_info_from_memory((const stbi_uc *) image_bytes, image_len, &w, &h, &comp)) {
copy_err(err, err_len, std::string("image probe failed: ") + stbi_failure_reason());
return 1;
}
if (w <= 0 || h <= 0 || (int64_t) w * h > (int64_t) 16 * 1024 * 1024) {
copy_err(err, err_len, "image dimensions out of range");
return 1;
}
unsigned char * px = stbi_load_from_memory(
(const stbi_uc *) image_bytes, image_len, &w, &h, &comp, 4);
if (!px) {
copy_err(err, err_len, std::string("image decode failed: ") + stbi_failure_reason());
return 1;
}
// stb supplies opaque alpha for inputs without it and preserves alpha for
// grayscale+alpha, RGBA, and transparent palette images. Turn an otherwise
// opaque border-connected near-black/near-white background into alpha before
// the reference alpha-bbox crop; meaningful existing masks are trusted.
if (background_mode < T2_BACKGROUND_AUTO || background_mode > T2_BACKGROUND_WHITE) {
stbi_image_free(px);
copy_err(err, err_len, "invalid background mode");
return 1;
}
trellis2_remove_solid_background_rgba(px, w, h, background_mode);
std::string e;
std::vector<uint8_t> rgb;
const bool ok = trellis2_preprocess_rgba(px, w, h, out_size, rgb, &e);
stbi_image_free(px);
if (!ok) {
copy_err(err, err_len, "preprocess failed: " + e);
return 1;
}
std::memcpy(out_rgb, rgb.data(), rgb.size());
return 0;
}
int t2_preprocess_image_bytes(const void * image_bytes, int image_len,
int out_size, unsigned char * out_rgb,
char * err, int err_len) {
return preprocess_image_bytes_mode(image_bytes, image_len, out_size, out_rgb,
T2_BACKGROUND_AUTO, err, err_len);
}
t2_mesh_result * t2_generate(t2_pipeline * p,
const void * image_bytes, int image_len,
int pipeline_type, int background_mode,
uint64_t seed, int steps, float guidance, int texture_steps,
t2_progress_fn progress, void * user,
t2_preview_fn preview, void * preview_user,
char * err, int err_len) {
if (!p) { copy_err(err, err_len, "null pipeline"); return nullptr; }
std::string e;
// Reload any flow DiT a previous GPU decode freed for VRAM (usually a no-op).
if (!reload_flows(p, e)) {
copy_err(err, err_len, "reload flow models: " + e);
return nullptr;
}
// Resolve the requested path to what is actually loaded.
int pt = pipeline_type;
if (pt == T2_PIPE_AUTO) {
pt = p->cascade ? T2_PIPE_1024 : (p->fine ? T2_PIPE_512 : T2_PIPE_COARSE);
}
if (pt == T2_PIPE_1024 && !p->cascade) pt = p->fine ? T2_PIPE_512 : T2_PIPE_COARSE;
if (pt == T2_PIPE_512 && !p->fine) pt = T2_PIPE_COARSE;
// Intermediate shape-SLAT keyframes (opt-in via T2_KEYFRAMES = per-stage
// count): capture a few x_0 estimates during the shape flow and replay them
// as coarse meshes after the final decode. Only when the host takes previews.
int keyframes = 0;
if (preview) {
if (const char * kv = std::getenv("T2_KEYFRAMES")) keyframes = std::atoi(kv);
keyframes = keyframes < 0 ? 0 : (keyframes > 8 ? 8 : keyframes);
}
const int S = 512;
if (progress) progress(user, T2_STAGE_PREPROCESS, 0, 0);
std::vector<unsigned char> rgb((size_t) S * S * 3);
char perr[256] = {0};
if (preprocess_image_bytes_mode(image_bytes, image_len, S, rgb.data(),
background_mode, perr, sizeof(perr))) {
copy_err(err, err_len, perr);
return nullptr;
}
if (progress) progress(user, T2_STAGE_DINO, 0, 0);
trellis2_dino_cond cond; // 512-res conditioning (SS + LR flow)
if (!trellis2_dino_encode_rgb(p->dino, rgb.data(), S, cond, &e)) {
copy_err(err, err_len, "dino encode: " + e);
return nullptr;
}
const trellis2_ss_flow_hparams & fhp = trellis2_ss_flow_hparams_of(p->flow);
if (cond.channels() != fhp.cond_channels) {
copy_err(err, err_len, "cond/flow channel mismatch");
return nullptr;
}
// SS-decoder geometry (also the occupancy scratch reused by the live
// previews and the settled decode below).
const trellis2_ss_dec_hparams & dechp = trellis2_ss_dec_hparams_of(p->dec);
const int Rout = dechp.res_out(); // 64
std::vector<float> occ((size_t) dechp.out_channels * Rout * Rout * Rout);
trellis2_ss_sampler_params sp;
if (steps > 0) sp.steps = steps;
if (guidance >= 0) sp.guidance_strength = guidance;
sp.seed = seed;
sp.verbose = false;
struct cb_ctx { t2_progress_fn fn; void * user; int stage; } cbc{progress, user, T2_STAGE_SS_FLOW};
if (progress) {
progress(user, T2_STAGE_SS_FLOW, 0, sp.steps);
sp.progress = [](void * u, int step, int total) {
auto * c = (cb_ctx *) u;
c->fn(c->user, c->stage, step, total);
};
sp.progress_user = &cbc;
}
// Live per-step previews: decode each step's x_0 estimate into 64^3
// occupancy and stream it as voxels (stride-gated; the last step is left to
// the settled SS_DEC checkpoint below). `pctx`/`occ` outlive the sampler.
ss_preview_ctx pctx;
if (preview) {
pctx = ss_preview_ctx{preview, preview_user, p->dec, Rout, preview_stride(sp.steps), &occ};
sp.preview = [](void * u, int step, int total, const float * latent, int /*n*/) {
auto * c = (ss_preview_ctx *) u;
if (step % c->stride != 0 || step == total) return;
std::string de;
if (!trellis2_ss_dec_decode(c->dec, latent, c->occ->data(), &de)) return;
std::vector<int32_t> cells;
collect_occupied(c->occ->data(), c->res, cells);
emit_voxels(c->fn, c->user, T2_STAGE_SS_FLOW, step, total, c->res, cells);
};
sp.preview_user = &pctx;
}
const int R = fhp.resolution;
std::vector<float> latent((size_t) fhp.in_channels * R * R * R);
if (!trellis2_ss_flow_sample(p->flow, cond.data.data(),
(int) cond.tokens(), (int) cond.channels(),
&sp, nullptr, latent.data(), &e)) {
copy_err(err, err_len, "ss_flow sample: " + e);
return nullptr;
}
if (progress) progress(user, T2_STAGE_SS_DEC, 0, 0);
if (!trellis2_ss_dec_decode(p->dec, latent.data(), occ.data(), &e)) {
copy_err(err, err_len, "ss_dec decode: " + e);
return nullptr;
}
// Settled-occupancy checkpoint (the clean sparse structure, 64^3 voxels).
if (preview) {
std::vector<int32_t> cells;
collect_occupied(occ.data(), Rout, cells);
emit_voxels(preview, preview_user, T2_STAGE_SS_DEC, 0, 0, Rout, cells);
}
auto * r = new t2_mesh_result();
if (pt == T2_PIPE_COARSE) {
// ── coarse path: marching cubes on the 64^3 occupancy ────────────────
if (progress) progress(user, T2_STAGE_MESH, 0, 0);
mc::Mesh mesh = mc::extract(occ.data(), Rout, Rout, Rout, /*iso*/ 0.0f);
if (mesh.verts.empty()) {
copy_err(err, err_len, "empty mesh (no occupied voxels at iso 0)");
delete r; return nullptr;
}
const float inv = 1.0f / (float) Rout;
for (size_t i = 0; i < mesh.verts.size(); ++i) mesh.verts[i] = mesh.verts[i] * inv - 0.5f;
r->verts = std::move(mesh.verts);
r->normals = std::move(mesh.normals);
r->tris = std::move(mesh.tris);
return r;
}
// ── fine / cascade: 64^3 occupancy -> 32^3 voxel scaffold ────────────────
const trellis2_slat_flow_hparams & shp = trellis2_slat_flow_hparams_of(p->slat);
const int ss_res = shp.resolution; // 32
const int ratio = Rout / ss_res; // 2 (max-pool 64 -> 32)
std::vector<int32_t> coords;
for (int x = 0; x < ss_res; ++x)
for (int y = 0; y < ss_res; ++y)
for (int z = 0; z < ss_res; ++z) {
bool any = false;
for (int dx = 0; dx < ratio && !any; ++dx)
for (int dy = 0; dy < ratio && !any; ++dy)
for (int dz = 0; dz < ratio && !any; ++dz) {
const int xi = x*ratio+dx, yi = y*ratio+dy, zi = z*ratio+dz;
const size_t idx = ((size_t) xi * Rout + yi) * Rout + zi;
if (occ[idx] > 0.0f) any = true;
}
if (any) { coords.push_back(x); coords.push_back(y); coords.push_back(z); }
}
int L = (int) (coords.size() / 3);
if (L == 0) { copy_err(err, err_len, "empty voxel scaffold"); delete r; return nullptr; }
// shape-SLAT sampler params (shared LR + HR)
auto make_slp = [&](int stage, uint64_t sd) {
trellis2_ss_sampler_params slp;
if (steps > 0) slp.steps = steps;
if (guidance >= 0) slp.guidance_strength = guidance;
slp.guidance_rescale = 0.5f;
slp.rescale_t = 3.0f;
slp.seed = sd;
slp.verbose = false;
if (progress) {
progress(user, stage, 0, slp.steps);
slp.progress = [](void * u, int step, int total) {
auto * c = (cb_ctx *) u;
c->fn(c->user, c->stage, step, total);
};
cbc.stage = stage;
slp.progress_user = &cbc;
}
return slp;
};
kf_capture kf_lr, kf_hr; // intermediate shape-flow keyframes (opt-in)
// ── LR shape-SLAT flow (512 model, 512-res cond) ─────────────────────────
std::vector<float> slat((size_t) L * shp.in_channels);
{
trellis2_ss_sampler_params slp = make_slp(T2_STAGE_SLAT_FLOW, seed ^ 0x51a7ULL);
if (keyframes > 0) {
kf_lr.stage = T2_STAGE_SLAT_FLOW; kf_lr.res_in = ss_res; kf_lr.channels = shp.in_channels;
kf_lr.norm_mean = shp.norm_mean; kf_lr.norm_std = shp.norm_std; kf_lr.coords = coords;
while ((ss_res << (kf_lr.levels + 1)) <= 128) kf_lr.levels++; // -> 128^3
if (kf_lr.levels < 1) kf_lr.levels = 1;
kf_lr.stride = std::max(1, slp.steps / keyframes);
slp.preview = kf_capture_cb; slp.preview_user = &kf_lr;
}
if (!trellis2_slat_flow_sample(p->slat, L, coords.data(),
cond.data.data(), (int) cond.tokens(), (int) cond.channels(),
&slp, nullptr, /*denormalize*/ true, slat.data(), &e)) {
copy_err(err, err_len, "slat sample: " + e);
delete r; return nullptr;
}
}
const trellis2_shape_dec_hparams & dhp2 = trellis2_shape_dec_hparams_of(p->shapedec);
std::vector<float> dec_feats; // 7-ch decoder output to mesh
std::vector<int32_t> dec_coords;
int grid = 0;
trellis2_dino_cond cond1024; // filled by the cascade branch; reused by texturing
if (pt == T2_PIPE_512) {
// ── 512 fine: decode the LR slat directly at grid 512 ────────────────
if (progress) progress(user, T2_STAGE_SHAPE_DEC, 0, 0);
ensure_decode_vram(p, T2_PIPE_512); // free the flow DiTs if a GPU decode needs the room
if (!trellis2_shape_dec_decode(p->shapedec, slat.data(), L, coords.data(),
dec_feats, dec_coords, nullptr, &e)) {
copy_err(err, err_len, "shape decode: " + e);
delete r; return nullptr;
}
grid = ss_res * dhp2.upscale(); // 32 * 16 = 512
} else {
// ── 1024 cascade: upsample -> quantize -> HR flow -> decode grid 1024 ─
if (progress) progress(user, T2_STAGE_UPSAMPLE, 0, 0);
std::vector<int32_t> up_coords; // 512^3 candidate coords
if (!trellis2_shape_dec_upsample(p->shapedec, slat.data(), L, coords.data(),
/*upsample_times*/ 4, up_coords, &e)) {
copy_err(err, err_len, "shape upsample: " + e);
delete r; return nullptr;
}
// quantize (c+0.5)/512*64 and dedup into the 64^3 HR scaffold
const int lr_res = ss_res * dhp2.upscale(); // 512
const int hr_grid = shp.resolution * 2; // 64 (HR flow resolution)
std::unordered_set<uint64_t> seen;
std::vector<int32_t> hr_coords;
auto key = [](int32_t a, int32_t b, int32_t c) {
return ((uint64_t)(uint32_t)a<<40) | ((uint64_t)(uint32_t)b<<20) | (uint64_t)(uint32_t)c;
};
for (size_t i = 0; i < up_coords.size(); i += 3) {
int32_t qx = (int32_t)((up_coords[i] + 0.5f) / lr_res * hr_grid);
int32_t qy = (int32_t)((up_coords[i + 1] + 0.5f) / lr_res * hr_grid);
int32_t qz = (int32_t)((up_coords[i + 2] + 0.5f) / lr_res * hr_grid);
if (seen.insert(key(qx, qy, qz)).second) {
hr_coords.push_back(qx); hr_coords.push_back(qy); hr_coords.push_back(qz);
}
}
const int Lhr = (int) (hr_coords.size() / 3);
if (Lhr == 0) { copy_err(err, err_len, "empty HR scaffold"); delete r; return nullptr; }
// Sharper 64^3 HR-scaffold checkpoint (the cascade's refined structure).
emit_voxels(preview, preview_user, T2_STAGE_UPSAMPLE, 0, 0, hr_grid, hr_coords);
// 1024-res conditioning (separate preprocess + encode at 1024)
std::vector<unsigned char> rgb1024((size_t) 1024 * 1024 * 3);
if (preprocess_image_bytes_mode(image_bytes, image_len, 1024, rgb1024.data(),
background_mode, perr, sizeof(perr))) {
copy_err(err, err_len, perr); delete r; return nullptr;
}
if (!trellis2_dino_encode_rgb(p->dino, rgb1024.data(), 1024, cond1024, &e)) {
copy_err(err, err_len, "dino encode 1024: " + e); delete r; return nullptr;
}
// HR shape-SLAT flow (1024 model)
const trellis2_slat_flow_hparams & shp_hr = trellis2_slat_flow_hparams_of(p->slat_hr);
std::vector<float> hr_slat((size_t) Lhr * shp_hr.in_channels);
trellis2_ss_sampler_params slp = make_slp(T2_STAGE_SLAT_FLOW_HR, seed ^ 0x1024ULL);
if (keyframes > 0) {
kf_hr.stage = T2_STAGE_SLAT_FLOW_HR; kf_hr.res_in = hr_grid; kf_hr.channels = shp_hr.in_channels;
kf_hr.norm_mean = shp_hr.norm_mean; kf_hr.norm_std = shp_hr.norm_std; kf_hr.coords = hr_coords;
while ((hr_grid << (kf_hr.levels + 1)) <= 128) kf_hr.levels++; // -> 128^3
if (kf_hr.levels < 1) kf_hr.levels = 1;
kf_hr.stride = std::max(1, slp.steps / keyframes);
slp.preview = kf_capture_cb; slp.preview_user = &kf_hr;
}
if (!trellis2_slat_flow_sample(p->slat_hr, Lhr, hr_coords.data(),
cond1024.data.data(), (int) cond1024.tokens(), (int) cond1024.channels(),
&slp, nullptr, /*denormalize*/ true, hr_slat.data(), &e)) {
copy_err(err, err_len, "HR slat sample: " + e);
delete r; return nullptr;
}
if (progress) progress(user, T2_STAGE_SHAPE_DEC_HR, 0, 0);
ensure_decode_vram(p, T2_PIPE_1024); // free the flow DiTs (all done) for the 1024³ decode
if (!trellis2_shape_dec_decode(p->shapedec, hr_slat.data(), Lhr, hr_coords.data(),
dec_feats, dec_coords, nullptr, &e)) {
copy_err(err, err_len, "HR shape decode: " + e);
delete r; return nullptr;
}
grid = hr_grid * dhp2.upscale(); // 64 * 16 = 1024
}
// ── mesh extraction (shared) ─────────────────────────────────────────────
if (progress) progress(user, T2_STAGE_MESH, 0, 0);
const int nvox = (int) (dec_coords.size() / 3);
fdg::Mesh mesh = fdg::extract(dec_feats.data(), dec_coords.data(), nvox, grid);
if (mesh.verts.empty()) {
copy_err(err, err_len, "empty mesh (dual grid found no faces)");
delete r; return nullptr;
}
// Clean up the raw dual-grid soup: drop floating specks, then fill the small
// boundary holes extract() left. Both only edit triangles (no new vertices),
// so the generated material volume can still be sampled at every vertex.
fdg::drop_small_components(mesh);
fdg::fill_holes(mesh);
r->verts = std::move(mesh.verts);
r->tris = std::move(mesh.tris);
r->normals = fdg::vertex_normals(fdg::Mesh{r->verts, r->tris});
// ── shape-flow keyframe replay ───────────────────────────────────────────
// Now is the safe window: the flow DiTs are freed (ensure_decode_vram) and
// the shape decoder owns VRAM, before the texture stage loads its models.
if (preview && keyframes > 0) {
emit_keyframes(p->shapedec, kf_lr, preview, preview_user);
emit_keyframes(p->shapedec, kf_hr, preview, preview_user); // empty for 512
}
// ── PBR texture stage (optional) ─────────────────────────────────────────
if (p->texture && pt != T2_PIPE_COARSE) {
// Free the (finished) geometry flow DiTs so the ~4 GB of tex models fit
// in VRAM; reload_flows() restores them on the next generate.
if (trellis2_gpu_free_vram() > 0) {
if (p->flow) { trellis2_ss_flow_free(p->flow); p->flow = nullptr; }
if (p->slat) { trellis2_slat_flow_free(p->slat); p->slat = nullptr; }
if (p->slat_hr) { trellis2_slat_flow_free(p->slat_hr); p->slat_hr = nullptr; }
}
const trellis2_dino_cond & texcond = (pt == T2_PIPE_1024) ? cond1024 : cond;
std::vector<float> pbr;
std::string te;
if (!run_texture_stage(p, dec_feats, dec_coords, r->verts, grid, pt,
texcond, seed ^ 0x7ec0ULL,
texture_steps, progress, user, pbr, te)) {
copy_err(err, err_len, "texture: " + te);
delete r; return nullptr;
}
r->pbr = std::move(pbr);
}
return r;
}
int t2_mesh_n_verts(const t2_mesh_result * r) { return r ? (int) (r->verts.size() / 3) : 0; }
int t2_mesh_n_tris (const t2_mesh_result * r) { return r ? (int) (r->tris.size() / 3) : 0; }
const float * t2_mesh_verts (const t2_mesh_result * r) { return r ? r->verts.data() : nullptr; }
const float * t2_mesh_normals(const t2_mesh_result * r) { return r ? r->normals.data() : nullptr; }
const int * t2_mesh_tris (const t2_mesh_result * r) { return r ? r->tris.data() : nullptr; }
int t2_mesh_has_pbr(const t2_mesh_result * r) { return (r && !r->pbr.empty()) ? 1 : 0; }
const float * t2_mesh_pbr(const t2_mesh_result * r) { return (r && !r->pbr.empty()) ? r->pbr.data() : nullptr; }
void t2_mesh_free(t2_mesh_result * r) { delete r; }
t2_mesh_result * t2_prepare_mesh(const float * verts, int n_verts,
const int * tris, int n_tris,
const float * pbr,
int component_filter,
char * err, int err_len) {
if (!verts || !tris || n_verts <= 0 || n_tris <= 0) {
copy_err(err, err_len, "empty mesh"); return nullptr;
}
if (component_filter < 0 || component_filter > 2) {
copy_err(err, err_len, "bad component filter"); return nullptr;
}
t2glb::MeshExportOptions opt;
opt.components = (t2glb::ComponentFilter) component_filter;
t2glb::PreparedMesh prepared;
std::string e;
if (!t2glb::prepare_mesh(verts, n_verts, (const int32_t *) tris, n_tris,
pbr, opt, prepared, e)) {
copy_err(err, err_len, e); return nullptr;
}
auto * r = new t2_mesh_result();
r->verts = std::move(prepared.verts);
r->normals = std::move(prepared.normals);
r->tris.assign(prepared.tris.begin(), prepared.tris.end());
r->pbr = std::move(prepared.pbr);
return r;
}
int t2_print_remesh_available(void) {
return t2glb::print_remesh_available() ? 1 : 0;
}
t2_mesh_result * t2_prepare_print_mesh(const float * verts, int n_verts,
const int * tris, int n_tris,
const float * pbr,
int component_filter,
float alpha_ratio,
float offset_ratio,
char * err, int err_len) {
if (!verts || !tris || n_verts <= 0 || n_tris <= 0) {
copy_err(err, err_len, "empty mesh"); return nullptr;
}
if (component_filter < 0 || component_filter > 2) {
copy_err(err, err_len, "bad component filter"); return nullptr;
}
t2glb::MeshExportOptions opt;
opt.components = (t2glb::ComponentFilter) component_filter;
t2glb::PreparedMesh prepared;
std::string e;
if (!t2glb::prepare_print_mesh(verts, n_verts, (const int32_t *) tris, n_tris,
pbr, opt, alpha_ratio, offset_ratio,
prepared, e)) {
copy_err(err, err_len, e); return nullptr;
}
auto * r = new t2_mesh_result();
r->verts = std::move(prepared.verts);
r->normals = std::move(prepared.normals);
r->tris.assign(prepared.tris.begin(), prepared.tris.end());
r->pbr = std::move(prepared.pbr);
return r;
}
uint8_t * t2_bake_glb(const float * verts, int n_verts, const int * tris, int n_tris,
const float * pbr, int texture_size, int component_filter,
int * out_len, char * err, int err_len) {
if (out_len) *out_len = 0;
if (!verts || !tris || n_verts <= 0 || n_tris <= 0) {
copy_err(err, err_len, "empty mesh"); return nullptr;
}
t2glb::MeshExportOptions opt;
if (texture_size > 0) opt.texture_size = texture_size;
if (component_filter < 0 || component_filter > 2) {
copy_err(err, err_len, "bad component filter"); return nullptr;
}
opt.components = (t2glb::ComponentFilter) component_filter;
std::vector<uint8_t> glb;
std::string e;
if (!t2glb::mesh_to_glb(verts, n_verts, tris, n_tris, pbr, opt, glb, e)) {
copy_err(err, err_len, e); return nullptr;
}
uint8_t * buf = (uint8_t *) std::malloc(glb.size());
if (!buf) { copy_err(err, err_len, "out of memory"); return nullptr; }
std::memcpy(buf, glb.data(), glb.size());
if (out_len) *out_len = (int) glb.size();
return buf;
}
uint8_t * t2_bake_projected_glb(const float * target_verts, int target_n_verts,
const int * target_tris, int target_n_tris,
const float * source_verts, int source_n_verts,
const int * source_tris, int source_n_tris,
const float * source_pbr,
int texture_size, int source_component_filter,
int * out_len, char * err, int err_len) {
if (out_len) *out_len = 0;
if (!target_verts || !target_tris || target_n_verts <= 0 || target_n_tris <= 0 ||
!source_verts || !source_tris || !source_pbr || source_n_verts <= 0 || source_n_tris <= 0) {
copy_err(err, err_len, "empty projected GLB mesh"); return nullptr;
}
if (source_component_filter < 0 || source_component_filter > 2) {
copy_err(err, err_len, "bad component filter"); return nullptr;
}
t2glb::MeshExportOptions opt;
if (texture_size > 0) opt.texture_size = texture_size;
opt.components = (t2glb::ComponentFilter) source_component_filter;
std::vector<uint8_t> glb;
std::string e;
if (!t2glb::mesh_to_projected_glb(
target_verts, target_n_verts, (const int32_t *) target_tris, target_n_tris,
source_verts, source_n_verts, (const int32_t *) source_tris, source_n_tris,
source_pbr, opt, glb, e)) {
copy_err(err, err_len, e); return nullptr;
}
uint8_t * buf = (uint8_t *) std::malloc(glb.size());
if (!buf) { copy_err(err, err_len, "out of memory"); return nullptr; }
std::memcpy(buf, glb.data(), glb.size());
if (out_len) *out_len = (int) glb.size();
return buf;
}
void t2_free_buffer(uint8_t * buf) { std::free(buf); }
} // extern "C"
Reference in New Issue View Git Blame Copy Permalink