From 656c10d4ef869ce4bb050da1749d1937f697c1fc Mon Sep 17 00:00:00 2001 From: aprilnightk Date: Sat, 6 Sep 2025 20:57:25 +0300 Subject: [PATCH] splitting to modules, starting to flesh out soundnodes --- .gitignore | 2 +- zigsonnum/build.zig | 116 ------------------------------ zigsonnum/build.zig.zon | 86 ---------------------- zigsonnum/point.zig | 30 ++++++++ zigsonnum/settings.zig | 30 ++++++++ zigsonnum/{src => }/soundnode.zig | 96 ++++++++++++------------- zigsonnum/src/freqampmap.zig | 0 zigsonnum/src/main.bak.zig | 46 ------------ zigsonnum/src/main.zig | 67 ----------------- zigsonnum/testtest.zig | 58 +++++++++++++++ zigsonnum/utility.zig | 8 +++ 11 files changed, 173 insertions(+), 366 deletions(-) delete mode 100644 zigsonnum/build.zig delete mode 100644 zigsonnum/build.zig.zon create mode 100644 zigsonnum/point.zig create mode 100644 zigsonnum/settings.zig rename zigsonnum/{src => }/soundnode.zig (57%) delete mode 100644 zigsonnum/src/freqampmap.zig delete mode 100644 zigsonnum/src/main.bak.zig delete mode 100644 zigsonnum/src/main.zig create mode 100644 zigsonnum/testtest.zig create mode 100644 zigsonnum/utility.zig diff --git a/.gitignore b/.gitignore index fcd5619..bf339a6 100644 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,7 @@ # Learn more about .gitignore: # https://www.atlassian.com/git/tutorials/saving-changes/gitignore -celltool_new/plugins/rarityct +sonnum.prj # Node artifact files node_modules/ diff --git a/zigsonnum/build.zig b/zigsonnum/build.zig deleted file mode 100644 index f21c5a4..0000000 --- a/zigsonnum/build.zig +++ /dev/null @@ -1,116 +0,0 @@ -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(.{}); - - // This creates a "module", which represents a collection of source files alongside - // some compilation options, such as optimization mode and linked system libraries. - // Every executable or library we compile will be based on one or more modules. - const lib_mod = b.createModule(.{ - // `root_source_file` is the Zig "entry point" of the module. If a module - // only contains e.g. external object files, you can make this `null`. - // 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, - }); - - // We will also create a module for our other entry point, 'main.zig'. - const exe_mod = b.createModule(.{ - // `root_source_file` is the Zig "entry point" of the module. If a module - // only contains e.g. external object files, you can make this `null`. - // 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/main.zig"), - .target = target, - .optimize = optimize, - }); - - // Modules can depend on one another using the `std.Build.Module.addImport` function. - // This is what allows Zig source code to use `@import("foo")` where 'foo' is not a - // file path. In this case, we set up `exe_mod` to import `lib_mod`. - exe_mod.addImport("zigsonnum_lib", lib_mod); - - // Now, we will create a static library based on the module we created above. - // This creates a `std.Build.Step.Compile`, which is the build step responsible - // for actually invoking the compiler. - const lib = b.addLibrary(.{ - .linkage = .static, - .name = "zigsonnum", - .root_module = lib_mod, - }); - - // 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); - - // This creates another `std.Build.Step.Compile`, but this one builds an executable - // rather than a static library. - const exe = b.addExecutable(.{ - .name = "zigsonnum", - .root_module = exe_mod, - }); - - // 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_module = lib_mod, - }); - - const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests); - - const exe_unit_tests = b.addTest(.{ - .root_module = exe_mod, - }); - - 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); -} diff --git a/zigsonnum/build.zig.zon b/zigsonnum/build.zig.zon deleted file mode 100644 index 06d754b..0000000 --- a/zigsonnum/build.zig.zon +++ /dev/null @@ -1,86 +0,0 @@ -.{ - // This is the default name used by packages depending on this one. For - // example, when a user runs `zig fetch --save `, this field is used - // as the key in the `dependencies` table. Although the user can choose a - // different name, most users will stick with this provided value. - // - // It is redundant to include "zig" in this name because it is already - // within the Zig package namespace. - .name = .zigsonnum, - - // 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", - - // Together with name, this represents a globally unique package - // identifier. This field is generated by the Zig toolchain when the - // package is first created, and then *never changes*. This allows - // unambiguous detection of one package being an updated version of - // another. - // - // When forking a Zig project, this id should be regenerated (delete the - // field and run `zig build`) if the upstream project is still maintained. - // Otherwise, the fork is *hostile*, attempting to take control over the - // original project's identity. Thus it is recommended to leave the comment - // on the following line intact, so that it shows up in code reviews that - // modify the field. - .fingerprint = 0x6c1efda17b55dfdb, // Changing this has security and trust implications. - - // Tracks the earliest Zig version that the package considers to be a - // supported use case. - .minimum_zig_version = "0.14.1", - - // 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 = .{ - // See `zig fetch --save ` for a command-line interface for adding dependencies. - //.example = .{ - // // When updating this field to a new URL, be sure to delete the corresponding - // // `hash`, otherwise you are communicating that you expect to find the old hash at - // // the new URL. If the contents of a URL change this will result in a hash mismatch - // // which will prevent zig from using it. - // .url = "https://example.com/foo.tar.gz", - // - // // This is computed from the file contents of the directory of files that is - // // obtained after fetching `url` and applying the inclusion rules given by - // // `paths`. - // // - // // This field is the source of truth; packages do not come from a `url`; they - // // come from a `hash`. `url` is just one of many possible mirrors for how to - // // obtain a package matching this `hash`. - // // - // // Uses the [multihash](https://multiformats.io/multihash/) format. - // .hash = "...", - // - // // When this is provided, the package is found in a directory relative to the - // // build root. In this case the package's hash is irrelevant and therefore not - // // computed. This field and `url` are mutually exclusive. - // .path = "foo", - // - // // When this is set to `true`, a package is declared to be lazily - // // fetched. This makes the dependency only get fetched if it is - // // actually used. - // .lazy = false, - //}, - }, - - // 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. Only files listed here will remain on disk - // when using the zig package manager. As a rule of thumb, one should list - // files required for compilation plus any license(s). - // 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 = .{ - "build.zig", - "build.zig.zon", - "src", - // For example... - //"LICENSE", - //"README.md", - }, -} diff --git a/zigsonnum/point.zig b/zigsonnum/point.zig new file mode 100644 index 0000000..c236d65 --- /dev/null +++ b/zigsonnum/point.zig @@ -0,0 +1,30 @@ +const std = @import("std"); +const print = std.debug.print; + +const math = std.math; + +pub const Pnt = struct { + + x: f32 = 0, + y: f32 = 0, + z: f32 = 0, + + fn printPnt(self: *const Pnt) void { + print("{d} {d} {d}\n", .{self.x, self.y, self.z}); + } + +}; + +pub fn distanceBetweenPoints(pt1: *const Pnt, pt2: *const Pnt) f32 { + + if ((pt1.x == pt2.x) and (pt1.y == pt2.y) and (pt1.z == pt2.z)) { + return 0; + } + + const dx: f32 = pt1.x - pt2.x; + const dy: f32 = pt1.y - pt2.y; + const dz: f32 = pt1.z - pt2.z; + + return math.sqrt(dx*dx + dy*dy + dz*dz); + +} \ No newline at end of file diff --git a/zigsonnum/settings.zig b/zigsonnum/settings.zig new file mode 100644 index 0000000..f165c10 --- /dev/null +++ b/zigsonnum/settings.zig @@ -0,0 +1,30 @@ +const std = @import("std"); +const print = std.debug.print; +const math = std.math; + +const utility = @import("utility.zig"); + + +pub const SoundSettings = struct { + + const default_sample_rate: u16 = 44100; + const default_bit_depth: u8 = 24; + + sample_rate: u16 = default_sample_rate, + speed_of_sound: f32 = 343.0 / @as(f32, default_sample_rate), + bit_depth: u8 = default_bit_depth, + max_amp: i64 = math.pow(i64, 2, default_bit_depth-1) - 1, + min_amp: i64 = - math.pow(i64, 2, default_bit_depth-1), + sample_width: u8 = @intFromFloat(@as(f32, default_bit_depth) / 8.0), + sine_multiplier: f64 = utility.tau / default_sample_rate, + + pub fn printSettings(self: *const SoundSettings) void { + print("Sample rate : {d}\n", .{self.sample_rate}); + print("Bit depth : {d}\n", .{self.bit_depth}); + print("Max amp : {d}\n", .{self.max_amp}); + print("Min amp : {d}\n", .{self.min_amp}); + print("Sample width: {d}\n", .{self.sample_width}); + print("Sine mult : {d}\n", .{self.sine_multiplier}); + } + +}; \ No newline at end of file diff --git a/zigsonnum/src/soundnode.zig b/zigsonnum/soundnode.zig similarity index 57% rename from zigsonnum/src/soundnode.zig rename to zigsonnum/soundnode.zig index 5f1a579..f98e446 100644 --- a/zigsonnum/src/soundnode.zig +++ b/zigsonnum/soundnode.zig @@ -1,58 +1,48 @@ const std = @import("std"); const print = std.debug.print; const math = std.math; + const Endian = std.builtin.Endian; +const ArrayList = std.ArrayList; +const AutoHashMap = std.AutoHashMap; +const Allocator = std.mem.Allocator; -pub const tau: f64 = 2 * 3.1415926535897932384626433832795028841971; +const Pnt = @import("point.zig").Pnt; +const SoundSettings = @import("settings.zig").SoundSettings; + +const utility = @import("utility.zig"); +const prnt = utility.prnt; -pub fn prnt(s: []const u8) void { - print("{s}\n", .{s}); -} - - -const SoundSettings = struct { - - const default_sample_rate: u16 = 44100; - const default_bit_depth: u8 = 24; - - sample_rate: u16 = default_sample_rate, - speed_of_sound: f32 = 343.0 / @as(f32, default_sample_rate), - bit_depth: u8 = default_bit_depth, - max_amp: i64 = math.pow(i64, 2, default_bit_depth-1) - 1, - min_amp: i64 = - math.pow(i64, 2, default_bit_depth-1), - sample_width: u8 = @intFromFloat(@as(f32, default_bit_depth) / 8.0), - sine_multiplier: f64 = tau / default_sample_rate, +pub const SoundNode = struct { - fn printSettings(self: *const SoundSettings) void { - print("Sample rate : {d}\n", .{self.sample_rate}); - print("Bit depth : {d}\n", .{self.bit_depth}); - print("Max amp : {d}\n", .{self.max_amp}); - print("Min amp : {d}\n", .{self.min_amp}); - print("Sample width: {d}\n", .{self.sample_width}); - print("Sine mult : {d}\n", .{self.sine_multiplier}); - } - -}; - - -const Pnt = struct { - - x: f32 = 0, - y: f32 = 0, - z: f32 = 0, - - fn printPnt(self: *const Pnt) void { - print("{d} {d} {d}\n", .{self.x, self.y, self.z}); - } - -}; - -const SoundNode = struct { name: []const u8 = "soundnode", - air_in: []*SoundNode = undefined, - wire_in: []*SoundNode = undefined, - location: Pnt = Pnt{.x = 0, .y = 0, .z = 0} + location: Pnt = Pnt{.x = 0, .y = 0, .z = 0}, + + air_in: ArrayList(*SoundNode), + wire_in: ArrayList(*SoundNode), + + freqmap: AutoHashMap(u64, f16), + + pub fn init(allocator: Allocator, name: []const u8) !SoundNode { + + var air_in = ArrayList(*SoundNode).init(allocator); + defer air_in.deinit(); + + var wire_in = ArrayList(*SoundNode).init(allocator); + defer wire_in.deinit(); + + var freqmap = AutoHashMap(u64, f16).init(allocator); + defer freqmap.deinit(); + + return .{ + .air_in = air_in, + .wire_in = wire_in, + .name = name, + .freqmap = freqmap, + }; + + } }; pub fn singleSineTick(st: *SoundSettings, freq: f16, t: u64) f64 { @@ -61,9 +51,15 @@ pub fn singleSineTick(st: *SoundSettings, freq: f16, t: u64) f64 { } pub fn main() !void { - - var sn1: SoundNode = SoundNode{ .name="left_sink" }; + + var gpa = std.heap.GeneralPurposeAllocator(.{}){}; + const allocator = gpa.allocator(); + + var sn1: SoundNode = try SoundNode.init(allocator, "left_sink"); + var sn2: SoundNode = try SoundNode.init(allocator, "right_sink"); + sn2.location.x = -5; sn1.location.x = 4; + try sn1.air_in.append(&sn2); var st = SoundSettings{}; st.printSettings(); @@ -87,7 +83,7 @@ pub fn main() !void { try stdout.writeAll("WAVE"); try stdout.writeAll("fmt "); - + try stdout.writeInt(u32, 16, Endian.little); try stdout.writeInt(u16, 1, Endian.little); try stdout.writeInt(u16, 2, Endian.little); @@ -120,4 +116,4 @@ pub fn main() !void { prnt("done"); try bw.flush(); -} \ No newline at end of file +} diff --git a/zigsonnum/src/freqampmap.zig b/zigsonnum/src/freqampmap.zig deleted file mode 100644 index e69de29..0000000 diff --git a/zigsonnum/src/main.bak.zig b/zigsonnum/src/main.bak.zig deleted file mode 100644 index aebcbfc..0000000 --- a/zigsonnum/src/main.bak.zig +++ /dev/null @@ -1,46 +0,0 @@ -//! By convention, main.zig is where your main function lives in the case that -//! you are building an executable. If you are making a library, the convention -//! is to delete this file and start with root.zig instead. - -pub fn main() !void { - // Prints to stderr (it's a shortcut based on `std.io.getStdErr()`) - std.debug.print("All your {s} are belong to us.\n", .{"codebase"}); - - // stdout is for the actual output of your application, for example if you - // are implementing gzip, then only the compressed bytes should be sent to - // stdout, not any debugging messages. - const stdout_file = std.io.getStdOut().writer(); - var bw = std.io.bufferedWriter(stdout_file); - const stdout = bw.writer(); - - try stdout.print("Run `zig build test` to run the tests.\n", .{}); - - try bw.flush(); // Don't forget to flush! -} - -test "simple test" { - var list = std.ArrayList(i32).init(std.testing.allocator); - defer list.deinit(); // Try commenting this out and see if zig detects the memory leak! - try list.append(42); - try std.testing.expectEqual(@as(i32, 42), list.pop()); -} - -test "use other module" { - try std.testing.expectEqual(@as(i32, 150), lib.add(100, 50)); -} - -test "fuzz example" { - const Context = struct { - fn testOne(context: @This(), input: []const u8) anyerror!void { - _ = context; - // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case! - try std.testing.expect(!std.mem.eql(u8, "canyoufindme", input)); - } - }; - try std.testing.fuzz(Context{}, Context.testOne, .{}); -} - -const std = @import("std"); - -/// This imports the separate module containing `root.zig`. Take a look in `build.zig` for details. -const lib = @import("zigsonnum_lib"); diff --git a/zigsonnum/src/main.zig b/zigsonnum/src/main.zig deleted file mode 100644 index 590d43b..0000000 --- a/zigsonnum/src/main.zig +++ /dev/null @@ -1,67 +0,0 @@ -const std = @import("std"); -const soundnode = @import("soundnode.zig"); -const expect = std.testing.expect; -const print = std.debug.print; -const math = std.math; - - -const TestError = error { - IsFive, - IsSix -}; - - - - -pub fn prnt(s: []const u8) void { - print("{s}\n", .{s}); -} - -pub fn prntNum(i: anytype) void { - print("{d}\n", .{i}); -} - -pub fn testValue(a: u8) TestError!u8 { - - if (a == 5) { - return TestError.IsFive; - } - else { - if (a == 6) { - return TestError.IsSix; - } - else { - return a; - } - } - - -} - -pub fn distanceBetweenPoints(pt1: *const Pnt, pt2: *const Pnt) f32 { - - if ((pt1.x == pt2.x) and (pt1.y == pt2.y) and (pt1.z == pt2.z)) { - return 0; - } - - const dx: f32 = pt1.x - pt2.x; - const dy: f32 = pt1.y - pt2.y; - const dz: f32 = pt1.z - pt2.z; - - return math.sqrt(dx*dx + dy*dy + dz*dz); - -} - -pub fn main() void { - - const p1: Pnt = Pnt{.x = 0, .y = 0}; - const p2: Pnt = Pnt{.x = 1, .y = 1}; - - const p3: Pnt = Pnt{.x = 1, .y = 9751.767}; - - var dst: f32 = distanceBetweenPoints(&p1, &p2); - prntNum(dst); - - dst = distanceBetweenPoints(&p1, &p3); - prntNum(dst); -} diff --git a/zigsonnum/testtest.zig b/zigsonnum/testtest.zig new file mode 100644 index 0000000..a913e0d --- /dev/null +++ b/zigsonnum/testtest.zig @@ -0,0 +1,58 @@ +const std = @import("std"); +const print = std.debug.print; +const ArrayList = std.ArrayList; +const AutoHashMap = std.AutoHashMap; + +pub fn prnt(s: []const u8) void { + print("{s}\n", .{s}); +} + +const Pnt = struct { + + x: f32 = 0, + y: f32 = 0, + z: f32 = 0, + + fn printPnt(self: *const Pnt) void { + print("{d} {d} {d}\n", .{self.x, self.y, self.z}); + } + +}; + +pub fn main() !void { + + var gpa = std.heap.GeneralPurposeAllocator(.{}){}; + const allocator = gpa.allocator(); + + defer { + const deinit_status = gpa.deinit(); + _ = deinit_status; + } + + var pntlist = ArrayList(Pnt).init(allocator); + + var p1 = Pnt{.x = 0, .y= 1, .z = 3}; + p1.printPnt(); + + try pntlist.append(p1); + pntlist.items[0].printPnt(); + print("{d}\n", .{pntlist.items.len}); + try pntlist.append(p1); + print("{d}\n", .{pntlist.items.len}); + try pntlist.append(p1); + print("{d}\n", .{pntlist.items.len}); + + p1.x = 4; + p1.printPnt(); + pntlist.items[0].printPnt(); + print("{any}", .{@TypeOf(pntlist)}); + defer pntlist.deinit(); + + var map = AutoHashMap(u32, Pnt).init(allocator); + defer map.deinit(); + + try map.put(1, p1); + try map.put(22, pntlist.items[0]); + //map.get(22).printPnt(); + +} \ No newline at end of file diff --git a/zigsonnum/utility.zig b/zigsonnum/utility.zig new file mode 100644 index 0000000..eb6c113 --- /dev/null +++ b/zigsonnum/utility.zig @@ -0,0 +1,8 @@ +const std = @import("std"); +const print = std.debug.print; + +pub const tau: f64 = 2 * 3.1415926535897932384626433832795028841971; + +pub fn prnt(s: []const u8) void { + print("{s}\n", .{s}); +} \ No newline at end of file