summaryrefslogtreecommitdiff
path: root/models.ha
diff options
context:
space:
mode:
Diffstat (limited to 'models.ha')
-rw-r--r--models.ha653
1 files changed, 653 insertions, 0 deletions
diff --git a/models.ha b/models.ha
new file mode 100644
index 0000000..71a8e05
--- /dev/null
+++ b/models.ha
@@ -0,0 +1,653 @@
+use dejson;
+use encoding::json;
+use glm;
+use math;
+use strings;
+use trace;
+
+type Model = struct {
+ Object,
+ decl: nullable *ModelDecl,
+ parent: nullable *Model,
+ geom: nullable *ModelGeom,
+ owns_geom: bool,
+ textures: []*Sprite,
+};
+
+type ModelGeom = struct {
+ textures: []str,
+ faces: []Face,
+};
+
+type Face = struct {
+ dir: Dir, // used for uvlock; probably a temporary hack.
+ cull_face: CullFace,
+ texture: u8,
+ normal: [3]i8,
+ texcoord: [4]u8,
+ rotation: u8,
+ vertices: [4][3]u16,
+};
+
+type CullFace = enum u8 {
+ WEST,
+ EAST,
+ DOWN,
+ UP,
+ NORTH,
+ SOUTH,
+ NONE,
+};
+
+let MODELS = OBJREG_EMPTY;
+
+fn models_find(ident: str) nullable *Model =
+ objreg_find(&MODELS, ident): nullable *Model;
+
+type ModelsIter = struct {
+ inner: ObjectRegistryIterator,
+};
+
+fn models_iter() ModelsIter =
+ ModelsIter { inner = objreg_iter(&MODELS) };
+
+fn models_next(it: *ModelsIter) nullable *Model =
+ objreg_next(&it.inner): nullable *Model;
+
+fn load_models(assets: *Pack) void = {
+ const tr = &trace::root;
+ trace::info(tr, "loading models...");
+
+ objreg_register(&MODELS, alloc(Model {
+ name = strings::dup(BUILTIN_MISSING),
+ ...
+ }));
+ objreg_register(&MODELS, alloc(Model {
+ name = strings::dup("minecraft:builtin/entity"),
+ ...
+ }));
+ objreg_register(&MODELS, alloc(Model {
+ name = strings::dup("minecraft:builtin/generated"),
+ ...
+ }));
+
+ const results = resource_search(assets, "models", ".json");
+ for (let i = 0z; i < len(results); i+= 1) {
+ const (ident, ext) = results[i];
+
+ const tr = trace::ctx(tr, "load model {}", ident);
+
+ const model = alloc(Model {
+ name = strings::dup(ident),
+ ...
+ });
+ objreg_register(&MODELS, model);
+
+ const json = match (resource_load_json(
+ assets, "models", ident, ".json", &tr)) {
+ case let json: json::value =>
+ yield json;
+ case trace::failed =>
+ continue;
+ };
+ defer json::finish(json);
+
+ const decl = {
+ const deser = dejson::newdeser(&json);
+ yield match (deser_model_decl(&deser)) {
+ case let x: ModelDecl =>
+ yield x;
+ case let err: dejson::error =>
+ defer free(err);
+ trace::error(&tr, "deser: {}", ident, err): void;
+ continue;
+ };
+ };
+
+ model.decl = alloc(decl);
+ };
+
+ let it = models_iter();
+ for (true) match (models_next(&it)) {
+ case let model: *Model =>
+ if (model.decl == null)
+ model.decl = alloc(missingno_model_decl());
+ case null => break;
+ };
+
+ let it = models_iter();
+ for (true) match (models_next(&it)) {
+ case let model: *Model =>
+ const tr = trace::ctx(tr, "load model {}", model.name);
+
+ const decl = model.decl as *ModelDecl;
+
+ match (decl.parent) {
+ case let parent: str =>
+ model.parent = models_find(parent);
+ if (model.parent == null) {
+ trace::error(&tr, "Unknown parent {}", parent): void;
+ model.parent =
+ models_find(BUILTIN_MISSING) as *Model;
+ };
+ case void => void;
+ };
+
+ const elements = match (decl.elements) {
+ case let elements: []ModelDeclElement =>
+ yield elements;
+ case void => void;
+ if (model.parent == null)
+ yield []: []ModelDeclElement;
+ yield void; // TODO: harec bug?
+ };
+
+ match (elements) {
+ case let elements: []ModelDeclElement =>
+ model.geom = alloc(build_model_geom(elements));
+ model.owns_geom = true;
+ case void => void;
+ };
+ case null => break;
+ };
+
+ let it = models_iter();
+ for (true) match (models_next(&it)) {
+ case let model: *Model =>
+ const tr = trace::ctx(tr, "load model {}", model.name);
+
+ if (model.geom == null) {
+ let i = model.parent;
+ for (true) match (i) {
+ case let model_: *Model =>
+ i = model_.parent;
+ match (model_.geom) {
+ case let geom: *ModelGeom =>
+ model.geom = geom;
+ break;
+ case null => void;
+ };
+ case null => abort();
+ };
+ };
+ const geom = model.geom as *ModelGeom;
+
+ model.textures = alloc([], len(geom.textures));
+
+ for (let i = 0z; i < len(geom.textures); i += 1) {
+ const spr = model_resolve_texture_name(
+ model, geom.textures[i], &tr);
+ const spr = match (spr) {
+ case let spr: *Sprite =>
+ yield spr;
+ case trace::failed =>
+ yield atlas_findsprite(&ATLAS_BLOCKS,
+ MISSINGNO) as *Sprite;
+ };
+ static append(model.textures, spr);
+ };
+ case null => break;
+ };
+};
+
+fn build_model_geom(elements: []ModelDeclElement) ModelGeom = {
+ // west, east, down, up, north, south
+ // (naxis, uaxis, vaxis, vertices)
+ // vertices = [top_left, bottom_left, bottom_right, top_right]
+ // vertices[_] = 0bZYX where 0: from, 1: to
+ static const face_info: [6](u8, u8, u8, [4]u8) = [
+ (0, 2, 1, [0b010, 0b000, 0b100, 0b110]),
+ (0, 2, 1, [0b111, 0b101, 0b001, 0b011]),
+ (1, 0, 2, [0b100, 0b000, 0b001, 0b101]),
+ (1, 0, 2, [0b010, 0b110, 0b111, 0b011]),
+ (2, 0, 1, [0b011, 0b001, 0b000, 0b010]),
+ (2, 0, 1, [0b110, 0b100, 0b101, 0b111]),
+ ];
+
+ let textures: []str = [];
+ let faces: []Face = [];
+
+ for (let i = 0z; i < len(elements); i += 1) {
+ const element = &elements[i];
+
+ let trans = glm::m4_new_ident();
+
+ let (rot_axis, rescale_axes): ([3]f32, [3]f32) =
+ switch (element.rot_axis) {
+ case Axis::X =>
+ yield ([1.0, 0.0, 0.0], [0.0, 1.0, 1.0]);
+ case Axis::Y =>
+ yield ([0.0, 1.0, 0.0], [1.0, 0.0, 1.0]);
+ case Axis::Z =>
+ yield ([0.0, 0.0, 1.0], [1.0, 1.0, 0.0]);
+ };
+ glm::translate(&trans, &({
+ let v = element.rot_origin;
+ glm::v3_negate(&v);
+ yield v;
+ }));
+ const angle = glm::rad(element.rot_angle);
+ glm::rotate(&trans, angle, &rot_axis);
+ if (element.rot_rescale) {
+ const sin = math::sinf64(angle): f32;
+ const cos = math::cosf64(angle): f32;
+ const rescale = 1.0
+ / (if (cos > sin) cos else sin)
+ - 1.0;
+ glm::v3_scale(&rescale_axes, rescale);
+ rescale_axes = glm::v3_add(&rescale_axes,
+ &glm::v3_new(1.0, 1.0, 1.0));
+ glm::scale(&trans, &rescale_axes);
+ };
+ glm::translate(&trans, &element.rot_origin);
+
+ const from = element.from;
+ const to = element.to;
+ const from_to = [from, to];
+
+ let vertices: [8][3]u16 = [[0...]...];
+ for (let j = 0z; j < 8; j += 1) {
+ let v: [3]f32 = [from_to[j & 1][0],
+ from_to[j >> 1 & 1][1],
+ from_to[j >> 2 & 1][2]];
+ v = glm::affine_mul_v3(&trans, &v);
+ for (let k = 0z; k < 3; k += 1)
+ vertices[j][k] = ((v[k] + 16.0) * 128.0): u16;
+ };
+
+ for (let j = 0z; j < 6; j += 1) {
+ const finfo = &face_info[j];
+ const naxis = finfo.0;
+ const uaxis = finfo.1;
+ const vaxis = finfo.2;
+ const faceverts = &finfo.3;
+
+ const face = match (element.faces[j]) {
+ case let x: ModelDeclFace =>
+ yield x;
+ case void =>
+ continue;
+ };
+
+ let texnum = 0u8;
+ for (texnum < len(textures); texnum += 1) {
+ if (textures[texnum] == face.texture) {
+ break;
+ };
+ };
+ if (texnum == len(textures)) {
+ append(textures, face.texture);
+ };
+
+ let normal: [3]f32 = [0.0...];
+ normal[naxis] = if (faceverts[0] & 1 << naxis != 0)
+ 127.0 else -127.0;
+ normal = glm::affine_mul_v3(&trans, &normal);
+ const intnormal =
+ [normal[0]: i8, normal[1]: i8, normal[2]: i8];
+
+ const uv: [4]f32 = match (face.uv) {
+ case let uv: [4]f32 =>
+ yield uv;
+ case void =>
+ const u = if (faceverts[0] & 1 << uaxis == 0)
+ [from[uaxis], to[uaxis]] else
+ [16.0 - to[uaxis], 16.0 - from[uaxis]];
+ const v = if (faceverts[0] & 1 << vaxis == 0)
+ [from[vaxis], to[vaxis]] else
+ [16.0 - to[vaxis], 16.0 - from[vaxis]];
+ yield [u[0], v[0], u[1], v[1]];
+ };
+
+ let intuv: [4]u8 = [0...];
+ for (let k = 0z; k < 4; k += 1) {
+ const a = uv[k];
+ if (a < 0.0) a = 0.0;
+ if (a > 16.0) a = 16.0;
+ intuv[k] = (a * 8.0): u8;
+ };
+
+ append(faces, Face {
+ dir = j: Dir,
+ cull_face = face.cull_face,
+ texture = texnum,
+ normal = intnormal,
+ texcoord = intuv,
+ rotation = face.rotation,
+ vertices = [
+ vertices[faceverts[0]],
+ vertices[faceverts[1]],
+ vertices[faceverts[2]],
+ vertices[faceverts[3]],
+ ],
+ });
+ };
+ };
+
+ return ModelGeom {
+ textures = textures,
+ faces = faces,
+ };
+};
+
+fn model_resolve_texture_name(model: *Model, name: str, tr: *trace::tracer)
+ (*Sprite | trace::failed) = {
+ let names: []str = [];
+ defer free(names);
+ let model_ = model;
+ for :resolve (true) {
+ if (!strings::hasprefix(name, '#')) break;
+ const var = strings::trimprefix(name, "#");
+
+ const decl = model_.decl as *ModelDecl;
+
+ for (let j = 0z; j < len(decl.textures); j += 1) {
+ if (decl.textures[j].0 != var) {
+ continue;
+ };
+
+ name = decl.textures[j].1;
+
+ for (let k = 0z; k < len(names); k += 1) {
+ if (names[k] == name) {
+ break :resolve;
+ };
+ };
+ append(names, name);
+
+ model_ = model;
+ continue :resolve;
+ };
+
+ match (model_.parent) {
+ case let parent: *Model =>
+ model_ = parent;
+ case null => break;
+ };
+ };
+
+ if (strings::hasprefix(name, "#")) {
+ return trace::error(tr, "Failed to resolve texture name {}", name);
+ };
+
+ const texident = ident_qual(name);
+ defer free(texident);
+
+ match (atlas_findsprite(&ATLAS_BLOCKS, texident)) {
+ case let spr: *Sprite =>
+ return spr;
+ case null =>
+ return trace::error(tr, "Unknown texture {}", texident);
+ };
+};
+
+type ModelDecl = struct {
+ parent: (str | void),
+ textures: [](str, str),
+ elements: ([]ModelDeclElement | void),
+};
+
+type ModelDeclElement = struct {
+ from: [3]f32,
+ to: [3]f32,
+ rot_origin: [3]f32,
+ rot_axis: Axis,
+ rot_angle: f32,
+ rot_rescale: bool,
+ faces: [6](ModelDeclFace | void), // west, east, down, up, north, south
+};
+
+type Axis = enum u8 {
+ X,
+ Y,
+ Z,
+};
+
+type ModelDeclFace = struct {
+ uv: ([4]f32 | void),
+ rotation: u8, // [0,4) 90° steps
+ texture: str,
+ cull_face: CullFace,
+};
+
+fn model_decl_finish(decl: ModelDecl) void = {
+ match (decl.parent) {
+ case let parent: str =>
+ free(parent);
+ case void => void;
+ };
+ for (let i = 0z; i < len(decl.textures); i += 1) {
+ free(decl.textures[i].0);
+ free(decl.textures[i].1);
+ };
+
+ match (decl.elements) {
+ case let elements: []ModelDeclElement =>
+ for (let i = 0z; i < len(elements); i += 1) {
+ model_decl_element_finish(elements[i]);
+ };
+ case void => void;
+ };
+};
+
+fn model_decl_element_finish(element: ModelDeclElement) void = {
+ for (let i = 0z; i < 6; i += 1) {
+ match (element.faces[i]) {
+ case let face: ModelDeclFace =>
+ free(face.texture);
+ case void => void;
+ };
+ };
+};
+
+fn missingno_model_decl() ModelDecl = {
+ let faces: [6](ModelDeclFace | void) = [void...];
+ for (let i = 0u8; i < 6; i += 1) {
+ faces[i] = ModelDeclFace {
+ uv = void,
+ rotation = 0,
+ texture = strings::dup(MISSINGNO),
+ cull_face = i: CullFace,
+ };
+ };
+ return ModelDecl {
+ parent = void,
+ textures = [],
+ elements = alloc([ModelDeclElement {
+ from = [0.0...],
+ to = [16.0...],
+ rot_origin = [0.0...],
+ rot_axis = Axis::X,
+ rot_angle = 0.0,
+ rot_rescale = false,
+ faces = faces,
+ }]),
+ };
+};
+
+fn deser_model_decl(de: *dejson::deser) (ModelDecl | dejson::error) = {
+ let success = false;
+ wassert_fields(de, "parent", "textures", "elements")?;
+
+ let res = ModelDecl {
+ parent = void,
+ elements = void,
+ ...
+ };
+ defer if (!success) model_decl_finish(res);
+ match (dejson::optfield(de, "parent")?) {
+ case let de_parent: dejson::deser =>
+ res.parent = ident_qual(dejson::string(&de_parent)?);
+ case void => void;
+ };
+
+ match (dejson::optfield(de, "textures")?) {
+ case let de_textures: dejson::deser =>
+ res.textures = alloc([], dejson::count(&de_textures)?);
+ let it = dejson::iter(&de_textures)?;
+ for (true) match (dejson::next(&it)) {
+ case let entry: (str, dejson::deser) =>
+ const var = strings::dup(entry.0);
+ const tex = strings::dup(dejson::string(&entry.1)?);
+ append(res.textures, (var, tex));
+ case void => break;
+ };
+ case void => void;
+ };
+
+ match (dejson::optfield(de, "elements")?) {
+ case let de_elements: dejson::deser =>
+ const nelements = dejson::length(&de_elements)?;
+ res.elements = alloc([], nelements);
+ for (let i = 0z; i < nelements; i += 1) {
+ // XXX: waiting for tagged union overhaul...
+ let elements = res.elements: []ModelDeclElement;
+ append(elements, deser_model_decl_element(
+ &dejson::index(&de_elements, i)?)?);
+ res.elements = elements;
+ };
+ case void => void;
+ };
+
+ success = true;
+ return res;
+};
+
+fn deser_model_decl_element(de: *dejson::deser)
+ (ModelDeclElement | dejson::error) = {
+ wassert_fields(de, "from", "to", "faces", "rotation")?;
+
+ static const facenames = ["west", "east", "down", "up",
+ "north", "south"];
+ const de_faces = dejson::field(de, "faces")?;
+ wassert_fields(&de_faces, facenames...)?;
+ const faces: [6](ModelDeclFace | void) = [void...];
+ for (let j = 0z; j < 6; j += 1) {
+ match (dejson::optfield(&de_faces, facenames[j])?) {
+ case let de_face: dejson::deser =>
+ faces[j] = deser_model_decl_face(&de_face)?;
+ case void => void;
+ };
+ };
+
+ let res = ModelDeclElement {
+ from = deser_model_decl_pos(
+ &dejson::field(de, "from")?)?,
+ to = deser_model_decl_pos(
+ &dejson::field(de, "to")?)?,
+ rot_origin = [0.0...],
+ rot_axis = Axis::X,
+ rot_angle = 0.0,
+ rot_rescale = false,
+ faces = faces,
+ };
+
+ match (dejson::optfield(de, "rotation")?) {
+ case let de_rotation: dejson::deser =>
+ wassert_fields(&de_rotation,
+ "origin", "axis", "angle", "rescale")?;
+ res.rot_origin = deser_model_decl_pos(
+ &dejson::field(&de_rotation, "origin")?)?;
+ const de_rot_axis = dejson::field(&de_rotation, "axis")?;
+ const rot_axis = dejson::string(&de_rot_axis)?;
+ res.rot_axis = switch (rot_axis) {
+ case "x" =>
+ yield Axis::X;
+ case "y" =>
+ yield Axis::Y;
+ case "z" =>
+ yield Axis::Z;
+ case =>
+ const s = dejson::strfield(rot_axis);
+ defer free(s);
+ return dejson::fail(&de_rot_axis, "Invalid axis {}", s);
+ };
+ res.rot_angle = dejson::number(
+ &dejson::field(&de_rotation, "angle")?)?: f32;
+ match (dejson::optfield(&de_rotation, "rescale")) {
+ case let de_rescale: dejson::deser =>
+ res.rot_rescale = dejson::boolean(&de_rescale)?;
+ case void => void;
+ };
+ case void => void;
+ };
+
+ return res;
+};
+
+fn deser_model_decl_pos(de: *dejson::deser) ([3]f32 | dejson::error) = {
+ dejson::assert_length(de, 3)?;
+ // TODO: check valid range?
+ return [
+ dejson::number(&dejson::index(de, 0)?)?: f32,
+ dejson::number(&dejson::index(de, 1)?)?: f32,
+ dejson::number(&dejson::index(de, 2)?)?: f32,
+ ];
+};
+
+fn deser_model_decl_face(de: *dejson::deser) (ModelDeclFace | dejson::error) = {
+ wassert_fields(de, "uv", "rotation", "cullface", "texture")?;
+
+ const uv = match (dejson::optfield(de, "uv")?) {
+ case let de_uv: dejson::deser =>
+ dejson::assert_length(&de_uv, 4)?;
+ let uv: [4]f32 = [0.0...];
+ for (let i = 0z; i < 4; i += 1)
+ uv[i] = dejson::number_frange(
+ &dejson::index(&de_uv, i)?,
+ 0.0, 16.0)?: f32;
+ yield uv;
+ case void => void;
+ };
+
+ const rotation = match (dejson::optfield(de, "rotation")?) {
+ case let de_rotation: dejson::deser =>
+ yield deser_90deg_angle(&de_rotation)?;
+ case void =>
+ yield 0u8;
+ };
+
+ const cull_face = match (dejson::optfield(de, "cullface")?) {
+ case let de_cull_face: dejson::deser =>
+ const s = dejson::string(&de_cull_face)?;
+ yield switch (s) {
+ case "west" =>
+ yield CullFace::WEST;
+ case "east" =>
+ yield CullFace::EAST;
+ case "down" =>
+ yield CullFace::DOWN;
+ case "up" =>
+ yield CullFace::UP;
+ case "north" =>
+ yield CullFace::NORTH;
+ case "south" =>
+ yield CullFace::SOUTH;
+ case =>
+ const s = dejson::strfield(s);
+ defer free(s);
+ trace::warn(&trace::root, "Invalid face {}", s);
+ yield CullFace::NONE;
+ };
+ case void =>
+ yield CullFace::NONE;
+ };
+
+ const texture = strings::dup(dejson::string(
+ &dejson::field(de, "texture")?)?);
+
+ return ModelDeclFace {
+ uv = uv,
+ rotation = rotation,
+ texture = texture,
+ cull_face = cull_face,
+ };
+};
+
+fn deser_90deg_angle(de: *dejson::deser) (u8 | dejson::error) = {
+ const v = dejson::number_i64(de)?;
+ if (v % 90 != 0)
+ return dejson::fail(de,
+ "Angle {} is not aligned to 90° increments", v);
+ return (v / 90 & 3): u8;
+};
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-05 09:59:35 +0000