From f52052da90409e120cd9b675f581df84d2091e9e Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 24 Oct 2025 17:31:36 +0200 Subject: [PATCH] big rework towards Zig 0.15 --- .gitignore | 6 +- build.zig | 190 +++++++++++++++++++++----------------- build.zig.zon | 52 ++++------- examples/mandelbrot.nzsl | 8 +- examples/mandelbrot.zig | 32 +++---- src/BackendParameters.zig | 81 ++++++++++++++++ src/GlslWriter.zig | 139 ++++++++++++++-------------- src/LangWriter.zig | 59 ++++++------ src/Module.zig | 33 ++++--- src/Parser.zig | 44 --------- src/SpirvWriter.zig | 78 +++++++++------- src/WriterStates.zig | 93 ------------------- src/lib.zig | 37 ++++++-- src/nzsl-c.zig | 3 - src/parser.zig | 27 ++++++ 15 files changed, 439 insertions(+), 443 deletions(-) create mode 100644 src/BackendParameters.zig delete mode 100644 src/Parser.zig delete mode 100644 src/WriterStates.zig delete mode 100644 src/nzsl-c.zig create mode 100644 src/parser.zig diff --git a/.gitignore b/.gitignore index 9d712b0..3389c86 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,2 @@ - -.idea/ -zig-cache/ -zig-out/ \ No newline at end of file +.zig-cache/ +zig-out/ diff --git a/build.zig b/build.zig index d26dc4b..51243d1 100644 --- a/build.zig +++ b/build.zig @@ -3,10 +3,7 @@ const std = @import("std"); const Build = std.Build; const Step = std.Build.Step; -pub const Libsource = enum { - source, - prebuild -}; +pub const Libsource = enum { source, prebuild }; // based on ziglua's build.zig @@ -28,24 +25,25 @@ pub fn build(b: *Build) void { } // Zig module - const nzslzig = b.addModule("nzslzig", .{ - .root_source_file = .{ .path = "src/lib.zig" }, - }); - - const docs = b.addStaticLibrary(.{ - .name = "nzslzig", - .root_source_file = .{ .path = "src/lib.zig" }, + const nzigsl = b.addModule("nzigsl", .{ .target = target, .optimize = optimize, + .root_source_file = b.path("src/lib.zig"), }); - // Expose build configuration to the nzslzig module + const docs = b.addLibrary(.{ + .name = "nzigsl", + .root_module = nzigsl, + .linkage = .static, + }); + + // Expose build configuration to the nzigsl module const config = b.addOptions(); config.addOption(Libsource, "libsource", libsource); - nzslzig.addOptions("config", config); + nzigsl.addOptions("config", config); nzsldep: { - const upstream = b.lazyDependency(if (libsource == .source) "nzsl_source" else break :nzsldep , .{}) orelse break :nzsldep; + const upstream = b.lazyDependency(if (libsource == .source) "nzsl" else break :nzsldep, .{}) orelse break :nzsldep; const nazaraUtils = b.lazyDependency("NazaraUtils", .{}) orelse break :nzsldep; const frozen = b.lazyDependency("frozen", .{}) orelse break :nzsldep; const fmt = b.lazyDependency("fmt", .{}) orelse break :nzsldep; @@ -53,16 +51,16 @@ pub fn build(b: *Build) void { const fast_float = b.lazyDependency("fast_float", .{}) orelse break :nzsldep; const lib = switch (libsource) { - .source => buildNzsl(b, target, optimize, upstream, nazaraUtils, frozen, fmt, ordered_map, fast_float, shared), - else => unreachable, + .source => buildNzsl(b, target, optimize, upstream, nazaraUtils, frozen, fmt, ordered_map, fast_float, shared), + else => unreachable, }; // Expose the Nzsl artifact b.installArtifact(lib); - //nzslzig.addSystemIncludePath(upstream.path("include")); + //nzigsl.addSystemIncludePath(upstream.path("include")); - nzslzig.linkLibrary(lib); + nzigsl.linkLibrary(lib); docs.linkLibrary(lib); } @@ -74,11 +72,13 @@ pub fn build(b: *Build) void { for (examples) |example| { const exe = b.addExecutable(.{ .name = example[0], - .root_source_file = .{ .path = example[1] }, - .target = target, - .optimize = optimize, + .root_module = b.createModule(.{ + .target = target, + .optimize = optimize, + .root_source_file = b.path(example[1]), + }), }); - exe.root_module.addImport("nzslzig", nzslzig); + exe.root_module.addImport("nzigsl", nzigsl); const artifact = b.addInstallArtifact(exe, .{}); const exe_step = b.step(b.fmt("install-example-{s}", .{example[0]}), b.fmt("Install {s} example", .{example[0]})); @@ -93,7 +93,7 @@ pub fn build(b: *Build) void { } docs.root_module.addOptions("config", config); - docs.root_module.addImport("nzslzig", nzslzig); + docs.root_module.addImport("nzigsl", nzigsl); const install_docs = b.addInstallDirectory(.{ .source_dir = docs.getEmittedDocs(), @@ -106,16 +106,14 @@ pub fn build(b: *Build) void { } fn buildNzsl(b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, upstream: *Build.Dependency, nazaraUtils: *Build.Dependency, frozen: *Build.Dependency, ordered_map: *Build.Dependency, fast_float: *Build.Dependency, fmt: *Build.Dependency, shared: bool) *Step.Compile { - - const lib_opts = .{ + const lib = b.addLibrary(.{ .name = "nzsl", - .target = target, - .optimize = optimize, - }; - const lib = if (shared) - b.addSharedLibrary(lib_opts) - else - b.addStaticLibrary(lib_opts); + .root_module = b.createModule(.{ + .target = target, + .optimize = optimize, + }), + .linkage = if (shared) .dynamic else .static, + }); lib.addSystemIncludePath(upstream.path("include")); lib.addSystemIncludePath(upstream.path("src")); @@ -128,7 +126,9 @@ fn buildNzsl(b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.Opti const flags = [_][]const u8{ if (shared) - "-DCNZSL_DYNAMIC" else "-DCNZSL_STATIC", + "-DCNZSL_DYNAMIC" + else + "-DCNZSL_STATIC", if (shared) "-DNZSL_DYNAMIC" else "-DNZSL_STATIC", "-DCNZSL_BUILD", "-DNZSL_BUILD", @@ -159,63 +159,83 @@ fn buildNzsl(b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.Opti lib.linkLibCpp(); - lib.installHeader(upstream.path("include/CNZSL/CNZSL.h"), "CNZSL/CNZSL.h"); - lib.installHeader(upstream.path("include/CNZSL/Config.h"), "CNZSL/Config.h"); - lib.installHeader(upstream.path("include/CNZSL/DebugLevel.h"), "CNZSL/DebugLevel.h"); - lib.installHeader(upstream.path("include/CNZSL/GlslWriter.h"), "CNZSL/GlslWriter.h"); - lib.installHeader(upstream.path("include/CNZSL/LangWriter.h"), "CNZSL/LangWriter.h"); - lib.installHeader(upstream.path("include/CNZSL/Module.h"), "CNZSL/Module.h"); - lib.installHeader(upstream.path("include/CNZSL/Parser.h"), "CNZSL/Parser.h"); - lib.installHeader(upstream.path("include/CNZSL/ShaderStageType.h"), "CNZSL/ShaderStageType.h"); lib.installHeader(upstream.path("include/CNZSL/SpirvWriter.h"), "CNZSL/SpirvWriter.h"); - lib.installHeader(upstream.path("include/CNZSL/WriterStates.h"), "CNZSL/WriterStates.h"); + lib.installHeader(upstream.path("include/CNZSL/ShaderStageType.h"), "CNZSL/ShaderStageType.h"); + lib.installHeader(upstream.path("include/CNZSL/Serializer.h"), "CNZSL/Serializer.h"); + lib.installHeader(upstream.path("include/CNZSL/Parser.h"), "CNZSL/Parser.h"); + lib.installHeader(upstream.path("include/CNZSL/Module.h"), "CNZSL/Module.h"); + lib.installHeader(upstream.path("include/CNZSL/LangWriter.h"), "CNZSL/LangWriter.h"); + lib.installHeader(upstream.path("include/CNZSL/GlslWriter.h"), "CNZSL/GlslWriter.h"); + lib.installHeader(upstream.path("include/CNZSL/DebugLevel.h"), "CNZSL/DebugLevel.h"); + lib.installHeader(upstream.path("include/CNZSL/Config.h"), "CNZSL/Config.h"); + lib.installHeader(upstream.path("include/CNZSL/CNZSL.h"), "CNZSL/CNZSL.h"); + lib.installHeader(upstream.path("include/CNZSL/BackendParameters.h"), "CNZSL/BackendParameters.h"); + lib.installHeader(upstream.path("include/CNZSL/FilesystemModuleResolver.h"), "CNZSL/FilesystemModuleResolver.h"); return lib; } const nzsl_source_files_list = [_][]const u8{ - "src/NZSL/Ast/AstSerializer.cpp", - "src/NZSL/Ast/Cloner.cpp", - "src/NZSL/Ast/ConstantPropagationVisitor.cpp", - "src/NZSL/Ast/ConstantPropagationVisitor_BinaryArithmetics.cpp", - "src/NZSL/Ast/ConstantPropagationVisitor_BinaryComparison.cpp", - "src/NZSL/Ast/ConstantValue.cpp", - "src/NZSL/Ast/DependencyCheckerVisitor.cpp", - "src/NZSL/Ast/EliminateUnusedPassVisitor.cpp", - "src/NZSL/Ast/ExportVisitor.cpp", - "src/NZSL/Ast/ExpressionType.cpp", - "src/NZSL/Ast/ExpressionVisitor.cpp", - "src/NZSL/Ast/ExpressionVisitorExcept.cpp", - "src/NZSL/Ast/IndexRemapperVisitor.cpp", - "src/NZSL/Ast/Nodes.cpp", - "src/NZSL/Ast/RecursiveVisitor.cpp", - "src/NZSL/Ast/ReflectVisitor.cpp", - "src/NZSL/Ast/SanitizeVisitor.cpp", - "src/NZSL/Ast/StatementVisitor.cpp", - "src/NZSL/Ast/StatementVisitorExcept.cpp", - "src/NZSL/Ast/Utils.cpp", - "src/NZSL/FilesystemModuleResolver.cpp", - "src/NZSL/GlslWriter.cpp", - "src/NZSL/Lang/Errors.cpp", - "src/NZSL/LangWriter.cpp", - "src/NZSL/Lexer.cpp", - "src/NZSL/ModuleResolver.cpp", - "src/NZSL/Parser.cpp", - "src/NZSL/Serializer.cpp", - "src/NZSL/ShaderWriter.cpp", - "src/NZSL/SpirV/SpirvAstVisitor.cpp", - "src/NZSL/SpirV/SpirvConstantCache.cpp", - "src/NZSL/SpirV/SpirvData.cpp", - "src/NZSL/SpirV/SpirvDecoder.cpp", - "src/NZSL/SpirV/SpirvExpressionLoad.cpp", - "src/NZSL/SpirV/SpirvExpressionStore.cpp", - "src/NZSL/SpirV/SpirvPrinter.cpp", - "src/NZSL/SpirV/SpirvSectionBase.cpp", "src/NZSL/SpirvWriter.cpp", - "src/CNZSL/GlslWriter.cpp", - "src/CNZSL/LangWriter.cpp", - "src/CNZSL/Module.cpp", - "src/CNZSL/Parser.cpp", + "src/NZSL/SpirV/SpirvSectionBase.cpp", + "src/NZSL/SpirV/SpirvPrinter.cpp", + "src/NZSL/SpirV/SpirvExpressionStore.cpp", + "src/NZSL/SpirV/SpirvExpressionLoad.cpp", + "src/NZSL/SpirV/SpirvDecoder.cpp", + "src/NZSL/SpirV/SpirvData.cpp", + "src/NZSL/SpirV/SpirvConstantCache.cpp", + "src/NZSL/SpirV/SpirvAstVisitor.cpp", + "src/NZSL/Serializer.cpp", + "src/NZSL/Parser.cpp", + "src/NZSL/ModuleResolver.cpp", + "src/NZSL/Lexer.cpp", + "src/NZSL/LangWriter.cpp", + "src/NZSL/Lang/Version.cpp", + "src/NZSL/Lang/Errors.cpp", + "src/NZSL/GlslWriter.cpp", + "src/NZSL/FilesystemModuleResolver.cpp", + "src/NZSL/Ast/Utils.cpp", + "src/NZSL/Ast/Transformations/ValidationTransformer.cpp", + "src/NZSL/Ast/Transformations/TransformerContext.cpp", + "src/NZSL/Ast/Transformations/Transformer.cpp", + "src/NZSL/Ast/Transformations/SwizzleTransformer.cpp", + "src/NZSL/Ast/Transformations/StructAssignmentTransformer.cpp", + "src/NZSL/Ast/Transformations/ResolveTransformer.cpp", + "src/NZSL/Ast/Transformations/MatrixTransformer.cpp", + "src/NZSL/Ast/Transformations/LoopUnrollTransformer.cpp", + "src/NZSL/Ast/Transformations/LiteralTransformer.cpp", + "src/NZSL/Ast/Transformations/IndexRemapperTransformer.cpp", + "src/NZSL/Ast/Transformations/IdentifierTransformer.cpp", + "src/NZSL/Ast/Transformations/ForToWhileTransformer.cpp", + "src/NZSL/Ast/Transformations/EliminateUnusedTransformer.cpp", + "src/NZSL/Ast/Transformations/ConstantRemovalTransformer.cpp", + "src/NZSL/Ast/Transformations/ConstantPropagationTransformer_Binary.cpp", + "src/NZSL/Ast/Transformations/ConstantPropagationTransformer.cpp", + "src/NZSL/Ast/Transformations/CompoundAssignmentTransformer.cpp", + "src/NZSL/Ast/Transformations/BranchSplitterTransformer.cpp", + "src/NZSL/Ast/Transformations/BindingResolverTransformer.cpp", + "src/NZSL/Ast/Transformations/AliasTransformer.cpp", + "src/NZSL/Ast/StatementVisitorExcept.cpp", + "src/NZSL/Ast/StatementVisitor.cpp", + "src/NZSL/Ast/ReflectVisitor.cpp", + "src/NZSL/Ast/RecursiveVisitor.cpp", + "src/NZSL/Ast/Nodes.cpp", + "src/NZSL/Ast/IdentifierList.cpp", + "src/NZSL/Ast/ExpressionVisitorExcept.cpp", + "src/NZSL/Ast/ExpressionVisitor.cpp", + "src/NZSL/Ast/ExpressionType.cpp", + "src/NZSL/Ast/ExportVisitor.cpp", + "src/NZSL/Ast/DependencyCheckerVisitor.cpp", + "src/NZSL/Ast/ConstantValue.cpp", + "src/NZSL/Ast/Cloner.cpp", + "src/NZSL/Ast/AstSerializer.cpp", + "src/NZSL/Archive.cpp", "src/CNZSL/SpirvWriter.cpp", - "src/CNZSL/WriterStates.cpp", -}; \ No newline at end of file + "src/CNZSL/Serializer.cpp", + "src/CNZSL/Parser.cpp", + "src/CNZSL/Module.cpp", + "src/CNZSL/LangWriter.cpp", + "src/CNZSL/GlslWriter.cpp", + "src/CNZSL/FilesystemModuleResolver.cpp", + "src/CNZSL/BackendParameters.cpp", +}; diff --git a/build.zig.zon b/build.zig.zon index ee79759..e5ab531 100644 --- a/build.zig.zon +++ b/build.zig.zon @@ -1,62 +1,42 @@ .{ .name = .NZSL, - // 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", + .version = "1.1.1", + .fingerprint = 0xd558585854524c37, - // 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 = .{ - .nzsl_source = .{ - .url = "https://github.com/NazaraEngine/ShaderLang/archive/97dfc07923572cb26aa2db485df6bd837dea79bb.tar.gz", - .hash = "12203c913b5cbccbb4b6b11d7e5730f81ed0737553fe3fc30995d059bf859101933f", + .nzsl = .{ + .url = "git+https://github.com/NazaraEngine/ShaderLang?ref=v1.1.1#6d06572eaa664b1655f57522edf1e8c88292be0a", + .hash = "N-V-__8AAPOQIwAwA5SQCrbVxrBp5Q7YX--899XJIjFv6rZn", + .lazy = true, .lazy = true, }, .NazaraUtils = .{ - .url = "https://github.com/NazaraEngine/NazaraUtils/archive/cbdb331a9610fa52f51e7c86576cc9e2e7235691.tar.gz", - .hash = "1220a6576ccd4e2c0cf5ab804ef680c4d1834859d1f7a7e3228fef73f8dce8c0e826", + .url = "git+https://github.com/NazaraEngine/NazaraUtils?ref=v1.0.0#d2f5d902ed9ac2bc8e26a015b1ff02edc5e3b550", + .hash = "N-V-__8AAJuBBgAWrip3l4mh6_ZGHqqhMM71rYLtPorOOwyf", .lazy = true, }, .frozen = .{ - .url = "https://github.com/serge-sans-paille/frozen/archive/292a8110466ae964c8fde9d0e0371e5ac21bfa60.tar.gz", - .hash = "122039e95c3739bd73b8413d3448395b1e7b17953e342e4c3c07de848d406a28733c", + .url = "git+https://github.com/serge-sans-paille/frozen?ref=1.2.0#06bee5321cecd9a9ffaceb164b5adb2ffafae781", + .hash = "N-V-__8AAKBODwDkFCWVcsOuoC6UVtDAF1UXmqRUcTQ3nAei", .lazy = true, }, .fmt = .{ - .url = "https://github.com/fmtlib/fmt/archive/e69e5f977d458f2650bb346dadf2ad30c5320281.tar.gz", - .hash = "12202f41bb1cbca6f555a37883ce510374b9ca577ed5cd117d71c7bdc2c87380e14d", + .url = "git+https://github.com/fmtlib/fmt?ref=12.0.0#e424e3f2e607da02742f73db84873b8084fc714c", + .hash = "N-V-__8AAPoaLgBRjRikFTr6HpPPxdavmJAPy_SOYbgt3cIM", .lazy = true, }, .ordered_map = .{ - .url = "https://github.com/Tessil/ordered-map/archive/bd8d5ef4149cd40783a486011778a2e7eedde441.tar.gz", - .hash = "122079b9af72c89c53a2fae29968665d7c8c5c9c466764019b7bf81f605072bd087f", + .url = "git+https://github.com/Tessil/ordered-map?ref=v1.1.0#eba0b81b89c42232e8a937389be303a33f34a527", + .hash = "N-V-__8AACcGBQD8RCQaOW9wvl9QUSQ3BoWjFhFdZjAySrEw", .lazy = true, }, .fast_float = .{ - .url = "https://github.com/fastfloat/fast_float/archive/1fc3ac3932220b5effaca7203bb1bb771528d256.tar.gz", - .hash = "12201d7ec3e6bd8e0e90d5792a66fd4ccc670f337ee8818f8d830c1f4bd7e2fe2f3b", + .url = "git+https://github.com/fastfloat/fast_float?ref=v8.1.0#88b1e5321c6918cbe091afd76728296290668403", + .hash = "N-V-__8AABEwCAAXomDLtLslEEK5zzy4Yy0b2RC-WS-DgdnU", .lazy = true, }, }, .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", }, } diff --git a/examples/mandelbrot.nzsl b/examples/mandelbrot.nzsl index 7187cad..ea9c5c2 100644 --- a/examples/mandelbrot.nzsl +++ b/examples/mandelbrot.nzsl @@ -1,4 +1,4 @@ -[nzsl_version("1.0")] +[nzsl_version("1.1")] [desc("Mandelbrot shader from http://nuclear.mutantstargoat.com/articles/sdr_fract")] [feature(primitive_externals)] //< Required since SFML doesn't use UBO module; @@ -53,8 +53,8 @@ fn main(input: Input) -> Output else u = 0.0; - let out: Output; - out.color = palette.Sample(vec2[f32](u, 0.0)); + let output: Output; + output.color = palette.Sample(vec2[f32](u, 0.0)); - return out; + return output; } diff --git a/examples/mandelbrot.zig b/examples/mandelbrot.zig index dcbc1a4..635f76f 100644 --- a/examples/mandelbrot.zig +++ b/examples/mandelbrot.zig @@ -1,24 +1,22 @@ -const std= @import("std"); -const nzsl = @import("nzslzig"); +const std = @import("std"); +const nzsl = @import("nzigsl"); pub fn main() !void { - const mandelbrotModule = try nzsl.parseFromFile("examples/mandelbrot.nzsl"); - defer mandelbrotModule.release(); + const module = try nzsl.parser.parseFromFile("examples/mandelbrot.nzsl"); + defer module.deinit(); - const glslWriter = nzsl.GlslWriter.create(); - defer glslWriter.release(); + const params = try nzsl.BackendParameters.init(); + defer params.deinit(); + params.setDebugLevel(.full); - const state = nzsl.WriterStates.create(); - defer state.release(); + const writer = try nzsl.GlslWriter.init(); + defer writer.deinit(); - state.setDebugLevel(.full); + const writer_params = try nzsl.GlslWriter.Parameters.init(); + defer writer_params.deinit(); - const mappings = nzsl.GlslBindingMapping.create(); - defer mappings.release(); + const output = try writer.generate(module, params, writer_params); + defer output.deinit(); - const output = try glslWriter.generate(mandelbrotModule, mappings, state); - defer output.release(); - - std.log.debug("Generated code: \n{s}", .{ output.getCode() }); - -} \ No newline at end of file + std.log.debug("Generated code: \n{s}", .{output.getCode()}); +} diff --git a/src/BackendParameters.zig b/src/BackendParameters.zig new file mode 100644 index 0000000..40707ee --- /dev/null +++ b/src/BackendParameters.zig @@ -0,0 +1,81 @@ +const std = @import("std"); +const DebugLevel = @import("lib.zig").DebugLevel; +const OptionHash = @import("lib.zig").OptionHash; +const cnzsl = @cImport({ + @cInclude("CNZSL/CNZSL.h"); +}); + +const Self = @This(); + +instance: *cnzsl.nzslBackendParameters, + +pub fn init() !Self { + const cparameters = cnzsl.nzslBackendParametersCreate() orelse return error.NullPointer; + return .{ + .instance = cparameters, + }; +} + +pub fn deinit(self: Self) void { + cnzsl.nzslBackendParametersDestroy(self.instance); +} + +pub fn enableDeadCodeRemoval(self: Self, enable: bool) void { + cnzsl.nzslBackendParametersEnableDeadCodeRemoval(self.instance, enable); +} + +pub fn enableOptimization(self: Self, enable: bool) void { + cnzsl.nzslBackendParametersEnableOptimization(self.instance, enable); +} + +pub fn enableResolving(self: Self, enable: bool) void { + cnzsl.nzslBackendParametersEnableResolving(self.instance, enable); +} + +pub fn enableTargetRequired(self: Self, enable: bool) void { + cnzsl.nzslBackendParametersEnableTargetRequired(self.instance, enable); +} + +pub fn enableValidation(self: Self, enable: bool) void { + cnzsl.nzslBackendParametersEnableValidation(self.instance, enable); +} + +pub fn setDebugLevel(self: Self, debug_level: DebugLevel) void { + cnzsl.nzslBackendParametersSetDebugLevel(self.instance, @intFromEnum(debug_level)); +} + +//pub fn SetModuleResolver_Filesystem(self: Self, const nzslFilesystemModuleResolver* resolverPtr) void { +//} + +pub fn setOption(self: Self, hash: OptionHash, value: anytype) void { + const T = @TypeOf(value); + switch (@typeInfo(T)) { + .vector => |v| self.setOption(hash, @as([v.len]v.child, value)), + .float, .int, .comptime_float, .comptime_int, .bool => self.setOption(hash, [1]T{value}), + .array => |a| { + const sanitized_value, const sanitized_primitive_name = switch (@typeInfo(a.child)) { + .bool => blk: { + var new_array: [a.len]c_int = undefined; + for (value, 0..a.len) |v, i| { + new_array[i] = @intFromBool(v); + } + break :blk .{ new_array, "bool" }; + }, + .float => |f| if (f.bits != 32) @compileError("Unhandled float size (not 32 bits)") else .{ value, @typeName(a.child) }, + .int => |i| if (i.bits != 32) @compileError("Unhandled integer size (not 32 bits)") else .{ value, @typeName(a.child) }, + .comptime_float => .{ value, "f32" }, + .comptime_int => .{ value, "i32" }, + else => @compileError("Unhandled type"), + }; + + const type_name, const c_value = switch (a.len) { + 1 => .{ "" ++ sanitized_primitive_name, sanitized_value[0] }, + 2...4 => .{ "vec" ++ [_]u8{'0' + a.len} ++ sanitized_primitive_name, @as([*c]const a.child, @ptrCast(&sanitized_value)) }, + else => @compileError("Unhandled array or vector size"), + }; + + @call(.auto, @field(cnzsl, "nzslBackendParametersSetOption_" ++ type_name), .{ self.instance, hash, c_value }); + }, + else => @compileError("Unhandled type"), + } +} diff --git a/src/GlslWriter.zig b/src/GlslWriter.zig index 844d594..c530ee6 100644 --- a/src/GlslWriter.zig +++ b/src/GlslWriter.zig @@ -1,107 +1,104 @@ -const cnzsl = @import("nzsl-c.zig"); -const nzsl = @import("lib.zig"); const std = @import("std"); +const Module = @import("Module.zig"); +const BackendParameters = @import("BackendParameters.zig"); +const ShaderStageType = @import("lib.zig").ShaderStageType; +const cnzsl = @cImport({ + @cInclude("CNZSL/CNZSL.h"); +}); -pub const ShaderStageType = enum(cnzsl.nzslShaderStageType) { - compute = cnzsl.NZSL_STAGE_COMPUTE, - fragment = cnzsl.NZSL_STAGE_FRAGMENT, - vertex = cnzsl.NZSL_STAGE_VERTEX, -}; +const Self = @This(); -pub const GlslWriter = struct { - instance: *cnzsl.nzslGlslWriter, +instance: *cnzsl.nzslGlslWriter, - pub fn create() GlslWriter { - return .{.instance = cnzsl.nzslGlslWriterCreate() orelse unreachable}; +pub fn init() !Self { + const cwriter = cnzsl.nzslGlslWriterCreate() orelse return error.NullPointer; + return .{ + .instance = cwriter, + }; +} + +pub fn deinit(self: Self) void { + cnzsl.nzslGlslWriterDestroy(self.instance); +} + +pub fn generate(self: Self, module: Module, backend_parameters: BackendParameters, parameters: Parameters) !Output { + const output = cnzsl.nzslGlslWriterGenerate(self.instance, @ptrCast(module.instance), @ptrCast(backend_parameters.instance), @ptrCast(parameters.instance)) orelse return error.FailedToGenerateGlsl; + return .{ + .instance = output, + }; +} + +pub fn generateStage(self: Self, stage: ShaderStageType, module: Module, backend_parameters: BackendParameters, parameters: Parameters) !Output { + const output = cnzsl.nzslGlslWriterGenerateStage(self.instance, @intFromEnum(stage), @ptrCast(module.instance), @ptrCast(backend_parameters.instance), @ptrCast(parameters.instance)) orelse return error.FailedToGenerateGlsl; + return .{ + .instance = output, + }; +} + +pub fn getLastError(self: Self) ![]const u8 { + const err = cnzsl.nzslGlslWriterGetLastError(self.instance) orelse return error.NullPointer; + return std.mem.span(err); +} + +pub const Parameters = struct { + const InnerSelf = @This(); + + instance: *cnzsl.nzslGlslWriterParameters, + + pub fn init() !InnerSelf { + const cparameters = cnzsl.nzslGlslWriterParametersCreate() orelse return error.NullPointer; + return .{ + .instance = cparameters, + }; } - pub fn release(self: GlslWriter) void { - cnzsl.nzslGlslWriterDestroy(self.instance); + pub fn deinit(self: InnerSelf) void { + cnzsl.nzslGlslWriterParametersDestroy(self.instance); } - pub fn generate(self: GlslWriter, module: nzsl.Module, bindingMapping: GlslBindingMapping, states: nzsl.WriterStates) !GlslOutput { - var output: ?*cnzsl.nzslGlslOutput = null; - - output = cnzsl.nzslGlslWriterGenerate(self.instance, module.instance, bindingMapping.instance, states.instance); - - if(output == null) { - std.log.err("Failed to generate glsl output: {s}", .{ self.getLastError() }); - - return error.FailedToGenerateGlsl; - } - - return .{.instance = output orelse unreachable}; + pub fn setBindingMapping(self: InnerSelf, set_index: u32, binding_index: u32, gl_binding: u32) void { + cnzsl.nzslGlslWriterParametersSetBindingMapping(self.instance, set_index, binding_index, @intCast(gl_binding)); } - pub fn generateStage(self: GlslWriter, stage: ShaderStageType, module: nzsl.Module, bindingMapping: GlslBindingMapping, states: nzsl.WriterStates) !GlslOutput { - var output: ?*cnzsl.nzslGlslOutput = null; - - output = cnzsl.nzslGlslWriterGenerateStage(@intFromEnum(stage), self.instance, module.instance, bindingMapping.instance, states.instance); - - if(output == null) { - std.log.err("Failed to generate glsl output: {s}", .{ self.getLastError() }); - - return error.FailedToGenerateGlsl; - } - - return .{.instance = output orelse unreachable}; - } - - pub fn getLastError(self: GlslWriter) [*c]const u8 { - return cnzsl.nzslGlslWriterGetLastError(self.instance); + pub fn setPushConstantBinding(self: InnerSelf, gl_binding: u32) void { + cnzsl.nzslGlslWriterParametersSetPushConstantBinding(self.instance, @intCast(gl_binding)); } }; -pub const GlslBindingMapping = struct { - instance: *cnzsl.nzslGlslBindingMapping, +pub const Output = struct { + const InnerSelf = @This(); - pub fn create() GlslBindingMapping { - return .{.instance = cnzsl.nzslGlslBindingMappingCreate() orelse unreachable}; - } - - pub fn release(self: GlslBindingMapping) void { - cnzsl.nzslGlslBindingMappingDestroy(self.instance); - } - - pub fn setBinding(self: GlslBindingMapping, setIndex: u32, bindingIndex: u32, glBinding: c_uint) void { - cnzsl.nzslGlslBindingMappingSetBinding(self.instance, setIndex, bindingIndex, glBinding); - } - -}; - -pub const GlslOutput = struct { instance: *cnzsl.nzslGlslOutput, - pub fn release(self: GlslOutput) void { + pub fn deinit(self: InnerSelf) void { cnzsl.nzslGlslOutputDestroy(self.instance); } - pub fn getCode(self: GlslOutput) []const u8 { + pub fn getCode(self: InnerSelf) []const u8 { var size: usize = undefined; const code = cnzsl.nzslGlslOutputGetCode(self.instance, &size); - return code[0..size]; } - /// Return texture binding in output or -1 if binding doesn't exists - pub fn getExplicitTextureBinding(self: GlslOutput, bindingName: [*c]const u8) c_int { - return cnzsl.nzslGlslOutputGetExplicitTextureBinding(self.instance, bindingName); + pub fn getExplicitTextureBinding(self: InnerSelf, binding_name: [:0]const u8) i32 { + const res = cnzsl.nzslGlslOutputGetExplicitTextureBinding(self.instance, binding_name); + return if (res != -1) res else error.BindingNameNotFound; } - /// Return uniform binding in output or -1 if binding doesn't exists - pub fn getExplicitUniformBlockBinding(self: GlslOutput, bindingName: [*c]const u8) c_int { - return cnzsl.nzslGlslOutputGetExplicitUniformBlockBinding(self.instance, bindingName); + pub fn getExplicitUniformBlockBinding(self: InnerSelf, binding_name: [:0]const u8) i32 { + const res = cnzsl.nzslGlslOutputGetExplicitUniformBlockBinding(self.instance, binding_name); + return if (res != -1) res else error.BindingNameNotFound; } - pub fn getUsesDrawParameterBaseInstanceUniform(self: GlslOutput) c_int { + pub fn usesDrawParameterBaseInstanceUniform(self: InnerSelf) bool { return cnzsl.nzslGlslOutputGetUsesDrawParameterBaseInstanceUniform(self.instance); } - pub fn getUsesDrawParameterBaseVertexUniform(self: GlslOutput) c_int { + pub fn usesDrawParameterBaseVertexUniform(self: InnerSelf) bool { return cnzsl.nzslGlslOutputGetUsesDrawParameterBaseVertexUniform(self.instance); } - pub fn getUsesDrawParameterDrawIndexUniform(self: GlslOutput) c_int { + pub fn usesDrawParameterDrawIndexUniform(self: InnerSelf) bool { return cnzsl.nzslGlslOutputGetUsesDrawParameterDrawIndexUniform(self.instance); } -}; \ No newline at end of file +}; diff --git a/src/LangWriter.zig b/src/LangWriter.zig index edb9d20..56e7e87 100644 --- a/src/LangWriter.zig +++ b/src/LangWriter.zig @@ -1,49 +1,48 @@ -const cnzsl = @import("nzsl-c.zig"); -const nzsl = @import("lib.zig"); const std = @import("std"); +const Module = @import("Module.zig"); +const cnzsl = @cImport({ + @cInclude("CNZSL/CNZSL.h"); +}); -pub const LangWriter = struct { - instance: *cnzsl.nzslLangWriter, +const Self = @This(); - pub fn create() LangWriter { - return .{.instance = cnzsl.nzslLangWriterCreate() orelse unreachable}; - } +instance: *cnzsl.nzslLangWriter, - pub fn release(self: LangWriter) void { - cnzsl.nzslLangWriterDestroy(self.instance); - } +pub fn init() !Self { + const cwriter = cnzsl.nzslLangWriterCreate() orelse return error.NullPointer; + return .{ + .instance = cwriter, + }; +} - pub fn getLastError(self: LangWriter) [*c]const u8 { - return cnzsl.nzslLangWriterGetLastError(self.instance); - } +pub fn deinit(self: Self) void { + cnzsl.nzslLangWriterDestroy(self.instance); +} - pub fn generate(self: LangWriter, module: nzsl.Module, states: nzsl.WriterStates) LangOutput { - var output: ?*cnzsl.nzslLangOutput = null; +pub fn getLastError(self: Self) ![]const u8 { + const err = cnzsl.nzslLangWriterGetLastError(self.instance) orelse return error.NullPointer; + return std.mem.span(err); +} - output = cnzsl.nzslLangWriterGenerate(self.instance, module.instance, states.instance); +pub fn generate(self: Self, module: Module) !Output { + const output = cnzsl.nzslLangWriterGenerate(self.instance, @ptrCast(module.instance)) orelse return error.FailedToGenerateLang; + return .{ + .instance = output, + }; +} - if(output == null) { - std.log.err("Failed to generate lang output: {s}", .{ self.getLastError() }); +pub const Output = struct { + const InnerSelf = @This(); - return error.FailedToGenerateLang; - } - - return .{.instance = output orelse unreachable}; - } - -}; - -pub const LangOutput = struct { instance: *cnzsl.nzslLangOutput, - pub fn release(self: LangOutput) void { + pub fn deinit(self: InnerSelf) void { cnzsl.nzslLangOutputDestroy(self.instance); } - pub fn getCode(self: LangOutput) []const u8 { + pub fn getCode(self: InnerSelf) []const u8 { var size: usize = undefined; const code = cnzsl.nzslLangOutputGetCode(self.instance, &size); - return code[0..size]; } }; diff --git a/src/Module.zig b/src/Module.zig index fe15882..ffe9a0b 100644 --- a/src/Module.zig +++ b/src/Module.zig @@ -1,17 +1,24 @@ -const cnzsl = @import("nzsl-c.zig"); +const std = @import("std"); +const cnzsl = @cImport({ + @cInclude("CNZSL/CNZSL.h"); +}); -pub const Module = struct { - instance: *cnzsl.nzslModule, +const Self = @This(); - pub fn create() Module { - return .{.instance = cnzsl.nzslModuleCreate() orelse unreachable}; - } +instance: *cnzsl.nzslModule, - pub fn release(self: Module) void { - cnzsl.nzslModuleDestroy(self.instance); - } +pub fn init() !Self { + const cmodule = cnzsl.nzslModuleCreate() orelse return error.NullPointer; + return .{ + .instance = cmodule, + }; +} - pub fn getLastError(self: Module) [*c]const u8 { - return cnzsl.nzslModuleGetLastError(self.instance); - } -}; \ No newline at end of file +pub fn deinit(self: Self) void { + cnzsl.nzslModuleDestroy(@ptrCast(self.instance)); +} + +pub fn getLastError(self: Self) ![]const u8 { + const err = cnzsl.nzslModuleGetLastError(@ptrCast(self.instance)) orelse return error.NullPointer; + return std.mem.span(err); +} diff --git a/src/Parser.zig b/src/Parser.zig deleted file mode 100644 index d8c8c7a..0000000 --- a/src/Parser.zig +++ /dev/null @@ -1,44 +0,0 @@ -const cnzsl = @import("nzsl-c.zig"); -const nzsl = @import("lib.zig"); -const std = @import("std"); - -pub fn parseSource(source: []const u8) !nzsl.Module { - return parseSourceWithFilePath(source, ""); -} - -/// Parse a NZSL source code and stores it inside a nzslModule -/// In case of failure, a negative value is returned and an error code is set -/// -/// @param module pointer to a -/// @param source pointer to NZSL source -/// @param sourceLen length of source in characters -/// @param filePath used when reporting errors -/// @param filePathLen length of filePath in characters -/// @return 0 if parsing succeeded and a negative value in case of failure -/// -/// @see nzslModuleGetLastError -pub fn parseSourceWithFilePath(source: []const u8, filePath: []const u8) !nzsl.Module { - const module = nzsl.Module.create(); - - if(cnzsl.nzslParserParseSourceWithFilePath(module.instance, source.ptr, source.len, filePath.ptr, filePath.len) != 0) { - defer module.release(); - std.log.err("Error while parsing source({s}): {s}", .{ filePath, module.getLastError() }); - - return error.FailedToParse; - } - - return module; -} - -pub fn parseFromFile(filePath: []const u8) !nzsl.Module { - const module = nzsl.Module.create(); - - if(cnzsl.nzslParserParseFromFile(module.instance, filePath.ptr, filePath.len) != 0) { - defer module.release(); - std.log.err("Error while parsing source: {s}", .{ module.getLastError() }); - - return error.FailedToParse; - } - - return module; -} \ No newline at end of file diff --git a/src/SpirvWriter.zig b/src/SpirvWriter.zig index 9f35783..d23a035 100644 --- a/src/SpirvWriter.zig +++ b/src/SpirvWriter.zig @@ -1,55 +1,65 @@ -const cnzsl = @import("nzsl-c.zig"); -const nzsl = @import("lib.zig"); const std = @import("std"); +const Module = @import("Module.zig"); +const BackendParameters = @import("BackendParameters.zig"); +const cnzsl = @cImport({ + @cInclude("CNZSL/CNZSL.h"); +}); -pub const SpirvWriterEnvironment = cnzsl.nzslSpirvWriterEnvironment; +const Self = @This(); -pub const SpirvWriter = struct { - instance: *cnzsl.nzslSpirvWriter, +instance: *cnzsl.nzslSpirvWriter, - pub fn create() SpirvWriter { - return .{.instance = cnzsl.nzslSpirvWriterCreate() orelse unreachable}; - } +pub fn init() !Self { + const cwriter = cnzsl.nzslSpirvWriterCreate() orelse return error.NullPointer; + return .{ + .instance = cwriter, + }; +} - pub fn release(self: SpirvWriter) void { - cnzsl.nzslSpirvWriterDestroy(self.instance); - } +pub fn deinit(self: Self) void { + cnzsl.nzslSpirvWriterDestroy(self.instance); +} - pub fn getLastError(self: SpirvWriter) [*c]const u8 { - return cnzsl.nzslSpirvWriterGetLastError(self.instance); - } +pub fn getLastError(self: Self) ![]const u8 { + const err = cnzsl.nzslSpirvWriterGetLastError(self.instance) orelse return error.NullPointer; + return std.mem.span(err); +} - pub fn setEnv(self: SpirvWriter, env: SpirvWriterEnvironment) void { - return cnzsl.nzslSpirvWriterSetEnv(self.instance, env); - } +pub fn setEnv(self: Self, env: Environment) void { + const SpirvEnv = extern struct { + spv_major_version: u32, + spv_minor_version: u32, + }; + const cenv: SpirvEnv = .{ + .spv_major_version = @intCast(env.spv_version.major), + .spv_minor_version = @intCast(env.spv_version.minor), + }; + return cnzsl.nzslSpirvWriterSetEnv(self.instance, @ptrCast(&cenv)); +} - pub fn generate(self: SpirvWriter, module: nzsl.Module, states: nzsl.WriterStates) SpirvOutput { - var output: ?*cnzsl.nzslSpirvOutput = null; - - output = cnzsl.nzslSpirvWriterGenerate(self.instance, module.instance, states.instance); - - if(output == null) { - std.log.err("Failed to generate spirv output: {s}", .{ self.getLastError() }); - - return error.FailedToGenerateSpirv; - } - - return .{.instance = output orelse unreachable}; - } +pub fn generate(self: Self, module: Module, backend_parameters: BackendParameters) !Output { + const output = cnzsl.nzslSpirvWriterGenerate(self.instance, @ptrCast(module.instance), @ptrCast(backend_parameters.instance)) orelse return error.FailedToGenerateSpirv; + return .{ + .instance = output, + }; +} +pub const Environment = struct { + spv_version: std.SemanticVersion, }; -pub const SpirvOutput = struct { +pub const Output = struct { + const InnerSelf = @This(); + instance: *cnzsl.nzslSpirvOutput, - pub fn release(self: SpirvOutput) void { + pub fn deinit(self: InnerSelf) void { cnzsl.nzslSpirvOutputDestroy(self.instance); } - pub fn getCode(self: SpirvOutput) []const u32 { + pub fn getCode(self: InnerSelf) []const u32 { var size: usize = undefined; const code = cnzsl.nzslSpirvOutputGetSpirv(self.instance, &size); - return code[0..size]; } }; diff --git a/src/WriterStates.zig b/src/WriterStates.zig deleted file mode 100644 index 79c2468..0000000 --- a/src/WriterStates.zig +++ /dev/null @@ -1,93 +0,0 @@ -const cnzsl = @import("nzsl-c.zig"); -const nzsl = @import("lib.zig"); -const std = @import("std"); - -pub fn vec(comptime T: type, comptime dim: usize) type { - return [dim]T; -} - -pub const vec2bool = vec(bool, 2); -pub const vec2nzslBool = vec(cnzsl.nzslBool, 2); -pub const vec3bool = vec(bool, 3); -pub const vec3nzslBool = vec(cnzsl.nzslBool, 3); -pub const vec4bool = vec(bool, 4); -pub const vec4nzslBool = vec(cnzsl.nzslBool, 4); -pub const vec2f32 = vec(f32, 2); -pub const vec3f32 = vec(f32, 3); -pub const vec4f32 = vec(f32, 4); -pub const vec2u32 = vec(u32, 2); -pub const vec3u32 = vec(u32, 3); -pub const vec4u32 = vec(u32, 4); -pub const vec2i32 = vec(i32, 2); -pub const vec3i32 = vec(i32, 3); -pub const vec4i32 = vec(i32, 4); - -pub const DebugLevel = enum(cnzsl.nzslDebugLevel) { - none = cnzsl.NZSL_DEBUG_NONE, - full = cnzsl.NZSL_DEBUG_FULL, - minimal = cnzsl.NZSL_DEBUG_MINIMAL, - regular = cnzsl.NZSL_DEBUG_REGULAR, -}; - -pub const OptionHash = cnzsl.nzslOptionHash; - -pub fn hashOption(str: [*c]const u8) OptionHash { - return cnzsl.nzslHashOption(str); -} - -pub const WriterStates = struct { - instance: *cnzsl.nzslWriterStates, - - pub fn create() WriterStates { - return .{.instance = cnzsl.nzslWriterStatesCreate() orelse unreachable}; - } - - pub fn enableOptimization(self: WriterStates, enable: bool) void { - cnzsl.nzslWriterStatesEnableOptimization(self.instance, enable); - } - pub fn enableSanitization(self: WriterStates, enable: bool) void { - cnzsl.nzslWriterStatesEnableSanitization(self.instance, enable); - } - pub fn setDebugLevel(self: WriterStates, debugLevel: DebugLevel) void { - cnzsl.nzslWriterStatesSetDebugLevel(self.instance, @intFromEnum(debugLevel)); - } - pub fn setOption(self: WriterStates, optionHash: OptionHash, value: anytype) void { - switch (@TypeOf(value)) { - inline bool => cnzsl.nzslWriterStatesSetOption_bool(self.instance, optionHash, @intFromBool(value)), - inline cnzsl.nzslBool => cnzsl.nzslWriterStatesSetOption_bool(self.instance, optionHash, value), - inline vec2bool => { - self.setOption(optionHash, vec2nzslBool{@intFromBool(value[0]), @intFromBool(value[1])}); - }, - inline vec2nzslBool => cnzsl.nzslWriterStatesSetOption_vec2bool(self.instance, optionHash, &value), - inline vec3bool => { - self.setOption(optionHash, vec3nzslBool{@intFromBool(value[0]), @intFromBool(value[1]), @intFromBool(value[2])}); - }, - inline vec3nzslBool => cnzsl.nzslWriterStatesSetOption_vec3bool(self.instance, optionHash, &value), - inline vec4bool => { - self.setOption(optionHash, vec4nzslBool{@intFromBool(value[0]), @intFromBool(value[1]), @intFromBool(value[2]), @intFromBool(value[3])}); - }, - inline vec4nzslBool => cnzsl.nzslWriterStatesSetOption_vec4bool(self.instance, optionHash, &value), - inline comptime_float, f32 => cnzsl.nzslWriterStatesSetOption_f32(self.instance, optionHash, value), - inline vec2f32 => cnzsl.nzslWriterStatesSetOption_vec2f32(self.instance, optionHash, &value), - inline vec3f32 => cnzsl.nzslWriterStatesSetOption_vec3f32(self.instance, optionHash, &value), - inline vec4f32 => cnzsl.nzslWriterStatesSetOption_vec4f32(self.instance, optionHash, &value), - inline i32 => cnzsl.nzslWriterStatesSetOption_i32(self.instance, optionHash, value), - inline comptime_int => { - std.log.debug("/!\\ setOption with comptime_int defaults to i32 with value {} ", .{ value }); - cnzsl.nzslWriterStatesSetOption_i32(self.instance, optionHash, value); - }, - inline vec2i32 => cnzsl.nzslWriterStatesSetOption_vec2i32(self.instance, optionHash, &value), - inline vec3i32 => cnzsl.nzslWriterStatesSetOption_vec3i32(self.instance, optionHash, &value), - inline vec4i32 => cnzsl.nzslWriterStatesSetOption_vec4i32(self.instance, optionHash, &value), - inline u32 => cnzsl.nzslWriterStatesSetOption_u32(self.instance, optionHash, value), - inline vec2u32 => cnzsl.nzslWriterStatesSetOption_vec2u32(self.instance, optionHash, &value), - inline vec3u32 => cnzsl.nzslWriterStatesSetOption_vec3u32(self.instance, optionHash, &value), - inline vec4u32 => cnzsl.nzslWriterStatesSetOption_vec4u32(self.instance, optionHash, &value), - else => std.debug.panic("Unsupported type {}", .{@TypeOf(value)}) - } - } - - pub fn release(self: WriterStates) void { - cnzsl.nzslWriterStatesDestroy(self.instance); - } -}; \ No newline at end of file diff --git a/src/lib.zig b/src/lib.zig index 8a135c4..662640a 100644 --- a/src/lib.zig +++ b/src/lib.zig @@ -1,11 +1,30 @@ -// const cnzsl = @cImport({ -// @cInclude("CNZSL/CNZSL.h"); -// }); const std = @import("std"); -const cnzsl = @import("nzsl-c.zig"); +const cnzsl = @cImport({ + @cInclude("CNZSL/CNZSL.h"); +}); -pub usingnamespace @import("WriterStates.zig"); -pub usingnamespace @import("GlslWriter.zig"); -pub usingnamespace @import("SpirvWriter.zig"); -pub usingnamespace @import("Module.zig"); -pub usingnamespace @import("Parser.zig"); +pub const ShaderStageType = enum(cnzsl.nzslShaderStageType) { + compute = cnzsl.NZSL_STAGE_COMPUTE, + fragment = cnzsl.NZSL_STAGE_FRAGMENT, + vertex = cnzsl.NZSL_STAGE_VERTEX, +}; + +pub const DebugLevel = enum(cnzsl.nzslDebugLevel) { + none = cnzsl.NZSL_DEBUG_NONE, + full = cnzsl.NZSL_DEBUG_FULL, + minimal = cnzsl.NZSL_DEBUG_MINIMAL, + regular = cnzsl.NZSL_DEBUG_REGULAR, +}; + +pub const OptionHash = u32; + +pub fn hashOption(str: [:0]const u8) !OptionHash { + return cnzsl.nzslHashOption(str); +} + +pub const BackendParameters = @import("BackendParameters.zig"); +pub const GlslWriter = @import("GlslWriter.zig"); +pub const LangWriter = @import("LangWriter.zig"); +pub const Module = @import("Module.zig"); +pub const parser = @import("parser.zig"); +pub const SpirvWriter = @import("SpirvWriter.zig"); diff --git a/src/nzsl-c.zig b/src/nzsl-c.zig deleted file mode 100644 index f53d3f9..0000000 --- a/src/nzsl-c.zig +++ /dev/null @@ -1,3 +0,0 @@ -pub usingnamespace @cImport({ - @cInclude("CNZSL/CNZSL.h"); -}); diff --git a/src/parser.zig b/src/parser.zig new file mode 100644 index 0000000..423ac0e --- /dev/null +++ b/src/parser.zig @@ -0,0 +1,27 @@ +const std = @import("std"); +const cnzsl = @cImport({ + @cInclude("CNZSL/CNZSL.h"); +}); +const Module = @import("Module.zig"); + +pub fn parseSource(source: []const u8) !Module { + return parseSourceWithFilePath(source, ""); +} + +pub fn parseSourceWithFilePath(source: []const u8, filePath: []const u8) !Module { + const module = try Module.init(); + errdefer module.deinit(); + if (cnzsl.nzslParserParseSourceWithFilePath(@ptrCast(module.instance), source.ptr, source.len, filePath.ptr, filePath.len) != 0) { + return error.FailedToParse; + } + return module; +} + +pub fn parseFromFile(filePath: []const u8) !Module { + const module = try Module.init(); + errdefer module.deinit(); + if (cnzsl.nzslParserParseFromFile(@ptrCast(module.instance), filePath.ptr, filePath.len) != 0) { + return error.FailedToParse; + } + return module; +}