Third person item display

assets/cubyz/entityModels/cubert.zig.zon

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

assets/cubyz/entityModels/snale.zig.zon

@@ -2,5 +2,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/client/entity_manager.zig

@@ -26,12 +26,13 @@ var uniforms: struct {
 	light: c_int,
 	contrast: c_int,
 	ambientLight: c_int,
+	nodeMatrices: c_int,
 } = undefined;
 
 var pipeline: graphics.Pipeline = undefined; // Entities are sometimes small and sometimes big. Therefor it would mean a lot of work to still use smooth lighting. Therefor the non-smooth shader is used for those.
 pub var entities: main.utils.VirtualList(main.client.Entity, 1 << 20) = undefined;
 pub var mutex: std.Thread.Mutex = .{};
-var model: *main.entityModel.EntityModel = undefined;
+pub var model: *main.entityModel.EntityModel = undefined;
 pub fn init() void {
 	entities = .init();
 	pipeline = graphics.Pipeline.init(
@@ -77,6 +78,21 @@ pub fn initAfterWorld() void {
 		std.log.err("EntityModel {s} wasn't found", .{"cubyz:snale"});
 		break :blk main.entityModel.default();
 	}).get();
+
+	// TODO: remove before merge
+	addEntity(ZonElement.parseFromString(main.globalArena, null,
+	\\ .{
+	\\    .id = 1,
+	\\    .name = "bobik",
+	\\
+	\\  }
+	)) catch unreachable;
+	 var w = utils.BinaryWriter.init(main.stackAllocator);
+        w.deinit();
+        w.writeVarInt(u32, 4);
+        var r = utils.BinaryReader.init(w.data.items);
+
+	main.entity.components.@"cubyz:model".client.load(1, &r,0) catch unreachable;
 }
 pub fn renderNames(projMatrix: Mat4f, playerPos: Vec3d) void {
 	mutex.lock();
@@ -132,29 +148,37 @@ pub fn render(projMatrix: Mat4f, ambientLight: Vec3f, playerPos: Vec3d) void {
 	for (entities.items()) |ent| {
 		if (ent.id == game.Player.id) continue; // don't render local player
 
-		model.bind();
-		const blockPos: vec.Vec3i = @intFromFloat(@floor(ent.pos));
-		const lightVals: [6]u8 = main.renderer.mesh_storage.getLight(blockPos[0], blockPos[1], blockPos[2]) orelse @splat(0);
-		const light = (@as(u32, lightVals[0] >> 3) << 25 |
-			@as(u32, lightVals[1] >> 3) << 20 |
-			@as(u32, lightVals[2] >> 3) << 15 |
-			@as(u32, lightVals[3] >> 3) << 10 |
-			@as(u32, lightVals[4] >> 3) << 5 |
-			@as(u32, lightVals[5] >> 3) << 0);
-
-		c.glUniform1ui(uniforms.light, @bitCast(@as(u32, light)));
-
-		const pos: Vec3d = ent.getRenderPosition() - playerPos;
-		const modelMatrix = (Mat4f.identity()
-			.mul(Mat4f.translation(Vec3f{
-				@floatCast(pos[0]),
-				@floatCast(pos[1]),
-				@floatCast(pos[2] - 1.0 + 0.09375),
-			}))
-			.mul(Mat4f.rotationZ(-ent.rot[2])));
-		const modelViewMatrix = game.camera.viewMatrix.mul(modelMatrix);
-		c.glUniformMatrix4fv(uniforms.viewMatrix, 1, c.GL_TRUE, @ptrCast(&modelViewMatrix));
-		c.glDrawElements(c.GL_TRIANGLES, model.indexCount, c.GL_UNSIGNED_INT, null);
+		if (main.entity.components.@"cubyz:model".client.get(ent.id)) |modelComp| {
+			modelComp.entityModel.get().bind();
+			const blockPos: vec.Vec3i = @intFromFloat(@floor(ent.pos));
+			const lightVals: [6]u8 = main.renderer.mesh_storage.getLight(blockPos[0], blockPos[1], blockPos[2]) orelse @splat(0);
+			const light = (@as(u32, lightVals[0] >> 3) << 25 |
+				@as(u32, lightVals[1] >> 3) << 20 |
+				@as(u32, lightVals[2] >> 3) << 15 |
+				@as(u32, lightVals[3] >> 3) << 10 |
+				@as(u32, lightVals[4] >> 3) << 5 |
+				@as(u32, lightVals[5] >> 3) << 0);
+
+			c.glUniform1ui(uniforms.light, @bitCast(@as(u32, light)));
+
+			const pos: Vec3d = ent.getRenderPosition() - playerPos;
+			const modelMatrix = (Mat4f.identity()
+				.mul(Mat4f.translation(Vec3f{
+					@floatCast(pos[0]),
+					@floatCast(pos[1]),
+					@floatCast(pos[2] - 1.0 + 0.09375),
+				}))
+				.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(&modelComp.matrices));
+			c.glDrawElements(c.GL_TRIANGLES, model.indexCount, c.GL_UNSIGNED_INT, null);
+
+			if (modelComp.entityModel.get().nodeReverse.get("RightItem")) |rightHandItemId| {
+				const nodeMat = modelComp.nodes[rightHandItemId].getHierarchyMatrix(modelComp.nodes);
+				main.itemdrop.ItemDropRenderer.renderOtherEntityDisplayItem(ambientLight, lightVals, projMatrix, modelMatrix, nodeMat);
+			}
+		}
 	}
 }
 

src/entity.zig

@@ -22,8 +22,12 @@ pub const EntityComponentLoadError = error{
 	UnreadableVersion,
 	UnreadableComponentData,
 	UnknownComponentId,
+	InvalidComponentVersion,
+};
+pub const Entity = enum(u32) {
+	noValue = std.math.maxInt(u32),
+	_,
 };
-// Analogous to Protocols.
 pub const EntityComponentId = u32;
 const EntityComponentVTable = struct {
 	serverLoad: *const fn (entityId: u32, reader: *main.utils.BinaryReader, version: u32) EntityComponentLoadError!void,

src/entityComponent/_list.zig

@@ -1 +1,2 @@
 pub const @"cubyz:_template" = @import("_template.zig");
+pub const @"cubyz:model" = @import("model.zig");

src/entityComponent/model.zig

@@ -0,0 +1,114 @@
+const std = @import("std");
+
+const main = @import("main");
+const chunk = main.chunk;
+const game = main.game;
+const graphics = main.graphics;
+const c = graphics.c;
+const ZonElement = main.ZonElement;
+const renderer = main.renderer;
+const settings = main.settings;
+const utils = main.utils;
+const vec = main.vec;
+const Mat4f = vec.Mat4f;
+const Vec3d = vec.Vec3d;
+const Vec3f = vec.Vec3f;
+const Vec4f = vec.Vec4f;
+const NeverFailingAllocator = main.heap.NeverFailingAllocator;
+
+const BinaryReader = main.utils.BinaryReader;
+
+pub var entityComponentID: main.entity.EntityComponentId = undefined;
+pub const entityComponentVersion = 0;
+
+// ############################# Client only stuff ################################
+pub const client = struct {
+	const Component = struct {
+		entityModel: main.entityModel.EntityModelIndex, // model
+		hasLoaded: bool = false,
+		nodes: [20]main.entityModel.EntityModel.Node = undefined,
+		matrices: [20]Mat4f = undefined,
+	};
+	pub var components: main.utils.SparseSet(Component, main.entity.Entity) = .{};
+
+	var countToCrash = 0;
+	pub fn init() void {}
+	pub fn deinit() void {
+		components.deinit(main.globalAllocator);
+	}
+	pub fn clear() void {
+		components.clear();
+	}
+	pub fn load(entity: u32, reader: *utils.BinaryReader, version: u32) main.entity.EntityComponentLoadError!void {
+		if (version != 0)
+			return error.InvalidComponentVersion;
+
+		const entityModel = reader.readVarInt(u32) catch return main.entity.EntityComponentLoadError.UnreadableComponentData;
+
+		const ptr = components.get(@enumFromInt(entity)) orelse components.add(main.globalAllocator, @enumFromInt(entity));
+		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 {};
+	}
+	pub fn get(entity: u32) ?*Component {
+		return components.get(@enumFromInt(entity));
+	}
+};
+
+// ############################# Server only stuff ################################
+
+pub const server = struct {
+	pub const Component = struct {
+		entityModel: main.entityModel.EntityModelIndex, // model
+		pub fn save(self: Component, writer: *utils.BinaryWriter, audience: main.entity.AudienceInfo) main.entity.ComponentSaveBehaviour {
+			_ = audience;
+			writer.writeVarInt(u32, self.entityModel.index);
+			return .save;
+		}
+	};
+	var components: main.utils.SparseSet(Component, main.entity.Entity) = undefined;
+	pub fn init() void {
+		components = .{};
+	}
+	pub fn deinit() void {
+		components.deinit(main.globalAllocator);
+	}
+	pub fn loadFromData(entity: u32, reader: *utils.BinaryReader, version: u32) main.entity.EntityComponentLoadError!void {
+		if (version != 0)
+			return error.InvalidComponentVersion;
+		const entityModel = reader.readVarInt(u32) catch return main.entity.EntityComponentLoadError.UnreadableComponentData;
+
+		try loadByIndex(entity, main.entityModel.EntityModelIndex{.index = entityModel});
+	}
+	pub fn loadByID(entity: u32, entityModelID: []const u8) main.entity.EntityComponentLoadError!void {
+		try loadByIndex(entity, main.entityModel.getById(entityModelID) orelse main.entityModel.default());
+	}
+	pub fn loadByIndex(entity: u32, entityModel: main.entityModel.EntityModelIndex) main.entity.EntityComponentLoadError!void {
+		const ptr = components.get(@enumFromInt(entity)) orelse components.add(main.globalAllocator, @enumFromInt(entity));
+		ptr.* = Component{
+			.entityModel = entityModel,
+		};
+	}
+	pub fn unload(entity: u32) void {
+		components.remove(@enumFromInt(entity)) catch {};
+	}
+	pub fn put(entity: u32, renderComponent: Component) void {
+		const ptr = components.get(@enumFromInt(entity)) orelse components.add(main.globalAllocator, @enumFromInt(entity));
+		ptr.* = renderComponent;
+	}
+	pub fn get(entity: u32) ?*Component {
+		return components.get(@enumFromInt(entity));
+	}
+};