unified shaders

Author: btipling

src/foundations/object/object_quad/ObjectQuad.zig

@@ -27,13 +27,21 @@ pub const default_correct_indices: [6]u32 = .{
 };
 
 pub fn init(
-    vertex_shader: []const u8,
-    frag_shader: []const u8,
+    allocator: std.mem.Allocator,
+    vertex_partials: []const []const u8,
+    frag_shader: rhi.Shader.fragment_shader_type,
     positions: [6][3]f32,
     colors: [6][4]f32,
 ) Quad {
     const program = rhi.createProgram();
-    rhi.attachShaders(program, vertex_shader, frag_shader);
+    {
+        var s: rhi.Shader = .{
+            .program = program,
+            .instance_data = true,
+            .fragment_shader = frag_shader,
+        };
+        s.attach(allocator, vertex_partials);
+    }
 
     var data: [6]rhi.attributeData = undefined;
     var i: usize = 0;

src/foundations/object/object_triangle/ObjectTriangle.zig

@@ -21,14 +21,22 @@ pub const default_normals: [3][3]f32 = .{
 };
 
 pub fn init(
-    vertex_shader: []const u8,
-    frag_shader: []const u8,
+    allocator: std.mem.Allocator,
+    vertex_partials: []const []const u8,
+    frag_shader: rhi.Shader.fragment_shader_type,
     positions: [3][3]f32,
     colors: [3][4]f32,
     normals: [3][3]f32,
 ) Triangle {
     const program = rhi.createProgram();
-    rhi.attachShaders(program, vertex_shader, frag_shader);
+    {
+        var s: rhi.Shader = .{
+            .program = program,
+            .instance_data = true,
+            .fragment_shader = frag_shader,
+        };
+        s.attach(allocator, vertex_partials);
+    }
     return initWithProgram(program, positions, colors, normals);
 }
 
@@ -63,4 +71,5 @@ pub fn initWithProgram(
     };
 }
 
+const std = @import("std");
 const rhi = @import("../../rhi/rhi.zig");

src/foundations/rhi/Shader.zig

@@ -0,0 +1,93 @@
+fragment_shader: fragment_shader_type,
+instance_data: bool,
+vertex_partials: [max_vertex_partials][]const u8 = undefined,
+num_vertex_partials: usize = 0,
+program: u32 = 0,
+
+const max_vertex_partials: usize = 10;
+
+pub const fragment_shader_type = enum(usize) {
+    color,
+    normals,
+    texture,
+};
+
+pub inline fn single_vertex(vertex_shader: []const u8) [1][]const u8 {
+    return [_][]const u8{vertex_shader};
+}
+
+const Shader = @This();
+
+const vertex_attrib_header = @embedFile("../shaders/vertex_attrib_header.glsl");
+const vertex_attrib_i_data = @embedFile("../shaders/vertex_attrib_i_data.glsl");
+
+const frag_color = @embedFile("../shaders/frag_color.glsl");
+const frag_normals = @embedFile("../shaders/frag_normals.glsl");
+const frag_texture = @embedFile("../shaders/frag_texture.glsl");
+
+pub fn attach(self: *Shader, allocator: std.mem.Allocator, vertex_partials: []const []const u8) void {
+    const frag = switch (self.fragment_shader) {
+        .color => frag_color,
+        .normals => frag_normals,
+        .texture => frag_texture,
+    };
+
+    {
+        self.vertex_partials[self.num_vertex_partials] = vertex_attrib_header;
+        self.num_vertex_partials += 1;
+    }
+    if (self.instance_data) {
+        self.vertex_partials[self.num_vertex_partials] = vertex_attrib_i_data;
+        self.num_vertex_partials += 1;
+    }
+    for (vertex_partials) |partial| {
+        self.vertex_partials[self.num_vertex_partials] = partial;
+        self.num_vertex_partials += 1;
+    }
+    const vertex = std.mem.concat(allocator, u8, self.vertex_partials[0..self.num_vertex_partials]) catch @panic("OOM");
+    defer allocator.free(vertex);
+
+    const shaders = [_]struct { source: []const u8, shader_type: c.GLenum }{
+        .{ .source = vertex, .shader_type = c.GL_VERTEX_SHADER },
+        .{ .source = frag, .shader_type = c.GL_FRAGMENT_SHADER },
+    };
+    const log_len: usize = 1024;
+
+    var i: usize = 0;
+    while (i < shaders.len) : (i += 1) {
+        const source: [:0]u8 = std.mem.concatWithSentinel(allocator, u8, &[_][]const u8{shaders[i].source}, 0) catch @panic("OOM");
+        defer allocator.free(source);
+
+        const shader = c.glCreateShader(shaders[i].shader_type);
+
+        c.glShaderSource(shader, 1, &[_][*c]const u8{source.ptr}, null);
+        c.glCompileShader(shader);
+
+        var success: c.GLint = 0;
+        c.glGetShaderiv(shader, c.GL_COMPILE_STATUS, &success);
+        if (success == c.GL_FALSE) {
+            var infoLog: [log_len]u8 = std.mem.zeroes([log_len]u8);
+            var logSize: c.GLsizei = 0;
+            c.glGetShaderInfoLog(shader, @intCast(log_len), &logSize, @ptrCast(&infoLog));
+            const len: usize = @intCast(logSize);
+            std.debug.panic("ERROR::SHADER::COMPILATION_FAILED\n{s}\n{s}\n", .{ infoLog[0..len], source });
+        }
+        c.glAttachShader(@intCast(self.program), shader);
+    }
+    {
+        c.glLinkProgram(@intCast(self.program));
+        var success: c.GLint = 0;
+        c.glGetProgramiv(@intCast(self.program), c.GL_LINK_STATUS, &success);
+        if (success == c.GL_FALSE) {
+            var infoLog: [log_len]u8 = std.mem.zeroes([log_len]u8);
+            var logSize: c.GLsizei = 0;
+            c.glGetProgramInfoLog(@intCast(self.program), @intCast(log_len), &logSize, @ptrCast(&infoLog));
+            const len: usize = @intCast(logSize);
+            std.debug.panic("ERROR::PROGRAM::LINKING_FAILED\n{s}\n", .{infoLog[0..len]});
+        }
+    }
+    return;
+}
+
+const std = @import("std");
+const c = @import("../c.zig").c;

src/foundations/rhi/rhi.zig

@@ -193,49 +193,6 @@ pub fn initEBO(indices: []const u32, vao: u32) u32 {
     return ebo;
 }
 
-pub fn attachShaders(program: u32, vertex: []const u8, frag: []const u8) void {
-    const shaders = [_]struct { source: []const u8, shader_type: c.GLenum }{
-        .{ .source = vertex, .shader_type = c.GL_VERTEX_SHADER },
-        .{ .source = frag, .shader_type = c.GL_FRAGMENT_SHADER },
-    };
-    const log_len: usize = 1024;
-
-    var i: usize = 0;
-    while (i < shaders.len) : (i += 1) {
-        const source: [:0]u8 = std.mem.concatWithSentinel(rhi.allocator, u8, &[_][]const u8{shaders[i].source}, 0) catch @panic("OOM");
-        defer rhi.allocator.free(source);
-
-        const shader = c.glCreateShader(shaders[i].shader_type);
-
-        c.glShaderSource(shader, 1, &[_][*c]const u8{source.ptr}, null);
-        c.glCompileShader(shader);
-
-        var success: c.GLint = 0;
-        c.glGetShaderiv(shader, c.GL_COMPILE_STATUS, &success);
-        if (success == c.GL_FALSE) {
-            var infoLog: [log_len]u8 = std.mem.zeroes([log_len]u8);
-            var logSize: c.GLsizei = 0;
-            c.glGetShaderInfoLog(shader, @intCast(log_len), &logSize, @ptrCast(&infoLog));
-            const len: usize = @intCast(logSize);
-            std.debug.panic("ERROR::SHADER::COMPILATION_FAILED\n{s}\n{s}\n", .{ infoLog[0..len], source });
-        }
-        c.glAttachShader(@intCast(program), shader);
-    }
-    {
-        c.glLinkProgram(@intCast(program));
-        var success: c.GLint = 0;
-        c.glGetProgramiv(@intCast(program), c.GL_LINK_STATUS, &success);
-        if (success == c.GL_FALSE) {
-            var infoLog: [log_len]u8 = std.mem.zeroes([log_len]u8);
-            var logSize: c.GLsizei = 0;
-            c.glGetProgramInfoLog(@intCast(program), @intCast(log_len), &logSize, @ptrCast(&infoLog));
-            const len: usize = @intCast(logSize);
-            std.debug.panic("ERROR::PROGRAM::LINKING_FAILED\n{s}\n", .{infoLog[0..len]});
-        }
-    }
-    return;
-}
-
 pub fn drawArrays(program: u32, vao: u32, count: usize) void {
     c.glUseProgram(@intCast(program));
     c.glBindVertexArray(vao);
@@ -391,3 +348,4 @@ const object = @import("../object/object.zig");
 pub const Mesh = @import("./Mesh.zig");
 pub const Uniform = @import("Uniform.zig");
 pub const Texture = @import("Texture.zig");
+pub const Shader = @import("Shader.zig");

src/foundations/scenery/grid/Grid.zig

@@ -13,7 +13,6 @@ const num_grid_lines: usize = 101;
 const grid_increments: usize = 1;
 
 const grid_vertex_shader: []const u8 = @embedFile("grid_vertex.glsl");
-const grid_frag_shader: []const u8 = @embedFile("grid_frag.glsl");
 
 pub fn init(allocator: std.mem.Allocator) *Grid {
     const grid = allocator.create(Grid) catch @panic("OOM");
@@ -48,7 +47,14 @@ pub fn program(self: *Grid) u32 {
 
 fn renderGrid(self: *Grid) void {
     const prog = rhi.createProgram();
-    rhi.attachShaders(prog, grid_vertex_shader, grid_frag_shader);
+    {
+        var s: rhi.Shader = .{
+            .program = prog,
+            .instance_data = true,
+            .fragment_shader = .color,
+        };
+        s.attach(self.allocator, rhi.Shader.single_vertex(grid_vertex_shader)[0..]);
+    }
     var i_datas: [num_grid_lines * 2]rhi.instanceData = undefined;
     var i_data_i: usize = 0;
     for (0..2) |axis| {

src/foundations/scenery/grid/grid_frag.glsl

@@ -1,18 +1,7 @@
-#version 460 core
-layout (location = 0) in vec3 f_position;
-layout (location = 1) in vec4 f_color;
-layout (location = 2) in vec3 f_normals;
-layout (location = 3) in vec2 f_texture_coords;
-layout (location = 4) in vec4 f_t_column0;
-layout (location = 5) in vec4 f_t_column1;
-layout (location = 6) in vec4 f_t_column2;
-layout (location = 7) in vec4 f_t_column3;
-layout (location = 8) in vec4 f_i_color;
-
 
 uniform mat4 f_mvp;
 
-out vec4 fo_color;
+out vec4 f_frag_color;
 out vec3 fo_normals;
 
 void main()
@@ -25,6 +14,6 @@ void main()
     );
     vec4 pos = f_mvp * f_transform * vec4(f_position.xyz, 1.0);
     gl_Position = pos;
-    fo_color = f_i_color;
+    f_frag_color = f_i_color;
     fo_normals = transpose(inverse(mat3(f_transform))) * f_normals;
 }

src/foundations/scenery/grid/grid_vertex.glsl

@@ -7,7 +7,6 @@ pub const mvp_uniform_name: []const u8 = "f_mvp";
 pub const pointer_uniform_name: []const u8 = "f_pointer_transform";
 
 const pointer_vertex_shader: []const u8 = @embedFile("pointer_vertex.glsl");
-const pointer_frag_shader: []const u8 = @embedFile("pointer_frag.glsl");
 
 pub fn init(allocator: std.mem.Allocator) *Pointer {
     const pointer = allocator.create(Pointer) catch @panic("OOM");
@@ -43,7 +42,14 @@ pub fn programs(self: *Pointer) [2]u32 {
 
 pub fn renderCylinder(self: *Pointer) void {
     const prog = rhi.createProgram();
-    rhi.attachShaders(prog, pointer_vertex_shader, pointer_frag_shader);
+    {
+        var s: rhi.Shader = .{
+            .program = prog,
+            .instance_data = true,
+            .fragment_shader = .normals,
+        };
+        s.attach(self.allocator, rhi.Shader.single_vertex(pointer_vertex_shader)[0..]);
+    }
     var i_datas: [1]rhi.instanceData = undefined;
     var m = math.matrix.identity();
     m = math.matrix.transformMatrix(m, math.matrix.translate(0, 0.075, 0));
@@ -69,7 +75,14 @@ pub fn renderCylinder(self: *Pointer) void {
 
 pub fn renderCone(self: *Pointer) void {
     const prog = rhi.createProgram();
-    rhi.attachShaders(prog, pointer_vertex_shader, pointer_frag_shader);
+    {
+        var s: rhi.Shader = .{
+            .program = prog,
+            .instance_data = true,
+            .fragment_shader = .normals,
+        };
+        s.attach(self.allocator, rhi.Shader.single_vertex(pointer_vertex_shader)[0..]);
+    }
     var i_datas: [1]rhi.instanceData = undefined;
     var m = math.matrix.identity();
     m = math.matrix.transformMatrix(m, math.matrix.translate(3.85, 0, 0));

src/foundations/scenery/pointer/Pointer.zig

@@ -1,19 +1,7 @@
-#version 460 core
-layout (location = 0) in vec3 f_position;
-layout (location = 1) in vec4 f_color;
-layout (location = 2) in vec3 f_normals;
-layout (location = 3) in vec2 f_texture_coords;
-layout (location = 4) in vec4 f_t_column0;
-layout (location = 5) in vec4 f_t_column1;
-layout (location = 6) in vec4 f_t_column2;
-layout (location = 7) in vec4 f_t_column3;
-layout (location = 8) in vec4 f_i_color;
-
-
 uniform mat4 f_pointer_transform;
 uniform mat4 f_mvp;
 
-out vec4 fo_color;
+out vec4 f_frag_color;
 out vec3 fo_normals;
 
 void main()
@@ -27,6 +15,6 @@ void main()
     f_transform = f_pointer_transform * f_transform;
     vec4 pos = f_mvp * f_transform * vec4(f_position.xyz, 1.0);
     gl_Position = pos;
-    fo_color = f_i_color;
+    f_frag_color = f_i_color;
     fo_normals = normalize(transpose(inverse(mat3(f_pointer_transform))) * f_normals);
 }