From 2ec0cd8c315fb361bfa0e64aea3a7e027b248060 Mon Sep 17 00:00:00 2001
From: Peter Li <peterino>
Date: Sun, 20 Apr 2025 15:57:08 -0700
Subject: [PATCH] > texture asset loader implemented

---
 engine/core/src/engine.zig                    |  17 ++-
 engine/core/src/scene.zig                     |   1 -
 engine/rend/shaders/meshes.vert.hlsl          |   4 +-
 engine/rend/shaders/meshes.vert.json          |  12 +-
 engine/rend/src/rend.zig                      |   3 +
 engine/rend/src/sgpu/TextureList.zig          | 128 ++++++++++++++++++
 engine/rend/src/sgpu/mesh-pool.zig            |  12 +-
 engine/rend/src/sgpu/renderer.zig             |  16 ++-
 engine/rend/src/texture/texture.zig           |  22 +++
 .../content/_shaders/dxil/meshes.vert.dxil    | Bin 5364 -> 5216 bytes
 projects/content/_shaders/msl/meshes.vert.msl |   6 +-
 projects/content/_shaders/spv/meshes.vert.spv | Bin 1892 -> 1492 bytes
 projects/sampleGame/main.zig                  |  24 +++-
 13 files changed, 214 insertions(+), 31 deletions(-)
 create mode 100644 engine/rend/src/sgpu/TextureList.zig
 create mode 100644 engine/rend/src/texture/texture.zig

diff --git a/engine/core/src/engine.zig b/engine/core/src/engine.zig
index ac0e15f..1b3e667 100644
--- a/engine/core/src/engine.zig
+++ b/engine/core/src/engine.zig
@@ -166,13 +166,18 @@ pub const Engine = struct {
             try self.destroyListSimple.append(self.allocator, newObjectRef);
         }
 
-        if (params.can_tick) {
-            if (!@hasDecl(T, "tick")) {
-                return error.RequestedTickNotAvailable; // tried to register a tickable for an object which does not implement tick
+        if (params.can_tick) |t| {
+            if (t and !@hasDecl(T, "tick")) {
+                return error.RequestedTickNotAvailable;
             }
 
-            // register to tick table
-            try self.tickables.append(self.allocator, newIndex);
+            if (t) {
+                try self.tickables.append(self.allocator, newIndex);
+            }
+        } else {
+            if (@hasDecl(T, "tick")) {
+                try self.tickables.append(self.allocator, newIndex);
+            }
         }
 
         if (@hasDecl(T, "engineDraw")) {
@@ -379,7 +384,7 @@ pub const Engine = struct {
 };
 
 pub const NeonObjectParams = struct {
-    can_tick: bool = false,
+    can_tick: ?bool = null,
     responds_to_events: bool = false,
     isCore: bool = false,
 };
diff --git a/engine/core/src/scene.zig b/engine/core/src/scene.zig
index 6f5b0e5..96bece4 100644
--- a/engine/core/src/scene.zig
+++ b/engine/core/src/scene.zig
@@ -135,7 +135,6 @@ pub const Scene = struct {
     pub fn setPosition(self: @This(), position: core.Vectorf) void {
         if (SceneObjectContainer.get(self.handle, .posRot)) |posRot| {
             posRot.*.position = position;
-            // core.engine_log("setposition scucess handle.index = 0x{x}", .{self.handle.index});
         } else {
             core.engine_log("setposition failed handle.index = 0x{x} generation = {d} alive={any}", .{ self.handle.index, self.handle.generation, self.handle.alive });
         }
diff --git a/engine/rend/shaders/meshes.vert.hlsl b/engine/rend/shaders/meshes.vert.hlsl
index b07b386..850f667 100644
--- a/engine/rend/shaders/meshes.vert.hlsl
+++ b/engine/rend/shaders/meshes.vert.hlsl
@@ -37,8 +37,8 @@ Output main(Input input)
 
     float4 pos = float4(input.Position, 1.0);
 
-    pos.x += 0.2 * sin(time * 0.5 ) * pos.y * 0.5;
-    pos.y += 0.2 * cos(time * 0.5 ) * pos.z * 0.5;
+    // pos.x += 0.2 * sin(time * 0.5 ) * pos.y * 0.5;
+    // pos.y += 0.2 * cos(time * 0.5 ) * pos.z * 0.5;
     
     output.Position = mul(ViewProjection, mul(scene[input.Instance].Model, pos));
 
diff --git a/engine/rend/shaders/meshes.vert.json b/engine/rend/shaders/meshes.vert.json
index 553384c..279e031 100644
--- a/engine/rend/shaders/meshes.vert.json
+++ b/engine/rend/shaders/meshes.vert.json
@@ -6,7 +6,7 @@
         }
     ],
     "types" : {
-        "_9" : {
+        "_8" : {
             "name" : "Scene",
             "members" : [
                 {
@@ -18,12 +18,12 @@
                 }
             ]
         },
-        "_8" : {
+        "_7" : {
             "name" : "type.StructuredBuffer.Scene",
             "members" : [
                 {
                     "name" : "_m0",
-                    "type" : "_9",
+                    "type" : "_8",
                     "array" : [
                         0
                     ],
@@ -35,7 +35,7 @@
                 }
             ]
         },
-        "_11" : {
+        "_10" : {
             "name" : "type.Uniforms",
             "members" : [
                 {
@@ -74,7 +74,7 @@
     ],
     "ssbos" : [
         {
-            "type" : "_8",
+            "type" : "_7",
             "name" : "scene",
             "readonly" : true,
             "block_size" : 0,
@@ -84,7 +84,7 @@
     ],
     "ubos" : [
         {
-            "type" : "_11",
+            "type" : "_10",
             "name" : "type.Uniforms",
             "block_size" : 68,
             "set" : 1,
diff --git a/engine/rend/src/rend.zig b/engine/rend/src/rend.zig
index a385351..4118561 100644
--- a/engine/rend/src/rend.zig
+++ b/engine/rend/src/rend.zig
@@ -30,6 +30,9 @@ pub const setActiveCamera = renderer.setActiveCamera;
 pub const createRendererObject = renderer.createRendererObject;
 pub const registerRendererObject = renderer.registerRendererObject;
 
+pub const getTexture = renderer.getTexture;
+pub const texture = @import("texture/texture.zig");
+
 var rendAllocator: std.mem.Allocator = undefined;
 pub fn getAllocator() std.mem.Allocator {
     return rendAllocator;
diff --git a/engine/rend/src/sgpu/TextureList.zig b/engine/rend/src/sgpu/TextureList.zig
new file mode 100644
index 0000000..559fb09
--- /dev/null
+++ b/engine/rend/src/sgpu/TextureList.zig
@@ -0,0 +1,128 @@
+// not to be confused with a real texture pool
+// but this texture list is just a container where all
+// textures are installed into the renderer
+//
+// this thing also servers as both the asset loader
+// as well as the engine interface
+//
+
+pub var LoaderInterfaceVTable = assets.AssetLoaderInterface.from("Texture", @This());
+pub var NeonObjectTable: core.EngineObjectVTable = core.EngineObjectVTable.from(@This());
+
+allocator: std.mem.Allocator,
+device: *gpu.GPUDevice = undefined,
+
+map: std.AutoHashMapUnmanaged(u32, *Texture) = .{},
+
+pub fn create(allocator: std.mem.Allocator) !*@This() {
+    const self = try allocator.create(@This());
+    self.* = .{
+        .allocator = allocator,
+    };
+
+    return self;
+}
+
+pub fn setup(self: *@This(), device: *gpu.GPUDevice) !void {
+    core.engine_log("Texture List Added", .{});
+    try assets.gAssetSys.registerLoader(self);
+    self.device = device;
+}
+
+pub fn loadAsset(self: *@This(), assetRef: assets.AssetRef, propertiesBag: ?assets.AssetPropertiesBag) assets.AssetLoaderError!void {
+    var name = assetRef.name;
+    core.engine_log("loading texture {s}", .{name.utf8()});
+    if (propertiesBag) |bag| {
+        const installed = self.uploadTextureFromPath(name, bag.path) catch return error.UnableToLoad;
+        self.map.put(self.allocator, name.handle(), installed) catch return error.UnableToLoad;
+    }
+}
+
+pub fn uploadTextureFromPath(self: *@This(), name: core.Name, path: []const u8) !*Texture {
+    var png = try core.png.PngContents.initFromFS(core.fs(), self.allocator, path);
+    defer png.deinit();
+
+    const cmd = self.device.acquireGPUCommandBuffer();
+
+    const gpuTexture = self.device.createGPUTexture(&std.mem.zeroInit(gpu.GPUTextureCreateInfo, .{
+        .type = .texturetype2d,
+        .format = .textureformatR8g8b8a8UnormSrgb,
+        .usage = .{ .textureusageSampler = true },
+        .width = png.size.x,
+        .height = png.size.y,
+        .layer_count_or_depth = 1,
+        .num_levels = 1,
+    }));
+
+    const transferBuffer = self.device.createGPUTransferBuffer(&.{
+        .usage = .transferbufferusageUpload,
+        .size = png.size.x * png.size.y * @sizeOf(u32),
+        .props = 0,
+    });
+
+    {
+        const data: [*]u8 = @ptrCast(self.device.mapGPUTransferBuffer(transferBuffer, false));
+        for (png.pixels, 0..) |pixel, i| {
+            data[i] = pixel;
+        }
+    }
+
+    self.device.unmapGPUTransferBuffer(transferBuffer);
+
+    const copyPass = cmd.beginGPUCopyPass();
+    // copyPass.uploadToGPUTexture(source: [*c]const GPUTextureTransferInfo, destination: [*c]const GPUTextureRegion, cycle: bool)
+    copyPass.uploadToGPUTexture(
+        &.{
+            .transfer_buffer = transferBuffer,
+            .offset = 0,
+            .pixels_per_row = png.size.x,
+            .rows_per_layer = png.size.y,
+        },
+        &std.mem.zeroInit(gpu.GPUTextureRegion, .{
+            .texture = gpuTexture,
+            .w = png.size.x,
+            .h = png.size.y,
+            .d = 1,
+        }),
+        false,
+    );
+
+    copyPass.endGPUCopyPass();
+    if (!cmd.submitGPUCommandBuffer()) {
+        return error.CopyFailed;
+    }
+    self.device.releaseGPUTransferBuffer(transferBuffer);
+
+    const tex = try self.allocator.create(Texture);
+    tex.* = .{
+        .texture = gpuTexture,
+        .id = 0,
+        .format = .f32_rgba,
+        .usage = .{},
+        .size = png.size,
+        .name = name,
+    };
+    return tex;
+}
+
+pub fn discardAll(self: *@This()) void {
+    _ = self;
+}
+
+pub fn destroy(self: *@This()) void {
+    var iter = self.map.valueIterator();
+    while (iter.next()) |x| {
+        self.allocator.destroy(x.*);
+    }
+    self.map.deinit(self.allocator);
+    self.allocator.destroy(self);
+}
+
+const std = @import("std");
+const core = @import("core");
+const rend = @import("../rend.zig");
+const texture = rend.texture;
+const Texture = texture.Texture;
+const sdl3 = @import("sdl3");
+const gpu = sdl3.gpu;
+const assets = @import("assets");
diff --git a/engine/rend/src/sgpu/mesh-pool.zig b/engine/rend/src/sgpu/mesh-pool.zig
index bf90cec..26c219b 100644
--- a/engine/rend/src/sgpu/mesh-pool.zig
+++ b/engine/rend/src/sgpu/mesh-pool.zig
@@ -68,10 +68,12 @@ pub const MeshPool = struct {
         while (self.meshUpdates.popFromUnlocked()) |u| {
             switch (u) {
                 .new => |new| {
+                    var name = new.name;
+                    core.engine_log("uploading mesh => {s}", .{name.utf8()});
+
                     const indexSpan = try self.addTransfer(copyPass, self.indexBuffer, u32, &self.indexSpans, new.indices);
                     const vertexSpan = try self.addTransfer(copyPass, self.vertexBuffer, meshes.MeshVertex, &self.vertexSpans, new.vertices);
 
-                    var name = new.name;
                     core.graphics_log("uploading {d} vertices and {d} indices", .{ vertexSpan.size, indexSpan.size });
 
                     core.engine_log("install mesh by name {d}", .{name.handle()});
@@ -79,7 +81,7 @@ pub const MeshPool = struct {
                         .vertex = vertexSpan,
                         .index = indexSpan,
                         .name = new.name,
-                        .jointRemap = null, // joint remaps... parse the installed skeletal meshes to generate this remap
+                        .jointRemap = null, // joint remaps... TODO parse the installed skeletal meshes to generate this remap
                     });
                 },
                 .free => |free| {
@@ -118,17 +120,19 @@ pub const MeshPool = struct {
 
         var mappedSlice: []T = undefined;
         mappedSlice.ptr = @ptrCast(@alignCast(self.device.mapGPUTransferBuffer(upload, false)));
-        defer self.device.unmapGPUTransferBuffer(upload);
         mappedSlice.len = uploadSlice.len;
         std.mem.copyForwards(T, mappedSlice, uploadSlice);
+        self.device.unmapGPUTransferBuffer(upload);
 
         //copyPass.uploadToGPUBuffer(source: [*c]const GPUTransferBufferLocation, destination: [*c]const GPUBufferRegion, cycle: bool)
         copyPass.uploadToGPUBuffer(
             &.{ .transfer_buffer = upload, .offset = 0 },
-            &.{ .buffer = destBuffer, .offset = newSpan.start, .size = newSpan.size * @sizeOf(T) },
+            &.{ .buffer = destBuffer, .offset = newSpan.start * @sizeOf(T), .size = newSpan.size * @sizeOf(T) },
             false,
         );
 
+        core.engine_log("uploading {s} buffer span {d}[{d}] ({d} bytes)", .{ @typeName(T), newSpan.start, newSpan.size, newSpan.size * @sizeOf(T) });
+
         return newSpan;
     }
 
diff --git a/engine/rend/src/sgpu/renderer.zig b/engine/rend/src/sgpu/renderer.zig
index 08b824d..f7a8ed7 100644
--- a/engine/rend/src/sgpu/renderer.zig
+++ b/engine/rend/src/sgpu/renderer.zig
@@ -37,6 +37,8 @@ pub const Renderer = struct {
 
     depthTexture: *gpu.GPUTexture = undefined,
 
+    textureList: *TextureList = undefined,
+
     // transients DO NOT TOUCH
     swapchainTexture: *gpu.GPUTexture = undefined,
 
@@ -57,8 +59,6 @@ pub const Renderer = struct {
         return self;
     }
 
-    // pub fn createRendererObjectArgs(self: *@This(), T: type) !*T {
-
     // registers a pre-existing render object, does not add to destroys
     pub fn registerRendererObject(self: *@This(), T: type, object: *anyopaque) !void {
         if (@hasDecl(T, "onUpload")) {
@@ -78,6 +78,13 @@ pub const Renderer = struct {
         }
     }
 
+    pub fn createRendererEngineObject(self: *@This(), T: type) !*T {
+        const object = try core.createObject(T, .{});
+        try object.setup(self.device);
+
+        return object;
+    }
+
     pub fn createRendererObject(self: *@This(), T: type) !*T {
         const object = try T.create(self.device, self.allocator, .{});
 
@@ -123,6 +130,7 @@ pub const Renderer = struct {
         try self.createDepthTexture();
 
         self.meshPool = try self.createRendererObject(MeshPool);
+        self.textureList = try self.createRendererEngineObject(TextureList);
     }
 
     pub fn discoverFormats(self: *@This()) !void {
@@ -473,6 +481,8 @@ const ShaderLoadArgs = sdl3.shaderTypes.ShaderLoadArgs;
 pub const mesh_pool = @import("mesh-pool.zig");
 pub const MeshPool = mesh_pool.MeshPool;
 
+pub const TextureList = @import("TextureList.zig");
+
 // debug api
 
 pub fn reloadShaders() !void {
@@ -515,3 +525,5 @@ pub const getMesh = mesh_pool.getMesh;
 pub const getMeshByName = mesh_pool.getMeshByName;
 
 pub const pushMeshUpdate = mesh_pool.pushMeshUpdate;
+
+pub const GPUTextureType = gpu.GPUTexture;
diff --git a/engine/rend/src/texture/texture.zig b/engine/rend/src/texture/texture.zig
new file mode 100644
index 0000000..07b7e37
--- /dev/null
+++ b/engine/rend/src/texture/texture.zig
@@ -0,0 +1,22 @@
+pub const TextureFormat = enum(u8) {
+    f32_rgba,
+    u8_rgba,
+};
+pub const TextureUsage = struct {
+    mesh: bool = false,
+};
+
+// handle to a texture resource in the engine.
+pub const Texture = struct {
+    id: u32 = 0, // 0 is unknown texture.
+    format: TextureFormat = .f32_rgba, // format of the texture
+    usage: TextureUsage = .{},
+    size: core.Vector2u,
+    name: core.Name,
+    texture: *GPUTextureType,
+};
+
+const core = @import("core");
+const rend = @import("../rend.zig");
+const renderer = rend.renderer;
+const GPUTextureType = renderer.GPUTextureType;
diff --git a/projects/content/_shaders/dxil/meshes.vert.dxil b/projects/content/_shaders/dxil/meshes.vert.dxil
index baf4ad69725c2e9fa3cc0fc2b1307b2e19537241..f401411b1562745c922c0a6cd3808a06c76eb722 100644
GIT binary patch
delta 2744
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

delta 2951
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
T7QeH9R`kw(dL#268UX$c+*-<M

diff --git a/projects/content/_shaders/msl/meshes.vert.msl b/projects/content/_shaders/msl/meshes.vert.msl
index 9d5d848..88a175b 100644
--- a/projects/content/_shaders/msl/meshes.vert.msl
+++ b/projects/content/_shaders/msl/meshes.vert.msl
@@ -34,12 +34,8 @@ struct main0_in
 vertex main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]], const device type_StructuredBuffer_Scene& scene [[buffer(1)]], uint gl_InstanceIndex [[instance_id]])
 {
     main0_out out = {};
-    float4 _44 = float4(in.in_var_TEXCOORD0, 1.0);
-    float _47 = Uniforms.time * 0.5;
-    _44.x = in.in_var_TEXCOORD0.x + (((0.20000000298023223876953125 * sin(_47)) * in.in_var_TEXCOORD0.y) * 0.5);
-    _44.y = in.in_var_TEXCOORD0.y + (((0.20000000298023223876953125 * cos(_47)) * in.in_var_TEXCOORD0.z) * 0.5);
     out.out_var_TEXCOORD0 = in.in_var_TEXCOORD3;
-    out.gl_Position = Uniforms.ViewProjection * (scene._m0[gl_InstanceIndex].Model * _44);
+    out.gl_Position = Uniforms.ViewProjection * (scene._m0[gl_InstanceIndex].Model * float4(in.in_var_TEXCOORD0, 1.0));
     return out;
 }
 
diff --git a/projects/content/_shaders/spv/meshes.vert.spv b/projects/content/_shaders/spv/meshes.vert.spv
index 9bac178323bb9ca6b0231d5d923754934562ca52..2290edaa4d979ded1f1408cf2cf810033fdaef76 100644
GIT binary patch
literal 1492
zcmZXU*=rL~6vj`JNn%~PSi871CXIV^5CjoKZCz+zN~^Wf*OK1Ah{?!wqWI>Y;GgS@
z;P<;Tw;A-p$+_Qm_A{5%YrU4)jG4_@tY6Ne)k>!BG1hrIe|8@oCu2ZOf=482NSYqk
z{ryPBhRvFiTmIv#ix2W_GRP;HJ9#}B4qX->4BXhsC$e+$DG)gt9*eTw^u&FU#%EUg
z)JK4uz8jzSaGVU&Y;-DnQ`L$t%|0dW`+k;wc7r@g)h&6kF-x9|oRpY`U68J%5YzH=
zCFA(paTb4kcl2g&@59^2g@4P>`;YBOu(5-5lK&S-|I`h8+ZJYL)b2~b><-KUv)i^u
z1!m7+G<IrL?d)em!od#idQ@O?W2X=7;9%cTHogI;S17A;e8UCFj^ctJ{gdaSG`(+1
zh{2aL%@dt*YvQ*x0Y1!ufB0Tg|0!3k8~msn;+TcFO$mANsY#aA*CpwW1fPD1=XB?+
z$ah}4Bf-X<`OJR4S`}W@4USrC`n@a-2W~5t9l)*Y&ir6_`UQ97xg<?5aBX3FBc`Yu
z*%jTf!&7s)w6PcBSET739{Z{^vBY3!m)PN%_p0ah<8@@$q_G!#WY={kH~z%mC^2&_
zDeJm)S0216?)co4rXGDi7iK2j6&#ouct-)#Gk5A@r$=fAOi%1EV0z*m<AXmv75^b-
zPi3JGd^z;>TiH9(FXYQ!x)SPvnQKErE--WVB-DGaT<q?agcwfXZtD&=Q{nEE9J%-P
z1=-PE3Gw)2=e=wxFFU#?VGq17YO}BV68J5}<MTkm?(m_ns&8Ky`!D6A)<X&P-~;!l
W<jMO|Q?fVa<<8Eq|IrlBB!2;0t5y*J

literal 1892
zcmZXU+iwy<6vjuc+E!|<y?7}C^^UGp+ghzHP&N2~X)S8{+Q5=v1Pm-1-}J$E|1kZ3
zd@=F+&F;uXhn$`Bedo-%?JUW}YSx$&#+aPh(~~u45|)`Z8N1gT&4xD$+TQxc8upw?
zvRT`#nX-C9&)#vj55Ss|q$L@N5{OG$d?d%TIb}|Y3qF7Fy=E{Rw}SD|Z|{ve9e?OG
zTYle{PfA|Kgorqt3fId)+kY<=AF_|^32??t3){GF`rXc8*c%CFQ~^BeZP)*FFdV$|
zTS0fAYKe=D2?X7qk55{^8SSwUVzRccZr}TOJoH{aKYF^qfB4MK0~`JRV|x(B$|{F3
zgK_ZRLF$jstuD;WsHZFeGdov1nAzqfEHHV&@L+Pq?aZenVPOXsEebJxVyA!XU}t}!
zYTV3M#k1lZwVknC_^z;14{=Uwr<SUOGrVusBu?rtw=BM{4)CE5{9Vrz{|Oh*>-@;;
z&e03!suJSjlaMT^uAKIQ1fOz*XQi_i<x4*W2{!aOi7{U)4xbhJ`J=Jx&dv+FSooil
zXjRCyAf*7(S`uE=jt{ji>$#*IE_{bcJ8QTV)xrFjeO@|q0T<-Stmp+UFHCQo3F}Uo
z^U|@0e9ByiY|NGO7qwF_JT+a?&RNc2U(t>o9?V?=hrOiCW$DCn_Ckc|V_s2;+Kcii
z**%QGyCA-+@k)fLds{i^iF=6;m>#%?4pTEZsRKJTGBby%k?+P~YUJ*52LFQg@IT0y
zO?eiDiOniWehFRGz9V1ea!tZnFnwN^kPplpZb-=YN>6&aDd7yuakr$yQIq4!5l8L=
zRm9A0OE`}|cJ5nEahcg233K3%k(*qe1pZr;`)<T>?`G6BK5G*4a%ZqR-+R)zzt|mj
zUphSb9mgLRJTbpUdDf*<C$>Z7q4o_4JUy^n{!QuR=Ua>Ce<)0T>@L@qba;Aq+#~7m
z@%)d4sS%sYzbze}I>^V|xLZ#o%#H7wxpB{SB=9xO9iLsvlms8%XWX|UjQzXf(Pvdc
cE_lb)q*o=x-PLX3zHv{`xog;etEw%@AFgt4YXATM

diff --git a/projects/sampleGame/main.zig b/projects/sampleGame/main.zig
index 673d976..6542cd7 100644
--- a/projects/sampleGame/main.zig
+++ b/projects/sampleGame/main.zig
@@ -25,11 +25,16 @@ const assetReferences = [_]assets.AssetImportReference{
         "m_empire",
         .{ .path = "meshes/lost_empire.obj" },
     ),
-    // assets.MakeImportRefOptions(
-    //     "Mesh",
-    //     "m_fox",
-    //     .{ .path = "gltf-samples/Fox/glTF/Fox.gltf" },
-    // ),
+    assets.MakeImportRefOptions(
+        "Mesh",
+        "m_fox",
+        .{ .path = "gltf-samples/Fox/glTF/Fox.gltf" },
+    ),
+    assets.MakeImportRefOptions(
+        "Texture",
+        "t_empire",
+        .{ .path = "textures/texture_sample.png" },
+    ),
 };
 
 pub fn prepare(self: *@This()) !void {
@@ -59,6 +64,15 @@ pub fn prepare(self: *@This()) !void {
         empireMesh.setMesh("m_empire");
     }
 
+    {
+        const fox = try core.createEntity();
+        const scene = fox.addComponent(core.Scene).?;
+        _ = scene;
+        // scene.setScale();
+        const mesh = fox.addComponent(rend.MeshComponent).?;
+        mesh.setMesh("m_fox");
+    }
+
     rend.setActiveCamera(camera);
 
     self.moveInput = try core.Axis2dBinding.create(core.MakeName("movement"));