6#include "tinyvdb_ray.h"
7#include "tinyvdb_sparse_tree.h"
20 void* sys_malloc(
size_t size,
void* )
22 return std::malloc(size);
25 void* sys_realloc(
void* ptr,
size_t ,
size_t size,
void* )
27 return std::realloc(ptr, size);
30 void sys_free(
void* ptr,
size_t ,
void* )
44 tvdb_allocator_t make_allocator()
46 tvdb_allocator_t alloc;
47 std::memset(&alloc, 0,
sizeof(alloc));
48 alloc.malloc_fn = &sys_malloc;
49 alloc.realloc_fn = &sys_realloc;
50 alloc.free_fn = &sys_free;
51 alloc.user_ctx =
nullptr;
55 constexpr const char* grid_type_token(
bool is_vector)
57 return is_vector ?
"Tree_vec3s_5_4_3" :
"Tree_float_5_4_3";
67 tvdb_value_type_t leaf_value_type(
const tvdb_grid_t& grid)
69 const int levels = grid.tree.layout.num_levels;
71 return TVDB_VALUE_NULL;
73 return grid.tree.layout.levels[levels - 1].value_type;
76 constexpr bool is_vector_type(tvdb_value_type_t vt)
78 return vt == TVDB_VALUE_VEC3F || vt == TVDB_VALUE_VEC3D || vt == TVDB_VALUE_VEC3I;
81 constexpr bool needs_narrowing(tvdb_value_type_t vt)
83 return vt != TVDB_VALUE_FLOAT && vt != TVDB_VALUE_VEC3F;
95 glm::vec3 grid_voxel_size(
const tvdb_transform_t& t)
98 case TVDB_TRANSFORM_UNIFORM_SCALE:
99 case TVDB_TRANSFORM_UNIFORM_SCALE_TRANSLATE:
100 return glm::vec3(
static_cast<float>(t.voxel_size[0]));
101 case TVDB_TRANSFORM_SCALE:
102 case TVDB_TRANSFORM_SCALE_TRANSLATE:
104 static_cast<float>(t.voxel_size[0]),
105 static_cast<float>(t.voxel_size[1]),
106 static_cast<float>(t.voxel_size[2]),
108 case TVDB_TRANSFORM_AFFINE:
110 static_cast<float>(t.matrix[0][0]),
111 static_cast<float>(t.matrix[1][1]),
112 static_cast<float>(t.matrix[2][2]),
114 case TVDB_TRANSFORM_TRANSLATION:
116 return glm::vec3(1.0F);
128 glm::vec3 grid_translation(
const tvdb_transform_t& t)
131 case TVDB_TRANSFORM_UNIFORM_SCALE_TRANSLATE:
132 case TVDB_TRANSFORM_SCALE_TRANSLATE:
133 case TVDB_TRANSFORM_TRANSLATION:
135 static_cast<float>(t.translation[0]),
136 static_cast<float>(t.translation[1]),
137 static_cast<float>(t.translation[2]),
139 case TVDB_TRANSFORM_AFFINE:
141 static_cast<float>(t.matrix[0][3]),
142 static_cast<float>(t.matrix[1][3]),
143 static_cast<float>(t.matrix[2][3]),
146 return glm::vec3(0.0F);
159 CastResult<float> narrow_scalar(tvdb_value_type_t vt,
const void* bytes)
162 case TVDB_VALUE_FLOAT: {
164 std::memcpy(&v, bytes,
sizeof(v));
165 return try_convert<float>(v);
167 case TVDB_VALUE_DOUBLE: {
169 std::memcpy(&v, bytes,
sizeof(v));
170 return try_convert<float>(v);
172 case TVDB_VALUE_INT32: {
174 std::memcpy(&v, bytes,
sizeof(v));
175 return try_convert<float>(v);
177 case TVDB_VALUE_INT64: {
179 std::memcpy(&v, bytes,
sizeof(v));
180 return try_convert<float>(v);
182 case TVDB_VALUE_BOOL: {
184 std::memcpy(&v, bytes,
sizeof(v));
185 return try_convert<float>(v != 0);
187 case TVDB_VALUE_HALF: {
189 std::memcpy(&v, bytes,
sizeof(v));
190 CastResult<float> result;
195 CastResult<float> result;
212 struct VectorNarrowResult {
213 glm::vec3 value { 0.0F };
214 bool precision_loss {
false };
217 VectorNarrowResult narrow_vector(tvdb_value_type_t vt,
const void* bytes)
220 case TVDB_VALUE_VEC3F: {
222 std::memcpy(v, bytes,
sizeof(v));
223 return { { v[0], v[1], v[2] },
false };
225 case TVDB_VALUE_VEC3D: {
227 std::memcpy(v, bytes,
sizeof(v));
228 const auto cx = try_convert<float>(v[0]);
229 const auto cy = try_convert<float>(v[1]);
230 const auto cz = try_convert<float>(v[2]);
232 { cx.value.value_or(0.0F), cy.value.value_or(0.0F), cz.value.value_or(0.0F) },
233 cx.precision_loss || cy.precision_loss || cz.precision_loss,
236 case TVDB_VALUE_VEC3I: {
238 std::memcpy(v, bytes,
sizeof(v));
239 const auto cx = try_convert<float>(v[0]);
240 const auto cy = try_convert<float>(v[1]);
241 const auto cz = try_convert<float>(v[2]);
243 { cx.value.value_or(0.0F), cy.value.value_or(0.0F), cz.value.value_or(0.0F) },
244 cx.precision_loss || cy.precision_loss || cz.precision_loss,
263 float grid_background_scalar(
const tvdb_grid_t& grid)
265 if (grid.tree.num_nodes == 0) {
268 const tvdb_value_t& bg = grid.tree.nodes[0].u.root.background;
269 return narrow_scalar(bg.type, &bg.u).value.value_or(0.0F);
272 glm::vec3 grid_background_vector(
const tvdb_grid_t& grid)
274 if (grid.tree.num_nodes == 0) {
275 return glm::vec3(0.0F);
277 const tvdb_value_t& bg = grid.tree.nodes[0].u.root.background;
278 return narrow_vector(bg.type, &bg.u).value;
287 glm::ivec3 min { 0 };
288 glm::ivec3 max { 0 };
289 bool has_any {
false };
292 int bbox_visit(
const tvdb_leaf_view_t* leaf,
void* user)
294 auto* acc =
static_cast<BBoxAcc*
>(user);
295 const int32_t dim = 1 << leaf->log2dim;
296 const glm::ivec3 lo(leaf->origin[0], leaf->origin[1], leaf->origin[2]);
297 const glm::ivec3 hi = lo + glm::ivec3(dim);
304 acc->min = glm::min(acc->min, lo);
305 acc->max = glm::max(acc->max, hi);
320 glm::ivec3 region_min;
321 glm::ivec3 region_max;
322 tvdb_value_type_t vt;
324 bool* precision_lost {
nullptr };
327 struct DenseScalarCtx : DenseCtx {
328 std::vector<float>* out;
331 struct DenseVectorCtx : DenseCtx {
332 std::vector<glm::vec3>* out;
339 glm::ivec3 leaf_slot_coord(
const tvdb_leaf_view_t& leaf, int32_t s)
341 const int32_t log2dim = leaf.log2dim;
342 const int32_t mask = (1 << log2dim) - 1;
344 leaf.origin[0] + ((s >> (2 * log2dim)) & mask),
345 leaf.origin[1] + ((s >> log2dim) & mask),
346 leaf.origin[2] + (s & mask),
350 int dense_scalar_visit(
const tvdb_leaf_view_t* leaf,
void* user)
352 auto* ctx =
static_cast<DenseScalarCtx*
>(user);
353 const int32_t nslots = 1 << (3 * leaf->log2dim);
354 const auto* base =
reinterpret_cast<const uint8_t*
>(leaf->data);
355 const glm::ivec3 res = ctx->region_max - ctx->region_min;
357 for (int32_t s = 0; s < nslots; ++s) {
358 if (!tvdb_nodemask_is_on(leaf->value_mask, s)) {
361 const glm::ivec3 world = leaf_slot_coord(*leaf, s);
362 if (glm::any(glm::lessThan(world, ctx->region_min))
363 || glm::any(glm::greaterThanEqual(world, ctx->region_max))) {
366 const glm::ivec3 local = world - ctx->region_min;
367 const size_t index = (
static_cast<size_t>(local.z) * res.y + local.y) * res.x + local.x;
368 const auto converted = narrow_scalar(ctx->vt, base +
static_cast<size_t>(s) * ctx->elem_size);
369 (*ctx->out)[index] = converted.value.value_or(0.0F);
370 if (converted.precision_loss && ctx->precision_lost) {
371 *ctx->precision_lost =
true;
377 int dense_vector_visit(
const tvdb_leaf_view_t* leaf,
void* user)
379 auto* ctx =
static_cast<DenseVectorCtx*
>(user);
380 const int32_t nslots = 1 << (3 * leaf->log2dim);
381 const auto* base =
reinterpret_cast<const uint8_t*
>(leaf->data);
382 const glm::ivec3 res = ctx->region_max - ctx->region_min;
384 for (int32_t s = 0; s < nslots; ++s) {
385 if (!tvdb_nodemask_is_on(leaf->value_mask, s)) {
388 const glm::ivec3 world = leaf_slot_coord(*leaf, s);
389 if (glm::any(glm::lessThan(world, ctx->region_min))
390 || glm::any(glm::greaterThanEqual(world, ctx->region_max))) {
393 const glm::ivec3 local = world - ctx->region_min;
394 const size_t index = (
static_cast<size_t>(local.z) * res.y + local.y) * res.x + local.x;
395 const auto converted = narrow_vector(ctx->vt, base +
static_cast<size_t>(s) * ctx->elem_size);
396 (*ctx->out)[index] = converted.value;
397 if (converted.precision_loss && ctx->precision_lost) {
398 *ctx->precision_lost =
true;
404 constexpr size_t element_width(
bool is_vector)
406 return is_vector ?
sizeof(glm::vec3) : sizeof(float);
416 tvdb_grid_t make_template(
417 const Kinesis::Lattice3D& lattice,
bool is_vector,
char* grid_type)
420 std::memset(&tmpl, 0,
sizeof(tmpl));
422 std::strcpy(grid_type, grid_type_token(is_vector));
423 tmpl.descriptor.grid_type = grid_type;
425 const tvdb_value_type_t vt = is_vector ? TVDB_VALUE_VEC3F : TVDB_VALUE_FLOAT;
427 tmpl.tree.layout.num_levels = 4;
428 tmpl.tree.layout.levels[0].node_type = TVDB_NODE_ROOT;
429 tmpl.tree.layout.levels[1].node_type = TVDB_NODE_INTERNAL;
430 tmpl.tree.layout.levels[2].node_type = TVDB_NODE_INTERNAL;
431 tmpl.tree.layout.levels[3].node_type = TVDB_NODE_LEAF;
432 tmpl.tree.layout.levels[0].log2dim = 0;
433 tmpl.tree.layout.levels[1].log2dim = 5;
434 tmpl.tree.layout.levels[2].log2dim = 4;
435 tmpl.tree.layout.levels[3].log2dim = 3;
436 for (
int lv = 0; lv < 4; ++lv) {
437 tmpl.tree.layout.levels[lv].value_type = vt;
440 const glm::vec3 cell = lattice.cell_size();
441 const glm::vec3 origin = lattice.bounds.min + 0.5F * cell;
443 tmpl.transform.type = TVDB_TRANSFORM_SCALE_TRANSLATE;
444 for (
int axis = 0; axis < 3; ++axis) {
445 tmpl.transform.scale_values[axis] = cell[axis];
446 tmpl.transform.voxel_size[axis] = cell[axis];
447 tmpl.transform.translation[axis] = origin[axis];
476 std::deque<std::vector<tvdb_meta_entry_t>>
entries;
490 for (
auto& grid :
m_state->grids) {
491 grid.metadata.entries =
nullptr;
492 grid.metadata.count = 0;
493 grid.metadata.capacity = 0;
494 tvdb_grid_destroy_owned(&grid);
498 tvdb_file_close(&
m_state->read_file);
510 const size_t width = element_width(spec.
is_vector);
513 +
"': value bytes do not match coordinate count";
518 +
"': background is the wrong width";
522 static_assert(
sizeof(glm::ivec3) ==
sizeof(tvdb_vec3i),
523 "glm::ivec3 and tvdb_vec3i must be layout compatible for the "
524 "coordinate span to be passed through without a copy");
526 auto& type_token =
m_state->type_tokens.emplace_back();
527 tvdb_grid_t tmpl = make_template(lattice, spec.
is_vector, type_token.data());
529 const std::string name(spec.
name);
532 const bool ok = tvdb_grid_from_sparse_typed_using_template(
534 reinterpret_cast<const tvdb_vec3i*
>(spec.
coords.data()),
537 spec.
is_vector ? TVDB_VALUE_VEC3F : TVDB_VALUE_FLOAT,
543 m_last_error =
"grid '" + name +
"': tree build failed";
547 auto& list =
m_state->entries.emplace_back();
548 list.reserve(spec.
metadata.size() + 1);
550 auto add_entry = [&](std::string_view key, std::string_view value) {
551 std::string& k =
m_state->strings.emplace_back(key);
552 std::string& t =
m_state->strings.emplace_back(
"string");
553 std::string& v =
m_state->strings.emplace_back(value);
555 tvdb_meta_entry_t entry;
556 std::memset(&entry, 0,
sizeof(entry));
557 entry.name = k.data();
558 entry.type_name = t.data();
559 entry.value.type = TVDB_VALUE_STRING;
560 entry.value.u.s.str = v.data();
561 entry.value.u.s.len = v.size();
562 list.push_back(entry);
567 add_entry(
"name", spec.
name);
569 for (
const auto& [key, value] : spec.
metadata) {
570 add_entry(key, value);
573 grid.metadata.entries = list.data();
574 grid.metadata.count = list.size();
575 grid.metadata.capacity = list.size();
576 grid.metadata.alloc =
nullptr;
578 m_state->grids.push_back(grid);
590 std::memset(&out, 0,
sizeof(out));
591 out.alloc = make_allocator();
592 out.num_grids =
m_state->grids.size();
593 out.grids =
m_state->grids.data();
596 std::memset(&err, 0,
sizeof(err));
598 const tvdb_status_t st = tvdb_file_save(
599 &out, path.c_str(), compression, level, 0, &err);
603 + (err.message[0] !=
'\0' ? err.message :
"unknown");
617 tvdb_file_close(&
m_state->read_file);
618 m_state->read_file_open =
false;
622 std::memset(&err, 0,
sizeof(err));
624 if (tvdb_file_open(&
m_state->read_file, path.c_str(),
nullptr, &err) != TVDB_OK) {
626 + (err.message[0] !=
'\0' ? err.message :
"unknown");
629 m_state->read_file_open =
true;
631 if (tvdb_read_all_grids(&
m_state->read_file, &err) != TVDB_OK) {
633 + (err.message[0] !=
'\0' ? err.message :
"unknown");
634 tvdb_file_close(&
m_state->read_file);
635 m_state->read_file_open =
false;
644 return m_state->read_file_open ? tvdb_grid_count(&
m_state->read_file) : 0;
651 if (!
m_state->read_file_open || index >=
m_state->read_file.num_grids) {
655 const tvdb_grid_t& grid =
m_state->read_file.grids[index];
657 const char* name = tvdb_grid_name(&
m_state->read_file, index);
658 out.
name = name ? name :
"";
660 const tvdb_value_type_t vt = leaf_value_type(grid);
664 out.
voxel_size = grid_voxel_size(grid.transform);
665 out.
translation = grid_translation(grid.transform);
668 tvdb_grid_visit_leaves(&grid, bbox_visit, &acc);
681 if (!
m_state->read_file_open || index >=
m_state->read_file.num_grids) {
685 const tvdb_grid_t& grid =
m_state->read_file.grids[index];
687 for (
size_t i = 0; i < grid.metadata.count; ++i) {
688 const tvdb_meta_entry_t& entry = grid.metadata.entries[i];
689 if (!entry.name || key != entry.name) {
692 if (entry.value.type != TVDB_VALUE_STRING || !entry.value.u.s.str) {
695 return { entry.value.u.s.str, entry.value.u.s.len };
702 const glm::ivec3& region_min,
703 const glm::uvec3& resolution,
705 std::vector<float>& out,
706 bool* precision_lost)
const
708 if (!
m_state->read_file_open || index >=
m_state->read_file.num_grids) {
709 m_last_error =
"read_dense_scalar: grid index out of range";
712 if (resolution.x == 0 || resolution.y == 0 || resolution.z == 0) {
717 const tvdb_grid_t& grid =
m_state->read_file.grids[index];
718 const tvdb_value_type_t vt = leaf_value_type(grid);
720 if (is_vector_type(vt)) {
721 const char* name = tvdb_grid_name(&
m_state->read_file, index);
722 m_last_error =
"read_dense_scalar: grid '" + std::string(name ? name :
"") +
"' is vector-typed";
725 const size_t elem_size = tvdb_value_type_size(vt);
726 if (elem_size == 0) {
727 m_last_error =
"read_dense_scalar: grid has an unsupported leaf value type";
731 if (precision_lost) {
732 *precision_lost =
false;
735 out.assign(
static_cast<size_t>(resolution.x) * resolution.y * resolution.z, background);
737 DenseScalarCtx ctx {};
738 ctx.region_min = region_min;
739 ctx.region_max = region_min + glm::ivec3(resolution);
741 ctx.elem_size = elem_size;
742 ctx.precision_lost = precision_lost;
745 tvdb_grid_visit_leaves(&grid, dense_scalar_visit, &ctx);
751 const glm::ivec3& region_min,
752 const glm::uvec3& resolution,
753 const glm::vec3& background,
754 std::vector<glm::vec3>& out,
755 bool* precision_lost)
const
757 if (!
m_state->read_file_open || index >=
m_state->read_file.num_grids) {
758 m_last_error =
"read_dense_vector: grid index out of range";
761 if (resolution.x == 0 || resolution.y == 0 || resolution.z == 0) {
766 const tvdb_grid_t& grid =
m_state->read_file.grids[index];
767 const tvdb_value_type_t vt = leaf_value_type(grid);
769 if (!is_vector_type(vt)) {
770 const char* name = tvdb_grid_name(&
m_state->read_file, index);
771 m_last_error =
"read_dense_vector: grid '" + std::string(name ? name :
"") +
"' is scalar-typed";
774 const size_t elem_size = tvdb_value_type_size(vt);
775 if (elem_size == 0) {
776 m_last_error =
"read_dense_vector: grid has an unsupported leaf value type";
780 if (precision_lost) {
781 *precision_lost =
false;
784 out.assign(
static_cast<size_t>(resolution.x) * resolution.y * resolution.z, background);
786 DenseVectorCtx ctx {};
787 ctx.region_min = region_min;
788 ctx.region_max = region_min + glm::ivec3(resolution);
790 ctx.elem_size = elem_size;
791 ctx.precision_lost = precision_lost;
794 tvdb_grid_visit_leaves(&grid, dense_vector_visit, &ctx);
bool save(const std::string &path, uint32_t compression, int level)
Write every added grid to one file.
std::string grid_metadata(size_t index, std::string_view key) const
Look up a string-typed metadata entry on a grid.
bool read_dense_scalar(size_t index, const glm::ivec3 ®ion_min, const glm::uvec3 &resolution, float background, std::vector< float > &out, bool *precision_lost=nullptr) const
Materialize a scalar grid's cells over an explicit region.
std::string m_last_error
Set from the const read-path accessors too.
std::unique_ptr< State > m_state
bool read_dense_vector(size_t index, const glm::ivec3 ®ion_min, const glm::uvec3 &resolution, const glm::vec3 &background, std::vector< glm::vec3 > &out, bool *precision_lost=nullptr) const
Materialize a vector grid's cells over an explicit region.
VDBGridSummary grid_summary(size_t index) const
Summarize one grid: name, value kind, transform, active bounds.
size_t grid_count() const
bool add_grid(const Kinesis::Lattice3D &lattice, const VDBGridSpec &spec)
Build one grid from active cells and retain it for saving.
bool open(const std::string &path)
Open a .vdb and read every grid's tree into memory.
size_t read_grid_count() const
Number of grids in the opened file, or 0 if none is open.
float half_to_float(uint16_t bits) noexcept
IEEE 754 binary16 to binary32.
std::deque< std::string > strings
std::deque< std::vector< tvdb_meta_entry_t > > entries
std::vector< tvdb_grid_t > grids
std::deque< std::array< char, 32 > > type_tokens
Built grids and the storage their borrowed pointers refer into.
std::span< const std::byte > values
std::span< const glm::ivec3 > coords
std::span< const std::byte > background
std::span< const std::pair< std::string, std::string > > metadata
One grid's worth of input to VDBArchive::add_grid.
glm::vec3 background_vector
glm::ivec3 active_max
Exclusive.
What a reader needs to know about one grid in an opened file, before deciding how to materialize it.
A regular subdivision of an AABB3D into a cell count per axis.