MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup last parts of build.zig

Browse Source
This commit is contained in:
haxsam 2026-04-17 20:09:13 +02:00
parent 98a40d736d
commit 0a6a2603a8
No known key found for this signature in database
2 changed files with 82 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
build.zig
View File

@ -118,7 +118,7 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
} }
if (options.linkage == .dynamic) { if (options.linkage == .dynamic) {
try raylib_flags_arr.append("-fPIC"); raylib_mod.pic = true;
raylib_mod.addCMacro("BUILD_LIBTYPE_SHARED", ""); raylib_mod.addCMacro("BUILD_LIBTYPE_SHARED", "");
} }
@ -160,6 +160,10 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
switch (options.platform) { switch (options.platform) {
.glfw => { .glfw => {
var opengl_version: OpenglVersion = options.opengl_version; var opengl_version: OpenglVersion = options.opengl_version;
if (opengl_version == .gl_soft) {
@panic("The opengl version is not supported by this platform");
}
raylib_mod.addIncludePath(b.path("src/external/glfw/include")); raylib_mod.addIncludePath(b.path("src/external/glfw/include"));
if (target.result.os.tag != .emscripten) { if (target.result.os.tag != .emscripten) {
@ -181,17 +185,11 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
@panic("Target is not supported with this platform"); @panic("Target is not supported with this platform");
} }
raylib_mod.linkSystemLibrary("GL", .{});
if (options.linux_display_backend == .X11 or options.linux_display_backend == .Both) { if (options.linux_display_backend == .X11 or options.linux_display_backend == .Both) {
raylib_mod.addCMacro("_GLFW_X11", ""); raylib_mod.addCMacro("_GLFW_X11", "");
raylib_mod.linkSystemLibrary("GLX", .{});
raylib_mod.linkSystemLibrary("X11", .{}); raylib_mod.linkSystemLibrary("X11", .{});
raylib_mod.linkSystemLibrary("Xcursor", .{});
raylib_mod.linkSystemLibrary("Xext", .{});
raylib_mod.linkSystemLibrary("Xfixes", .{});
raylib_mod.linkSystemLibrary("Xi", .{});
raylib_mod.linkSystemLibrary("Xinerama", .{});
raylib_mod.linkSystemLibrary("Xrandr", .{});
raylib_mod.linkSystemLibrary("Xrender", .{});
} }
if (options.linux_display_backend == .Wayland or options.linux_display_backend == .Both) { if (options.linux_display_backend == .Wayland or options.linux_display_backend == .Both) {
@ -212,15 +210,11 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
}, },
.freebsd, .openbsd, .netbsd, .dragonfly => { .freebsd, .openbsd, .netbsd, .dragonfly => {
raylib_mod.linkSystemLibrary("GL", .{}); raylib_mod.linkSystemLibrary("GL", .{});
raylib_mod.linkSystemLibrary("rt", .{});
raylib_mod.linkSystemLibrary("dl", .{}); raylib_mod.addSystemIncludePath(b.path("/usr/local/include/"));
raylib_mod.linkSystemLibrary("m", .{}); raylib_mod.addSystemIncludePath(b.path("/usr/pkg/include"));
raylib_mod.linkSystemLibrary("X11", .{}); raylib_mod.addSystemIncludePath(b.path("/usr/X11R7/include"));
raylib_mod.linkSystemLibrary("Xrandr", .{}); raylib_mod.addRPath(b.path("/usr/pkg/lib"));
raylib_mod.linkSystemLibrary("Xinerama", .{});
raylib_mod.linkSystemLibrary("Xi", .{});
raylib_mod.linkSystemLibrary("Xxf86vm", .{});
raylib_mod.linkSystemLibrary("Xcursor", .{});
}, },
.macos => { .macos => {
// On macos rglfw.c include Objective-C files. // On macos rglfw.c include Objective-C files.
@ -278,18 +272,21 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
raylib_mod.linkSystemLibrary("opengl32", .{}); raylib_mod.linkSystemLibrary("opengl32", .{});
}, },
.linux => { .linux => {
if (target.result.abi.isAndroid()) {
@panic("Target is not supported with this platform");
}
raylib_mod.linkSystemLibrary("GL", .{});
if (options.linux_display_backend == .X11 or options.linux_display_backend == .Both) { if (options.linux_display_backend == .X11 or options.linux_display_backend == .Both) {
raylib_mod.addCMacro("RGFW_X11", ""); raylib_mod.addCMacro("RGFW_X11", "");
raylib_mod.addCMacro("RGFW_UNIX", ""); raylib_mod.addCMacro("RGFW_UNIX", "");
raylib_mod.linkSystemLibrary("GL", .{});
raylib_mod.linkSystemLibrary("X11", .{}); raylib_mod.linkSystemLibrary("X11", .{});
raylib_mod.linkSystemLibrary("Xrandr", .{}); raylib_mod.linkSystemLibrary("Xrandr", .{});
raylib_mod.linkSystemLibrary("Xinerama", .{});
raylib_mod.linkSystemLibrary("Xi", .{}); raylib_mod.linkSystemLibrary("Xi", .{});
raylib_mod.linkSystemLibrary("Xcursor", .{}); raylib_mod.linkSystemLibrary("Xcursor", .{});
raylib_mod.linkSystemLibrary("pthread", .{});
raylib_mod.linkSystemLibrary("dl", .{});
raylib_mod.linkSystemLibrary("rt", .{});
} }
if (options.linux_display_backend == .Wayland or options.linux_display_backend == .Both) { if (options.linux_display_backend == .Wayland or options.linux_display_backend == .Both) {
@ -313,6 +310,14 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
try waylandGenerate(b, raylib, "src/external/RGFW/deps/wayland/", true); try waylandGenerate(b, raylib, "src/external/RGFW/deps/wayland/", true);
} }
}, },
.freebsd, .openbsd, .netbsd, .dragonfly => {
raylib_mod.linkSystemLibrary("GL", .{});
raylib_mod.addSystemIncludePath(b.path("/usr/local/include/"));
raylib_mod.addSystemIncludePath(b.path("/usr/pkg/include"));
raylib_mod.addSystemIncludePath(b.path("/usr/X11R7/include"));
raylib_mod.addRPath(b.path("/usr/pkg/lib"));
},
.macos => { .macos => {
// Include xcode_frameworks for cross compilation // Include xcode_frameworks for cross compilation
if (b.lazyDependency("xcode_frameworks", .{})) |dep| { if (b.lazyDependency("xcode_frameworks", .{})) |dep| {
@ -350,18 +355,18 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
raylib_mod.addCMacro(options.opengl_version.toCMacroStr(), ""); raylib_mod.addCMacro(options.opengl_version.toCMacroStr(), "");
} }
raylib_mod.addCMacro("PLATFORM_DESKTOP_SDL", "");
if (options.platform == .sdl2) { if (options.platform == .sdl2) {
raylib_mod.addCMacro("USING_SDL2_PACKAGE", ""); raylib_mod.addCMacro("USING_SDL2_PACKAGE", "");
} }
if (options.platform == .sdl3) { if (options.platform == .sdl3) {
raylib_mod.addCMacro("USING_SDL3_PACKAGE", ""); raylib_mod.addCMacro("USING_SDL3_PACKAGE", "");
} }
raylib_mod.addCMacro("PLATFORM_DESKTOP_SDL", "");
}, },
.memory => { .memory => {
if (options.opengl_version != .auto and options.opengl_version != .gl_soft) { if (options.opengl_version != .auto and options.opengl_version != .gl_soft) {
@panic("opengl version not supported"); @panic("The opengl version is not supported by this platform");
} }
raylib_mod.addCMacro(OpenglVersion.gl_soft.toCMacroStr(), ""); raylib_mod.addCMacro(OpenglVersion.gl_soft.toCMacroStr(), "");
raylib_mod.addCMacro("PLATFORM_MEMORY", ""); raylib_mod.addCMacro("PLATFORM_MEMORY", "");
@ -397,12 +402,11 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
try raylib_flags_arr.append("-Werror=implicit-function-declaration"); try raylib_flags_arr.append("-Werror=implicit-function-declaration");
raylib_mod.addSystemIncludePath(b.path("/usr/include/libdrm"));
raylib_mod.linkSystemLibrary("libdrm", .{ .use_pkg_config = .force }); raylib_mod.linkSystemLibrary("libdrm", .{ .use_pkg_config = .force });
raylib_mod.linkSystemLibrary("drm", .{}); raylib_mod.linkSystemLibrary("drm", .{});
raylib_mod.linkSystemLibrary("gbm", .{}); raylib_mod.linkSystemLibrary("gbm", .{});
raylib_mod.linkSystemLibrary("pthread", .{});
raylib_mod.linkSystemLibrary("rt", .{});
raylib_mod.linkSystemLibrary("dl", .{});
switch (options.opengl_version) { switch (options.opengl_version) {
.auto, .gles_2 => { .auto, .gles_2 => {
@ -411,7 +415,7 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
raylib_mod.linkSystemLibrary("EGL", .{}); raylib_mod.linkSystemLibrary("EGL", .{});
}, },
.gl_soft => {}, .gl_soft => {},
else => @panic("opengl version not supported"), else => @panic("The opengl version is not supported by this platform"),
} }
}, },
.android => { .android => {
@ -422,9 +426,12 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
raylib_mod.addCMacro("PLATFORM_ANDROID", ""); raylib_mod.addCMacro("PLATFORM_ANDROID", "");
raylib_mod.linkSystemLibrary("EGL", .{}); raylib_mod.linkSystemLibrary("EGL", .{});
if (options.opengl_version == .auto or options.opengl_version == .gles_2) { switch (options.opengl_version) {
raylib_mod.addCMacro(OpenglVersion.gles_2.toCMacroStr(), ""); .auto, .gles_2 => {
raylib_mod.linkSystemLibrary("GLESv2", .{}); raylib_mod.addCMacro(OpenglVersion.gles_2.toCMacroStr(), "");
raylib_mod.linkSystemLibrary("GLESv2", .{});
},
else => @panic("The opengl version is not supported by this platform"),
} }
//these are the only tag options per https://developer.android.com/ndk/guides/other_build_systems //these are the only tag options per https://developer.android.com/ndk/guides/other_build_systems
@ -637,14 +644,14 @@ pub fn build(b: *std.Build) !void {
} }
const examples = b.step("examples", "build/install all examples"); const examples = b.step("examples", "build/install all examples");
examples.dependOn(try addExamples("core", b, target, optimize, lib)); examples.dependOn(try addExamples("core", b, target, optimize, lib, options.platform));
examples.dependOn(try addExamples("audio", b, target, optimize, lib)); examples.dependOn(try addExamples("audio", b, target, optimize, lib, options.platform));
examples.dependOn(try addExamples("models", b, target, optimize, lib)); examples.dependOn(try addExamples("models", b, target, optimize, lib, options.platform));
examples.dependOn(try addExamples("others", b, target, optimize, lib)); examples.dependOn(try addExamples("shaders", b, target, optimize, lib, options.platform));
examples.dependOn(try addExamples("shaders", b, target, optimize, lib)); examples.dependOn(try addExamples("shapes", b, target, optimize, lib, options.platform));
examples.dependOn(try addExamples("shapes", b, target, optimize, lib)); examples.dependOn(try addExamples("text", b, target, optimize, lib, options.platform));
examples.dependOn(try addExamples("text", b, target, optimize, lib)); examples.dependOn(try addExamples("textures", b, target, optimize, lib, options.platform));
examples.dependOn(try addExamples("textures", b, target, optimize, lib)); examples.dependOn(try addExamples("others", b, target, optimize, lib, options.platform));
} }
fn addExamples( fn addExamples(
@ -653,6 +660,7 @@ fn addExamples(
target: std.Build.ResolvedTarget, target: std.Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
raylib: *std.Build.Step.Compile, raylib: *std.Build.Step.Compile,
platform: PlatformBackend,
) !*std.Build.Step { ) !*std.Build.Step {
const all = b.step(module, "All " ++ module ++ " examples"); const all = b.step(module, "All " ++ module ++ " examples");
const module_subpath = b.pathJoin(&.{ "examples", module }); const module_subpath = b.pathJoin(&.{ "examples", module });
@ -660,6 +668,17 @@ fn addExamples(
var dir = try b.build_root.handle.openDir(b.graph.io, module_subpath, .{ .iterate = true }); var dir = try b.build_root.handle.openDir(b.graph.io, module_subpath, .{ .iterate = true });
defer dir.close(b.graph.io); defer dir.close(b.graph.io);
if (platform == .sdl) {
raylib.root_module.linkSystemLibrary("SDL2", .{});
raylib.root_module.linkSystemLibrary("SDL3", .{});
}
if (platform == .sdl2) {
raylib.root_module.linkSystemLibrary("SDL2", .{});
}
if (platform == .sdl3) {
raylib.root_module.linkSystemLibrary("SDL3", .{});
}
var iter = dir.iterate(); var iter = dir.iterate();
while (try iter.next(b.graph.io)) |entry| { while (try iter.next(b.graph.io)) |entry| {
if (entry.kind != .file) continue; if (entry.kind != .file) continue;
@ -668,114 +687,68 @@ fn addExamples(
if (!std.mem.eql(u8, filetype, ".c")) continue; if (!std.mem.eql(u8, filetype, ".c")) continue;
const filename = std.fs.path.stem(entry.name); const filename = std.fs.path.stem(entry.name);
const path = b.pathJoin(&.{ module_subpath, entry.name }); const path = b.pathJoin(&.{ module_subpath, entry.name });
// zig's mingw headers do not include pthread.h
if (std.mem.eql(u8, "core_loading_thread", filename) and target.result.os.tag == .windows) continue;
const exe_mod = b.createModule(.{ const exe_mod = b.createModule(.{
.target = target, .target = target,
.optimize = optimize, .optimize = optimize,
.link_libc = true,
}); });
exe_mod.addCSourceFile(.{ .file = b.path(path), .flags = &.{} }); exe_mod.addCSourceFile(.{ .file = b.path(path) });
exe_mod.linkLibrary(raylib); exe_mod.linkLibrary(raylib);
if (std.mem.eql(u8, filename, "rlgl_standalone")) {
if (platform != .glfw) continue;
exe_mod.addIncludePath(b.path("src"));
exe_mod.addIncludePath(b.path("src/external/glfw/include"));
}
if (std.mem.eql(u8, filename, "raylib_opengl_interop")) {
exe_mod.addIncludePath(b.path("src/external"));
}
const run_step = b.step(filename, filename); const run_step = b.step(filename, filename);
if (target.result.os.tag == .emscripten) { // web exports are completely separate
if (target.query.os_tag == .emscripten) {
exe_mod.addCMacro("PLATFORM_WEB", "");
const wasm = b.addLibrary(.{ const wasm = b.addLibrary(.{
.name = filename, .name = filename,
.linkage = .static,
.root_module = exe_mod, .root_module = exe_mod,
}); });
if (std.mem.eql(u8, filename, "rlgl_standalone")) { const install_dir: std.Build.InstallDir = .{ .custom = "web" };
exe_mod.addIncludePath(b.path("src"));
exe_mod.addIncludePath(b.path("src/external/glfw/include"));
}
if (std.mem.eql(u8, filename, "raylib_opengl_interop")) {
exe_mod.addIncludePath(b.path("src/external"));
}
const emcc_flags = emsdk.emccDefaultFlags(b.allocator, .{ .optimize = optimize }); const emcc_flags = emsdk.emccDefaultFlags(b.allocator, .{ .optimize = optimize });
const emcc_settings = emsdk.emccDefaultSettings(b.allocator, .{ .optimize = optimize }); const emcc_settings = emsdk.emccDefaultSettings(b.allocator, .{ .optimize = optimize });
const install_dir: std.Build.InstallDir = .{ .custom = "htmlout" };
const emcc_step = emsdk.emccStep(b, raylib, wasm, .{ const emcc_step = emsdk.emccStep(b, raylib, wasm, .{
.optimize = optimize, .optimize = optimize,
.flags = emcc_flags, .flags = emcc_flags,
.settings = emcc_settings, .settings = emcc_settings,
.shell_file_path = b.path("src/shell.html"), .shell_file_path = b.path("src/shell.html"),
.embed_paths = &.{
.{
.src_path = b.pathJoin(&.{ module_subpath, "resources" }),
.virtual_path = "resources",
},
},
.install_dir = install_dir, .install_dir = install_dir,
}); });
b.getInstallStep().dependOn(emcc_step);
const html_filename = try std.fmt.allocPrint(b.allocator, "{s}.html", .{wasm.name}); const html_filename = try std.fmt.allocPrint(b.allocator, "{s}.html", .{wasm.name});
const emrun_step = emsdk.emrunStep( const emrun_step = emsdk.emrunStep(
b, b,
b.getInstallPath(install_dir, html_filename), b.getInstallPath(install_dir, html_filename),
&.{"--no_browser"}, &.{},
); );
emrun_step.dependOn(emcc_step);
emrun_step.dependOn(emcc_step);
run_step.dependOn(emrun_step); run_step.dependOn(emrun_step);
all.dependOn(emcc_step); all.dependOn(emcc_step);
} else { } else {
// special examples that test using these external dependencies directly exe_mod.addCMacro("PLATFORM_DESKTOP", "");
// alongside raylib
if (std.mem.eql(u8, filename, "rlgl_standalone")) {
exe_mod.addIncludePath(b.path("src"));
exe_mod.addIncludePath(b.path("src/external/glfw/include"));
if (!hasCSource(raylib.root_module, "rglfw.c")) {
exe_mod.addCSourceFile(.{ .file = b.path("src/rglfw.c"), .flags = &.{} });
}
}
if (std.mem.eql(u8, filename, "raylib_opengl_interop")) {
exe_mod.addIncludePath(b.path("src/external"));
}
switch (target.result.os.tag) {
.windows => {
exe_mod.linkSystemLibrary("winmm", .{});
exe_mod.linkSystemLibrary("gdi32", .{});
exe_mod.linkSystemLibrary("opengl32", .{});
exe_mod.addCMacro("PLATFORM_DESKTOP", "");
},
.linux => {
exe_mod.linkSystemLibrary("GL", .{});
exe_mod.linkSystemLibrary("rt", .{});
exe_mod.linkSystemLibrary("dl", .{});
exe_mod.linkSystemLibrary("m", .{});
exe_mod.linkSystemLibrary("X11", .{});
exe_mod.addCMacro("PLATFORM_DESKTOP", "");
},
.macos => {
exe_mod.linkFramework("Foundation", .{});
exe_mod.linkFramework("Cocoa", .{});
exe_mod.linkFramework("OpenGL", .{});
exe_mod.linkFramework("CoreAudio", .{});
exe_mod.linkFramework("CoreVideo", .{});
exe_mod.linkFramework("IOKit", .{});
exe_mod.addCMacro("PLATFORM_DESKTOP", "");
},
else => {
@panic("Unsupported OS");
},
}
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = filename, .name = filename,
.root_module = exe_mod, .root_module = exe_mod,
.use_lld = target.result.os.tag == .windows,
}); });
b.installArtifact(exe);
const install_cmd = b.addInstallArtifact(exe, .{}); const install_cmd = b.addInstallArtifact(exe, .{});
@ -787,7 +760,6 @@ fn addExamples(
all.dependOn(&install_cmd.step); all.dependOn(&install_cmd.step);
} }
} }
return all; return all;
} }

4
projects/Zig/build.zig
View File

@ -19,9 +19,6 @@ pub fn build(b: *std.Build) !void {
} }
} }
const options = b.addOptions();
options.addOption(rl.PlatformBackend, "platform", platform);
const exe_mod = b.createModule(.{ const exe_mod = b.createModule(.{
.target = target, .target = target,
.optimize = optimize, .optimize = optimize,
@ -66,6 +63,7 @@ pub fn build(b: *std.Build) !void {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "core_basic_window", .name = "core_basic_window",
.root_module = exe_mod, .root_module = exe_mod,
.use_lld = target.result.os.tag == .windows,
}); });
b.installArtifact(exe); b.installArtifact(exe);