src/sysgpu: move mach-sysgpu@d6ed118f54c4784f7ce01b70fc1b94f887fae1a8 package to here

Helps hexops/mach#1165

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

src/sysgpu/opengl/c.zig

@@ -0,0 +1,6 @@
+pub usingnamespace @cImport({
+    @cInclude("windows.h");
+    @cInclude("GL/glcorearb.h");
+    @cInclude("GL/glext.h");
+    @cInclude("GL/wglext.h");
+});

src/sysgpu/opengl/conv.zig

@@ -0,0 +1,263 @@
+const sysgpu = @import("../sysgpu/main.zig");
+const utils = @import("../utils.zig");
+const c = @import("c.zig");
+
+fn stencilEnable(stencil: sysgpu.StencilFaceState) bool {
+    return stencil.compare != .always or stencil.fail_op != .keep or stencil.depth_fail_op != .keep or stencil.pass_op != .keep;
+}
+
+pub fn glAttributeCount(format: sysgpu.VertexFormat) c.GLint {
+    return switch (format) {
+        .undefined => unreachable,
+        .uint8x2 => 2,
+        .uint8x4 => 4,
+        .sint8x2 => 2,
+        .sint8x4 => 4,
+        .unorm8x2 => 2,
+        .unorm8x4 => 4,
+        .snorm8x2 => 2,
+        .snorm8x4 => 4,
+        .uint16x2 => 2,
+        .uint16x4 => 4,
+        .sint16x2 => 2,
+        .sint16x4 => 4,
+        .unorm16x2 => 2,
+        .unorm16x4 => 4,
+        .snorm16x2 => 2,
+        .snorm16x4 => 4,
+        .float16x2 => 2,
+        .float16x4 => 4,
+        .float32 => 1,
+        .float32x2 => 2,
+        .float32x3 => 3,
+        .float32x4 => 4,
+        .uint32 => 1,
+        .uint32x2 => 2,
+        .uint32x3 => 3,
+        .uint32x4 => 4,
+        .sint32 => 1,
+        .sint32x2 => 2,
+        .sint32x3 => 3,
+        .sint32x4 => 4,
+    };
+}
+
+pub fn glAttributeIsNormalized(format_type: utils.FormatType) c.GLboolean {
+    return switch (format_type) {
+        .unorm, .unorm_srgb, .snorm => c.GL_TRUE,
+        else => c.GL_FALSE,
+    };
+}
+
+pub fn glAttributeIsInt(format_type: utils.FormatType) bool {
+    return switch (format_type) {
+        .uint, .sint => true,
+        else => false,
+    };
+}
+
+pub fn glAttributeType(format: sysgpu.VertexFormat) c.GLenum {
+    return switch (format) {
+        .undefined => unreachable,
+        .uint8x2 => c.GL_UNSIGNED_BYTE,
+        .uint8x4 => c.GL_UNSIGNED_BYTE,
+        .sint8x2 => c.GL_BYTE,
+        .sint8x4 => c.GL_BYTE,
+        .unorm8x2 => c.GL_UNSIGNED_BYTE,
+        .unorm8x4 => c.GL_UNSIGNED_BYTE,
+        .snorm8x2 => c.GL_BYTE,
+        .snorm8x4 => c.GL_BYTE,
+        .uint16x2 => c.GL_UNSIGNED_SHORT,
+        .uint16x4 => c.GL_UNSIGNED_SHORT,
+        .sint16x2 => c.GL_SHORT,
+        .sint16x4 => c.GL_SHORT,
+        .unorm16x2 => c.GL_UNSIGNED_SHORT,
+        .unorm16x4 => c.GL_UNSIGNED_SHORT,
+        .snorm16x2 => c.GL_SHORT,
+        .snorm16x4 => c.GL_SHORT,
+        .float16x2 => c.GL_HALF_FLOAT,
+        .float16x4 => c.GL_HALF_FLOAT,
+        .float32 => c.GL_FLOAT,
+        .float32x2 => c.GL_FLOAT,
+        .float32x3 => c.GL_FLOAT,
+        .float32x4 => c.GL_FLOAT,
+        .uint32 => c.GL_UNSIGNED_INT,
+        .uint32x2 => c.GL_UNSIGNED_INT,
+        .uint32x3 => c.GL_UNSIGNED_INT,
+        .uint32x4 => c.GL_UNSIGNED_INT,
+        .sint32 => c.GL_INT,
+        .sint32x2 => c.GL_INT,
+        .sint32x3 => c.GL_INT,
+        .sint32x4 => c.GL_INT,
+    };
+}
+
+pub fn glBlendFactor(factor: sysgpu.BlendFactor, color: bool) c.GLenum {
+    return switch (factor) {
+        .zero => c.GL_ZERO,
+        .one => c.GL_ONE,
+        .src => c.GL_SRC_COLOR,
+        .one_minus_src => c.GL_ONE_MINUS_SRC_COLOR,
+        .src_alpha => c.GL_SRC_ALPHA,
+        .one_minus_src_alpha => c.GL_ONE_MINUS_SRC_ALPHA,
+        .dst => c.GL_DST_COLOR,
+        .one_minus_dst => c.GL_ONE_MINUS_DST_COLOR,
+        .dst_alpha => c.GL_DST_ALPHA,
+        .one_minus_dst_alpha => c.GL_ONE_MINUS_DST_ALPHA,
+        .src_alpha_saturated => c.GL_SRC_ALPHA_SATURATE,
+        .constant => if (color) c.GL_CONSTANT_COLOR else c.GL_CONSTANT_ALPHA,
+        .one_minus_constant => if (color) c.GL_ONE_MINUS_CONSTANT_COLOR else c.GL_ONE_MINUS_CONSTANT_ALPHA,
+        .src1 => c.GL_SRC1_COLOR,
+        .one_minus_src1 => c.GL_ONE_MINUS_SRC1_COLOR,
+        .src1_alpha => c.GL_SRC1_ALPHA,
+        .one_minus_src1_alpha => c.GL_ONE_MINUS_SRC1_ALPHA,
+    };
+}
+
+pub fn glBlendOp(op: sysgpu.BlendOperation) c.GLenum {
+    return switch (op) {
+        .add => c.GL_FUNC_ADD,
+        .subtract => c.GL_FUNC_SUBTRACT,
+        .reverse_subtract => c.GL_FUNC_REVERSE_SUBTRACT,
+        .min => c.GL_MIN,
+        .max => c.GL_MAX,
+    };
+}
+
+//pub fn glBufferDataUsage(usage: sysgpu.Buffer.UsageFlags, mapped_at_creation: sysgpu.Bool32) c.GLenum {}
+
+pub fn glBufferStorageFlags(usage: sysgpu.Buffer.UsageFlags, mapped_at_creation: sysgpu.Bool32) c.GLbitfield {
+    var flags: c.GLbitfield = 0;
+    if (mapped_at_creation == .true)
+        flags |= c.GL_MAP_WRITE_BIT;
+    if (usage.map_read)
+        flags |= c.GL_MAP_PERSISTENT_BIT | c.GL_MAP_READ_BIT;
+    if (usage.map_write)
+        flags |= c.GL_MAP_PERSISTENT_BIT | c.GL_MAP_COHERENT_BIT | c.GL_MAP_WRITE_BIT;
+    return flags;
+}
+
+pub fn glCompareFunc(func: sysgpu.CompareFunction) c.GLenum {
+    return switch (func) {
+        .undefined => unreachable,
+        .never => c.GL_NEVER,
+        .less => c.GL_LESS,
+        .less_equal => c.GL_LEQUAL,
+        .greater => c.GL_GREATER,
+        .greater_equal => c.GL_GEQUAL,
+        .equal => c.GL_EQUAL,
+        .not_equal => c.GL_NOTEQUAL,
+        .always => c.GL_ALWAYS,
+    };
+}
+
+pub fn glCullEnabled(cull_mode: sysgpu.CullMode) bool {
+    return switch (cull_mode) {
+        .none => false,
+        else => true,
+    };
+}
+
+pub fn glCullFace(cull_mode: sysgpu.CullMode) c.GLenum {
+    return switch (cull_mode) {
+        .none => c.GL_BACK,
+        .front => c.GL_FRONT,
+        .back => c.GL_BACK,
+    };
+}
+
+pub fn glDepthMask(ds: *const sysgpu.DepthStencilState) c.GLboolean {
+    return if (ds.depth_write_enabled == .true) c.GL_TRUE else c.GL_FALSE;
+}
+
+pub fn glDepthTestEnabled(ds: *const sysgpu.DepthStencilState) bool {
+    return ds.depth_compare != .always or ds.depth_write_enabled == .true;
+}
+
+pub fn glFrontFace(front_face: sysgpu.FrontFace) c.GLenum {
+    return switch (front_face) {
+        .ccw => c.GL_CCW,
+        .cw => c.GL_CW,
+    };
+}
+
+pub fn glIndexType(format: sysgpu.IndexFormat) c.GLenum {
+    return switch (format) {
+        .undefined => unreachable,
+        .uint16 => c.GL_UNSIGNED_SHORT,
+        .uint32 => c.GL_UNSIGNED_INT,
+    };
+}
+
+pub fn glIndexElementSize(format: sysgpu.IndexFormat) usize {
+    return switch (format) {
+        .undefined => unreachable,
+        .uint16 => 2,
+        .uint32 => 4,
+    };
+}
+
+pub fn glMapAccess(usage: sysgpu.Buffer.UsageFlags, mapped_at_creation: sysgpu.Bool32) c.GLbitfield {
+    var flags: c.GLbitfield = 0;
+    if (mapped_at_creation == .true)
+        flags |= c.GL_MAP_WRITE_BIT;
+    if (usage.map_read)
+        flags |= c.GL_MAP_PERSISTENT_BIT | c.GL_MAP_READ_BIT;
+    if (usage.map_write)
+        flags |= c.GL_MAP_PERSISTENT_BIT | c.GL_MAP_WRITE_BIT;
+    return flags;
+}
+
+pub fn glPrimitiveMode(topology: sysgpu.PrimitiveTopology) c.GLenum {
+    return switch (topology) {
+        .point_list => c.GL_POINTS,
+        .line_list => c.GL_LINES,
+        .line_strip => c.GL_LINE_STRIP,
+        .triangle_list => c.GL_TRIANGLES,
+        .triangle_strip => c.GL_TRIANGLE_STRIP,
+    };
+}
+
+pub fn glStencilOp(op: sysgpu.StencilOperation) c.GLenum {
+    return switch (op) {
+        .keep => c.GL_KEEP,
+        .zero => c.GL_ZERO,
+        .replace => c.GL_REPLACE,
+        .invert => c.GL_INVERT,
+        .increment_clamp => c.GL_INCR,
+        .decrement_clamp => c.GL_DECR,
+        .increment_wrap => c.GL_INCR_WRAP,
+        .decrement_wrap => c.GL_DECR_WRAP,
+    };
+}
+
+pub fn glStencilTestEnabled(ds: *const sysgpu.DepthStencilState) bool {
+    return stencilEnable(ds.stencil_front) or stencilEnable(ds.stencil_back);
+}
+
+pub fn glTargetForBuffer(usage: sysgpu.Buffer.UsageFlags) c.GLenum {
+    // Not sure if this matters anymore - only get to pick one anyway
+    if (usage.index)
+        return c.GL_ELEMENT_ARRAY_BUFFER;
+    if (usage.vertex)
+        return c.GL_ARRAY_BUFFER;
+    if (usage.uniform)
+        return c.GL_UNIFORM_BUFFER;
+    if (usage.storage)
+        return c.GL_SHADER_STORAGE_BUFFER;
+    if (usage.indirect)
+        return c.GL_DRAW_INDIRECT_BUFFER;
+    if (usage.query_resolve)
+        return c.GL_QUERY_BUFFER;
+
+    return c.GL_ARRAY_BUFFER;
+}
+
+pub fn glTargetForBufferBinding(binding_type: sysgpu.Buffer.BindingType) c.GLenum {
+    return switch (binding_type) {
+        .undefined => unreachable,
+        .uniform => c.GL_UNIFORM_BUFFER,
+        .storage => c.GL_SHADER_STORAGE_BUFFER,
+        .read_only_storage => c.GL_SHADER_STORAGE_BUFFER,
+    };
+}