Merge pull request #34 from Interrupt/fixes/material-pointers

Updating meshes to hold pointers to materials, not the actual material

Author: Interrupt

src/examples/frustums.zig

@@ -76,7 +76,7 @@ pub fn on_init() !void {
         return;
     };
 
-    cube_mesh = delve.graphics.mesh.createCube(delve.math.Vec3.new(0, 0, 0), delve.math.Vec3.new(1, 1, 1), delve.colors.white, material_cube) catch {
+    cube_mesh = delve.graphics.mesh.createCube(delve.math.Vec3.new(0, 0, 0), delve.math.Vec3.new(1, 1, 1), delve.colors.white, &material_cube) catch {
         delve.debug.fatal("Could not create cube mesh!", .{});
         return;
     };
@@ -127,5 +127,5 @@ pub fn createFrustumMesh() !delve.graphics.mesh.Mesh {
 
     try builder.addFrustum(secondary_camera.getViewFrustum(), delve.math.Mat4.identity, delve.colors.cyan);
 
-    return builder.buildMesh(material_frustum);
+    return builder.buildMesh(&material_frustum);
 }

src/examples/lighting.zig

@@ -36,6 +36,9 @@ const mesh_texture_file = "assets/meshes/CesiumMan.png";
 var cube1: delve.graphics.mesh.Mesh = undefined;
 var cube2: delve.graphics.mesh.Mesh = undefined;
 
+var skinned_mesh_material: delve.platform.graphics.Material = undefined;
+var static_mesh_material: delve.platform.graphics.Material = undefined;
+
 // This example shows an example of some simple lighting in a shader
 
 // Web build note: this does not seem to work when built in --release=fast or --release=small
@@ -86,7 +89,7 @@ fn on_init() !void {
     const tex_base = graphics.Texture.init(&base_img);
 
     // Create a material out of our shader and textures
-    const skinned_mesh_material = delve.platform.graphics.Material.init(.{
+    skinned_mesh_material = delve.platform.graphics.Material.init(.{
         .shader = skinned_shader.?,
         .texture_0 = tex_base,
         .texture_1 = delve.platform.graphics.createSolidTexture(0x00000000),
@@ -99,7 +102,7 @@ fn on_init() !void {
     });
 
     // Create a material out of the texture
-    const static_mesh_material = graphics.Material.init(.{
+    static_mesh_material = graphics.Material.init(.{
         .shader = static_shader.?,
         .texture_0 = delve.platform.graphics.createSolidTexture(0xFFFFFFFF),
         .texture_1 = delve.platform.graphics.createSolidTexture(0x00000000),
@@ -109,16 +112,16 @@ fn on_init() !void {
     });
 
     // Load an animated mesh
-    const loaded_mesh = skinned_mesh.SkinnedMesh.initFromFile(delve.mem.getAllocator(), mesh_file, .{ .material = skinned_mesh_material });
+    const loaded_mesh = skinned_mesh.SkinnedMesh.initFromFile(delve.mem.getAllocator(), mesh_file, .{ .material = &skinned_mesh_material });
 
     if (loaded_mesh == null) {
         debug.fatal("Could not load skinned mesh!", .{});
         return;
     }
 
     // make some cubes
-    cube1 = try delve.graphics.mesh.createCube(math.Vec3.new(0, -1.0, 0), math.Vec3.new(10.0, 0.25, 10.0), delve.colors.white, static_mesh_material);
-    cube2 = try delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), math.Vec3.new(2.0, 1.25, 1.0), delve.colors.white, static_mesh_material);
+    cube1 = try delve.graphics.mesh.createCube(math.Vec3.new(0, -1.0, 0), math.Vec3.new(10.0, 0.25, 10.0), delve.colors.white, &static_mesh_material);
+    cube2 = try delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), math.Vec3.new(2.0, 1.25, 1.0), delve.colors.white, &static_mesh_material);
 
     animated_mesh = loaded_mesh.?;
     animation = try animated_mesh.createAnimation(0, 1.0, true);
@@ -159,13 +162,10 @@ fn on_draw() void {
     const point_lights = &[_]delve.platform.graphics.PointLight{ point_light_1, point_light_2, point_light_3 };
 
     // add the lights and camera to the materials
-    animated_mesh.mesh.material.params.point_lights = @constCast(point_lights);
-    animated_mesh.mesh.material.params.directional_light = directional_light;
-    animated_mesh.mesh.material.params.ambient_light = colors.Color.new(0.02, 0.02, 0.05, 1.0);
-
-    // copy over the material params to the cube mesh too
-    cube1.material.params = animated_mesh.mesh.material.params;
-    cube2.material.params = animated_mesh.mesh.material.params;
+    static_mesh_material.params.point_lights = @constCast(point_lights);
+    static_mesh_material.params.directional_light = directional_light;
+    static_mesh_material.params.ambient_light = colors.Color.new(0.02, 0.02, 0.05, 1.0);
+    skinned_mesh_material.params = static_mesh_material.params;
 
     animated_mesh.draw(view_mats, model);
     cube1.draw(view_mats, Mat4.identity);

src/examples/meshbuilder.zig

@@ -61,19 +61,19 @@ pub fn on_init() !void {
     camera = delve.graphics.camera.Camera.initThirdPerson(90.0, 0.01, 20.0, 5.0, math.Vec3.up);
 
     // make a cube
-    cube1 = delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), math.Vec3.new(2, 3, 1), delve.colors.white, material) catch {
+    cube1 = delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), math.Vec3.new(2, 3, 1), delve.colors.white, &material) catch {
         delve.debug.log("Could not create cube!", .{});
         return;
     };
 
     // and another
-    cube2 = delve.graphics.mesh.createCube(math.Vec3.new(3, 0, -1), math.Vec3.new(1, 1, 2), delve.colors.green, material) catch {
+    cube2 = delve.graphics.mesh.createCube(math.Vec3.new(3, 0, -1), math.Vec3.new(1, 1, 2), delve.colors.green, &material) catch {
         delve.debug.log("Could not create cube!", .{});
         return;
     };
 
     // and then a floor
-    cube3 = delve.graphics.mesh.createCube(math.Vec3.new(0, -2, 0), math.Vec3.new(12, 0.25, 12), delve.colors.red, material) catch {
+    cube3 = delve.graphics.mesh.createCube(math.Vec3.new(0, -2, 0), math.Vec3.new(12, 0.25, 12), delve.colors.red, &material) catch {
         delve.debug.log("Could not create cube!", .{});
         return;
     };

src/examples/meshes.zig

@@ -24,6 +24,7 @@ const emissive_shader_builtin = delve.shaders.default_emissive;
 
 var time: f32 = 0.0;
 var mesh_test: ?mesh.Mesh = null;
+var material: graphics.Material = undefined;
 var camera: cam.Camera = undefined;
 
 // This example shows loading and drawing meshes
@@ -92,14 +93,14 @@ fn on_init() !void {
     }
 
     // Create a material out of our shader and textures
-    const material = graphics.Material.init(.{
+    material = graphics.Material.init(.{
         .shader = shader.?,
         .texture_0 = tex_base,
         .texture_1 = tex_emissive,
     });
 
     // Load our mesh!
-    mesh_test = mesh.Mesh.initFromFile(delve.mem.getAllocator(), "assets/meshes/SciFiHelmet.gltf", .{ .material = material });
+    mesh_test = mesh.Mesh.initFromFile(delve.mem.getAllocator(), "assets/meshes/SciFiHelmet.gltf", .{ .material = &material });
 }
 
 fn on_tick(delta: f32) void {

src/examples/passes.zig

@@ -93,19 +93,19 @@ pub fn on_init() !void {
     camera_offscreen = delve.graphics.camera.Camera.initThirdPerson(90.0, 0.01, 200.0, 5.0, math.Vec3.up);
 
     // make a cube
-    cube1 = delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), math.Vec3.new(2, 3, 1), delve.colors.white, material1) catch {
+    cube1 = delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), math.Vec3.new(2, 3, 1), delve.colors.white, &material1) catch {
         delve.debug.log("Could not create cube!", .{});
         return;
     };
 
     // and another
-    cube2 = delve.graphics.mesh.createCube(math.Vec3.new(3, 0, -1), math.Vec3.new(1, 1, 2), delve.colors.white, material3) catch {
+    cube2 = delve.graphics.mesh.createCube(math.Vec3.new(3, 0, -1), math.Vec3.new(1, 1, 2), delve.colors.white, &material3) catch {
         delve.debug.log("Could not create cube!", .{});
         return;
     };
 
     // and then a screen
-    cube3 = delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), math.Vec3.new(20, 12.0, 0.25), delve.colors.white, material2) catch {
+    cube3 = delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), math.Vec3.new(20, 12.0, 0.25), delve.colors.white, &material2) catch {
         delve.debug.log("Could not create cube!", .{});
         return;
     };

src/examples/quakemap.zig

@@ -9,10 +9,13 @@ const math = delve.math;
 
 var camera: delve.graphics.camera.Camera = undefined;
 var fallback_material: graphics.Material = undefined;
+var fallback_quake_material: delve.utils.quakemap.QuakeMaterial = undefined;
+var materials: std.StringHashMap(delve.utils.quakemap.QuakeMaterial) = undefined;
 
 var quake_map: delve.utils.quakemap.QuakeMap = undefined;
 var map_meshes: std.ArrayList(delve.graphics.mesh.Mesh) = undefined;
 var entity_meshes: std.ArrayList(delve.graphics.mesh.Mesh) = undefined;
+
 var cube_mesh: delve.graphics.mesh.Mesh = undefined;
 
 var map_transform: math.Mat4 = undefined;
@@ -150,14 +153,16 @@ pub fn on_init() !void {
         .samplers = &[_]graphics.FilterMode{.NEAREST},
     });
 
+    fallback_quake_material = .{ .material = fallback_material };
+
     // create our camera
     camera = delve.graphics.camera.Camera.initThirdPerson(90.0, 0.01, 512, 16.0, math.Vec3.up);
     camera.position.y = 10.0;
 
     // set our player position too
     player_pos = camera.position;
 
-    var materials = std.StringHashMap(delve.utils.quakemap.QuakeMaterial).init(allocator);
+    materials = std.StringHashMap(delve.utils.quakemap.QuakeMaterial).init(allocator);
     const shader = graphics.Shader.initDefault(.{ .vertex_attributes = delve.graphics.mesh.getShaderAttributes() });
 
     for (quake_map.worldspawn.solids.items) |solid| {
@@ -197,11 +202,11 @@ pub fn on_init() !void {
     }
 
     // make meshes out of the quake map, one per material
-    map_meshes = try quake_map.buildWorldMeshes(allocator, math.Mat4.identity, materials, .{ .material = fallback_material });
-    entity_meshes = try quake_map.buildEntityMeshes(allocator, math.Mat4.identity, materials, .{ .material = fallback_material });
+    map_meshes = try quake_map.buildWorldMeshes(allocator, math.Mat4.identity, &materials, &fallback_quake_material);
+    entity_meshes = try quake_map.buildEntityMeshes(allocator, math.Mat4.identity, &materials, &fallback_quake_material);
 
     // make a bounding box cube
-    cube_mesh = try delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), bounding_box_size, delve.colors.red, fallback_material);
+    cube_mesh = try delve.graphics.mesh.createCube(math.Vec3.new(0, 0, 0), bounding_box_size, delve.colors.red, &fallback_material);
 
     // set a bg color
     delve.platform.graphics.setClearColor(delve.colors.examples_bg_light);

src/examples/rays.zig

@@ -76,17 +76,17 @@ pub fn on_init() !void {
     camera.position = delve.math.Vec3.new(0, 30, 32);
     camera.pitch_angle = -50.0;
 
-    cube_mesh = delve.graphics.mesh.createCube(delve.math.Vec3.new(0, 0, 0), delve.math.Vec3.new(1, 1, 1), delve.colors.white, material_cube) catch {
+    cube_mesh = delve.graphics.mesh.createCube(delve.math.Vec3.new(0, 0, 0), delve.math.Vec3.new(1, 1, 1), delve.colors.white, &material_cube) catch {
         delve.debug.fatal("Could not create cube mesh!", .{});
         return;
     };
 
-    hit_mesh = delve.graphics.mesh.createCube(delve.math.Vec3.new(0, 0, 0), delve.math.Vec3.new(0.5, 0.5, 0.5), delve.colors.white, material_cube) catch {
+    hit_mesh = delve.graphics.mesh.createCube(delve.math.Vec3.new(0, 0, 0), delve.math.Vec3.new(0.5, 0.5, 0.5), delve.colors.white, &material_cube) catch {
         delve.debug.fatal("Could not create cube mesh!", .{});
         return;
     };
 
-    ray_mesh = delve.graphics.mesh.createCube(delve.math.Vec3.new(50, 0, 0), delve.math.Vec3.new(100, 0.1, 0.1), delve.colors.red, material_cube) catch {
+    ray_mesh = delve.graphics.mesh.createCube(delve.math.Vec3.new(50, 0, 0), delve.math.Vec3.new(100, 0.1, 0.1), delve.colors.red, &material_cube) catch {
         delve.debug.fatal("Could not create cube mesh!", .{});
         return;
     };

src/examples/skinned-meshes.zig

@@ -22,6 +22,7 @@ const Color = colors.Color;
 
 const shader_builtin = delve.shaders.default_skinned;
 
+var material: delve.platform.graphics.Material = undefined;
 var mesh_test: skinned_mesh.SkinnedMesh = undefined;
 var animation: skinned_mesh.PlayingAnimation = undefined;
 
@@ -90,7 +91,7 @@ fn on_init() !void {
     const tex_base = graphics.Texture.init(&base_img);
 
     // Create a material out of our shader and textures
-    const material = delve.platform.graphics.Material.init(.{
+    material = delve.platform.graphics.Material.init(.{
         .shader = shader.?,
         .texture_0 = tex_base,
         .texture_1 = delve.platform.graphics.createSolidTexture(0x00000000),
@@ -100,7 +101,7 @@ fn on_init() !void {
     });
 
     // Load our mesh!
-    const loaded = skinned_mesh.SkinnedMesh.initFromFile(delve.mem.getAllocator(), mesh_file, .{ .material = material });
+    const loaded = skinned_mesh.SkinnedMesh.initFromFile(delve.mem.getAllocator(), mesh_file, .{ .material = &material });
 
     if (loaded == null) {
         debug.fatal("Could not load skinned mesh!", .{});

src/framework/graphics/mesh.zig

@@ -24,7 +24,7 @@ const FSParams = graphics.FSDefaultUniforms;
 const vertex_layout = getVertexLayout();
 
 pub const MeshConfig = struct {
-    material: ?graphics.Material = null,
+    material: ?*graphics.Material = null,
 };
 
 pub fn init() !void {
@@ -39,7 +39,7 @@ pub fn deinit() void {
 /// These can be created on the fly, using a MeshBuilder, or loaded from GLTF files.
 pub const Mesh = struct {
     bindings: graphics.Bindings = undefined,
-    material: graphics.Material = undefined,
+    material: *graphics.Material = undefined,
     bounds: boundingbox.BoundingBox = undefined,
 
     has_skin: bool = false,
@@ -107,10 +107,12 @@ pub const Mesh = struct {
             }
         }
 
-        var material: graphics.Material = undefined;
+        var material: *graphics.Material = undefined;
         if (cfg.material == null) {
-            const tex = graphics.createDebugTexture();
-            material = graphics.Material.init(.{ .texture_0 = tex });
+            // Todo: Use a backup material!
+            debug.log("No material in mesh config!", .{});
+            // const tex = graphics.createDebugTexture();
+            // material = graphics.Material.init(.{ .texture_0 = tex });
         } else {
             material = cfg.material.?;
         }
@@ -158,7 +160,7 @@ pub const Mesh = struct {
 
     /// Draw this mesh
     pub fn draw(self: *Mesh, cam_matrices: CameraMatrices, model_matrix: math.Mat4) void {
-        graphics.drawWithMaterial(&self.bindings, &self.material, cam_matrices, model_matrix);
+        graphics.drawWithMaterial(&self.bindings, self.material, cam_matrices, model_matrix);
     }
 
     /// Draw this mesh, using the specified material instead of the set one
@@ -168,12 +170,12 @@ pub const Mesh = struct {
 };
 
 /// Create a mesh out of some vertex data
-pub fn createMesh(vertices: []PackedVertex, indices: []u32, normals: [][3]f32, tangents: [][4]f32, material: graphics.Material) Mesh {
+pub fn createMesh(vertices: []PackedVertex, indices: []u32, normals: [][3]f32, tangents: [][4]f32, material: *graphics.Material) Mesh {
     // create a mesh with the default vertex layout
     return createMeshWithLayout(vertices, indices, normals, tangents, material, vertex_layout);
 }
 
-pub fn createSkinnedMesh(vertices: []PackedVertex, indices: []u32, normals: [][3]f32, tangents: [][4]f32, joints: [][4]f32, weights: [][4]f32, material: graphics.Material, data: *zmesh.io.zcgltf.Data) Mesh {
+pub fn createSkinnedMesh(vertices: []PackedVertex, indices: []u32, normals: [][3]f32, tangents: [][4]f32, joints: [][4]f32, weights: [][4]f32, material: *graphics.Material, data: *zmesh.io.zcgltf.Data) Mesh {
     // create a mesh with the default vertex layout
     // debug.log("Creating skinned mesh: {d} indices, {d} normals, {d}tangents, {d} joints, {d} weights", .{ indices.len, normals.len, tangents.len, joints.len, weights.len });
 
@@ -199,7 +201,7 @@ pub fn createSkinnedMesh(vertices: []PackedVertex, indices: []u32, normals: [][3
 }
 
 /// Create a mesh out of some vertex data with a given vertex layout
-pub fn createMeshWithLayout(vertices: []PackedVertex, indices: []u32, normals: [][3]f32, tangents: [][4]f32, material: graphics.Material, layout: graphics.VertexLayout) Mesh {
+pub fn createMeshWithLayout(vertices: []PackedVertex, indices: []u32, normals: [][3]f32, tangents: [][4]f32, material: *graphics.Material, layout: graphics.VertexLayout) Mesh {
     // debug.log("Creating mesh: {d} indices", .{indices.len});
 
     var bindings = graphics.Bindings.init(.{
@@ -219,7 +221,7 @@ pub fn createMeshWithLayout(vertices: []PackedVertex, indices: []u32, normals: [
 }
 
 /// Creates a cube using a mesh builder
-pub fn createCube(pos: Vec3, size: Vec3, color: Color, material: graphics.Material) !Mesh {
+pub fn createCube(pos: Vec3, size: Vec3, color: Color, material: *graphics.Material) !Mesh {
     var builder = MeshBuilder.init(mem.getAllocator());
     defer builder.deinit();
 
@@ -466,7 +468,7 @@ pub const MeshBuilder = struct {
     }
 
     /// Bakes a mesh out of the mesh builder from the current state
-    pub fn buildMesh(self: *const MeshBuilder, material: graphics.Material) Mesh {
+    pub fn buildMesh(self: *const MeshBuilder, material: *graphics.Material) Mesh {
         const layout = getVertexLayout();
         return createMeshWithLayout(self.vertices.items, self.indices.items, self.normals.items, self.tangents.items, material, layout);
     }

src/framework/graphics/skinned-mesh.zig

@@ -222,7 +222,7 @@ pub const SkinnedMesh = struct {
             self.applySkeletonTransforms();
 
         self.mesh.material.params.joints = &self.joint_locations;
-        graphics.drawWithMaterial(&self.mesh.bindings, &self.mesh.material, cam_matrices, model_matrix);
+        graphics.drawWithMaterial(&self.mesh.bindings, self.mesh.material, cam_matrices, model_matrix);
     }
 
     /// Draw this mesh, using the specified material instead of the set one