paoda/zba
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat: upgrade to zig v0.15.1

Browse Source 
note: emu crashes for unknown reason
This commit is contained in:
Rekai Nyangadzayi Musuka
2025-10-12 18:10:12 -05:00
parent 6cacdc7180
commit bd02f625a5
22 changed files with 1083 additions and 5597 deletions
Download Patch File Download Diff File Expand all files Collapse all files

336
src/platform.zig
View File

@@ -1,7 +1,7 @@
const std = @import("std");
const SDL = @import("sdl2");
const gl = @import("gl");
const zgui = @import("zgui");
const c = @import("lib.zig").c;
const emu = @import("core/emu.zig");
const config = @import("config.zig");
@@ -18,24 +18,27 @@ const KeyInput = @import("core/bus/io.zig").KeyInput;
const gba_width = @import("core/ppu.zig").width;
const gba_height = @import("core/ppu.zig").height;
const GLuint = gl.GLuint;
const GLsizei = gl.GLsizei;
const SDL_GLContext = *anyopaque;
const GLsizei = gl.sizei;
const SDL_GLContext = *c.SDL_GLContextState;
const Allocator = std.mem.Allocator;
pub const Dimensions = struct { width: u32, height: u32 };
const default_dim: Dimensions = .{ .width = 1280, .height = 720 };
pub const sample_rate = 1 << 15;
pub const sample_format = SDL.AUDIO_U16;
// pub const sample_format = SDL.AUDIO_U16;
const window_title = "ZBA";
const errify = @import("lib.zig").errify;
var gl_procs: gl.ProcTable = undefined;
pub const Gui = struct {
const Self = @This();
const log = std.log.scoped(.Gui);
window: *SDL.SDL_Window,
window: *c.SDL_Window,
ctx: SDL_GLContext,
audio: Audio,
@@ -43,36 +46,42 @@ pub const Gui = struct {
allocator: Allocator,
pub fn init(allocator: Allocator, apu: *Apu, title_opt: ?*const [12]u8) !Self {
if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_EVENTS | SDL.SDL_INIT_AUDIO) < 0) panic();
if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_PROFILE_MASK, SDL.SDL_GL_CONTEXT_PROFILE_CORE) < 0) panic();
if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();
if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();
c.SDL_SetMainReady();
const window = SDL.SDL_CreateWindow(
window_title,
SDL.SDL_WINDOWPOS_CENTERED,
SDL.SDL_WINDOWPOS_CENTERED,
default_dim.width,
default_dim.height,
SDL.SDL_WINDOW_OPENGL | SDL.SDL_WINDOW_SHOWN | SDL.SDL_WINDOW_RESIZABLE,
) orelse panic();
try errify(c.SDL_Init(c.SDL_INIT_VIDEO | c.SDL_INIT_AUDIO | c.SDL_INIT_EVENTS));
const ctx = SDL.SDL_GL_CreateContext(window) orelse panic();
if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic();
try errify(c.SDL_SetAppMetadata(window_title, "0.1.0", "moe.paoda.zba"));
try errify(c.SDL_GL_SetAttribute(c.SDL_GL_CONTEXT_MAJOR_VERSION, gl.info.version_major));
try errify(c.SDL_GL_SetAttribute(c.SDL_GL_CONTEXT_MINOR_VERSION, gl.info.version_minor));
try errify(c.SDL_GL_SetAttribute(c.SDL_GL_CONTEXT_PROFILE_MASK, c.SDL_GL_CONTEXT_PROFILE_CORE));
try errify(c.SDL_GL_SetAttribute(c.SDL_GL_CONTEXT_FLAGS, c.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG));
gl.load(ctx, Self.glGetProcAddress) catch {};
if (SDL.SDL_GL_SetSwapInterval(@intFromBool(config.config().host.vsync)) < 0) panic();
const window: *c.SDL_Window = try errify(c.SDL_CreateWindow(window_title, default_dim.width, default_dim.height, c.SDL_WINDOW_OPENGL | c.SDL_WINDOW_RESIZABLE));
errdefer c.SDL_DestroyWindow(window);
const gl_ctx = try errify(c.SDL_GL_CreateContext(window));
errdefer errify(c.SDL_GL_DestroyContext(gl_ctx)) catch {};
try errify(c.SDL_GL_MakeCurrent(window, gl_ctx));
errdefer errify(c.SDL_GL_MakeCurrent(window, null)) catch {};
if (!gl_procs.init(c.SDL_GL_GetProcAddress)) return error.gl_init_failed;
gl.makeProcTableCurrent(&gl_procs);
errdefer gl.makeProcTableCurrent(null);
try errify(c.SDL_GL_SetSwapInterval(@intFromBool(config.config().host.vsync)));
zgui.init(allocator);
zgui.plot.init();
zgui.backend.init(window, ctx, "#version 330 core");
zgui.backend.init(window, gl_ctx);
// zgui.io.setIniFilename(null);
return Self{
.window = window,
.ctx = ctx,
.audio = Audio.init(apu),
.ctx = gl_ctx,
.audio = try Audio.init(apu),
.allocator = allocator,
.state = try imgui.State.init(allocator, title_opt),
@@ -87,9 +96,9 @@ pub const Gui = struct {
zgui.plot.deinit();
zgui.deinit();
SDL.SDL_GL_DeleteContext(self.ctx);
SDL.SDL_DestroyWindow(self.window);
SDL.SDL_Quit();
errify(c.SDL_GL_DestroyContext(self.ctx)) catch {};
c.SDL_DestroyWindow(self.window);
c.SDL_Quit();
self.* = undefined;
}
@@ -109,17 +118,19 @@ pub const Gui = struct {
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const vao_id = opengl_impl.vao();
defer gl.deleteVertexArrays(1, &[_]GLuint{vao_id});
defer gl.DeleteVertexArrays(1, vao_id[0..]);
const emu_tex = opengl_impl.screenTex(bus_ptr.ppu.framebuf.get(.Renderer));
const out_tex = opengl_impl.outTex();
defer gl.deleteTextures(2, &[_]GLuint{ emu_tex, out_tex });
defer gl.DeleteTextures(1, emu_tex[0..]);
const fbo_id = try opengl_impl.frameBuffer(out_tex);
defer gl.deleteFramebuffers(1, &fbo_id);
const out_tex = opengl_impl.outTex();
defer gl.DeleteTextures(1, out_tex[0..]);
const fbo_id = try opengl_impl.frameBuffer(out_tex[0]);
defer gl.DeleteFramebuffers(1, fbo_id[0..]);
const prog_id = try opengl_impl.program(); // Dynamic Shaders?
defer gl.deleteProgram(prog_id);
defer gl.DeleteProgram(prog_id);
var win_dim: Dimensions = default_dim;
@@ -128,61 +139,59 @@ pub const Gui = struct {
// should exit, in which case we should also handle this
if (self.state.should_quit or sync.should_quit.load(.monotonic)) break :emu_loop;
var event: SDL.SDL_Event = undefined;
while (SDL.SDL_PollEvent(&event) != 0) {
var event: c.SDL_Event = undefined;
while (c.SDL_PollEvent(&event)) {
_ = zgui.backend.processEvent(&event);
switch (event.type) {
SDL.SDL_QUIT => break :emu_loop,
SDL.SDL_KEYDOWN => {
c.SDL_EVENT_QUIT => break :emu_loop,
c.SDL_EVENT_KEY_DOWN => {
// TODO: Make use of compare_and_xor?
const key_code = event.key.keysym.sym;
var keyinput: KeyInput = .{ .raw = 0x0000 };
switch (key_code) {
SDL.SDLK_UP => keyinput.up.set(),
SDL.SDLK_DOWN => keyinput.down.set(),
SDL.SDLK_LEFT => keyinput.left.set(),
SDL.SDLK_RIGHT => keyinput.right.set(),
SDL.SDLK_x => keyinput.a.set(),
SDL.SDLK_z => keyinput.b.set(),
SDL.SDLK_a => keyinput.shoulder_l.set(),
SDL.SDLK_s => keyinput.shoulder_r.set(),
SDL.SDLK_RETURN => keyinput.start.set(),
SDL.SDLK_RSHIFT => keyinput.select.set(),
switch (event.key.scancode) {
c.SDL_SCANCODE_UP => keyinput.up.write(true),
c.SDL_SCANCODE_DOWN => keyinput.down.write(true),
c.SDL_SCANCODE_LEFT => keyinput.left.write(true),
c.SDL_SCANCODE_RIGHT => keyinput.right.write(true),
c.SDL_SCANCODE_X => keyinput.a.write(true),
c.SDL_SCANCODE_Z => keyinput.b.write(true),
c.SDL_SCANCODE_A => keyinput.shoulder_l.write(true),
c.SDL_SCANCODE_S => keyinput.shoulder_r.write(true),
c.SDL_SCANCODE_RETURN => keyinput.start.write(true),
c.SDL_SCANCODE_RSHIFT => keyinput.select.write(true),
else => {},
}
bus_ptr.io.keyinput.fetchAnd(~keyinput.raw, .monotonic);
},
SDL.SDL_KEYUP => {
c.SDL_EVENT_KEY_UP => {
// FIXME(paoda): merge with above?
// TODO: Make use of compare_and_xor?
const key_code = event.key.keysym.sym;
var keyinput: KeyInput = .{ .raw = 0x0000 };
switch (key_code) {
SDL.SDLK_UP => keyinput.up.set(),
SDL.SDLK_DOWN => keyinput.down.set(),
SDL.SDLK_LEFT => keyinput.left.set(),
SDL.SDLK_RIGHT => keyinput.right.set(),
SDL.SDLK_x => keyinput.a.set(),
SDL.SDLK_z => keyinput.b.set(),
SDL.SDLK_a => keyinput.shoulder_l.set(),
SDL.SDLK_s => keyinput.shoulder_r.set(),
SDL.SDLK_RETURN => keyinput.start.set(),
SDL.SDLK_RSHIFT => keyinput.select.set(),
switch (event.key.scancode) {
c.SDL_SCANCODE_UP => keyinput.up.write(true),
c.SDL_SCANCODE_DOWN => keyinput.down.write(true),
c.SDL_SCANCODE_LEFT => keyinput.left.write(true),
c.SDL_SCANCODE_RIGHT => keyinput.right.write(true),
c.SDL_SCANCODE_X => keyinput.a.write(true),
c.SDL_SCANCODE_Z => keyinput.b.write(true),
c.SDL_SCANCODE_A => keyinput.shoulder_l.write(true),
c.SDL_SCANCODE_S => keyinput.shoulder_r.write(true),
c.SDL_SCANCODE_RETURN => keyinput.start.write(true),
c.SDL_SCANCODE_RSHIFT => keyinput.select.write(true),
else => {},
}
bus_ptr.io.keyinput.fetchOr(keyinput.raw, .monotonic);
},
SDL.SDL_WINDOWEVENT => {
if (event.window.event == SDL.SDL_WINDOWEVENT_RESIZED) {
log.debug("window resized to: {}x{}", .{ event.window.data1, event.window.data2 });
c.SDL_EVENT_WINDOW_RESIZED => {
log.debug("window resized to: {}x{}", .{ event.window.data1, event.window.data2 });
win_dim.width = @intCast(event.window.data1);
win_dim.height = @intCast(event.window.data2);
}
win_dim.width = @intCast(event.window.data1);
win_dim.height = @intCast(event.window.data2);
},
else => {},
}
@@ -194,13 +203,13 @@ pub const Gui = struct {
.Transition => |inner| switch (inner) {
.Active => {
sync.paused.store(false, .monotonic);
if (!config.config().host.mute) SDL.SDL_PauseAudioDevice(self.audio.device, 0);
if (!config.config().host.mute) try errify(c.SDL_PauseAudioDevice(c.SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK));
self.state.emulation = .Active;
},
.Inactive => {
// Assert that double pausing is impossible
SDL.SDL_PauseAudioDevice(self.audio.device, 1);
try errify(c.SDL_ResumeAudioDevice(c.SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK));
sync.paused.store(true, .monotonic);
self.state.emulation = .Inactive;
@@ -212,182 +221,163 @@ pub const Gui = struct {
// Draw GBA Screen to Texture
{
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
gl.BindFramebuffer(gl.FRAMEBUFFER, fbo_id[0]);
defer gl.BindFramebuffer(gl.FRAMEBUFFER, 0);
gl.viewport(0, 0, gba_width, gba_height);
opengl_impl.drawScreen(emu_tex, prog_id, vao_id, bus_ptr.ppu.framebuf.get(.Renderer));
gl.Viewport(0, 0, gba_width, gba_height);
opengl_impl.drawScreen(emu_tex[0], prog_id, vao_id[0], bus_ptr.ppu.framebuf.get(.Renderer));
}
// FIXME: We only really care about locking the audio device (and therefore writing silence)
// since if nfd-zig is used the emu may be paused for way too long. Perhaps we should try and limit
// spurious calls to SDL_LockAudioDevice?
SDL.SDL_LockAudioDevice(self.audio.device);
defer SDL.SDL_UnlockAudioDevice(self.audio.device);
zgui_redraw = imgui.draw(&self.state, sync, win_dim, cpu, out_tex);
try errify(c.SDL_LockAudioStream(self.audio.stream));
defer errify(c.SDL_UnlockAudioStream(self.audio.stream)) catch @panic("TODO: FIXME");
zgui_redraw = imgui.draw(&self.state, sync, win_dim, cpu, out_tex[0]);
},
.Inactive => zgui_redraw = imgui.draw(&self.state, sync, win_dim, cpu, out_tex),
.Inactive => zgui_redraw = imgui.draw(&self.state, sync, win_dim, cpu, out_tex[0]),
}
if (zgui_redraw) {
// Background Colour
const size = zgui.io.getDisplaySize();
gl.viewport(0, 0, @intFromFloat(size[0]), @intFromFloat(size[1]));
gl.clearColor(0, 0, 0, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.Viewport(0, 0, @intFromFloat(size[0]), @intFromFloat(size[1]));
gl.ClearColor(0, 0, 0, 1.0);
gl.Clear(gl.COLOR_BUFFER_BIT);
zgui.backend.draw();
}
SDL.SDL_GL_SwapWindow(self.window);
try errify(c.SDL_GL_SwapWindow(self.window));
}
sync.should_quit.store(true, .monotonic);
}
fn glGetProcAddress(ctx: SDL.SDL_GLContext, proc: [:0]const u8) ?*anyopaque {
_ = ctx;
return SDL.SDL_GL_GetProcAddress(proc.ptr);
}
};
const Audio = struct {
const Self = @This();
const log = std.log.scoped(.PlatformAudio);
device: SDL.SDL_AudioDeviceID,
stream: *c.SDL_AudioStream,
fn init(apu: *Apu) Self {
var have: SDL.SDL_AudioSpec = undefined;
var want: SDL.SDL_AudioSpec = std.mem.zeroes(SDL.SDL_AudioSpec);
want.freq = sample_rate;
want.format = sample_format;
want.channels = 2;
want.samples = 0x100;
want.callback = Self.callback;
want.userdata = apu;
fn init(apu: *Apu) !Self {
var desired: c.SDL_AudioSpec = std.mem.zeroes(c.SDL_AudioSpec);
desired.freq = sample_rate;
desired.format = c.SDL_AUDIO_S16LE;
desired.channels = 2;
std.debug.assert(sample_format == SDL.AUDIO_U16);
log.info("Host Sample Rate: {}Hz, Host Format: SDL.AUDIO_U16", .{sample_rate});
log.info("Host Sample Rate: {}Hz, Host Format: SDL_AUDIO_S16LE", .{sample_rate});
const device = SDL.SDL_OpenAudioDevice(null, 0, &want, &have, 0);
if (device == 0) panic();
const stream = try errify(c.SDL_OpenAudioDeviceStream(c.SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &desired, null, null));
errdefer c.SDL_DestroyAudioStream(stream);
return .{ .device = device };
apu.stream = stream;
return .{ .stream = stream };
}
fn deinit(self: *Self) void {
SDL.SDL_CloseAudioDevice(self.device);
c.SDL_DestroyAudioStream(self.stream);
self.* = undefined;
}
export fn callback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void {
const apu: *Apu = @ptrCast(@alignCast(userdata));
_ = SDL.SDL_AudioStreamGet(apu.stream, stream, len);
}
};
fn panic() noreturn {
const str = @as(?[*:0]const u8, SDL.SDL_GetError()) orelse "unknown error";
@panic(std.mem.sliceTo(str, 0));
}
const opengl_impl = struct {
fn drawScreen(tex_id: GLuint, prog_id: GLuint, vao_id: GLuint, buf: []const u8) void {
gl.bindTexture(gl.TEXTURE_2D, tex_id);
defer gl.bindTexture(gl.TEXTURE_2D, 0);
fn drawScreen(tex_id: gl.uint, prog_id: gl.uint, vao_id: gl.uint, buf: []const u8) void {
gl.BindTexture(gl.TEXTURE_2D, tex_id);
defer gl.BindTexture(gl.TEXTURE_2D, 0);
gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
gl.TexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
// Bind VAO
gl.bindVertexArray(vao_id);
defer gl.bindVertexArray(0);
gl.BindVertexArray(vao_id);
defer gl.BindVertexArray(0);
// Use compiled frag + vertex shader
gl.useProgram(prog_id);
defer gl.useProgram(0);
gl.UseProgram(prog_id);
defer gl.UseProgram(0);
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 3);
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 3);
}
fn program() !GLuint {
const vert_shader = @embedFile("shader/pixelbuf.vert");
const frag_shader = @embedFile("shader/pixelbuf.frag");
fn program() !gl.uint {
const vert_shader: [1][*]const u8 = .{@embedFile("shader/pixelbuf.vert")};
const frag_shader: [1][*]const u8 = .{@embedFile("shader/pixelbuf.frag")};
const vs = gl.createShader(gl.VERTEX_SHADER);
defer gl.deleteShader(vs);
const vs = gl.CreateShader(gl.VERTEX_SHADER);
defer gl.DeleteShader(vs);
gl.shaderSource(vs, 1, &[_][*c]const u8{vert_shader}, 0);
gl.compileShader(vs);
gl.ShaderSource(vs, 1, vert_shader[0..], null);
gl.CompileShader(vs);
if (!shader.didCompile(vs)) return error.VertexCompileError;
const fs = gl.createShader(gl.FRAGMENT_SHADER);
defer gl.deleteShader(fs);
const fs = gl.CreateShader(gl.FRAGMENT_SHADER);
defer gl.DeleteShader(fs);
gl.shaderSource(fs, 1, &[_][*c]const u8{frag_shader}, 0);
gl.compileShader(fs);
gl.ShaderSource(fs, 1, frag_shader[0..], null);
gl.CompileShader(fs);
if (!shader.didCompile(fs)) return error.FragmentCompileError;
const prog = gl.createProgram();
gl.attachShader(prog, vs);
gl.attachShader(prog, fs);
gl.linkProgram(prog);
const prog = gl.CreateProgram();
gl.AttachShader(prog, vs);
gl.AttachShader(prog, fs);
gl.LinkProgram(prog);
return prog;
}
fn vao() GLuint {
var vao_id: GLuint = undefined;
gl.genVertexArrays(1, &vao_id);
fn vao() [1]gl.uint {
var vao_id: [1]gl.uint = undefined;
gl.GenVertexArrays(1, vao_id[0..]);
return vao_id;
}
fn screenTex(buf: []const u8) GLuint {
var tex_id: GLuint = undefined;
gl.genTextures(1, &tex_id);
fn screenTex(buf: []const u8) [1]gl.uint {
var tex_id: [1]gl.uint = undefined;
gl.GenTextures(1, tex_id[0..]);
gl.bindTexture(gl.TEXTURE_2D, tex_id);
defer gl.bindTexture(gl.TEXTURE_2D, 0);
gl.BindTexture(gl.TEXTURE_2D, tex_id[0]);
defer gl.BindTexture(gl.TEXTURE_2D, 0);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
return tex_id;
}
fn outTex() GLuint {
var tex_id: GLuint = undefined;
gl.genTextures(1, &tex_id);
fn outTex() [1]gl.uint {
var tex_id: [1]gl.uint = undefined;
gl.GenTextures(1, tex_id[0..]);
gl.bindTexture(gl.TEXTURE_2D, tex_id);
defer gl.bindTexture(gl.TEXTURE_2D, 0);
gl.BindTexture(gl.TEXTURE_2D, tex_id[0]);
defer gl.BindTexture(gl.TEXTURE_2D, 0);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, null);
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, null);
return tex_id;
}
fn frameBuffer(tex_id: GLuint) !GLuint {
var fbo_id: GLuint = undefined;
gl.genFramebuffers(1, &fbo_id);
fn frameBuffer(tex_id: gl.uint) ![1]gl.uint {
var fbo_id: [1]gl.uint = undefined;
gl.GenFramebuffers(1, fbo_id[0..]);
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
gl.BindFramebuffer(gl.FRAMEBUFFER, fbo_id[0]);
defer gl.BindFramebuffer(gl.FRAMEBUFFER, 0);
gl.framebufferTexture(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex_id, 0);
gl.drawBuffers(1, &@as(GLuint, gl.COLOR_ATTACHMENT0));
gl.FramebufferTexture(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex_id, 0);
gl.DrawBuffers(1, &.{gl.COLOR_ATTACHMENT0});
if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE)
if (gl.CheckFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE)
return error.FrameBufferObejctInitFailed;
return fbo_id;
@@ -396,20 +386,20 @@ const opengl_impl = struct {
const shader = struct {
const log = std.log.scoped(.shader);
fn didCompile(id: gl.GLuint) bool {
var success: gl.GLint = undefined;
gl.getShaderiv(id, gl.COMPILE_STATUS, &success);
fn didCompile(id: gl.uint) bool {
var success: [1]gl.int = undefined;
gl.GetShaderiv(id, gl.COMPILE_STATUS, success[0..]);
if (success == 0) err(id);
if (success[0] == 0) err(id);
return success == 1;
return success[0] == 1;
}
fn err(id: gl.GLuint) void {
fn err(id: gl.uint) void {
const buf_len = 512;
var error_msg: [buf_len]u8 = undefined;
gl.getShaderInfoLog(id, buf_len, 0, &error_msg);
gl.GetShaderInfoLog(id, buf_len, null, &error_msg);
log.err("{s}", .{std.mem.sliceTo(&error_msg, 0)});
}
};