Entity model node system

assets/cubyz/entityModels/cubert.zig.zon

@@ -5,5 +5,6 @@
 	.model = "cubyz:cubert",
 	.defaultTexture = "cubyz:cubert",
 	.height = 2,
-	.coordinateSystem = .right_handed_z_up,
+	.isPlayerModel = true,
+	.coordinateSystem = .left_handed_y_up,
 }

assets/cubyz/entityModels/snale.zig.zon

@@ -5,5 +5,6 @@
 	.model = "cubyz:snale",
 	.defaultTexture = "cubyz:snale",
 	.height = 2,
+	.isPlayerModel = true,
 	.coordinateSystem = .left_handed_y_up,
 }

assets/cubyz/shaders/entity_vertex.vert

@@ -3,6 +3,7 @@
 layout (location = 0) in vec3 inPos;
 layout (location = 1) in vec3 inNormal;
 layout (location = 2) in vec2 inUV;
+layout (location = 3) in uint inNodeID;
 
 layout(location = 0) out vec2 outTexCoord;
 layout(location = 1) out vec3 mvVertexPos;
@@ -13,6 +14,7 @@ layout(location = 0) uniform mat4 projectionMatrix;
 layout(location = 1) uniform mat4 viewMatrix;
 layout(location = 2) uniform vec3 ambientLight;
 layout(location = 3) uniform uint light;
+layout(location = 6) uniform mat4 nodeMatrices[20];
 
 vec3 square(vec3 x) {
 	return x*x;
@@ -35,7 +37,7 @@ vec3 calcLight(uint fullLight) {
 void main() {
 	normal = inNormal;
 
-	vec4 mvPos = viewMatrix*vec4(inPos, 1);
+	vec4 mvPos = viewMatrix * nodeMatrices[inNodeID] * vec4(inPos, 1);
 	gl_Position = projectionMatrix*mvPos;
 	mvVertexPos = mvPos.xyz;
 	outTexCoord = inUV;

src/client/Entity.zig

@@ -14,6 +14,7 @@ const Mat4f = vec.Mat4f;
 const Vec3d = vec.Vec3d;
 const Vec3f = vec.Vec3f;
 const Vec4f = vec.Vec4f;
+const EntityModel = main.entityModel.EntityModel;
 const NeverFailingAllocator = main.heap.NeverFailingAllocator;
 
 const BinaryReader = main.utils.BinaryReader;
@@ -40,6 +41,7 @@ pub fn init(self: *@This(), zon: ZonElement, allocator: NeverFailingAllocator) !
 		.name = allocator.dupe(u8, zon.get([]const u8, "name", "")),
 		.playerIndex = zon.get(?usize, "playerIndex", null),
 	};
+
 	self._interpolationPos = [_]f64{
 		self.pos[0],
 		self.pos[1],
@@ -77,6 +79,25 @@ pub fn update(self: *@This(), time: i16, lastTime: i16) void {
 	self.rot[0] = @floatCast(self.interpolatedValues.outPos[3]);
 	self.rot[1] = @floatCast(self.interpolatedValues.outPos[4]);
 	self.rot[2] = @floatCast(self.interpolatedValues.outPos[5]);
+
+	if (main.entity.components.@"cubyz:model".client.get(self.id)) |modelComp| {
+		const model = modelComp.entityModel.get();
+
+		const head = model.nodeReverse.get("Head");
+		if (model.nodeReverse.get("Eyestalks")) |eyestalksId| {
+			const stalkRot = self.rot[0]*0.25;
+			const headRot = self.rot[0]*0.75;
+			modelComp.nodes[eyestalksId].rot = vec.quatFromAxisAngle(Vec3f{1, 0, 0}, stalkRot);
+			modelComp.matrices[eyestalksId] = modelComp.nodes[eyestalksId].getHierarchyMatrix(modelComp.nodes);
+
+			const headId = head.?;
+			modelComp.nodes[headId].rot = vec.quatFromAxisAngle(Vec3f{1, 0, 0}, headRot);
+			modelComp.matrices[headId] = modelComp.nodes[headId].getHierarchyMatrix(modelComp.nodes);
+		} else if (head) |headId| {
+			modelComp.nodes[headId].rot = vec.quatFromAxisAngle(Vec3f{1, 0, 0}, self.rot[0]);
+			modelComp.matrices[headId] = modelComp.nodes[headId].getHierarchyMatrix(modelComp.nodes);
+		}
+	}
 }
 
 pub fn format(self: *const @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void {

src/entityComponent/model.zig

@@ -25,6 +25,9 @@ pub const entityComponentVersion = 0;
 pub const client = struct {
 	const Component = struct {
 		entityModel: main.entityModel.EntityModelIndex,
+		hasLoaded: bool = false,
+		nodes: [20]main.entityModel.EntityModel.Node = undefined,
+		matrices: [20]Mat4f = undefined,
 	};
 	pub var components: main.utils.SparseSet(Component, main.entity.Entity) = .{};
 
@@ -45,6 +48,15 @@ pub const client = struct {
 		ptr.* = Component{
 			.entityModel = .{.index = entityModel},
 		};
+		const model = ptr.entityModel.get();
+
+		for (0..model.nodeCount) |i| {
+			ptr.nodes[i] = model.nodes[i];
+		}
+
+		for (0..model.nodeCount) |i| {
+			ptr.matrices[i] = ptr.nodes[i].getHierarchyMatrix(ptr.nodes);
+		}
 	}
 	pub fn unload(entity: u32) void {
 		components.remove(@enumFromInt(entity)) catch {};

src/entityModel.zig

@@ -27,11 +27,41 @@ pub const EntityModel = struct {
 	texturePath: []const u8,
 	modelId: ?[]const u8,
 
+	nodeReverse: std.StringHashMap(u16) = undefined,
+	nodes: NodeList = undefined,
+	nodeCount: u8,
+
 	vao: ?graphics.VertexArray = null,
 	indexCount: c_int,
 	defaultTexture: ?main.graphics.Texture,
 	coordinateSystem: CoordinateSystem,
 
+	pub const maxNodesCount = 20;
+	pub const NodeList = [maxNodesCount]Node;
+	pub const MatrixList = [maxNodesCount]Mat4f;
+
+	pub const Node = struct {
+		pos: Vec3f = @splat(0),
+		rot: Vec4f = Vec4f{0, 0, 0, 1},
+		scale: Vec3f = @splat(1),
+
+		originMat: Mat4f,
+
+		parent: ?u16 = null,
+
+		pub fn getHierarchyMatrix(self: Node, nodes: NodeList) Mat4f {
+			var mat = self.originMat.mul(Mat4f.translation(self.pos));
+			mat = mat.mul(Mat4f.rotationQuat(self.rot));
+			mat = mat.mul(Mat4f.scale(self.scale));
+
+			if (self.parent == null) {
+				return mat;
+			}
+
+			return nodes[self.parent.?].getHierarchyMatrix(nodes).mul(mat);
+		}
+	};
+
 	pub const CoordinateSystem = enum {
 		right_handed_z_up,
 		right_handed_y_up,
@@ -43,6 +73,7 @@ pub const EntityModel = struct {
 		pos: [3]f32,
 		normal: [3]f32,
 		uv: [2]f32,
+		nodeID: c_uint,
 
 		pub const attributeDescriptions: []const c.VkVertexInputAttributeDescription = &.{
 			.{
@@ -60,6 +91,11 @@ pub const EntityModel = struct {
 				.format = c.VK_FORMAT_R32G32_SFLOAT,
 				.offset = @offsetOf(@This(), "uv"),
 			},
+			.{
+				.location = 3,
+				.format = c.VK_FORMAT_R32_UINT,
+				.offset = @offsetOf(@This(), "nodeID"),
+			},
 		};
 	};
 
@@ -76,6 +112,16 @@ pub const EntityModel = struct {
 		self.indexCount = 0;
 		self.coordinateSystem = zon.get(CoordinateSystem, "coordinateSystem", .right_handed_z_up);
 
+		self.nodeReverse = .init(main.worldArena.allocator);
+		self.nodes = std.mem.zeroes([20]Node);
+		self.nodeCount = 0;
+
+		if (zon.getChildOrNull("isPlayerModel")) |isPlayerModel| {
+			if (isPlayerModel.as(bool, false)) {
+				playerEntityModels.append(main.worldArena, index);
+			}
+		}
+
 		var isPlayerModel = false;
 		const tags = main.Tag.loadTagsFromZon(main.worldArena, zon.getChild("tags"));
 		for (tags) |tag| {
@@ -124,6 +170,9 @@ pub const EntityModel = struct {
 			.indexCount = 0,
 			.defaultTexture = null,
 			.coordinateSystem = self.coordinateSystem,
+			.nodeReverse = self.nodeReverse.clone() catch unreachable,
+			.nodes = self.nodes,
+			.nodeCount = self.nodeCount,
 		};
 	}
 
@@ -164,63 +213,96 @@ pub const EntityModel = struct {
 		defer indices.deinit();
 		var baseVertex: u32 = 0;
 
+		var nodeIdx: u8 = 0;
+
+		for (data.nodes, 0..data.nodes_count) |node, _| {
+			if (node.children_count == 0) continue;
+			const nameC = std.mem.span(node.name);
+
+			const name = main.globalArena.alloc(u8, nameC.len);
+			@memcpy(name, nameC);
+			self.nodeReverse.put(name, @intCast(nodeIdx)) catch unreachable;
+
+			var originMat = Mat4f.translation(convertCoordinateSystemVec(node.translation, self.coordinateSystem));
+			originMat = originMat.mul(Mat4f.rotationQuat(convertCoordinateSystemQuat(node.rotation, self.coordinateSystem)));
+			originMat = originMat.mul(Mat4f.scale(convertCoordinateSystemScale(node.scale, self.coordinateSystem)));
+			self.nodes[nodeIdx] = Node{
+				.originMat = originMat,
+			};
+			nodeIdx += 1;
+		}
+
+		for (data.nodes, 0..data.nodes_count) |node, _| {
+			if (node.children_count == 0 or node.parent == null) continue;
+
+			const curNode = self.nodeReverse.get(std.mem.span(node.name)).?;
+			self.nodes[curNode].parent = self.nodeReverse.get(std.mem.span(node.parent.*.name)).?;
+		}
+
 		for (data.nodes[0..data.nodes_count]) |node| {
-			if (node.mesh != null) {
-				const finalMat = getHierarchyMatrix(node, self.coordinateSystem);
-
-				const primitives = node.mesh.*.primitives;
-				for (primitives[0..node.mesh.*.primitives_count]) |primitive| {
-					if (primitive.type != gltf.cgltf_primitive_type_triangles) {
-						std.log.warn("Unsupported primitive type: {d}", .{primitive.type});
-						continue;
-					}
+			if (node.mesh == null) continue;
 
-					const indicesAccessor = primitive.indices.*;
-					const vertCount = primitive.attributes[0].data.*.count;
-					var indicesSlice = indices.addMany(indicesAccessor.count);
-					baseVertex = @intCast(vertices.items.len);
-					const vertSlice: []Vertex = vertices.addMany(vertCount);
+			var finalMat = Mat4f.translation(convertCoordinateSystemVec(node.translation, self.coordinateSystem));
+			finalMat = finalMat.mul(Mat4f.rotationQuat(convertCoordinateSystemQuat(node.rotation, self.coordinateSystem)));
+			finalMat = finalMat.mul(Mat4f.scale(convertCoordinateSystemScale(node.scale, self.coordinateSystem)));
 
-					for (0..indicesAccessor.count) |i| {
-						const idx = indicesAccessor.read_index(i);
-						indicesSlice[i] = @as(u32, @intCast(idx)) + baseVertex;
-					}
+			const parentNodeID = if (node.parent) |p| self.nodeReverse.get(std.mem.span(p.*.name)).? else 0;
 
-					var positionAttr: gltf.cgltf_accessor = undefined;
-					var normalAttr: gltf.cgltf_accessor = undefined;
-					var uvAttr: gltf.cgltf_accessor = undefined;
-					for (primitive.attributes, 0..primitive.attributes_count) |attrib, _| {
-						const attribAccessor = attrib.data.*;
-
-						switch (attrib.type) {
-							gltf.cgltf_attribute_type_position => positionAttr = attribAccessor,
-							gltf.cgltf_attribute_type_normal => normalAttr = attribAccessor,
-							gltf.cgltf_attribute_type_texcoord => uvAttr = attribAccessor,
-							else => continue,
-						}
-					}
+			const primitives = node.mesh.*.primitives;
+			for (primitives[0..node.mesh.*.primitives_count]) |primitive| {
+				if (primitive.type != gltf.cgltf_primitive_type_triangles) {
+					std.log.warn("Unsupported primitive type: {d}", .{primitive.type});
+					continue;
+				}
 
-					for (0..positionAttr.count) |v| {
-						var p: [3]f32 = undefined;
-						_ = positionAttr.read_float(v, @ptrCast(&p), 3);
-						const p2 = convertCoordinateSystemVec(p, self.coordinateSystem);
-						const pos: vec.Vec4f = finalMat.mulVec(.{p2[0], p2[1], p2[2], 1});
-						vertSlice[v].pos = vec.xyz(pos);
+				const indicesAccessor = primitive.indices.*;
+				const vertCount = primitive.attributes[0].data.*.count;
+				var indicesSlice = indices.addMany(indicesAccessor.count);
+				baseVertex = @intCast(vertices.items.len);
+				const vertSlice: []Vertex = vertices.addMany(vertCount);
 
-						var normal: [3]f32 = undefined;
-						_ = normalAttr.read_float(v, @ptrCast(&normal), 3);
-						vertSlice[v].normal = convertCoordinateSystemVec(normal, self.coordinateSystem);
+				for (0..indicesAccessor.count) |i| {
+					const idx = indicesAccessor.read_index(i);
+					indicesSlice[i] = @as(u32, @intCast(idx)) + baseVertex;
+				}
 
-						var uv: [2]f32 = undefined;
-						_ = uvAttr.read_float(v, @ptrCast(&uv), 2);
-						vertSlice[v].uv = .{uv[0], 1 - uv[1]};
+				var positionAttr: gltf.cgltf_accessor = undefined;
+				var normalAttr: gltf.cgltf_accessor = undefined;
+				var uvAttr: gltf.cgltf_accessor = undefined;
+				for (primitive.attributes, 0..primitive.attributes_count) |attrib, _| {
+					const attribAccessor = attrib.data.*;
+
+					switch (attrib.type) {
+						gltf.cgltf_attribute_type_position => positionAttr = attribAccessor,
+						gltf.cgltf_attribute_type_normal => normalAttr = attribAccessor,
+						gltf.cgltf_attribute_type_texcoord => uvAttr = attribAccessor,
+						else => continue,
 					}
 				}
+
+				for (0..positionAttr.count) |v| {
+					var p: [3]f32 = undefined;
+					_ = positionAttr.read_float(v, @ptrCast(&p), 3);
+					const p2 = convertCoordinateSystemVec(p, self.coordinateSystem);
+					const pos: vec.Vec4f = finalMat.mulVec(.{p2[0], p2[1], p2[2], 1});
+					vertSlice[v].pos = vec.xyz(pos);
+
+					var normal: [3]f32 = undefined;
+					_ = normalAttr.read_float(v, @ptrCast(&normal), 3);
+					vertSlice[v].normal = convertCoordinateSystemVec(normal, self.coordinateSystem);
+
+					var uv: [2]f32 = undefined;
+					_ = uvAttr.read_float(v, @ptrCast(&uv), 2);
+					vertSlice[v].uv = .{uv[0], 1 - uv[1]};
+
+					vertSlice[v].nodeID = @intCast(parentNodeID);
+				}
 			}
 		}
 
 		self.vao = .init(Vertex, vertices.items, indices.items);
 		self.indexCount = @intCast(indices.items.len);
+		self.nodeCount = nodeIdx;
 	}
 
 	fn convertCoordinateSystemVec(v: Vec3f, sys: CoordinateSystem) Vec3f {
@@ -248,18 +330,6 @@ pub const EntityModel = struct {
 		};
 	}
 
-	fn getHierarchyMatrix(node: gltf.cgltf_node, sys: CoordinateSystem) Mat4f {
-		var currentMat = Mat4f.translation(convertCoordinateSystemVec(node.translation, sys));
-		currentMat = currentMat.mul(Mat4f.rotationQuat(convertCoordinateSystemQuat(node.rotation, sys)));
-		currentMat = currentMat.mul(Mat4f.scale(convertCoordinateSystemScale(node.scale, sys)));
-
-		if (node.parent == null) {
-			return currentMat;
-		}
-
-		return getHierarchyMatrix(node.parent.*, sys).mul(currentMat);
-	}
-
 	fn getGltfError(result: gltf.cgltf_result) anyerror {
 		return switch (result) {
 			gltf.cgltf_result_data_too_short => error.DataTooShort,

src/entitySystem/modelRenderer.zig

@@ -41,6 +41,7 @@ pub const client = struct {
 		light: c_int,
 		contrast: c_int,
 		ambientLight: c_int,
+		nodeMatrices: c_int,
 	} = undefined;
 
 	pub fn init() void {
@@ -151,6 +152,7 @@ pub const client = struct {
 				.mul(Mat4f.rotationZ(-ent.rot[2])));
 			const modelViewMatrix = game.camera.viewMatrix.mul(modelMatrix);
 			c.glUniformMatrix4fv(uniforms.viewMatrix, 1, c.GL_TRUE, @ptrCast(&modelViewMatrix));
+			c.glUniformMatrix4fv(uniforms.nodeMatrices, main.entityModel.EntityModel.maxNodesCount, c.GL_TRUE, @ptrCast(&component.matrices));
 			c.glDrawElements(c.GL_TRIANGLES, entModel.indexCount, c.GL_UNSIGNED_INT, null);
 		}
 	}

src/game.zig

@@ -298,13 +298,15 @@ pub const World = struct { // MARK: World
 		errdefer self.itemDrops.deinit();
 
 		try network.protocols.handShake.clientSide(self.conn, settings.playerName);
+		self.conn.mutex.lock();
 
 		main.Window.setMouseGrabbed(true);
-
 		main.blocks.meshes.generateTextureArray();
 		main.particles.ParticleManager.generateTextureArray();
 		main.models.uploadModels();
 		main.entityModel.loadModelsAndTexture();
+
+		self.conn.mutex.unlock();
 	}
 
 	pub fn deinit(self: *World) void {