rework clap entry point exporting

bandithedoge · bandithedoge · commit e3312e681d06 · 2025-12-27T21:39:18.000+01:00
diff --git a/build.zig b/build.zig
@@ -40,39 +40,22 @@ pub fn clapModule(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std
 pub const Options = struct {
     /// Doesn't have to match the display name in your plugin's descriptor
     name: []const u8,
-    /// Module that contains `plugin()`
+    /// This module must export a CLAP entry point
     root_module: *std.Build.Module,
     /// Whether to add the resulting compile step to your project's top level install step
     install: bool = true,
 };
 
 /// If `options.install` is true, the result will be installed to `lib/clap/{options.name}.clap`
 pub fn addClap(b: *std.Build, options: Options) !*std.Build.Step.Compile {
-    const entry = b.addWriteFile("entry.zig",
-        \\ export const clap_entry = @import("clap").clapEntry(@import("plugin_root"));
-    );
-
-    const target = options.root_module.resolved_target.?;
-    const optimize = options.root_module.optimize.?;
-
     const lib = b.addLibrary(.{
         .name = try std.fmt.allocPrint(b.allocator, "{s}_clap", .{options.name}),
         .linkage = .dynamic,
         // printing to stdout/stderr segfaults without this, possibly a bug in zig's new x86 backend
         .use_llvm = true,
-        .root_module = b.createModule(.{
-            .target = target,
-            .optimize = optimize,
-            .root_source_file = entry.getDirectory().path(b, "entry.zig"),
-            .imports = &.{
-                .{ .name = "plugin_root", .module = options.root_module },
-                .{ .name = "clap", .module = clapModule(b, target, optimize) },
-            },
-        }),
+        .root_module = options.root_module,
     });
 
-    lib.step.dependOn(&entry.step);
-
     if (options.install) {
         const install = b.addInstallArtifact(lib, .{
             .dest_sub_path = b.fmt("clap/{s}.clap", .{options.name}),
diff --git a/examples/clap-ext/build.zig b/examples/clap-ext/build.zig
@@ -13,15 +13,23 @@ pub fn build(b: *std.Build) !void {
     const plugin = b.createModule(.{
         .target = target,
         .optimize = optimize,
-        .root_source_file = b.path("src/Plugin.zig"),
+        .root_source_file = b.path("src/ClapExtExample.zig"),
         .imports = &.{
             .{ .name = "zigplug", .module = zigplug_dep.module("zigplug") },
-            .{ .name = "zigplug_clap", .module = zigplug.clapModule(b, target, optimize) },
         },
     });
 
     _ = try zigplug.addClap(b, .{
         .name = "clap-ext",
-        .root_module = plugin,
+        .root_module = b.createModule(.{
+            .target = target,
+            .optimize = optimize,
+            .root_source_file = b.path("src/entry_clap.zig"),
+            .imports = &.{
+                .{ .name = "ClapExtExample", .module = plugin },
+
+                .{ .name = "zigplug_clap", .module = zigplug.clapModule(b, target, optimize) },
+            },
+        }),
     });
 }
diff --git a/examples/clap-ext/src/ClapExtExample.zig b/examples/clap-ext/src/ClapExtExample.zig
@@ -3,7 +3,6 @@ const ClapExtExample = @This();
 const std = @import("std");
 
 const zigplug = @import("zigplug");
-const clap = @import("zigplug_clap");
 
 pub const meta: zigplug.Meta = .{
     .name = "zigplug clap extension example",
@@ -26,52 +25,6 @@ pub const meta: zigplug.Meta = .{
     },
 };
 
-fn getExtension(id: [:0]const u8) ?*const anyopaque {
-    // let's implement the "note-name" extension, which is not supported in zigplug (yet?).
-    // we can test this in reaper for example
-    //
-    // https://github.com/free-audio/clap/blob/main/include/clap/ext/note-name.h
-    if (std.mem.eql(u8, id, &clap.c.CLAP_EXT_NOTE_NAME)) {
-        const ext = struct {
-            pub fn count(_: [*c]const clap.c.clap_plugin_t) callconv(.c) u32 {
-                return 1;
-            }
-
-            pub fn get(clap_plugin: [*c]const clap.c.clap_plugin_t, index: u32, note_name: [*c]clap.c.clap_note_name_t) callconv(.c) bool {
-                // you can use this to access your plugin's state
-                const self = clap.pluginFromClap(clap_plugin, ClapExtExample);
-                _ = self;
-
-                if (index == 0) {
-                    // let's set the name of every note to some string
-                    note_name.* = .{
-                        // zig initializes c structs with `std.mem.zeroes` so we don't have to deal with an undefined
-                        // name value
-                        .port = -1,
-                        .key = -1,
-                        .channel = -1,
-                    };
-                    std.mem.copyForwards(u8, &note_name.*.name, "Hello world... i mean note");
-                    return true;
-                }
-                return false;
-            }
-        };
-        return &clap.c.clap_plugin_note_name_t{
-            .count = ext.count,
-            .get = ext.get,
-        };
-    }
-    return null;
-}
-
-pub const clap_meta: clap.Meta = .{
-    .id = "com.bandithedoge.zigplug_clap_ext_example",
-    .features = &.{ .instrument, .synthesizer, .mono },
-    .extra_features = &.{"custom-namespace:custom-feature"},
-    .getExtension = getExtension,
-};
-
 gpa: std.heap.GeneralPurposeAllocator(.{}) = .init,
 
 phase: f32 = 0,
diff --git a/examples/clap-ext/src/entry_clap.zig b/examples/clap-ext/src/entry_clap.zig
@@ -0,0 +1,52 @@
+const std = @import("std");
+const clap = @import("zigplug_clap");
+
+const ClapExtExample = @import("ClapExtExample");
+
+// let's implement the "note-name" extension, which is not supported in zigplug (yet?).
+// we can test this in reaper for example
+//
+// https://github.com/free-audio/clap/blob/main/include/clap/ext/note-name.h
+fn getExtension(id: [:0]const u8) ?*const anyopaque {
+    if (std.mem.eql(u8, id, &clap.c.CLAP_EXT_NOTE_NAME)) {
+        const ext = struct {
+            pub fn count(_: [*c]const clap.c.clap_plugin_t) callconv(.c) u32 {
+                return 1;
+            }
+
+            pub fn get(clap_plugin: [*c]const clap.c.clap_plugin_t, index: u32, note_name: [*c]clap.c.clap_note_name_t) callconv(.c) bool {
+                // you can use this to access your plugin's state
+                const self = clap.pluginFromClap(clap_plugin, ClapExtExample);
+                _ = self;
+
+                if (index == 0) {
+                    // let's set the name of every note to some string
+                    note_name.* = .{
+                        // zig initializes c structs with `std.mem.zeroes` so we don't have to deal with an undefined
+                        // name value
+                        .port = -1,
+                        .key = -1,
+                        .channel = -1,
+                    };
+                    std.mem.copyForwards(u8, &note_name.*.name, "Hello world... i mean note");
+                    return true;
+                }
+                return false;
+            }
+        };
+        return &clap.c.clap_plugin_note_name_t{
+            .count = ext.count,
+            .get = ext.get,
+        };
+    }
+    return null;
+}
+
+comptime {
+    clap.exportClap(ClapExtExample, .{
+        .id = "com.bandithedoge.zigplug_clap_ext_example",
+        .features = &.{ .instrument, .synthesizer, .mono },
+        .extra_features = &.{"custom-namespace:custom-feature"},
+        .getExtension = getExtension,
+    });
+}
diff --git a/examples/gain/build.zig b/examples/gain/build.zig
@@ -13,15 +13,23 @@ pub fn build(b: *std.Build) !void {
     const plugin = b.createModule(.{
         .target = target,
         .optimize = optimize,
-        .root_source_file = b.path("src/Plugin.zig"),
+        .root_source_file = b.path("src/GainExample.zig"),
         .imports = &.{
             .{ .name = "zigplug", .module = zigplug_dep.module("zigplug") },
-            .{ .name = "zigplug_clap", .module = zigplug.clapModule(b, target, optimize) },
         },
     });
 
     _ = try zigplug.addClap(b, .{
         .name = "gain",
-        .root_module = plugin,
+        .root_module = b.createModule(.{
+            .target = target,
+            .optimize = optimize,
+            .root_source_file = b.path("src/entry_clap.zig"),
+            .imports = &.{
+                .{ .name = "GainExample", .module = plugin },
+
+                .{ .name = "zigplug_clap", .module = zigplug.clapModule(b, target, optimize) },
+            },
+        }),
     });
 }
diff --git a/examples/gain/src/GainExample.zig b/examples/gain/src/GainExample.zig
@@ -54,11 +54,6 @@ pub const meta: zigplug.Meta = .{
     .sample_accurate_automation = true,
 };
 
-pub const clap_meta: @import("zigplug_clap").Meta = .{
-    .id = "com.bandithedoge.zigplug_gain_example",
-    .features = &.{ .audio_effect, .mono, .stereo, .utility },
-};
-
 gpa: std.heap.GeneralPurposeAllocator(.{}) = .init,
 
 pub fn init() !GainExample {
diff --git a/examples/gain/src/entry_clap.zig b/examples/gain/src/entry_clap.zig
@@ -0,0 +1,8 @@
+const GainExample = @import("GainExample");
+
+comptime {
+    @import("zigplug_clap").exportClap(GainExample, .{
+        .id = "com.bandithedoge.zigplug_gain_example",
+        .features = &.{ .audio_effect, .mono, .stereo, .utility },
+    });
+}
diff --git a/examples/sine/build.zig b/examples/sine/build.zig
@@ -13,15 +13,23 @@ pub fn build(b: *std.Build) !void {
     const plugin = b.createModule(.{
         .target = target,
         .optimize = optimize,
-        .root_source_file = b.path("src/Plugin.zig"),
+        .root_source_file = b.path("src/SineExample.zig"),
         .imports = &.{
             .{ .name = "zigplug", .module = zigplug_dep.module("zigplug") },
-            .{ .name = "zigplug_clap", .module = zigplug.clapModule(b, target, optimize) },
         },
     });
 
     _ = try zigplug.addClap(b, .{
         .name = "sine",
-        .root_module = plugin,
+        .root_module = b.createModule(.{
+            .target = target,
+            .optimize = optimize,
+            .root_source_file = b.path("src/entry_clap.zig"),
+            .imports = &.{
+                .{ .name = "SineExample", .module = plugin },
+
+                .{ .name = "zigplug_clap", .module = zigplug.clapModule(b, target, optimize) },
+            },
+        }),
     });
 }
diff --git a/examples/sine/src/SineExample.zig b/examples/sine/src/SineExample.zig
@@ -25,11 +25,6 @@ pub const meta: zigplug.Meta = .{
     },
 };
 
-pub const clap_meta: @import("zigplug_clap").Meta = .{
-    .id = "com.bandithedoge.zigplug_sine_example",
-    .features = &.{ .instrument, .synthesizer, .mono },
-};
-
 gpa: std.heap.GeneralPurposeAllocator(.{}) = .init,
 
 phase: f32 = 0,
diff --git a/examples/sine/src/entry_clap.zig b/examples/sine/src/entry_clap.zig
@@ -0,0 +1,8 @@
+const SineExample = @import("SineExample");
+
+comptime {
+    @import("zigplug_clap").exportClap(SineExample, .{
+        .id = "com.bandithedoge.zigplug_gain_example",
+        .features = &.{ .audio_effect, .mono, .stereo, .utility },
+    });
+}
diff --git a/src/clap/root.zig b/src/clap/root.zig
diff --git a/src/core/root.zig b/src/core/root.zig
