Merge pull request #52 from Interrupt/features/simple-materials-api

Updating the Materials API so that materials own pointers to their material params

Author: Interrupt

src/examples/frustums.zig

@@ -44,20 +44,20 @@ pub fn on_init() !void {
     const shader = delve.platform.graphics.Shader.initFromBuiltin(.{ .vertex_attributes = delve.graphics.mesh.getShaderAttributes() }, delve.shaders.default_mesh);
 
     // Create some materials
-    material_frustum = delve.platform.graphics.Material.init(.{
+    material_frustum = try delve.platform.graphics.Material.init(.{
         .shader = shader,
         .texture_0 = delve.platform.graphics.createSolidTexture(0x66FFFFFF),
         .cull_mode = .NONE,
         .depth_write_enabled = false,
         .blend_mode = .BLEND,
     });
 
-    material_cube = delve.platform.graphics.Material.init(.{
+    material_cube = try delve.platform.graphics.Material.init(.{
         .shader = shader,
         .texture_0 = delve.platform.graphics.tex_white,
     });
 
-    material_highlight = delve.platform.graphics.Material.init(.{
+    material_highlight = try delve.platform.graphics.Material.init(.{
         .shader = shader,
         .texture_0 = delve.platform.graphics.createSolidTexture(0xFF0000CC),
     });
@@ -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;
     };
@@ -111,7 +111,7 @@ pub fn on_draw() void {
             const bounds = cube_mesh.bounds.translate(cube_pos);
 
             if (frustum.containsBoundingBox(bounds)) {
-                cube_mesh.drawWithMaterial(&material_highlight, view_mats, cube_model_matrix);
+                cube_mesh.drawWithMaterial(material_highlight, view_mats, cube_model_matrix);
             } else {
                 cube_mesh.draw(view_mats, cube_model_matrix);
             }
@@ -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

@@ -90,7 +90,7 @@ fn on_init() !void {
     const tex_base = graphics.Texture.init(&base_img);
 
     // Create a material out of our shader and textures
-    skinned_mesh_material = delve.platform.graphics.Material.init(.{
+    skinned_mesh_material = try delve.platform.graphics.Material.init(.{
         .shader = skinned_shader.?,
         .texture_0 = tex_base,
         .texture_1 = delve.platform.graphics.createSolidTexture(0x00000000),
@@ -103,7 +103,7 @@ fn on_init() !void {
     });
 
     // Create a material out of the texture
-    static_mesh_material = graphics.Material.init(.{
+    static_mesh_material = try graphics.Material.init(.{
         .shader = static_shader.?,
         .texture_0 = delve.platform.graphics.createSolidTexture(0xFFFFFFFF),
         .texture_1 = delve.platform.graphics.createSolidTexture(0x00000000),
@@ -113,16 +113,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);
@@ -163,10 +163,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
-    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;
+    static_mesh_material.state.params.point_lights = @constCast(point_lights);
+    static_mesh_material.state.params.directional_light = directional_light;
+    static_mesh_material.state.params.ambient_light = colors.Color.new(0.02, 0.02, 0.05, 1.0);
+    skinned_mesh_material.state.params = static_mesh_material.state.params;
 
     animated_mesh.draw(view_mats, model);
     cube1.draw(view_mats, Mat4.identity);

src/examples/meshbuilder.zig

@@ -52,7 +52,7 @@ pub fn on_init() !void {
     const shader = graphics.Shader.initFromBuiltin(.{ .vertex_attributes = delve.graphics.mesh.getShaderAttributes() }, delve.shaders.default_mesh);
 
     // Create a material out of the texture
-    material = graphics.Material.init(.{
+    material = try graphics.Material.init(.{
         .shader = shader,
         .texture_0 = tex,
         .samplers = &[_]graphics.FilterMode{.NEAREST},
@@ -62,19 +62,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

@@ -95,14 +95,14 @@ fn on_init() !void {
     }
 
     // Create a material out of our shader and textures
-    material = graphics.Material.init(.{
+    material = try 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 {
@@ -126,7 +126,7 @@ fn on_draw() void {
     model = model.mul(Mat4.rotate(time * 0.6, Vec3.new(0.0, 1.0, 0.0)));
 
     const sin_val = std.math.sin(time * 0.006) + 0.5;
-    mesh_test.?.material.params.draw_color = Color.new(sin_val, sin_val, sin_val, 1.0);
+    mesh_test.?.material.state.params.draw_color = Color.new(sin_val, sin_val, sin_val, 1.0);
     mesh_test.?.draw(view_mats, model);
 
     model = Mat4.translate(Vec3.new(-2.0, 0.0, 0.0));

src/examples/quakemap.zig

@@ -147,7 +147,7 @@ pub fn on_init() !void {
     quake_map = try delve.utils.quakemap.QuakeMap.read(allocator, test_map_file, map_transform, &err);
 
     // Create a material out of the texture
-    fallback_material = graphics.Material.init(.{
+    fallback_material = try graphics.Material.init(.{
         .shader = graphics.Shader.initDefault(.{ .vertex_attributes = delve.graphics.mesh.getShaderAttributes() }),
         .texture_0 = fallback_tex,
         .samplers = &[_]graphics.FilterMode{.NEAREST},
@@ -190,7 +190,7 @@ pub fn on_init() !void {
                 defer tex_img.deinit();
                 const tex = graphics.Texture.init(&tex_img);
 
-                const mat = graphics.Material.init(.{
+                const mat = try graphics.Material.init(.{
                     .shader = shader,
                     .samplers = &[_]graphics.FilterMode{.NEAREST},
                     .texture_0 = tex,
@@ -207,7 +207,7 @@ pub fn on_init() !void {
     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

@@ -46,25 +46,25 @@ pub fn on_init() !void {
     const shader = delve.platform.graphics.Shader.initFromBuiltin(.{ .vertex_attributes = delve.graphics.mesh.getShaderAttributes() }, delve.shaders.default_mesh);
 
     // Create some materials
-    material_frustum = delve.platform.graphics.Material.init(.{
+    material_frustum = try delve.platform.graphics.Material.init(.{
         .shader = shader,
         .texture_0 = delve.platform.graphics.createSolidTexture(0x66FFFFFF),
         .cull_mode = .NONE,
         .depth_write_enabled = false,
         .blend_mode = .BLEND,
     });
 
-    material_cube = delve.platform.graphics.Material.init(.{
+    material_cube = try delve.platform.graphics.Material.init(.{
         .shader = shader,
         .texture_0 = delve.platform.graphics.tex_white,
     });
 
-    material_highlight = delve.platform.graphics.Material.init(.{
+    material_highlight = try delve.platform.graphics.Material.init(.{
         .shader = shader,
         .texture_0 = delve.platform.graphics.createSolidTexture(0xFF0000CC),
     });
 
-    material_hitpoint = delve.platform.graphics.Material.init(.{
+    material_hitpoint = try delve.platform.graphics.Material.init(.{
         .shader = shader,
         .texture_0 = delve.platform.graphics.createSolidTexture(0xFFFF0000),
     });
@@ -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;
     };
@@ -129,10 +129,10 @@ pub fn on_draw() void {
             const rayhit = ray.intersectOrientedBoundingBox(bounds);
 
             if (rayhit != null) {
-                cube_mesh.drawWithMaterial(&material_highlight, view_mats, cube_model_matrix);
+                cube_mesh.drawWithMaterial(material_highlight, view_mats, cube_model_matrix);
 
                 const hit_model_matrix = delve.math.Mat4.translate(rayhit.?.hit_pos);
-                hit_mesh.drawWithMaterial(&material_hitpoint, view_mats, hit_model_matrix);
+                hit_mesh.drawWithMaterial(material_hitpoint, view_mats, hit_model_matrix);
             } else {
                 cube_mesh.draw(view_mats, cube_model_matrix);
             }

src/examples/skinned-meshes.zig

@@ -92,7 +92,7 @@ fn on_init() !void {
     const tex_base = graphics.Texture.init(&base_img);
 
     // Create a material out of our shader and textures
-    material = delve.platform.graphics.Material.init(.{
+    material = try delve.platform.graphics.Material.init(.{
         .shader = shader.?,
         .texture_0 = tex_base,
         .texture_1 = delve.platform.graphics.createSolidTexture(0x00000000),
@@ -102,7 +102,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/examples/sprite-animation.zig

@@ -71,7 +71,7 @@ fn on_init() !void {
     shader_default = loaded_shader.?;
 
     // make a material to draw with
-    test_material = graphics.Material.init(.{
+    test_material = try graphics.Material.init(.{
         .shader = shader_default,
         .texture_0 = sprite_texture,
         .cull_mode = .BACK,
@@ -115,7 +115,7 @@ fn on_draw() void {
     sprite_batch.reset();
 
     // make sure we are using our material
-    sprite_batch.useMaterial(&test_material);
+    sprite_batch.useMaterial(test_material);
 
     // add our sprite rectangle
     const rect = delve.spatial.Rect.new(cur_frame.offset, cur_frame.size);

src/examples/sprites.zig

@@ -94,14 +94,14 @@ fn on_init() !void {
     shader_blend = graphics.Shader.initDefault(.{ .blend_mode = graphics.BlendMode.BLEND });
 
     // Create some test materials out of our shader and textures
-    test_material_1 = graphics.Material.init(.{
+    test_material_1 = try graphics.Material.init(.{
         .shader = shader_opaque,
         .texture_0 = graphics.tex_white,
         .cull_mode = .BACK,
         .blend_mode = .BLEND,
     });
 
-    test_material_2 = graphics.Material.init(.{
+    test_material_2 = try graphics.Material.init(.{
         .shader = shader_opaque,
         .texture_0 = texture_1,
         .cull_mode = .BACK,
@@ -177,12 +177,12 @@ fn pre_draw() void {
 
     // test using materials as well!
     // test a filled rectangle
-    test_batch.useMaterial(&test_material_1);
+    test_batch.useMaterial(test_material_1);
     test_batch.setTransformMatrix(math.Mat4.translate(math.vec3(0, 0, -0.001)));
 
     test_batch.addRectangle(rect1, sprites.TextureRegion.default(), colors.cyan.mul(Color{ .a = 0.75 }));
 
-    test_batch.useMaterial(&test_material_2);
+    test_batch.useMaterial(test_material_2);
     test_batch.setTransformMatrix(math.Mat4.translate(math.vec3(1, -1, -0.001)));
 
     const rect3 = Rect.new(math.vec2(-1.0, 0), math.vec2(1, 1));

src/framework/graphics/batcher.zig

@@ -33,7 +33,7 @@ const BatcherConfig = struct {
     min_indices: usize = 128,
     texture: ?graphics.Texture = null,
     shader: ?graphics.Shader = null,
-    material: ?*graphics.Material = null,
+    material: ?graphics.Material = null,
     flip_tex_y: bool = false,
 };
 
@@ -47,7 +47,7 @@ pub const SpriteBatcher = struct {
     current_batch_key: u64 = 0,
     current_tex: graphics.Texture = undefined,
     current_shader: graphics.Shader = undefined,
-    current_material: ?*graphics.Material = null,
+    current_material: ?graphics.Material = null,
 
     // If we needed to make resources, we need to clean them up later too
     owned_texture: ?graphics.Texture = null,
@@ -94,7 +94,7 @@ pub const SpriteBatcher = struct {
     }
 
     /// Switch the current batch to one for the given material
-    pub fn useMaterial(self: *SpriteBatcher, material: *graphics.Material) void {
+    pub fn useMaterial(self: *SpriteBatcher, material: graphics.Material) void {
         self.current_batch_key = makeSpriteBatchKeyFromMaterial(material);
         self.current_material = material;
     }
@@ -225,11 +225,8 @@ fn makeSpriteBatchKey(tex: graphics.Texture, shader: graphics.Shader) u64 {
     return tex.handle + (shader.handle * 1000000);
 }
 
-fn makeSpriteBatchKeyFromMaterial(material: *const graphics.Material) u64 {
-    // Hash the material, just like an auto map would.
-    var hasher = Wyhash.init(0);
-    autoHash(&hasher, material);
-    return hasher.final();
+fn makeSpriteBatchKeyFromMaterial(material: graphics.Material) u64 {
+    return @intCast(@intFromPtr(material.state));
 }
 
 /// Handles drawing a batch of primitive shapes all with the same texture / shader
@@ -241,7 +238,7 @@ pub const Batcher = struct {
     index_pos: usize,
     bindings: graphics.Bindings,
     shader: graphics.Shader,
-    material: ?*graphics.Material = null,
+    material: ?graphics.Material = null,
     transform: Mat4 = Mat4.identity,
     flip_tex_y: bool = false,
 
@@ -503,7 +500,7 @@ pub const Batcher = struct {
         if (self.material == null)
             return;
 
-        graphics.drawWithMaterial(&self.bindings, self.material.?, cam_matrices, model_matrix);
+        graphics.drawWithMaterial(&self.bindings, &self.material.?, cam_matrices, model_matrix);
     }
 
     /// Expand the buffers for this batch if needed to fit the new size