initial commit

.gitignore

@@ -0,0 +1,2 @@
+zig-cache
+zig-out

README.md

@@ -0,0 +1,16 @@
+# Seam carving
+
+https://en.wikipedia.org/wiki/Seam_carving
+
+## Building & run
+
+Windows & linux
+```shell
+zig build run
+```
+
+Web
+```shell
+emsdk install latest
+zig build -Dtarget=wasm32-emscripten --sysroot [path to emsdk]/upstream/emscripten run
+```

build.zig

@@ -0,0 +1,141 @@
+// const std = @import("std");
+//
+// // Although this function looks imperative, note that its job is to
+// // declaratively construct a build graph that will be executed by an external
+// // runner.
+// pub fn build(b: *std.Build) void {
+//     // Standard target options allows the person running `zig build` to choose
+//     // what target to build for. Here we do not override the defaults, which
+//     // means any target is allowed, and the default is native. Other options
+//     // for restricting supported target set are available.
+//     const target = b.standardTargetOptions(.{});
+//
+//     // Standard optimization options allow the person running `zig build` to select
+//     // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+//     // set a preferred release mode, allowing the user to decide how to optimize.
+//     const optimize = b.standardOptimizeOption(.{});
+//
+//     const lib = b.addStaticLibrary(.{
+//         .name = "seam-carving",
+//         // In this case the main source file is merely a path, however, in more
+//         // complicated build scripts, this could be a generated file.
+//         .root_source_file = b.path("src/root.zig"),
+//         .target = target,
+//         .optimize = optimize,
+//     });
+//
+//     // This declares intent for the library to be installed into the standard
+//     // location when the user invokes the "install" step (the default step when
+//     // running `zig build`).
+//     b.installArtifact(lib);
+//
+//     const exe = b.addExecutable(.{
+//         .name = "seam-carving",
+//         .root_source_file = b.path("src/main.zig"),
+//         .target = target,
+//         .optimize = optimize,
+//     });
+//
+//     // This declares intent for the executable to be installed into the
+//     // standard location when the user invokes the "install" step (the default
+//     // step when running `zig build`).
+//     b.installArtifact(exe);
+//
+//     // This *creates* a Run step in the build graph, to be executed when another
+//     // step is evaluated that depends on it. The next line below will establish
+//     // such a dependency.
+//     const run_cmd = b.addRunArtifact(exe);
+//
+//     // By making the run step depend on the install step, it will be run from the
+//     // installation directory rather than directly from within the cache directory.
+//     // This is not necessary, however, if the application depends on other installed
+//     // files, this ensures they will be present and in the expected location.
+//     run_cmd.step.dependOn(b.getInstallStep());
+//
+//     // This allows the user to pass arguments to the application in the build
+//     // command itself, like this: `zig build run -- arg1 arg2 etc`
+//     if (b.args) |args| {
+//         run_cmd.addArgs(args);
+//     }
+//
+//     // This creates a build step. It will be visible in the `zig build --help` menu,
+//     // and can be selected like this: `zig build run`
+//     // This will evaluate the `run` step rather than the default, which is "install".
+//     const run_step = b.step("run", "Run the app");
+//     run_step.dependOn(&run_cmd.step);
+//
+//     // Creates a step for unit testing. This only builds the test executable
+//     // but does not run it.
+//     const lib_unit_tests = b.addTest(.{
+//         .root_source_file = b.path("src/root.zig"),
+//         .target = target,
+//         .optimize = optimize,
+//     });
+//
+//     const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
+//
+//     const exe_unit_tests = b.addTest(.{
+//         .root_source_file = b.path("src/main.zig"),
+//         .target = target,
+//         .optimize = optimize,
+//     });
+//
+//     const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+//
+//     // Similar to creating the run step earlier, this exposes a `test` step to
+//     // the `zig build --help` menu, providing a way for the user to request
+//     // running the unit tests.
+//     const test_step = b.step("test", "Run unit tests");
+//     test_step.dependOn(&run_lib_unit_tests.step);
+//     test_step.dependOn(&run_exe_unit_tests.step);
+// }
+
+const std = @import("std");
+const rlz = @import("raylib-zig");
+
+pub fn build(b: *std.Build) !void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const project_name = "seam-carving";
+
+    const raylib_dep = b.dependency("raylib-zig", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const raylib = raylib_dep.module("raylib");
+    const raylib_artifact = raylib_dep.artifact("raylib");
+
+    //web exports are completely separate
+    if (target.query.os_tag == .emscripten) {
+        const exe_lib = rlz.emcc.compileForEmscripten(b, project_name, "src/main.zig", target, optimize);
+
+        exe_lib.linkLibrary(raylib_artifact);
+        exe_lib.root_module.addImport("raylib", raylib);
+
+        // Note that raylib itself is not actually added to the exe_lib output file, so it also needs to be linked with emscripten.
+        const link_step = try rlz.emcc.linkWithEmscripten(b, &[_]*std.Build.Step.Compile{ exe_lib, raylib_artifact });
+
+        b.getInstallStep().dependOn(&link_step.step);
+        const run_step = try rlz.emcc.emscriptenRunStep(b);
+        run_step.step.dependOn(&link_step.step);
+
+        const run_label = try std.fmt.allocPrint(b.allocator, "Run {s}", .{project_name});
+        const run_option = b.step("run", run_label);
+        run_option.dependOn(&run_step.step);
+        return;
+    }
+
+    const exe = b.addExecutable(.{ .name = project_name, .root_source_file = b.path("src/main.zig"), .optimize = optimize, .target = target });
+
+    exe.linkLibrary(raylib_artifact);
+    exe.root_module.addImport("raylib", raylib);
+
+    const run_cmd = b.addRunArtifact(exe);
+    const run_label = try std.fmt.allocPrint(b.allocator, "Run {s}", .{project_name});
+    const run_step = b.step("run", run_label);
+    run_step.dependOn(&run_cmd.step);
+
+    b.installArtifact(exe);
+}

build.zig.zon

@@ -0,0 +1,43 @@
+.{
+    .name = "seam-carving",
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+
+    // This field is optional.
+    // This is currently advisory only; Zig does not yet do anything
+    // with this value.
+    //.minimum_zig_version = "0.11.0",
+
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+         .@"raylib-zig" = .{
+            .url = "https://github.com/Not-Nik/raylib-zig/archive/43d15b05c2b97cab30103fa2b46cff26e91619ec.tar.gz",
+            .hash = "12204a223b19043e17b79300413d02f60fc8004c0d9629b8d8072831e352a78bf212",
+        },
+    },
+
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package.
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        // This makes *all* files, recursively, included in this package. It is generally
+        // better to explicitly list the files and directories instead, to insure that
+        // fetching from tarballs, file system paths, and version control all result
+        // in the same contents hash.
+        "",
+        // For example...
+        //"build.zig",
+        //"build.zig.zon",
+        //"src",
+        //"LICENSE",
+        //"README.md",
+    },
+}

src/main.zig

@@ -0,0 +1,32 @@
+const std = @import("std");
+const rl = @import("raylib");
+
+fn toTraceLogLevel(log_level: std.log.Level) rl.TraceLogLevel {
+    return switch (log_level) {
+        .err   => rl.TraceLogLevel.log_error,
+        .warn  => rl.TraceLogLevel.log_warning,
+        .info  => rl.TraceLogLevel.log_info,
+        .debug => rl.TraceLogLevel.log_all,
+    };
+}
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+    defer _ = gpa.deinit();
+    _ = allocator;
+
+    rl.setTraceLogLevel(toTraceLogLevel(std.log.default_level));
+
+    rl.initWindow(800, 450, "Seam carving");
+    defer rl.closeWindow();
+
+    rl.setTargetFPS(60);
+
+    while (!rl.windowShouldClose()) {
+        rl.beginDrawing();
+        defer rl.endDrawing();
+
+        rl.clearBackground(rl.Color.white);
+    }
+}