code
stringlengths 38
801k
| repo_path
stringlengths 6
263
|
|---|---|
const std = @import("std");
const stdx = @import("stdx");
const build_options = @import("build_options");
const Backend = build_options.GraphicsBackend;
const window_sdl = @import("window_sdl.zig");
const WindowSdl = window_sdl.Window;
const canvas = @import("window_canvas.zig");
const log = stdx.log.scoped(.window);
const platform = @import("platform.zig");
const WindowResizeEvent = platform.WindowResizeEvent;
const EventDispatcher = platform.EventDispatcher;
pub const Window = struct {
impl: switch (Backend) {
.OpenGL => WindowSdl,
.Vulkan => WindowSdl,
.WasmCanvas => canvas.Window,
.Test => TestWindow,
else => @compileError("unsupported"),
},
/// A hook for window resizes.
on_resize: ?fn (ctx: ?*anyopaque, width: u32, height: u32) void,
on_resize_ctx: ?*anyopaque,
const Self = @This();
pub fn init(alloc: std.mem.Allocator, config: Config) !Self {
const impl = switch (Backend) {
.OpenGL => try WindowSdl.init(alloc, config),
.Vulkan => try WindowSdl.init(alloc, config),
.WasmCanvas => try canvas.Window.init(alloc, config),
.Test => TestWindow{ .width = config.width, .height = config.height },
else => stdx.unsupported(),
};
return Self{
.impl = impl,
.on_resize = null,
.on_resize_ctx = null,
};
}
pub fn initWithSharedContext(alloc: std.mem.Allocator, config: Config, win: Window) !Self {
const impl = switch (Backend) {
.OpenGL => try WindowSdl.initWithSharedContext(alloc, config, win.impl),
else => @panic("unsupported"),
};
return Self{
.impl = impl,
.on_resize = null,
.on_resize_ctx = null,
};
}
pub fn deinit(self: Self) void {
switch (Backend) {
.OpenGL, .Vulkan => WindowSdl.deinit(self.impl),
.WasmCanvas => canvas.Window.deinit(&self.impl),
else => stdx.unsupported(),
}
}
pub fn addDefaultHandlers(self: *Self, dispatcher: *EventDispatcher) void {
const S = struct {
fn onWindowResize(ctx: ?*anyopaque, e: WindowResizeEvent) void {
const self_ = stdx.mem.ptrCastAlign(*Self, ctx);
self_.handleResize(e.width, e.height);
}
};
dispatcher.addOnWindowResize(self, S.onWindowResize);
}
/// Should be called before beginFrame if multiple windows are being rendered together.
/// If there is only one window, it only needs to be called once.
pub fn makeCurrent(self: Self) void {
switch (Backend) {
.OpenGL => WindowSdl.makeCurrent(self.impl),
else => stdx.unsupported(),
}
}
pub fn resize(self: *Self, width: u32, height: u32) void {
switch (Backend) {
.OpenGL => WindowSdl.resize(&self.impl, width, height),
else => stdx.unsupported(),
}
}
pub fn setUserResizeHook(self: *Self, ctx: ?*anyopaque, cb: fn (?*anyopaque, u32, u32) void) void {
self.on_resize = cb;
self.on_resize_ctx = ctx;
}
/// Internal function to update the buffer on a user resize or window manager resize.
/// An explicit call to resize() should not need to call this.
pub fn handleResize(self: *Self, width: u32, height: u32) void {
switch (Backend) {
.OpenGL => return WindowSdl.handleResize(&self.impl, width, height),
else => stdx.unsupported(),
}
if (self.on_resize) |cb| {
cb(self.on_resize_ctx, width, height);
}
}
pub fn getWidth(self: Self) u32 {
return self.impl.width;
}
pub fn getHeight(self: Self) u32 {
return self.impl.height;
}
pub fn getAspectRatio(self: Self) f32 {
return @intToFloat(f32, self.impl.width) / @intToFloat(f32, self.impl.height);
}
pub fn minimize(self: Self) void {
switch (Backend) {
.OpenGL => WindowSdl.minimize(self.impl),
else => stdx.unsupported(),
}
}
pub fn maximize(self: Self) void {
switch (Backend) {
.OpenGL => WindowSdl.maximize(self.impl),
else => stdx.unsupported(),
}
}
pub fn restore(self: Self) void {
switch (Backend) {
.OpenGL => WindowSdl.restore(self.impl),
else => stdx.unsupported(),
}
}
pub fn setMode(self: Self, mode: Mode) void {
switch (Backend) {
.OpenGL => WindowSdl.setMode(self.impl, mode),
else => stdx.unsupported(),
}
}
pub fn setPosition(self: Self, x: i32, y: i32) void {
switch (Backend) {
.OpenGL => WindowSdl.setPosition(self.impl, x, y),
else => stdx.unsupported(),
}
}
pub fn center(self: Self) void {
switch (Backend) {
.OpenGL => WindowSdl.center(self.impl),
else => stdx.unsupported(),
}
}
pub fn focus(self: Self) void {
switch (Backend) {
.OpenGL => WindowSdl.focus(self.impl),
else => stdx.unsupported(),
}
}
/// In the OpenGL SDL backend, swapBuffers will also block the thread to achieve the target refresh rate if vsync is on.
pub fn swapBuffers(self: Self) void {
switch (Backend) {
.OpenGL => WindowSdl.swapBuffers(self.impl),
.WasmCanvas => {},
.Test => {},
else => stdx.unsupported(),
}
}
pub fn setTitle(self: Self, title: []const u8) void {
switch (Backend) {
.OpenGL => WindowSdl.setTitle(self.impl, title),
else => stdx.unsupported(),
}
}
pub fn getTitle(self: Self, alloc: std.mem.Allocator) []const u8 {
switch (Backend) {
.OpenGL => return WindowSdl.getTitle(self.impl, alloc),
else => stdx.unsupported(),
}
}
};
pub const Mode = enum {
Windowed,
PseudoFullscreen,
Fullscreen,
};
pub fn quit() void {
switch (Backend) {
.OpenGL => window_sdl.quit(),
.WasmCanvas => {},
else => stdx.unsupported(),
}
}
pub const Config = struct {
title: []const u8 = "My Window",
width: u32 = 1024,
height: u32 = 768,
resizable: bool = false,
high_dpi: bool = false,
mode: Mode = .Windowed,
anti_alias: bool = false,
};
const TestWindow = struct {
width: u32,
height: u32,
}; | platform/window.zig |
usingnamespace @import("../engine/engine.zig");
const Literal = @import("../parser/literal.zig").Literal;
const LiteralValue = @import("../parser/literal.zig").LiteralValue;
const std = @import("std");
const testing = std.testing;
const mem = std.mem;
pub fn MapToContext(comptime Payload: type, comptime Value: type, comptime Target: type) type {
return struct {
parser: *Parser(Payload, Value),
mapTo: fn (in: Result(Value), payload: Payload, allocator: *mem.Allocator, key: ParserPosKey, path: ParserPath) callconv(.Async) Error!?Result(Target),
};
}
/// Wraps the `input.parser`, mapping its value to the `dst` type.
///
/// The `input.parser` must remain alive for as long as the `MapTo` parser will be used.
pub fn MapTo(comptime Payload: type, comptime Value: type, comptime Target: type) type {
return struct {
parser: Parser(Payload, Target) = Parser(Payload, Target).init(parse, nodeName, deinit),
input: MapToContext(Payload, Value, Target),
const Self = @This();
pub fn init(input: MapToContext(Payload, Value, Target)) Self {
return Self{ .input = input };
}
pub fn deinit(parser: *Parser(Payload, Target), allocator: *mem.Allocator) void {
const self = @fieldParentPtr(Self, "parser", parser);
self.input.parser.deinit(allocator);
}
pub fn nodeName(parser: *const Parser(Payload, Target), node_name_cache: *std.AutoHashMap(usize, ParserNodeName)) Error!u64 {
const self = @fieldParentPtr(Self, "parser", parser);
var v = std.hash_map.hashString("MapTo");
v +%= try self.input.parser.nodeName(node_name_cache);
v +%= @ptrToInt(self.input.mapTo);
return v;
}
pub fn parse(parser: *const Parser(Payload, Target), in_ctx: *const Context(Payload, Target)) callconv(.Async) !void {
const self = @fieldParentPtr(Self, "parser", parser);
var ctx = in_ctx.with(self.input);
defer ctx.results.close();
const child_node_name = try ctx.input.parser.nodeName(&in_ctx.memoizer.node_name_cache);
const child_ctx = try in_ctx.initChild(Value, child_node_name, ctx.offset);
defer child_ctx.deinitChild();
if (!child_ctx.existing_results) try ctx.input.parser.parse(&child_ctx);
var sub = child_ctx.subscribe();
var closed = false;
while (sub.next()) |next| {
if (closed) {
continue;
}
var frame = try std.heap.page_allocator.allocAdvanced(u8, 16, @frameSize(self.input.mapTo), std.mem.Allocator.Exact.at_least);
defer std.heap.page_allocator.free(frame);
const mapped = try await @asyncCall(frame, {}, self.input.mapTo, .{ next, in_ctx.input, ctx.allocator, ctx.key, ctx.path });
if (mapped == null) {
closed = true;
continue;
}
try ctx.results.add(mapped.?);
}
}
};
}
test "mapto" {
nosuspend {
const allocator = testing.allocator;
const String = struct {
value: []const u8,
pub fn init(value: []const u8) @This() {
return .{ .value = value };
}
pub fn deinit(self: *const @This(), _allocator: *mem.Allocator) void {}
};
const Payload = void;
const ctx = try Context(Payload, String).init(allocator, "hello world", {});
defer ctx.deinit();
const mapTo = MapTo(Payload, LiteralValue, String).init(.{
.parser = (&Literal(Payload).init("hello").parser).ref(),
.mapTo = struct {
fn mapTo(in: Result(LiteralValue), payload: Payload, _allocator: *mem.Allocator, key: ParserPosKey, path: ParserPath) callconv(.Async) Error!?Result(String) {
switch (in.result) {
.err => return Result(String).initError(in.offset, in.result.err),
else => return Result(String).init(in.offset, String.init("hello")),
}
}
}.mapTo,
});
try mapTo.parser.parse(&ctx);
var sub = ctx.subscribe();
var first = sub.next().?;
try testing.expectEqual(Result(String).init(5, String.init("hello")), first);
try testing.expect(sub.next() == null);
}
} | src/combn/combinator/mapto.zig |
const std = @import("std");
const fs = std.fs;
const Allocator = std.mem.Allocator;
const Builder = std.build.Builder;
var root: []const u8 = undefined;
var allocator: *Allocator = undefined;
// set to true if we want tracy to record frame/function times, false if we just want stubbed
var enable_tracy = true;
pub fn build(b: *Builder) void {
const target = b.standardTargetOptions(.{});
const mode = b.standardReleaseOptions();
root = b.build_root;
allocator = b.allocator;
{
const debugPlayer = b.addExecutable("sdl-debug-player", "src/sdl-app.zig");
debugPlayer.setTarget(target);
debugPlayer.setBuildMode(mode);
debugPlayer.linkLibC();
debugPlayer.want_lto = false;
debugPlayer.addPackagePath("threadpool", "zig-threadpool/src/lib.zig");
buildWithSDL2(debugPlayer);
buildWithFFmpeg(debugPlayer);
buildWithTracy(debugPlayer);
debugPlayer.install();
const runDebugPlayer = debugPlayer.run();
runDebugPlayer.cwd = b.exe_dir;
const runDebugStep = b.step("debug", "Run the debug player");
runDebugStep.dependOn(&runDebugPlayer.step);
}
// {
// const lutGen = b.addExecutable("lut-gen", "src/lut-main.zig");
// lutGen.setTarget(target);
// lutGen.setBuildMode(mode);
// lutGen.install();
// }
{
const jniLib = b.addSharedLibrary("nativemap", "src/jni-lib.zig", b.version(0, 0, 1));
jniLib.setTarget(target);
jniLib.setBuildMode(mode);
jniLib.linkLibC();
jniLib.addPackagePath("threadpool", "zig-threadpool/src/lib.zig");
buildWithJNI(jniLib);
buildWithFFmpeg(jniLib);
buildWithTracy(jniLib);
jniLib.install();
}
}
fn buildWithSDL2(target: *std.build.LibExeObjStep) void {
target.addIncludeDir(joinWithRoot("\\sdl2\\include"));
target.addLibPath(joinWithRoot("\\sdl2\\lib\\x64"));
target.linkSystemLibrary("sdl2");
}
fn buildWithFFmpeg(target: *std.build.LibExeObjStep) void {
target.addIncludeDir(joinWithRoot("\\ffmpeg\\include"));
target.addLibPath(joinWithRoot("\\ffmpeg\\lib"));
target.linkSystemLibrary("avcodec");
target.linkSystemLibrary("swresample");
target.linkSystemLibrary("avutil");
target.linkSystemLibrary("avformat");
target.linkSystemLibrary("swscale");
}
fn buildWithJNI(target: *std.build.LibExeObjStep) void {
target.addIncludeDir(joinWithRoot("\\jni\\include"));
target.addIncludeDir(joinWithRoot("\\jni\\include\\win32"));
}
fn buildWithTracy(target: *std.build.LibExeObjStep) void {
const tracyPath = joinWithRoot("\\tracy-0.7.8");
target.addBuildOption(bool, "tracy_enabled", enable_tracy);
target.addIncludeDir(tracyPath);
const tracyClient = std.fs.path.join(allocator, &.{ tracyPath, "TracyClient.cpp" }) catch unreachable;
target.addCSourceFile(tracyClient, &.{
"-fno-sanitize=undefined",
"-DTRACY_ENABLE",
"-D_WIN32_WINNT=0x601",
});
// if building from source, make sure you change this to match your specific windows SDK install
target.addLibPath("C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Community\\VC\\Tools\\MSVC\\14.29.30037\\lib\\x64");
target.linkSystemLibrary("DbgHelp");
target.linkSystemLibrary("Advapi32");
target.linkSystemLibrary("User32");
target.linkSystemLibrary("Ws2_32");
target.linkLibC();
target.linkSystemLibrary("c++");
}
fn joinWithRoot(path: []const u8) []const u8 {
return fs.path.join(allocator, &.{ root, path }) catch unreachable;
} | nativemap/build.zig |
const builtin = @import("builtin");
const clap = @import("clap");
const std = @import("std");
const util = @import("util");
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const mem = std.mem;
const process = std.process;
const Executables = @This();
arena: heap.ArenaAllocator,
load: util.Path = util.Path{ .buffer = undefined },
apply: util.Path = util.Path{ .buffer = undefined },
identify: util.Path = util.Path{ .buffer = undefined },
commands: []const Command = &[_]Command{},
pub const Command = struct {
path: []const u8,
help: []const u8,
flags: []const Flag,
ints: []const Int,
floats: []const Float,
enums: []const Enum,
strings: []const String,
files: []const File,
multi_strings: []const MultiString,
params: []const clap.Param(clap.Help),
const Flag = struct {
i: usize,
};
const Int = struct {
i: usize,
default: usize,
};
const Float = struct {
i: usize,
default: f64,
};
const Enum = struct {
i: usize,
options: []const []const u8,
default: usize,
};
const String = struct {
i: usize,
default: []const u8,
};
const File = struct {
i: usize,
default: []const u8,
};
const MultiString = struct {
i: usize,
};
pub fn name(command: Command) []const u8 {
return util.path.basenameNoExt(command.path);
}
};
pub const program_name = "tm35-randomizer";
const extension = switch (builtin.target.os.tag) {
.linux => "",
.windows => ".exe",
else => @compileError("Unsupported os"),
};
const command_file_name = "commands";
const default_commands =
"tm35-rand-machines" ++ extension ++ "\n" ++
"tm35-rand-pokemons" ++ extension ++ "\n" ++
"tm35-rand-pokeball-items" ++ extension ++ "\n" ++
"tm35-rand-trainers" ++ extension ++ "\n" ++
"tm35-rand-starters" ++ extension ++ "\n" ++
"tm35-rand-static" ++ extension ++ "\n" ++
"tm35-rand-wild" ++ extension ++ "\n" ++
"tm35-random-stones" ++ extension ++ "\n" ++
"tm35-rand-names" ++ extension ++ "\n" ++
"tm35-no-trade-evolutions" ++ extension ++ "\n" ++
"tm35-misc" ++ extension ++ "\n" ++
"tm35-generate-site" ++ extension ++ "\n";
pub fn deinit(exes: Executables) void {
exes.arena.deinit();
}
pub fn find(allocator: mem.Allocator) !Executables {
var arena = heap.ArenaAllocator.init(allocator);
errdefer arena.deinit();
var res = Executables{
.arena = undefined,
.load = findCore("tm35-load" ++ extension) catch
return error.LoadToolNotFound,
.apply = findCore("tm35-apply" ++ extension) catch
return error.ApplyToolNotFound,
.identify = findCore("tm35-identify" ++ extension) catch
return error.IdentifyToolNotFound,
.commands = try findCommands(&arena),
};
res.arena = arena;
return res;
}
fn findCore(tool: []const u8) !util.Path {
const self_exe_dir = (try util.dir.selfExeDir()).slice();
return joinAccess(&[_][]const u8{ self_exe_dir, "core", tool }) catch
joinAccess(&[_][]const u8{ self_exe_dir, tool }) catch
try findInPath(tool);
}
const path_env_seperator = switch (builtin.target.os.tag) {
.linux => ":",
.windows => ";",
else => @compileError("Unsupported os"),
};
const path_env_name = switch (builtin.target.os.tag) {
.linux => "PATH",
.windows => "Path",
else => @compileError("Unsupported os"),
};
fn findInPath(name: []const u8) !util.Path {
var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
var fba = heap.FixedBufferAllocator.init(&buf);
const path_env = try process.getEnvVarOwned(fba.allocator(), path_env_name);
var iter = mem.tokenize(u8, path_env, path_env_seperator);
while (iter.next()) |dir|
return joinAccess(&[_][]const u8{ dir, name }) catch continue;
return error.NotInPath;
}
fn joinAccess(paths: []const []const u8) !util.Path {
const res = util.path.join(paths);
try fs.cwd().access(res.constSlice(), .{});
return res;
}
fn findCommands(arena: *heap.ArenaAllocator) ![]Command {
const command_file = try openCommandFile();
defer command_file.close();
var res = std.ArrayList(Command).init(arena.allocator());
var fifo = util.io.Fifo(.{ .Static = mem.page_size }).init();
while (try util.io.readLine(command_file.reader(), &fifo)) |line| {
if (fs.path.isAbsolute(line)) {
const command = pathToCommand(arena, line) catch continue;
try res.append(command);
} else {
const command_path = findCommand(line) catch continue;
const command = pathToCommand(arena, command_path.constSlice()) catch continue;
try res.append(command);
}
}
return res.toOwnedSlice();
}
const Allocators = struct {
temp: mem.Allocator,
res: mem.Allocator,
};
fn findCommand(name: []const u8) !util.Path {
const self_exe_dir = (try util.dir.selfExeDir()).slice();
const config_dir = (try util.dir.folder(.local_configuration)).slice();
const cwd = (try util.dir.cwd()).slice();
return joinAccess(&[_][]const u8{ cwd, name }) catch
joinAccess(&[_][]const u8{ config_dir, program_name, name }) catch
joinAccess(&[_][]const u8{ self_exe_dir, "randomizers", name }) catch
joinAccess(&[_][]const u8{ self_exe_dir, name }) catch
try findInPath(name);
}
fn openCommandFile() !fs.File {
const cwd = fs.cwd();
const config_dir = (try util.dir.folder(.local_configuration)).slice();
const command_path = util.path.join(&[_][]const u8{
config_dir,
program_name,
command_file_name,
}).slice();
// TODO: When we want to enable plugin support, readd this
//if (cwd.openFile(command_path, .{})) |file| {
// return file;
//} else |_|
{
const dirname = fs.path.dirname(command_path) orelse ".";
try cwd.makePath(dirname);
try cwd.writeFile(command_path, default_commands);
return cwd.openFile(command_path, .{});
}
}
fn pathToCommand(arena: *heap.ArenaAllocator, command_path: []const u8) !Command {
const help = try execHelp(arena.allocator(), command_path);
var flags = std.ArrayList(Command.Flag).init(arena.allocator());
var ints = std.ArrayList(Command.Int).init(arena.allocator());
var floats = std.ArrayList(Command.Float).init(arena.allocator());
var enums = std.ArrayList(Command.Enum).init(arena.allocator());
var strings = std.ArrayList(Command.String).init(arena.allocator());
var files = std.ArrayList(Command.File).init(arena.allocator());
var multi_strings = std.ArrayList(Command.MultiString).init(arena.allocator());
var params = std.ArrayList(clap.Param(clap.Help)).init(arena.allocator());
var it = mem.split(u8, help, "\n");
while (it.next()) |line| {
const param = clap.parseParam(line) catch continue;
if (param.names.long == null and param.names.short == null)
continue;
if (mem.eql(u8, param.names.long orelse "", "help"))
continue;
if (mem.eql(u8, param.names.long orelse "", "version"))
continue;
if (mem.eql(u8, param.names.long orelse "", "seed"))
continue;
const i = params.items.len;
try params.append(param);
switch (param.takes_value) {
.none => try flags.append(.{ .i = i }),
.one => if (mem.eql(u8, param.id.value, "BOOL")) {
try flags.append(.{ .i = i });
} else if (mem.eql(u8, param.id.value, "INT")) {
const default = if (findDefaultValue(param.id.msg)) |v|
fmt.parseInt(usize, v, 10) catch 0
else
0;
try ints.append(.{ .i = i, .default = default });
} else if (mem.eql(u8, param.id.value, "FLOAT")) {
const default = if (findDefaultValue(param.id.msg)) |v|
fmt.parseFloat(f64, v) catch 0
else
0;
try floats.append(.{ .i = i, .default = default });
} else if (mem.indexOfScalar(u8, param.id.value, '|') != null) {
var options = std.ArrayList([]const u8).init(arena.allocator());
var options_it = mem.split(u8, param.id.value, "|");
while (options_it.next()) |option|
try options.append(option);
const default = if (findDefaultValue(param.id.msg)) |v| blk: {
for (options.items) |option, option_i| {
if (mem.eql(u8, option, v))
break :blk option_i;
}
break :blk 0;
} else 0;
try enums.append(.{
.i = i,
.options = options.toOwnedSlice(),
.default = default,
});
} else if (mem.eql(u8, param.id.value, "FILE")) {
const default = findDefaultValue(param.id.msg) orelse "";
try files.append(.{ .i = i, .default = default });
} else {
const default = findDefaultValue(param.id.msg) orelse "";
try strings.append(.{ .i = i, .default = default });
},
.many => {
try multi_strings.append(.{ .i = i });
},
}
}
const lists = .{ flags, ints, floats, enums, strings, files, multi_strings };
comptime var i = 0;
inline while (i < lists.len) : (i += 1) {
const Item = @TypeOf(lists[i].items[0]);
std.sort.sort(Item, lists[i].items, params.items, comptime lessThanByName(Item));
}
return Command{
.path = try arena.allocator().dupe(u8, command_path),
.help = help,
.flags = flags.toOwnedSlice(),
.ints = ints.toOwnedSlice(),
.floats = floats.toOwnedSlice(),
.enums = enums.toOwnedSlice(),
.strings = strings.toOwnedSlice(),
.files = files.toOwnedSlice(),
.multi_strings = multi_strings.toOwnedSlice(),
.params = params.toOwnedSlice(),
};
}
fn lessThanByName(comptime T: type) fn ([]const clap.Param(clap.Help), T, T) bool {
return struct {
fn lessThan(params: []const clap.Param(clap.Help), a: T, b: T) bool {
const a_names = params[a.i].names;
const b_names = params[b.i].names;
const a_text = a_names.long orelse @as(*const [1]u8, &a_names.short.?)[0..];
const b_text = b_names.long orelse @as(*const [1]u8, &b_names.short.?)[0..];
return mem.lessThan(u8, a_text, b_text);
}
}.lessThan;
}
fn findDefaultValue(str: []const u8) ?[]const u8 {
const prefix = "(default:";
const start_with_prefix = mem.indexOf(u8, str, "(default:") orelse return null;
const start = start_with_prefix + prefix.len;
const len = mem.indexOf(u8, str[start..], ")") orelse return null;
return mem.trim(u8, str[start..][0..len], " ");
}
fn execHelp(allocator: mem.Allocator, exe: []const u8) ![]u8 {
var buf: [1024 * 40]u8 = undefined;
var fba = heap.FixedBufferAllocator.init(&buf);
const res = try std.ChildProcess.exec(.{
.allocator = fba.allocator(),
.argv = &[_][]const u8{ exe, "--help" },
});
switch (res.term) {
.Exited => |status| if (status != 0) return error.ProcessFailed,
else => return error.ProcessFailed,
}
return allocator.dupe(u8, res.stdout);
} | src/gui/Executables.zig |
pub const TPMVSC_DEFAULT_ADMIN_ALGORITHM_ID = @as(u32, 130);
//--------------------------------------------------------------------------------
// Section: Types (9)
//--------------------------------------------------------------------------------
const CLSID_TpmVirtualSmartCardManager_Value = @import("../zig.zig").Guid.initString("16a18e86-7f6e-4c20-ad89-4ffc0db7a96a");
pub const CLSID_TpmVirtualSmartCardManager = &CLSID_TpmVirtualSmartCardManager_Value;
const CLSID_RemoteTpmVirtualSmartCardManager_Value = @import("../zig.zig").Guid.initString("152ea2a8-70dc-4c59-8b2a-32aa3ca0dcac");
pub const CLSID_RemoteTpmVirtualSmartCardManager = &CLSID_RemoteTpmVirtualSmartCardManager_Value;
pub const TPMVSC_ATTESTATION_TYPE = enum(i32) {
NONE = 0,
AIK_ONLY = 1,
AIK_AND_CERTIFICATE = 2,
};
pub const TPMVSC_ATTESTATION_NONE = TPMVSC_ATTESTATION_TYPE.NONE;
pub const TPMVSC_ATTESTATION_AIK_ONLY = TPMVSC_ATTESTATION_TYPE.AIK_ONLY;
pub const TPMVSC_ATTESTATION_AIK_AND_CERTIFICATE = TPMVSC_ATTESTATION_TYPE.AIK_AND_CERTIFICATE;
pub const TPMVSCMGR_STATUS = enum(i32) {
VTPMSMARTCARD_INITIALIZING = 0,
VTPMSMARTCARD_CREATING = 1,
VTPMSMARTCARD_DESTROYING = 2,
VGIDSSIMULATOR_INITIALIZING = 3,
VGIDSSIMULATOR_CREATING = 4,
VGIDSSIMULATOR_DESTROYING = 5,
VREADER_INITIALIZING = 6,
VREADER_CREATING = 7,
VREADER_DESTROYING = 8,
GENERATE_WAITING = 9,
GENERATE_AUTHENTICATING = 10,
GENERATE_RUNNING = 11,
CARD_CREATED = 12,
CARD_DESTROYED = 13,
};
pub const TPMVSCMGR_STATUS_VTPMSMARTCARD_INITIALIZING = TPMVSCMGR_STATUS.VTPMSMARTCARD_INITIALIZING;
pub const TPMVSCMGR_STATUS_VTPMSMARTCARD_CREATING = TPMVSCMGR_STATUS.VTPMSMARTCARD_CREATING;
pub const TPMVSCMGR_STATUS_VTPMSMARTCARD_DESTROYING = TPMVSCMGR_STATUS.VTPMSMARTCARD_DESTROYING;
pub const TPMVSCMGR_STATUS_VGIDSSIMULATOR_INITIALIZING = TPMVSCMGR_STATUS.VGIDSSIMULATOR_INITIALIZING;
pub const TPMVSCMGR_STATUS_VGIDSSIMULATOR_CREATING = TPMVSCMGR_STATUS.VGIDSSIMULATOR_CREATING;
pub const TPMVSCMGR_STATUS_VGIDSSIMULATOR_DESTROYING = TPMVSCMGR_STATUS.VGIDSSIMULATOR_DESTROYING;
pub const TPMVSCMGR_STATUS_VREADER_INITIALIZING = TPMVSCMGR_STATUS.VREADER_INITIALIZING;
pub const TPMVSCMGR_STATUS_VREADER_CREATING = TPMVSCMGR_STATUS.VREADER_CREATING;
pub const TPMVSCMGR_STATUS_VREADER_DESTROYING = TPMVSCMGR_STATUS.VREADER_DESTROYING;
pub const TPMVSCMGR_STATUS_GENERATE_WAITING = TPMVSCMGR_STATUS.GENERATE_WAITING;
pub const TPMVSCMGR_STATUS_GENERATE_AUTHENTICATING = TPMVSCMGR_STATUS.GENERATE_AUTHENTICATING;
pub const TPMVSCMGR_STATUS_GENERATE_RUNNING = TPMVSCMGR_STATUS.GENERATE_RUNNING;
pub const TPMVSCMGR_STATUS_CARD_CREATED = TPMVSCMGR_STATUS.CARD_CREATED;
pub const TPMVSCMGR_STATUS_CARD_DESTROYED = TPMVSCMGR_STATUS.CARD_DESTROYED;
pub const TPMVSCMGR_ERROR = enum(i32) {
IMPERSONATION = 0,
PIN_COMPLEXITY = 1,
READER_COUNT_LIMIT = 2,
TERMINAL_SERVICES_SESSION = 3,
VTPMSMARTCARD_INITIALIZE = 4,
VTPMSMARTCARD_CREATE = 5,
VTPMSMARTCARD_DESTROY = 6,
VGIDSSIMULATOR_INITIALIZE = 7,
VGIDSSIMULATOR_CREATE = 8,
VGIDSSIMULATOR_DESTROY = 9,
VGIDSSIMULATOR_WRITE_PROPERTY = 10,
VGIDSSIMULATOR_READ_PROPERTY = 11,
VREADER_INITIALIZE = 12,
VREADER_CREATE = 13,
VREADER_DESTROY = 14,
GENERATE_LOCATE_READER = 15,
GENERATE_FILESYSTEM = 16,
CARD_CREATE = 17,
CARD_DESTROY = 18,
};
pub const TPMVSCMGR_ERROR_IMPERSONATION = TPMVSCMGR_ERROR.IMPERSONATION;
pub const TPMVSCMGR_ERROR_PIN_COMPLEXITY = TPMVSCMGR_ERROR.PIN_COMPLEXITY;
pub const TPMVSCMGR_ERROR_READER_COUNT_LIMIT = TPMVSCMGR_ERROR.READER_COUNT_LIMIT;
pub const TPMVSCMGR_ERROR_TERMINAL_SERVICES_SESSION = TPMVSCMGR_ERROR.TERMINAL_SERVICES_SESSION;
pub const TPMVSCMGR_ERROR_VTPMSMARTCARD_INITIALIZE = TPMVSCMGR_ERROR.VTPMSMARTCARD_INITIALIZE;
pub const TPMVSCMGR_ERROR_VTPMSMARTCARD_CREATE = TPMVSCMGR_ERROR.VTPMSMARTCARD_CREATE;
pub const TPMVSCMGR_ERROR_VTPMSMARTCARD_DESTROY = TPMVSCMGR_ERROR.VTPMSMARTCARD_DESTROY;
pub const TPMVSCMGR_ERROR_VGIDSSIMULATOR_INITIALIZE = TPMVSCMGR_ERROR.VGIDSSIMULATOR_INITIALIZE;
pub const TPMVSCMGR_ERROR_VGIDSSIMULATOR_CREATE = TPMVSCMGR_ERROR.VGIDSSIMULATOR_CREATE;
pub const TPMVSCMGR_ERROR_VGIDSSIMULATOR_DESTROY = TPMVSCMGR_ERROR.VGIDSSIMULATOR_DESTROY;
pub const TPMVSCMGR_ERROR_VGIDSSIMULATOR_WRITE_PROPERTY = TPMVSCMGR_ERROR.VGIDSSIMULATOR_WRITE_PROPERTY;
pub const TPMVSCMGR_ERROR_VGIDSSIMULATOR_READ_PROPERTY = TPMVSCMGR_ERROR.VGIDSSIMULATOR_READ_PROPERTY;
pub const TPMVSCMGR_ERROR_VREADER_INITIALIZE = TPMVSCMGR_ERROR.VREADER_INITIALIZE;
pub const TPMVSCMGR_ERROR_VREADER_CREATE = TPMVSCMGR_ERROR.VREADER_CREATE;
pub const TPMVSCMGR_ERROR_VREADER_DESTROY = TPMVSCMGR_ERROR.VREADER_DESTROY;
pub const TPMVSCMGR_ERROR_GENERATE_LOCATE_READER = TPMVSCMGR_ERROR.GENERATE_LOCATE_READER;
pub const TPMVSCMGR_ERROR_GENERATE_FILESYSTEM = TPMVSCMGR_ERROR.GENERATE_FILESYSTEM;
pub const TPMVSCMGR_ERROR_CARD_CREATE = TPMVSCMGR_ERROR.CARD_CREATE;
pub const TPMVSCMGR_ERROR_CARD_DESTROY = TPMVSCMGR_ERROR.CARD_DESTROY;
// TODO: this type is limited to platform 'windows8.0'
const IID_ITpmVirtualSmartCardManagerStatusCallback_Value = @import("../zig.zig").Guid.initString("1a1bb35f-abb8-451c-a1ae-33d98f1bef4a");
pub const IID_ITpmVirtualSmartCardManagerStatusCallback = &IID_ITpmVirtualSmartCardManagerStatusCallback_Value;
pub const ITpmVirtualSmartCardManagerStatusCallback = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ReportProgress: fn(
self: *const ITpmVirtualSmartCardManagerStatusCallback,
Status: TPMVSCMGR_STATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReportError: fn(
self: *const ITpmVirtualSmartCardManagerStatusCallback,
Error: TPMVSCMGR_ERROR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ITpmVirtualSmartCardManagerStatusCallback_ReportProgress(self: *const T, Status: TPMVSCMGR_STATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const ITpmVirtualSmartCardManagerStatusCallback.VTable, self.vtable).ReportProgress(@ptrCast(*const ITpmVirtualSmartCardManagerStatusCallback, self), Status);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ITpmVirtualSmartCardManagerStatusCallback_ReportError(self: *const T, Error: TPMVSCMGR_ERROR) callconv(.Inline) HRESULT {
return @ptrCast(*const ITpmVirtualSmartCardManagerStatusCallback.VTable, self.vtable).ReportError(@ptrCast(*const ITpmVirtualSmartCardManagerStatusCallback, self), Error);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ITpmVirtualSmartCardManager_Value = @import("../zig.zig").Guid.initString("112b1dff-d9dc-41f7-869f-d67fee7cb591");
pub const IID_ITpmVirtualSmartCardManager = &IID_ITpmVirtualSmartCardManager_Value;
pub const ITpmVirtualSmartCardManager = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
CreateVirtualSmartCard: fn(
self: *const ITpmVirtualSmartCardManager,
pszFriendlyName: ?[*:0]const u16,
bAdminAlgId: u8,
pbAdminKey: [*:0]const u8,
cbAdminKey: u32,
pbAdminKcv: [*:0]const u8,
cbAdminKcv: u32,
pbPuk: [*:0]const u8,
cbPuk: u32,
pbPin: [*:0]const u8,
cbPin: u32,
fGenerate: BOOL,
pStatusCallback: ?*ITpmVirtualSmartCardManagerStatusCallback,
ppszInstanceId: ?*?PWSTR,
pfNeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DestroyVirtualSmartCard: fn(
self: *const ITpmVirtualSmartCardManager,
pszInstanceId: ?[*:0]const u16,
pStatusCallback: ?*ITpmVirtualSmartCardManagerStatusCallback,
pfNeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ITpmVirtualSmartCardManager_CreateVirtualSmartCard(self: *const T, pszFriendlyName: ?[*:0]const u16, bAdminAlgId: u8, pbAdminKey: [*:0]const u8, cbAdminKey: u32, pbAdminKcv: [*:0]const u8, cbAdminKcv: u32, pbPuk: [*:0]const u8, cbPuk: u32, pbPin: [*:0]const u8, cbPin: u32, fGenerate: BOOL, pStatusCallback: ?*ITpmVirtualSmartCardManagerStatusCallback, ppszInstanceId: ?*?PWSTR, pfNeedReboot: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ITpmVirtualSmartCardManager.VTable, self.vtable).CreateVirtualSmartCard(@ptrCast(*const ITpmVirtualSmartCardManager, self), pszFriendlyName, bAdminAlgId, pbAdminKey, cbAdminKey, pbAdminKcv, cbAdminKcv, pbPuk, cbPuk, pbPin, cbPin, fGenerate, pStatusCallback, ppszInstanceId, pfNeedReboot);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ITpmVirtualSmartCardManager_DestroyVirtualSmartCard(self: *const T, pszInstanceId: ?[*:0]const u16, pStatusCallback: ?*ITpmVirtualSmartCardManagerStatusCallback, pfNeedReboot: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ITpmVirtualSmartCardManager.VTable, self.vtable).DestroyVirtualSmartCard(@ptrCast(*const ITpmVirtualSmartCardManager, self), pszInstanceId, pStatusCallback, pfNeedReboot);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ITpmVirtualSmartCardManager2_Value = @import("../zig.zig").Guid.initString("fdf8a2b9-02de-47f4-bc26-aa85ab5e5267");
pub const IID_ITpmVirtualSmartCardManager2 = &IID_ITpmVirtualSmartCardManager2_Value;
pub const ITpmVirtualSmartCardManager2 = extern struct {
pub const VTable = extern struct {
base: ITpmVirtualSmartCardManager.VTable,
CreateVirtualSmartCardWithPinPolicy: fn(
self: *const ITpmVirtualSmartCardManager2,
pszFriendlyName: ?[*:0]const u16,
bAdminAlgId: u8,
pbAdminKey: [*:0]const u8,
cbAdminKey: u32,
pbAdminKcv: [*:0]const u8,
cbAdminKcv: u32,
pbPuk: [*:0]const u8,
cbPuk: u32,
pbPin: [*:0]const u8,
cbPin: u32,
pbPinPolicy: [*:0]const u8,
cbPinPolicy: u32,
fGenerate: BOOL,
pStatusCallback: ?*ITpmVirtualSmartCardManagerStatusCallback,
ppszInstanceId: ?*?PWSTR,
pfNeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ITpmVirtualSmartCardManager.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ITpmVirtualSmartCardManager2_CreateVirtualSmartCardWithPinPolicy(self: *const T, pszFriendlyName: ?[*:0]const u16, bAdminAlgId: u8, pbAdminKey: [*:0]const u8, cbAdminKey: u32, pbAdminKcv: [*:0]const u8, cbAdminKcv: u32, pbPuk: [*:0]const u8, cbPuk: u32, pbPin: [*:0]const u8, cbPin: u32, pbPinPolicy: [*:0]const u8, cbPinPolicy: u32, fGenerate: BOOL, pStatusCallback: ?*ITpmVirtualSmartCardManagerStatusCallback, ppszInstanceId: ?*?PWSTR, pfNeedReboot: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ITpmVirtualSmartCardManager2.VTable, self.vtable).CreateVirtualSmartCardWithPinPolicy(@ptrCast(*const ITpmVirtualSmartCardManager2, self), pszFriendlyName, bAdminAlgId, pbAdminKey, cbAdminKey, pbAdminKcv, cbAdminKcv, pbPuk, cbPuk, pbPin, cbPin, pbPinPolicy, cbPinPolicy, fGenerate, pStatusCallback, ppszInstanceId, pfNeedReboot);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ITpmVirtualSmartCardManager3_Value = @import("../zig.zig").Guid.initString("3c745a97-f375-4150-be17-5950f694c699");
pub const IID_ITpmVirtualSmartCardManager3 = &IID_ITpmVirtualSmartCardManager3_Value;
pub const ITpmVirtualSmartCardManager3 = extern struct {
pub const VTable = extern struct {
base: ITpmVirtualSmartCardManager2.VTable,
CreateVirtualSmartCardWithAttestation: fn(
self: *const ITpmVirtualSmartCardManager3,
pszFriendlyName: ?[*:0]const u16,
bAdminAlgId: u8,
pbAdminKey: [*:0]const u8,
cbAdminKey: u32,
pbAdminKcv: [*:0]const u8,
cbAdminKcv: u32,
pbPuk: [*:0]const u8,
cbPuk: u32,
pbPin: [*:0]const u8,
cbPin: u32,
pbPinPolicy: [*:0]const u8,
cbPinPolicy: u32,
attestationType: TPMVSC_ATTESTATION_TYPE,
fGenerate: BOOL,
pStatusCallback: ?*ITpmVirtualSmartCardManagerStatusCallback,
ppszInstanceId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ITpmVirtualSmartCardManager2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ITpmVirtualSmartCardManager3_CreateVirtualSmartCardWithAttestation(self: *const T, pszFriendlyName: ?[*:0]const u16, bAdminAlgId: u8, pbAdminKey: [*:0]const u8, cbAdminKey: u32, pbAdminKcv: [*:0]const u8, cbAdminKcv: u32, pbPuk: [*:0]const u8, cbPuk: u32, pbPin: [*:0]const u8, cbPin: u32, pbPinPolicy: [*:0]const u8, cbPinPolicy: u32, attestationType: TPMVSC_ATTESTATION_TYPE, fGenerate: BOOL, pStatusCallback: ?*ITpmVirtualSmartCardManagerStatusCallback, ppszInstanceId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ITpmVirtualSmartCardManager3.VTable, self.vtable).CreateVirtualSmartCardWithAttestation(@ptrCast(*const ITpmVirtualSmartCardManager3, self), pszFriendlyName, bAdminAlgId, pbAdminKey, cbAdminKey, pbAdminKcv, cbAdminKcv, pbPuk, cbPuk, pbPin, cbPin, pbPinPolicy, cbPinPolicy, attestationType, fGenerate, pStatusCallback, ppszInstanceId);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (0)
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (4)
//--------------------------------------------------------------------------------
const BOOL = @import("../foundation.zig").BOOL;
const HRESULT = @import("../foundation.zig").HRESULT;
const IUnknown = @import("../system/com.zig").IUnknown;
const PWSTR = @import("../foundation.zig").PWSTR;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/security/tpm.zig |
pub const CGD_DEFAULT = @as(u32, 0);
pub const CGD_UNKNOWN_PROPERTY = @as(u32, 0);
pub const CGD_STRING_PROPERTY = @as(u32, 1);
pub const CGD_DATE_PROPERTY = @as(u32, 2);
pub const CGD_BINARY_PROPERTY = @as(u32, 4);
pub const CGD_ARRAY_NODE = @as(u32, 8);
pub const CLSID_ContactAggregationManager = Guid.initString("96c8ad95-c199-44de-b34e-ac33c442df39");
//--------------------------------------------------------------------------------
// Section: Types (21)
//--------------------------------------------------------------------------------
const CLSID_Contact_Value = @import("../zig.zig").Guid.initString("61b68808-8eee-4fd1-acb8-3d804c8db056");
pub const CLSID_Contact = &CLSID_Contact_Value;
const CLSID_ContactManager_Value = @import("../zig.zig").Guid.initString("7165c8ab-af88-42bd-86fd-5310b4285a02");
pub const CLSID_ContactManager = &CLSID_ContactManager_Value;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContactManager_Value = @import("../zig.zig").Guid.initString("ad553d98-deb1-474a-8e17-fc0c2075b738");
pub const IID_IContactManager = &IID_IContactManager_Value;
pub const IContactManager = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Initialize: fn(
self: *const IContactManager,
pszAppName: ?[*:0]const u16,
pszAppVersion: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Load: fn(
self: *const IContactManager,
pszContactID: ?[*:0]const u16,
ppContact: ?*?*IContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
MergeContactIDs: fn(
self: *const IContactManager,
pszNewContactID: ?[*:0]const u16,
pszOldContactID: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMeContact: fn(
self: *const IContactManager,
ppMeContact: ?*?*IContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetMeContact: fn(
self: *const IContactManager,
pMeContact: ?*IContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetContactCollection: fn(
self: *const IContactManager,
ppContactCollection: ?*?*IContactCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactManager_Initialize(self: *const T, pszAppName: ?[*:0]const u16, pszAppVersion: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactManager.VTable, self.vtable).Initialize(@ptrCast(*const IContactManager, self), pszAppName, pszAppVersion);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactManager_Load(self: *const T, pszContactID: ?[*:0]const u16, ppContact: ?*?*IContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactManager.VTable, self.vtable).Load(@ptrCast(*const IContactManager, self), pszContactID, ppContact);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactManager_MergeContactIDs(self: *const T, pszNewContactID: ?[*:0]const u16, pszOldContactID: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactManager.VTable, self.vtable).MergeContactIDs(@ptrCast(*const IContactManager, self), pszNewContactID, pszOldContactID);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactManager_GetMeContact(self: *const T, ppMeContact: ?*?*IContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactManager.VTable, self.vtable).GetMeContact(@ptrCast(*const IContactManager, self), ppMeContact);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactManager_SetMeContact(self: *const T, pMeContact: ?*IContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactManager.VTable, self.vtable).SetMeContact(@ptrCast(*const IContactManager, self), pMeContact);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactManager_GetContactCollection(self: *const T, ppContactCollection: ?*?*IContactCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactManager.VTable, self.vtable).GetContactCollection(@ptrCast(*const IContactManager, self), ppContactCollection);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContactCollection_Value = @import("../zig.zig").Guid.initString("b6afa338-d779-11d9-8bde-f66bad1e3f3a");
pub const IID_IContactCollection = &IID_IContactCollection_Value;
pub const IContactCollection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Reset: fn(
self: *const IContactCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IContactCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCurrent: fn(
self: *const IContactCollection,
ppContact: ?*?*IContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactCollection_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactCollection.VTable, self.vtable).Reset(@ptrCast(*const IContactCollection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactCollection_Next(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactCollection.VTable, self.vtable).Next(@ptrCast(*const IContactCollection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactCollection_GetCurrent(self: *const T, ppContact: ?*?*IContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactCollection.VTable, self.vtable).GetCurrent(@ptrCast(*const IContactCollection, self), ppContact);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContactProperties_Value = @import("../zig.zig").Guid.initString("70dd27dd-5cbd-46e8-bef0-23b6b346288f");
pub const IID_IContactProperties = &IID_IContactProperties_Value;
pub const IContactProperties = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetString: fn(
self: *const IContactProperties,
pszPropertyName: ?[*:0]const u16,
dwFlags: u32,
pszValue: [*:0]u16,
cchValue: u32,
pdwcchPropertyValueRequired: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDate: fn(
self: *const IContactProperties,
pszPropertyName: ?[*:0]const u16,
dwFlags: u32,
pftDateTime: ?*FILETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetBinary: fn(
self: *const IContactProperties,
pszPropertyName: ?[*:0]const u16,
dwFlags: u32,
pszContentType: [*:0]u16,
cchContentType: u32,
pdwcchContentTypeRequired: ?*u32,
ppStream: ?*?*IStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLabels: fn(
self: *const IContactProperties,
pszArrayElementName: ?[*:0]const u16,
dwFlags: u32,
pszLabels: [*:0]u16,
cchLabels: u32,
pdwcchLabelsRequired: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetString: fn(
self: *const IContactProperties,
pszPropertyName: ?[*:0]const u16,
dwFlags: u32,
pszValue: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetDate: fn(
self: *const IContactProperties,
pszPropertyName: ?[*:0]const u16,
dwFlags: u32,
ftDateTime: FILETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetBinary: fn(
self: *const IContactProperties,
pszPropertyName: ?[*:0]const u16,
dwFlags: u32,
pszContentType: ?[*:0]const u16,
pStream: ?*IStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetLabels: fn(
self: *const IContactProperties,
pszArrayElementName: ?[*:0]const u16,
dwFlags: u32,
dwLabelCount: u32,
ppszLabels: [*]?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateArrayNode: fn(
self: *const IContactProperties,
pszArrayName: ?[*:0]const u16,
dwFlags: u32,
fAppend: BOOL,
pszNewArrayElementName: [*:0]u16,
cchNewArrayElementName: u32,
pdwcchNewArrayElementNameRequired: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteProperty: fn(
self: *const IContactProperties,
pszPropertyName: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteArrayNode: fn(
self: *const IContactProperties,
pszArrayElementName: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteLabels: fn(
self: *const IContactProperties,
pszArrayElementName: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyCollection: fn(
self: *const IContactProperties,
ppPropertyCollection: ?*?*IContactPropertyCollection,
dwFlags: u32,
pszMultiValueName: ?[*:0]const u16,
dwLabelCount: u32,
ppszLabels: [*]?PWSTR,
fAnyLabelMatches: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_GetString(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pszValue: [*:0]u16, cchValue: u32, pdwcchPropertyValueRequired: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).GetString(@ptrCast(*const IContactProperties, self), pszPropertyName, dwFlags, pszValue, cchValue, pdwcchPropertyValueRequired);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_GetDate(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pftDateTime: ?*FILETIME) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).GetDate(@ptrCast(*const IContactProperties, self), pszPropertyName, dwFlags, pftDateTime);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_GetBinary(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pszContentType: [*:0]u16, cchContentType: u32, pdwcchContentTypeRequired: ?*u32, ppStream: ?*?*IStream) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).GetBinary(@ptrCast(*const IContactProperties, self), pszPropertyName, dwFlags, pszContentType, cchContentType, pdwcchContentTypeRequired, ppStream);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_GetLabels(self: *const T, pszArrayElementName: ?[*:0]const u16, dwFlags: u32, pszLabels: [*:0]u16, cchLabels: u32, pdwcchLabelsRequired: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).GetLabels(@ptrCast(*const IContactProperties, self), pszArrayElementName, dwFlags, pszLabels, cchLabels, pdwcchLabelsRequired);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_SetString(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pszValue: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).SetString(@ptrCast(*const IContactProperties, self), pszPropertyName, dwFlags, pszValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_SetDate(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, ftDateTime: FILETIME) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).SetDate(@ptrCast(*const IContactProperties, self), pszPropertyName, dwFlags, ftDateTime);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_SetBinary(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pszContentType: ?[*:0]const u16, pStream: ?*IStream) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).SetBinary(@ptrCast(*const IContactProperties, self), pszPropertyName, dwFlags, pszContentType, pStream);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_SetLabels(self: *const T, pszArrayElementName: ?[*:0]const u16, dwFlags: u32, dwLabelCount: u32, ppszLabels: [*]?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).SetLabels(@ptrCast(*const IContactProperties, self), pszArrayElementName, dwFlags, dwLabelCount, ppszLabels);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_CreateArrayNode(self: *const T, pszArrayName: ?[*:0]const u16, dwFlags: u32, fAppend: BOOL, pszNewArrayElementName: [*:0]u16, cchNewArrayElementName: u32, pdwcchNewArrayElementNameRequired: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).CreateArrayNode(@ptrCast(*const IContactProperties, self), pszArrayName, dwFlags, fAppend, pszNewArrayElementName, cchNewArrayElementName, pdwcchNewArrayElementNameRequired);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_DeleteProperty(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).DeleteProperty(@ptrCast(*const IContactProperties, self), pszPropertyName, dwFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_DeleteArrayNode(self: *const T, pszArrayElementName: ?[*:0]const u16, dwFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).DeleteArrayNode(@ptrCast(*const IContactProperties, self), pszArrayElementName, dwFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_DeleteLabels(self: *const T, pszArrayElementName: ?[*:0]const u16, dwFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).DeleteLabels(@ptrCast(*const IContactProperties, self), pszArrayElementName, dwFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactProperties_GetPropertyCollection(self: *const T, ppPropertyCollection: ?*?*IContactPropertyCollection, dwFlags: u32, pszMultiValueName: ?[*:0]const u16, dwLabelCount: u32, ppszLabels: [*]?PWSTR, fAnyLabelMatches: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactProperties.VTable, self.vtable).GetPropertyCollection(@ptrCast(*const IContactProperties, self), ppPropertyCollection, dwFlags, pszMultiValueName, dwLabelCount, ppszLabels, fAnyLabelMatches);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContact_Value = @import("../zig.zig").Guid.initString("f941b671-bda7-4f77-884a-f46462f226a7");
pub const IID_IContact = &IID_IContact_Value;
pub const IContact = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetContactID: fn(
self: *const IContact,
pszContactID: [*:0]u16,
cchContactID: u32,
pdwcchContactIDRequired: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPath: fn(
self: *const IContact,
pszPath: [*:0]u16,
cchPath: u32,
pdwcchPathRequired: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CommitChanges: fn(
self: *const IContact,
dwCommitFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContact_GetContactID(self: *const T, pszContactID: [*:0]u16, cchContactID: u32, pdwcchContactIDRequired: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContact.VTable, self.vtable).GetContactID(@ptrCast(*const IContact, self), pszContactID, cchContactID, pdwcchContactIDRequired);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContact_GetPath(self: *const T, pszPath: [*:0]u16, cchPath: u32, pdwcchPathRequired: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContact.VTable, self.vtable).GetPath(@ptrCast(*const IContact, self), pszPath, cchPath, pdwcchPathRequired);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContact_CommitChanges(self: *const T, dwCommitFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContact.VTable, self.vtable).CommitChanges(@ptrCast(*const IContact, self), dwCommitFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContactPropertyCollection_Value = @import("../zig.zig").Guid.initString("ffd3adf8-fa64-4328-b1b6-2e0db509cb3c");
pub const IID_IContactPropertyCollection = &IID_IContactPropertyCollection_Value;
pub const IContactPropertyCollection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Reset: fn(
self: *const IContactPropertyCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IContactPropertyCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyName: fn(
self: *const IContactPropertyCollection,
pszPropertyName: [*:0]u16,
cchPropertyName: u32,
pdwcchPropertyNameRequired: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyType: fn(
self: *const IContactPropertyCollection,
pdwType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyVersion: fn(
self: *const IContactPropertyCollection,
pdwVersion: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyModificationDate: fn(
self: *const IContactPropertyCollection,
pftModificationDate: ?*FILETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyArrayElementID: fn(
self: *const IContactPropertyCollection,
pszArrayElementID: [*:0]u16,
cchArrayElementID: u32,
pdwcchArrayElementIDRequired: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactPropertyCollection_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactPropertyCollection.VTable, self.vtable).Reset(@ptrCast(*const IContactPropertyCollection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactPropertyCollection_Next(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactPropertyCollection.VTable, self.vtable).Next(@ptrCast(*const IContactPropertyCollection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactPropertyCollection_GetPropertyName(self: *const T, pszPropertyName: [*:0]u16, cchPropertyName: u32, pdwcchPropertyNameRequired: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactPropertyCollection.VTable, self.vtable).GetPropertyName(@ptrCast(*const IContactPropertyCollection, self), pszPropertyName, cchPropertyName, pdwcchPropertyNameRequired);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactPropertyCollection_GetPropertyType(self: *const T, pdwType: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactPropertyCollection.VTable, self.vtable).GetPropertyType(@ptrCast(*const IContactPropertyCollection, self), pdwType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactPropertyCollection_GetPropertyVersion(self: *const T, pdwVersion: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactPropertyCollection.VTable, self.vtable).GetPropertyVersion(@ptrCast(*const IContactPropertyCollection, self), pdwVersion);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactPropertyCollection_GetPropertyModificationDate(self: *const T, pftModificationDate: ?*FILETIME) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactPropertyCollection.VTable, self.vtable).GetPropertyModificationDate(@ptrCast(*const IContactPropertyCollection, self), pftModificationDate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactPropertyCollection_GetPropertyArrayElementID(self: *const T, pszArrayElementID: [*:0]u16, cchArrayElementID: u32, pdwcchArrayElementIDRequired: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactPropertyCollection.VTable, self.vtable).GetPropertyArrayElementID(@ptrCast(*const IContactPropertyCollection, self), pszArrayElementID, cchArrayElementID, pdwcchArrayElementIDRequired);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS = enum(i32) {
LOCAL = 0,
EXTERNAL = 1,
};
pub const CA_CREATE_LOCAL = CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS.LOCAL;
pub const CA_CREATE_EXTERNAL = CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS.EXTERNAL;
pub const CONTACT_AGGREGATION_COLLECTION_OPTIONS = enum(i32) {
DEFAULT = 0,
INCLUDE_EXTERNAL = 1,
EXTERNAL_ONLY = 2,
};
pub const CACO_DEFAULT = CONTACT_AGGREGATION_COLLECTION_OPTIONS.DEFAULT;
pub const CACO_INCLUDE_EXTERNAL = CONTACT_AGGREGATION_COLLECTION_OPTIONS.INCLUDE_EXTERNAL;
pub const CACO_EXTERNAL_ONLY = CONTACT_AGGREGATION_COLLECTION_OPTIONS.EXTERNAL_ONLY;
pub const CONTACT_AGGREGATION_BLOB = extern struct {
dwCount: u32,
lpb: ?*u8,
};
const IID_IContactAggregationManager_Value = @import("../zig.zig").Guid.initString("1d865989-4b1f-4b60-8f34-c2ad468b2b50");
pub const IID_IContactAggregationManager = &IID_IContactAggregationManager_Value;
pub const IContactAggregationManager = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetVersionInfo: fn(
self: *const IContactAggregationManager,
plMajorVersion: ?*i32,
plMinorVersion: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateOrOpenGroup: fn(
self: *const IContactAggregationManager,
pGroupName: ?[*:0]const u16,
options: CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS,
pCreatedGroup: ?*BOOL,
ppGroup: ?*?*IContactAggregationGroup,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateExternalContact: fn(
self: *const IContactAggregationManager,
ppItem: ?*?*IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateServerPerson: fn(
self: *const IContactAggregationManager,
ppServerPerson: ?*?*IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateServerContactLink: fn(
self: *const IContactAggregationManager,
ppServerContactLink: ?*?*IContactAggregationLink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Flush: fn(
self: *const IContactAggregationManager,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenAggregateContact: fn(
self: *const IContactAggregationManager,
pItemId: ?[*:0]const u16,
ppItem: ?*?*IContactAggregationAggregate,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenContact: fn(
self: *const IContactAggregationManager,
pItemId: ?[*:0]const u16,
ppItem: ?*?*IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenServerContactLink: fn(
self: *const IContactAggregationManager,
pItemId: ?[*:0]const u16,
ppItem: ?*?*IContactAggregationLink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenServerPerson: fn(
self: *const IContactAggregationManager,
pItemId: ?[*:0]const u16,
ppItem: ?*?*IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Contacts: fn(
self: *const IContactAggregationManager,
options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
ppItems: ?*?*IContactAggregationContactCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AggregateContacts: fn(
self: *const IContactAggregationManager,
options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
ppAggregates: ?*?*IContactAggregationAggregateCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Groups: fn(
self: *const IContactAggregationManager,
options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
ppGroups: ?*?*IContactAggregationGroupCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ServerPersons: fn(
self: *const IContactAggregationManager,
ppServerPersonCollection: ?*?*IContactAggregationServerPersonCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ServerContactLinks: fn(
self: *const IContactAggregationManager,
pPersonItemId: ?[*:0]const u16,
ppServerContactLinkCollection: ?*?*IContactAggregationLinkCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_GetVersionInfo(self: *const T, plMajorVersion: ?*i32, plMinorVersion: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).GetVersionInfo(@ptrCast(*const IContactAggregationManager, self), plMajorVersion, plMinorVersion);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_CreateOrOpenGroup(self: *const T, pGroupName: ?[*:0]const u16, options: CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS, pCreatedGroup: ?*BOOL, ppGroup: ?*?*IContactAggregationGroup) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).CreateOrOpenGroup(@ptrCast(*const IContactAggregationManager, self), pGroupName, options, pCreatedGroup, ppGroup);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_CreateExternalContact(self: *const T, ppItem: ?*?*IContactAggregationContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).CreateExternalContact(@ptrCast(*const IContactAggregationManager, self), ppItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_CreateServerPerson(self: *const T, ppServerPerson: ?*?*IContactAggregationServerPerson) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).CreateServerPerson(@ptrCast(*const IContactAggregationManager, self), ppServerPerson);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_CreateServerContactLink(self: *const T, ppServerContactLink: ?*?*IContactAggregationLink) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).CreateServerContactLink(@ptrCast(*const IContactAggregationManager, self), ppServerContactLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_Flush(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).Flush(@ptrCast(*const IContactAggregationManager, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_OpenAggregateContact(self: *const T, pItemId: ?[*:0]const u16, ppItem: ?*?*IContactAggregationAggregate) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).OpenAggregateContact(@ptrCast(*const IContactAggregationManager, self), pItemId, ppItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_OpenContact(self: *const T, pItemId: ?[*:0]const u16, ppItem: ?*?*IContactAggregationContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).OpenContact(@ptrCast(*const IContactAggregationManager, self), pItemId, ppItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_OpenServerContactLink(self: *const T, pItemId: ?[*:0]const u16, ppItem: ?*?*IContactAggregationLink) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).OpenServerContactLink(@ptrCast(*const IContactAggregationManager, self), pItemId, ppItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_OpenServerPerson(self: *const T, pItemId: ?[*:0]const u16, ppItem: ?*?*IContactAggregationServerPerson) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).OpenServerPerson(@ptrCast(*const IContactAggregationManager, self), pItemId, ppItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_get_Contacts(self: *const T, options: CONTACT_AGGREGATION_COLLECTION_OPTIONS, ppItems: ?*?*IContactAggregationContactCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).get_Contacts(@ptrCast(*const IContactAggregationManager, self), options, ppItems);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_get_AggregateContacts(self: *const T, options: CONTACT_AGGREGATION_COLLECTION_OPTIONS, ppAggregates: ?*?*IContactAggregationAggregateCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).get_AggregateContacts(@ptrCast(*const IContactAggregationManager, self), options, ppAggregates);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_get_Groups(self: *const T, options: CONTACT_AGGREGATION_COLLECTION_OPTIONS, ppGroups: ?*?*IContactAggregationGroupCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).get_Groups(@ptrCast(*const IContactAggregationManager, self), options, ppGroups);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_get_ServerPersons(self: *const T, ppServerPersonCollection: ?*?*IContactAggregationServerPersonCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).get_ServerPersons(@ptrCast(*const IContactAggregationManager, self), ppServerPersonCollection);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationManager_get_ServerContactLinks(self: *const T, pPersonItemId: ?[*:0]const u16, ppServerContactLinkCollection: ?*?*IContactAggregationLinkCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationManager.VTable, self.vtable).get_ServerContactLinks(@ptrCast(*const IContactAggregationManager, self), pPersonItemId, ppServerContactLinkCollection);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationContact_Value = @import("../zig.zig").Guid.initString("1eb22e86-4c86-41f0-9f9f-c251e9fda6c3");
pub const IID_IContactAggregationContact = &IID_IContactAggregationContact_Value;
pub const IContactAggregationContact = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Delete: fn(
self: *const IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Save: fn(
self: *const IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
MoveToAggregate: fn(
self: *const IContactAggregationContact,
pAggregateId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Unlink: fn(
self: *const IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AccountId: fn(
self: *const IContactAggregationContact,
ppAccountId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_AccountId: fn(
self: *const IContactAggregationContact,
pAccountId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AggregateId: fn(
self: *const IContactAggregationContact,
ppAggregateId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Id: fn(
self: *const IContactAggregationContact,
ppItemId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsMe: fn(
self: *const IContactAggregationContact,
pIsMe: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsExternal: fn(
self: *const IContactAggregationContact,
pIsExternal: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_NetworkSourceId: fn(
self: *const IContactAggregationContact,
pNetworkSourceId: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_NetworkSourceId: fn(
self: *const IContactAggregationContact,
networkSourceId: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_NetworkSourceIdString: fn(
self: *const IContactAggregationContact,
ppNetworkSourceId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_NetworkSourceIdString: fn(
self: *const IContactAggregationContact,
pNetworkSourceId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_RemoteObjectId: fn(
self: *const IContactAggregationContact,
ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_RemoteObjectId: fn(
self: *const IContactAggregationContact,
pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_SyncIdentityHash: fn(
self: *const IContactAggregationContact,
ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_SyncIdentityHash: fn(
self: *const IContactAggregationContact,
pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_Delete(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).Delete(@ptrCast(*const IContactAggregationContact, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_Save(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).Save(@ptrCast(*const IContactAggregationContact, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_MoveToAggregate(self: *const T, pAggregateId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).MoveToAggregate(@ptrCast(*const IContactAggregationContact, self), pAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_Unlink(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).Unlink(@ptrCast(*const IContactAggregationContact, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_AccountId(self: *const T, ppAccountId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_AccountId(@ptrCast(*const IContactAggregationContact, self), ppAccountId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_put_AccountId(self: *const T, pAccountId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).put_AccountId(@ptrCast(*const IContactAggregationContact, self), pAccountId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_AggregateId(self: *const T, ppAggregateId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_AggregateId(@ptrCast(*const IContactAggregationContact, self), ppAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_Id(self: *const T, ppItemId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_Id(@ptrCast(*const IContactAggregationContact, self), ppItemId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_IsMe(self: *const T, pIsMe: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_IsMe(@ptrCast(*const IContactAggregationContact, self), pIsMe);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_IsExternal(self: *const T, pIsExternal: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_IsExternal(@ptrCast(*const IContactAggregationContact, self), pIsExternal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_NetworkSourceId(self: *const T, pNetworkSourceId: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_NetworkSourceId(@ptrCast(*const IContactAggregationContact, self), pNetworkSourceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_put_NetworkSourceId(self: *const T, networkSourceId: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).put_NetworkSourceId(@ptrCast(*const IContactAggregationContact, self), networkSourceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_NetworkSourceIdString(self: *const T, ppNetworkSourceId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_NetworkSourceIdString(@ptrCast(*const IContactAggregationContact, self), ppNetworkSourceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_put_NetworkSourceIdString(self: *const T, pNetworkSourceId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).put_NetworkSourceIdString(@ptrCast(*const IContactAggregationContact, self), pNetworkSourceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_RemoteObjectId(self: *const T, ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_RemoteObjectId(@ptrCast(*const IContactAggregationContact, self), ppRemoteObjectId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_put_RemoteObjectId(self: *const T, pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).put_RemoteObjectId(@ptrCast(*const IContactAggregationContact, self), pRemoteObjectId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_get_SyncIdentityHash(self: *const T, ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).get_SyncIdentityHash(@ptrCast(*const IContactAggregationContact, self), ppSyncIdentityHash);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContact_put_SyncIdentityHash(self: *const T, pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContact.VTable, self.vtable).put_SyncIdentityHash(@ptrCast(*const IContactAggregationContact, self), pSyncIdentityHash);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationContactCollection_Value = @import("../zig.zig").Guid.initString("826e66fa-81de-43ca-a6fb-8c785cd996c6");
pub const IID_IContactAggregationContactCollection = &IID_IContactAggregationContactCollection_Value;
pub const IContactAggregationContactCollection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
FindFirst: fn(
self: *const IContactAggregationContactCollection,
ppItem: ?*?*IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindNext: fn(
self: *const IContactAggregationContactCollection,
ppItem: ?*?*IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindFirstByIdentityHash: fn(
self: *const IContactAggregationContactCollection,
pSourceType: ?[*:0]const u16,
pAccountId: ?[*:0]const u16,
pIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
ppItem: ?*?*IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const IContactAggregationContactCollection,
pCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindFirstByRemoteId: fn(
self: *const IContactAggregationContactCollection,
pSourceType: ?[*:0]const u16,
pAccountId: ?[*:0]const u16,
pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
ppItem: ?*?*IContactAggregationContact,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContactCollection_FindFirst(self: *const T, ppItem: ?*?*IContactAggregationContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContactCollection.VTable, self.vtable).FindFirst(@ptrCast(*const IContactAggregationContactCollection, self), ppItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContactCollection_FindNext(self: *const T, ppItem: ?*?*IContactAggregationContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContactCollection.VTable, self.vtable).FindNext(@ptrCast(*const IContactAggregationContactCollection, self), ppItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContactCollection_FindFirstByIdentityHash(self: *const T, pSourceType: ?[*:0]const u16, pAccountId: ?[*:0]const u16, pIdentityHash: ?*const CONTACT_AGGREGATION_BLOB, ppItem: ?*?*IContactAggregationContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContactCollection.VTable, self.vtable).FindFirstByIdentityHash(@ptrCast(*const IContactAggregationContactCollection, self), pSourceType, pAccountId, pIdentityHash, ppItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContactCollection_get_Count(self: *const T, pCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContactCollection.VTable, self.vtable).get_Count(@ptrCast(*const IContactAggregationContactCollection, self), pCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationContactCollection_FindFirstByRemoteId(self: *const T, pSourceType: ?[*:0]const u16, pAccountId: ?[*:0]const u16, pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB, ppItem: ?*?*IContactAggregationContact) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationContactCollection.VTable, self.vtable).FindFirstByRemoteId(@ptrCast(*const IContactAggregationContactCollection, self), pSourceType, pAccountId, pRemoteObjectId, ppItem);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationAggregate_Value = @import("../zig.zig").Guid.initString("7ed1c814-cd30-43c8-9b8d-2e489e53d54b");
pub const IID_IContactAggregationAggregate = &IID_IContactAggregationAggregate_Value;
pub const IContactAggregationAggregate = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Save: fn(
self: *const IContactAggregationAggregate,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetComponentItems: fn(
self: *const IContactAggregationAggregate,
pComponentItems: ?*?*IContactAggregationContactCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Link: fn(
self: *const IContactAggregationAggregate,
pAggregateId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Groups: fn(
self: *const IContactAggregationAggregate,
options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
ppGroups: ?*?*IContactAggregationGroupCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AntiLink: fn(
self: *const IContactAggregationAggregate,
ppAntiLink: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_AntiLink: fn(
self: *const IContactAggregationAggregate,
pAntiLink: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_FavoriteOrder: fn(
self: *const IContactAggregationAggregate,
pFavoriteOrder: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_FavoriteOrder: fn(
self: *const IContactAggregationAggregate,
favoriteOrder: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Id: fn(
self: *const IContactAggregationAggregate,
ppItemId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_Save(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).Save(@ptrCast(*const IContactAggregationAggregate, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_GetComponentItems(self: *const T, pComponentItems: ?*?*IContactAggregationContactCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).GetComponentItems(@ptrCast(*const IContactAggregationAggregate, self), pComponentItems);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_Link(self: *const T, pAggregateId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).Link(@ptrCast(*const IContactAggregationAggregate, self), pAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_get_Groups(self: *const T, options: CONTACT_AGGREGATION_COLLECTION_OPTIONS, ppGroups: ?*?*IContactAggregationGroupCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).get_Groups(@ptrCast(*const IContactAggregationAggregate, self), options, ppGroups);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_get_AntiLink(self: *const T, ppAntiLink: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).get_AntiLink(@ptrCast(*const IContactAggregationAggregate, self), ppAntiLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_put_AntiLink(self: *const T, pAntiLink: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).put_AntiLink(@ptrCast(*const IContactAggregationAggregate, self), pAntiLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_get_FavoriteOrder(self: *const T, pFavoriteOrder: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).get_FavoriteOrder(@ptrCast(*const IContactAggregationAggregate, self), pFavoriteOrder);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_put_FavoriteOrder(self: *const T, favoriteOrder: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).put_FavoriteOrder(@ptrCast(*const IContactAggregationAggregate, self), favoriteOrder);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregate_get_Id(self: *const T, ppItemId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregate.VTable, self.vtable).get_Id(@ptrCast(*const IContactAggregationAggregate, self), ppItemId);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationAggregateCollection_Value = @import("../zig.zig").Guid.initString("2359f3a6-3a68-40af-98db-0f9eb143c3bb");
pub const IID_IContactAggregationAggregateCollection = &IID_IContactAggregationAggregateCollection_Value;
pub const IContactAggregationAggregateCollection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
FindFirst: fn(
self: *const IContactAggregationAggregateCollection,
ppAggregate: ?*?*IContactAggregationAggregate,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindFirstByAntiLinkId: fn(
self: *const IContactAggregationAggregateCollection,
pAntiLinkId: ?[*:0]const u16,
ppAggregate: ?*?*IContactAggregationAggregate,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindNext: fn(
self: *const IContactAggregationAggregateCollection,
ppAggregate: ?*?*IContactAggregationAggregate,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const IContactAggregationAggregateCollection,
pCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregateCollection_FindFirst(self: *const T, ppAggregate: ?*?*IContactAggregationAggregate) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregateCollection.VTable, self.vtable).FindFirst(@ptrCast(*const IContactAggregationAggregateCollection, self), ppAggregate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregateCollection_FindFirstByAntiLinkId(self: *const T, pAntiLinkId: ?[*:0]const u16, ppAggregate: ?*?*IContactAggregationAggregate) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregateCollection.VTable, self.vtable).FindFirstByAntiLinkId(@ptrCast(*const IContactAggregationAggregateCollection, self), pAntiLinkId, ppAggregate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregateCollection_FindNext(self: *const T, ppAggregate: ?*?*IContactAggregationAggregate) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregateCollection.VTable, self.vtable).FindNext(@ptrCast(*const IContactAggregationAggregateCollection, self), ppAggregate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationAggregateCollection_get_Count(self: *const T, pCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationAggregateCollection.VTable, self.vtable).get_Count(@ptrCast(*const IContactAggregationAggregateCollection, self), pCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationGroup_Value = @import("../zig.zig").Guid.initString("c93c545f-1284-499b-96af-07372af473e0");
pub const IID_IContactAggregationGroup = &IID_IContactAggregationGroup_Value;
pub const IContactAggregationGroup = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Delete: fn(
self: *const IContactAggregationGroup,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Save: fn(
self: *const IContactAggregationGroup,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Add: fn(
self: *const IContactAggregationGroup,
pAggregateId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Remove: fn(
self: *const IContactAggregationGroup,
pAggregateId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Members: fn(
self: *const IContactAggregationGroup,
ppAggregateContactCollection: ?*?*IContactAggregationAggregateCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_GlobalObjectId: fn(
self: *const IContactAggregationGroup,
pGlobalObjectId: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_GlobalObjectId: fn(
self: *const IContactAggregationGroup,
pGlobalObjectId: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Id: fn(
self: *const IContactAggregationGroup,
ppItemId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Name: fn(
self: *const IContactAggregationGroup,
ppName: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Name: fn(
self: *const IContactAggregationGroup,
pName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_Delete(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).Delete(@ptrCast(*const IContactAggregationGroup, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_Save(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).Save(@ptrCast(*const IContactAggregationGroup, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_Add(self: *const T, pAggregateId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).Add(@ptrCast(*const IContactAggregationGroup, self), pAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_Remove(self: *const T, pAggregateId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).Remove(@ptrCast(*const IContactAggregationGroup, self), pAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_get_Members(self: *const T, ppAggregateContactCollection: ?*?*IContactAggregationAggregateCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).get_Members(@ptrCast(*const IContactAggregationGroup, self), ppAggregateContactCollection);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_get_GlobalObjectId(self: *const T, pGlobalObjectId: ?*Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).get_GlobalObjectId(@ptrCast(*const IContactAggregationGroup, self), pGlobalObjectId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_put_GlobalObjectId(self: *const T, pGlobalObjectId: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).put_GlobalObjectId(@ptrCast(*const IContactAggregationGroup, self), pGlobalObjectId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_get_Id(self: *const T, ppItemId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).get_Id(@ptrCast(*const IContactAggregationGroup, self), ppItemId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_get_Name(self: *const T, ppName: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).get_Name(@ptrCast(*const IContactAggregationGroup, self), ppName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroup_put_Name(self: *const T, pName: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroup.VTable, self.vtable).put_Name(@ptrCast(*const IContactAggregationGroup, self), pName);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationGroupCollection_Value = @import("../zig.zig").Guid.initString("20a19a9c-d2f3-4b83-9143-beffd2cc226d");
pub const IID_IContactAggregationGroupCollection = &IID_IContactAggregationGroupCollection_Value;
pub const IContactAggregationGroupCollection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
FindFirst: fn(
self: *const IContactAggregationGroupCollection,
ppGroup: ?*?*IContactAggregationGroup,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindFirstByGlobalObjectId: fn(
self: *const IContactAggregationGroupCollection,
pGlobalObjectId: ?*const Guid,
ppGroup: ?*?*IContactAggregationGroup,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindNext: fn(
self: *const IContactAggregationGroupCollection,
ppGroup: ?*?*IContactAggregationGroup,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const IContactAggregationGroupCollection,
pCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroupCollection_FindFirst(self: *const T, ppGroup: ?*?*IContactAggregationGroup) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroupCollection.VTable, self.vtable).FindFirst(@ptrCast(*const IContactAggregationGroupCollection, self), ppGroup);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroupCollection_FindFirstByGlobalObjectId(self: *const T, pGlobalObjectId: ?*const Guid, ppGroup: ?*?*IContactAggregationGroup) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroupCollection.VTable, self.vtable).FindFirstByGlobalObjectId(@ptrCast(*const IContactAggregationGroupCollection, self), pGlobalObjectId, ppGroup);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroupCollection_FindNext(self: *const T, ppGroup: ?*?*IContactAggregationGroup) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroupCollection.VTable, self.vtable).FindNext(@ptrCast(*const IContactAggregationGroupCollection, self), ppGroup);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationGroupCollection_get_Count(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationGroupCollection.VTable, self.vtable).get_Count(@ptrCast(*const IContactAggregationGroupCollection, self), pCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationLink_Value = @import("../zig.zig").Guid.initString("b6813323-a183-4654-8627-79b30de3a0ec");
pub const IID_IContactAggregationLink = &IID_IContactAggregationLink_Value;
pub const IContactAggregationLink = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Delete: fn(
self: *const IContactAggregationLink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Save: fn(
self: *const IContactAggregationLink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AccountId: fn(
self: *const IContactAggregationLink,
ppAccountId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_AccountId: fn(
self: *const IContactAggregationLink,
pAccountId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Id: fn(
self: *const IContactAggregationLink,
ppItemId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsLinkResolved: fn(
self: *const IContactAggregationLink,
pIsLinkResolved: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_IsLinkResolved: fn(
self: *const IContactAggregationLink,
isLinkResolved: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_NetworkSourceIdString: fn(
self: *const IContactAggregationLink,
ppNetworkSourceId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_NetworkSourceIdString: fn(
self: *const IContactAggregationLink,
pNetworkSourceId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_RemoteObjectId: fn(
self: *const IContactAggregationLink,
ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_RemoteObjectId: fn(
self: *const IContactAggregationLink,
pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ServerPerson: fn(
self: *const IContactAggregationLink,
ppServerPersonId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_ServerPerson: fn(
self: *const IContactAggregationLink,
pServerPersonId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ServerPersonBaseline: fn(
self: *const IContactAggregationLink,
ppServerPersonId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_ServerPersonBaseline: fn(
self: *const IContactAggregationLink,
pServerPersonId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_SyncIdentityHash: fn(
self: *const IContactAggregationLink,
ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_SyncIdentityHash: fn(
self: *const IContactAggregationLink,
pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_Delete(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).Delete(@ptrCast(*const IContactAggregationLink, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_Save(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).Save(@ptrCast(*const IContactAggregationLink, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_get_AccountId(self: *const T, ppAccountId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).get_AccountId(@ptrCast(*const IContactAggregationLink, self), ppAccountId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_put_AccountId(self: *const T, pAccountId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).put_AccountId(@ptrCast(*const IContactAggregationLink, self), pAccountId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_get_Id(self: *const T, ppItemId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).get_Id(@ptrCast(*const IContactAggregationLink, self), ppItemId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_get_IsLinkResolved(self: *const T, pIsLinkResolved: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).get_IsLinkResolved(@ptrCast(*const IContactAggregationLink, self), pIsLinkResolved);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_put_IsLinkResolved(self: *const T, isLinkResolved: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).put_IsLinkResolved(@ptrCast(*const IContactAggregationLink, self), isLinkResolved);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_get_NetworkSourceIdString(self: *const T, ppNetworkSourceId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).get_NetworkSourceIdString(@ptrCast(*const IContactAggregationLink, self), ppNetworkSourceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_put_NetworkSourceIdString(self: *const T, pNetworkSourceId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).put_NetworkSourceIdString(@ptrCast(*const IContactAggregationLink, self), pNetworkSourceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_get_RemoteObjectId(self: *const T, ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).get_RemoteObjectId(@ptrCast(*const IContactAggregationLink, self), ppRemoteObjectId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_put_RemoteObjectId(self: *const T, pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).put_RemoteObjectId(@ptrCast(*const IContactAggregationLink, self), pRemoteObjectId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_get_ServerPerson(self: *const T, ppServerPersonId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).get_ServerPerson(@ptrCast(*const IContactAggregationLink, self), ppServerPersonId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_put_ServerPerson(self: *const T, pServerPersonId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).put_ServerPerson(@ptrCast(*const IContactAggregationLink, self), pServerPersonId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_get_ServerPersonBaseline(self: *const T, ppServerPersonId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).get_ServerPersonBaseline(@ptrCast(*const IContactAggregationLink, self), ppServerPersonId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_put_ServerPersonBaseline(self: *const T, pServerPersonId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).put_ServerPersonBaseline(@ptrCast(*const IContactAggregationLink, self), pServerPersonId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_get_SyncIdentityHash(self: *const T, ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).get_SyncIdentityHash(@ptrCast(*const IContactAggregationLink, self), ppSyncIdentityHash);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLink_put_SyncIdentityHash(self: *const T, pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLink.VTable, self.vtable).put_SyncIdentityHash(@ptrCast(*const IContactAggregationLink, self), pSyncIdentityHash);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationLinkCollection_Value = @import("../zig.zig").Guid.initString("f8bc0e93-fb55-4f28-b9fa-b1c274153292");
pub const IID_IContactAggregationLinkCollection = &IID_IContactAggregationLinkCollection_Value;
pub const IContactAggregationLinkCollection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
FindFirst: fn(
self: *const IContactAggregationLinkCollection,
ppServerContactLink: ?*?*IContactAggregationLink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindFirstByRemoteId: fn(
self: *const IContactAggregationLinkCollection,
pSourceType: ?[*:0]const u16,
pAccountId: ?[*:0]const u16,
pRemoteId: ?*const CONTACT_AGGREGATION_BLOB,
ppServerContactLink: ?*?*IContactAggregationLink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindNext: fn(
self: *const IContactAggregationLinkCollection,
ppServerContactLink: ?*?*IContactAggregationLink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const IContactAggregationLinkCollection,
pCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLinkCollection_FindFirst(self: *const T, ppServerContactLink: ?*?*IContactAggregationLink) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLinkCollection.VTable, self.vtable).FindFirst(@ptrCast(*const IContactAggregationLinkCollection, self), ppServerContactLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLinkCollection_FindFirstByRemoteId(self: *const T, pSourceType: ?[*:0]const u16, pAccountId: ?[*:0]const u16, pRemoteId: ?*const CONTACT_AGGREGATION_BLOB, ppServerContactLink: ?*?*IContactAggregationLink) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLinkCollection.VTable, self.vtable).FindFirstByRemoteId(@ptrCast(*const IContactAggregationLinkCollection, self), pSourceType, pAccountId, pRemoteId, ppServerContactLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLinkCollection_FindNext(self: *const T, ppServerContactLink: ?*?*IContactAggregationLink) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLinkCollection.VTable, self.vtable).FindNext(@ptrCast(*const IContactAggregationLinkCollection, self), ppServerContactLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationLinkCollection_get_Count(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationLinkCollection.VTable, self.vtable).get_Count(@ptrCast(*const IContactAggregationLinkCollection, self), pCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationServerPerson_Value = @import("../zig.zig").Guid.initString("7fdc3d4b-1b82-4334-85c5-25184ee5a5f2");
pub const IID_IContactAggregationServerPerson = &IID_IContactAggregationServerPerson_Value;
pub const IContactAggregationServerPerson = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Delete: fn(
self: *const IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Save: fn(
self: *const IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AggregateId: fn(
self: *const IContactAggregationServerPerson,
ppAggregateId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_AggregateId: fn(
self: *const IContactAggregationServerPerson,
pAggregateId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AntiLink: fn(
self: *const IContactAggregationServerPerson,
ppAntiLink: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_AntiLink: fn(
self: *const IContactAggregationServerPerson,
pAntiLink: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AntiLinkBaseline: fn(
self: *const IContactAggregationServerPerson,
ppAntiLink: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_AntiLinkBaseline: fn(
self: *const IContactAggregationServerPerson,
pAntiLink: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_FavoriteOrder: fn(
self: *const IContactAggregationServerPerson,
pFavoriteOrder: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_FavoriteOrder: fn(
self: *const IContactAggregationServerPerson,
favoriteOrder: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_FavoriteOrderBaseline: fn(
self: *const IContactAggregationServerPerson,
pFavoriteOrder: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_FavoriteOrderBaseline: fn(
self: *const IContactAggregationServerPerson,
favoriteOrder: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Groups: fn(
self: *const IContactAggregationServerPerson,
pGroups: ?*?*CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Groups: fn(
self: *const IContactAggregationServerPerson,
pGroups: ?*const CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_GroupsBaseline: fn(
self: *const IContactAggregationServerPerson,
ppGroups: ?*?*CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_GroupsBaseline: fn(
self: *const IContactAggregationServerPerson,
pGroups: ?*const CONTACT_AGGREGATION_BLOB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Id: fn(
self: *const IContactAggregationServerPerson,
ppId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsTombstone: fn(
self: *const IContactAggregationServerPerson,
pIsTombstone: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_IsTombstone: fn(
self: *const IContactAggregationServerPerson,
isTombstone: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_LinkedAggregateId: fn(
self: *const IContactAggregationServerPerson,
ppLinkedAggregateId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_LinkedAggregateId: fn(
self: *const IContactAggregationServerPerson,
pLinkedAggregateId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ObjectId: fn(
self: *const IContactAggregationServerPerson,
ppObjectId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_ObjectId: fn(
self: *const IContactAggregationServerPerson,
pObjectId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_Delete(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).Delete(@ptrCast(*const IContactAggregationServerPerson, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_Save(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).Save(@ptrCast(*const IContactAggregationServerPerson, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_AggregateId(self: *const T, ppAggregateId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_AggregateId(@ptrCast(*const IContactAggregationServerPerson, self), ppAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_AggregateId(self: *const T, pAggregateId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_AggregateId(@ptrCast(*const IContactAggregationServerPerson, self), pAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_AntiLink(self: *const T, ppAntiLink: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_AntiLink(@ptrCast(*const IContactAggregationServerPerson, self), ppAntiLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_AntiLink(self: *const T, pAntiLink: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_AntiLink(@ptrCast(*const IContactAggregationServerPerson, self), pAntiLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_AntiLinkBaseline(self: *const T, ppAntiLink: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_AntiLinkBaseline(@ptrCast(*const IContactAggregationServerPerson, self), ppAntiLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_AntiLinkBaseline(self: *const T, pAntiLink: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_AntiLinkBaseline(@ptrCast(*const IContactAggregationServerPerson, self), pAntiLink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_FavoriteOrder(self: *const T, pFavoriteOrder: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_FavoriteOrder(@ptrCast(*const IContactAggregationServerPerson, self), pFavoriteOrder);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_FavoriteOrder(self: *const T, favoriteOrder: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_FavoriteOrder(@ptrCast(*const IContactAggregationServerPerson, self), favoriteOrder);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_FavoriteOrderBaseline(self: *const T, pFavoriteOrder: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_FavoriteOrderBaseline(@ptrCast(*const IContactAggregationServerPerson, self), pFavoriteOrder);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_FavoriteOrderBaseline(self: *const T, favoriteOrder: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_FavoriteOrderBaseline(@ptrCast(*const IContactAggregationServerPerson, self), favoriteOrder);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_Groups(self: *const T, pGroups: ?*?*CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_Groups(@ptrCast(*const IContactAggregationServerPerson, self), pGroups);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_Groups(self: *const T, pGroups: ?*const CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_Groups(@ptrCast(*const IContactAggregationServerPerson, self), pGroups);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_GroupsBaseline(self: *const T, ppGroups: ?*?*CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_GroupsBaseline(@ptrCast(*const IContactAggregationServerPerson, self), ppGroups);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_GroupsBaseline(self: *const T, pGroups: ?*const CONTACT_AGGREGATION_BLOB) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_GroupsBaseline(@ptrCast(*const IContactAggregationServerPerson, self), pGroups);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_Id(self: *const T, ppId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_Id(@ptrCast(*const IContactAggregationServerPerson, self), ppId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_IsTombstone(self: *const T, pIsTombstone: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_IsTombstone(@ptrCast(*const IContactAggregationServerPerson, self), pIsTombstone);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_IsTombstone(self: *const T, isTombstone: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_IsTombstone(@ptrCast(*const IContactAggregationServerPerson, self), isTombstone);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_LinkedAggregateId(self: *const T, ppLinkedAggregateId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_LinkedAggregateId(@ptrCast(*const IContactAggregationServerPerson, self), ppLinkedAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_LinkedAggregateId(self: *const T, pLinkedAggregateId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_LinkedAggregateId(@ptrCast(*const IContactAggregationServerPerson, self), pLinkedAggregateId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_get_ObjectId(self: *const T, ppObjectId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).get_ObjectId(@ptrCast(*const IContactAggregationServerPerson, self), ppObjectId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPerson_put_ObjectId(self: *const T, pObjectId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPerson.VTable, self.vtable).put_ObjectId(@ptrCast(*const IContactAggregationServerPerson, self), pObjectId);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IContactAggregationServerPersonCollection_Value = @import("../zig.zig").Guid.initString("4f730a4a-6604-47b6-a987-669ecf1e5751");
pub const IID_IContactAggregationServerPersonCollection = &IID_IContactAggregationServerPersonCollection_Value;
pub const IContactAggregationServerPersonCollection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
FindFirst: fn(
self: *const IContactAggregationServerPersonCollection,
ppServerPerson: ?*?*IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindFirstByServerId: fn(
self: *const IContactAggregationServerPersonCollection,
pServerId: ?[*:0]const u16,
ppServerPerson: ?*?*IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindFirstByAggregateId: fn(
self: *const IContactAggregationServerPersonCollection,
pAggregateId: ?[*:0]const u16,
ppServerPerson: ?*?*IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindFirstByLinkedAggregateId: fn(
self: *const IContactAggregationServerPersonCollection,
pAggregateId: ?[*:0]const u16,
ppServerPerson: ?*?*IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindNext: fn(
self: *const IContactAggregationServerPersonCollection,
ppServerPerson: ?*?*IContactAggregationServerPerson,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const IContactAggregationServerPersonCollection,
pCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPersonCollection_FindFirst(self: *const T, ppServerPerson: ?*?*IContactAggregationServerPerson) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPersonCollection.VTable, self.vtable).FindFirst(@ptrCast(*const IContactAggregationServerPersonCollection, self), ppServerPerson);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPersonCollection_FindFirstByServerId(self: *const T, pServerId: ?[*:0]const u16, ppServerPerson: ?*?*IContactAggregationServerPerson) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPersonCollection.VTable, self.vtable).FindFirstByServerId(@ptrCast(*const IContactAggregationServerPersonCollection, self), pServerId, ppServerPerson);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPersonCollection_FindFirstByAggregateId(self: *const T, pAggregateId: ?[*:0]const u16, ppServerPerson: ?*?*IContactAggregationServerPerson) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPersonCollection.VTable, self.vtable).FindFirstByAggregateId(@ptrCast(*const IContactAggregationServerPersonCollection, self), pAggregateId, ppServerPerson);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPersonCollection_FindFirstByLinkedAggregateId(self: *const T, pAggregateId: ?[*:0]const u16, ppServerPerson: ?*?*IContactAggregationServerPerson) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPersonCollection.VTable, self.vtable).FindFirstByLinkedAggregateId(@ptrCast(*const IContactAggregationServerPersonCollection, self), pAggregateId, ppServerPerson);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPersonCollection_FindNext(self: *const T, ppServerPerson: ?*?*IContactAggregationServerPerson) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPersonCollection.VTable, self.vtable).FindNext(@ptrCast(*const IContactAggregationServerPersonCollection, self), ppServerPerson);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IContactAggregationServerPersonCollection_get_Count(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IContactAggregationServerPersonCollection.VTable, self.vtable).get_Count(@ptrCast(*const IContactAggregationServerPersonCollection, self), pCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (0)
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (7)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const FILETIME = @import("../foundation.zig").FILETIME;
const HRESULT = @import("../foundation.zig").HRESULT;
const IStream = @import("../system/com.zig").IStream;
const IUnknown = @import("../system/com.zig").IUnknown;
const PWSTR = @import("../foundation.zig").PWSTR;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/system/contacts.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const file = @embedFile("../input.txt");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const output = part1(&gpa.allocator, file);
print("total: {}\n", .{output});
}
const Operator = enum {
add,
multiply,
left_paren,
};
const Token = union(enum) {
number: u8,
operator: Operator,
};
fn part1(allocator: *Allocator, contents: []const u8) !u64 {
var sum: u64 = 0;
var line_iterator = std.mem.tokenize(contents, "\n");
while (line_iterator.next()) |line| {
var output = std.fifo.LinearFifo(Token, .Dynamic).init(allocator);
defer output.deinit();
var operator_stack = std.ArrayList(Operator).init(allocator);
defer operator_stack.deinit();
for (line) |char| {
switch (char) {
'0'...'9' => {
try output.writeItem(.{ .number = char - '0' });
},
'+', '*' => {
while (operator_stack.items.len > 0 and operator_stack.items[operator_stack.items.len - 1] != .left_paren) {
try output.writeItem(.{ .operator = operator_stack.pop() });
}
const op = if (char == '+') Operator.add else Operator.multiply;
try operator_stack.append(op);
},
'(' => {
try operator_stack.append(.left_paren);
},
')' => {
while (operator_stack.items.len > 0 and operator_stack.items[operator_stack.items.len - 1] != .left_paren) {
try output.writeItem(.{ .operator = operator_stack.pop() });
}
if (operator_stack.items.len > 0 and operator_stack.items[operator_stack.items.len - 1] == .left_paren) {
_ = operator_stack.pop();
}
},
else => {},
}
}
while (operator_stack.popOrNull()) |token| try output.writeItem(.{ .operator = token });
var stack = std.ArrayList(u64).init(allocator);
defer stack.deinit();
while (output.readItem()) |token| {
switch (token) {
.number => |num| try stack.append(num),
.operator => |op| {
var first = stack.pop();
var second = stack.pop();
switch (op) {
.add => try stack.append(first + second),
.multiply => try stack.append(first * second),
.left_paren => unreachable,
}
},
}
}
std.debug.assert(stack.items.len == 1);
sum += stack.pop();
}
return sum;
}
const testing = std.testing;
test "test strings" {
const alloc = testing.allocator;
testing.expectEqual(@intCast(u64, 71), try part1(alloc, "1 + 2 * 3 + 4 * 5 + 6"));
testing.expectEqual(@intCast(u64, 51), try part1(alloc, "1 + (2 * 3) + (4 * (5 + 6))"));
testing.expectEqual(@intCast(u64, 26), try part1(alloc, "2 * 3 + (4 * 5)"));
testing.expectEqual(@intCast(u64, 437), try part1(alloc, "5 + (8 * 3 + 9 + 3 * 4 * 3)"));
testing.expectEqual(@intCast(u64, 12240), try part1(alloc, "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))"));
testing.expectEqual(@intCast(u64, 13632), try part1(alloc, "((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2"));
} | 2020/day18/zig/day18.zig |
const builtin = @import("builtin");
const std = @import("std");
const json = std.json;
const mem = std.mem;
const meta = std.meta;
const warn = std.debug.warn;
/// encode takes a value and returns json.Value that can be marshalled to json
/// object. This limits on which objects can be marshalled and also supports
/// custom encoding for objects.
///
/// Valid values supported are
/// ```
/// Integers => any integer that can be casted to i64
/// Floats => any float that can be casted to f64
/// Structs,
/// Enums,
/// Optionals.
/// HashMap => keys must be string
/// ```
/// Also Pointers to any valid objects works fine. Including Arrays,Slices of
/// valid objects.
pub fn encode(
a: *mem.Allocator,
value: var,
) anyerror!json.Value {
const T = @typeOf(value);
switch (@typeInfo(T)) {
.Int => |elem| {
return json.Value{ .Integer = @intCast(i64, value) };
},
.Float => |elem| {
return json.Value{ .Float = @intCast(f64, value) };
},
.Bool => {
if (value) {
return json.Value{ .Bool = true };
}
return json.Value{ .Bool = false };
},
.Struct => |elem| {
const has_cust_encode = comptime implementsEncoder(T);
if (has_cust_encode) return value.encodeJson(a);
const is_array_list = comptime check_array_list(T);
if (is_array_list) return encode(a, value.toSlice());
var m = json.ObjectMap.init(a);
comptime var i: usize = 0;
inline while (i < elem.fields.len) : (i += 1) {
const field = elem.fields[i];
if (validValue(field.field_type)) {
if (@typeId(field.field_type) == .Optional) {
if (@field(value, field.name)) |optional_value| {
if (validValue(@typeOf(optional_value))) {
_ = try m.put(field.name, try encode(a, optional_value));
}
}
} else {
_ = try m.put(field.name, try encode(a, @field(value, field.name)));
}
}
}
return json.Value{ .Object = m };
},
.Pointer => |pointer| {
switch (pointer.size) {
.One => {
return encode(a, value.*);
},
.Slice => {
var ls = std.ArrayList(json.Value).init(a);
for (value) |elem| {
try ls.append(try encode(a, elem));
}
return json.Value{ .Array = ls };
},
else => {
return error.NotSupported;
},
}
},
else => {
warn("{}\n", @typeId(T));
return error.NotSupported;
},
}
}
fn implementsEncoder(comptime T: type) bool {
return meta.trait.hasFn("encodeJson")(T);
}
const check_array_list = meta.trait.multiTrait(
meta.trait.TraitList{
meta.trait.hasFn("toSlice"),
meta.trait.hasField("len"),
meta.trait.hasField("items"),
meta.trait.hasField("allocator"),
},
);
/// Returns true if T is a valid value for encoding and false aotherwise.
fn validValue(comptime T: type) bool {
switch (@typeId(T)) {
.Int,
.Float,
.Bool,
.Pointer,
.Array,
.Struct,
.Optional,
=> return true,
else => {
return false;
},
}
}
test "encode" {
var a = std.debug.global_allocator;
const Int = struct {
value: usize,
};
warn("\n");
try testEncode(a, Int{ .value = 12 });
// try testEncode(a, &Int{ .value = 12 });
const Nested = struct {
const Self = @This();
pub fn encodeJson(self: Self, alloc: *mem.Allocator) anyerror!json.Value {
return json.Value{ .String = "okay" };
}
};
try testEncode(a, Nested{});
const NestedPtr = struct {
value: usize,
child: *Int,
};
try testEncode(a, NestedPtr{
.value = 12,
.child = &Int{ .value = 12 },
});
const Bool = struct {
value: bool,
};
// try testEncode(a, Bool{ .value = true });
// try testEncode(a, Bool{ .value = false });
const List = std.ArrayList(Bool);
var list = List.init(a);
try list.append(Bool{ .value = true });
try testEncode(a, list);
const Optional = struct {
maybe: ?bool,
};
try testEncode(a, Optional{ .maybe = null });
try testEncode(a, Optional{ .maybe = true });
}
fn testEncode(
a: *mem.Allocator,
value: var,
) !void {
var arena = std.heap.ArenaAllocator.init(a);
defer arena.deinit();
var v = try encode(&arena.allocator, value);
v.dump();
warn("\n");
} | src/lsp/protocol/encoding.zig |
const std = @import("std");
const IR = @import("../IR.zig");
pub const External = std.wasm.ExternalKind;
inline fn nextExternal(e: External) External {
if (e == .global) return e;
return @intToEnum(External, @enumToInt(e) + 1);
}
pub const Import = struct {
m: *const IR.Module,
state: External = .function,
offset: usize = 0,
const Point = struct {
key: IR.ImportName,
kind: External,
index: usize,
};
pub fn next(self: *Import) ?Point {
return switch (self.state) {
.function => self.nextN("funcs"),
.table => self.nextN("tables"),
.memory => if (self.offset == 0 and self.m.memory != null and self.m.memory.?.import != null) {
self.offset += 1;
return Point{ .key = self.m.memory.?.import.?, .kind = .memory, .index = 0 };
} else {
self.state = nextExternal(self.state);
self.offset = 0;
return self.next();
},
.global => self.nextN("globals"),
};
}
inline fn nextN(self: *Import, comptime fname: []const u8) ?Point {
const slice = @field(self.m, fname);
while (self.offset < slice.len) {
const index = self.offset;
const body = slice[index].body;
self.offset += 1;
switch (body) {
.import => |key| return Point{ .key = key, .kind = self.state, .index = index },
else => {},
}
}
if (self.state == .global) return null;
self.state = nextExternal(self.state);
self.offset = 0;
return self.next();
}
};
pub const Export = struct {
m: *const IR.Module,
state: External = .function,
offset: struct {
field: usize = 0,
expor: usize = 0,
} = .{},
const Point = struct {
key: IR.ExportName,
kind: External,
index: usize,
};
pub fn next(self: *Export) ?Point {
return switch (self.state) {
.function => self.nextN("funcs"),
.table => self.nextN("tables"),
.memory => if (self.offset.field == 0 and self.m.memory != null and self.offset.expor < self.m.memory.?.exports.len) {
const key = self.m.memory.?.exports[self.offset.expor];
self.offset.expor += 1;
return Point{ .key = key, .kind = .memory, .index = 0 };
} else {
self.state = nextExternal(self.state);
self.offset = .{};
return self.next();
},
.global => self.nextN("globals"),
};
}
inline fn nextN(self: *Export, comptime fname: []const u8) ?Point {
const slice = @field(self.m, fname);
while (self.offset.field < slice.len) {
const exps = slice[self.offset.field].exports;
if (self.offset.expor < exps.len) {
const key = exps[self.offset.expor];
self.offset.expor += 1;
return Point{ .key = key, .kind = self.state, .index = self.offset.field };
}
self.offset.expor = 0;
self.offset.field += 1;
}
if (self.state == .global) return null;
self.state = nextExternal(self.state);
self.offset.field = 0;
return self.next();
}
}; | src/IR/iters.zig |
const std = @import("std");
const windows = @import("windows.zig");
const dxgi = @import("dxgi.zig");
const d3d = @import("d3dcommon.zig");
const UINT = windows.UINT;
const IUnknown = windows.IUnknown;
const HRESULT = windows.HRESULT;
const GUID = windows.GUID;
const LUID = windows.LUID;
const WINAPI = windows.WINAPI;
const FLOAT = windows.FLOAT;
const LPCWSTR = windows.LPCWSTR;
const LPCSTR = windows.LPCSTR;
const UINT8 = windows.UINT8;
const UINT16 = windows.UINT16;
const UINT32 = windows.UINT32;
const UINT64 = windows.UINT64;
const INT = windows.INT;
const INT8 = windows.INT8;
const BYTE = windows.BYTE;
const DWORD = windows.DWORD;
const SIZE_T = windows.SIZE_T;
const HANDLE = windows.HANDLE;
const SECURITY_ATTRIBUTES = windows.SECURITY_ATTRIBUTES;
const BOOL = windows.BOOL;
const FALSE = windows.FALSE;
const TRUE = windows.TRUE;
pub const RESOURCE_BARRIER_ALL_SUBRESOURCES = 0xffff_ffff;
pub const SHADER_IDENTIFIER_SIZE_IN_BYTES = 32;
pub const GPU_VIRTUAL_ADDRESS = UINT64;
pub const PRIMITIVE_TOPOLOGY = d3d.PRIMITIVE_TOPOLOGY;
pub const CPU_DESCRIPTOR_HANDLE = extern struct {
ptr: UINT64,
};
pub const GPU_DESCRIPTOR_HANDLE = extern struct {
ptr: UINT64,
};
pub const PRIMITIVE_TOPOLOGY_TYPE = enum(UINT) {
UNDEFINED = 0,
POINT = 1,
LINE = 2,
TRIANGLE = 3,
PATCH = 4,
};
pub const HEAP_TYPE = enum(UINT) {
DEFAULT = 1,
UPLOAD = 2,
READBACK = 3,
CUSTOM = 4,
};
pub const CPU_PAGE_PROPERTY = enum(UINT) {
UNKNOWN = 0,
NOT_AVAILABLE = 1,
WRITE_COMBINE = 2,
WRITE_BACK = 3,
};
pub const MEMORY_POOL = enum(UINT) {
UNKNOWN = 0,
L0 = 1,
L1 = 2,
};
pub const HEAP_PROPERTIES = extern struct {
Type: HEAP_TYPE,
CPUPageProperty: CPU_PAGE_PROPERTY,
MemoryPoolPreference: MEMORY_POOL,
CreationNodeMask: UINT,
VisibleNodeMask: UINT,
pub fn initType(heap_type: HEAP_TYPE) HEAP_PROPERTIES {
var v = std.mem.zeroes(@This());
v = HEAP_PROPERTIES{
.Type = heap_type,
.CPUPageProperty = .UNKNOWN,
.MemoryPoolPreference = .UNKNOWN,
.CreationNodeMask = 0,
.VisibleNodeMask = 0,
};
return v;
}
};
pub const HEAP_FLAGS = UINT;
pub const HEAP_FLAG_NONE = 0;
pub const HEAP_FLAG_SHARED = 0x1;
pub const HEAP_FLAG_DENY_BUFFERS = 0x4;
pub const HEAP_FLAG_ALLOW_DISPLAY = 0x8;
pub const HEAP_FLAG_SHARED_CROSS_ADAPTER = 0x20;
pub const HEAP_FLAG_DENY_RT_DS_TEXTURES = 0x40;
pub const HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 0x80;
pub const HEAP_FLAG_HARDWARE_PROTECTED = 0x100;
pub const HEAP_FLAG_ALLOW_WRITE_WATCH = 0x200;
pub const HEAP_FLAG_ALLOW_SHADER_ATOMICS = 0x400;
pub const HEAP_FLAG_CREATE_NOT_RESIDENT = 0x800;
pub const HEAP_FLAG_CREATE_NOT_ZEROED = 0x1000;
pub const HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0;
pub const HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0;
pub const HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44;
pub const HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 0x84;
pub const HEAP_DESC = extern struct {
SizeInBytes: UINT64,
Properties: HEAP_PROPERTIES,
Alignment: UINT64,
Flags: HEAP_FLAGS,
};
pub const RANGE = extern struct {
Begin: UINT64,
End: UINT64,
};
pub const BOX = extern struct {
left: UINT,
top: UINT,
front: UINT,
right: UINT,
bottom: UINT,
back: UINT,
};
pub const RESOURCE_DIMENSION = enum(UINT) {
UNKNOWN = 0,
BUFFER = 1,
TEXTURE1D = 2,
TEXTURE2D = 3,
TEXTURE3D = 4,
};
pub const TEXTURE_LAYOUT = enum(UINT) {
UNKNOWN = 0,
ROW_MAJOR = 1,
_64KB_UNDEFINED_SWIZZLE = 2,
_64KB_STANDARD_SWIZZLE = 3,
};
pub const RESOURCE_FLAGS = UINT;
pub const RESOURCE_FLAG_NONE = 0;
pub const RESOURCE_FLAG_ALLOW_RENDER_TARGET = 0x1;
pub const RESOURCE_FLAG_ALLOW_DEPTH_STENCIL = 0x2;
pub const RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS = 0x4;
pub const RESOURCE_FLAG_DENY_SHADER_RESOURCE = 0x8;
pub const RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = 0x10;
pub const RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 0x20;
pub const RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = 0x40;
pub const RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY = 0x80;
pub const RESOURCE_DESC = extern struct {
Dimension: RESOURCE_DIMENSION,
Alignment: UINT64,
Width: UINT64,
Height: UINT,
DepthOrArraySize: UINT16,
MipLevels: UINT16,
Format: dxgi.FORMAT,
SampleDesc: dxgi.SAMPLE_DESC,
Layout: TEXTURE_LAYOUT,
Flags: RESOURCE_FLAGS,
pub fn initBuffer(width: UINT64) RESOURCE_DESC {
var v = std.mem.zeroes(@This());
v = .{
.Dimension = .BUFFER,
.Alignment = 0,
.Width = width,
.Height = 1,
.DepthOrArraySize = 1,
.MipLevels = 1,
.Format = .UNKNOWN,
.SampleDesc = .{ .Count = 1, .Quality = 0 },
.Layout = .ROW_MAJOR,
.Flags = RESOURCE_FLAG_NONE,
};
return v;
}
pub fn initTex2d(format: dxgi.FORMAT, width: UINT64, height: UINT, mip_levels: u32) RESOURCE_DESC {
var v = std.mem.zeroes(@This());
v = .{
.Dimension = .TEXTURE2D,
.Alignment = 0,
.Width = width,
.Height = height,
.DepthOrArraySize = 1,
.MipLevels = @intCast(u16, mip_levels),
.Format = format,
.SampleDesc = .{ .Count = 1, .Quality = 0 },
.Layout = .UNKNOWN,
.Flags = RESOURCE_FLAG_NONE,
};
return v;
}
};
pub const FENCE_FLAGS = UINT;
pub const FENCE_FLAG_NONE = 0;
pub const FENCE_FLAG_SHARED = 0x1;
pub const FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2;
pub const FENCE_FLAG_NON_MONITORED = 0x4;
pub const DESCRIPTOR_HEAP_TYPE = enum(UINT) {
CBV_SRV_UAV = 0,
SAMPLER = 1,
RTV = 2,
DSV = 3,
};
pub const DESCRIPTOR_HEAP_FLAGS = UINT;
pub const DESCRIPTOR_HEAP_FLAG_NONE = 0;
pub const DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 0x1;
pub const DESCRIPTOR_HEAP_DESC = extern struct {
Type: DESCRIPTOR_HEAP_TYPE,
NumDescriptors: UINT,
Flags: DESCRIPTOR_HEAP_FLAGS,
NodeMask: UINT,
};
pub const DESCRIPTOR_RANGE_TYPE = enum(UINT) {
SRV = 0,
UAV = 1,
CBV = 2,
SAMPLER = 3,
};
pub const DESCRIPTOR_RANGE = extern struct {
RangeType: DESCRIPTOR_RANGE_TYPE,
NumDescriptors: UINT,
BaseShaderRegister: UINT,
RegisterSpace: UINT,
OffsetInDescriptorsFromStart: UINT,
};
pub const ROOT_DESCRIPTOR_TABLE = extern struct {
NumDescriptorRanges: UINT,
pDescriptorRanges: ?[*]const DESCRIPTOR_RANGE,
};
pub const ROOT_CONSTANTS = extern struct {
ShaderRegister: UINT,
RegisterSpace: UINT,
Num32BitValues: UINT,
};
pub const ROOT_DESCRIPTOR = extern struct {
ShaderRegister: UINT,
RegisterSpace: UINT,
};
pub const ROOT_PARAMETER_TYPE = enum(UINT) {
DESCRIPTOR_TABLE = 0,
_32BIT_CONSTANTS = 1,
CBV = 2,
SRV = 3,
UAV = 4,
};
pub const SHADER_VISIBILITY = enum(UINT) {
ALL = 0,
VERTEX = 1,
HULL = 2,
DOMAIN = 3,
GEOMETRY = 4,
PIXEL = 5,
AMPLIFICATION = 6,
MESH = 7,
};
pub const ROOT_PARAMETER = extern struct {
ParameterType: ROOT_PARAMETER_TYPE,
u: extern union {
DescriptorTable: ROOT_DESCRIPTOR_TABLE,
Constants: ROOT_CONSTANTS,
Descriptor: ROOT_DESCRIPTOR,
},
ShaderVisibility: SHADER_VISIBILITY,
};
pub const STATIC_BORDER_COLOR = enum(UINT) {
TRANSPARENT_BLACK = 0,
OPAQUE_BLACK = 1,
OPAQUE_WHITE = 2,
};
pub const STATIC_SAMPLER_DESC = extern struct {
Filter: FILTER,
AddressU: TEXTURE_ADDRESS_MODE,
AddressV: TEXTURE_ADDRESS_MODE,
AddressW: TEXTURE_ADDRESS_MODE,
MipLODBias: FLOAT,
MaxAnisotropy: UINT,
ComparisonFunc: COMPARISON_FUNC,
BorderColor: STATIC_BORDER_COLOR,
MinLOD: FLOAT,
MaxLOD: FLOAT,
ShaderRegister: UINT,
RegisterSpace: UINT,
ShaderVisibility: SHADER_VISIBILITY,
};
pub const ROOT_SIGNATURE_FLAGS = UINT;
pub const ROOT_SIGNATURE_FLAG_NONE: ROOT_SIGNATURE_FLAGS = 0;
pub const ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT: ROOT_SIGNATURE_FLAGS = 0x1;
pub const ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS: ROOT_SIGNATURE_FLAGS = 0x2;
pub const ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS: ROOT_SIGNATURE_FLAGS = 0x4;
pub const ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS: ROOT_SIGNATURE_FLAGS = 0x8;
pub const ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS: ROOT_SIGNATURE_FLAGS = 0x10;
pub const ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS: ROOT_SIGNATURE_FLAGS = 0x20;
pub const ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT: ROOT_SIGNATURE_FLAGS = 0x40;
pub const ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE: ROOT_SIGNATURE_FLAGS = 0x80;
pub const ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS: ROOT_SIGNATURE_FLAGS = 0x100;
pub const ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS: ROOT_SIGNATURE_FLAGS = 0x200;
pub const ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED: ROOT_SIGNATURE_FLAGS = 0x400;
pub const ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED: ROOT_SIGNATURE_FLAGS = 0x800;
pub const ROOT_SIGNATURE_DESC = extern struct {
NumParamenters: UINT,
pParameters: ?[*]const ROOT_PARAMETER,
NumStaticSamplers: UINT,
pStaticSamplers: ?[*]const STATIC_SAMPLER_DESC,
Flags: ROOT_SIGNATURE_FLAGS,
};
pub const DESCRIPTOR_RANGE_FLAGS = UINT;
pub const DESCRIPTOR_RANGE_FLAG_NONE: DESCRIPTOR_RANGE_FLAGS = 0;
pub const DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE: DESCRIPTOR_RANGE_FLAGS = 0x1;
pub const DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE: DESCRIPTOR_RANGE_FLAGS = 0x2;
pub const DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE: DESCRIPTOR_RANGE_FLAGS = 0x4;
pub const DESCRIPTOR_RANGE_FLAG_DATA_STATIC: DESCRIPTOR_RANGE_FLAGS = 0x8;
pub const DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: DESCRIPTOR_RANGE_FLAGS = 0x10000;
pub const DESCRIPTOR_RANGE1 = extern struct {
RangeType: DESCRIPTOR_RANGE_TYPE,
NumDescriptors: UINT,
BaseShaderRegister: UINT,
RegisterSpace: UINT,
Flags: DESCRIPTOR_RANGE_FLAGS,
OffsetInDescriptorsFromTableStart: UINT,
};
pub const ROOT_DESCRIPTOR_TABLE1 = extern struct {
NumDescriptorRanges: UINT,
pDescriptorRanges: ?[*]const DESCRIPTOR_RANGE1,
};
pub const ROOT_DESCRIPTOR_FLAGS = UINT;
pub const ROOT_DESCRIPTOR_FLAG_NONE: ROOT_DESCRIPTOR_FLAGS = 0;
pub const ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE: ROOT_DESCRIPTOR_FLAGS = 0x2;
pub const ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE: ROOT_DESCRIPTOR_FLAGS = 0x4;
pub const ROOT_DESCRIPTOR_FLAG_DATA_STATIC: ROOT_DESCRIPTOR_FLAGS = 0x8;
pub const ROOT_DESCRIPTOR1 = extern struct {
ShaderRegister: UINT,
RegisterSpace: UINT,
Flags: ROOT_DESCRIPTOR_FLAGS,
};
pub const ROOT_PARAMETER1 = extern struct {
ParameterType: ROOT_PARAMETER_TYPE,
u: extern union {
DescriptorTable: ROOT_DESCRIPTOR_TABLE1,
Constants: ROOT_CONSTANTS,
Descriptor: ROOT_DESCRIPTOR1,
},
ShaderVisibility: SHADER_VISIBILITY,
};
pub const ROOT_SIGNATURE_DESC1 = extern struct {
NumParamenters: UINT,
pParameters: ?[*]const ROOT_PARAMETER1,
NumStaticSamplers: UINT,
pStaticSamplers: ?[*]const STATIC_SAMPLER_DESC,
Flags: ROOT_SIGNATURE_FLAGS,
};
pub const ROOT_SIGNATURE_VERSION = enum(UINT) {
VERSION_1_0 = 0x1,
VERSION_1_1 = 0x2,
};
pub const VERSIONED_ROOT_SIGNATURE_DESC = extern struct {
Version: ROOT_SIGNATURE_VERSION,
u: extern union {
Desc_1_0: ROOT_SIGNATURE_DESC,
Desc_1_1: ROOT_SIGNATURE_DESC1,
},
};
pub const COMMAND_LIST_TYPE = enum(UINT) {
DIRECT = 0,
BUNDLE = 1,
COMPUTE = 2,
COPY = 3,
VIDEO_DECODE = 4,
VIDEO_PROCESS = 5,
VIDEO_ENCODE = 6,
};
pub const RESOURCE_BARRIER_TYPE = enum(UINT) {
TRANSITION = 0,
ALIASING = 1,
UAV = 2,
};
pub const RESOURCE_TRANSITION_BARRIER = extern struct {
pResource: *IResource,
Subresource: UINT,
StateBefore: RESOURCE_STATES,
StateAfter: RESOURCE_STATES,
};
pub const RESOURCE_ALIASING_BARRIER = extern struct {
pResourceBefore: *IResource,
pResourceAfter: *IResource,
};
pub const RESOURCE_UAV_BARRIER = extern struct {
pResource: *IResource,
};
pub const RESOURCE_BARRIER_FLAGS = UINT;
pub const RESOURCE_BARRIER_FLAG_NONE = 0;
pub const RESOURCE_BARRIER_FLAG_BEGIN_ONLY = 0x1;
pub const RESOURCE_BARRIER_FLAG_END_ONLY = 0x2;
pub const RESOURCE_BARRIER = extern struct {
Type: RESOURCE_BARRIER_TYPE,
Flags: RESOURCE_BARRIER_FLAGS,
u: extern union {
Transition: RESOURCE_TRANSITION_BARRIER,
Aliasing: RESOURCE_ALIASING_BARRIER,
UAV: RESOURCE_UAV_BARRIER,
},
pub fn initUav(resource: *IResource) RESOURCE_BARRIER {
var v = std.mem.zeroes(@This());
v = .{ .Type = .UAV, .Flags = 0, .u = .{ .UAV = .{ .pResource = resource } } };
return v;
}
};
pub const SUBRESOURCE_FOOTPRINT = extern struct {
Format: dxgi.FORMAT,
Width: UINT,
Height: UINT,
Depth: UINT,
RowPitch: UINT,
};
pub const PLACED_SUBRESOURCE_FOOTPRINT = extern struct {
Offset: UINT64,
Footprint: SUBRESOURCE_FOOTPRINT,
};
pub const TEXTURE_COPY_TYPE = enum(UINT) {
SUBRESOURCE_INDEX = 0,
PLACED_FOOTPRINT = 1,
};
pub const TEXTURE_COPY_LOCATION = extern struct {
pResource: *IResource,
Type: TEXTURE_COPY_TYPE,
u: extern union {
PlacedFootprint: PLACED_SUBRESOURCE_FOOTPRINT,
SubresourceIndex: UINT,
},
};
pub const TILED_RESOURCE_COORDINATE = extern struct {
X: UINT,
Y: UINT,
Z: UINT,
Subresource: UINT,
};
pub const TILE_REGION_SIZE = extern struct {
NumTiles: UINT,
UseBox: BOOL,
Width: UINT,
Height: UINT16,
Depth: UINT16,
};
pub const TILE_RANGE_FLAGS = UINT;
pub const TILE_RANGE_FLAG_NONE = 0;
pub const TILE_RANGE_FLAG_NULL = 0x1;
pub const TILE_RANGE_FLAG_SKIP = 0x2;
pub const TILE_RANGE_FLAG_REUSE_SINGLE_TILE = 0x4;
pub const SUBRESOURCE_TILING = extern struct {
WidthInTiles: UINT,
HeightInTiles: UINT16,
DepthInTiles: UINT16,
StartTileIndexInOverallResource: UINT,
};
pub const TILE_SHAPE = extern struct {
WidthInTexels: UINT,
HeightInTexels: UINT,
DepthInTexels: UINT,
};
pub const TILE_MAPPING_FLAGS = UINT;
pub const TILE_MAPPING_FLAG_NONE = 0;
pub const TILE_MAPPING_FLAG_NO_HAZARD = 0x1;
pub const TILE_COPY_FLAGS = UINT;
pub const TILE_COPY_FLAG_NONE = 0;
pub const TILE_COPY_FLAG_NO_HAZARD = 0x1;
pub const TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2;
pub const TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4;
pub const VIEWPORT = extern struct {
TopLeftX: FLOAT,
TopLeftY: FLOAT,
Width: FLOAT,
Height: FLOAT,
MinDepth: FLOAT,
MaxDepth: FLOAT,
};
pub const RECT = windows.RECT;
pub const RESOURCE_STATES = UINT;
pub const RESOURCE_STATE_COMMON = 0;
pub const RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER = 0x1;
pub const RESOURCE_STATE_INDEX_BUFFER = 0x2;
pub const RESOURCE_STATE_RENDER_TARGET = 0x4;
pub const RESOURCE_STATE_UNORDERED_ACCESS = 0x8;
pub const RESOURCE_STATE_DEPTH_WRITE = 0x10;
pub const RESOURCE_STATE_DEPTH_READ = 0x20;
pub const RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE = 0x40;
pub const RESOURCE_STATE_PIXEL_SHADER_RESOURCE = 0x80;
pub const RESOURCE_STATE_STREAM_OUT = 0x100;
pub const RESOURCE_STATE_INDIRECT_ARGUMENT = 0x200;
pub const RESOURCE_STATE_COPY_DEST = 0x400;
pub const RESOURCE_STATE_COPY_SOURCE = 0x800;
pub const RESOURCE_STATE_RESOLVE_DEST = 0x1000;
pub const RESOURCE_STATE_RESOLVE_SOURCE = 0x2000;
pub const RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 0x400000;
pub const RESOURCE_STATE_SHADING_RATE_SOURCE = 0x1000000;
pub const RESOURCE_STATE_GENERIC_READ = (((((0x1 | 0x2) | 0x40) | 0x80) | 0x200) | 0x800);
pub const RESOURCE_STATE_ALL_SHADER_RESOURCE = (0x40 | 0x80);
pub const RESOURCE_STATE_PRESENT = 0;
pub const RESOURCE_STATE_PREDICATION = 0x200;
pub const RESOURCE_STATE_VIDEO_DECODE_READ = 0x10000;
pub const RESOURCE_STATE_VIDEO_DECODE_WRITE = 0x20000;
pub const RESOURCE_STATE_VIDEO_PROCESS_READ = 0x40000;
pub const RESOURCE_STATE_VIDEO_PROCESS_WRITE = 0x80000;
pub const RESOURCE_STATE_VIDEO_ENCODE_READ = 0x200000;
pub const RESOURCE_STATE_VIDEO_ENCODE_WRITE = 0x800000;
pub const INDEX_BUFFER_STRIP_CUT_VALUE = enum(UINT) {
DISABLED = 0,
_0xFFFF = 1,
_0xFFFFFFFF = 2,
};
pub const VERTEX_BUFFER_VIEW = extern struct {
BufferLocation: GPU_VIRTUAL_ADDRESS,
SizeInBytes: UINT,
StrideInBytes: UINT,
};
pub const INDEX_BUFFER_VIEW = extern struct {
BufferLocation: GPU_VIRTUAL_ADDRESS,
SizeInBytes: UINT,
Format: dxgi.FORMAT,
};
pub const STREAM_OUTPUT_BUFFER_VIEW = extern struct {
BufferLocation: GPU_VIRTUAL_ADDRESS,
SizeInBytes: UINT64,
BufferFilledSizeLocation: GPU_VIRTUAL_ADDRESS,
};
pub const CLEAR_FLAGS = UINT;
pub const CLEAR_FLAG_DEPTH: CLEAR_FLAGS = 0x1;
pub const CLEAR_FLAG_STENCIL: CLEAR_FLAGS = 0x2;
pub const DISCARD_REGION = extern struct {
NumRects: UINT,
pRects: *const RECT,
FirstSubresource: UINT,
NumSubresources: UINT,
};
pub const QUERY_HEAP_TYPE = enum(UINT) {
OCCLUSION = 0,
TIMESTAMP = 1,
PIPELINE_STATISTICS = 2,
SO_STATISTICS = 3,
};
pub const QUERY_HEAP_DESC = extern struct {
Type: QUERY_HEAP_TYPE,
Count: UINT,
NodeMask: UINT,
};
pub const QUERY_TYPE = enum(UINT) {
OCCLUSION = 0,
BINARY_OCCLUSION = 1,
TIMESTAMP = 2,
PIPELINE_STATISTICS = 3,
SO_STATISTICS_STREAM0 = 4,
SO_STATISTICS_STREAM1 = 5,
SO_STATISTICS_STREAM2 = 6,
SO_STATISTICS_STREAM3 = 7,
VIDEO_DECODE_STATISTICS = 8,
PIPELINE_STATISTICS1 = 10,
};
pub const PREDICATION_OP = enum(UINT) {
EQUAL_ZERO = 0,
NOT_EQUAL_ZERO = 1,
};
pub const INDIRECT_ARGUMENT_TYPE = enum(UINT) {
DRAW = 0,
DRAW_INDEXED = 1,
DISPATCH = 2,
VERTEX_BUFFER_VIEW = 3,
INDEX_BUFFER_VIEW = 4,
CONSTANT = 5,
CONSTANT_BUFFER_VIEW = 6,
SHADER_RESOURCE_VIEW = 7,
UNORDERED_ACCESS_VIEW = 8,
DISPATCH_RAYS = 9,
DISPATCH_MESH = 10,
};
pub const INDIRECT_ARGUMENT_DESC = extern struct {
Type: INDIRECT_ARGUMENT_TYPE,
u: extern union {
VertexBuffer: extern struct {
Slot: UINT,
},
Constant: extern struct {
RootParameterIndex: UINT,
DestOffsetIn32BitValues: UINT,
Num32BitValuesToSet: UINT,
},
ConstantBufferView: extern struct {
RootParameterIndex: UINT,
},
ShaderResourceView: extern struct {
RootParameterIndex: UINT,
},
UnorderedAccessView: extern struct {
RootParameterIndex: UINT,
},
},
};
pub const COMMAND_SIGNATURE_DESC = extern struct {
ByteStride: UINT,
NumArgumentDescs: UINT,
pArgumentDescs: *const INDIRECT_ARGUMENT_DESC,
NodeMask: UINT,
};
pub const PACKED_MIP_INFO = extern struct {
NumStandardMips: UINT8,
NumPackedMips: UINT8,
NumTilesForPackedMips: UINT,
StartTileIndexInOverallResource: UINT,
};
pub const COMMAND_QUEUE_FLAGS = UINT;
pub const COMMAND_QUEUE_FLAG_NONE = 0;
pub const COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1;
pub const COMMAND_QUEUE_PRIORITY = enum(UINT) {
NORMAL = 0,
HIGH = 100,
GLOBAL_REALTIME = 10000,
};
pub const COMMAND_QUEUE_DESC = extern struct {
Type: COMMAND_LIST_TYPE,
Priority: INT,
Flags: COMMAND_QUEUE_FLAGS,
NodeMask: UINT,
};
pub const SHADER_BYTECODE = extern struct {
pShaderBytecode: ?*const anyopaque,
BytecodeLength: UINT64,
pub inline fn initZero() SHADER_BYTECODE {
return std.mem.zeroes(@This());
}
};
pub const SO_DECLARATION_ENTRY = extern struct {
Stream: UINT,
SemanticName: LPCSTR,
SemanticIndex: UINT,
StartComponent: UINT8,
ComponentCount: UINT8,
OutputSlot: UINT8,
};
pub const STREAM_OUTPUT_DESC = extern struct {
pSODeclaration: ?[*]const SO_DECLARATION_ENTRY,
NumEntries: UINT,
pBufferStrides: ?[*]const UINT,
NumStrides: UINT,
RasterizedStream: UINT,
pub inline fn initZero() STREAM_OUTPUT_DESC {
return std.mem.zeroes(@This());
}
};
pub const BLEND = enum(UINT) {
ZERO = 1,
ONE = 2,
SRC_COLOR = 3,
INV_SRC_COLOR = 4,
SRC_ALPHA = 5,
INV_SRC_ALPHA = 6,
DEST_ALPHA = 7,
INV_DEST_ALPHA = 8,
DEST_COLOR = 9,
INV_DEST_COLOR = 10,
SRC_ALPHA_SAT = 11,
BLEND_FACTOR = 14,
INV_BLEND_FACTOR = 15,
SRC1_COLOR = 16,
INV_SRC1_COLOR = 17,
SRC1_ALPHA = 18,
INV_SRC1_ALPHA = 19,
};
pub const BLEND_OP = enum(UINT) {
ADD = 1,
SUBTRACT = 2,
REV_SUBTRACT = 3,
MIN = 4,
MAX = 5,
};
pub const COLOR_WRITE_ENABLE = UINT;
pub const COLOR_WRITE_ENABLE_RED = 0x1;
pub const COLOR_WRITE_ENABLE_GREEN = 0x2;
pub const COLOR_WRITE_ENABLE_BLUE = 0x4;
pub const COLOR_WRITE_ENABLE_ALPHA = 0x8;
pub const COLOR_WRITE_ENABLE_ALL =
COLOR_WRITE_ENABLE_RED |
COLOR_WRITE_ENABLE_GREEN |
COLOR_WRITE_ENABLE_BLUE |
COLOR_WRITE_ENABLE_ALPHA;
pub const LOGIC_OP = enum(UINT) {
CLEAR = 0,
SET = 1,
COPY = 2,
COPY_INVERTED = 3,
NOOP = 4,
INVERT = 5,
AND = 6,
NAND = 7,
OR = 8,
NOR = 9,
XOR = 10,
EQUIV = 11,
AND_REVERSE = 12,
AND_INVERTED = 13,
OR_REVERSE = 14,
OR_INVERTED = 15,
};
pub const RENDER_TARGET_BLEND_DESC = extern struct {
BlendEnable: BOOL,
LogicOpEnable: BOOL,
SrcBlend: BLEND,
DestBlend: BLEND,
BlendOp: BLEND_OP,
SrcBlendAlpha: BLEND,
DestBlendAlpha: BLEND,
BlendOpAlpha: BLEND_OP,
LogicOp: LOGIC_OP,
RenderTargetWriteMask: UINT8,
pub fn initDefault() RENDER_TARGET_BLEND_DESC {
var v = std.mem.zeroes(@This());
v = .{
.BlendEnable = FALSE,
.LogicOpEnable = FALSE,
.SrcBlend = .ONE,
.DestBlend = .ZERO,
.BlendOp = .ADD,
.SrcBlendAlpha = .ONE,
.DestBlendAlpha = .ZERO,
.BlendOpAlpha = .ADD,
.LogicOp = .NOOP,
.RenderTargetWriteMask = 0x0,
};
return v;
}
};
pub const BLEND_DESC = extern struct {
AlphaToCoverageEnable: BOOL,
IndependentBlendEnable: BOOL,
RenderTarget: [8]RENDER_TARGET_BLEND_DESC,
pub fn initDefault() BLEND_DESC {
var v = std.mem.zeroes(@This());
v = .{
.AlphaToCoverageEnable = FALSE,
.IndependentBlendEnable = FALSE,
.RenderTarget = [_]RENDER_TARGET_BLEND_DESC{RENDER_TARGET_BLEND_DESC.initDefault()} ** 8,
};
return v;
}
};
pub const RASTERIZER_DESC = extern struct {
FillMode: FILL_MODE,
CullMode: CULL_MODE,
FrontCounterClockwise: BOOL,
DepthBias: INT,
DepthBiasClamp: FLOAT,
SlopeScaledDepthBias: FLOAT,
DepthClipEnable: BOOL,
MultisampleEnable: BOOL,
AntialiasedLineEnable: BOOL,
ForcedSampleCount: UINT,
ConservativeRaster: CONSERVATIVE_RASTERIZATION_MODE,
pub fn initDefault() RASTERIZER_DESC {
var v = std.mem.zeroes(@This());
v = .{
.FillMode = .SOLID,
.CullMode = .BACK,
.FrontCounterClockwise = FALSE,
.DepthBias = 0,
.DepthBiasClamp = 0.0,
.SlopeScaledDepthBias = 0.0,
.DepthClipEnable = TRUE,
.MultisampleEnable = FALSE,
.AntialiasedLineEnable = FALSE,
.ForcedSampleCount = 0,
.ConservativeRaster = .OFF,
};
return v;
}
};
pub const FILL_MODE = enum(UINT) {
WIREFRAME = 2,
SOLID = 3,
};
pub const CULL_MODE = enum(UINT) {
NONE = 1,
FRONT = 2,
BACK = 3,
};
pub const CONSERVATIVE_RASTERIZATION_MODE = enum(UINT) {
OFF = 0,
ON = 1,
};
pub const COMPARISON_FUNC = enum(UINT) {
NEVER = 1,
LESS = 2,
EQUAL = 3,
LESS_EQUAL = 4,
GREATER = 5,
NOT_EQUAL = 6,
GREATER_EQUAL = 7,
ALWAYS = 8,
};
pub const DEPTH_WRITE_MASK = enum(UINT) {
ZERO = 0,
ALL = 1,
};
pub const STENCIL_OP = enum(UINT) {
KEEP = 1,
ZERO = 2,
REPLACE = 3,
INCR_SAT = 4,
DECR_SAT = 5,
INVERT = 6,
INCR = 7,
DECR = 8,
};
pub const DEPTH_STENCILOP_DESC = extern struct {
StencilFailOp: STENCIL_OP,
StencilDepthFailOp: STENCIL_OP,
StencilPassOp: STENCIL_OP,
StencilFunc: COMPARISON_FUNC,
pub fn initDefault() DEPTH_STENCILOP_DESC {
var v = std.mem.zeroes(@This());
v = .{
.StencilFailOp = .KEEP,
.StencilDepthFailOp = .KEEP,
.StencilPassOp = .KEEP,
.StencilFunc = .ALWAYS,
};
return v;
}
};
pub const DEPTH_STENCIL_DESC = extern struct {
DepthEnable: BOOL,
DepthWriteMask: DEPTH_WRITE_MASK,
DepthFunc: COMPARISON_FUNC,
StencilEnable: BOOL,
StencilReadMask: UINT8,
StencilWriteMask: UINT8,
FrontFace: DEPTH_STENCILOP_DESC,
BackFace: DEPTH_STENCILOP_DESC,
pub fn initDefault() DEPTH_STENCIL_DESC {
var desc = std.mem.zeroes(@This());
desc = .{
.DepthEnable = TRUE,
.DepthWriteMask = .ALL,
.DepthFunc = .LESS,
.StencilEnable = FALSE,
.StencilReadMask = 0xff,
.StencilWriteMask = 0xff,
.FrontFace = DEPTH_STENCILOP_DESC.initDefault(),
.BackFace = DEPTH_STENCILOP_DESC.initDefault(),
};
return desc;
}
};
pub const DEPTH_STENCIL_DESC1 = extern struct {
DepthEnable: BOOL,
DepthWriteMask: DEPTH_WRITE_MASK,
DepthFunc: COMPARISON_FUNC,
StencilEnable: BOOL,
StencilReadMask: UINT8,
StencilWriteMask: UINT8,
FrontFace: DEPTH_STENCILOP_DESC,
BackFace: DEPTH_STENCILOP_DESC,
DepthBoundsTestEnable: BOOL,
pub fn initDefault() DEPTH_STENCIL_DESC1 {
var desc = std.mem.zeroes(@This());
desc = .{
.DepthEnable = TRUE,
.DepthWriteMask = .ALL,
.DepthFunc = .LESS,
.StencilEnable = FALSE,
.StencilReadMask = 0xff,
.StencilWriteMask = 0xff,
.FrontFace = DEPTH_STENCILOP_DESC.initDefault(),
.BackFace = DEPTH_STENCILOP_DESC.initDefault(),
.DepthBoundsTestEnable = FALSE,
};
return desc;
}
};
pub const INPUT_LAYOUT_DESC = extern struct {
pInputElementDescs: ?[*]const INPUT_ELEMENT_DESC,
NumElements: UINT,
pub inline fn initZero() INPUT_LAYOUT_DESC {
return std.mem.zeroes(@This());
}
};
pub const INPUT_CLASSIFICATION = enum(UINT) {
PER_VERTEX_DATA = 0,
PER_INSTANCE_DATA = 1,
};
pub const INPUT_ELEMENT_DESC = extern struct {
SemanticName: LPCSTR,
SemanticIndex: UINT,
Format: dxgi.FORMAT,
InputSlot: UINT,
AlignedByteOffset: UINT,
InputSlotClass: INPUT_CLASSIFICATION,
InstanceDataStepRate: UINT,
pub inline fn init(
semanticName: LPCSTR,
semanticIndex: UINT,
format: dxgi.FORMAT,
inputSlot: UINT,
alignedByteOffset: UINT,
inputSlotClass: INPUT_CLASSIFICATION,
instanceDataStepRate: UINT,
) INPUT_ELEMENT_DESC {
var v = std.mem.zeroes(@This());
v = .{
.SemanticName = semanticName,
.SemanticIndex = semanticIndex,
.Format = format,
.InputSlot = inputSlot,
.AlignedByteOffset = alignedByteOffset,
.InputSlotClass = inputSlotClass,
.InstanceDataStepRate = instanceDataStepRate,
};
return v;
}
};
pub const CACHED_PIPELINE_STATE = extern struct {
pCachedBlob: ?*const anyopaque,
CachedBlobSizeInBytes: UINT64,
pub inline fn initZero() CACHED_PIPELINE_STATE {
return std.mem.zeroes(@This());
}
};
pub const PIPELINE_STATE_FLAGS = UINT;
pub const PIPELINE_STATE_FLAG_NONE = 0;
pub const PIPELINE_STATE_FLAG_TOOL_DEBUG = 0x1;
pub const GRAPHICS_PIPELINE_STATE_DESC = extern struct {
pRootSignature: ?*IRootSignature,
VS: SHADER_BYTECODE,
PS: SHADER_BYTECODE,
DS: SHADER_BYTECODE,
HS: SHADER_BYTECODE,
GS: SHADER_BYTECODE,
StreamOutput: STREAM_OUTPUT_DESC,
BlendState: BLEND_DESC,
SampleMask: UINT,
RasterizerState: RASTERIZER_DESC,
DepthStencilState: DEPTH_STENCIL_DESC,
InputLayout: INPUT_LAYOUT_DESC,
IBStripCutValue: INDEX_BUFFER_STRIP_CUT_VALUE,
PrimitiveTopologyType: PRIMITIVE_TOPOLOGY_TYPE,
NumRenderTargets: UINT,
RTVFormats: [8]dxgi.FORMAT,
DSVFormat: dxgi.FORMAT,
SampleDesc: dxgi.SAMPLE_DESC,
NodeMask: UINT,
CachedPSO: CACHED_PIPELINE_STATE,
Flags: PIPELINE_STATE_FLAGS,
pub fn initDefault() GRAPHICS_PIPELINE_STATE_DESC {
var v = std.mem.zeroes(@This());
v = GRAPHICS_PIPELINE_STATE_DESC{
.pRootSignature = null,
.VS = SHADER_BYTECODE.initZero(),
.PS = SHADER_BYTECODE.initZero(),
.DS = SHADER_BYTECODE.initZero(),
.HS = SHADER_BYTECODE.initZero(),
.GS = SHADER_BYTECODE.initZero(),
.StreamOutput = STREAM_OUTPUT_DESC.initZero(),
.BlendState = BLEND_DESC.initDefault(),
.SampleMask = 0xffff_ffff,
.RasterizerState = RASTERIZER_DESC.initDefault(),
.DepthStencilState = DEPTH_STENCIL_DESC.initDefault(),
.InputLayout = INPUT_LAYOUT_DESC.initZero(),
.IBStripCutValue = .DISABLED,
.PrimitiveTopologyType = .UNDEFINED,
.NumRenderTargets = 0,
.RTVFormats = [_]dxgi.FORMAT{.UNKNOWN} ** 8,
.DSVFormat = .UNKNOWN,
.SampleDesc = .{ .Count = 1, .Quality = 0 },
.NodeMask = 0,
.CachedPSO = CACHED_PIPELINE_STATE.initZero(),
.Flags = PIPELINE_STATE_FLAG_NONE,
};
return v;
}
};
pub const COMPUTE_PIPELINE_STATE_DESC = extern struct {
pRootSignature: ?*IRootSignature,
CS: SHADER_BYTECODE,
NodeMask: UINT,
CachedPSO: CACHED_PIPELINE_STATE,
Flags: PIPELINE_STATE_FLAGS,
pub fn initDefault() COMPUTE_PIPELINE_STATE_DESC {
var v = std.mem.zeroes(@This());
v = COMPUTE_PIPELINE_STATE_DESC{
.pRootSignature = null,
.CS = SHADER_BYTECODE.initZero(),
.NodeMask = 0,
.CachedPSO = CACHED_PIPELINE_STATE.initZero(),
.Flags = PIPELINE_STATE_FLAG_NONE,
};
return v;
}
};
pub const FEATURE = enum(UINT) {
OPTIONS = 0,
ARCHITECTURE = 1,
FEATURE_LEVELS = 2,
FORMAT_SUPPORT = 3,
MULTISAMPLE_QUALITY_LEVELS = 4,
FORMAT_INFO = 5,
GPU_VIRTUAL_ADDRESS_SUPPORT = 6,
SHADER_MODEL = 7,
OPTIONS1 = 8,
PROTECTED_RESOURCE_SESSION_SUPPORT = 10,
ROOT_SIGNATURE = 12,
ARCHITECTURE1 = 16,
OPTIONS2 = 18,
SHADER_CACHE = 19,
COMMAND_QUEUE_PRIORITY = 20,
OPTIONS3 = 21,
EXISTING_HEAPS = 22,
OPTIONS4 = 23,
SERIALIZATION = 24,
CROSS_NODE = 25,
OPTIONS5 = 27,
DISPLAYABLE = 28,
OPTIONS6 = 30,
QUERY_META_COMMAND = 31,
OPTIONS7 = 32,
PROTECTED_RESOURCE_SESSION_TYPE_COUNT = 33,
PROTECTED_RESOURCE_SESSION_TYPES = 34,
OPTIONS8 = 36,
OPTIONS9 = 37,
OPTIONS10 = 39,
OPTIONS11 = 40,
};
pub const SHADER_MODEL = enum(UINT) {
SM_5_1 = 0x51,
SM_6_0 = 0x60,
SM_6_1 = 0x61,
SM_6_2 = 0x62,
SM_6_3 = 0x63,
SM_6_4 = 0x64,
SM_6_5 = 0x65,
SM_6_6 = 0x66,
SM_6_7 = 0x67,
};
pub const RESOURCE_BINDING_TIER = enum(UINT) {
TIER_1 = 1,
TIER_2 = 2,
TIER_3 = 3,
};
pub const RESOURCE_HEAP_TIER = enum(UINT) {
TIER_1 = 1,
TIER_2 = 2,
};
pub const SHADER_MIN_PRECISION_SUPPORT = UINT;
pub const SHADER_MIN_PRECISION_SUPPORT_NONE: SHADER_MIN_PRECISION_SUPPORT = 0;
pub const SHADER_MIN_PRECISION_SUPPORT_10_BIT: SHADER_MIN_PRECISION_SUPPORT = 0x1;
pub const SHADER_MIN_PRECISION_SUPPORT_16_BIT: SHADER_MIN_PRECISION_SUPPORT = 0x2;
pub const TILED_RESOURCES_TIER = enum(UINT) {
NOT_SUPPORTED = 0,
TIER_1 = 1,
TIER_2 = 2,
TIER_3 = 3,
TIER_4 = 4,
};
pub const CONSERVATIVE_RASTERIZATION_TIER = enum(UINT) {
NOT_SUPPORTED = 0,
TIER_1 = 1,
TIER_2 = 2,
TIER_3 = 3,
};
pub const CROSS_NODE_SHARING_TIER = enum(UINT) {
NOT_SUPPORTED = 0,
TIER_1_EMULATED = 1,
TIER_1 = 2,
TIER_2 = 3,
TIER_3 = 4,
};
pub const FEATURE_DATA_D3D12_OPTIONS = extern struct {
DoublePrecisionFloatShaderOps: BOOL,
OutputMergerLogicOp: BOOL,
MinPrecisionSupport: SHADER_MIN_PRECISION_SUPPORT,
TiledResourcesTier: TILED_RESOURCES_TIER,
ResourceBindingTier: RESOURCE_BINDING_TIER,
PSSpecifiedStencilRefSupported: BOOL,
TypedUAVLoadAdditionalFormats: BOOL,
ROVsSupported: BOOL,
ConservativeRasterizationTier: CONSERVATIVE_RASTERIZATION_TIER,
MaxGPUVirtualAddressBitsPerResource: UINT,
StandardSwizzle64KBSupported: BOOL,
CrossNodeSharingTier: CROSS_NODE_SHARING_TIER,
CrossAdapterRowMajorTextureSupported: BOOL,
VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation: BOOL,
ResourceHeapTier: RESOURCE_HEAP_TIER,
};
pub const FEATURE_DATA_SHADER_MODEL = extern struct {
HighestShaderModel: SHADER_MODEL,
};
pub const RENDER_PASS_TIER = enum(UINT) {
TIER_0 = 0,
TIER_1 = 1,
TIER_2 = 2,
};
pub const RAYTRACING_TIER = enum(UINT) {
NOT_SUPPORTED = 0,
TIER_1_0 = 10,
TIER_1_1 = 11,
};
pub const MESH_SHADER_TIER = enum(UINT) {
NOT_SUPPORTED = 0,
TIER_1 = 10,
};
pub const SAMPLER_FEEDBACK_TIER = enum(UINT) {
NOT_SUPPORTED = 0,
TIER_0_9 = 90,
TIER_1_0 = 100,
};
pub const FEATURE_DATA_D3D12_OPTIONS7 = extern struct {
MeshShaderTier: MESH_SHADER_TIER,
SamplerFeedbackTier: SAMPLER_FEEDBACK_TIER,
};
pub const COMMAND_LIST_SUPPORT_FLAGS = UINT;
pub const COMMAND_LIST_SUPPORT_FLAG_NONE: COMMAND_LIST_SUPPORT_FLAGS = 0x0;
pub const COMMAND_LIST_SUPPORT_FLAG_DIRECT: COMMAND_LIST_SUPPORT_FLAGS = 0x1;
pub const COMMAND_LIST_SUPPORT_FLAG_BUNDLE: COMMAND_LIST_SUPPORT_FLAGS = 0x2;
pub const COMMAND_LIST_SUPPORT_FLAG_COMPUTE: COMMAND_LIST_SUPPORT_FLAGS = 0x4;
pub const COMMAND_LIST_SUPPORT_FLAG_COPY: COMMAND_LIST_SUPPORT_FLAGS = 0x8;
pub const COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE: COMMAND_LIST_SUPPORT_FLAGS = 0x10;
pub const COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS: COMMAND_LIST_SUPPORT_FLAGS = 0x20;
pub const COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE: COMMAND_LIST_SUPPORT_FLAGS = 0x40;
pub const VIEW_INSTANCING_TIER = enum(UINT) {
NOT_SUPPORTED = 0,
TIER_1 = 1,
TIER_2 = 2,
TIER_3 = 3,
};
pub const FEATURE_DATA_D3D12_OPTIONS3 = extern struct {
CopyQueueTimestampQueriesSupported: BOOL,
CastingFullyTypedFormatSupported: BOOL,
WriteBufferImmediateSupportFlags: COMMAND_LIST_SUPPORT_FLAGS,
ViewInstancingTier: VIEW_INSTANCING_TIER,
BarycentricsSupported: BOOL,
};
pub const FEATURE_DATA_D3D12_OPTIONS5 = extern struct {
SRVOnlyTiledResourceTier3: BOOL,
RenderPassesTier: RENDER_PASS_TIER,
RaytracingTier: RAYTRACING_TIER,
};
pub const CONSTANT_BUFFER_VIEW_DESC = extern struct {
BufferLocation: GPU_VIRTUAL_ADDRESS,
SizeInBytes: UINT,
};
pub inline fn encodeShader4ComponentMapping(src0: UINT, src1: UINT, src2: UINT, src3: UINT) UINT {
return (src0 & 0x7) | ((src1 & 0x7) << 3) | ((src2 & 0x7) << (3 * 2)) | ((src3 & 0x7) << (3 * 3)) | (1 << (3 * 4));
}
pub const DEFAULT_SHADER_4_COMPONENT_MAPPING = encodeShader4ComponentMapping(0, 1, 2, 3);
pub const BUFFER_SRV_FLAGS = UINT;
pub const BUFFER_SRV_FLAG_NONE = 0;
pub const BUFFER_SRV_FLAG_RAW = 0x1;
pub const BUFFER_SRV = extern struct {
FirstElement: UINT64,
NumElements: UINT,
StructureByteStride: UINT,
Flags: BUFFER_SRV_FLAGS,
};
pub const TEX1D_SRV = extern struct {
MostDetailedMip: UINT,
MipLevels: UINT,
ResourceMinLODClamp: FLOAT,
};
pub const TEX1D_ARRAY_SRV = extern struct {
MostDetailedMip: UINT,
MipLevels: UINT,
FirstArraySlice: UINT,
ArraySize: UINT,
ResourceMinLODClamp: FLOAT,
};
pub const TEX2D_SRV = extern struct {
MostDetailedMip: UINT,
MipLevels: UINT,
PlaneSlice: UINT,
ResourceMinLODClamp: FLOAT,
};
pub const TEX2D_ARRAY_SRV = extern struct {
MostDetailedMip: UINT,
MipLevels: UINT,
FirstArraySlice: UINT,
ArraySize: UINT,
PlaneSlice: UINT,
ResourceMinLODClamp: FLOAT,
};
pub const TEX3D_SRV = extern struct {
MostDetailedMip: UINT,
MipLevels: UINT,
ResourceMinLODClamp: FLOAT,
};
pub const TEXCUBE_SRV = extern struct {
MostDetailedMip: UINT,
MipLevels: UINT,
ResourceMinLODClamp: FLOAT,
};
pub const TEXCUBE_ARRAY_SRV = extern struct {
MostDetailedMip: UINT,
MipLevels: UINT,
First2DArrayFace: UINT,
NumCubes: UINT,
ResourceMinLODClamp: FLOAT,
};
pub const TEX2DMS_SRV = extern struct {
UnusedField_NothingToDefine: UINT,
};
pub const TEX2DMS_ARRAY_SRV = extern struct {
FirstArraySlice: UINT,
ArraySize: UINT,
};
pub const SRV_DIMENSION = enum(UINT) {
UNKNOWN = 0,
BUFFER = 1,
TEXTURE1D = 2,
TEXTURE1DARRAY = 3,
TEXTURE2D = 4,
TEXTURE2DARRAY = 5,
TEXTURE2DMS = 6,
TEXTURE2DMSARRAY = 7,
TEXTURE3D = 8,
TEXTURECUBE = 9,
TEXTURECUBEARRAY = 10,
};
pub const SHADER_RESOURCE_VIEW_DESC = extern struct {
Format: dxgi.FORMAT,
ViewDimension: SRV_DIMENSION,
Shader4ComponentMapping: UINT,
u: extern union {
Buffer: BUFFER_SRV,
Texture1D: TEX1D_SRV,
Texture1DArray: TEX1D_ARRAY_SRV,
Texture2D: TEX2D_SRV,
Texture2DArray: TEX2D_ARRAY_SRV,
Texture2DMS: TEX2DMS_SRV,
Texture2DMSArray: TEX2DMS_ARRAY_SRV,
Texture3D: TEX3D_SRV,
TextureCube: TEXCUBE_SRV,
TextureCubeArray: TEXCUBE_ARRAY_SRV,
},
pub fn initTypedBuffer(
format: dxgi.FORMAT,
first_element: UINT64,
num_elements: UINT,
) SHADER_RESOURCE_VIEW_DESC {
var desc = std.mem.zeroes(@This());
desc = .{
.Format = format,
.ViewDimension = .BUFFER,
.Shader4ComponentMapping = DEFAULT_SHADER_4_COMPONENT_MAPPING,
.u = .{
.Buffer = .{
.FirstElement = first_element,
.NumElements = num_elements,
.StructureByteStride = 0,
.Flags = BUFFER_SRV_FLAG_NONE,
},
},
};
return desc;
}
pub fn initStructuredBuffer(
first_element: UINT64,
num_elements: UINT,
stride: UINT,
) SHADER_RESOURCE_VIEW_DESC {
var v = std.mem.zeroes(@This());
v = .{
.Format = .UNKNOWN,
.ViewDimension = .BUFFER,
.Shader4ComponentMapping = DEFAULT_SHADER_4_COMPONENT_MAPPING,
.u = .{
.Buffer = .{
.FirstElement = first_element,
.NumElements = num_elements,
.StructureByteStride = stride,
.Flags = BUFFER_SRV_FLAG_NONE,
},
},
};
return v;
}
};
pub const FILTER = enum(UINT) {
MIN_MAG_MIP_POINT = 0,
MIN_MAG_POINT_MIP_LINEAR = 0x1,
MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4,
MIN_POINT_MAG_MIP_LINEAR = 0x5,
MIN_LINEAR_MAG_MIP_POINT = 0x10,
MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11,
MIN_MAG_LINEAR_MIP_POINT = 0x14,
MIN_MAG_MIP_LINEAR = 0x15,
ANISOTROPIC = 0x55,
COMPARISON_MIN_MAG_MIP_POINT = 0x80,
COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81,
COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84,
COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85,
COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90,
COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91,
COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94,
COMPARISON_MIN_MAG_MIP_LINEAR = 0x95,
COMPARISON_ANISOTROPIC = 0xd5,
MINIMUM_MIN_MAG_MIP_POINT = 0x100,
MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101,
MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104,
MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105,
MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110,
MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111,
MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114,
MINIMUM_MIN_MAG_MIP_LINEAR = 0x115,
MINIMUM_ANISOTROPIC = 0x155,
MAXIMUM_MIN_MAG_MIP_POINT = 0x180,
MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181,
MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184,
MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185,
MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190,
MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191,
MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194,
MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195,
MAXIMUM_ANISOTROPIC = 0x1d5,
};
pub const FILTER_TYPE = enum(UINT) {
POINT = 0,
LINEAR = 1,
};
pub const FILTER_REDUCTION_TYPE = enum(UINT) {
STANDARD = 0,
COMPARISON = 1,
MINIMUM = 2,
MAXIMUM = 3,
};
pub const TEXTURE_ADDRESS_MODE = enum(UINT) {
WRAP = 1,
MIRROR = 2,
CLAMP = 3,
BORDER = 4,
MIRROR_ONCE = 5,
};
pub const SAMPLER_DESC = extern struct {
Filter: FILTER,
AddressU: TEXTURE_ADDRESS_MODE,
AddressV: TEXTURE_ADDRESS_MODE,
AddressW: TEXTURE_ADDRESS_MODE,
MipLODBias: FLOAT,
MaxAnisotropy: UINT,
ComparisonFunc: COMPARISON_FUNC,
BorderColor: [4]FLOAT,
MinLOD: FLOAT,
MaxLOD: FLOAT,
};
pub const BUFFER_UAV_FLAGS = UINT;
pub const BUFFER_UAV_FLAG_NONE = 0;
pub const BUFFER_UAV_FLAG_RAW = 0x1;
pub const BUFFER_UAV = extern struct {
FirstElement: UINT64,
NumElements: UINT,
StructureByteStride: UINT,
CounterOffsetInBytes: UINT64,
Flags: BUFFER_UAV_FLAGS,
};
pub const TEX1D_UAV = extern struct {
MipSlice: UINT,
};
pub const TEX1D_ARRAY_UAV = extern struct {
MipSlice: UINT,
FirstArraySlice: UINT,
ArraySize: UINT,
};
pub const TEX2D_UAV = extern struct {
MipSlice: UINT,
PlaneSlice: UINT,
};
pub const TEX2D_ARRAY_UAV = extern struct {
MipSlice: UINT,
FirstArraySlice: UINT,
ArraySize: UINT,
PlaneSlice: UINT,
};
pub const TEX3D_UAV = extern struct {
MipSlice: UINT,
FirstWSlice: UINT,
WSize: UINT,
};
pub const UAV_DIMENSION = enum(UINT) {
UNKNOWN = 0,
BUFFER = 1,
TEXTURE1D = 2,
TEXTURE1DARRAY = 3,
TEXTURE2D = 4,
TEXTURE2DARRAY = 5,
TEXTURE3D = 8,
};
pub const UNORDERED_ACCESS_VIEW_DESC = extern struct {
Format: dxgi.FORMAT,
ViewDimension: UAV_DIMENSION,
u: extern union {
Buffer: BUFFER_UAV,
Texture1D: TEX1D_UAV,
Texture1DArray: TEX1D_ARRAY_UAV,
Texture2D: TEX2D_UAV,
Texture2DArray: TEX2D_ARRAY_UAV,
Texture3D: TEX3D_UAV,
},
pub fn initTypedBuffer(
format: dxgi.FORMAT,
first_element: UINT64,
num_elements: UINT,
counter_offset: UINT64,
) UNORDERED_ACCESS_VIEW_DESC {
var desc = std.mem.zeroes(@This());
desc = .{
.Format = format,
.ViewDimension = .BUFFER,
.u = .{
.Buffer = .{
.FirstElement = first_element,
.NumElements = num_elements,
.StructureByteStride = 0,
.CounterOffsetInBytes = counter_offset,
.Flags = BUFFER_SRV_FLAG_NONE,
},
},
};
return desc;
}
pub fn initStructuredBuffer(
first_element: UINT64,
num_elements: UINT,
stride: UINT,
counter_offset: UINT64,
) UNORDERED_ACCESS_VIEW_DESC {
var v = std.mem.zeroes(@This());
v = .{
.Format = .UNKNOWN,
.ViewDimension = .BUFFER,
.u = .{
.Buffer = .{
.FirstElement = first_element,
.NumElements = num_elements,
.StructureByteStride = stride,
.CounterOffsetInBytes = counter_offset,
.Flags = BUFFER_SRV_FLAG_NONE,
},
},
};
return v;
}
};
pub const BUFFER_RTV = extern struct {
FirstElement: UINT64,
NumElements: UINT,
};
pub const TEX1D_RTV = extern struct {
MipSlice: UINT,
};
pub const TEX1D_ARRAY_RTV = extern struct {
MipSlice: UINT,
FirstArraySlice: UINT,
ArraySize: UINT,
};
pub const TEX2D_RTV = extern struct {
MipSlice: UINT,
PlaneSlice: UINT,
};
pub const TEX2DMS_RTV = extern struct {
UnusedField_NothingToDefine: UINT,
};
pub const TEX2D_ARRAY_RTV = extern struct {
MipSlice: UINT,
FirstArraySlice: UINT,
ArraySize: UINT,
PlaneSlice: UINT,
};
pub const TEX2DMS_ARRAY_RTV = extern struct {
FirstArraySlice: UINT,
ArraySize: UINT,
};
pub const TEX3D_RTV = extern struct {
MipSlice: UINT,
FirstWSlice: UINT,
WSize: UINT,
};
pub const RTV_DIMENSION = enum(UINT) {
UNKNOWN = 0,
BUFFER = 1,
TEXTURE1D = 2,
TEXTURE1DARRAY = 3,
TEXTURE2D = 4,
TEXTURE2DARRAY = 5,
TEXTURE2DMS = 6,
TEXTURE2DMSARRAY = 7,
TEXTURE3D = 8,
};
pub const RENDER_TARGET_VIEW_DESC = extern struct {
Format: dxgi.FORMAT,
ViewDimension: RTV_DIMENSION,
u: extern union {
Buffer: BUFFER_RTV,
Texture1D: TEX1D_RTV,
Texture1DArray: TEX1D_ARRAY_RTV,
Texture2D: TEX2D_RTV,
Texture2DArray: TEX2D_ARRAY_RTV,
Texture2DMS: TEX2DMS_RTV,
Texture2DMSArray: TEX2DMS_ARRAY_RTV,
Texture3D: TEX3D_RTV,
},
};
pub const TEX1D_DSV = extern struct {
MipSlice: UINT,
};
pub const TEX1D_ARRAY_DSV = extern struct {
MipSlice: UINT,
FirstArraySlice: UINT,
ArraySize: UINT,
};
pub const TEX2D_DSV = extern struct {
MipSlice: UINT,
};
pub const TEX2D_ARRAY_DSV = extern struct {
MipSlice: UINT,
FirstArraySlice: UINT,
ArraySize: UINT,
};
pub const TEX2DMS_DSV = extern struct {
UnusedField_NothingToDefine: UINT,
};
pub const TEX2DMS_ARRAY_DSV = extern struct {
FirstArraySlice: UINT,
ArraySize: UINT,
};
pub const DSV_FLAGS = UINT;
pub const DSV_FLAG_NONE = 0;
pub const DSV_FLAG_READ_ONLY_DEPTH = 0x1;
pub const DSV_FLAG_READ_ONLY_STENCIL = 0x2;
pub const DSV_DIMENSION = enum(UINT) {
UNKNOWN = 0,
TEXTURE1D = 1,
TEXTURE1DARRAY = 2,
TEXTURE2D = 3,
TEXTURE2DARRAY = 4,
TEXTURE2DMS = 5,
TEXTURE2DMSARRAY = 6,
};
pub const DEPTH_STENCIL_VIEW_DESC = extern struct {
Format: dxgi.FORMAT,
ViewDimension: DSV_DIMENSION,
Flags: DSV_FLAGS,
u: extern union {
Texture1D: TEX1D_DSV,
Texture1DArray: TEX1D_ARRAY_DSV,
Texture2D: TEX2D_DSV,
Texture2DArray: TEX2D_ARRAY_DSV,
Texture2DMS: TEX2DMS_DSV,
Texture2DMSArray: TEX2DMS_ARRAY_DSV,
},
};
pub const RESOURCE_ALLOCATION_INFO = extern struct {
SizeInBytes: UINT64,
Alignment: UINT64,
};
pub const DEPTH_STENCIL_VALUE = extern struct {
Depth: FLOAT,
Stencil: UINT8,
};
pub const CLEAR_VALUE = extern struct {
Format: dxgi.FORMAT,
u: extern union {
Color: [4]FLOAT,
DepthStencil: DEPTH_STENCIL_VALUE,
},
pub fn initColor(format: dxgi.FORMAT, in_color: *const [4]FLOAT) CLEAR_VALUE {
var v = std.mem.zeroes(@This());
v = .{
.Format = format,
.u = .{ .Color = in_color.* },
};
return v;
}
pub fn initDepthStencil(format: dxgi.FORMAT, depth: FLOAT, stencil: UINT8) CLEAR_VALUE {
var v = std.mem.zeroes(@This());
v = .{
.Format = format,
.u = .{ .DepthStencil = .{ .Depth = depth, .Stencil = stencil } },
};
return v;
}
};
pub const IObject = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetPrivateData(self: *T, guid: *const GUID, data_size: *UINT, data: ?*anyopaque) HRESULT {
return self.v.object.GetPrivateData(self, guid, data_size, data);
}
pub inline fn SetPrivateData(self: *T, guid: *const GUID, data_size: UINT, data: ?*const anyopaque) HRESULT {
return self.v.object.SetPrivateData(self, guid, data_size, data);
}
pub inline fn SetPrivateDataInterface(self: *T, guid: *const GUID, data: ?*const IUnknown) HRESULT {
return self.v.object.SetPrivateDataInterface(self, guid, data);
}
pub inline fn SetName(self: *T, name: LPCWSTR) HRESULT {
return self.v.object.SetName(self, name);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetPrivateData: fn (*T, *const GUID, *UINT, ?*anyopaque) callconv(WINAPI) HRESULT,
SetPrivateData: fn (*T, *const GUID, UINT, ?*const anyopaque) callconv(WINAPI) HRESULT,
SetPrivateDataInterface: fn (*T, *const GUID, ?*const IUnknown) callconv(WINAPI) HRESULT,
SetName: fn (*T, LPCWSTR) callconv(WINAPI) HRESULT,
};
}
};
pub const IDeviceChild = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetDevice(self: *T, guid: *const GUID, device: *?*anyopaque) HRESULT {
return self.v.devchild.GetDevice(self, guid, device);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetDevice: fn (*T, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
};
}
};
pub const IRootSignature = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
rs: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
_ = T;
return extern struct {};
}
fn VTable(comptime T: type) type {
_ = T;
return extern struct {};
}
};
pub const IQueryHeap = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
qheap: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
_ = T;
return extern struct {};
}
fn VTable(comptime T: type) type {
_ = T;
return extern struct {};
}
};
pub const ICommandSignature = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
cmdsig: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
_ = T;
return extern struct {};
}
fn VTable(comptime T: type) type {
_ = T;
return extern struct {};
}
};
pub const IPageable = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
_ = T;
return extern struct {};
}
fn VTable(comptime T: type) type {
_ = T;
return extern struct {};
}
};
pub const IHeap = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
heap: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetDesc(self: *T) HEAP_DESC {
var desc: HEAP_DESC = undefined;
_ = self.v.heap.GetDesc(self, &desc);
return desc;
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetDesc: fn (*T, *HEAP_DESC) callconv(WINAPI) *HEAP_DESC,
};
}
};
pub const IResource = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
resource: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn Map(self: *T, subresource: UINT, read_range: ?*const RANGE, data: *?*anyopaque) HRESULT {
return self.v.resource.Map(self, subresource, read_range, data);
}
pub inline fn Unmap(self: *T, subresource: UINT, written_range: ?*const RANGE) void {
self.v.resource.Unmap(self, subresource, written_range);
}
pub inline fn GetDesc(self: *T) RESOURCE_DESC {
var desc: RESOURCE_DESC = undefined;
_ = self.v.resource.GetDesc(self, &desc);
return desc;
}
pub inline fn GetGPUVirtualAddress(self: *T) GPU_VIRTUAL_ADDRESS {
return self.v.resource.GetGPUVirtualAddress(self);
}
pub inline fn WriteToSubresource(
self: *T,
dst_subresource: UINT,
dst_box: ?*const BOX,
src_data: *const anyopaque,
src_row_pitch: UINT,
src_depth_pitch: UINT,
) HRESULT {
return self.v.resource.WriteToSubresource(
self,
dst_subresource,
dst_box,
src_data,
src_row_pitch,
src_depth_pitch,
);
}
pub inline fn ReadFromSubresource(
self: *T,
dst_data: *anyopaque,
dst_row_pitch: UINT,
dst_depth_pitch: UINT,
src_subresource: UINT,
src_box: ?*const BOX,
) HRESULT {
return self.v.resource.ReadFromSubresource(
self,
dst_data,
dst_row_pitch,
dst_depth_pitch,
src_subresource,
src_box,
);
}
pub inline fn GetHeapProperties(
self: *T,
properties: ?*HEAP_PROPERTIES,
flags: ?*HEAP_FLAGS,
) HRESULT {
return self.v.resource.GetHeapProperties(self, properties, flags);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
Map: fn (*T, UINT, ?*const RANGE, *?*anyopaque) callconv(WINAPI) HRESULT,
Unmap: fn (*T, UINT, ?*const RANGE) callconv(WINAPI) void,
GetDesc: fn (*T, *RESOURCE_DESC) callconv(WINAPI) *RESOURCE_DESC,
GetGPUVirtualAddress: fn (*T) callconv(WINAPI) GPU_VIRTUAL_ADDRESS,
WriteToSubresource: fn (*T, UINT, ?*const BOX, *const anyopaque, UINT, UINT) callconv(WINAPI) HRESULT,
ReadFromSubresource: fn (*T, *anyopaque, UINT, UINT, UINT, ?*const BOX) callconv(WINAPI) HRESULT,
GetHeapProperties: fn (*T, ?*HEAP_PROPERTIES, ?*HEAP_FLAGS) callconv(WINAPI) HRESULT,
};
}
};
pub const IResource1 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
resource: IResource.VTable(Self),
resource1: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace IResource.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetProtectedResourceSession(self: *T, guid: *const GUID, session: *?*anyopaque) HRESULT {
return self.v.resource1.GetProtectedResourceSession(self, guid, session);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetProtectedResourceSession: fn (*T, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
};
}
};
pub const ICommandAllocator = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
alloc: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn Reset(self: *T) HRESULT {
return self.v.alloc.Reset(self);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
Reset: fn (*T) callconv(WINAPI) HRESULT,
};
}
};
pub const IFence = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
fence: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetCompletedValue(self: *T) UINT64 {
return self.v.fence.GetCompletedValue(self);
}
pub inline fn SetEventOnCompletion(self: *T, value: UINT64, event: HANDLE) HRESULT {
return self.v.fence.SetEventOnCompletion(self, value, event);
}
pub inline fn Signal(self: *T, value: UINT64) HRESULT {
return self.v.fence.Signal(self, value);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetCompletedValue: fn (*T) callconv(WINAPI) UINT64,
SetEventOnCompletion: fn (*T, UINT64, HANDLE) callconv(WINAPI) HRESULT,
Signal: fn (*T, UINT64) callconv(WINAPI) HRESULT,
};
}
};
pub const IFence1 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
fence: IFence.VTable(Self),
fence1: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace IFence.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetCreationFlags(self: *T) FENCE_FLAGS {
return self.v.fence1.GetCreationFlags(self);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetCreationFlags: fn (*T) callconv(WINAPI) FENCE_FLAGS,
};
}
};
pub const IPipelineState = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
pstate: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetCachedBlob(self: *T, blob: **d3d.IBlob) HRESULT {
return self.v.pstate.GetCachedBlob(self, blob);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetCachedBlob: fn (*T, **d3d.IBlob) callconv(WINAPI) HRESULT,
};
}
};
pub const IDescriptorHeap = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
dheap: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetDesc(self: *T) DESCRIPTOR_HEAP_DESC {
var desc: DESCRIPTOR_HEAP_DESC = undefined;
_ = self.v.dheap.GetDesc(self, &desc);
return desc;
}
pub inline fn GetCPUDescriptorHandleForHeapStart(self: *T) CPU_DESCRIPTOR_HANDLE {
var handle: CPU_DESCRIPTOR_HANDLE = undefined;
_ = self.v.dheap.GetCPUDescriptorHandleForHeapStart(self, &handle);
return handle;
}
pub inline fn GetGPUDescriptorHandleForHeapStart(self: *T) GPU_DESCRIPTOR_HANDLE {
var handle: GPU_DESCRIPTOR_HANDLE = undefined;
_ = self.v.dheap.GetGPUDescriptorHandleForHeapStart(self, &handle);
return handle;
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetDesc: fn (*T, *DESCRIPTOR_HEAP_DESC) callconv(WINAPI) *DESCRIPTOR_HEAP_DESC,
GetCPUDescriptorHandleForHeapStart: fn (
*T,
*CPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) *CPU_DESCRIPTOR_HANDLE,
GetGPUDescriptorHandleForHeapStart: fn (
*T,
*GPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) *GPU_DESCRIPTOR_HANDLE,
};
}
};
pub const ICommandList = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
cmdlist: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetType(self: *T) COMMAND_LIST_TYPE {
return self.v.cmdlist.GetType(self);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetType: fn (*T) callconv(WINAPI) COMMAND_LIST_TYPE,
};
}
};
pub const IGraphicsCommandList = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
cmdlist: ICommandList.VTable(Self),
grcmdlist: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace ICommandList.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn Close(self: *T) HRESULT {
return self.v.grcmdlist.Close(self);
}
pub inline fn Reset(self: *T, alloc: *ICommandAllocator, initial_state: ?*IPipelineState) HRESULT {
return self.v.grcmdlist.Reset(self, alloc, initial_state);
}
pub inline fn ClearState(self: *T, pso: ?*IPipelineState) void {
self.v.grcmdlist.ClearState(self, pso);
}
pub inline fn DrawInstanced(
self: *T,
vertex_count_per_instance: UINT,
instance_count: UINT,
start_vertex_location: UINT,
start_instance_location: UINT,
) void {
self.v.grcmdlist.DrawInstanced(
self,
vertex_count_per_instance,
instance_count,
start_vertex_location,
start_instance_location,
);
}
pub inline fn DrawIndexedInstanced(
self: *T,
index_count_per_instance: UINT,
instance_count: UINT,
start_index_location: UINT,
base_vertex_location: INT,
start_instance_location: UINT,
) void {
self.v.grcmdlist.DrawIndexedInstanced(
self,
index_count_per_instance,
instance_count,
start_index_location,
base_vertex_location,
start_instance_location,
);
}
pub inline fn Dispatch(self: *T, count_x: UINT, count_y: UINT, count_z: UINT) void {
self.v.grcmdlist.Dispatch(self, count_x, count_y, count_z);
}
pub inline fn CopyBufferRegion(
self: *T,
dst_buffer: *IResource,
dst_offset: UINT64,
src_buffer: *IResource,
src_offset: UINT64,
num_bytes: UINT64,
) void {
self.v.grcmdlist.CopyBufferRegion(
self,
dst_buffer,
dst_offset,
src_buffer,
src_offset,
num_bytes,
);
}
pub inline fn CopyTextureRegion(
self: *T,
dst: *const TEXTURE_COPY_LOCATION,
dst_x: UINT,
dst_y: UINT,
dst_z: UINT,
src: *const TEXTURE_COPY_LOCATION,
src_box: ?*const BOX,
) void {
self.v.grcmdlist.CopyTextureRegion(self, dst, dst_x, dst_y, dst_z, src, src_box);
}
pub inline fn CopyResource(self: *T, dst: *IResource, src: *IResource) void {
self.v.grcmdlist.CopyResource(self, dst, src);
}
pub inline fn CopyTiles(
self: *T,
tiled_resource: *IResource,
tile_region_start_coordinate: *const TILED_RESOURCE_COORDINATE,
tile_region_size: *const TILE_REGION_SIZE,
buffer: *IResource,
buffer_start_offset_in_bytes: UINT64,
flags: TILE_COPY_FLAGS,
) void {
self.v.grcmdlist.CopyTiles(
self,
tiled_resource,
tile_region_start_coordinate,
tile_region_size,
buffer,
buffer_start_offset_in_bytes,
flags,
);
}
pub inline fn ResolveSubresource(
self: *T,
dst_resource: *IResource,
dst_subresource: UINT,
src_resource: *IResource,
src_subresource: UINT,
format: dxgi.FORMAT,
) void {
self.v.grcmdlist.ResolveSubresource(
self,
dst_resource,
dst_subresource,
src_resource,
src_subresource,
format,
);
}
pub inline fn IASetPrimitiveTopology(self: *T, topology: PRIMITIVE_TOPOLOGY) void {
self.v.grcmdlist.IASetPrimitiveTopology(self, topology);
}
pub inline fn RSSetViewports(self: *T, num: UINT, viewports: [*]const VIEWPORT) void {
self.v.grcmdlist.RSSetViewports(self, num, viewports);
}
pub inline fn RSSetScissorRects(self: *T, num: UINT, rects: [*]const RECT) void {
self.v.grcmdlist.RSSetScissorRects(self, num, rects);
}
pub inline fn OMSetBlendFactor(self: *T, blend_factor: *const [4]FLOAT) void {
self.v.grcmdlist.OMSetBlendFactor(self, blend_factor);
}
pub inline fn OMSetStencilRef(self: *T, stencil_ref: UINT) void {
self.v.grcmdlist.OMSetStencilRef(self, stencil_ref);
}
pub inline fn SetPipelineState(self: *T, pso: *IPipelineState) void {
self.v.grcmdlist.SetPipelineState(self, pso);
}
pub inline fn ResourceBarrier(self: *T, num: UINT, barriers: [*]const RESOURCE_BARRIER) void {
self.v.grcmdlist.ResourceBarrier(self, num, barriers);
}
pub inline fn ExecuteBundle(self: *T, cmdlist: *IGraphicsCommandList) void {
self.v.grcmdlist.ExecuteBundle(self, cmdlist);
}
pub inline fn SetDescriptorHeaps(self: *T, num: UINT, heaps: [*]const *IDescriptorHeap) void {
self.v.grcmdlist.SetDescriptorHeaps(self, num, heaps);
}
pub inline fn SetComputeRootSignature(self: *T, root_signature: ?*IRootSignature) void {
self.v.grcmdlist.SetComputeRootSignature(self, root_signature);
}
pub inline fn SetGraphicsRootSignature(self: *T, root_signature: ?*IRootSignature) void {
self.v.grcmdlist.SetGraphicsRootSignature(self, root_signature);
}
pub inline fn SetComputeRootDescriptorTable(
self: *T,
root_index: UINT,
base_descriptor: GPU_DESCRIPTOR_HANDLE,
) void {
self.v.grcmdlist.SetComputeRootDescriptorTable(self, root_index, base_descriptor);
}
pub inline fn SetGraphicsRootDescriptorTable(
self: *T,
root_index: UINT,
base_descriptor: GPU_DESCRIPTOR_HANDLE,
) void {
self.v.grcmdlist.SetGraphicsRootDescriptorTable(self, root_index, base_descriptor);
}
pub inline fn SetComputeRoot32BitConstant(self: *T, index: UINT, data: UINT, off: UINT) void {
self.v.grcmdlist.SetComputeRoot32BitConstant(self, index, data, off);
}
pub inline fn SetGraphicsRoot32BitConstant(self: *T, index: UINT, data: UINT, off: UINT) void {
self.v.grcmdlist.SetGraphicsRoot32BitConstant(self, index, data, off);
}
pub inline fn SetComputeRoot32BitConstants(
self: *T,
root_index: UINT,
num: UINT,
data: *const anyopaque,
offset: UINT,
) void {
self.v.grcmdlist.SetComputeRoot32BitConstants(self, root_index, num, data, offset);
}
pub inline fn SetGraphicsRoot32BitConstants(
self: *T,
root_index: UINT,
num: UINT,
data: *const anyopaque,
offset: UINT,
) void {
self.v.grcmdlist.SetGraphicsRoot32BitConstants(self, root_index, num, data, offset);
}
pub inline fn SetComputeRootConstantBufferView(
self: *T,
index: UINT,
buffer_location: GPU_VIRTUAL_ADDRESS,
) void {
self.v.grcmdlist.SetComputeRootConstantBufferView(self, index, buffer_location);
}
pub inline fn SetGraphicsRootConstantBufferView(
self: *T,
index: UINT,
buffer_location: GPU_VIRTUAL_ADDRESS,
) void {
self.v.grcmdlist.SetGraphicsRootConstantBufferView(self, index, buffer_location);
}
pub inline fn SetComputeRootShaderResourceView(
self: *T,
index: UINT,
buffer_location: GPU_VIRTUAL_ADDRESS,
) void {
self.v.grcmdlist.SetComputeRootShaderResourceView(self, index, buffer_location);
}
pub inline fn SetGraphicsRootShaderResourceView(
self: *T,
index: UINT,
buffer_location: GPU_VIRTUAL_ADDRESS,
) void {
self.v.grcmdlist.SetGraphicsRootShaderResourceView(self, index, buffer_location);
}
pub inline fn SetComputeRootUnorderedAccessView(
self: *T,
index: UINT,
buffer_location: GPU_VIRTUAL_ADDRESS,
) void {
self.v.grcmdlist.SetComputeRootUnorderedAccessView(self, index, buffer_location);
}
pub inline fn SetGraphicsRootUnorderedAccessView(
self: *T,
index: UINT,
buffer_location: GPU_VIRTUAL_ADDRESS,
) void {
self.v.grcmdlist.SetGraphicsRootUnorderedAccessView(self, index, buffer_location);
}
pub inline fn IASetIndexBuffer(self: *T, view: ?*const INDEX_BUFFER_VIEW) void {
self.v.grcmdlist.IASetIndexBuffer(self, view);
}
pub inline fn IASetVertexBuffers(
self: *T,
start_slot: UINT,
num_views: UINT,
views: ?[*]const VERTEX_BUFFER_VIEW,
) void {
self.v.grcmdlist.IASetVertexBuffers(self, start_slot, num_views, views);
}
pub inline fn SOSetTargets(
self: *T,
start_slot: UINT,
num_views: UINT,
views: ?[*]const STREAM_OUTPUT_BUFFER_VIEW,
) void {
self.v.grcmdlist.SOSetTargets(self, start_slot, num_views, views);
}
pub inline fn OMSetRenderTargets(
self: *T,
num_rt_descriptors: UINT,
rt_descriptors: ?[*]const CPU_DESCRIPTOR_HANDLE,
single_handle: BOOL,
ds_descriptors: ?*const CPU_DESCRIPTOR_HANDLE,
) void {
self.v.grcmdlist.OMSetRenderTargets(
self,
num_rt_descriptors,
rt_descriptors,
single_handle,
ds_descriptors,
);
}
pub inline fn ClearDepthStencilView(
self: *T,
ds_view: CPU_DESCRIPTOR_HANDLE,
clear_flags: CLEAR_FLAGS,
depth: FLOAT,
stencil: UINT8,
num_rects: UINT,
rects: ?[*]const RECT,
) void {
self.v.grcmdlist.ClearDepthStencilView(
self,
ds_view,
clear_flags,
depth,
stencil,
num_rects,
rects,
);
}
pub inline fn ClearRenderTargetView(
self: *T,
rt_view: CPU_DESCRIPTOR_HANDLE,
rgba: *const [4]FLOAT,
num_rects: UINT,
rects: ?[*]const RECT,
) void {
self.v.grcmdlist.ClearRenderTargetView(self, rt_view, rgba, num_rects, rects);
}
pub inline fn ClearUnorderedAccessViewUint(
self: *T,
gpu_view: GPU_DESCRIPTOR_HANDLE,
cpu_view: CPU_DESCRIPTOR_HANDLE,
resource: *IResource,
values: *const [4]UINT,
num_rects: UINT,
rects: ?[*]const RECT,
) void {
self.v.grcmdlist.ClearUnorderedAccessViewUint(
self,
gpu_view,
cpu_view,
resource,
values,
num_rects,
rects,
);
}
pub inline fn ClearUnorderedAccessViewFloat(
self: *T,
gpu_view: GPU_DESCRIPTOR_HANDLE,
cpu_view: CPU_DESCRIPTOR_HANDLE,
resource: *IResource,
values: *const [4]FLOAT,
num_rects: UINT,
rects: ?[*]const RECT,
) void {
self.v.grcmdlist.ClearUnorderedAccessViewFloat(
self,
gpu_view,
cpu_view,
resource,
values,
num_rects,
rects,
);
}
pub inline fn DiscardResource(self: *T, resource: *IResource, region: ?*const DISCARD_REGION) void {
self.v.grcmdlist.DiscardResource(self, resource, region);
}
pub inline fn BeginQuery(self: *T, query: *IQueryHeap, query_type: QUERY_TYPE, index: UINT) void {
self.v.grcmdlist.BeginQuery(self, query, query_type, index);
}
pub inline fn EndQuery(self: *T, query: *IQueryHeap, query_type: QUERY_TYPE, index: UINT) void {
self.v.grcmdlist.EndQuery(self, query, query_type, index);
}
pub inline fn ResolveQueryData(
self: *T,
query: *IQueryHeap,
query_type: QUERY_TYPE,
start_index: UINT,
num_queries: UINT,
dst_resource: *IResource,
buffer_offset: UINT64,
) void {
self.v.grcmdlist.ResolveQueryData(
self,
query,
query_type,
start_index,
num_queries,
dst_resource,
buffer_offset,
);
}
pub inline fn SetPredication(
self: *T,
buffer: ?*IResource,
buffer_offset: UINT64,
operation: PREDICATION_OP,
) void {
self.v.grcmdlist.SetPredication(self, buffer, buffer_offset, operation);
}
pub inline fn SetMarker(self: *T, metadata: UINT, data: ?*const anyopaque, size: UINT) void {
self.v.grcmdlist.SetMarker(self, metadata, data, size);
}
pub inline fn BeginEvent(self: *T, metadata: UINT, data: ?*const anyopaque, size: UINT) void {
self.v.grcmdlist.BeginEvent(self, metadata, data, size);
}
pub inline fn EndEvent(self: *T) void {
self.v.grcmdlist.EndEvent(self);
}
pub inline fn ExecuteIndirect(
self: *T,
command_signature: *ICommandSignature,
max_command_count: UINT,
arg_buffer: *IResource,
arg_buffer_offset: UINT64,
count_buffer: ?*IResource,
count_buffer_offset: UINT64,
) void {
self.v.grcmdlist.ExecuteIndirect(
self,
command_signature,
max_command_count,
arg_buffer,
arg_buffer_offset,
count_buffer,
count_buffer_offset,
);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
Close: fn (*T) callconv(.C) HRESULT,
Reset: fn (*T, *ICommandAllocator, ?*IPipelineState) callconv(WINAPI) HRESULT,
ClearState: fn (*T, ?*IPipelineState) callconv(WINAPI) void,
DrawInstanced: fn (*T, UINT, UINT, UINT, UINT) callconv(WINAPI) void,
DrawIndexedInstanced: fn (*T, UINT, UINT, UINT, INT, UINT) callconv(WINAPI) void,
Dispatch: fn (*T, UINT, UINT, UINT) callconv(WINAPI) void,
CopyBufferRegion: fn (*T, *IResource, UINT64, *IResource, UINT64, UINT64) callconv(WINAPI) void,
CopyTextureRegion: fn (
*T,
*const TEXTURE_COPY_LOCATION,
UINT,
UINT,
UINT,
*const TEXTURE_COPY_LOCATION,
?*const BOX,
) callconv(WINAPI) void,
CopyResource: fn (*T, *IResource, *IResource) callconv(WINAPI) void,
CopyTiles: fn (
*T,
*IResource,
*const TILED_RESOURCE_COORDINATE,
*const TILE_REGION_SIZE,
*IResource,
buffer_start_offset_in_bytes: UINT64,
TILE_COPY_FLAGS,
) callconv(WINAPI) void,
ResolveSubresource: fn (*T, *IResource, UINT, *IResource, UINT, dxgi.FORMAT) callconv(WINAPI) void,
IASetPrimitiveTopology: fn (*T, PRIMITIVE_TOPOLOGY) callconv(WINAPI) void,
RSSetViewports: fn (*T, UINT, [*]const VIEWPORT) callconv(WINAPI) void,
RSSetScissorRects: fn (*T, UINT, [*]const RECT) callconv(WINAPI) void,
OMSetBlendFactor: fn (*T, *const [4]FLOAT) callconv(WINAPI) void,
OMSetStencilRef: fn (*T, UINT) callconv(WINAPI) void,
SetPipelineState: fn (*T, *IPipelineState) callconv(WINAPI) void,
ResourceBarrier: fn (*T, UINT, [*]const RESOURCE_BARRIER) callconv(WINAPI) void,
ExecuteBundle: fn (*T, *IGraphicsCommandList) callconv(WINAPI) void,
SetDescriptorHeaps: fn (*T, UINT, [*]const *IDescriptorHeap) callconv(WINAPI) void,
SetComputeRootSignature: fn (*T, ?*IRootSignature) callconv(WINAPI) void,
SetGraphicsRootSignature: fn (*T, ?*IRootSignature) callconv(WINAPI) void,
SetComputeRootDescriptorTable: fn (*T, UINT, GPU_DESCRIPTOR_HANDLE) callconv(WINAPI) void,
SetGraphicsRootDescriptorTable: fn (*T, UINT, GPU_DESCRIPTOR_HANDLE) callconv(WINAPI) void,
SetComputeRoot32BitConstant: fn (*T, UINT, UINT, UINT) callconv(WINAPI) void,
SetGraphicsRoot32BitConstant: fn (*T, UINT, UINT, UINT) callconv(WINAPI) void,
SetComputeRoot32BitConstants: fn (*T, UINT, UINT, *const anyopaque, UINT) callconv(WINAPI) void,
SetGraphicsRoot32BitConstants: fn (*T, UINT, UINT, *const anyopaque, UINT) callconv(WINAPI) void,
SetComputeRootConstantBufferView: fn (*T, UINT, GPU_VIRTUAL_ADDRESS) callconv(WINAPI) void,
SetGraphicsRootConstantBufferView: fn (*T, UINT, GPU_VIRTUAL_ADDRESS) callconv(WINAPI) void,
SetComputeRootShaderResourceView: fn (*T, UINT, GPU_VIRTUAL_ADDRESS) callconv(WINAPI) void,
SetGraphicsRootShaderResourceView: fn (*T, UINT, GPU_VIRTUAL_ADDRESS) callconv(WINAPI) void,
SetComputeRootUnorderedAccessView: fn (*T, UINT, GPU_VIRTUAL_ADDRESS) callconv(WINAPI) void,
SetGraphicsRootUnorderedAccessView: fn (*T, UINT, GPU_VIRTUAL_ADDRESS) callconv(WINAPI) void,
IASetIndexBuffer: fn (*T, ?*const INDEX_BUFFER_VIEW) callconv(WINAPI) void,
IASetVertexBuffers: fn (*T, UINT, UINT, ?[*]const VERTEX_BUFFER_VIEW) callconv(WINAPI) void,
SOSetTargets: fn (*T, UINT, UINT, ?[*]const STREAM_OUTPUT_BUFFER_VIEW) callconv(WINAPI) void,
OMSetRenderTargets: fn (
*T,
UINT,
?[*]const CPU_DESCRIPTOR_HANDLE,
BOOL,
?*const CPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) void,
ClearDepthStencilView: fn (
*T,
CPU_DESCRIPTOR_HANDLE,
CLEAR_FLAGS,
FLOAT,
UINT8,
UINT,
?[*]const RECT,
) callconv(WINAPI) void,
ClearRenderTargetView: fn (
*T,
CPU_DESCRIPTOR_HANDLE,
*const [4]FLOAT,
UINT,
?[*]const RECT,
) callconv(WINAPI) void,
ClearUnorderedAccessViewUint: fn (
*T,
GPU_DESCRIPTOR_HANDLE,
CPU_DESCRIPTOR_HANDLE,
*IResource,
*const [4]UINT,
UINT,
?[*]const RECT,
) callconv(WINAPI) void,
ClearUnorderedAccessViewFloat: fn (
*T,
GPU_DESCRIPTOR_HANDLE,
CPU_DESCRIPTOR_HANDLE,
*IResource,
*const [4]FLOAT,
UINT,
?[*]const RECT,
) callconv(WINAPI) void,
DiscardResource: fn (*T, *IResource, ?*const DISCARD_REGION) callconv(WINAPI) void,
BeginQuery: fn (*T, *IQueryHeap, QUERY_TYPE, UINT) callconv(WINAPI) void,
EndQuery: fn (*T, *IQueryHeap, QUERY_TYPE, UINT) callconv(WINAPI) void,
ResolveQueryData: fn (
*T,
*IQueryHeap,
QUERY_TYPE,
UINT,
UINT,
*IResource,
UINT64,
) callconv(WINAPI) void,
SetPredication: fn (*T, ?*IResource, UINT64, PREDICATION_OP) callconv(WINAPI) void,
SetMarker: fn (*T, UINT, ?*const anyopaque, UINT) callconv(WINAPI) void,
BeginEvent: fn (*T, UINT, ?*const anyopaque, UINT) callconv(WINAPI) void,
EndEvent: fn (*T) callconv(WINAPI) void,
ExecuteIndirect: fn (
*T,
*ICommandSignature,
UINT,
*IResource,
UINT64,
?*IResource,
UINT64,
) callconv(WINAPI) void,
};
}
};
pub const RANGE_UINT64 = extern struct {
Begin: UINT64,
End: UINT64,
};
pub const SUBRESOURCE_RANGE_UINT64 = extern struct {
Subresource: UINT,
Range: RANGE_UINT64,
};
pub const SAMPLE_POSITION = extern struct {
X: INT8,
Y: INT8,
};
pub const RESOLVE_MODE = enum(UINT) {
DECOMPRESS = 0,
MIN = 1,
MAX = 2,
AVERAGE = 3,
ENCODE_SAMPLER_FEEDBACK = 4,
DECODE_SAMPLER_FEEDBACK = 5,
};
pub const IGraphicsCommandList1 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
cmdlist: ICommandList.VTable(Self),
grcmdlist: IGraphicsCommandList.VTable(Self),
grcmdlist1: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace ICommandList.Methods(Self);
usingnamespace IGraphicsCommandList.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn AtomicCopyBufferUINT(
self: *T,
dst_buffer: *IResource,
dst_offset: UINT64,
src_buffer: *IResource,
src_offset: UINT64,
dependencies: UINT,
dependent_resources: [*]const *IResource,
dependent_subresource_ranges: [*]const SUBRESOURCE_RANGE_UINT64,
) void {
self.v.grcmdlist1.AtomicCopyBufferUINT(
self,
dst_buffer,
dst_offset,
src_buffer,
src_offset,
dependencies,
dependent_resources,
dependent_subresource_ranges,
);
}
pub inline fn AtomicCopyBufferUINT64(
self: *T,
dst_buffer: *IResource,
dst_offset: UINT64,
src_buffer: *IResource,
src_offset: UINT64,
dependencies: UINT,
dependent_resources: [*]const *IResource,
dependent_subresource_ranges: [*]const SUBRESOURCE_RANGE_UINT64,
) void {
self.v.grcmdlist1.AtomicCopyBufferUINT64(
self,
dst_buffer,
dst_offset,
src_buffer,
src_offset,
dependencies,
dependent_resources,
dependent_subresource_ranges,
);
}
pub inline fn OMSetDepthBounds(self: *T, min: FLOAT, max: FLOAT) void {
self.v.grcmdlist1.OMSetDepthBounds(self, min, max);
}
pub inline fn SetSamplePositions(
self: *T,
num_samples: UINT,
num_pixels: UINT,
sample_positions: *SAMPLE_POSITION,
) void {
self.v.grcmdlist1.SetSamplePositions(self, num_samples, num_pixels, sample_positions);
}
pub inline fn ResolveSubresourceRegion(
self: *T,
dst_resource: *IResource,
dst_subresource: UINT,
dst_x: UINT,
dst_y: UINT,
src_resource: *IResource,
src_subresource: UINT,
src_rect: *RECT,
format: dxgi.FORMAT,
resolve_mode: RESOLVE_MODE,
) void {
self.v.grcmdlist1.ResolveSubresourceRegion(
self,
dst_resource,
dst_subresource,
dst_x,
dst_y,
src_resource,
src_subresource,
src_rect,
format,
resolve_mode,
);
}
pub inline fn SetViewInstanceMask(self: *T, mask: UINT) void {
self.v.grcmdlist1.SetViewInstanceMask(self, mask);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
AtomicCopyBufferUINT: fn (
*T,
*IResource,
UINT64,
*IResource,
UINT64,
UINT,
[*]const *IResource,
[*]const SUBRESOURCE_RANGE_UINT64,
) callconv(WINAPI) void,
AtomicCopyBufferUINT64: fn (
*T,
*IResource,
UINT64,
*IResource,
UINT64,
UINT,
[*]const *IResource,
[*]const SUBRESOURCE_RANGE_UINT64,
) callconv(WINAPI) void,
OMSetDepthBounds: fn (*T, FLOAT, FLOAT) callconv(WINAPI) void,
SetSamplePositions: fn (*T, UINT, UINT, *SAMPLE_POSITION) callconv(WINAPI) void,
ResolveSubresourceRegion: fn (
*T,
*IResource,
UINT,
UINT,
UINT,
*IResource,
UINT,
*RECT,
dxgi.FORMAT,
RESOLVE_MODE,
) callconv(WINAPI) void,
SetViewInstanceMask: fn (*T, UINT) callconv(WINAPI) void,
};
}
};
pub const WRITEBUFFERIMMEDIATE_PARAMETER = extern struct {
Dest: GPU_VIRTUAL_ADDRESS,
Value: UINT32,
};
pub const WRITEBUFFERIMMEDIATE_MODE = enum(UINT) {
DEFAULT = 0,
MARKER_IN = 0x1,
MARKER_OUT = 0x2,
};
pub const IGraphicsCommandList2 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
cmdlist: ICommandList.VTable(Self),
grcmdlist: IGraphicsCommandList.VTable(Self),
grcmdlist1: IGraphicsCommandList1.VTable(Self),
grcmdlist2: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace ICommandList.Methods(Self);
usingnamespace IGraphicsCommandList.Methods(Self);
usingnamespace IGraphicsCommandList1.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn WriteBufferImmediate(
self: *T,
count: UINT,
params: [*]const WRITEBUFFERIMMEDIATE_PARAMETER,
modes: ?[*]const WRITEBUFFERIMMEDIATE_MODE,
) void {
self.v.grcmdlist2.WriteBufferImmediate(self, count, params, modes);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
WriteBufferImmediate: fn (
*T,
UINT,
[*]const WRITEBUFFERIMMEDIATE_PARAMETER,
?[*]const WRITEBUFFERIMMEDIATE_MODE,
) callconv(WINAPI) void,
};
}
};
pub const IGraphicsCommandList3 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
cmdlist: ICommandList.VTable(Self),
grcmdlist: IGraphicsCommandList.VTable(Self),
grcmdlist1: IGraphicsCommandList1.VTable(Self),
grcmdlist2: IGraphicsCommandList2.VTable(Self),
grcmdlist3: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace ICommandList.Methods(Self);
usingnamespace IGraphicsCommandList.Methods(Self);
usingnamespace IGraphicsCommandList1.Methods(Self);
usingnamespace IGraphicsCommandList2.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn SetProtectedResourceSession(self: *T, prsession: ?*IProtectedResourceSession) void {
self.v.grcmdlist3.SetProtectedResourceSession(self, prsession);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
SetProtectedResourceSession: fn (*T, ?*IProtectedResourceSession) callconv(WINAPI) void,
};
}
};
pub const RENDER_PASS_BEGINNING_ACCESS_TYPE = enum(UINT) {
DISCARD = 0,
PRESERVE = 1,
CLEAR = 2,
NO_ACCESS = 3,
};
pub const RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS = extern struct {
ClearValue: CLEAR_VALUE,
};
pub const RENDER_PASS_BEGINNING_ACCESS = extern struct {
Type: RENDER_PASS_BEGINNING_ACCESS_TYPE,
u: extern union {
Clear: RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS,
},
};
pub const RENDER_PASS_ENDING_ACCESS_TYPE = enum(UINT) {
DISCARD = 0,
PRESERVE = 1,
RESOLVE = 2,
NO_ACCESS = 3,
};
pub const RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS = extern struct {
SrcSubresource: UINT,
DstSubresource: UINT,
DstX: UINT,
DstY: UINT,
SrcRect: RECT,
};
pub const RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS = extern struct {
pSrcResource: *IResource,
pDstResource: *IResource,
SubresourceCount: UINT,
pSubresourceParameters: [*]const RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS,
Format: dxgi.FORMAT,
ResolveMode: RESOLVE_MODE,
PreserveResolveSource: BOOL,
};
pub const RENDER_PASS_ENDING_ACCESS = extern struct {
Type: RENDER_PASS_ENDING_ACCESS_TYPE,
u: extern union {
Resolve: RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS,
},
};
pub const RENDER_PASS_RENDER_TARGET_DESC = extern struct {
cpuDescriptor: CPU_DESCRIPTOR_HANDLE,
BeginningAccess: RENDER_PASS_BEGINNING_ACCESS,
EndingAccess: RENDER_PASS_ENDING_ACCESS,
};
pub const RENDER_PASS_DEPTH_STENCIL_DESC = extern struct {
cpuDescriptor: CPU_DESCRIPTOR_HANDLE,
DepthBeginningAccess: RENDER_PASS_BEGINNING_ACCESS,
StencilBeginningAccess: RENDER_PASS_BEGINNING_ACCESS,
DepthEndingAccess: RENDER_PASS_ENDING_ACCESS,
StencilEndingAccess: RENDER_PASS_ENDING_ACCESS,
};
pub const RENDER_PASS_FLAGS = UINT;
pub const RENDER_PASS_FLAG_NONE = 0;
pub const RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1;
pub const RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2;
pub const RENDER_PASS_FLAG_RESUMING_PASS = 0x4;
pub const META_COMMAND_PARAMETER_TYPE = enum(UINT) {
FLOAT = 0,
UINT64 = 1,
GPU_VIRTUAL_ADDRESS = 2,
CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 3,
GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 4,
};
pub const META_COMMAND_PARAMETER_FLAGS = UINT;
pub const META_COMMAND_PARAMETER_FLAG_INPUT = 0x1;
pub const META_COMMAND_PARAMETER_FLAG_OUTPUT = 0x2;
pub const META_COMMAND_PARAMETER_STAGE = enum(UINT) {
CREATION = 0,
INITIALIZATION = 1,
EXECUTION = 2,
};
pub const META_COMMAND_PARAMETER_DESC = extern struct {
Name: LPCWSTR,
Type: META_COMMAND_PARAMETER_TYPE,
Flags: META_COMMAND_PARAMETER_FLAGS,
RequiredResourceState: RESOURCE_STATES,
StructureOffset: UINT,
};
pub const GRAPHICS_STATES = UINT;
pub const GRAPHICS_STATE_NONE = 0;
pub const GRAPHICS_STATE_IA_VERTEX_BUFFERS = (1 << 0);
pub const GRAPHICS_STATE_IA_INDEX_BUFFER = (1 << 1);
pub const GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = (1 << 2);
pub const GRAPHICS_STATE_DESCRIPTOR_HEAP = (1 << 3);
pub const GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = (1 << 4);
pub const GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = (1 << 5);
pub const GRAPHICS_STATE_RS_VIEWPORTS = (1 << 6);
pub const GRAPHICS_STATE_RS_SCISSOR_RECTS = (1 << 7);
pub const GRAPHICS_STATE_PREDICATION = (1 << 8);
pub const GRAPHICS_STATE_OM_RENDER_TARGETS = (1 << 9);
pub const GRAPHICS_STATE_OM_STENCIL_REF = (1 << 10);
pub const GRAPHICS_STATE_OM_BLEND_FACTOR = (1 << 11);
pub const GRAPHICS_STATE_PIPELINE_STATE = (1 << 12);
pub const GRAPHICS_STATE_SO_TARGETS = (1 << 13);
pub const GRAPHICS_STATE_OM_DEPTH_BOUNDS = (1 << 14);
pub const GRAPHICS_STATE_SAMPLE_POSITIONS = (1 << 15);
pub const GRAPHICS_STATE_VIEW_INSTANCE_MASK = (1 << 16);
pub const META_COMMAND_DESC = extern struct {
Id: GUID,
Name: LPCWSTR,
InitializationDirtyState: GRAPHICS_STATES,
ExecutionDirtyState: GRAPHICS_STATES,
};
pub const IMetaCommand = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
metacmd: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetRequiredParameterResourceSize(
self: *T,
stage: META_COMMAND_PARAMETER_STAGE,
param_index: UINT,
) UINT64 {
return self.v.metacmd.GetRequiredParameterResourceSize(self, stage, param_index);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetRequiredParameterResourceSize: fn (
*T,
META_COMMAND_PARAMETER_STAGE,
UINT,
) callconv(WINAPI) UINT64,
};
}
};
pub const STATE_SUBOBJECT_TYPE = enum(UINT) {
STATE_OBJECT_CONFIG = 0,
GLOBAL_ROOT_SIGNATURE = 1,
LOCAL_ROOT_SIGNATURE = 2,
NODE_MASK = 3,
DXIL_LIBRARY = 5,
EXISTING_COLLECTION = 6,
SUBOBJECT_TO_EXPORTS_ASSOCIATION = 7,
DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 8,
RAYTRACING_SHADER_CONFIG = 9,
RAYTRACING_PIPELINE_CONFIG = 10,
HIT_GROUP = 11,
RAYTRACING_PIPELINE_CONFIG1 = 12,
MAX_VALID,
};
pub const STATE_SUBOBJECT = extern struct {
Type: STATE_SUBOBJECT_TYPE,
pDesc: *const anyopaque,
};
pub const STATE_OBJECT_FLAGS = UINT;
pub const STATE_OBJECT_FLAG_NONE = 0;
pub const STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1;
pub const STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2;
pub const STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = 0x4;
pub const STATE_OBJECT_CONFIG = extern struct {
Flags: STATE_OBJECT_FLAGS,
};
pub const GLOBAL_ROOT_SIGNATURE = extern struct {
pGlobalRootSignature: *IRootSignature,
};
pub const LOCAL_ROOT_SIGNATURE = extern struct {
pLocalRootSignature: *IRootSignature,
};
pub const NODE_MASK = extern struct {
NodeMask: UINT,
};
pub const EXPORT_FLAGS = UINT;
pub const EXPORT_DESC = extern struct {
Name: LPCWSTR,
ExportToRename: LPCWSTR,
Flags: EXPORT_FLAGS,
};
pub const DXIL_LIBRARY_DESC = extern struct {
DXILLibrary: SHADER_BYTECODE,
NumExports: UINT,
pExports: ?[*]EXPORT_DESC,
};
pub const EXISTING_COLLECTION_DESC = extern struct {
pExistingCollection: *IStateObject,
NumExports: UINT,
pExports: [*]EXPORT_DESC,
};
pub const SUBOBJECT_TO_EXPORTS_ASSOCIATION = extern struct {
pSubobjectToAssociate: *const STATE_SUBOBJECT,
NumExports: UINT,
pExports: [*]LPCWSTR,
};
pub const DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = extern struct {
SubobjectToAssociate: LPCWSTR,
NumExports: UINT,
pExports: [*]LPCWSTR,
};
pub const HIT_GROUP_TYPE = enum(UINT) {
TRIANGLES = 0,
PROCEDURAL_PRIMITIVE = 0x1,
};
pub const HIT_GROUP_DESC = extern struct {
HitGroupExport: LPCWSTR,
Type: HIT_GROUP_TYPE,
AnyHitShaderImport: LPCWSTR,
ClosestHitShaderImport: LPCWSTR,
IntersectionShaderImport: LPCWSTR,
};
pub const RAYTRACING_SHADER_CONFIG = extern struct {
MaxPayloadSizeInBytes: UINT,
MaxAttributeSizeInBytes: UINT,
};
pub const RAYTRACING_PIPELINE_CONFIG = extern struct {
MaxTraceRecursionDepth: UINT,
};
pub const RAYTRACING_PIPELINE_FLAGS = UINT;
pub const RAYTRACING_PIPELINE_FLAG_NONE = 0;
pub const RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = 0x100;
pub const RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200;
pub const RAYTRACING_PIPELINE_CONFIG1 = extern struct {
MaxTraceRecursionDepth: UINT,
Flags: RAYTRACING_PIPELINE_FLAGS,
};
pub const STATE_OBJECT_TYPE = enum(UINT) {
COLLECTION = 0,
RAYTRACING_PIPELINE = 3,
};
pub const STATE_OBJECT_DESC = extern struct {
Type: STATE_OBJECT_TYPE,
NumSubobjects: UINT,
pSubobjects: [*]const STATE_SUBOBJECT,
};
pub const RAYTRACING_GEOMETRY_FLAGS = UINT;
pub const RAYTRACING_GEOMETRY_FLAG_NONE = 0;
pub const RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1;
pub const RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2;
pub const RAYTRACING_GEOMETRY_TYPE = enum(UINT) {
TRIANGLES = 0,
PROCEDURAL_PRIMITIVE_AABBS = 1,
};
pub const RAYTRACING_INSTANCE_FLAGS = UINT;
pub const RAYTRACING_INSTANCE_FLAG_NONE = 0;
pub const RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1;
pub const RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2;
pub const RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4;
pub const RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8;
pub const GPU_VIRTUAL_ADDRESS_AND_STRIDE = extern struct {
StartAddress: GPU_VIRTUAL_ADDRESS,
StrideInBytes: UINT64,
};
pub const GPU_VIRTUAL_ADDRESS_RANGE = extern struct {
StartAddress: GPU_VIRTUAL_ADDRESS,
SizeInBytes: UINT64,
};
pub const GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE = extern struct {
StartAddress: GPU_VIRTUAL_ADDRESS,
SizeInBytes: UINT64,
StrideInBytes: UINT64,
};
pub const RAYTRACING_GEOMETRY_TRIANGLES_DESC = extern struct {
Transform3x4: GPU_VIRTUAL_ADDRESS,
IndexFormat: dxgi.FORMAT,
VertexFormat: dxgi.FORMAT,
IndexCount: UINT,
VertexCount: UINT,
IndexBuffer: GPU_VIRTUAL_ADDRESS,
VertexBuffer: GPU_VIRTUAL_ADDRESS_AND_STRIDE,
};
pub const RAYTRACING_AABB = extern struct {
MinX: FLOAT,
MinY: FLOAT,
MinZ: FLOAT,
MaxX: FLOAT,
MaxY: FLOAT,
MaxZ: FLOAT,
};
pub const RAYTRACING_GEOMETRY_AABBS_DESC = extern struct {
AABBCount: UINT64,
AABBs: GPU_VIRTUAL_ADDRESS_AND_STRIDE,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS = UINT;
pub const RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0;
pub const RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x1;
pub const RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x2;
pub const RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x4;
pub const RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x8;
pub const RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10;
pub const RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20;
pub const RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE = enum(UINT) {
CLONE = 0,
COMPACT = 0x1,
VISUALIZATION_DECODE_FOR_TOOLS = 0x2,
SERIALIZE = 0x3,
DESERIALIZE = 0x4,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_TYPE = enum(UINT) {
TOP_LEVEL = 0,
BOTTOM_LEVEL = 0x1,
};
pub const ELEMENTS_LAYOUT = enum(UINT) {
ARRAY = 0,
ARRAY_OF_POINTERS = 0x1,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE = enum(UINT) {
COMPACTED_SIZE = 0,
TOOLS_VISUALIZATION = 0x1,
SERIALIZATION = 0x2,
CURRENT_SIZE = 0x3,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC = extern struct {
DestBuffer: GPU_VIRTUAL_ADDRESS,
InfoType: RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC = extern struct {
CompactedSizeInBytes: UINT64,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC = extern struct {
DecodedSizeInBytes: UINT64,
};
pub const BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER = extern struct {
Type: RAYTRACING_ACCELERATION_STRUCTURE_TYPE,
NumDescs: UINT,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC = extern struct {
SerializedSizeInBytes: UINT64,
NumBottomLevelAccelerationStructurePointers: UINT64,
};
pub const SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER = extern struct {
DriverOpaqueGUID: GUID,
DriverOpaqueVersioningData: [16]BYTE,
};
pub const SERIALIZED_DATA_TYPE = enum(UINT) {
RAYTRACING_ACCELERATION_STRUCTURE = 0,
};
pub const DRIVER_MATCHING_IDENTIFIER_STATUS = enum(UINT) {
COMPATIBLE_WITH_DEVICE = 0,
UNSUPPORTED_TYPE = 0x1,
UNRECOGNIZED = 0x2,
INCOMPATIBLE_VERSION = 0x3,
INCOMPATIBLE_TYPE = 0x4,
};
pub const SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER = extern struct {
DriverMatchingIdentifier: SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER,
SerializedSizeInBytesIncludingHeader: UINT64,
DeserializedSizeInBytes: UINT64,
NumBottomLevelAccelerationStructurePointersAfterHeader: UINT64,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC = extern struct {
CurrentSizeInBytes: UINT64,
};
pub const RAYTRACING_INSTANCE_DESC = packed struct {
Transform: [3][4]FLOAT,
InstanceID: u24,
InstanceMask: u8,
InstanceContributionToHitGroupIndex: u24,
Flags: u8,
AccelerationStructure: GPU_VIRTUAL_ADDRESS,
};
comptime {
std.debug.assert(@sizeOf(RAYTRACING_INSTANCE_DESC) == 64);
//std.debug.assert(@alignOf(RAYTRACING_INSTANCE_DESC) == 16);
}
pub const RAYTRACING_GEOMETRY_DESC = extern struct {
Type: RAYTRACING_GEOMETRY_TYPE,
Flags: RAYTRACING_GEOMETRY_FLAGS,
u: extern union {
Triangles: RAYTRACING_GEOMETRY_TRIANGLES_DESC,
AABBs: RAYTRACING_GEOMETRY_AABBS_DESC,
},
};
pub const BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS = extern struct {
Type: RAYTRACING_ACCELERATION_STRUCTURE_TYPE,
Flags: RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS,
NumDescs: UINT,
DescsLayout: ELEMENTS_LAYOUT,
u: extern union {
InstanceDescs: GPU_VIRTUAL_ADDRESS,
pGeometryDescs: [*]const RAYTRACING_GEOMETRY_DESC,
ppGeometryDescs: [*]const *RAYTRACING_GEOMETRY_DESC,
},
};
pub const BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC = extern struct {
DestAccelerationStructureData: GPU_VIRTUAL_ADDRESS,
Inputs: BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS,
SourceAccelerationStructureData: GPU_VIRTUAL_ADDRESS,
ScratchAccelerationStructureData: GPU_VIRTUAL_ADDRESS,
};
pub const RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO = extern struct {
ResultDataMaxSizeInBytes: UINT64,
ScratchDataSizeInBytes: UINT64,
UpdateScratchDataSizeInBytes: UINT64,
};
pub const IID_IStateObject = GUID.parse("{47016943-fca8-4594-93ea-af258b55346d}");
pub const IStateObject = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
stateobj: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
_ = T;
return extern struct {};
}
fn VTable(comptime T: type) type {
_ = T;
return extern struct {};
}
};
pub const IID_IStateObjectProperties = GUID.parse("{de5fa827-9bf9-4f26-89ff-d7f56fde3860}");
pub const IStateObjectProperties = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
properties: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetShaderIdentifier(self: *T, export_name: LPCWSTR) *anyopaque {
return self.v.properties.GetShaderIdentifier(self, export_name);
}
pub inline fn GetShaderStackSize(self: *T, export_name: LPCWSTR) UINT64 {
return self.v.properties.GetShaderStackSize(self, export_name);
}
pub inline fn GetPipelineStackSize(self: *T) UINT64 {
return self.v.properties.GetPipelineStackSize(self);
}
pub inline fn SetPipelineStackSize(self: *T, stack_size: UINT64) void {
self.v.properties.SetPipelineStackSize(self, stack_size);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetShaderIdentifier: fn (*T, LPCWSTR) callconv(WINAPI) *anyopaque,
GetShaderStackSize: fn (*T, LPCWSTR) callconv(WINAPI) UINT64,
GetPipelineStackSize: fn (*T) callconv(WINAPI) UINT64,
SetPipelineStackSize: fn (*T, UINT64) callconv(WINAPI) void,
};
}
};
pub const DISPATCH_RAYS_DESC = extern struct {
RayGenerationShaderRecord: GPU_VIRTUAL_ADDRESS_RANGE,
MissShaderTable: GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
HitGroupTable: GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
CallableShaderTable: GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
Width: UINT,
Height: UINT,
Depth: UINT,
};
pub const IGraphicsCommandList4 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
cmdlist: ICommandList.VTable(Self),
grcmdlist: IGraphicsCommandList.VTable(Self),
grcmdlist1: IGraphicsCommandList1.VTable(Self),
grcmdlist2: IGraphicsCommandList2.VTable(Self),
grcmdlist3: IGraphicsCommandList3.VTable(Self),
grcmdlist4: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace ICommandList.Methods(Self);
usingnamespace IGraphicsCommandList.Methods(Self);
usingnamespace IGraphicsCommandList1.Methods(Self);
usingnamespace IGraphicsCommandList2.Methods(Self);
usingnamespace IGraphicsCommandList3.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn BeginRenderPass(
self: *T,
num_render_targets: UINT,
render_targets: ?[*]const RENDER_PASS_RENDER_TARGET_DESC,
depth_stencil: ?*const RENDER_PASS_DEPTH_STENCIL_DESC,
flags: RENDER_PASS_FLAGS,
) void {
self.v.grcmdlist4.BeginRenderPass(self, num_render_targets, render_targets, depth_stencil, flags);
}
pub inline fn EndRenderPass(self: *T) void {
self.v.grcmdlist4.EndRenderPass(self);
}
pub inline fn InitializeMetaCommand(
self: *T,
meta_cmd: *IMetaCommand,
init_param_data: ?*const anyopaque,
data_size: SIZE_T,
) void {
self.v.grcmdlist4.InitializeMetaCommand(self, meta_cmd, init_param_data, data_size);
}
pub inline fn ExecuteMetaCommand(
self: *T,
meta_cmd: *IMetaCommand,
exe_param_data: ?*const anyopaque,
data_size: SIZE_T,
) void {
self.v.grcmdlist4.InitializeMetaCommand(self, meta_cmd, exe_param_data, data_size);
}
pub inline fn BuildRaytracingAccelerationStructure(
self: *T,
desc: *const BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC,
num_post_build_descs: UINT,
post_build_descs: ?[*]const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC,
) void {
self.v.grcmdlist4.BuildRaytracingAccelerationStructure(self, desc, num_post_build_descs, post_build_descs);
}
pub inline fn EmitRaytracingAccelerationStructurePostbuildInfo(
self: *T,
desc: *const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC,
num_src_accel_structs: UINT,
src_accel_struct_data: [*]const GPU_VIRTUAL_ADDRESS,
) void {
self.v.grcmdlist4.EmitRaytracingAccelerationStructurePostbuildInfo(
self,
desc,
num_src_accel_structs,
src_accel_struct_data,
);
}
pub inline fn CopyRaytracingAccelerationStructure(
self: *T,
dst_data: GPU_VIRTUAL_ADDRESS,
src_data: GPU_VIRTUAL_ADDRESS,
mode: RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE,
) void {
self.v.grcmdlist4.CopyRaytracingAccelerationStructure(self, dst_data, src_data, mode);
}
pub inline fn SetPipelineState1(self: *T, state_obj: *IStateObject) void {
self.v.grcmdlist4.SetPipelineState1(self, state_obj);
}
pub inline fn DispatchRays(self: *T, desc: *const DISPATCH_RAYS_DESC) void {
self.v.grcmdlist4.DispatchRays(self, desc);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
BeginRenderPass: fn (
*T,
UINT,
?[*]const RENDER_PASS_RENDER_TARGET_DESC,
?*const RENDER_PASS_DEPTH_STENCIL_DESC,
RENDER_PASS_FLAGS,
) callconv(WINAPI) void,
EndRenderPass: fn (*T) callconv(WINAPI) void,
InitializeMetaCommand: fn (*T, *IMetaCommand, ?*const anyopaque, SIZE_T) callconv(WINAPI) void,
ExecuteMetaCommand: fn (*T, *IMetaCommand, ?*const anyopaque, SIZE_T) callconv(WINAPI) void,
BuildRaytracingAccelerationStructure: fn (
*T,
*const BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC,
UINT,
?[*]const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC,
) callconv(WINAPI) void,
EmitRaytracingAccelerationStructurePostbuildInfo: fn (
*T,
*const RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC,
UINT,
[*]const GPU_VIRTUAL_ADDRESS,
) callconv(WINAPI) void,
CopyRaytracingAccelerationStructure: fn (
*T,
GPU_VIRTUAL_ADDRESS,
GPU_VIRTUAL_ADDRESS,
RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE,
) callconv(WINAPI) void,
SetPipelineState1: fn (*T, *IStateObject) callconv(WINAPI) void,
DispatchRays: fn (*T, *const DISPATCH_RAYS_DESC) callconv(WINAPI) void,
};
}
};
pub const RS_SET_SHADING_RATE_COMBINER_COUNT = 2;
pub const SHADING_RATE = enum(UINT) {
_1X1 = 0,
_1X2 = 0x1,
_2X1 = 0x4,
_2X2 = 0x5,
_2X4 = 0x6,
_4X2 = 0x9,
_4X4 = 0xa,
};
pub const SHADING_RATE_COMBINER = enum(UINT) {
PASSTHROUGH = 0,
OVERRIDE = 1,
COMBINER_MIN = 2,
COMBINER_MAX = 3,
COMBINER_SUM = 4,
};
pub const IGraphicsCommandList5 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
cmdlist: ICommandList.VTable(Self),
grcmdlist: IGraphicsCommandList.VTable(Self),
grcmdlist1: IGraphicsCommandList1.VTable(Self),
grcmdlist2: IGraphicsCommandList2.VTable(Self),
grcmdlist3: IGraphicsCommandList3.VTable(Self),
grcmdlist4: IGraphicsCommandList4.VTable(Self),
grcmdlist5: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace ICommandList.Methods(Self);
usingnamespace IGraphicsCommandList.Methods(Self);
usingnamespace IGraphicsCommandList1.Methods(Self);
usingnamespace IGraphicsCommandList2.Methods(Self);
usingnamespace IGraphicsCommandList3.Methods(Self);
usingnamespace IGraphicsCommandList4.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn RSSetShadingRate(
self: *T,
base_shading_rate: SHADING_RATE,
combiners: ?[RS_SET_SHADING_RATE_COMBINER_COUNT]SHADING_RATE_COMBINER,
) void {
self.v.grcmdlist5.RSSetShadingRate(self, base_shading_rate, combiners);
}
pub inline fn RSSetShadingRateImage(self: *T, shading_rate_img: ?*IResource) void {
self.v.grcmdlist5.RSSetShadingRateImage(self, shading_rate_img);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
RSSetShadingRate: fn (
*T,
SHADING_RATE,
?[RS_SET_SHADING_RATE_COMBINER_COUNT]SHADING_RATE_COMBINER,
) callconv(WINAPI) void,
RSSetShadingRateImage: fn (*T, ?*IResource) callconv(WINAPI) void,
};
}
};
pub const IGraphicsCommandList6 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
cmdlist: ICommandList.VTable(Self),
grcmdlist: IGraphicsCommandList.VTable(Self),
grcmdlist1: IGraphicsCommandList1.VTable(Self),
grcmdlist2: IGraphicsCommandList2.VTable(Self),
grcmdlist3: IGraphicsCommandList3.VTable(Self),
grcmdlist4: IGraphicsCommandList4.VTable(Self),
grcmdlist5: IGraphicsCommandList5.VTable(Self),
grcmdlist6: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace ICommandList.Methods(Self);
usingnamespace IGraphicsCommandList.Methods(Self);
usingnamespace IGraphicsCommandList1.Methods(Self);
usingnamespace IGraphicsCommandList2.Methods(Self);
usingnamespace IGraphicsCommandList3.Methods(Self);
usingnamespace IGraphicsCommandList4.Methods(Self);
usingnamespace IGraphicsCommandList5.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn DispatchMesh(
self: *T,
thread_group_count_x: UINT,
thread_group_count_y: UINT,
thread_group_count_z: UINT,
) void {
self.v.grcmdlist6.DispatchMesh(self, thread_group_count_x, thread_group_count_y, thread_group_count_z);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
DispatchMesh: fn (*T, UINT, UINT, UINT) callconv(WINAPI) void,
};
}
};
pub const ICommandQueue = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
pageable: IPageable.VTable(Self),
cmdqueue: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IPageable.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn UpdateTileMappings(
self: *T,
resource: *IResource,
num_resource_regions: UINT,
resource_region_start_coordinates: ?[*]const TILED_RESOURCE_COORDINATE,
resource_region_sizes: ?[*]const TILE_REGION_SIZE,
heap: ?*IHeap,
num_ranges: UINT,
range_flags: ?[*]const TILE_RANGE_FLAGS,
heap_range_start_offsets: ?[*]const UINT,
range_tile_counts: ?[*]const UINT,
flags: TILE_MAPPING_FLAGS,
) void {
self.v.cmdqueue.UpdateTileMappings(
self,
resource,
num_resource_regions,
resource_region_start_coordinates,
resource_region_sizes,
heap,
num_ranges,
range_flags,
heap_range_start_offsets,
range_tile_counts,
flags,
);
}
pub inline fn CopyTileMappings(
self: *T,
dst_resource: *IResource,
dst_region_start_coordinate: *const TILED_RESOURCE_COORDINATE,
src_resource: *IResource,
src_region_start_coordinate: *const TILED_RESOURCE_COORDINATE,
region_size: *const TILE_REGION_SIZE,
flags: TILE_MAPPING_FLAGS,
) void {
self.v.cmdqueue.CopyTileMappings(
self,
dst_resource,
dst_region_start_coordinate,
src_resource,
src_region_start_coordinate,
region_size,
flags,
);
}
pub inline fn ExecuteCommandLists(self: *T, num: UINT, cmdlists: [*]const *ICommandList) void {
self.v.cmdqueue.ExecuteCommandLists(self, num, cmdlists);
}
pub inline fn SetMarker(self: *T, metadata: UINT, data: ?*const anyopaque, size: UINT) void {
self.v.cmdqueue.SetMarker(self, metadata, data, size);
}
pub inline fn BeginEvent(self: *T, metadata: UINT, data: ?*const anyopaque, size: UINT) void {
self.v.cmdqueue.BeginEvent(self, metadata, data, size);
}
pub inline fn EndEvent(self: *T) void {
self.v.cmdqueue.EndEvent(self);
}
pub inline fn Signal(self: *T, fence: *IFence, value: UINT64) HRESULT {
return self.v.cmdqueue.Signal(self, fence, value);
}
pub inline fn Wait(self: *T, fence: *IFence, value: UINT64) HRESULT {
return self.v.cmdqueue.Wait(self, fence, value);
}
pub inline fn GetTimestampFrequency(self: *T, frequency: *UINT64) HRESULT {
return self.v.cmdqueue.GetTimestampFrequency(self, frequency);
}
pub inline fn GetClockCalibration(self: *T, gpu_timestamp: *UINT64, cpu_timestamp: *UINT64) HRESULT {
return self.v.cmdqueue.GetClockCalibration(self, gpu_timestamp, cpu_timestamp);
}
pub inline fn GetDesc(self: *T) COMMAND_QUEUE_DESC {
var desc: COMMAND_QUEUE_DESC = undefined;
_ = self.v.cmdqueue.GetDesc(self, &desc);
return desc;
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
UpdateTileMappings: fn (
*T,
*IResource,
UINT,
?[*]const TILED_RESOURCE_COORDINATE,
?[*]const TILE_REGION_SIZE,
*IHeap,
UINT,
?[*]const TILE_RANGE_FLAGS,
?[*]const UINT,
?[*]const UINT,
TILE_MAPPING_FLAGS,
) callconv(WINAPI) void,
CopyTileMappings: fn (
*T,
*IResource,
*const TILED_RESOURCE_COORDINATE,
*IResource,
*const TILED_RESOURCE_COORDINATE,
*const TILE_REGION_SIZE,
TILE_MAPPING_FLAGS,
) callconv(WINAPI) void,
ExecuteCommandLists: fn (*T, UINT, [*]const *ICommandList) callconv(WINAPI) void,
SetMarker: fn (*T, UINT, ?*const anyopaque, UINT) callconv(WINAPI) void,
BeginEvent: fn (*T, UINT, ?*const anyopaque, UINT) callconv(WINAPI) void,
EndEvent: fn (*T) callconv(WINAPI) void,
Signal: fn (*T, *IFence, UINT64) callconv(WINAPI) HRESULT,
Wait: fn (*T, *IFence, UINT64) callconv(WINAPI) HRESULT,
GetTimestampFrequency: fn (*T, *UINT64) callconv(WINAPI) HRESULT,
GetClockCalibration: fn (*T, *UINT64, *UINT64) callconv(WINAPI) HRESULT,
GetDesc: fn (*T, *COMMAND_QUEUE_DESC) callconv(WINAPI) *COMMAND_QUEUE_DESC,
};
}
};
pub const IDevice = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetNodeCount(self: *T) UINT {
return self.v.device.GetNodeCount(self);
}
pub inline fn CreateCommandQueue(
self: *T,
desc: *const COMMAND_QUEUE_DESC,
guid: *const GUID,
obj: *?*anyopaque,
) HRESULT {
return self.v.device.CreateCommandQueue(self, desc, guid, obj);
}
pub inline fn CreateCommandAllocator(
self: *T,
cmdlist_type: COMMAND_LIST_TYPE,
guid: *const GUID,
obj: *?*anyopaque,
) HRESULT {
return self.v.device.CreateCommandAllocator(self, cmdlist_type, guid, obj);
}
pub inline fn CreateGraphicsPipelineState(
self: *T,
desc: *const GRAPHICS_PIPELINE_STATE_DESC,
guid: *const GUID,
pso: *?*anyopaque,
) HRESULT {
return self.v.device.CreateGraphicsPipelineState(self, desc, guid, pso);
}
pub inline fn CreateComputePipelineState(
self: *T,
desc: *const COMPUTE_PIPELINE_STATE_DESC,
guid: *const GUID,
pso: *?*anyopaque,
) HRESULT {
return self.v.device.CreateComputePipelineState(self, desc, guid, pso);
}
pub inline fn CreateCommandList(
self: *T,
node_mask: UINT,
cmdlist_type: COMMAND_LIST_TYPE,
cmdalloc: *ICommandAllocator,
initial_state: ?*IPipelineState,
guid: *const GUID,
cmdlist: *?*anyopaque,
) HRESULT {
return self.v.device.CreateCommandList(self, node_mask, cmdlist_type, cmdalloc, initial_state, guid, cmdlist);
}
pub inline fn CheckFeatureSupport(self: *T, feature: FEATURE, data: *anyopaque, data_size: UINT) HRESULT {
return self.v.device.CheckFeatureSupport(self, feature, data, data_size);
}
pub inline fn CreateDescriptorHeap(
self: *T,
desc: *const DESCRIPTOR_HEAP_DESC,
guid: *const GUID,
heap: *?*anyopaque,
) HRESULT {
return self.v.device.CreateDescriptorHeap(self, desc, guid, heap);
}
pub inline fn GetDescriptorHandleIncrementSize(self: *T, heap_type: DESCRIPTOR_HEAP_TYPE) UINT {
return self.v.device.GetDescriptorHandleIncrementSize(self, heap_type);
}
pub inline fn CreateRootSignature(
self: *T,
node_mask: UINT,
blob: *const anyopaque,
blob_size: UINT64,
guid: *const GUID,
signature: *?*anyopaque,
) HRESULT {
return self.v.device.CreateRootSignature(self, node_mask, blob, blob_size, guid, signature);
}
pub inline fn CreateConstantBufferView(
self: *T,
desc: ?*const CONSTANT_BUFFER_VIEW_DESC,
dst_descriptor: CPU_DESCRIPTOR_HANDLE,
) void {
self.v.device.CreateConstantBufferView(self, desc, dst_descriptor);
}
pub inline fn CreateShaderResourceView(
self: *T,
resource: ?*IResource,
desc: ?*const SHADER_RESOURCE_VIEW_DESC,
dst_descriptor: CPU_DESCRIPTOR_HANDLE,
) void {
self.v.device.CreateShaderResourceView(self, resource, desc, dst_descriptor);
}
pub inline fn CreateUnorderedAccessView(
self: *T,
resource: ?*IResource,
counter_resource: ?*IResource,
desc: ?*const UNORDERED_ACCESS_VIEW_DESC,
dst_descriptor: CPU_DESCRIPTOR_HANDLE,
) void {
self.v.device.CreateUnorderedAccessView(
self,
resource,
counter_resource,
desc,
dst_descriptor,
);
}
pub inline fn CreateRenderTargetView(
self: *T,
resource: ?*IResource,
desc: ?*const RENDER_TARGET_VIEW_DESC,
dst_descriptor: CPU_DESCRIPTOR_HANDLE,
) void {
self.v.device.CreateRenderTargetView(self, resource, desc, dst_descriptor);
}
pub inline fn CreateDepthStencilView(
self: *T,
resource: ?*IResource,
desc: ?*const DEPTH_STENCIL_VIEW_DESC,
dst_descriptor: CPU_DESCRIPTOR_HANDLE,
) void {
self.v.device.CreateDepthStencilView(self, resource, desc, dst_descriptor);
}
pub inline fn CreateSampler(
self: *T,
desc: *const SAMPLER_DESC,
dst_descriptor: CPU_DESCRIPTOR_HANDLE,
) void {
self.v.device.CreateSampler(self, desc, dst_descriptor);
}
pub inline fn CopyDescriptors(
self: *T,
num_dst_ranges: UINT,
dst_range_starts: [*]const CPU_DESCRIPTOR_HANDLE,
dst_range_sizes: ?[*]const UINT,
num_src_ranges: UINT,
src_range_starts: [*]const CPU_DESCRIPTOR_HANDLE,
src_range_sizes: ?[*]const UINT,
heap_type: DESCRIPTOR_HEAP_TYPE,
) void {
self.v.device.CopyDescriptors(
self,
num_dst_ranges,
dst_range_starts,
dst_range_sizes,
num_src_ranges,
src_range_starts,
src_range_sizes,
heap_type,
);
}
pub inline fn CopyDescriptorsSimple(
self: *T,
num: UINT,
dst_range_start: CPU_DESCRIPTOR_HANDLE,
src_range_start: CPU_DESCRIPTOR_HANDLE,
heap_type: DESCRIPTOR_HEAP_TYPE,
) void {
self.v.device.CopyDescriptorsSimple(self, num, dst_range_start, src_range_start, heap_type);
}
pub inline fn GetResourceAllocationInfo(
self: *T,
visible_mask: UINT,
num_descs: UINT,
descs: [*]const RESOURCE_DESC,
) RESOURCE_ALLOCATION_INFO {
var info: RESOURCE_ALLOCATION_INFO = undefined;
self.v.device.GetResourceAllocationInfo(self, &info, visible_mask, num_descs, descs);
return info;
}
pub inline fn GetCustomHeapProperties(
self: *T,
node_mask: UINT,
heap_type: HEAP_TYPE,
) HEAP_PROPERTIES {
var props: HEAP_PROPERTIES = undefined;
self.v.device.GetCustomHeapProperties(self, &props, node_mask, heap_type);
return props;
}
pub inline fn CreateCommittedResource(
self: *T,
heap_props: *const HEAP_PROPERTIES,
heap_flags: HEAP_FLAGS,
desc: *const RESOURCE_DESC,
state: RESOURCE_STATES,
clear_value: ?*const CLEAR_VALUE,
guid: *const GUID,
resource: ?*?*anyopaque,
) HRESULT {
return self.v.device.CreateCommittedResource(
self,
heap_props,
heap_flags,
desc,
state,
clear_value,
guid,
resource,
);
}
pub inline fn CreateHeap(self: *T, desc: *const HEAP_DESC, guid: *const GUID, heap: ?*?*anyopaque) HRESULT {
return self.v.device.CreateHeap(self, desc, guid, heap);
}
pub inline fn CreatePlacedResource(
self: *T,
heap: *IHeap,
heap_offset: UINT64,
desc: *const RESOURCE_DESC,
state: RESOURCE_STATES,
clear_value: ?*const CLEAR_VALUE,
guid: *const GUID,
resource: ?*?*anyopaque,
) HRESULT {
return self.v.device.CreatePlacedResource(
self,
heap,
heap_offset,
desc,
state,
clear_value,
guid,
resource,
);
}
pub inline fn CreateReservedResource(
self: *T,
desc: *const RESOURCE_DESC,
state: RESOURCE_STATES,
clear_value: ?*const CLEAR_VALUE,
guid: *const GUID,
resource: ?*?*anyopaque,
) HRESULT {
return self.v.device.CreateReservedResource(self, desc, state, clear_value, guid, resource);
}
pub inline fn CreateSharedHandle(
self: *T,
object: *IDeviceChild,
attributes: ?*const SECURITY_ATTRIBUTES,
access: DWORD,
name: ?LPCWSTR,
handle: ?*HANDLE,
) HRESULT {
return self.v.device.CreateSharedHandle(self, object, attributes, access, name, handle);
}
pub inline fn OpenSharedHandle(self: *T, handle: HANDLE, guid: *const GUID, object: ?*?*anyopaque) HRESULT {
return self.v.device.OpenSharedHandle(self, handle, guid, object);
}
pub inline fn OpenSharedHandleByName(self: *T, name: LPCWSTR, access: DWORD, handle: ?*HANDLE) HRESULT {
return self.v.device.OpenSharedHandleByName(self, name, access, handle);
}
pub inline fn MakeResident(self: *T, num: UINT, objects: [*]const *IPageable) HRESULT {
return self.v.device.MakeResident(self, num, objects);
}
pub inline fn Evict(self: *T, num: UINT, objects: [*]const *IPageable) HRESULT {
return self.v.device.Evict(self, num, objects);
}
pub inline fn CreateFence(
self: *T,
initial_value: UINT64,
flags: FENCE_FLAGS,
guid: *const GUID,
fence: *?*anyopaque,
) HRESULT {
return self.v.device.CreateFence(self, initial_value, flags, guid, fence);
}
pub inline fn GetDeviceRemovedReason(self: *T) HRESULT {
return self.v.device.GetDeviceRemovedReason(self);
}
pub inline fn GetCopyableFootprints(
self: *T,
desc: *const RESOURCE_DESC,
first_subresource: UINT,
num_subresources: UINT,
base_offset: UINT64,
layouts: ?[*]PLACED_SUBRESOURCE_FOOTPRINT,
num_rows: ?[*]UINT,
row_size: ?[*]UINT64,
total_sizie: ?*UINT64,
) void {
self.v.device.GetCopyableFootprints(
self,
desc,
first_subresource,
num_subresources,
base_offset,
layouts,
num_rows,
row_size,
total_sizie,
);
}
pub inline fn CreateQueryHeap(
self: *T,
desc: *const QUERY_HEAP_DESC,
guid: *const GUID,
query_heap: ?*?*anyopaque,
) HRESULT {
return self.v.device.CreateQueryHeap(self, desc, guid, query_heap);
}
pub inline fn SetStablePowerState(self: *T, enable: BOOL) HRESULT {
return self.v.device.SetStablePowerState(self, enable);
}
pub inline fn CreateCommandSignature(
self: *T,
desc: *const COMMAND_SIGNATURE_DESC,
root_signature: ?*IRootSignature,
guid: *const GUID,
cmd_signature: ?*?*anyopaque,
) HRESULT {
return self.v.device.CreateCommandSignature(self, desc, root_signature, guid, cmd_signature);
}
pub inline fn GetResourceTiling(
self: *T,
resource: *IResource,
num_resource_tiles: ?*UINT,
packed_mip_desc: ?*PACKED_MIP_INFO,
std_tile_shape_non_packed_mips: ?*TILE_SHAPE,
num_subresource_tilings: ?*UINT,
first_subresource: UINT,
subresource_tiling_for_non_packed_mips: [*]SUBRESOURCE_TILING,
) void {
self.v.device.GetResourceTiling(
self,
resource,
num_resource_tiles,
packed_mip_desc,
std_tile_shape_non_packed_mips,
num_subresource_tilings,
first_subresource,
subresource_tiling_for_non_packed_mips,
);
}
pub inline fn GetAdapterLuid(self: *T) LUID {
var luid: LUID = undefined;
self.v.device.GetAdapterLuid(self, &luid);
return luid;
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetNodeCount: fn (*T) callconv(WINAPI) UINT,
CreateCommandQueue: fn (*T, *const COMMAND_QUEUE_DESC, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
CreateCommandAllocator: fn (*T, COMMAND_LIST_TYPE, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
CreateGraphicsPipelineState: fn (
*T,
*const GRAPHICS_PIPELINE_STATE_DESC,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateComputePipelineState: fn (
*T,
*const COMPUTE_PIPELINE_STATE_DESC,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateCommandList: fn (
*T,
UINT,
COMMAND_LIST_TYPE,
*ICommandAllocator,
?*IPipelineState,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
CheckFeatureSupport: fn (*T, FEATURE, *anyopaque, UINT) callconv(WINAPI) HRESULT,
CreateDescriptorHeap: fn (
*T,
*const DESCRIPTOR_HEAP_DESC,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
GetDescriptorHandleIncrementSize: fn (*T, DESCRIPTOR_HEAP_TYPE) callconv(WINAPI) UINT,
CreateRootSignature: fn (*T, UINT, *const anyopaque, UINT64, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
CreateConstantBufferView: fn (
*T,
?*const CONSTANT_BUFFER_VIEW_DESC,
CPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) void,
CreateShaderResourceView: fn (
*T,
?*IResource,
?*const SHADER_RESOURCE_VIEW_DESC,
CPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) void,
CreateUnorderedAccessView: fn (
*T,
?*IResource,
?*IResource,
?*const UNORDERED_ACCESS_VIEW_DESC,
CPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) void,
CreateRenderTargetView: fn (
*T,
?*IResource,
?*const RENDER_TARGET_VIEW_DESC,
CPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) void,
CreateDepthStencilView: fn (
*T,
?*IResource,
?*const DEPTH_STENCIL_VIEW_DESC,
CPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) void,
CreateSampler: fn (*T, *const SAMPLER_DESC, CPU_DESCRIPTOR_HANDLE) callconv(WINAPI) void,
CopyDescriptors: fn (
*T,
UINT,
[*]const CPU_DESCRIPTOR_HANDLE,
?[*]const UINT,
UINT,
[*]const CPU_DESCRIPTOR_HANDLE,
?[*]const UINT,
DESCRIPTOR_HEAP_TYPE,
) callconv(WINAPI) void,
CopyDescriptorsSimple: fn (
*T,
UINT,
CPU_DESCRIPTOR_HANDLE,
CPU_DESCRIPTOR_HANDLE,
DESCRIPTOR_HEAP_TYPE,
) callconv(WINAPI) void,
GetResourceAllocationInfo: fn (
*T,
*RESOURCE_ALLOCATION_INFO,
UINT,
UINT,
[*]const RESOURCE_DESC,
) callconv(WINAPI) *RESOURCE_ALLOCATION_INFO,
GetCustomHeapProperties: fn (
*T,
*HEAP_PROPERTIES,
UINT,
HEAP_TYPE,
) callconv(WINAPI) *HEAP_PROPERTIES,
CreateCommittedResource: fn (
*T,
*const HEAP_PROPERTIES,
HEAP_FLAGS,
*const RESOURCE_DESC,
RESOURCE_STATES,
?*const CLEAR_VALUE,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateHeap: fn (*T, *const HEAP_DESC, *const GUID, ?*?*anyopaque) callconv(WINAPI) HRESULT,
CreatePlacedResource: fn (
*T,
*IHeap,
UINT64,
*const RESOURCE_DESC,
RESOURCE_STATES,
?*const CLEAR_VALUE,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateReservedResource: fn (
*T,
*const RESOURCE_DESC,
RESOURCE_STATES,
?*const CLEAR_VALUE,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateSharedHandle: fn (
*T,
*IDeviceChild,
?*const SECURITY_ATTRIBUTES,
DWORD,
?LPCWSTR,
?*HANDLE,
) callconv(WINAPI) HRESULT,
OpenSharedHandle: fn (*T, HANDLE, *const GUID, ?*?*anyopaque) callconv(WINAPI) HRESULT,
OpenSharedHandleByName: fn (*T, LPCWSTR, DWORD, ?*HANDLE) callconv(WINAPI) HRESULT,
MakeResident: fn (*T, UINT, [*]const *IPageable) callconv(WINAPI) HRESULT,
Evict: fn (*T, UINT, [*]const *IPageable) callconv(WINAPI) HRESULT,
CreateFence: fn (*T, UINT64, FENCE_FLAGS, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
GetDeviceRemovedReason: fn (*T) callconv(WINAPI) HRESULT,
GetCopyableFootprints: fn (
*T,
*const RESOURCE_DESC,
UINT,
UINT,
UINT64,
?[*]PLACED_SUBRESOURCE_FOOTPRINT,
?[*]UINT,
?[*]UINT64,
?*UINT64,
) callconv(WINAPI) void,
CreateQueryHeap: fn (*T, *const QUERY_HEAP_DESC, *const GUID, ?*?*anyopaque) callconv(WINAPI) HRESULT,
SetStablePowerState: fn (*T, BOOL) callconv(WINAPI) HRESULT,
CreateCommandSignature: fn (
*T,
*const COMMAND_SIGNATURE_DESC,
?*IRootSignature,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
GetResourceTiling: fn (
*T,
*IResource,
?*UINT,
?*PACKED_MIP_INFO,
?*TILE_SHAPE,
?*UINT,
UINT,
[*]SUBRESOURCE_TILING,
) callconv(WINAPI) void,
GetAdapterLuid: fn (*T, *LUID) callconv(WINAPI) *LUID,
};
}
};
pub const MULTIPLE_FENCE_WAIT_FLAGS = enum(UINT) {
ALL = 0,
ANY = 1,
};
pub const RESIDENCY_PRIORITY = enum(UINT) {
MINIMUM = 0x28000000,
LOW = 0x50000000,
NORMAL = 0x78000000,
HIGH = 0xa0010000,
MAXIMUM = 0xc8000000,
};
pub const IDevice1 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn CreatePipelineLibrary(
self: *T,
blob: *const anyopaque,
blob_length: SIZE_T,
guid: *const GUID,
library: *?*anyopaque,
) HRESULT {
return self.v.device1.CreatePipelineLibrary(self, blob, blob_length, guid, library);
}
pub inline fn SetEventOnMultipleFenceCompletion(
self: *T,
fences: [*]const *IFence,
fence_values: [*]const UINT64,
num_fences: UINT,
flags: MULTIPLE_FENCE_WAIT_FLAGS,
event: HANDLE,
) HRESULT {
return self.v.device1.SetEventOnMultipleFenceCompletion(
self,
fences,
fence_values,
num_fences,
flags,
event,
);
}
pub inline fn SetResidencyPriority(
self: *T,
num_objects: UINT,
objects: [*]const *IPageable,
priorities: [*]const RESIDENCY_PRIORITY,
) HRESULT {
return self.v.device1.SetResidencyPriority(self, num_objects, objects, priorities);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
CreatePipelineLibrary: fn (*T, *const anyopaque, SIZE_T, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
SetEventOnMultipleFenceCompletion: fn (
*T,
[*]const *IFence,
[*]const UINT64,
UINT,
MULTIPLE_FENCE_WAIT_FLAGS,
HANDLE,
) callconv(WINAPI) HRESULT,
SetResidencyPriority: fn (
*T,
UINT,
[*]const *IPageable,
[*]const RESIDENCY_PRIORITY,
) callconv(WINAPI) HRESULT,
};
}
};
pub const PIPELINE_STATE_SUBOBJECT_TYPE = enum(UINT) {
ROOT_SIGNATURE = 0,
VS = 1,
PS = 2,
DS = 3,
HS = 4,
GS = 5,
CS = 6,
STREAM_OUTPUT = 7,
BLEND = 8,
SAMPLE_MASK = 9,
RASTERIZER = 10,
DEPTH_STENCIL = 11,
INPUT_LAYOUT = 12,
IB_STRIP_CUT_VALUE = 13,
PRIMITIVE_TOPOLOGY = 14,
RENDER_TARGET_FORMATS = 15,
DEPTH_STENCIL_FORMAT = 16,
SAMPLE_DESC = 17,
NODE_MASK = 18,
CACHED_PSO = 19,
FLAGS = 20,
DEPTH_STENCIL1 = 21,
VIEW_INSTANCING = 22,
AS = 24,
MS = 25,
MAX_VALID,
};
pub const RT_FORMAT_ARRAY = extern struct {
RTFormats: [8]dxgi.FORMAT,
NumRenderTargets: UINT,
};
pub const PIPELINE_STATE_STREAM_DESC = extern struct {
SizeInBytes: SIZE_T,
pPipelineStateSubobjectStream: *anyopaque,
};
// NOTE(mziulek): Helper structures for defining Mesh Shaders.
pub const MESH_SHADER_PIPELINE_STATE_DESC = extern struct {
pRootSignature: ?*IRootSignature,
AS: SHADER_BYTECODE,
MS: SHADER_BYTECODE,
PS: SHADER_BYTECODE,
BlendState: BLEND_DESC,
SampleMask: UINT,
RasterizerState: RASTERIZER_DESC,
DepthStencilState: DEPTH_STENCIL_DESC1,
PrimitiveTopologyType: PRIMITIVE_TOPOLOGY_TYPE,
NumRenderTargets: UINT,
RTVFormats: [8]dxgi.FORMAT,
DSVFormat: dxgi.FORMAT,
SampleDesc: dxgi.SAMPLE_DESC,
NodeMask: UINT,
CachedPSO: CACHED_PIPELINE_STATE,
Flags: PIPELINE_STATE_FLAGS,
pub fn initDefault() MESH_SHADER_PIPELINE_STATE_DESC {
var v = std.mem.zeroes(@This());
v = .{
.pRootSignature = null,
.AS = SHADER_BYTECODE.initZero(),
.MS = SHADER_BYTECODE.initZero(),
.PS = SHADER_BYTECODE.initZero(),
.BlendState = BLEND_DESC.initDefault(),
.SampleMask = 0xffff_ffff,
.RasterizerState = RASTERIZER_DESC.initDefault(),
.DepthStencilState = DEPTH_STENCIL_DESC1.initDefault(),
.PrimitiveTopologyType = .UNDEFINED,
.NumRenderTargets = 0,
.RTVFormats = [_]dxgi.FORMAT{.UNKNOWN} ** 8,
.DSVFormat = .UNKNOWN,
.SampleDesc = .{ .Count = 1, .Quality = 0 },
.NodeMask = 0,
.CachedPSO = CACHED_PIPELINE_STATE.initZero(),
.Flags = PIPELINE_STATE_FLAG_NONE,
};
return v;
}
};
pub const PIPELINE_MESH_STATE_STREAM = extern struct {
Flags_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .FLAGS,
Flags: PIPELINE_STATE_FLAGS,
NodeMask_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .NODE_MASK,
NodeMask: UINT,
pRootSignature_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .ROOT_SIGNATURE,
pRootSignature: ?*IRootSignature,
PS_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .PS,
PS: SHADER_BYTECODE,
AS_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .AS,
AS: SHADER_BYTECODE,
MS_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .MS,
MS: SHADER_BYTECODE,
BlendState_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .BLEND,
BlendState: BLEND_DESC,
DepthStencilState_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .DEPTH_STENCIL1,
DepthStencilState: DEPTH_STENCIL_DESC1,
DSVFormat_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .DEPTH_STENCIL_FORMAT,
DSVFormat: dxgi.FORMAT,
RasterizerState_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .RASTERIZER,
RasterizerState: RASTERIZER_DESC,
RTVFormats_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .RENDER_TARGET_FORMATS,
RTVFormats: RT_FORMAT_ARRAY,
SampleDesc_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .SAMPLE_DESC,
SampleDesc: dxgi.SAMPLE_DESC,
SampleMask_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .SAMPLE_MASK,
SampleMask: UINT,
CachedPSO_type: PIPELINE_STATE_SUBOBJECT_TYPE align(8) = .CACHED_PSO,
CachedPSO: CACHED_PIPELINE_STATE,
pub fn init(desc: MESH_SHADER_PIPELINE_STATE_DESC) PIPELINE_MESH_STATE_STREAM {
const stream = PIPELINE_MESH_STATE_STREAM{
.Flags = desc.Flags,
.NodeMask = desc.NodeMask,
.pRootSignature = desc.pRootSignature,
.PS = desc.PS,
.AS = desc.AS,
.MS = desc.MS,
.BlendState = desc.BlendState,
.DepthStencilState = desc.DepthStencilState,
.DSVFormat = desc.DSVFormat,
.RasterizerState = desc.RasterizerState,
.RTVFormats = .{ .RTFormats = desc.RTVFormats, .NumRenderTargets = desc.NumRenderTargets },
.SampleDesc = desc.SampleDesc,
.SampleMask = desc.SampleMask,
.CachedPSO = desc.CachedPSO,
};
return stream;
}
};
pub const IDevice2 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: IDevice1.VTable(Self),
device2: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace IDevice1.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn CreatePipelineState(
self: *T,
desc: *const PIPELINE_STATE_STREAM_DESC,
guid: *const GUID,
pso: *?*anyopaque,
) HRESULT {
return self.v.device2.CreatePipelineState(self, desc, guid, pso);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
CreatePipelineState: fn (
*T,
*const PIPELINE_STATE_STREAM_DESC,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
};
}
};
pub const RESIDENCY_FLAGS = UINT;
pub const RESIDENCY_FLAG_NONE = 0;
pub const RESIDENCY_FLAG_DENY_OVERBUDGET = 0x1;
pub const IDevice3 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: IDevice1.VTable(Self),
device2: IDevice2.VTable(Self),
device3: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace IDevice1.Methods(Self);
usingnamespace IDevice2.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn OpenExistingHeapFromAddress(
self: *T,
address: *const anyopaque,
guid: *const GUID,
heap: *?*anyopaque,
) HRESULT {
return self.v.device3.OpenExistingHeapFromAddress(self, address, guid, heap);
}
pub inline fn OpenExistingHeapFromFileMapping(
self: *T,
file_mapping: HANDLE,
guid: *const GUID,
heap: *?*anyopaque,
) HRESULT {
return self.v.device3.OpenExistingHeapFromFileMapping(self, file_mapping, guid, heap);
}
pub inline fn EnqueueMakeResident(
self: *T,
flags: RESIDENCY_FLAGS,
num_objects: UINT,
objects: [*]const *IPageable,
fence_to_signal: *IFence,
fence_value_to_signal: UINT64,
) HRESULT {
return self.v.device3.EnqueueMakeResident(
self,
flags,
num_objects,
objects,
fence_to_signal,
fence_value_to_signal,
);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
OpenExistingHeapFromAddress: fn (*T, *const anyopaque, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
OpenExistingHeapFromFileMapping: fn (*T, HANDLE, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
EnqueueMakeResident: fn (
*T,
RESIDENCY_FLAGS,
UINT,
[*]const *IPageable,
*IFence,
UINT64,
) callconv(WINAPI) HRESULT,
};
}
};
pub const COMMAND_LIST_FLAGS = UINT;
pub const RESOURCE_ALLOCATION_INFO1 = extern struct {
Offset: UINT64,
Alignment: UINT64,
SizeInBytes: UINT64,
};
pub const IDevice4 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: IDevice1.VTable(Self),
device2: IDevice2.VTable(Self),
device3: IDevice3.VTable(Self),
device4: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace IDevice1.Methods(Self);
usingnamespace IDevice2.Methods(Self);
usingnamespace IDevice3.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn CreateCommandList1(
self: *T,
node_mask: UINT,
cmdlist_type: COMMAND_LIST_TYPE,
flags: COMMAND_LIST_FLAGS,
guid: *const GUID,
cmdlist: *?*anyopaque,
) HRESULT {
return self.v.device4.CreateCommandList1(self, node_mask, cmdlist_type, flags, guid, cmdlist);
}
pub inline fn CreateProtectedResourceSession(
self: *T,
desc: *const PROTECTED_RESOURCE_SESSION_DESC,
guid: *const GUID,
session: *?*anyopaque,
) HRESULT {
return self.v.device4.CreateProtectedResourceSession(self, desc, guid, session);
}
pub inline fn CreateCommittedResource1(
self: *T,
heap_properties: *const HEAP_PROPERTIES,
heap_flags: HEAP_FLAGS,
desc: *const RESOURCE_DESC,
initial_state: RESOURCE_STATES,
clear_value: ?*const CLEAR_VALUE,
psession: ?*IProtectedResourceSession,
guid: *const GUID,
resource: ?*?*anyopaque,
) HRESULT {
return self.v.device4.CreateCommittedResource1(
self,
heap_properties,
heap_flags,
desc,
initial_state,
clear_value,
psession,
guid,
resource,
);
}
pub inline fn CreateHeap1(
self: *T,
desc: *const HEAP_DESC,
psession: ?*IProtectedResourceSession,
guid: *const GUID,
heap: ?*?*anyopaque,
) HRESULT {
return self.v.device4.CreateHeap1(self, desc, psession, guid, heap);
}
pub inline fn CreateReservedResource1(
self: *T,
desc: *const RESOURCE_DESC,
initial_state: RESOURCE_STATES,
clear_value: ?*const CLEAR_VALUE,
psession: ?*IProtectedResourceSession,
guid: *const GUID,
resource: ?*?*anyopaque,
) HRESULT {
return self.v.device4.CreateReservedResource1(
self,
desc,
initial_state,
clear_value,
psession,
guid,
resource,
);
}
pub inline fn GetResourceAllocationInfo1(
self: *T,
visible_mask: UINT,
num_resource_descs: UINT,
resource_descs: [*]const RESOURCE_DESC,
alloc_info: ?[*]RESOURCE_ALLOCATION_INFO1,
) RESOURCE_ALLOCATION_INFO {
var desc: RESOURCE_ALLOCATION_INFO = undefined;
self.v.device4.GetResourceAllocationInfo1(
self,
&desc,
visible_mask,
num_resource_descs,
resource_descs,
alloc_info,
);
return desc;
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
CreateCommandList1: fn (
*T,
UINT,
COMMAND_LIST_TYPE,
COMMAND_LIST_FLAGS,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateProtectedResourceSession: fn (
*T,
*const PROTECTED_RESOURCE_SESSION_DESC,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateCommittedResource1: fn (
*T,
*const HEAP_PROPERTIES,
HEAP_FLAGS,
*const RESOURCE_DESC,
RESOURCE_STATES,
?*const CLEAR_VALUE,
?*IProtectedResourceSession,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateHeap1: fn (
*T,
*const HEAP_DESC,
?*IProtectedResourceSession,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateReservedResource1: fn (
*T,
*const RESOURCE_DESC,
RESOURCE_STATES,
?*const CLEAR_VALUE,
?*IProtectedResourceSession,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
GetResourceAllocationInfo1: fn (
*T,
*RESOURCE_ALLOCATION_INFO,
UINT,
UINT,
[*]const RESOURCE_DESC,
?[*]RESOURCE_ALLOCATION_INFO1,
) callconv(WINAPI) *RESOURCE_ALLOCATION_INFO,
};
}
};
pub const LIFETIME_STATE = enum(UINT) {
IN_USE = 0,
NOT_IN_USE = 1,
};
pub const ILifetimeOwner = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
ltowner: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn LifetimeStateUpdated(self: *T, new_state: LIFETIME_STATE) void {
self.v.ltowner.LifetimeStateUpdated(self, new_state);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
LifetimeStateUpdated: fn (*T, LIFETIME_STATE) callconv(WINAPI) void,
};
}
};
pub const IDevice5 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: IDevice1.VTable(Self),
device2: IDevice2.VTable(Self),
device3: IDevice3.VTable(Self),
device4: IDevice4.VTable(Self),
device5: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace IDevice1.Methods(Self);
usingnamespace IDevice2.Methods(Self);
usingnamespace IDevice3.Methods(Self);
usingnamespace IDevice4.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn CreateLifetimeTracker(
self: *T,
owner: *ILifetimeOwner,
guid: *const GUID,
tracker: *?*anyopaque,
) HRESULT {
return self.v.device5.CreateLifetimeTracker(self, owner, guid, tracker);
}
pub inline fn RemoveDevice(self: *T) void {
self.v.device5.RemoveDevice(self);
}
pub inline fn EnumerateMetaCommands(
self: *T,
num_meta_cmds: *UINT,
descs: ?[*]META_COMMAND_DESC,
) HRESULT {
return self.v.device5.EnumerateMetaCommands(self, num_meta_cmds, descs);
}
pub inline fn EnumerateMetaCommandParameters(
self: *T,
cmd_id: *const GUID,
stage: META_COMMAND_PARAMETER_STAGE,
total_size: ?*UINT,
param_count: *UINT,
param_descs: ?[*]META_COMMAND_PARAMETER_DESC,
) HRESULT {
return self.v.device5.EnumerateMetaCommandParameters(
self,
cmd_id,
stage,
total_size,
param_count,
param_descs,
);
}
pub inline fn CreateMetaCommand(
self: *T,
cmd_id: *const GUID,
node_mask: UINT,
creation_param_data: ?*const anyopaque,
creation_param_data_size: SIZE_T,
guid: *const GUID,
meta_cmd: *?*anyopaque,
) HRESULT {
return self.v.device5.CreateMetaCommand(
self,
cmd_id,
node_mask,
creation_param_data,
creation_param_data_size,
guid,
meta_cmd,
);
}
pub inline fn CreateStateObject(
self: *T,
desc: *const STATE_OBJECT_DESC,
guid: *const GUID,
state_object: *?*anyopaque,
) HRESULT {
return self.v.device5.CreateStateObject(self, desc, guid, state_object);
}
pub inline fn GetRaytracingAccelerationStructurePrebuildInfo(
self: *T,
desc: *const BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS,
info: *RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO,
) void {
self.v.device5.GetRaytracingAccelerationStructurePrebuildInfo(self, desc, info);
}
pub inline fn CheckDriverMatchingIdentifier(
self: *T,
serialized_data_type: SERIALIZED_DATA_TYPE,
identifier_to_check: *const SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER,
) DRIVER_MATCHING_IDENTIFIER_STATUS {
return self.v.device5.CheckDriverMatchingIdentifier(self, serialized_data_type, identifier_to_check);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
CreateLifetimeTracker: fn (*T, *ILifetimeOwner, *const GUID, *?*anyopaque) callconv(WINAPI) HRESULT,
RemoveDevice: fn (self: *T) callconv(WINAPI) void,
EnumerateMetaCommands: fn (*T, *UINT, ?[*]META_COMMAND_DESC) callconv(WINAPI) HRESULT,
EnumerateMetaCommandParameters: fn (
*T,
*const GUID,
META_COMMAND_PARAMETER_STAGE,
?*UINT,
*UINT,
?[*]META_COMMAND_PARAMETER_DESC,
) callconv(WINAPI) HRESULT,
CreateMetaCommand: fn (
*T,
*const GUID,
UINT,
?*const anyopaque,
SIZE_T,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateStateObject: fn (
*T,
*const STATE_OBJECT_DESC,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
GetRaytracingAccelerationStructurePrebuildInfo: fn (
*T,
*const BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS,
*RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO,
) callconv(WINAPI) void,
CheckDriverMatchingIdentifier: fn (
*T,
SERIALIZED_DATA_TYPE,
*const SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER,
) callconv(WINAPI) DRIVER_MATCHING_IDENTIFIER_STATUS,
};
}
};
pub const BACKGROUND_PROCESSING_MODE = enum(UINT) {
ALLOWED = 0,
ALLOW_INTRUSIVE_MEASUREMENTS = 1,
DISABLE_BACKGROUND_WORK = 2,
DISABLE_PROFILING_BY_SYSTEM = 3,
};
pub const MEASUREMENTS_ACTION = enum(UINT) {
KEEP_ALL = 0,
COMMIT_RESULTS = 1,
COMMIT_RESULTS_HIGH_PRIORITY = 2,
DISCARD_PREVIOUS = 3,
};
pub const IDevice6 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: IDevice1.VTable(Self),
device2: IDevice2.VTable(Self),
device3: IDevice3.VTable(Self),
device4: IDevice4.VTable(Self),
device5: IDevice5.VTable(Self),
device6: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace IDevice1.Methods(Self);
usingnamespace IDevice2.Methods(Self);
usingnamespace IDevice3.Methods(Self);
usingnamespace IDevice4.Methods(Self);
usingnamespace IDevice5.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn SetBackgroundProcessingMode(
self: *T,
mode: BACKGROUND_PROCESSING_MODE,
measurements_action: MEASUREMENTS_ACTION,
event_to_signal_upon_completion: ?HANDLE,
further_measurements_desired: ?*BOOL,
) HRESULT {
return self.v.device6.SetBackgroundProcessingMode(
self,
mode,
measurements_action,
event_to_signal_upon_completion,
further_measurements_desired,
);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
SetBackgroundProcessingMode: fn (
*T,
BACKGROUND_PROCESSING_MODE,
MEASUREMENTS_ACTION,
?HANDLE,
?*BOOL,
) callconv(WINAPI) HRESULT,
};
}
};
pub const PROTECTED_RESOURCE_SESSION_DESC1 = extern struct {
NodeMask: UINT,
Flags: PROTECTED_RESOURCE_SESSION_FLAGS,
ProtectionType: GUID,
};
pub const IDevice7 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: IDevice1.VTable(Self),
device2: IDevice2.VTable(Self),
device3: IDevice3.VTable(Self),
device4: IDevice4.VTable(Self),
device5: IDevice5.VTable(Self),
device6: IDevice6.VTable(Self),
device7: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace IDevice1.Methods(Self);
usingnamespace IDevice2.Methods(Self);
usingnamespace IDevice3.Methods(Self);
usingnamespace IDevice4.Methods(Self);
usingnamespace IDevice5.Methods(Self);
usingnamespace IDevice6.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn AddToStateObject(
self: *T,
addition: *const STATE_OBJECT_DESC,
state_object: *IStateObject,
guid: *const GUID,
new_state_object: *?*anyopaque,
) HRESULT {
return self.v.device7.AddToStateObject(self, addition, state_object, guid, new_state_object);
}
pub inline fn CreateProtectedResourceSession1(
self: *T,
desc: *const PROTECTED_RESOURCE_SESSION_DESC1,
guid: *const GUID,
session: *?*anyopaque,
) HRESULT {
return self.v.device7.CreateProtectedResourceSession1(self, desc, guid, session);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
AddToStateObject: fn (
*T,
*const STATE_OBJECT_DESC,
*IStateObject,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateProtectedResourceSession1: fn (
*T,
*const PROTECTED_RESOURCE_SESSION_DESC1,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
};
}
};
pub const MIP_REGION = extern struct {
Width: UINT,
Height: UINT,
Depth: UINT,
};
pub const RESOURCE_DESC1 = extern struct {
Dimension: RESOURCE_DIMENSION,
Alignment: UINT64,
Width: UINT64,
Height: UINT,
DepthOrArraySize: UINT16,
MipLevels: UINT16,
Format: dxgi.FORMAT,
SampleDesc: dxgi.SAMPLE_DESC,
Layout: TEXTURE_LAYOUT,
Flags: RESOURCE_FLAGS,
SamplerFeedbackMipRegion: MIP_REGION,
};
pub const IDevice8 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: IDevice1.VTable(Self),
device2: IDevice2.VTable(Self),
device3: IDevice3.VTable(Self),
device4: IDevice4.VTable(Self),
device5: IDevice5.VTable(Self),
device6: IDevice6.VTable(Self),
device7: IDevice7.VTable(Self),
device8: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace IDevice1.Methods(Self);
usingnamespace IDevice2.Methods(Self);
usingnamespace IDevice3.Methods(Self);
usingnamespace IDevice4.Methods(Self);
usingnamespace IDevice5.Methods(Self);
usingnamespace IDevice6.Methods(Self);
usingnamespace IDevice7.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetResourceAllocationInfo2(
self: *T,
visible_mask: UINT,
num_resource_descs: UINT,
resource_descs: *const RESOURCE_DESC1,
alloc_info: ?[*]RESOURCE_ALLOCATION_INFO1,
) RESOURCE_ALLOCATION_INFO {
var desc: RESOURCE_ALLOCATION_INFO = undefined;
self.v.device8.GetResourceAllocationInfo2(
self,
&desc,
visible_mask,
num_resource_descs,
resource_descs,
alloc_info,
);
return desc;
}
pub inline fn CreateCommittedResource2(
self: *T,
heap_properties: *const HEAP_PROPERTIES,
heap_flags: HEAP_FLAGS,
desc: *const RESOURCE_DESC1,
initial_state: RESOURCE_STATES,
clear_value: ?*const CLEAR_VALUE,
prsession: ?*IProtectedResourceSession,
guid: *const GUID,
resource: ?*?*anyopaque,
) HRESULT {
return self.v.device8.CreateCommittedResource2(
self,
heap_properties,
heap_flags,
desc,
initial_state,
clear_value,
prsession,
guid,
resource,
);
}
pub inline fn CreatePlacedResource1(
self: *T,
heap: *IHeap,
heap_offset: UINT64,
desc: *const RESOURCE_DESC1,
initial_state: RESOURCE_STATES,
clear_value: ?*const CLEAR_VALUE,
guid: *const GUID,
resource: ?*?*anyopaque,
) HRESULT {
return self.v.device8.CreatePlacedResource1(
self,
heap,
heap_offset,
desc,
initial_state,
clear_value,
guid,
resource,
);
}
pub inline fn CreateSamplerFeedbackUnorderedAccessView(
self: *T,
targeted_resource: ?*IResource,
feedback_resource: ?*IResource,
dest_descriptor: CPU_DESCRIPTOR_HANDLE,
) void {
self.v.device8.CreateSamplerFeedbackUnorderedAccessView(
self,
targeted_resource,
feedback_resource,
dest_descriptor,
);
}
pub inline fn GetCopyableFootprints1(
self: *T,
desc: *const RESOURCE_DESC1,
first_subresource: UINT,
num_subresources: UINT,
base_offset: UINT64,
layouts: ?[*]PLACED_SUBRESOURCE_FOOTPRINT,
num_rows: ?[*]UINT,
row_size_in_bytes: ?[*]UINT64,
total_bytes: ?*UINT64,
) void {
self.v.device8.GetCopyableFootprints1(
self,
desc,
first_subresource,
num_subresources,
base_offset,
layouts,
num_rows,
row_size_in_bytes,
total_bytes,
);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetResourceAllocationInfo2: fn (
*T,
UINT,
UINT,
*const RESOURCE_DESC1,
?[*]RESOURCE_ALLOCATION_INFO1,
) callconv(WINAPI) RESOURCE_ALLOCATION_INFO,
CreateCommittedResource2: fn (
*T,
*const HEAP_PROPERTIES,
HEAP_FLAGS,
*const RESOURCE_DESC1,
RESOURCE_STATES,
?*const CLEAR_VALUE,
?*IProtectedResourceSession,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreatePlacedResource1: fn (
*T,
*IHeap,
UINT64,
*const RESOURCE_DESC1,
RESOURCE_STATES,
?*const CLEAR_VALUE,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
CreateSamplerFeedbackUnorderedAccessView: fn (
*T,
?*IResource,
?*IResource,
CPU_DESCRIPTOR_HANDLE,
) callconv(WINAPI) void,
GetCopyableFootprints1: fn (
*T,
*const RESOURCE_DESC1,
UINT,
UINT,
UINT64,
?[*]PLACED_SUBRESOURCE_FOOTPRINT,
?[*]UINT,
?[*]UINT64,
?*UINT64,
) callconv(WINAPI) void,
};
}
};
pub const SHADER_CACHE_KIND_FLAGS = UINT;
pub const SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = 0x1;
pub const SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = 0x2;
pub const SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = 0x4;
pub const SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = 0x8;
pub const SHADER_CACHE_CONTROL_FLAGS = UINT;
pub const SHADER_CACHE_CONTROL_FLAG_DISABLE = 0x1;
pub const SHADER_CACHE_CONTROL_FLAG_ENABLE = 0x2;
pub const SHADER_CACHE_CONTROL_FLAG_CLEAR = 0x4;
pub const SHADER_CACHE_MODE = enum(UINT) {
MEMORY = 0,
DISK = 1,
};
pub const SHADER_CACHE_FLAGS = UINT;
pub const SHADER_CACHE_FLAG_NONE = 0;
pub const SHADER_CACHE_FLAG_DRIVER_VERSIONED = 0x1;
pub const SHADER_CACHE_FLAG_USE_WORKING_DIR = 0x2;
pub const SHADER_CACHE_SESSION_DESC = extern struct {
Identifier: GUID,
Mode: SHADER_CACHE_MODE,
Flags: SHADER_CACHE_FLAGS,
MaximumInMemoryCacheSizeBytes: UINT,
MaximumInMemoryCacheEntries: UINT,
MaximumValueFileSizeBytes: UINT,
Version: UINT64,
};
pub const IDevice9 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
device: IDevice.VTable(Self),
device1: IDevice1.VTable(Self),
device2: IDevice2.VTable(Self),
device3: IDevice3.VTable(Self),
device4: IDevice4.VTable(Self),
device5: IDevice5.VTable(Self),
device6: IDevice6.VTable(Self),
device7: IDevice7.VTable(Self),
device8: IDevice8.VTable(Self),
device9: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDevice.Methods(Self);
usingnamespace IDevice1.Methods(Self);
usingnamespace IDevice2.Methods(Self);
usingnamespace IDevice3.Methods(Self);
usingnamespace IDevice4.Methods(Self);
usingnamespace IDevice5.Methods(Self);
usingnamespace IDevice6.Methods(Self);
usingnamespace IDevice7.Methods(Self);
usingnamespace IDevice8.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn CreateShaderCacheSession(
self: *T,
desc: *const SHADER_CACHE_SESSION_DESC,
guid: *const GUID,
session: ?*?*anyopaque,
) HRESULT {
return self.v.device9.CreateShaderCacheSession(self, desc, guid, session);
}
pub inline fn ShaderCacheControl(
self: *T,
kinds: SHADER_CACHE_KIND_FLAGS,
control: SHADER_CACHE_CONTROL_FLAGS,
) HRESULT {
return self.v.device9.ShaderCacheControl(self, kinds, control);
}
pub inline fn CreateCommandQueue1(
self: *T,
desc: *const COMMAND_QUEUE_DESC,
creator_id: *const GUID,
guid: *const GUID,
cmdqueue: *?*anyopaque,
) HRESULT {
return self.v.device9.CreateCommandQueue1(self, desc, creator_id, guid, cmdqueue);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
CreateShaderCacheSession: fn (
*T,
*const SHADER_CACHE_SESSION_DESC,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT,
ShaderCacheControl: fn (
*T,
SHADER_CACHE_KIND_FLAGS,
SHADER_CACHE_CONTROL_FLAGS,
) callconv(WINAPI) HRESULT,
CreateCommandQueue1: fn (
*T,
*const COMMAND_QUEUE_DESC,
*const GUID,
*const GUID,
*?*anyopaque,
) callconv(WINAPI) HRESULT,
};
}
};
pub const PROTECTED_SESSION_STATUS = enum(UINT) {
OK = 0,
INVALID = 1,
};
pub const IProtectedSession = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
psession: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetStatusFence(self: *T, guid: *const GUID, fence: ?*?*anyopaque) HRESULT {
return self.v.psession.GetStatusFence(self, guid, fence);
}
pub inline fn GetSessionStatus(self: *T) PROTECTED_SESSION_STATUS {
return self.v.psession.GetSessionStatus(self);
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetStatusFence: fn (*T, *const GUID, ?*?*anyopaque) callconv(WINAPI) HRESULT,
GetSessionStatus: fn (*T) callconv(WINAPI) PROTECTED_SESSION_STATUS,
};
}
};
pub const PROTECTED_RESOURCE_SESSION_FLAGS = UINT;
pub const PROTECTED_RESOURCE_SESSION_DESC = extern struct {
NodeMask: UINT,
Flags: PROTECTED_RESOURCE_SESSION_FLAGS,
};
pub const IProtectedResourceSession = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
object: IObject.VTable(Self),
devchild: IDeviceChild.VTable(Self),
psession: IProtectedSession.VTable(Self),
prsession: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace IObject.Methods(Self);
usingnamespace IDeviceChild.Methods(Self);
usingnamespace IProtectedSession.Methods(Self);
usingnamespace Methods(Self);
fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetDesc(self: *T) PROTECTED_RESOURCE_SESSION_DESC {
var desc: PROTECTED_RESOURCE_SESSION_DESC = undefined;
_ = self.v.prsession.GetDesc(self, &desc);
return desc;
}
};
}
fn VTable(comptime T: type) type {
return extern struct {
GetDesc: fn (
*T,
*PROTECTED_RESOURCE_SESSION_DESC,
) callconv(WINAPI) *PROTECTED_RESOURCE_SESSION_DESC,
};
}
};
pub extern "d3d12" fn D3D12GetDebugInterface(*const GUID, ?*?*anyopaque) callconv(WINAPI) HRESULT;
pub extern "d3d12" fn D3D12CreateDevice(
?*IUnknown,
d3d.FEATURE_LEVEL,
*const GUID,
?*?*anyopaque,
) callconv(WINAPI) HRESULT;
pub extern "d3d12" fn D3D12SerializeVersionedRootSignature(
*const VERSIONED_ROOT_SIGNATURE_DESC,
?*?*d3d.IBlob,
?*?*d3d.IBlob,
) callconv(WINAPI) HRESULT;
pub const IID_IDevice = GUID{
.Data1 = 0x189819f1,
.Data2 = 0x1db6,
.Data3 = 0x4b57,
.Data4 = .{ 0xbe, 0x54, 0x18, 0x21, 0x33, 0x9b, 0x85, 0xf7 },
};
pub const IID_IDevice1 = GUID{
.Data1 = 0x77acce80,
.Data2 = 0x638e,
.Data3 = 0x4e65,
.Data4 = .{ 0x88, 0x95, 0xc1, 0xf2, 0x33, 0x86, 0x86, 0x3e },
};
pub const IID_IDevice2 = GUID{
.Data1 = 0x30baa41e,
.Data2 = 0xb15b,
.Data3 = 0x475c,
.Data4 = .{ 0xa0, 0xbb, 0x1a, 0xf5, 0xc5, 0xb6, 0x43, 0x28 },
};
pub const IID_IDevice3 = GUID{
.Data1 = 0x81dadc15,
.Data2 = 0x2bad,
.Data3 = 0x4392,
.Data4 = .{ 0x93, 0xc5, 0x10, 0x13, 0x45, 0xc4, 0xaa, 0x98 },
};
pub const IID_IDevice4 = GUID{
.Data1 = 0xe865df17,
.Data2 = 0xa9ee,
.Data3 = 0x46f9,
.Data4 = .{ 0xa4, 0x63, 0x30, 0x98, 0x31, 0x5a, 0xa2, 0xe5 },
};
pub const IID_IDevice5 = GUID{
.Data1 = 0x8b4f173a,
.Data2 = 0x2fea,
.Data3 = 0x4b80,
.Data4 = .{ 0x8f, 0x58, 0x43, 0x07, 0x19, 0x1a, 0xb9, 0x5d },
};
pub const IID_IDevice6 = GUID{
.Data1 = 0xc70b221b,
.Data2 = 0x40e4,
.Data3 = 0x4a17,
.Data4 = .{ 0x89, 0xaf, 0x02, 0x5a, 0x07, 0x27, 0xa6, 0xdc },
};
pub const IID_IDevice7 = GUID{
.Data1 = 0x5c014b53,
.Data2 = 0x68a1,
.Data3 = 0x4b9b,
.Data4 = .{ 0x8b, 0xd1, 0xdd, 0x60, 0x46, 0xb9, 0x35, 0x8b },
};
pub const IID_IDevice8 = GUID{
.Data1 = 0x9218E6BB,
.Data2 = 0xF944,
.Data3 = 0x4F7E,
.Data4 = .{ 0xA7, 0x5C, 0xB1, 0xB2, 0xC7, 0xB7, 0x01, 0xF3 },
};
pub const IID_IDevice9 = GUID{
.Data1 = 0x4c80e962,
.Data2 = 0xf032,
.Data3 = 0x4f60,
.Data4 = .{ 0xbc, 0x9e, 0xeb, 0xc2, 0xcf, 0xa1, 0xd8, 0x3c },
};
pub const IID_ICommandQueue = GUID{
.Data1 = 0x0ec870a6,
.Data2 = 0x5d7e,
.Data3 = 0x4c22,
.Data4 = .{ 0x8c, 0xfc, 0x5b, 0xaa, 0xe0, 0x76, 0x16, 0xed },
};
pub const IID_IFence = GUID{
.Data1 = 0x0a753dcf,
.Data2 = 0xc4d8,
.Data3 = 0x4b91,
.Data4 = .{ 0xad, 0xf6, 0xbe, 0x5a, 0x60, 0xd9, 0x5a, 0x76 },
};
pub const IID_ICommandAllocator = GUID{
.Data1 = 0x6102dee4,
.Data2 = 0xaf59,
.Data3 = 0x4b09,
.Data4 = .{ 0xb9, 0x99, 0xb4, 0x4d, 0x73, 0xf0, 0x9b, 0x24 },
};
pub const IID_IPipelineState = GUID{
.Data1 = 0x765a30f3,
.Data2 = 0xf624,
.Data3 = 0x4c6f,
.Data4 = .{ 0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45 },
};
pub const IID_IDescriptorHeap = GUID{
.Data1 = 0x8efb471d,
.Data2 = 0x616c,
.Data3 = 0x4f49,
.Data4 = .{ 0x90, 0xf7, 0x12, 0x7b, 0xb7, 0x63, 0xfa, 0x51 },
};
pub const IID_IResource = GUID{
.Data1 = 0x696442be,
.Data2 = 0xa72e,
.Data3 = 0x4059,
.Data4 = .{ 0xbc, 0x79, 0x5b, 0x5c, 0x98, 0x04, 0x0f, 0xad },
};
pub const IID_IRootSignature = GUID{
.Data1 = 0xc54a6b66,
.Data2 = 0x72df,
.Data3 = 0x4ee8,
.Data4 = .{ 0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14 },
};
pub const IID_IGraphicsCommandList = GUID{
.Data1 = 0x5b160d0f,
.Data2 = 0xac1b,
.Data3 = 0x4185,
.Data4 = .{ 0x8b, 0xa8, 0xb3, 0xae, 0x42, 0xa5, 0xa4, 0x55 },
};
pub const IID_IGraphicsCommandList1 = GUID{
.Data1 = 0x553103fb,
.Data2 = 0x1fe7,
.Data3 = 0x4557,
.Data4 = .{ 0xbb, 0x38, 0x94, 0x6d, 0x7d, 0x0e, 0x7c, 0xa7 },
};
pub const IID_IGraphicsCommandList2 = GUID{
.Data1 = 0x38C3E584,
.Data2 = 0xFF17,
.Data3 = 0x412C,
.Data4 = .{ 0x91, 0x50, 0x4F, 0xC6, 0xF9, 0xD7, 0x2A, 0x28 },
};
pub const IID_IGraphicsCommandList3 = GUID{
.Data1 = 0x6FDA83A7,
.Data2 = 0xB84C,
.Data3 = 0x4E38,
.Data4 = .{ 0x9A, 0xC8, 0xC7, 0xBD, 0x22, 0x01, 0x6B, 0x3D },
};
pub const IID_IGraphicsCommandList4 = GUID{
.Data1 = 0x8754318e,
.Data2 = 0xd3a9,
.Data3 = 0x4541,
.Data4 = .{ 0x98, 0xcf, 0x64, 0x5b, 0x50, 0xdc, 0x48, 0x74 },
};
pub const IID_IGraphicsCommandList5 = GUID{
.Data1 = 0x55050859,
.Data2 = 0x4024,
.Data3 = 0x474c,
.Data4 = .{ 0x87, 0xf5, 0x64, 0x72, 0xea, 0xee, 0x44, 0xea },
};
pub const IID_IGraphicsCommandList6 = GUID{
.Data1 = 0xc3827890,
.Data2 = 0xe548,
.Data3 = 0x4cfa,
.Data4 = .{ 0x96, 0xcf, 0x56, 0x89, 0xa9, 0x37, 0x0f, 0x80 },
};
// Error return codes from https://docs.microsoft.com/en-us/windows/win32/direct3d12/d3d12-graphics-reference-returnvalues
pub const ERROR_ADAPTER_NOT_FOUND = @bitCast(HRESULT, @as(c_ulong, 0x887E0001));
pub const ERROR_DRIVER_VERSION_MISMATCH = @bitCast(HRESULT, @as(c_ulong, 0x887E0002));
// Error set corresponding to the above error return codes
pub const Error = error{
ADAPTER_NOT_FOUND,
DRIVER_VERSION_MISMATCH,
}; | modules/platform/vendored/zwin32/src/d3d12.zig |
const mustache = @import("mustache.zig");
const Delimiters = mustache.Delimiters;
const builtin = @import("builtin");
pub const comptime_tests_enabled = false;
/// General options for processing a mustache template
pub const TemplateOptions = struct {
/// Template source options
source: TemplateSource,
/// Template output options
output: ParserOutput,
/// Those options affect both performance and supported Mustache features.
/// Defaults to full-spec compatible.
features: Features = .{},
/// Template load mode
/// Can be "runtime" or "comptime"
load_mode: TemplateLoadMode = .runtime_loaded,
pub fn isRefCounted(self: @This()) bool {
return self.source == .Stream;
}
pub fn copyStrings(self: @This()) bool {
return switch (self.output) {
.Render => false,
.Parse => switch (self.source) {
.String => |option| option.copy_strings,
.Stream => true,
},
};
}
};
pub const TemplateLoadMode = union(enum) {
runtime_loaded,
comptime_loaded: struct {
template_text: []const u8,
default_delimiters: Delimiters,
},
};
pub const TemplateSource = union(enum) {
/// Loads a template from string
String: struct {
/// Use 'false' if the source string is static or lives enough
copy_strings: bool = true,
},
/// Loads a template from a file or stream
Stream: struct {
/// Define the buffer size for reading the stream
read_buffer_size: usize = 4 * 1024,
},
};
pub const ParserOutput = enum {
/// Parses a template
/// Use this option for validation and to store a template for future rendering
/// This option speeds up the rendering process when the same template is rendered many times
Parse,
/// Parses just enough to render directly, without storing the template.
/// This option saves memory.
Render,
};
pub const ParseTextOptions = struct {
/// Use 'false' if the source string is static or lives enough
copy_strings: bool,
/// Those options affect both performance and supported Mustache features.
/// Defaults to full-spec compatible.
features: Features = .{},
};
pub const ParseFileOptions = struct {
/// Define the buffer size for reading the stream
read_buffer_size: usize = 4 * 1024,
/// Those options affect both performance and supported Mustache features.
/// Defaults to full-spec compatible.
features: Features = .{},
};
pub const Features = struct {
/// Allows redefining the delimiters through the tags '{{=' and '=}}'
/// Disabling this option speeds up the parsing process.
/// If disabled, any occurrence of '{{=' will result in a parse error
allow_redefining_delimiters: bool = true,
/// Preserve line breaks and indentations.
/// This option is useful when rendering documents sensible to spaces such as `yaml` for example.
/// Disabling this option speeds up the parsing process.
/// Examples:
/// [Line breaks](https://github.com/mustache/spec/blob/b2aeb3c283de931a7004b5f7a2cb394b89382369/specs/comments.yml#L38)
/// [Indentation](https://github.com/mustache/spec/blob/b2aeb3c283de931a7004b5f7a2cb394b89382369/specs/partials.yml#L82)
preseve_line_breaks_and_indentation: bool = true,
/// Lambda expansion support
lambdas: Lambdas = .{ .Enabled = .{} },
};
pub const Lambdas = union(enum) {
/// Use this option if your data source does not implement lambda functions
/// Disabling lambda support saves memory and speeds up the parsing process
Disabled,
/// Use this option to support lambda functions in your data sources
Enabled: struct {
/// Lambdas can expand to new tags, including another lambda
/// Defines the max recursion depth to avoid infinite recursion when evaluating lambdas
/// A recursive lambda will interpolate as an empty string, without erros
max_recursion: u32 = 100,
},
};
pub const ContextMisses = enum {
Empty,
Error,
};
pub const RenderTemplateOptions = struct {
/// Defines the behavior when rendering a unknown context
/// Mustache's spec says it must be rendered as an empty string
/// However, in Debug mode it defaults to `Error` to avoid silently broken contexts.
context_misses: ContextMisses = if (builtin.mode == .Debug) .Error else .Empty,
};
pub const RenderTextOptions = struct {
/// Defines the behavior when rendering a unknown context
/// Mustache's spec says it must be rendered as an empty string
/// However, in Debug mode it defaults to `Error` to avoid silently broken contexts.
context_misses: ContextMisses = if (builtin.mode == .Debug) .Error else .Empty,
/// Those options affect both performance and supported Mustache features.
/// Defaults to full-spec compatible.
features: Features = .{},
};
pub const RenderFileOptions = struct {
/// Defines the behavior when rendering a unknown context
/// Mustache's spec says it must be rendered as an empty string
/// However, in Debug mode it defaults to `Error` to avoid silently broken contexts.
context_misses: ContextMisses = if (builtin.mode == .Debug) .Error else .Empty,
/// Define the buffer size for reading the stream
read_buffer_size: usize = 4 * 1024,
/// Those options affect both performance and supported Mustache features.
/// Defaults to full-spec compatible.
features: Features = .{},
};
pub const RenderOptions = union(enum) {
Template: RenderTemplateOptions,
Text: RenderTextOptions,
File: RenderFileOptions,
}; | src/options.zig |
const std = @import("std");
pub const ArgParseOptions = struct {
allocator: *std.mem.Allocator = std.heap.c_allocator,
};
const ArgParseError = error{
AllocatorRequired,
InvalidArgs,
MissingField,
UnexpectedArgument,
UnexpectedField,
};
pub fn parse(comptime T: type, options: ArgParseOptions) !T {
var args = std.ArrayList([]const u8).init(options.allocator);
defer args.deinit();
for (std.os.argv) |arg| {
var str = std.mem.spanZ(arg);
if (std.mem.startsWith(u8, str, "--")) {
if (std.mem.indexOf(u8, str, "=")) |idx| {
try args.append(str[0..idx]);
str = str[idx + 1 ..];
}
}
try args.append(str);
}
return parseInternal(T, args.items[1..], options);
}
fn parseInternal(comptime T: type, args: []const []const u8, options: ArgParseOptions) ArgParseError!T {
const info = @typeInfo(T).Struct;
var result: T = undefined;
var fields_seen = [_]bool{false} ** info.fields.len;
var iter = try splitArgs(args);
while (iter.next()) |kv| {
const key = kv[0][2..]; // Remove -- prefix
const val = kv[1..];
var found = false;
inline for (info.fields) |field, field_i| {
if (std.mem.eql(u8, key, field.name)) {
fields_seen[field_i] = true;
@field(result, field.name) = try parseValues(field.field_type, val, options);
found = true;
break;
}
}
if (!found) {
return error.UnexpectedField;
}
}
// Set default value
inline for (info.fields) |field, i| {
if (!fields_seen[i]) {
if (field.default_value) |default| {
if (!field.is_comptime) {
@field(result, field.name) = default;
}
} else {
return error.MissingField;
}
}
}
return result;
}
fn splitArgs(args: []const []const u8) ArgParseError!SplitIterator {
if (args.len == 0) {
return SplitIterator{ .args = args, .index = null };
}
if (!std.mem.startsWith(u8, args[0], "--")) {
return error.InvalidArgs;
}
return SplitIterator{
.args = args,
.index = 0,
};
}
const SplitIterator = struct {
args: []const []const u8,
index: ?usize,
pub fn next(self: *SplitIterator) ?[]const []const u8 {
const start = self.index orelse return null;
const end = if (indexOfPos(self.args, start + 1)) |key_start| blk: {
self.index = key_start;
break :blk key_start;
} else blk: {
self.index = null;
break :blk self.args.len;
};
return self.args[start..end];
}
/// Returns a slice of the remaining bytes. Does not affect iterator state.
pub fn rest(self: SplitIterator) []const []const u8 {
const end = self.args.len;
const start = self.index orelse end;
return self.args[start..end];
}
fn indexOfPos(args: []const []const u8, start_index: usize) ?usize {
var i: usize = start_index;
while (i < args.len) : (i += 1) {
if (std.mem.startsWith(u8, args[i], "--")) {
return i;
}
}
return null;
}
};
fn parseValues(comptime T: type, values: []const []const u8, options: ArgParseOptions) ArgParseError!T {
if (values.len != 1) {
return error.InvalidArgs;
}
switch (@typeInfo(T)) {
.Bool => {
if (std.mem.eql(u8, values[0], "true")) return true;
if (std.mem.eql(u8, values[0], "false")) return false;
return error.InvalidArgs;
},
.Float, .ComptimeFloat => {
return try std.fmt.parseFloat(T, values[0]) catch error.InvalidArgs;
},
.Int, .ComptimeInt => {
return std.fmt.parseInt(T, values[0], 10) catch error.InvalidArgs;
},
.Optional => |optionalInfo| {
return try parseValues(optionalInfo.child, values, options);
},
.Pointer => |ptrInfo| {
switch (ptrInfo.size) {
.One => {
const allocator = options.allocator orelse return error.AllocatorRequired;
const r: T = try allocator.create(ptrInfo.child);
r.* = try parseValues(ptrInfo.child, values, options);
return r;
},
.Slice => {
if (ptrInfo.child != u8) return error.InvalidArgs;
return values[0];
},
else => return error.InvalidArgs,
}
},
else => return error.InvalidArgs,
}
}
pub fn parseFree(comptime T: type, value: T, options: ArgParseOptions) void {
inline for (@typeInfo(T).Struct.fields) |field| {
fieldFree(field.field_type, @field(value, field.name), options);
}
}
fn fieldFree(comptime T: type, value: T, options: ArgParseOptions) void {
switch (@typeInfo(T)) {
.Bool, .Float, .ComptimeFloat, .Int, .ComptimeInt => {},
.Optional => |optionalInfo| {
if (value) |v| {
fieldFree(optionalInfo.child, v, options);
}
},
.Pointer => |ptrInfo| {
switch (ptrInfo.size) {
.One => {
fieldFree(ptrInfo.child, value.*, options);
options.allocator.destroy(value);
},
.Slice => {
for (value) |v| {
fieldFree(ptrInfo.child, v, options);
}
},
else => unreachable,
}
},
else => unreachable,
}
}
test "parse multiple fields" {
const Args = struct {
str: []const u8,
boolean: bool,
default: []const u8 = "default",
float: f64,
int: u32,
optional_str: ?[]const u8 = null,
};
const options = ArgParseOptions{ .allocator = std.testing.allocator };
const parsed = try parseInternal(Args, &[_][]const u8{
"--str",
"test",
"--boolean",
"false",
"--float",
"1.1",
"--int",
"1234",
"--optional_str",
"optional",
}, options);
try std.testing.expectEqual(@as([]const u8, "test"), parsed.str);
try std.testing.expectEqual(false, parsed.boolean);
try std.testing.expectEqual(@as(f64, 1.1), parsed.float);
try std.testing.expectEqual(@as(u32, 1234), parsed.int);
try std.testing.expectEqual(@as(?[]const u8, "optional"), parsed.optional_str);
defer parseFree(Args, parsed, options);
}
test "parse default values" {
const Args = struct {
str: []const u8 = "test",
boolean: bool = false,
float: f64 = 1.1,
int: u32 = 1234,
optional: ?u32 = null,
};
const options = ArgParseOptions{ .allocator = std.testing.allocator };
const parsed = try parseInternal(Args, &[_][]const u8{}, options);
try std.testing.expectEqual(@as([]const u8, "test"), parsed.str);
try std.testing.expectEqual(false, parsed.boolean);
try std.testing.expectEqual(@as(f64, 1.1), parsed.float);
try std.testing.expectEqual(@as(u32, 1234), parsed.int);
try std.testing.expectEqual(@as(?u32, null), parsed.optional);
defer parseFree(Args, parsed, options);
}
test "parse missing field" {
const Args = struct {
str: []const u8,
};
const options = ArgParseOptions{ .allocator = std.testing.allocator };
const parsed = parseInternal(Args, &[_][]const u8{}, options);
try std.testing.expectError(error.MissingField, parsed);
}
test "parse unexpected field" {
const Args = struct {
str: []const u8,
};
const options = ArgParseOptions{ .allocator = std.testing.allocator };
const parsed = parseInternal(Args, &[_][]const u8{
"--str",
"test",
"--something",
"some",
}, options);
try std.testing.expectError(error.UnexpectedField, parsed);
} | src/argparse.zig |
const std = @import("std");
const argsParser = @import("args.zig");
pub fn main() !u8 {
var argsAllocator = std.heap.page_allocator;
const options = argsParser.parseWithVerbForCurrentProcess(
struct {
// this declares long option that can come before or after verb
output: ?[]const u8 = null,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.o = "output",
};
},
union(enum) {
compact: struct {
// This declares long options for double hyphen
host: ?[]const u8 = null,
port: u16 = 3420,
mode: enum { default, special, slow, fast } = .default,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.H = "host",
.p = "port",
};
},
reload: struct {
// This declares long options for double hyphen
force: bool = false,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.f = "force",
};
},
},
argsAllocator,
.print,
) catch return 1;
defer options.deinit();
std.debug.print("executable name: {s}\n", .{options.executable_name});
// non-verb/global options
inline for (std.meta.fields(@TypeOf(options.options))) |fld| {
std.debug.print("\t{s} = {any}\n", .{
fld.name,
@field(options.options, fld.name),
});
}
// verb options
switch (options.verb.?) {
.compact => |opts| {
inline for (std.meta.fields(@TypeOf(opts))) |fld| {
std.debug.print("\t{s} = {any}\n", .{
fld.name,
@field(opts, fld.name),
});
}
},
.reload => |opts| {
inline for (std.meta.fields(@TypeOf(opts))) |fld| {
std.debug.print("\t{s} = {any}\n", .{
fld.name,
@field(opts, fld.name),
});
}
},
}
std.debug.print("parsed positionals:\n", .{});
for (options.positionals) |arg| {
std.debug.print("\t'{s}'\n", .{arg});
}
return 0;
} | demo_verb.zig |
const cc = @cImport(@cInclude("GLFW/glfw3.h"));
/// The unknown key
pub const unknown = cc.GLFW_KEY_UNKNOWN;
/// Printable keys
pub const space = cc.GLFW_KEY_SPACE;
pub const apostrophe = cc.GLFW_KEY_APOSTROPHE;
pub const comma = cc.GLFW_KEY_COMMA;
pub const minus = cc.GLFW_KEY_MINUS;
pub const period = cc.GLFW_KEY_PERIOD;
pub const slash = cc.GLFW_KEY_SLASH;
pub const zero = cc.GLFW_KEY_0;
pub const one = cc.GLFW_KEY_1;
pub const two = cc.GLFW_KEY_2;
pub const three = cc.GLFW_KEY_3;
pub const four = cc.GLFW_KEY_4;
pub const five = cc.GLFW_KEY_5;
pub const six = cc.GLFW_KEY_6;
pub const seven = cc.GLFW_KEY_7;
pub const eight = cc.GLFW_KEY_8;
pub const nine = cc.GLFW_KEY_9;
pub const semicolon = cc.GLFW_KEY_SEMICOLON;
pub const equal = cc.GLFW_KEY_EQUAL;
pub const a = cc.GLFW_KEY_A;
pub const b = cc.GLFW_KEY_B;
pub const c = cc.GLFW_KEY_C;
pub const d = cc.GLFW_KEY_D;
pub const e = cc.GLFW_KEY_E;
pub const f = cc.GLFW_KEY_F;
pub const g = cc.GLFW_KEY_G;
pub const h = cc.GLFW_KEY_H;
pub const i = cc.GLFW_KEY_I;
pub const j = cc.GLFW_KEY_J;
pub const k = cc.GLFW_KEY_K;
pub const l = cc.GLFW_KEY_L;
pub const m = cc.GLFW_KEY_M;
pub const n = cc.GLFW_KEY_N;
pub const o = cc.GLFW_KEY_O;
pub const p = cc.GLFW_KEY_P;
pub const q = cc.GLFW_KEY_Q;
pub const r = cc.GLFW_KEY_R;
pub const s = cc.GLFW_KEY_S;
pub const t = cc.GLFW_KEY_T;
pub const u = cc.GLFW_KEY_U;
pub const v = cc.GLFW_KEY_V;
pub const w = cc.GLFW_KEY_W;
pub const x = cc.GLFW_KEY_X;
pub const y = cc.GLFW_KEY_Y;
pub const z = cc.GLFW_KEY_Z;
pub const left_bracket = cc.GLFW_KEY_LEFT_BRACKET;
pub const backslash = cc.GLFW_KEY_BACKSLASH;
pub const right_bracket = cc.GLFW_KEY_RIGHT_BRACKET;
pub const grave_accent = cc.GLFW_KEY_GRAVE_ACCENT;
pub const world_1 = cc.GLFW_KEY_WORLD_1; // non-US #1
pub const world_2 = cc.GLFW_KEY_WORLD_2; // non-US #2
/// Function keys
pub const escape = cc.GLFW_KEY_ESCAPE;
pub const enter = cc.GLFW_KEY_ENTER;
pub const tab = cc.GLFW_KEY_TAB;
pub const backspace = cc.GLFW_KEY_BACKSPACE;
pub const insert = cc.GLFW_KEY_INSERT;
pub const delete = cc.GLFW_KEY_DELETE;
pub const right = cc.GLFW_KEY_RIGHT;
pub const left = cc.GLFW_KEY_LEFT;
pub const down = cc.GLFW_KEY_DOWN;
pub const up = cc.GLFW_KEY_UP;
pub const page_up = cc.GLFW_KEY_PAGE_UP;
pub const page_down = cc.GLFW_KEY_PAGE_DOWN;
pub const home = cc.GLFW_KEY_HOME;
pub const end = cc.GLFW_KEY_END;
pub const caps_lock = cc.GLFW_KEY_CAPS_LOCK;
pub const scroll_lock = cc.GLFW_KEY_SCROLL_LOCK;
pub const num_lock = cc.GLFW_KEY_NUM_LOCK;
pub const print_screen = cc.GLFW_KEY_PRINT_SCREEN;
pub const pause = cc.GLFW_KEY_PAUSE;
pub const F1 = cc.GLFW_KEY_F1;
pub const F2 = cc.GLFW_KEY_F2;
pub const F3 = cc.GLFW_KEY_F3;
pub const F4 = cc.GLFW_KEY_F4;
pub const F5 = cc.GLFW_KEY_F5;
pub const F6 = cc.GLFW_KEY_F6;
pub const F7 = cc.GLFW_KEY_F7;
pub const F8 = cc.GLFW_KEY_F8;
pub const F9 = cc.GLFW_KEY_F9;
pub const F10 = cc.GLFW_KEY_F10;
pub const F11 = cc.GLFW_KEY_F11;
pub const F12 = cc.GLFW_KEY_F12;
pub const F13 = cc.GLFW_KEY_F13;
pub const F14 = cc.GLFW_KEY_F14;
pub const F15 = cc.GLFW_KEY_F15;
pub const F16 = cc.GLFW_KEY_F16;
pub const F17 = cc.GLFW_KEY_F17;
pub const F18 = cc.GLFW_KEY_F18;
pub const F19 = cc.GLFW_KEY_F19;
pub const F20 = cc.GLFW_KEY_F20;
pub const F21 = cc.GLFW_KEY_F21;
pub const F22 = cc.GLFW_KEY_F22;
pub const F23 = cc.GLFW_KEY_F23;
pub const F24 = cc.GLFW_KEY_F24;
pub const F25 = cc.GLFW_KEY_F25;
pub const kp_0 = cc.GLFW_KEY_KP_0;
pub const kp_1 = cc.GLFW_KEY_KP_1;
pub const kp_2 = cc.GLFW_KEY_KP_2;
pub const kp_3 = cc.GLFW_KEY_KP_3;
pub const kp_4 = cc.GLFW_KEY_KP_4;
pub const kp_5 = cc.GLFW_KEY_KP_5;
pub const kp_6 = cc.GLFW_KEY_KP_6;
pub const kp_7 = cc.GLFW_KEY_KP_7;
pub const kp_8 = cc.GLFW_KEY_KP_8;
pub const kp_9 = cc.GLFW_KEY_KP_9;
pub const kp_decimal = cc.GLFW_KEY_KP_DECIMAL;
pub const kp_divide = cc.GLFW_KEY_KP_DIVIDE;
pub const kp_multiply = cc.GLFW_KEY_KP_MULTIPLY;
pub const kp_subtract = cc.GLFW_KEY_KP_SUBTRACT;
pub const kp_add = cc.GLFW_KEY_KP_ADD;
pub const kp_enter = cc.GLFW_KEY_KP_ENTER;
pub const kp_equal = cc.GLFW_KEY_KP_EQUAL;
pub const left_shift = cc.GLFW_KEY_LEFT_SHIFT;
pub const left_control = cc.GLFW_KEY_LEFT_CONTROL;
pub const left_alt = cc.GLFW_KEY_LEFT_ALT;
pub const left_super = cc.GLFW_KEY_LEFT_SUPER;
pub const right_shift = cc.GLFW_KEY_RIGHT_SHIFT;
pub const right_control = cc.GLFW_KEY_RIGHT_CONTROL;
pub const right_alt = cc.GLFW_KEY_RIGHT_ALT;
pub const right_super = cc.GLFW_KEY_RIGHT_SUPER;
pub const menu = cc.GLFW_KEY_MENU;
pub const last = cc.GLFW_KEY_LAST; | glfw/src/key.zig |
const std = @import("std");
const Rational = std.math.big.Rational;
const Allocator = std.mem.Allocator;
const Real = @import("Real.zig").Real;
const IntermediateRepresentation = @import("ir.zig");
// TODO: rhm will have approximate mode, which runs faster at the expense of using floats instead of Reals
// TODO: resolve() standard function for resolving equations (only on functions with no control flow)
// ex: function sinus(x) -> sin(x)
// resolve(sinus, "=") -- return a function that given an expected result b, returns a number a such that f(a) = b
// resolve(sinus, "=")(1) -- should be equal to π/2
const Value = union(enum) {
None: void,
// TODO: UInt32, Int32, etc. types to save on memory
// TODO: use rationals
Number: *Real,
// Number: Real
String: []const u8,
pub fn clone(self: *Value, allocator: Allocator) !Value {
switch (self.*) {
.Number => |object| {
return Value { .Number = try object.clone(allocator) };
},
.String => std.debug.todo("clone strings"),
.None => unreachable,
}
}
pub fn reference(self: *Value) void {
switch (self.*) {
.Number => |object| {
object.rc.reference();
},
else => {}
}
}
pub fn dereference(self: *Value) void {
switch (self.*) {
.Number => |object| {
object.rc.dereference();
},
else => {}
}
}
};
pub fn execute(allocator: Allocator, ir: []const IntermediateRepresentation.Instruction) !void {
var registers: [256]Value = [_]Value{ .None } ** 256;
// TODO: dynamically size locals array
var locals: [16]Value = [_]Value{ .None } ** 16;
for (ir) |instruction| {
std.log.scoped(.vm).debug("{}", .{ instruction });
switch (instruction) {
.LoadByte => |lb| {
const real = try Real.initFloat(allocator, @intToFloat(f32, lb.value));
// Dereference old value
const registerId = @enumToInt(lb.target);
registers[registerId].dereference();
registers[@enumToInt(lb.target)] = .{ .Number = real };
},
.LoadString => |ls| {
// Dereference old value
const registerId = @enumToInt(ls.target);
registers[registerId].dereference();
registers[@enumToInt(ls.target)] = .{ .String = ls.value };
},
.Add => |add| {
var result = try registers[@enumToInt(add.lhs)].Number.clone(allocator);
try result.add(allocator, registers[@enumToInt(add.rhs)].Number);
// Dereference old value
const registerId = @enumToInt(add.target);
registers[registerId].dereference();
registers[@enumToInt(add.target)] = .{ .Number = result };
},
.SetLocal => |set| {
std.log.scoped(.vm).debug("set local {d} to {d}", .{ set.local, registers[@enumToInt(set.source)] });
const localId = @enumToInt(set.local);
// If there was already a local there, de-reference it
locals[localId].dereference();
locals[localId] = try registers[@enumToInt(set.source)].clone(allocator);
},
.LoadLocal => |load| {
std.log.scoped(.vm).debug("load from local {d} to register {d} = {d}", .{ load.local, load.target, locals[@enumToInt(load.local)] });
// Dereference old value
const registerId = @enumToInt(load.target);
registers[registerId].dereference();
registers[registerId] = try locals[@enumToInt(load.local)].clone(allocator);
},
.LoadGlobal => |load| {
std.log.scoped(.vm).debug("load from global {s} to register {d}", .{ load.global, load.target });
if (std.mem.eql(u8, load.global, "pi")) {
// Dereference old value
const registerId = @enumToInt(load.target);
registers[registerId].dereference();
registers[@enumToInt(load.target)] = .{
.Number = try Real.pi(allocator)
};
} else {
@panic("TODO");
}
},
.CallFunction => |call| {
std.log.scoped(.vm).debug("call {s} with {d} arguments ", .{ call.name, call.args_num });
if (std.mem.eql(u8, call.name, "print")) {
var i: u8 = 0;
while (i < call.args_num) : (i += 1) {
const value = registers[@enumToInt(call.args_start) + i];
switch (value) {
.None => @panic("'None' value cannot be used by a program"),
.Number => std.log.info("{d}", .{ value.Number }),
.String => std.log.info("{s}", .{ value.String }),
}
}
} else {
std.log.err("no such function {s}", .{ call.name });
break;
}
},
.Move => |move| {
// Dereference old value
const registerId = @enumToInt(move.target);
registers[registerId].dereference();
registers[@enumToInt(move.target)] = try registers[@enumToInt(move.source)].clone(allocator);
}
}
}
for (locals) |*local, idx| {
if (local.* != .None) std.log.debug("deinit local {d}", .{ idx });
local.dereference();
}
for (registers) |*register, idx| {
if (register.* != .None) std.log.debug("deinit register {d}", .{ idx });
register.dereference();
}
} | src/vm.zig |
const std = @import("std");
const input = @import("input.zig");
pub fn run(allocator: std.mem.Allocator, stdout: anytype) anyerror!void {
{
var input_ = try input.readFile("inputs/day16");
defer input_.deinit();
const result = try part1(allocator, &input_);
try stdout.print("16a: {}\n", .{ result });
std.debug.assert(result == 852);
}
{
var input_ = try input.readFile("inputs/day16");
defer input_.deinit();
const result = try part2(allocator, &input_);
try stdout.print("16b: {}\n", .{ result });
std.debug.assert(result == 19348959966392);
}
}
fn part1(allocator: std.mem.Allocator, input_: anytype) !u64 {
var bits = try BitsIterator.init(input_);
var packet = try Packet.init(allocator, &bits);
defer packet.deinit();
var sum: u64 = 0;
walkPacket(&packet, &sum);
return sum;
}
fn part2(allocator: std.mem.Allocator, input_: anytype) !u64 {
var bits = try BitsIterator.init(input_);
var packet = try Packet.init(allocator, &bits);
defer packet.deinit();
return evalPacket(&packet);
}
const BitsIterator = struct {
line: []const u8,
pos: usize,
fn init(input_: anytype) !@This() {
const line = (try input_.next()) orelse return error.InvalidInput;
return BitsIterator { .line = line, .pos = 0 };
}
fn next(self: *@This()) !u1 {
const c = self.line[self.pos / 4];
const b = try std.fmt.parseInt(u4, &[_]u8 { c }, 16);
const result = if (b & (@as(u4, 0b1000) >> @intCast(u2, self.pos % 4)) == 0) @as(u1, 0) else @as(u1, 1);
self.pos += 1;
return result;
}
};
const Packet = struct {
version: u3,
body: PacketBody,
fn init(allocator: std.mem.Allocator, bits: *BitsIterator) error{InvalidCharacter, InvalidInput, OutOfMemory, Overflow}!@This() {
const version = try getNum(3, bits);
const type_id = try getNum(3, bits);
const body = body: {
switch (type_id) {
4 => {
var literal: u64 = 0;
while (true) {
const block = try getNum(5, bits);
literal = (literal << 4) | (block & 0b01111);
if (block & 0b10000 == 0) {
break;
}
}
break :body PacketBody {
.literal = literal,
};
},
else => {
var body = PacketBody {
.operator = Operator {
.type_id = type_id,
.sub_packets = std.ArrayList(Packet).init(allocator),
},
};
errdefer body.deinit();
const length_type_id = try bits.next();
switch (length_type_id) {
0 => {
const length = try getNum(15, bits);
const end = bits.pos + length;
while (bits.pos < end) {
const sub_packet = try Packet.init(allocator, bits);
try body.operator.sub_packets.append(sub_packet);
}
bits.pos = end;
},
1 => {
const num_sub_packets = try getNum(11, bits);
var sub_packet_i: usize = 0;
while (sub_packet_i < num_sub_packets) : (sub_packet_i += 1) {
const sub_packet = try Packet.init(allocator, bits);
try body.operator.sub_packets.append(sub_packet);
}
},
}
break :body body;
},
}
};
return Packet {
.version = version,
.body = body,
};
}
fn deinit(self: *@This()) void {
self.body.deinit();
}
};
const PacketBody = union(enum) {
literal: Literal,
operator: Operator,
fn deinit(self: *@This()) void {
switch (self.*) {
.literal => {},
.operator => |*operator| operator.deinit(),
}
}
};
const Literal = u64;
const Operator = struct {
type_id: u3,
sub_packets: std.ArrayList(Packet),
fn deinit(self: *@This()) void {
for (self.sub_packets.items) |*sub_packet| {
sub_packet.deinit();
}
self.sub_packets.deinit();
}
};
fn getNum(comptime bit_length: usize, bits: *BitsIterator) !std.meta.Int(.unsigned, bit_length) {
var result: std.meta.Int(.unsigned, bit_length) = 0;
var i: usize = 0;
while (i < bit_length) : (i += 1) {
result = (result << 1) | (try bits.next());
}
return result;
}
fn walkPacket(packet: *const Packet, sum: *u64) void {
sum.* += packet.version;
switch (packet.body) {
.literal => {},
.operator => |operator| {
for (operator.sub_packets.items) |*sub_packet| {
walkPacket(sub_packet, sum);
}
}
}
}
fn evalPacket(packet: *const Packet) error{InvalidInput}!u64 {
switch (packet.body) {
.literal => |literal| return literal,
.operator => |operator| {
switch (operator.type_id) {
0 => {
var result: u64 = 0;
for (operator.sub_packets.items) |*sub_packet| {
result += try evalPacket(sub_packet);
}
return result;
},
1 => {
var result: u64 = 1;
for (operator.sub_packets.items) |*sub_packet| {
result *= try evalPacket(sub_packet);
}
return result;
},
2 => {
var result: u64 = std.math.maxInt(u64);
for (operator.sub_packets.items) |*sub_packet| {
result = std.math.min(result, try evalPacket(sub_packet));
}
return result;
},
3 => {
var result: u64 = std.math.minInt(u64);
for (operator.sub_packets.items) |*sub_packet| {
result = std.math.max(result, try evalPacket(sub_packet));
}
return result;
},
5 => {
if (operator.sub_packets.items.len != 2) {
return error.InvalidInput;
}
const left_packet = &operator.sub_packets.items[0];
const right_packet = &operator.sub_packets.items[1];
if ((try evalPacket(left_packet)) > (try evalPacket(right_packet))) {
return 1;
}
return 0;
},
6 => {
if (operator.sub_packets.items.len != 2) {
return error.InvalidInput;
}
const left_packet = &operator.sub_packets.items[0];
const right_packet = &operator.sub_packets.items[1];
if ((try evalPacket(left_packet)) < (try evalPacket(right_packet))) {
return 1;
}
return 0;
},
7 => {
if (operator.sub_packets.items.len != 2) {
return error.InvalidInput;
}
const left_packet = &operator.sub_packets.items[0];
const right_packet = &operator.sub_packets.items[1];
if ((try evalPacket(left_packet)) == (try evalPacket(right_packet))) {
return 1;
}
return 0;
},
else => return error.InvalidInput,
}
}
}
}
test "day 16 example 1" {
const input_ =
\\D2FE28
;
var input__ = input.readString(input_);
var bits = try BitsIterator.init(&input__);
var packet = try Packet.init(std.testing.allocator, &bits);
defer packet.deinit();
try std.testing.expectEqual(@as(u3, 6), packet.version);
switch (packet.body) {
.literal => |literal| try std.testing.expectEqual(@as(u64, 2021), literal),
else => try std.testing.expect(false),
}
}
test "day 16 example 2" {
const input_ =
\\38006F45291200
;
var input__ = input.readString(input_);
var bits = try BitsIterator.init(&input__);
var packet = try Packet.init(std.testing.allocator, &bits);
defer packet.deinit();
try std.testing.expectEqual(@as(u3, 1), packet.version);
switch (packet.body) {
.operator => |operator| {
try std.testing.expectEqual(@as(u3, 6), operator.type_id);
try std.testing.expectEqual(@as(usize, 2), operator.sub_packets.items.len);
const sub_packet0 = &operator.sub_packets.items[0];
switch (sub_packet0.body) {
.literal => |literal| try std.testing.expectEqual(@as(u64, 10), literal),
else => try std.testing.expect(false),
}
const sub_packet1 = &operator.sub_packets.items[1];
switch (sub_packet1.body) {
.literal => |literal| try std.testing.expectEqual(@as(u64, 20), literal),
else => try std.testing.expect(false),
}
},
else => try std.testing.expect(false),
}
}
test "day 16 example 3" {
const input_ =
\\EE00D40C823060
;
var input__ = input.readString(input_);
var bits = try BitsIterator.init(&input__);
var packet = try Packet.init(std.testing.allocator, &bits);
defer packet.deinit();
try std.testing.expectEqual(@as(u3, 7), packet.version);
switch (packet.body) {
.operator => |operator| {
try std.testing.expectEqual(@as(u3, 3), operator.type_id);
try std.testing.expectEqual(@as(usize, 3), operator.sub_packets.items.len);
const sub_packet0 = &operator.sub_packets.items[0];
switch (sub_packet0.body) {
.literal => |literal| try std.testing.expectEqual(@as(u64, 1), literal),
else => try std.testing.expect(false),
}
const sub_packet1 = &operator.sub_packets.items[1];
switch (sub_packet1.body) {
.literal => |literal| try std.testing.expectEqual(@as(u64, 2), literal),
else => try std.testing.expect(false),
}
const sub_packet2 = &operator.sub_packets.items[2];
switch (sub_packet2.body) {
.literal => |literal| try std.testing.expectEqual(@as(u64, 3), literal),
else => try std.testing.expect(false),
}
},
else => try std.testing.expect(false),
}
}
test "day 16 example 4" {
const input_ =
\\8A004A801A8002F478
;
{
var input__ = input.readString(input_);
var bits = try BitsIterator.init(&input__);
var packet = try Packet.init(std.testing.allocator, &bits);
defer packet.deinit();
try std.testing.expectEqual(@as(u3, 4), packet.version);
switch (packet.body) {
.operator => |operator| {
try std.testing.expectEqual(@as(usize, 1), operator.sub_packets.items.len);
const sub_packet0 = &operator.sub_packets.items[0];
try std.testing.expectEqual(@as(u3, 1), sub_packet0.version);
switch (sub_packet0.body) {
.operator => |sub_operator| {
try std.testing.expectEqual(@as(usize, 1), sub_operator.sub_packets.items.len);
const sub_sub_packet0 = &sub_operator.sub_packets.items[0];
try std.testing.expectEqual(@as(u3, 5), sub_sub_packet0.version);
switch (sub_sub_packet0.body) {
.operator => |sub_sub_operator| {
try std.testing.expectEqual(@as(usize, 1), sub_sub_operator.sub_packets.items.len);
const sub_sub_sub_packet0 = &sub_sub_operator.sub_packets.items[0];
try std.testing.expectEqual(@as(u3, 6), sub_sub_sub_packet0.version);
switch (sub_sub_sub_packet0.body) {
.literal => {},
else => try std.testing.expect(false),
}
},
else => try std.testing.expect(false),
}
},
else => try std.testing.expect(false),
}
},
else => try std.testing.expect(false),
}
}
try std.testing.expectEqual(@as(u64, 16), try part1(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 5" {
const input_ =
\\620080001611562C8802118E34
;
{
var input__ = input.readString(input_);
var bits = try BitsIterator.init(&input__);
var packet = try Packet.init(std.testing.allocator, &bits);
defer packet.deinit();
try std.testing.expectEqual(@as(u3, 3), packet.version);
switch (packet.body) {
.operator => |operator| {
try std.testing.expectEqual(@as(usize, 2), operator.sub_packets.items.len);
for (operator.sub_packets.items) |sub_packet| {
switch (sub_packet.body) {
.operator => |sub_operator| {
try std.testing.expectEqual(@as(usize, 2), sub_operator.sub_packets.items.len);
for (sub_operator.sub_packets.items) |sub_sub_packet| {
switch (sub_sub_packet.body) {
.literal => {},
else => try std.testing.expect(false),
}
}
},
else => try std.testing.expect(false),
}
}
},
else => try std.testing.expect(false),
}
}
try std.testing.expectEqual(@as(u64, 12), try part1(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 6" {
const input_ =
\\C0015000016115A2E0802F182340
;
{
var input__ = input.readString(input_);
var bits = try BitsIterator.init(&input__);
var packet = try Packet.init(std.testing.allocator, &bits);
defer packet.deinit();
switch (packet.body) {
.operator => |operator| {
try std.testing.expectEqual(@as(usize, 2), operator.sub_packets.items.len);
for (operator.sub_packets.items) |sub_packet| {
switch (sub_packet.body) {
.operator => |sub_operator| {
try std.testing.expectEqual(@as(usize, 2), sub_operator.sub_packets.items.len);
for (sub_operator.sub_packets.items) |sub_sub_packet| {
switch (sub_sub_packet.body) {
.literal => {},
else => try std.testing.expect(false),
}
}
},
else => try std.testing.expect(false),
}
}
},
else => try std.testing.expect(false),
}
}
try std.testing.expectEqual(@as(u64, 23), try part1(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 7" {
const input_ =
\\A0016C880162017C3686B18A3D4780
;
{
var input__ = input.readString(input_);
var bits = try BitsIterator.init(&input__);
var packet = try Packet.init(std.testing.allocator, &bits);
defer packet.deinit();
switch (packet.body) {
.operator => |operator| {
try std.testing.expectEqual(@as(usize, 1), operator.sub_packets.items.len);
for (operator.sub_packets.items) |sub_packet| {
switch (sub_packet.body) {
.operator => |sub_operator| {
try std.testing.expectEqual(@as(usize, 1), sub_operator.sub_packets.items.len);
for (sub_operator.sub_packets.items) |sub_sub_packet| {
switch (sub_sub_packet.body) {
.operator => |sub_sub_operator| {
try std.testing.expectEqual(@as(usize, 5), sub_sub_operator.sub_packets.items.len);
for (sub_sub_operator.sub_packets.items) |sub_sub_sub_packet| {
switch (sub_sub_sub_packet.body) {
.literal => {},
else => try std.testing.expect(false),
}
}
},
else => try std.testing.expect(false),
}
}
},
else => try std.testing.expect(false),
}
}
},
else => try std.testing.expect(false),
}
}
try std.testing.expectEqual(@as(u64, 31), try part1(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 8" {
const input_ =
\\C200B40A82
;
try std.testing.expectEqual(@as(u64, 1 + 2), try part2(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 9" {
const input_ =
\\04005AC33890
;
try std.testing.expectEqual(@as(u64, 6 * 9), try part2(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 10" {
const input_ =
\\880086C3E88112
;
try std.testing.expectEqual(@as(u64, std.math.min3(7, 8, 9)), try part2(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 11" {
const input_ =
\\CE00C43D881120
;
try std.testing.expectEqual(@as(u64, std.math.max3(7, 8, 9)), try part2(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 12" {
const input_ =
\\D8005AC2A8F0
;
try std.testing.expectEqual(@as(u64, if (5 < 15) 1 else 0), try part2(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 13" {
const input_ =
\\F600BC2D8F
;
try std.testing.expectEqual(@as(u64, if (5 > 15) 1 else 0), try part2(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 14" {
const input_ =
\\9C005AC2F8F0
;
try std.testing.expectEqual(@as(u64, if (5 == 15) 1 else 0), try part2(std.testing.allocator, &input.readString(input_)));
}
test "day 16 example 15" {
const input_ =
\\9C0141080250320F1802104A08
;
try std.testing.expectEqual(@as(u64, if (1 + 3 == 2 * 2) 1 else 0), try part2(std.testing.allocator, &input.readString(input_)));
} | src/day16.zig |
const std = @import("std");
const math = std.math;
const Allocator = std.mem.Allocator;
const PixelFormat = @import("pixel_format.zig").PixelFormat;
const TypeInfo = std.builtin.TypeInfo;
inline fn toColorInt(comptime T: type, value: f32) T {
return math.max(math.minInt(T), math.min(math.maxInt(T), @floatToInt(T, math.round(value * @intToFloat(f32, math.maxInt(T))))));
}
inline fn toColorFloat(value: var, comptime maxValue: f32) f32 {
return @intToFloat(f32, value) / maxValue;
}
pub const Color = struct {
R: u8,
G: u8,
B: u8,
A: u8,
const Self = @This();
pub fn initRGB(r: u8, g: u8, b: u8) Self {
return Self{
.R = r,
.G = g,
.B = b,
.A = 0xFF,
};
}
pub fn initRGBA(r: u8, g: u8, b: u8, a: u8) Self {
return Self{
.R = r,
.G = g,
.B = b,
.A = a,
};
}
pub fn premultipliedAlpha(self: Self) Self {
var floatR: f32 = toColorFloat(self.R, 255.0);
var floatG: f32 = toColorFloat(self.G, 255.0);
var floatB: f32 = toColorFloat(self.B, 255.0);
var floatA: f32 = toColorFloat(self.A, 255.0);
return Self{
.R = toColorInt(u8, floatR * floatA),
.G = toColorInt(u8, floatG * floatA),
.B = toColorInt(u8, floatB * floatA),
.A = self.A,
};
}
};
fn RgbColor(comptime red_bits: comptime_int, comptime green_bits: comptime_int, comptime blue_bits: comptime_int) type {
return packed struct {
B: BlueType,
G: GreenType,
R: RedType,
const RedType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = red_bits } });
const GreenType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = green_bits } });
const BlueType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = blue_bits } });
const MaxRed = @intToFloat(f32, (1 << red_bits) - 1);
const MaxGreen = @intToFloat(f32, (1 << green_bits) - 1);
const MaxBlue = @intToFloat(f32, (1 << blue_bits) - 1);
const Self = @This();
pub fn initRGB(r: RedType, g: GreenType, b: BlueType) Self {
return Self{
.R = r,
.G = g,
.B = b,
};
}
pub fn toColor(self: Self) Color {
return Color{
.R = toColorInt(u8, toColorFloat(self.R, MaxRed)),
.G = toColorInt(u8, toColorFloat(self.G, MaxGreen)),
.B = toColorInt(u8, toColorFloat(self.B, MaxBlue)),
.A = 0xFF,
};
}
};
}
fn ARgbColor(comptime red_bits: comptime_int, comptime green_bits: comptime_int, comptime blue_bits: comptime_int, comptime alpha_bits: comptime_int) type {
return packed struct {
B: BlueType,
G: GreenType,
R: RedType,
A: AlphaType,
const RedType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = red_bits } });
const GreenType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = green_bits } });
const BlueType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = blue_bits } });
const AlphaType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = alpha_bits } });
const MaxRed = @intToFloat(f32, (1 << red_bits) - 1);
const MaxGreen = @intToFloat(f32, (1 << green_bits) - 1);
const MaxBlue = @intToFloat(f32, (1 << blue_bits) - 1);
const MaxAlpha = @intToFloat(f32, (1 << alpha_bits) - 1);
const Self = @This();
pub fn initRGB(r: RedType, g: GreenType, b: BlueType) Self {
return Self{
.R = r,
.G = g,
.B = b,
.A = @floatToInt(AlphaType, MaxAlpha),
};
}
pub fn initRGBA(r: RedType, g: GreenType, b: BlueType, a: AlphaType) Self {
return Self{
.R = r,
.G = g,
.B = b,
.A = a,
};
}
pub fn toColor(self: Self) Color {
return Color{
.R = toColorInt(u8, toColorFloat(self.R, MaxRed)),
.G = toColorInt(u8, toColorFloat(self.G, MaxGreen)),
.B = toColorInt(u8, toColorFloat(self.B, MaxBlue)),
.A = toColorInt(u8, toColorFloat(self.A, MaxAlpha)),
};
}
};
}
fn RgbaColor(comptime red_bits: comptime_int, comptime green_bits: comptime_int, comptime blue_bits: comptime_int, comptime alpha_bits: comptime_int) type {
return packed struct {
A: AlphaType,
B: BlueType,
G: GreenType,
R: RedType,
const RedType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = red_bits } });
const GreenType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = green_bits } });
const BlueType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = blue_bits } });
const AlphaType = @Type(TypeInfo{ .Int = TypeInfo.Int{ .is_signed = false, .bits = alpha_bits } });
const MaxRed = @intToFloat(f32, (1 << red_bits) - 1);
const MaxGreen = @intToFloat(f32, (1 << green_bits) - 1);
const MaxBlue = @intToFloat(f32, (1 << blue_bits) - 1);
const MaxAlpha = @intToFloat(f32, (1 << alpha_bits) - 1);
const Self = @This();
pub fn initRGB(r: RedType, g: GreenType, b: BlueType) Self {
return Self{
.R = r,
.G = g,
.B = b,
.A = @floatToInt(AlphaType, MaxAlpha),
};
}
pub fn initRGBA(r: RedType, g: GreenType, b: BlueType, a: AlphaType) Self {
return Self{
.R = r,
.G = g,
.B = b,
.A = a,
};
}
pub fn toColor(self: Self) Color {
return Color{
.R = toColorInt(u8, toColorFloat(self.R, MaxRed)),
.G = toColorInt(u8, toColorFloat(self.G, MaxGreen)),
.B = toColorInt(u8, toColorFloat(self.B, MaxBlue)),
.A = toColorInt(u8, toColorFloat(self.A, MaxAlpha)),
};
}
};
}
pub const Rgb24 = RgbColor(8, 8, 8);
pub const Rgba32 = RgbaColor(8, 8, 8, 8);
pub const Rgb565 = RgbColor(5, 6, 5);
pub const Rgb555 = RgbColor(5, 5, 5);
pub const Argb32 = ARgbColor(8, 8, 8, 8);
fn IndexedStorage(comptime T: type) type {
return struct {
palette: [PaletteSize]Color = undefined,
indices: []T,
pub const PaletteSize = 1 << @bitSizeOf(T);
const Self = @This();
pub fn init(allocator: *Allocator, pixel_count: usize) !Self {
return Self{
.indices = try allocator.alloc(T, pixel_count),
};
}
pub fn deinit(self: Self, allocator: *Allocator) void {
allocator.free(self.indices);
}
};
}
pub const ColorStorage = union(PixelFormat) {
Bpp1: IndexedStorage(u1),
Bpp2: IndexedStorage(u2),
Bpp4: IndexedStorage(u4),
Bpp8: IndexedStorage(u8),
Bpp16: IndexedStorage(u16),
Rgb24: []Rgb24,
Rgba32: []Rgba32,
Rgb565: []Rgb565,
Rgb555: []Rgb555,
Argb32: []Argb32,
const Self = @This();
pub fn init(allocator: *Allocator, format: PixelFormat, pixel_count: usize) !Self {
return switch (format) {
.Bpp1 => {
return Self{
.Bpp1 = try IndexedStorage(u1).init(allocator, pixel_count),
};
},
.Bpp2 => {
return Self{
.Bpp2 = try IndexedStorage(u2).init(allocator, pixel_count),
};
},
.Bpp4 => {
return Self{
.Bpp4 = try IndexedStorage(u4).init(allocator, pixel_count),
};
},
.Bpp8 => {
return Self{
.Bpp8 = try IndexedStorage(u8).init(allocator, pixel_count),
};
},
.Bpp16 => {
return Self{
.Bpp16 = try IndexedStorage(u16).init(allocator, pixel_count),
};
},
.Rgb24 => {
return Self{
.Rgb24 = try allocator.alloc(Rgb24, pixel_count),
};
},
.Rgba32 => {
return Self{
.Rgba32 = try allocator.alloc(Rgba32, pixel_count),
};
},
.Rgb565 => {
return Self{
.Rgb565 = try allocator.alloc(Rgb565, pixel_count),
};
},
.Rgb555 => {
return Self{
.Rgb555 = try allocator.alloc(Rgb555, pixel_count),
};
},
.Argb32 => {
return Self{
.Argb32 = try allocator.alloc(Argb32, pixel_count),
};
},
};
}
pub fn deinit(self: Self, allocator: *Allocator) void {
switch (self) {
.Bpp1 => |data| data.deinit(allocator),
.Bpp2 => |data| data.deinit(allocator),
.Bpp4 => |data| data.deinit(allocator),
.Bpp8 => |data| data.deinit(allocator),
.Bpp16 => |data| data.deinit(allocator),
.Rgb24 => |data| allocator.free(data),
.Rgba32 => |data| allocator.free(data),
.Rgb565 => |data| allocator.free(data),
.Rgb555 => |data| allocator.free(data),
.Argb32 => |data| allocator.free(data),
}
}
pub fn len(self: Self) usize {
return switch (self) {
.Bpp1 => |data| data.indices.len,
.Bpp2 => |data| data.indices.len,
.Bpp4 => |data| data.indices.len,
.Bpp8 => |data| data.indices.len,
.Bpp16 => |data| data.indices.len,
.Rgb24 => |data| data.len,
.Rgba32 => |data| data.len,
.Rgb565 => |data| data.len,
.Rgb555 => |data| data.len,
.Argb32 => |data| data.len,
};
}
}; | src/color.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = false;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const assert = std.debug.assert;
pub const main = tools.defaultMain("2021/day10.txt", run);
pub fn run(input: []const u8, gpa: std.mem.Allocator) tools.RunError![2][]const u8 {
const ans12 = ans: {
var score_syntax: u64 = 0;
var scores_complete: [100]u64 = undefined;
var scores_complete_len: usize = 0;
var it = std.mem.tokenize(u8, input, "\n");
var stack: [128]u8 = undefined;
stack[0] = 'X'; // canary
var sp: u32 = 0;
while (it.next()) |line| {
sp = 0;
const wrong_char = err: for (line) |c| {
switch (c) {
// push fermeture attendue
'(', '[', '{', '<' => {
sp += 1;
stack[sp] = switch (c) {
'(' => ')',
'[' => ']',
'{' => '}',
'<' => '>',
else => unreachable,
};
},
// pop + check fermeture
')', ']', '}', '>' => {
const expected = stack[sp];
assert(expected != 'X'); // manifestement, jamais de stack underflow? triste.
sp -= 1;
if (expected != c) break :err c;
},
else => continue,
}
} else null;
if (wrong_char) |c| {
score_syntax += switch (c) {
')' => @as(u32, 3),
']' => @as(u32, 57),
'}' => @as(u32, 1197),
'>' => @as(u32, 25137),
else => unreachable,
};
trace("syntax error '{s}', found error: '{c}'. {} points\n", .{ line, wrong_char, score_syntax });
} else {
var pts: u64 = 0;
while (sp > 0) : (sp -= 1) {
pts = pts * 5 +
switch (stack[sp]) {
')' => @as(u32, 1),
']' => @as(u32, 2),
'}' => @as(u32, 3),
'>' => @as(u32, 4),
else => unreachable,
};
}
scores_complete[scores_complete_len] = pts;
scores_complete_len += 1;
trace("autocomplete '{s}': {} points\n", .{ line, pts });
}
}
std.sort.sort(u64, scores_complete[0..scores_complete_len], {}, comptime std.sort.asc(u64));
break :ans [2]u64{ score_syntax, scores_complete[scores_complete_len / 2] };
};
return [_][]const u8{
try std.fmt.allocPrint(gpa, "{}", .{ans12[0]}),
try std.fmt.allocPrint(gpa, "{}", .{ans12[1]}),
};
}
test {
const res = try run(
\\[({(<(())[]>[[{[]{<()<>>
\\[(()[<>])]({[<{<<[]>>(
\\{([(<{}[<>[]}>{[]{[(<()>
\\(((({<>}<{<{<>}{[]{[]{}
\\[[<[([]))<([[{}[[()]]]
\\[{[{({}]{}}([{[{{{}}([]
\\{<[[]]>}<{[{[{[]{()[[[]
\\[<(<(<(<{}))><([]([]()
\\<{([([[(<>()){}]>(<<{{
\\<{([{{}}[<[[[<>{}]]]>[]]
, std.testing.allocator);
defer std.testing.allocator.free(res[0]);
defer std.testing.allocator.free(res[1]);
try std.testing.expectEqualStrings("26397", res[0]);
try std.testing.expectEqualStrings("288957", res[1]);
} | 2021/day10.zig |
const std = @import("std");
const nvg = @import("nvg.zig");
const gfx = @import("gfx.zig");
const Game = @This();
const GameState = enum(u1) {
title,
play,
};
const BuildingColor = enum(u2) {
grey,
teal,
red,
};
const Building = struct {
const Hole = struct {
x: f32,
y: f32,
r: f32,
};
x: f32,
y: f32,
w: f32,
h: f32,
color: BuildingColor,
holes: std.ArrayList(Hole),
fn init(allocator: *std.mem.Allocator, x: f32, y: f32, w: f32, h: f32, color: BuildingColor) !*Building {
var self = try allocator.create(Building);
self.* = Building{
.x = x,
.y = y,
.w = w,
.h = h,
.color = color,
.holes = std.ArrayList(Hole).init(allocator),
};
return self;
}
fn deinit(self: Building) void {
self.holes.deinit();
}
fn addHole(self: *Building, x: f32, y: f32, r: f32) void {
self.holes.append(Hole{ .x = x, .y = y, .r = r }) catch unreachable;
}
fn hit(self: *Building, x: f32, y: f32, r: f32) bool {
const wh = 0.5 * self.w;
const hh = 0.5 * self.h;
var dist = sdRect(x - (self.x + wh), y - (self.y + hh), wh, hh);
if (dist < r) {
for (self.holes.items) |hole| {
const holeDist = sdCircle(x - hole.x, y - hole.y, hole.r);
dist = sdSubtraction(dist, holeDist);
}
if (dist < r) {
self.addHole(x, y, 48);
return true;
}
}
return false;
}
fn draw(self: Building) void {
nvg.scissor(self.x, self.y, self.w, self.h);
defer nvg.resetScissor();
nvg.beginPath();
nvg.rect(self.x + 4, self.y + 4, self.w - 8, self.h);
nvg.strokeWidth(10);
nvg.stroke();
nvg.fillColor(switch (self.color) {
.grey => nvg.rgb(168, 168, 168),
.teal => nvg.rgb(96, 200, 136),
.red => nvg.rgb(168, 0, 0),
});
nvg.fill();
// windows
const seed = @floatToInt(u64, self.x); // stable
var pcg = std.rand.Pcg.init(seed);
nvg.beginPath();
var wy = self.y;
while (wy < self.y + self.h) : (wy += 40) {
var wx = self.x + 0.5 * @rem(self.w, 30);
while (wx + 15 < self.x + self.w) : (wx += 30) {
const on = pcg.random.uintLessThan(u8, 100) < 70;
if (on) nvg.rect(wx + 10, wy + 18, 12, 20);
}
}
nvg.fillColor(nvg.rgb(255, 255, 0));
nvg.fill();
pcg = std.rand.Pcg.init(seed);
nvg.beginPath();
wy = self.y;
while (wy < self.y + self.h) : (wy += 40) {
var wx = self.x + 0.5 * @rem(self.w, 30);
while (wx + 15 < self.x + self.w) : (wx += 30) {
const on = pcg.random.uintLessThan(u8, 100) < 70;
if (!on) nvg.rect(wx + 10, wy + 18, 12, 20);
}
}
nvg.fillColor(nvg.rgb(80, 80, 80));
nvg.fill();
// holes
nvg.beginPath();
for (self.holes.items) |hole| {
nvg.circle(hole.x, hole.y, hole.r - 4);
}
nvg.stroke();
nvg.scissor(self.x - 1, self.y - 1, self.w + 2, self.h + 2); // HACK
nvg.fillColor(nvg.rgbf(0.3, 0.5, 0.8)); // background color
nvg.fill();
}
};
const TextEntry = enum(u2) {
player1_name,
player2_name,
angle,
velocity,
};
const world_width: f32 = 1920;
const world_height: f32 = 1080;
const player_r: f32 = 48;
const banana_r: f32 = 16 - 4;
const wind_max: f32 = 0.002;
allocator: *std.mem.Allocator,
width: f32 = 1280,
height: f32 = 720,
state: GameState = .title,
player_turn: u2 = 1,
player_win: u2 = 0,
player1_name: std.ArrayList(u8),
player1_x: f32 = undefined,
player1_y: f32 = undefined,
player1_arm: u8 = 0,
player2_name: std.ArrayList(u8),
player2_x: f32 = undefined,
player2_y: f32 = undefined,
player2_arm: u8 = 0,
banana_x: f32 = undefined,
banana_y: f32 = undefined,
banana_vx: f32 = undefined,
banana_vy: f32 = undefined,
banana_flying: bool = false,
explosion_x: f32 = undefined,
explosion_y: f32 = undefined,
explosion_r: f32 = undefined,
explosion_frames: u32 = 0,
wind: f32 = 0,
text_entry: TextEntry = .player1_name,
text_buffer: std.ArrayList(u8),
angle: u32 = 45,
velocity: u32 = 50,
buildings: std.ArrayList(*Building),
screenshake_amplitude: f32 = 0,
screenshake_frequency: f32 = 0,
frame: usize = 0,
rng: std.rand.Pcg = undefined,
pub fn init(allocator: *std.mem.Allocator) !Game {
var self = Game{
.allocator = allocator,
.player1_name = std.ArrayList(u8).init(allocator),
.player2_name = std.ArrayList(u8).init(allocator),
.text_buffer = std.ArrayList(u8).init(allocator),
.buildings = std.ArrayList(*Building).init(allocator),
};
try self.player1_name.appendSlice("Player 1");
try self.player2_name.appendSlice("Player 2");
const seed: u64 = @intCast(u64, std.time.milliTimestamp());
self.rng = std.rand.Pcg.init(seed);
try self.reset();
return self;
}
pub fn deinit(self: *Game) void {
self.player1_name.deinit();
self.player2_name.deinit();
self.text_buffer.deinit();
self.clearBuildings();
self.buildings.deinit();
}
fn reset(self: *Game) !void {
self.state = .title;
self.text_entry = .player1_name;
self.player_win = 0;
self.player_turn = 1;
self.frame = 0;
try self.generateBuildings(12);
self.randomizeWind();
}
pub fn setSize(self: *Game, width: f32, height: f32) void {
self.width = width;
self.height = height;
}
pub fn onTextInput(self: *Game, text: []const u8) !void {
switch (self.text_entry) {
.player1_name => if (self.player1_name.items.len + text.len < 16) try self.player1_name.appendSlice(text),
.player2_name => if (self.player2_name.items.len + text.len < 16) try self.player2_name.appendSlice(text),
else => {
if (self.banana_flying or self.player_win != 0) return;
if (self.text_buffer.items.len >= 3) return;
const c = text[0];
if (c >= '0' and c <= '9') {
try self.text_buffer.append(c);
}
},
}
}
pub fn onKeyBackspace(self: *Game) void {
switch (self.text_entry) {
.player1_name => {if (self.player1_name.items.len > 0) self.player1_name.items.len -= 1;},
.player2_name => {if (self.player2_name.items.len > 0) self.player2_name.items.len -= 1;},
else => {if (self.text_buffer.items.len > 0) self.text_buffer.items.len -= 1;},
}
}
pub fn onKeyReturn(self: *Game) void {
switch (self.state) {
.title => {
switch (self.text_entry) {
.player1_name => {
if (self.player1_name.items.len > 0) self.text_entry = .player2_name;
},
.player2_name => {
if (self.player1_name.items.len > 0) {
self.state = .play;
self.text_entry = .angle;
}
},
else => unreachable,
}
},
.play => {
if (self.banana_flying) return;
if (self.player_win != 0) {
self.reset() catch unreachable;
} else {
if (self.text_entry == .angle) {
if (self.text_buffer.items.len == 0) return;
self.angle = std.fmt.parseInt(u32, self.text_buffer.items, 10) catch unreachable;
self.text_buffer.items.len = 0;
self.text_entry = .velocity;
} else if (self.text_entry == .velocity) {
if (self.text_buffer.items.len == 0) return;
self.velocity = std.fmt.parseInt(u32, self.text_buffer.items, 10) catch unreachable;
self.text_buffer.items.len = 0;
self.text_entry = .angle;
self.launchBanana(self.player_turn, @intToFloat(f32, self.angle), @intToFloat(f32, self.velocity));
}
}
},
}
}
fn clearBuildings(self: *Game) void {
for (self.buildings.items) |building| {
building.deinit();
self.allocator.destroy(building);
}
self.buildings.items.len = 0;
}
fn generateBuildings(self: *Game, n: usize) !void {
self.clearBuildings();
try self.buildings.ensureCapacity(n);
var total_width: f32 = 0;
const spacing: f32 = 12;
var i: usize = 0;
while (i < n) : (i += 1) {
const color = @intToEnum(BuildingColor, self.rng.random.uintLessThan(u2, @typeInfo(BuildingColor).Enum.fields.len));
const width = @intToFloat(f32, self.rng.random.intRangeAtMost(i32, 120, 250));
const height = @intToFloat(f32, self.rng.random.intRangeAtMost(i32, 200, 750));
self.buildings.appendAssumeCapacity(try Building.init(self.allocator, total_width, world_height - height, width, height, color));
total_width += width;
}
const s = (world_width - @intToFloat(f32, n - 1) * spacing) / total_width;
var x: f32 = 0;
for (self.buildings.items) |building| {
building.x = x;
building.w *= s;
x += building.w + spacing;
}
const building1 = self.buildings.items[1];
const building2 = self.buildings.items[n - 2];
self.player1_x = building1.x + 0.5 * building1.w;
self.player1_y = building1.y;
self.player2_x = building2.x + 0.5 * building2.w;
self.player2_y = building2.y;
}
fn randomizeWind(self: *Game) void {
self.wind = wind_max * (self.rng.random.float(f32) * 2 - 1);
}
fn launchBanana(self: *Game, player: u2, angle: f32, velocity: f32) void {
const rad = angle * std.math.pi / 180;
const power = std.math.clamp(velocity, 1, 100) / 20;
if (player == 1) {
self.player1_arm = 20;
self.banana_x = self.player1_x + 10 - player_r;
self.banana_y = self.player1_y - 10 - 2 * player_r;
self.banana_vx = @cos(rad) * power;
self.banana_vy = -@sin(rad) * power;
} else if (player == 2) {
self.player2_arm = 20;
self.banana_x = self.player2_x - 10 + player_r;
self.banana_y = self.player2_y - 10 - 2 * player_r;
self.banana_vx = -@cos(rad) * power;
self.banana_vy = -@sin(rad) * power;
}
self.banana_flying = true;
}
fn checkBuildingCollision(self: *Game, x: f32, y: f32, r: f32) bool {
for (self.buildings.items) |building| {
if (building.hit(x, y, r)) {
return true;
}
}
return false;
}
fn explode(self: *Game, x: f32, y: f32, r: f32) void {
self.explosion_x = x;
self.explosion_y = y;
self.explosion_r = r;
self.explosion_frames = 30;
}
pub fn tick(self: *Game) void {
if (self.banana_flying) {
self.banana_x += self.banana_vx;
self.banana_y += self.banana_vy;
self.banana_vx += self.wind;
self.banana_vy += 0.004; // gravity
const oob = self.banana_x < -banana_r or self.banana_x > world_width + banana_r;
if (oob or self.checkBuildingCollision(self.banana_x, self.banana_y, banana_r)) {
self.explode(self.banana_x, self.banana_y, 48);
self.banana_flying = false;
self.randomizeWind();
self.player_turn = 3 - self.player_turn;
} else { // check player collision
if (self.player_turn == 1) {
const d_x = self.player2_x - self.banana_x;
const d_y = self.player2_y - player_r - self.banana_y;
if (d_x * d_x + d_y * d_y < player_r * player_r) {
self.explode(self.player2_x, self.player2_y - player_r, 3 * player_r);
for (self.buildings.items) |building| building.addHole(self.explosion_x, self.explosion_y, self.explosion_r);
self.banana_flying = false;
self.player_win = self.player_turn;
}
} else if (self.player_turn == 2) {
const d_x = self.player1_x - self.banana_x;
const d_y = self.player1_y - player_r - self.banana_y;
if (d_x * d_x + d_y * d_y < player_r * player_r) {
self.explode(self.player1_x, self.player1_y - player_r, 3 * player_r);
for (self.buildings.items) |building| building.addHole(self.explosion_x, self.explosion_y, self.explosion_r);
self.banana_flying = false;
self.player_win = self.player_turn;
}
}
}
}
if (self.player1_arm > 0) self.player1_arm -= 1;
if (self.player2_arm > 0) self.player2_arm -= 1;
if (self.explosion_frames > 0) self.explosion_frames -= 1;
self.screenshake_frequency = 0.8;
self.screenshake_amplitude = @intToFloat(f32, self.explosion_frames);
self.frame += 1;
}
fn drawParametersEntry(self: Game) void {
nvg.save();
defer nvg.restore();
if (self.player_turn == 2) nvg.translate(self.width - 330, 0);
const cursor_blink = self.frame % 60 < 30;
var buf: [20]u8 = undefined;
var x = nvg.text(10, 80, "Angle:");
if (self.text_entry == .angle) {
if (self.text_buffer.items.len > 0) x = nvg.text(x, 80, self.text_buffer.items);
if (cursor_blink) _ = nvg.text(x, 80, "_");
} else {
_ = nvg.text(x, 80, std.fmt.bufPrint(&buf, "{}", .{self.angle}) catch unreachable);
}
x = nvg.text(10, 110, "Velocity:");
if (self.text_entry == .velocity) {
if (self.text_buffer.items.len > 0) x = nvg.text(x, 110, self.text_buffer.items);
if (cursor_blink) _ = nvg.text(x, 110, "_");
}
}
fn drawTitle(self: Game) void {
const s = self.width / world_width;
nvg.translate(0, (self.height - s * world_height) / 2);
nvg.scale(s, s);
nvg.save();
nvg.translate(300, 250);
nvg.scale(4, 4);
gfx.drawHighVoltage();
nvg.translate((world_width - 600) / 4, 0);
gfx.drawHighVoltage();
nvg.restore();
nvg.fillColor(nvg.rgbf(1, 1, 1));
nvg.fontSize(96);
nvg.textAlign(.center);
_ = nvg.text(world_width / 2, 300, "<NAME>");
_ = nvg.text(world_width / 2, 600, "VS");
nvg.fontSize(48);
var x1: f32 = 600;
if (self.player1_name.items.len > 0) x1 = nvg.text(x1, 800, self.player1_name.items);
var x2: f32 = world_width - 600;
if (self.player2_name.items.len > 0) x2 = nvg.text(x2, 800, self.player2_name.items);
nvg.textAlign(.left);
if (self.frame % 60 < 30) _ = nvg.text(if (self.text_entry == .player1_name) x1 else x2, 800, "_");
nvg.scale(2, 2);
gfx.drawGorilla(600 / 2, 320, self.frame % 60 < 30, true);
gfx.drawGorilla((world_width - 600) / 2, 320, self.frame % 60 >= 30, true);
}
fn drawWindIndicator(self: Game) void {
const b = self.buildings.items[self.buildings.items.len / 2];
const x = b.x + b.w / 2;
const y = b.y;
const h = 96;
nvg.beginPath();
nvg.moveTo(x, y);
nvg.lineTo(x, y - h);
nvg.strokeWidth(4);
nvg.stroke();
nvg.beginPath();
nvg.moveTo(x, y - h);
nvg.lineTo(x, y - h + 24);
nvg.lineTo(x + 64 * self.wind / wind_max, y - h + 12 + 8 * std.math.sin(0.06 * @intToFloat(f32, self.frame)));
nvg.closePath();
nvg.fillColor(nvg.rgbf(1, 0, 0));
nvg.fill();
nvg.lineJoin(.Round);
nvg.stroke();
}
fn drawGameplay(self: Game) void {
// background
nvg.beginPath();
nvg.rect(0, 0, self.width, self.height);
nvg.fillPaint(nvg.linearGradient(0, 0, 0, self.height, nvg.rgb(2, 124, 255), nvg.rgb(153, 202, 255)));
nvg.fill();
// player names
nvg.fillColor(nvg.rgbf(1, 1, 1));
nvg.fontSize(24);
_ = nvg.text(10, 34, self.player1_name.items);
_ = nvg.textAlign(.right);
_ = nvg.text(self.width - 10, 34, self.player2_name.items);
_ = nvg.textAlign(.left);
if (self.player_win == 1) {
_ = nvg.text(10, 80, "WIN");
} else if (self.player_win == 2) {
_ = nvg.textAlign(.right);
_ = nvg.text(self.width - 10, 80, "WIN");
_ = nvg.textAlign(.left);
} else {
if (!self.banana_flying) {
self.drawParametersEntry();
}
}
nvg.save();
defer nvg.restore();
const s = self.width / world_width;
nvg.translate(0, self.height - s * world_height);
nvg.scale(s, s);
const screenshake = @sin(self.screenshake_frequency * @intToFloat(f32, self.frame)) * self.screenshake_amplitude;
nvg.translate(screenshake, 0);
gfx.drawSun(world_width / 2, world_height - 970, self.banana_flying, self.banana_x, self.banana_y);
for (self.buildings.items) |building| {
building.draw();
}
self.drawWindIndicator();
if (self.player_win == 1) {
gfx.drawGorilla(self.player1_x, self.player1_y, self.frame % 20 < 10, true);
} else if (self.player_win == 2) {
gfx.drawGorilla(self.player2_x, self.player2_y, self.frame % 20 < 10, true);
} else {
gfx.drawGorilla(self.player1_x, self.player1_y, false, self.player1_arm > 0);
gfx.drawGorilla(self.player2_x, self.player2_y, true, self.player2_arm > 0);
}
if (self.banana_flying) {
gfx.drawBanana(self.banana_x, self.banana_y, @intToFloat(f32, self.frame) * 0.1);
}
if (self.explosion_frames > 0) {
if (self.explosion_frames >= 25) {
nvg.beginPath();
nvg.circle(self.explosion_x, self.explosion_y, self.explosion_r);
nvg.fillColor(nvg.rgbf(1, 1, 1));
nvg.fill();
} else if (self.explosion_frames <= 20) {
gfx.drawExplosion(self.explosion_x, self.explosion_y, self.explosion_r);
}
}
}
pub fn draw(self: Game) void {
switch (self.state) {
.title => self.drawTitle(),
.play => self.drawGameplay(),
}
}
// https://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm
fn sdCircle(x: f32, y: f32, r: f32) f32 {
return std.math.sqrt(x * x + y * y) - r;
}
fn sdRect(x: f32, y: f32, hw: f32, hh: f32) f32 {
const q_x = std.math.absFloat(x) - hw;
const q_y = std.math.absFloat(y) - hh;
const q_x0 = std.math.max(q_x, 0);
const q_y0 = std.math.max(q_y, 0);
return std.math.sqrt(q_x0 * q_x0 + q_y0 * q_y0) + std.math.min(std.math.max(q_x, q_y), 0.0);
}
fn sdSubtraction(d1: f32, d2: f32) f32 {
return std.math.max(d1, -d2);
} | src/game.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const opts = b.addOptions();
const dynamic = b.option(bool, "dynamic", "build a dynamic .so or .dll") orelse false;
opts.addOption(bool, "dynamic", dynamic);
const omaha = b.option(bool, "omaha", "build omaha lib (libphevalomaha)") orelse false;
opts.addOption(bool, "omaha", omaha);
const lib = addStaticLib(b, mode, target, dynamic, omaha);
lib.install();
// TODO: add tests step
// var main_tests = b.addTest("src/main.zig");
// main_tests.setBuildMode(mode);
// const test_step = b.step("test", "Run library tests");
// test_step.dependOn(&main_tests.step);
// 'build examples' step - builds examples/ and installs them to zig-out/bin
// - also installs libphe and libpheomaha to zig-out/lib
// - these can be built and run manually with the following commands
// $ zig run examples/c_example.c -lc -Iinclude -Lzig-out/lib -lpheval
// $ zig run examples/cpp_example.cc -lc++ -Iinclude -Lzig-out/lib -lpheval
// $ zig run examples/omaha_example.cc -lc++ -Iinclude -Lzig-out/lib -lphevalomaha
const examples_step = b.step("examples", "build executables in examples folder");
const example_files: []const []const u8 = &.{ "c_example.c", "cpp_example.cc", "omaha_example.cc" };
inline for (example_files) |example_file| {
const exe = b.addExecutable(std.mem.trimRight(u8, example_file, ".c"), null);
exe.addCSourceFiles(&.{"examples/" ++ example_file}, &.{});
exe.addIncludeDir("include");
const want_omaha = std.mem.startsWith(u8, example_file, "omaha");
const deplib = if (!omaha and want_omaha) addStaticLib(b, mode, target, dynamic, true) else lib;
exe.linkLibrary(deplib);
if (std.mem.endsWith(u8, example_file, ".cc")) exe.linkLibCpp() else exe.linkLibC();
// install the deplib to zig-out/lib - without this 'zig build examples'
// won't install libs to zig-out/lib
const deplib_install_step = b.addInstallArtifact(deplib);
examples_step.dependOn(&deplib_install_step.step);
// install the example exe to zig-out/bin
const exe_install_step = b.addInstallArtifact(exe);
examples_step.dependOn(&exe_install_step.step);
}
}
fn addStaticLib(b: *std.build.Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget, dynamic: bool, omaha: bool) *std.build.LibExeObjStep {
const lib_name = if (omaha) "phevalomaha" else "pheval";
const lib = b.addStaticLibrary(lib_name, null);
lib.linkage = if (dynamic) .dynamic else .static;
lib.setBuildMode(mode);
lib.setTarget(target);
const c_sources: []const []const u8 = if (omaha)
&.{
"src/dptables.c",
"src/tables_omaha.c",
"src/evaluator_omaha.c",
"src/hash.c",
"src/hashtable.c",
"src/rank.c",
"src/7462.c",
}
else
&.{
"src/evaluator5.c",
"src/hashtable5.c",
"src/evaluator6.c",
"src/hashtable6.c",
"src/evaluator7.c",
"src/hashtable7.c",
"src/hash.c",
"src/hashtable.c",
"src/dptables.c",
"src/rank.c",
"src/7462.c",
};
lib.addCSourceFiles(c_sources, &.{"-std=c99"});
const cpp_sources: []const []const u8 = if (omaha)
&.{
"src/evaluator_omaha.cc",
"src/hand.cc",
}
else
&.{
"src/evaluator.cc",
"src/hand.cc",
};
lib.addCSourceFiles(
cpp_sources,
&.{"-std=c++14"},
);
lib.addIncludeDir("include");
lib.linkLibCpp();
// TODO: test building on windows with msvc abi
// if (target.isWindows())
// if (target.abi) |abi| if (abi == .msvc) lib.linkLibC();
return lib;
} | cpp/build.zig |
const Driver = struct {
transport: virtio.Driver,
inflight: u32 = 0,
pitch: u32 = 0,
width: u32 = 0,
height: u32 = 0,
// Initialize the virtio transport, but don't change modes
pub fn init(pciaddr: pci.Addr) !Driver {
var v = try virtio.Driver.init(pciaddr, 0, 0);
var d: Driver = .{ .transport = v };
return d;
}
// Do a modeswitch to the described mode
pub fn modeset(self: *Driver, addr: u64, width: u32, height: u32) void {
self.pitch = width * 4;
self.width = width;
self.height = height;
var iter = self.transport.iter(0);
{
var msg: ResourceCreate2D = .{
.hdr = .{ .cmdtype = VIRTIO_GPU_CMD_RESOURCE_CREATE_2D, .flags = 0, .fenceid = 0, .ctxid = 0 },
.resid = 1,
.format = 1,
.width = width,
.height = height,
};
var resp: ConfHdr = undefined;
iter.begin();
iter.put(&msg, @sizeOf(ResourceCreate2D), virtio.VRING_DESC_F_NEXT);
iter.put(&resp, @sizeOf(ConfHdr), virtio.VRING_DESC_F_WRITE);
self.inflight += 1;
}
{
var msg: ResourceAttachBacking = .{
.hdr = .{ .cmdtype = VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING, .flags = 0, .fenceid = 0, .ctxid = 0 },
.resid = 1,
.entrynum = 1,
};
var msg1: ResourceAttachBackingEntry = .{ .addr = addr, .len = width * height * 4 };
var resp: ConfHdr = undefined;
iter.begin();
iter.put(&msg, @sizeOf(ResourceAttachBacking), virtio.VRING_DESC_F_NEXT);
iter.put(&msg1, @sizeOf(ResourceAttachBackingEntry), virtio.VRING_DESC_F_NEXT);
iter.put(&resp, @sizeOf(ConfHdr), virtio.VRING_DESC_F_WRITE);
self.inflight += 1;
}
{
var msg: SetScanout = .{
.hdr = .{ .cmdtype = VIRTIO_GPU_CMD_SET_SCANOUT, .flags = 0, .fenceid = 0, .ctxid = 0 },
.resid = 1,
.scanid = 0,
.rect = .{ .x = 0, .y = 0, .width = width, .height = height },
};
var resp: ConfHdr = undefined;
iter.begin();
iter.put(&msg, @sizeOf(SetScanout), virtio.VRING_DESC_F_NEXT);
iter.put(&resp, @sizeOf(ConfHdr), virtio.VRING_DESC_F_WRITE);
self.inflight += 1;
}
self.transport.start(0);
self.wait();
self.update_rect(0, .{.x = 0, .y = 0, .width = width, .height = height});
}
/// Update *only* the rectangle
pub fn update_rect(self: *Driver, offset: u64, rect: Rect) void {
var iter = self.transport.iter(0);
{
var msg: TransferHost2D = .{
.hdr = .{ .cmdtype = VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D, .flags = 0, .fenceid = 0, .ctxid = 0 },
.resid = 1,
.offset = offset,
.rect = rect,
};
var resp: ConfHdr = undefined;
iter.begin();
iter.put(&msg, @sizeOf(TransferHost2D), virtio.VRING_DESC_F_NEXT);
iter.put(&resp, @sizeOf(ConfHdr), virtio.VRING_DESC_F_WRITE);
self.inflight += 1;
}
{
var msg: ResourceFlush = .{
.hdr = .{ .cmdtype = VIRTIO_GPU_CMD_RESOURCE_FLUSH, .flags = 0, .fenceid = 0, .ctxid = 0 },
.resid = 1,
.rect = rect,
};
var resp: ConfHdr = undefined;
iter.begin();
iter.put(&msg, @sizeOf(ResourceFlush), virtio.VRING_DESC_F_NEXT);
iter.put(&resp, @sizeOf(ConfHdr), virtio.VRING_DESC_F_WRITE);
self.inflight += 1;
}
self.transport.start(0);
self.wait();
}
/// Wait for request to finish.
fn wait(self: *Driver) void {
while (true) {
var a: *volatile u32 = &self.inflight;
if (a.* == 0) break;
self.transport.process(0, process, self);
}
}
};
pub fn handle_controller(addr: pci.Addr) void {
const alloc = os.memory.vmm.backed(.Eternal);
const drv = alloc.create(Driver) catch {
os.log("Virtio display controller: Allocation failure\n", .{});
return;
};
drv.* = Driver.init(addr) catch {
os.log("Virtio display controller: Init has failed!\n", .{});
return;
};
if (os.drivers.vesa_log.get_info()) |vesa| {
drv.modeset(os.drivers.vesa_log.framebuffer.?.bb_phys, vesa.width, vesa.height);
os.drivers.vesa_log.set_updater(updater, @ptrToInt(drv));
os.log("Virtio display controller: Initialized with preexisting fb\n", .{});
} else {
os.drivers.vesa_log.register_fb(updater, @ptrToInt(drv), 800*4, 800, 600, 32);
drv.modeset(os.drivers.vesa_log.get_backbuffer_phy(), 800, 600);
os.log("Virtio display controller: Initialized\n", .{});
}
}
fn process(self: *Driver, i: u8, head: virtio.Descriptor) void {
self.transport.freechain(i, head);
self.inflight -= 1;
}
/// General callback on an interrupt, context is a pointer to a Driver structure
pub fn interrupt(frame: *os.platform.InterruptFrame, context: u64) void {
var driver = @intToPtr(*Driver, context);
driver.transport.acknowledge();
driver.transport.process(0, process, driver);
}
/// Global rectangle update, but with a global context
fn updater(bb: [*]u8, yoff_src: usize, yoff_dest: usize, ysize: usize, pitch: usize, ctx: usize) void {
var self = @intToPtr(*Driver, ctx);
self.update_rect(self.pitch * yoff_src, .{ .x = 0, .y = @truncate(u32, yoff_dest), .width = self.width, .height = @truncate(u32, ysize) });
}
const virtio = @import("virtio-pci.zig");
const os = @import("root").os;
const paging = os.memory.paging;
const pmm = os.memory.pmm;
const pci = os.platform.pci;
const ConfHdr = packed struct {
cmdtype: u32,
flags: u32,
fenceid: u64,
ctxid: u32,
_: u32 = 0,
};
const ResourceCreate2D = packed struct {
hdr: ConfHdr, resid: u32, format: u32, width: u32, height: u32
};
const ResourceAttachBacking = packed struct {
hdr: ConfHdr, resid: u32, entrynum: u32
};
const ResourceAttachBackingEntry = packed struct {
addr: u64,
len: u32,
_: u32 = 0,
};
const Rect = packed struct {
x: u32, y: u32, width: u32, height: u32
};
const SetScanout = packed struct {
hdr: ConfHdr,
rect: Rect,
scanid: u32,
resid: u32,
};
const TransferHost2D = packed struct {
hdr: ConfHdr, rect: Rect, offset: u64, resid: u32, _: u32 = 0
};
const ResourceFlush = packed struct {
hdr: ConfHdr, rect: Rect, resid: u32, _: u32 = 0
};
// Feature bits
const VIRTIO_F_VERSION_1 = 32;
const VIRTIO_F_ACCESS_PLATFORM = 33;
const VIRTIO_F_RING_PACKED = 34;
const VIRTIO_F_ORDER_PLATFORM = 36;
const VIRTIO_F_SR_IOV = 37;
// 2D cmds
const VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 0x0100;
const VIRTIO_GPU_CMD_RESOURCE_CREATE_2D = 0x101;
const VIRTIO_GPU_CMD_RESOURCE_UNREF = 0x102;
const VIRTIO_GPU_CMD_SET_SCANOUT = 0x103;
const VIRTIO_GPU_CMD_RESOURCE_FLUSH = 0x104;
const VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D = 0x105;
const VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING = 0x106;
const VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING = 0x107;
const VIRTIO_GPU_CMD_GET_CAPSET_INFO = 0x108;
const VIRTIO_GPU_CMD_GET_CAPSET = 0x109;
const VIRTIO_GPU_CMD_GET_EDID = 0x10A;
// Cursor cmds
const VIRTIO_GPU_CMD_UPDATE_CURSOR = 0x0300;
const VIRTIO_GPU_CMD_MOVE_CURSOR = 0x301;
// Success
const VIRTIO_GPU_RESP_OK_NODATA = 0x1100;
const VIRTIO_GPU_RESP_OK_DISPLAY_INFO = 0x1101;
const VIRTIO_GPU_RESP_OK_CAPSET_INFO = 0x1102;
const VIRTIO_GPU_RESP_OK_CAPSET = 0x1103;
const VIRTIO_GPU_RESP_OK_EDID = 0x1104;
// Error
const VIRTIO_GPU_RESP_ERR_UNSPEC = 0x1200;
const VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY = 0x1201;
const VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID = 0x1202;
const VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID = 0x1203;
const VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID = 0x1204;
const VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER = 0x1205;
const VIRTIO_GPU_FLAG_FENCE = (1 << 0); | src/drivers/virtio/virtio-gpu.zig |
const std = @import("std");
const zp = @import("zplay");
const VertexArray = zp.graphics.common.VertexArray;
const Texture2D = zp.graphics.texture.Texture2D;
const Camera = zp.graphics.@"3d".Camera;
const Material = zp.graphics.@"3d".Material;
const Renderer = zp.graphics.@"3d".Renderer;
const SimpleRenderer = zp.graphics.@"3d".SimpleRenderer;
const alg = zp.deps.alg;
const Vec3 = alg.Vec3;
const Mat4 = alg.Mat4;
var simple_renderer: SimpleRenderer = undefined;
var vertex_array: VertexArray = undefined;
var material: Material = undefined;
const vertices = [_]f32{
-0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 1.0,
0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0,
0.0, 0.5, 0.0, 0.0, 0.0, 1.0, 1.0,
};
fn init(ctx: *zp.Context) anyerror!void {
_ = ctx;
std.log.info("game init", .{});
// create renderer
simple_renderer = SimpleRenderer.init();
simple_renderer.mix_factor = 1;
// vertex array
vertex_array = VertexArray.init(5);
vertex_array.use();
defer vertex_array.disuse();
vertex_array.bufferData(0, f32, &vertices, .array_buffer, .static_draw);
vertex_array.setAttribute(0, SimpleRenderer.ATTRIB_LOCATION_POS, 3, f32, false, 7 * @sizeOf(f32), 0);
vertex_array.setAttribute(0, SimpleRenderer.ATTRIB_LOCATION_COLOR, 4, f32, false, 7 * @sizeOf(f32), 3 * @sizeOf(f32));
// create material
material = Material.init(.{ .single_texture = try Texture2D.fromPixelData(
std.testing.allocator,
&.{
0, 0, 0, 255,
0, 255, 0, 255,
0, 0, 255, 255,
255, 255, 255, 255,
},
2,
2,
.{},
) });
_ = material.allocTextureUnit(0);
}
fn loop(ctx: *zp.Context) void {
while (ctx.pollEvent()) |e| {
switch (e) {
.window_event => |we| {
switch (we.data) {
.resized => |size| {
ctx.graphics.setViewport(0, 0, size.width, size.height);
},
else => {},
}
},
.keyboard_event => |key| {
if (key.trigger_type == .up) {
switch (key.scan_code) {
.escape => ctx.kill(),
.f1 => ctx.toggleFullscreeen(null),
else => {},
}
}
},
.quit_event => ctx.kill(),
else => {},
}
}
ctx.graphics.clear(true, false, false, [_]f32{ 0.2, 0.3, 0.3, 1.0 });
// update color and draw triangle
simple_renderer.renderer().begin();
simple_renderer.renderer().render(
vertex_array,
false,
.triangles,
0,
3,
Mat4.identity(),
Mat4.identity(),
null,
material,
null,
) catch unreachable;
simple_renderer.renderer().end();
}
fn quit(ctx: *zp.Context) void {
_ = ctx;
std.log.info("game quit", .{});
}
pub fn main() anyerror!void {
try zp.run(.{
.initFn = init,
.loopFn = loop,
.quitFn = quit,
.enable_resizable = true,
});
} | examples/single_triangle.zig |
const assert = @import("std").debug.assert;
/// C11 Standard Annex D
pub fn isC11IdChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
// 1
0x00A8,
0x00AA,
0x00AD,
0x00AF,
0x00B2...0x00B5,
0x00B7...0x00BA,
0x00BC...0x00BE,
0x00C0...0x00D6,
0x00D8...0x00F6,
0x00F8...0x00FF,
// 2
0x0100...0x167F,
0x1681...0x180D,
0x180F...0x1FFF,
// 3
0x200B...0x200D,
0x202A...0x202E,
0x203F...0x2040,
0x2054,
0x2060...0x206F,
// 4
0x2070...0x218F,
0x2460...0x24FF,
0x2776...0x2793,
0x2C00...0x2DFF,
0x2E80...0x2FFF,
// 5
0x3004...0x3007,
0x3021...0x302F,
0x3031...0x303F,
// 6
0x3040...0xD7FF,
// 7
0xF900...0xFD3D,
0xFD40...0xFDCF,
0xFDF0...0xFE44,
0xFE47...0xFFFD,
// 8
0x10000...0x1FFFD,
0x20000...0x2FFFD,
0x30000...0x3FFFD,
0x40000...0x4FFFD,
0x50000...0x5FFFD,
0x60000...0x6FFFD,
0x70000...0x7FFFD,
0x80000...0x8FFFD,
0x90000...0x9FFFD,
0xA0000...0xAFFFD,
0xB0000...0xBFFFD,
0xC0000...0xCFFFD,
0xD0000...0xDFFFD,
0xE0000...0xEFFFD,
=> true,
else => false,
};
}
/// C99 Standard Annex D
pub fn isC99IdChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
// Latin
0x00AA,
0x00BA,
0x00C0...0x00D6,
0x00D8...0x00F6,
0x00F8...0x01F5,
0x01FA...0x0217,
0x0250...0x02A8,
0x1E00...0x1E9B,
0x1EA0...0x1EF9,
0x207F,
// Greek
0x0386,
0x0388...0x038A,
0x038C,
0x038E...0x03A1,
0x03A3...0x03CE,
0x03D0...0x03D6,
0x03DA,
0x03DC,
0x03DE,
0x03E0,
0x03E2...0x03F3,
0x1F00...0x1F15,
0x1F18...0x1F1D,
0x1F20...0x1F45,
0x1F48...0x1F4D,
0x1F50...0x1F57,
0x1F59,
0x1F5B,
0x1F5D,
0x1F5F...0x1F7D,
0x1F80...0x1FB4,
0x1FB6...0x1FBC,
0x1FC2...0x1FC4,
0x1FC6...0x1FCC,
0x1FD0...0x1FD3,
0x1FD6...0x1FDB,
0x1FE0...0x1FEC,
0x1FF2...0x1FF4,
0x1FF6...0x1FFC,
// Cyrillic
0x0401...0x040C,
0x040E...0x044F,
0x0451...0x045C,
0x045E...0x0481,
0x0490...0x04C4,
0x04C7...0x04C8,
0x04CB...0x04CC,
0x04D0...0x04EB,
0x04EE...0x04F5,
0x04F8...0x04F9,
// Armenian
0x0531...0x0556,
0x0561...0x0587,
// Hebrew
0x05B0...0x05B9,
0x05BB...0x05BD,
0x05BF,
0x05C1...0x05C2,
0x05D0...0x05EA,
0x05F0...0x05F2,
// Arabic
0x0621...0x063A,
0x0640...0x0652,
0x0670...0x06B7,
0x06BA...0x06BE,
0x06C0...0x06CE,
0x06D0...0x06DC,
0x06E5...0x06E8,
0x06EA...0x06ED,
// Devanagari
0x0901...0x0903,
0x0905...0x0939,
0x093E...0x094D,
0x0950...0x0952,
0x0958...0x0963,
// Bengali
0x0981...0x0983,
0x0985...0x098C,
0x098F...0x0990,
0x0993...0x09A8,
0x09AA...0x09B0,
0x09B2,
0x09B6...0x09B9,
0x09BE...0x09C4,
0x09C7...0x09C8,
0x09CB...0x09CD,
0x09DC...0x09DD,
0x09DF...0x09E3,
0x09F0...0x09F1,
// Gurmukhi
0x0A02,
0x0A05...0x0A0A,
0x0A0F...0x0A10,
0x0A13...0x0A28,
0x0A2A...0x0A30,
0x0A32...0x0A33,
0x0A35...0x0A36,
0x0A38...0x0A39,
0x0A3E...0x0A42,
0x0A47...0x0A48,
0x0A4B...0x0A4D,
0x0A59...0x0A5C,
0x0A5E,
0x0A74,
// Gujarati
0x0A81...0x0A83,
0x0A85...0x0A8B,
0x0A8D,
0x0A8F...0x0A91,
0x0A93...0x0AA8,
0x0AAA...0x0AB0,
0x0AB2...0x0AB3,
0x0AB5...0x0AB9,
0x0ABD...0x0AC5,
0x0AC7...0x0AC9,
0x0ACB...0x0ACD,
0x0AD0,
0x0AE0,
// Oriya
0x0B01...0x0B03,
0x0B05...0x0B0C,
0x0B0F...0x0B10,
0x0B13...0x0B28,
0x0B2A...0x0B30,
0x0B32...0x0B33,
0x0B36...0x0B39,
0x0B3E...0x0B43,
0x0B47...0x0B48,
0x0B4B...0x0B4D,
0x0B5C...0x0B5D,
0x0B5F...0x0B61,
// Tamil
0x0B82...0x0B83,
0x0B85...0x0B8A,
0x0B8E...0x0B90,
0x0B92...0x0B95,
0x0B99...0x0B9A,
0x0B9C,
0x0B9E...0x0B9F,
0x0BA3...0x0BA4,
0x0BA8...0x0BAA,
0x0BAE...0x0BB5,
0x0BB7...0x0BB9,
0x0BBE...0x0BC2,
0x0BC6...0x0BC8,
0x0BCA...0x0BCD,
// Telugu
0x0C01...0x0C03,
0x0C05...0x0C0C,
0x0C0E...0x0C10,
0x0C12...0x0C28,
0x0C2A...0x0C33,
0x0C35...0x0C39,
0x0C3E...0x0C44,
0x0C46...0x0C48,
0x0C4A...0x0C4D,
0x0C60...0x0C61,
// Kannada
0x0C82...0x0C83,
0x0C85...0x0C8C,
0x0C8E...0x0C90,
0x0C92...0x0CA8,
0x0CAA...0x0CB3,
0x0CB5...0x0CB9,
0x0CBE...0x0CC4,
0x0CC6...0x0CC8,
0x0CCA...0x0CCD,
0x0CDE,
0x0CE0...0x0CE1,
// Malayalam
0x0D02...0x0D03,
0x0D05...0x0D0C,
0x0D0E...0x0D10,
0x0D12...0x0D28,
0x0D2A...0x0D39,
0x0D3E...0x0D43,
0x0D46...0x0D48,
0x0D4A...0x0D4D,
0x0D60...0x0D61,
// Thai (excluding digits 0x0E50...0x0E59; originally 0x0E01...0x0E3A and 0x0E40...0x0E5B
0x0E01...0x0E3A,
0x0E40...0x0E4F,
0x0E5A...0x0E5B,
// Lao
0x0E81...0x0E82,
0x0E84,
0x0E87...0x0E88,
0x0E8A,
0x0E8D,
0x0E94...0x0E97,
0x0E99...0x0E9F,
0x0EA1...0x0EA3,
0x0EA5,
0x0EA7,
0x0EAA...0x0EAB,
0x0EAD...0x0EAE,
0x0EB0...0x0EB9,
0x0EBB...0x0EBD,
0x0EC0...0x0EC4,
0x0EC6,
0x0EC8...0x0ECD,
0x0EDC...0x0EDD,
// Tibetan
0x0F00,
0x0F18...0x0F19,
0x0F35,
0x0F37,
0x0F39,
0x0F3E...0x0F47,
0x0F49...0x0F69,
0x0F71...0x0F84,
0x0F86...0x0F8B,
0x0F90...0x0F95,
0x0F97,
0x0F99...0x0FAD,
0x0FB1...0x0FB7,
0x0FB9,
// Georgian
0x10A0...0x10C5,
0x10D0...0x10F6,
// Hiragana
0x3041...0x3093,
0x309B...0x309C,
// Katakana
0x30A1...0x30F6,
0x30FB...0x30FC,
// Bopomofo
0x3105...0x312C,
// CJK Unified Ideographs
0x4E00...0x9FA5,
// Hangul
0xAC00...0xD7A3,
// Digits
0x0660...0x0669,
0x06F0...0x06F9,
0x0966...0x096F,
0x09E6...0x09EF,
0x0A66...0x0A6F,
0x0AE6...0x0AEF,
0x0B66...0x0B6F,
0x0BE7...0x0BEF,
0x0C66...0x0C6F,
0x0CE6...0x0CEF,
0x0D66...0x0D6F,
0x0E50...0x0E59,
0x0ED0...0x0ED9,
0x0F20...0x0F33,
// Special characters
0x00B5,
0x00B7,
0x02B0...0x02B8,
0x02BB,
0x02BD...0x02C1,
0x02D0...0x02D1,
0x02E0...0x02E4,
0x037A,
0x0559,
0x093D,
0x0B3D,
0x1FBE,
0x203F...0x2040,
0x2102,
0x2107,
0x210A...0x2113,
0x2115,
0x2118...0x211D,
0x2124,
0x2126,
0x2128,
0x212A...0x2131,
0x2133...0x2138,
0x2160...0x2182,
0x3005...0x3007,
0x3021...0x3029,
=> true,
else => false,
};
}
/// C11 standard Annex D
pub fn isC11DisallowedInitialIdChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
0x0300...0x036F,
0x1DC0...0x1DFF,
0x20D0...0x20FF,
0xFE20...0xFE2F,
=> true,
else => false,
};
}
/// These are "digit" characters; C99 disallows them as the first
/// character of an identifier
pub fn isC99DisallowedInitialIDChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
0x0660...0x0669,
0x06F0...0x06F9,
0x0966...0x096F,
0x09E6...0x09EF,
0x0A66...0x0A6F,
0x0AE6...0x0AEF,
0x0B66...0x0B6F,
0x0BE7...0x0BEF,
0x0C66...0x0C6F,
0x0CE6...0x0CEF,
0x0D66...0x0D6F,
0x0E50...0x0E59,
0x0ED0...0x0ED9,
0x0F20...0x0F33,
=> true,
else => false,
};
}
pub fn isInvisible(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
0x00ad, // SOFT HYPHEN
0x200b, // ZERO WIDTH SPACE
0x200c, // ZERO WIDTH NON-JOINER
0x200d, // ZERO WIDTH JOINER
0x2060, // WORD JOINER
0x2061, // FUNCTION APPLICATION
0x2062, // INVISIBLE TIMES
0x2063, // INVISIBLE SEPARATOR
0x2064, // INVISIBLE PLUS
0xfeff, // ZERO WIDTH NO-BREAK SPACE
=> true,
else => false,
};
}
/// Checks for identifier characters which resemble non-identifier characters
pub fn homoglyph(codepoint: u21) ?u21 {
assert(codepoint > 0x7F);
return switch (codepoint) {
0x01c3 => '!', // LATIN LETTER RETROFLEX CLICK
0x037e => ';', // GREEK QUESTION MARK
0x2212 => '-', // MINUS SIGN
0x2215 => '/', // DIVISION SLASH
0x2216 => '\\', // SET MINUS
0x2217 => '*', // ASTERISK OPERATOR
0x2223 => '|', // DIVIDES
0x2227 => '^', // LOGICAL AND
0x2236 => ':', // RATIO
0x223c => '~', // TILDE OPERATOR
0xa789 => ':', // MODIFIER LETTER COLON
0xff01 => '!', // FULLWIDTH EXCLAMATION MARK
0xff03 => '#', // FULLWIDTH NUMBER SIGN
0xff04 => '$', // FULLWIDTH DOLLAR SIGN
0xff05 => '%', // FULLWIDTH PERCENT SIGN
0xff06 => '&', // FULLWIDTH AMPERSAND
0xff08 => '(', // FULLWIDTH LEFT PARENTHESIS
0xff09 => ')', // FULLWIDTH RIGHT PARENTHESIS
0xff0a => '*', // FULLWIDTH ASTERISK
0xff0b => '+', // FULLWIDTH ASTERISK
0xff0c => ',', // FULLWIDTH COMMA
0xff0d => '-', // FULLWIDTH HYPHEN-MINUS
0xff0e => '.', // FULLWIDTH FULL STOP
0xff0f => '/', // FULLWIDTH SOLIDUS
0xff1a => ':', // FULLWIDTH COLON
0xff1b => ';', // FULLWIDTH SEMICOLON
0xff1c => '<', // FULLWIDTH LESS-THAN SIGN
0xff1d => '=', // FULLWIDTH EQUALS SIGN
0xff1e => '>', // FULLWIDTH GREATER-THAN SIGN
0xff1f => '?', // FULLWIDTH QUESTION MARK
0xff20 => '@', // FULLWIDTH COMMERCIAL AT
0xff3b => '[', // FULLWIDTH LEFT SQUARE BRACKET
0xff3c => '\\', // FULLWIDTH REVERSE SOLIDUS
0xff3d => ']', // FULLWIDTH RIGHT SQUARE BRACKET
0xff3e => '^', // FULLWIDTH CIRCUMFLEX ACCENT
0xff5b => '{', // FULLWIDTH LEFT CURLY BRACKET
0xff5c => '|', // FULLWIDTH VERTICAL LINE
0xff5d => '}', // FULLWIDTH RIGHT CURLY BRACKET
0xff5e => '~', // FULLWIDTH TILDE
else => null,
};
} | src/CharInfo.zig |
const std = @import("std");
const builtin = @import("builtin");
const mem = std.mem;
const TypeInfo = std.builtin.TypeInfo;
const TypeId = std.builtin.TypeId;
const expect = std.testing.expect;
const expectEqualStrings = std.testing.expectEqualStrings;
test "type info: integer, floating point type info" {
try testIntFloat();
comptime try testIntFloat();
}
fn testIntFloat() !void {
const u8_info = @typeInfo(u8);
try expect(u8_info == .Int);
try expect(u8_info.Int.signedness == .unsigned);
try expect(u8_info.Int.bits == 8);
const f64_info = @typeInfo(f64);
try expect(f64_info == .Float);
try expect(f64_info.Float.bits == 64);
}
test "type info: optional type info" {
try testOptional();
comptime try testOptional();
}
fn testOptional() !void {
const null_info = @typeInfo(?void);
try expect(null_info == .Optional);
try expect(null_info.Optional.child == void);
}
test "type info: C pointer type info" {
try testCPtr();
comptime try testCPtr();
}
fn testCPtr() !void {
const ptr_info = @typeInfo([*c]align(4) const i8);
try expect(ptr_info == .Pointer);
try expect(ptr_info.Pointer.size == .C);
try expect(ptr_info.Pointer.is_const);
try expect(!ptr_info.Pointer.is_volatile);
try expect(ptr_info.Pointer.alignment == 4);
try expect(ptr_info.Pointer.child == i8);
}
test "type info: value is correctly copied" {
comptime {
var ptrInfo = @typeInfo([]u32);
ptrInfo.Pointer.size = .One;
try expect(@typeInfo([]u32).Pointer.size == .Slice);
}
}
test "type info: tag type, void info" {
try testBasic();
comptime try testBasic();
}
fn testBasic() !void {
try expect(@typeInfo(TypeInfo).Union.tag_type == TypeId);
const void_info = @typeInfo(void);
try expect(void_info == TypeId.Void);
try expect(void_info.Void == {});
}
test "type info: pointer type info" {
try testPointer();
comptime try testPointer();
}
fn testPointer() !void {
const u32_ptr_info = @typeInfo(*u32);
try expect(u32_ptr_info == .Pointer);
try expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.One);
try expect(u32_ptr_info.Pointer.is_const == false);
try expect(u32_ptr_info.Pointer.is_volatile == false);
try expect(u32_ptr_info.Pointer.alignment == @alignOf(u32));
try expect(u32_ptr_info.Pointer.child == u32);
try expect(u32_ptr_info.Pointer.sentinel == null);
}
test "type info: unknown length pointer type info" {
try testUnknownLenPtr();
comptime try testUnknownLenPtr();
}
fn testUnknownLenPtr() !void {
const u32_ptr_info = @typeInfo([*]const volatile f64);
try expect(u32_ptr_info == .Pointer);
try expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many);
try expect(u32_ptr_info.Pointer.is_const == true);
try expect(u32_ptr_info.Pointer.is_volatile == true);
try expect(u32_ptr_info.Pointer.sentinel == null);
try expect(u32_ptr_info.Pointer.alignment == @alignOf(f64));
try expect(u32_ptr_info.Pointer.child == f64);
}
test "type info: null terminated pointer type info" {
try testNullTerminatedPtr();
comptime try testNullTerminatedPtr();
}
fn testNullTerminatedPtr() !void {
const ptr_info = @typeInfo([*:0]u8);
try expect(ptr_info == .Pointer);
try expect(ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many);
try expect(ptr_info.Pointer.is_const == false);
try expect(ptr_info.Pointer.is_volatile == false);
try expect(@ptrCast(*const u8, ptr_info.Pointer.sentinel.?).* == 0);
try expect(@typeInfo([:0]u8).Pointer.sentinel != null);
}
test "type info: slice type info" {
try testSlice();
comptime try testSlice();
}
fn testSlice() !void {
const u32_slice_info = @typeInfo([]u32);
try expect(u32_slice_info == .Pointer);
try expect(u32_slice_info.Pointer.size == .Slice);
try expect(u32_slice_info.Pointer.is_const == false);
try expect(u32_slice_info.Pointer.is_volatile == false);
try expect(u32_slice_info.Pointer.alignment == 4);
try expect(u32_slice_info.Pointer.child == u32);
}
test "type info: array type info" {
try testArray();
comptime try testArray();
}
fn testArray() !void {
{
const info = @typeInfo([42]u8);
try expect(info == .Array);
try expect(info.Array.len == 42);
try expect(info.Array.child == u8);
try expect(info.Array.sentinel == null);
}
{
const info = @typeInfo([10:0]u8);
try expect(info.Array.len == 10);
try expect(info.Array.child == u8);
try expect(@ptrCast(*const u8, info.Array.sentinel.?).* == @as(u8, 0));
try expect(@sizeOf([10:0]u8) == info.Array.len + 1);
}
}
test "type info: error set, error union info" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
try testErrorSet();
comptime try testErrorSet();
}
fn testErrorSet() !void {
const TestErrorSet = error{
First,
Second,
Third,
};
const error_set_info = @typeInfo(TestErrorSet);
try expect(error_set_info == .ErrorSet);
try expect(error_set_info.ErrorSet.?.len == 3);
try expect(mem.eql(u8, error_set_info.ErrorSet.?[0].name, "First"));
const error_union_info = @typeInfo(TestErrorSet!usize);
try expect(error_union_info == .ErrorUnion);
try expect(error_union_info.ErrorUnion.error_set == TestErrorSet);
try expect(error_union_info.ErrorUnion.payload == usize);
const global_info = @typeInfo(anyerror);
try expect(global_info == .ErrorSet);
try expect(global_info.ErrorSet == null);
}
test "type info: enum info" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try testEnum();
comptime try testEnum();
}
fn testEnum() !void {
const Os = enum {
Windows,
Macos,
Linux,
FreeBSD,
};
const os_info = @typeInfo(Os);
try expect(os_info == .Enum);
try expect(os_info.Enum.layout == .Auto);
try expect(os_info.Enum.fields.len == 4);
try expect(mem.eql(u8, os_info.Enum.fields[1].name, "Macos"));
try expect(os_info.Enum.fields[3].value == 3);
try expect(os_info.Enum.tag_type == u2);
try expect(os_info.Enum.decls.len == 0);
}
test "type info: union info" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
try testUnion();
comptime try testUnion();
}
fn testUnion() !void {
const typeinfo_info = @typeInfo(TypeInfo);
try expect(typeinfo_info == .Union);
try expect(typeinfo_info.Union.layout == .Auto);
try expect(typeinfo_info.Union.tag_type.? == TypeId);
try expect(typeinfo_info.Union.fields.len == 25);
try expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int));
try expect(typeinfo_info.Union.decls.len == 22);
const TestNoTagUnion = union {
Foo: void,
Bar: u32,
};
const notag_union_info = @typeInfo(TestNoTagUnion);
try expect(notag_union_info == .Union);
try expect(notag_union_info.Union.tag_type == null);
try expect(notag_union_info.Union.layout == .Auto);
try expect(notag_union_info.Union.fields.len == 2);
try expect(notag_union_info.Union.fields[0].alignment == @alignOf(void));
try expect(notag_union_info.Union.fields[1].field_type == u32);
try expect(notag_union_info.Union.fields[1].alignment == @alignOf(u32));
const TestExternUnion = extern union {
foo: *anyopaque,
};
const extern_union_info = @typeInfo(TestExternUnion);
try expect(extern_union_info.Union.layout == .Extern);
try expect(extern_union_info.Union.tag_type == null);
try expect(extern_union_info.Union.fields[0].field_type == *anyopaque);
}
test "type info: struct info" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try testStruct();
comptime try testStruct();
}
fn testStruct() !void {
const unpacked_struct_info = @typeInfo(TestStruct);
try expect(unpacked_struct_info.Struct.is_tuple == false);
try expect(unpacked_struct_info.Struct.fields[0].alignment == @alignOf(u32));
try expect(@ptrCast(*const u32, unpacked_struct_info.Struct.fields[0].default_value.?).* == 4);
try expect(mem.eql(u8, "foobar", @ptrCast(*const *const [6:0]u8, unpacked_struct_info.Struct.fields[1].default_value.?).*));
}
const TestStruct = struct {
fieldA: u32 = 4,
fieldB: *const [6:0]u8 = "foobar",
};
test "type info: packed struct info" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
try testPackedStruct();
comptime try testPackedStruct();
}
fn testPackedStruct() !void {
const struct_info = @typeInfo(TestPackedStruct);
try expect(struct_info == .Struct);
try expect(struct_info.Struct.is_tuple == false);
try expect(struct_info.Struct.layout == .Packed);
try expect(struct_info.Struct.fields.len == 4);
try expect(struct_info.Struct.fields[0].alignment == 0);
try expect(struct_info.Struct.fields[2].field_type == f32);
try expect(struct_info.Struct.fields[2].default_value == null);
try expect(@ptrCast(*const u32, struct_info.Struct.fields[3].default_value.?).* == 4);
try expect(struct_info.Struct.fields[3].alignment == 0);
try expect(struct_info.Struct.decls.len == 2);
try expect(struct_info.Struct.decls[0].is_pub);
}
const TestPackedStruct = packed struct {
fieldA: usize,
fieldB: void,
fieldC: f32,
fieldD: u32 = 4,
pub fn foo(self: *const Self) void {
_ = self;
}
const Self = @This();
};
test "type info: opaque info" {
try testOpaque();
comptime try testOpaque();
}
fn testOpaque() !void {
const Foo = opaque {
const A = 1;
fn b() void {}
};
const foo_info = @typeInfo(Foo);
try expect(foo_info.Opaque.decls.len == 2);
}
test "type info: function type info" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
// wasm doesn't support align attributes on functions
if (builtin.target.cpu.arch == .wasm32 or builtin.target.cpu.arch == .wasm64) return error.SkipZigTest;
try testFunction();
comptime try testFunction();
}
fn testFunction() !void {
const fn_info = @typeInfo(@TypeOf(foo));
try expect(fn_info == .Fn);
try expect(fn_info.Fn.alignment > 0);
try expect(fn_info.Fn.calling_convention == .C);
try expect(!fn_info.Fn.is_generic);
try expect(fn_info.Fn.args.len == 2);
try expect(fn_info.Fn.is_var_args);
try expect(fn_info.Fn.return_type.? == usize);
const fn_aligned_info = @typeInfo(@TypeOf(fooAligned));
try expect(fn_aligned_info.Fn.alignment == 4);
if (builtin.zig_backend != .stage1) return; // no bound fn in stage2
const test_instance: TestPackedStruct = undefined;
const bound_fn_info = @typeInfo(@TypeOf(test_instance.foo));
try expect(bound_fn_info == .BoundFn);
try expect(bound_fn_info.BoundFn.args[0].arg_type.? == *const TestPackedStruct);
}
extern fn foo(a: usize, b: bool, ...) callconv(.C) usize;
extern fn fooAligned(a: usize, b: bool, ...) align(4) callconv(.C) usize;
test "typeInfo with comptime parameter in struct fn def" {
const S = struct {
pub fn func(comptime x: f32) void {
_ = x;
}
};
comptime var info = @typeInfo(S);
_ = info;
}
test "type info: vectors" {
try testVector();
comptime try testVector();
}
fn testVector() !void {
const vec_info = @typeInfo(std.meta.Vector(4, i32));
try expect(vec_info == .Vector);
try expect(vec_info.Vector.len == 4);
try expect(vec_info.Vector.child == i32);
}
test "type info: anyframe and anyframe->T" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
try testAnyFrame();
comptime try testAnyFrame();
}
fn testAnyFrame() !void {
{
const anyframe_info = @typeInfo(anyframe->i32);
try expect(anyframe_info == .AnyFrame);
try expect(anyframe_info.AnyFrame.child.? == i32);
}
{
const anyframe_info = @typeInfo(anyframe);
try expect(anyframe_info == .AnyFrame);
try expect(anyframe_info.AnyFrame.child == null);
}
}
test "type info: pass to function" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
_ = passTypeInfo(@typeInfo(void));
_ = comptime passTypeInfo(@typeInfo(void));
}
fn passTypeInfo(comptime info: TypeInfo) type {
_ = info;
return void;
}
test "type info: TypeId -> TypeInfo impl cast" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
_ = passTypeInfo(TypeId.Void);
_ = comptime passTypeInfo(TypeId.Void);
}
test "sentinel of opaque pointer type" {
const c_void_info = @typeInfo(*anyopaque);
try expect(c_void_info.Pointer.sentinel == null);
}
test "@typeInfo does not force declarations into existence" {
const S = struct {
x: i32,
fn doNotReferenceMe() void {
@compileError("test failed");
}
};
comptime try expect(@typeInfo(S).Struct.fields.len == 1);
}
fn add(a: i32, b: i32) i32 {
return a + b;
}
test "type info for async frames" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
switch (@typeInfo(@Frame(add))) {
.Frame => |frame| {
try expect(@ptrCast(@TypeOf(add), frame.function) == add);
},
else => unreachable,
}
}
test "Declarations are returned in declaration order" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
const a = 1;
const b = 2;
const c = 3;
const d = 4;
const e = 5;
};
const d = @typeInfo(S).Struct.decls;
try expect(std.mem.eql(u8, d[0].name, "a"));
try expect(std.mem.eql(u8, d[1].name, "b"));
try expect(std.mem.eql(u8, d[2].name, "c"));
try expect(std.mem.eql(u8, d[3].name, "d"));
try expect(std.mem.eql(u8, d[4].name, "e"));
}
test "Struct.is_tuple for anon list literal" {
try expect(@typeInfo(@TypeOf(.{0})).Struct.is_tuple);
}
test "Struct.is_tuple for anon struct literal" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
try expect(!@typeInfo(@TypeOf(.{ .a = 0 })).Struct.is_tuple);
}
test "StructField.is_comptime" {
const info = @typeInfo(struct { x: u8 = 3, comptime y: u32 = 5 }).Struct;
try expect(!info.fields[0].is_comptime);
try expect(info.fields[1].is_comptime);
}
test "typeInfo resolves usingnamespace declarations" {
const A = struct {
pub const f1 = 42;
};
const B = struct {
const f0 = 42;
usingnamespace A;
};
try expect(@typeInfo(B).Struct.decls.len == 2);
//a
} | test/behavior/type_info.zig |
const builtin = @import("builtin");
const std = @import("std.zig");
const mem = std.mem;
const os = std.os;
const assert = std.debug.assert;
const testing = std.testing;
const elf = std.elf;
const windows = std.os.windows;
const maxInt = std.math.maxInt;
pub const DynLib = switch (builtin.os) {
.linux => LinuxDynLib,
.windows => WindowsDynLib,
else => void,
};
// The link_map structure is not completely specified beside the fields
// reported below, any libc is free to store additional data in the remaining
// space.
// An iterator is provided in order to traverse the linked list in a idiomatic
// fashion.
const LinkMap = extern struct {
l_addr: usize,
l_name: [*]const u8,
l_ld: ?*elf.Dyn,
l_next: ?*LinkMap,
l_prev: ?*LinkMap,
pub const Iterator = struct {
current: ?*LinkMap,
fn end(self: *Iterator) bool {
return self.current == null;
}
fn next(self: *Iterator) ?*LinkMap {
if (self.current) |it| {
self.current = it.l_next;
return it;
}
return null;
}
};
};
const RDebug = extern struct {
r_version: i32,
r_map: ?*LinkMap,
r_brk: usize,
r_ldbase: usize,
};
fn elf_get_va_offset(phdrs: []elf.Phdr) !usize {
for (phdrs) |*phdr| {
if (phdr.p_type == elf.PT_LOAD) {
return @ptrToInt(phdr) - phdr.p_vaddr;
}
}
return error.InvalidExe;
}
pub fn linkmap_iterator(phdrs: []elf.Phdr) !LinkMap.Iterator {
const va_offset = try elf_get_va_offset(phdrs);
const dyn_table = init: {
for (phdrs) |*phdr| {
if (phdr.p_type == elf.PT_DYNAMIC) {
const ptr = @intToPtr([*]elf.Dyn, va_offset + phdr.p_vaddr);
break :init ptr[0 .. phdr.p_memsz / @sizeOf(elf.Dyn)];
}
}
// No PT_DYNAMIC means this is either a statically-linked program or a
// badly corrupted one
return LinkMap.Iterator{ .current = null };
};
const link_map_ptr = init: {
for (dyn_table) |*dyn| {
switch (dyn.d_tag) {
elf.DT_DEBUG => {
const r_debug = @intToPtr(*RDebug, dyn.d_un.d_ptr);
if (r_debug.r_version != 1) return error.InvalidExe;
break :init r_debug.r_map;
},
elf.DT_PLTGOT => {
const got_table = @intToPtr([*]usize, dyn.d_un.d_ptr);
// The address to the link_map structure is stored in the
// second slot
break :init @intToPtr(?*LinkMap, got_table[1]);
},
else => {},
}
}
return error.InvalidExe;
};
return LinkMap.Iterator{ .current = link_map_ptr };
}
pub const LinuxDynLib = struct {
elf_lib: ElfLib,
fd: i32,
memory: []align(mem.page_size) u8,
/// Trusts the file
pub fn open(path: []const u8) !DynLib {
const fd = try os.open(path, 0, os.O_RDONLY | os.O_CLOEXEC);
errdefer os.close(fd);
// TODO remove this @intCast
const size = @intCast(usize, (try os.fstat(fd)).size);
const bytes = try os.mmap(
null,
mem.alignForward(size, mem.page_size),
os.PROT_READ | os.PROT_EXEC,
os.MAP_PRIVATE,
fd,
0,
);
errdefer os.munmap(bytes);
return DynLib{
.elf_lib = try ElfLib.init(bytes),
.fd = fd,
.memory = bytes,
};
}
pub fn close(self: *DynLib) void {
os.munmap(self.memory);
os.close(self.fd);
self.* = undefined;
}
pub fn lookup(self: *DynLib, name: []const u8) ?usize {
return self.elf_lib.lookup("", name);
}
};
pub const ElfLib = struct {
strings: [*]u8,
syms: [*]elf.Sym,
hashtab: [*]os.Elf_Symndx,
versym: ?[*]u16,
verdef: ?*elf.Verdef,
base: usize,
// Trusts the memory
pub fn init(bytes: []align(@alignOf(elf.Ehdr)) u8) !ElfLib {
const eh = @ptrCast(*elf.Ehdr, bytes.ptr);
if (!mem.eql(u8, eh.e_ident[0..4], "\x7fELF")) return error.NotElfFile;
if (eh.e_type != elf.ET_DYN) return error.NotDynamicLibrary;
const elf_addr = @ptrToInt(bytes.ptr);
var ph_addr: usize = elf_addr + eh.e_phoff;
var base: usize = maxInt(usize);
var maybe_dynv: ?[*]usize = null;
{
var i: usize = 0;
while (i < eh.e_phnum) : ({
i += 1;
ph_addr += eh.e_phentsize;
}) {
const ph = @intToPtr(*elf.Phdr, ph_addr);
switch (ph.p_type) {
elf.PT_LOAD => base = elf_addr + ph.p_offset - ph.p_vaddr,
elf.PT_DYNAMIC => maybe_dynv = @intToPtr([*]usize, elf_addr + ph.p_offset),
else => {},
}
}
}
const dynv = maybe_dynv orelse return error.MissingDynamicLinkingInformation;
if (base == maxInt(usize)) return error.BaseNotFound;
var maybe_strings: ?[*]u8 = null;
var maybe_syms: ?[*]elf.Sym = null;
var maybe_hashtab: ?[*]os.Elf_Symndx = null;
var maybe_versym: ?[*]u16 = null;
var maybe_verdef: ?*elf.Verdef = null;
{
var i: usize = 0;
while (dynv[i] != 0) : (i += 2) {
const p = base + dynv[i + 1];
switch (dynv[i]) {
elf.DT_STRTAB => maybe_strings = @intToPtr([*]u8, p),
elf.DT_SYMTAB => maybe_syms = @intToPtr([*]elf.Sym, p),
elf.DT_HASH => maybe_hashtab = @intToPtr([*]os.Elf_Symndx, p),
elf.DT_VERSYM => maybe_versym = @intToPtr([*]u16, p),
elf.DT_VERDEF => maybe_verdef = @intToPtr(*elf.Verdef, p),
else => {},
}
}
}
return ElfLib{
.base = base,
.strings = maybe_strings orelse return error.ElfStringSectionNotFound,
.syms = maybe_syms orelse return error.ElfSymSectionNotFound,
.hashtab = maybe_hashtab orelse return error.ElfHashTableNotFound,
.versym = maybe_versym,
.verdef = maybe_verdef,
};
}
/// Returns the address of the symbol
pub fn lookup(self: *const ElfLib, vername: []const u8, name: []const u8) ?usize {
const maybe_versym = if (self.verdef == null) null else self.versym;
const OK_TYPES = (1 << elf.STT_NOTYPE | 1 << elf.STT_OBJECT | 1 << elf.STT_FUNC | 1 << elf.STT_COMMON);
const OK_BINDS = (1 << elf.STB_GLOBAL | 1 << elf.STB_WEAK | 1 << elf.STB_GNU_UNIQUE);
var i: usize = 0;
while (i < self.hashtab[1]) : (i += 1) {
if (0 == (@as(u32, 1) << @intCast(u5, self.syms[i].st_info & 0xf) & OK_TYPES)) continue;
if (0 == (@as(u32, 1) << @intCast(u5, self.syms[i].st_info >> 4) & OK_BINDS)) continue;
if (0 == self.syms[i].st_shndx) continue;
if (!mem.eql(u8, name, mem.toSliceConst(u8, self.strings + self.syms[i].st_name))) continue;
if (maybe_versym) |versym| {
if (!checkver(self.verdef.?, versym[i], vername, self.strings))
continue;
}
return self.base + self.syms[i].st_value;
}
return null;
}
};
fn checkver(def_arg: *elf.Verdef, vsym_arg: i32, vername: []const u8, strings: [*]u8) bool {
var def = def_arg;
const vsym = @bitCast(u32, vsym_arg) & 0x7fff;
while (true) {
if (0 == (def.vd_flags & elf.VER_FLG_BASE) and (def.vd_ndx & 0x7fff) == vsym)
break;
if (def.vd_next == 0)
return false;
def = @intToPtr(*elf.Verdef, @ptrToInt(def) + def.vd_next);
}
const aux = @intToPtr(*elf.Verdaux, @ptrToInt(def) + def.vd_aux);
return mem.eql(u8, vername, mem.toSliceConst(u8, strings + aux.vda_name));
}
pub const WindowsDynLib = struct {
dll: windows.HMODULE,
pub fn open(path: []const u8) !WindowsDynLib {
const wpath = try windows.sliceToPrefixedFileW(path);
return WindowsDynLib{
.dll = try windows.LoadLibraryW(&wpath),
};
}
pub fn close(self: *WindowsDynLib) void {
windows.FreeLibrary(self.dll);
self.* = undefined;
}
pub fn lookup(self: *WindowsDynLib, name: []const u8) ?usize {
return @ptrToInt(windows.kernel32.GetProcAddress(self.dll, name.ptr));
}
};
test "dynamic_library" {
const libname = switch (builtin.os) {
.linux => "invalid_so.so",
.windows => "invalid_dll.dll",
else => return,
};
const dynlib = DynLib.open(libname) catch |err| {
testing.expect(err == error.FileNotFound);
return;
};
@panic("Expected error from function");
} | lib/std/dynamic_library.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const Risks = std.AutoHashMap(aoc.Coord, u8);
pub fn run(problem: *aoc.Problem) !aoc.Solution {
var risks1 = Risks.init(problem.allocator);
defer risks1.deinit();
var end_coord1 = aoc.Coord.init(.{0, 0});
while (problem.line()) |line| {
end_coord1.col = 0;
for (line) |risk| {
try risks1.put(end_coord1, risk - '0');
end_coord1.col += 1;
}
end_coord1.row += 1;
}
var risks2 = Risks.init(problem.allocator);
defer risks2.deinit();
{
var iter = risks1.iterator();
while (iter.next()) |risk| {
var row: u8 = 0;
while (row < 5) : (row += 1) {
var col: u8 = 0;
while (col < 5) : (col += 1) {
try risks2.put(
risk.key_ptr.add(aoc.Coord.init(.{end_coord1.row * row, end_coord1.col * col})),
wrapRisk(risk.value_ptr.* + row + col)
);
}
}
}
}
const end_coord2 = aoc.Coord.init(.{end_coord1.row * 5 - 1, end_coord1.col * 5 - 1});
end_coord1.row -= 1; end_coord1.col -= 1;
const min_risk1 = try aStar(&risks1, end_coord1);
const min_risk2 = try aStar(&risks2, end_coord2);
return problem.solution(min_risk1, min_risk2);
}
fn aStar(risks: *const Risks, end_coord: aoc.Coord) !usize {
const Node = struct {
const Self = @This();
coord: aoc.Coord, g_score: usize,
fn compare(_: void, a: Self, b: Self) std.math.Order {
return std.math.order(a.g_score, b.g_score);
}
};
var open_set = std.PriorityQueue(Node, void, Node.compare).init(risks.allocator, {});
defer open_set.deinit();
try open_set.add(.{ .coord = aoc.Coord.init(.{0, 0}), .g_score = 0 });
var g_score = std.AutoHashMap(aoc.Coord, usize).init(risks.allocator);
defer g_score.deinit();
try g_score.put(aoc.Coord.init(.{0, 0}), 0);
while (open_set.removeOrNull()) |current| {
if (current.coord.equals(end_coord)) {
return current.g_score;
}
for (&[_]aoc.Coord {
current.coord.add(aoc.PredefinedCoord.UP),
current.coord.add(aoc.PredefinedCoord.LEFT),
current.coord.add(aoc.PredefinedCoord.RIGHT),
current.coord.add(aoc.PredefinedCoord.DOWN),
}) |neighbor| {
const neighbor_score = risks.get(neighbor) orelse continue;
const tentative_g_score = current.g_score + neighbor_score;
if (tentative_g_score < g_score.get(neighbor) orelse std.math.maxInt(usize)) {
try g_score.put(neighbor, tentative_g_score);
try open_set.add(.{ .coord = neighbor, .g_score = tentative_g_score }); // not optimal
}
}
}
unreachable;
}
fn wrapRisk(risk: u8) u8 {
return if (risk >= 10) risk - 9 else risk;
} | src/main/zig/2021/day15.zig |
const std = @import("../std.zig");
const __rem_pio2_large = @import("__rem_pio2_large.zig").__rem_pio2_large;
const math = std.math;
const toint = 1.5 / math.floatEps(f64);
// pi/4
const pio4 = 0x1.921fb6p-1;
// invpio2: 53 bits of 2/pi
const invpio2 = 6.36619772367581382433e-01; // 0x3FE45F30, 0x6DC9C883
// pio2_1: first 25 bits of pi/2
const pio2_1 = 1.57079631090164184570e+00; // 0x3FF921FB, 0x50000000
// pio2_1t: pi/2 - pio2_1
const pio2_1t = 1.58932547735281966916e-08; // 0x3E5110b4, 0x611A6263
// Returns the remainder of x rem pi/2 in *y
// use double precision for everything except passing x
// use __rem_pio2_large() for large x
pub fn __rem_pio2f(x: f32, y: *f64) i32 {
var tx: [1]f64 = undefined;
var ty: [1]f64 = undefined;
var @"fn": f64 = undefined;
var ix: u32 = undefined;
var n: i32 = undefined;
var sign: bool = undefined;
var e0: u32 = undefined;
var ui: u32 = undefined;
ui = @bitCast(u32, x);
ix = ui & 0x7fffffff;
// 25+53 bit pi is good enough for medium size
if (ix < 0x4dc90fdb) { // |x| ~< 2^28*(pi/2), medium size
// Use a specialized rint() to get fn.
@"fn" = @floatCast(f64, x) * invpio2 + toint - toint;
n = @floatToInt(i32, @"fn");
y.* = x - @"fn" * pio2_1 - @"fn" * pio2_1t;
// Matters with directed rounding.
if (y.* < -pio4) {
n -= 1;
@"fn" -= 1;
y.* = x - @"fn" * pio2_1 - @"fn" * pio2_1t;
} else if (y.* > pio4) {
n += 1;
@"fn" += 1;
y.* = x - @"fn" * pio2_1 - @"fn" * pio2_1t;
}
return n;
}
if (ix >= 0x7f800000) { // x is inf or NaN
y.* = x - x;
return 0;
}
// scale x into [2^23, 2^24-1]
sign = ui >> 31 != 0;
e0 = (ix >> 23) - (0x7f + 23); // e0 = ilogb(|x|)-23, positive
ui = ix - (e0 << 23);
tx[0] = @bitCast(f32, ui);
n = __rem_pio2_large(&tx, &ty, @intCast(i32, e0), 1, 0);
if (sign) {
y.* = -ty[0];
return -n;
}
y.* = ty[0];
return n;
} | lib/std/math/__rem_pio2f.zig |
const std = @import("std");
const c = @import("c.zig").c;
const Window = @import("Window.zig");
const Error = @import("errors.zig").Error;
const getError = @import("errors.zig").getError;
const Action = @import("action.zig").Action;
const GamepadAxis = @import("gamepad_axis.zig").GamepadAxis;
const GamepadButton = @import("gamepad_button.zig").GamepadButton;
const Hat = @import("hat.zig").Hat;
const internal_debug = @import("internal_debug.zig");
const Joystick = @This();
/// The GLFW joystick ID.
jid: Id,
/// Joystick IDs.
///
/// See glfw.Joystick.setCallback for how these are used.
pub const Id = enum(c_int) {
one = c.GLFW_JOYSTICK_1,
two = c.GLFW_JOYSTICK_2,
three = c.GLFW_JOYSTICK_3,
four = c.GLFW_JOYSTICK_4,
five = c.GLFW_JOYSTICK_5,
six = c.GLFW_JOYSTICK_6,
seven = c.GLFW_JOYSTICK_7,
eight = c.GLFW_JOYSTICK_8,
nine = c.GLFW_JOYSTICK_9,
ten = c.GLFW_JOYSTICK_10,
eleven = c.GLFW_JOYSTICK_11,
twelve = c.GLFW_JOYSTICK_12,
thirteen = c.GLFW_JOYSTICK_13,
fourteen = c.GLFW_JOYSTICK_14,
fifteen = c.GLFW_JOYSTICK_15,
sixteen = c.GLFW_JOYSTICK_16,
pub const last = @intToEnum(@This(), c.GLFW_JOYSTICK_LAST);
};
/// Gamepad input state
///
/// This describes the input state of a gamepad.
///
/// see also: gamepad, glfwGetGamepadState
const GamepadState = extern struct {
/// The states of each gamepad button (see gamepad_buttons), `glfw.Action.press` or `glfw.Action.release`.
///
/// Use the enumeration helper e.g. `.getButton(.dpad_up)` to access these indices.
buttons: [15]u8,
/// The states of each gamepad axis (see gamepad_axes), in the range -1.0 to 1.0 inclusive.
///
/// Use the enumeration helper e.g. `.getAxis(.left_x)` to access these indices.
axes: [6]f32,
/// Returns the state of the specified gamepad button.
pub fn getButton(self: @This(), which: GamepadButton) Action {
_ = self;
return @intToEnum(Action, self.buttons[@intCast(usize, @enumToInt(which))]);
}
/// Returns the status of the specified gamepad axis, in the range -1.0 to 1.0 inclusive.
pub fn getAxis(self: @This(), which: GamepadAxis) f32 {
_ = self;
return self.axes[@intCast(usize, @enumToInt(which))];
}
};
/// Returns whether the specified joystick is present.
///
/// This function returns whether the specified joystick is present.
///
/// There is no need to call this function before other functions that accept a joystick ID, as
/// they all check for presence before performing any other work.
///
/// @return `true` if the joystick is present, or `false` otherwise.
///
/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: joystick
pub inline fn present(self: Joystick) Error!bool {
internal_debug.assertInitialized();
const is_present = c.glfwJoystickPresent(@enumToInt(self.jid));
getError() catch |err| return switch (err) {
Error.PlatformError => err,
else => unreachable,
};
return is_present == c.GLFW_TRUE;
}
/// Returns the values of all axes of the specified joystick.
///
/// This function returns the values of all axes of the specified joystick. Each element in the
/// array is a value between -1.0 and 1.0.
///
/// If the specified joystick is not present this function will return null but will not generate
/// an error. This can be used instead of first calling glfw.Joystick.present.
///
/// @return An array of axis values, or null if the joystick is not present.
///
/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
///
/// @pointer_lifetime The returned array is allocated and freed by GLFW. You should not free it
/// yourself. It is valid until the specified joystick is disconnected or the library is
/// terminated.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: joystick_axis
/// Replaces `glfwGetJoystickPos`.
pub inline fn getAxes(self: Joystick) Error!?[]const f32 {
internal_debug.assertInitialized();
var count: c_int = undefined;
const axes = c.glfwGetJoystickAxes(@enumToInt(self.jid), &count);
getError() catch |err| return switch (err) {
Error.PlatformError => err,
else => unreachable,
};
if (axes == null) return null;
return axes[0..@intCast(usize, count)];
}
/// Returns the state of all buttons of the specified joystick.
///
/// This function returns the state of all buttons of the specified joystick. Each element in the
/// array is either `glfw.Action.press` or `glfw.Action.release`.
///
/// For backward compatibility with earlier versions that did not have glfw.Joystick.getHats, the
/// button array also includes all hats, each represented as four buttons. The hats are in the same
/// order as returned by glfw.Joystick.getHats and are in the order _up_, _right_, _down_ and
/// _left_. To disable these extra buttons, set the glfw.joystick_hat_buttons init hint before
/// initialization.
///
/// If the specified joystick is not present this function will return null but will not generate an
/// error. This can be used instead of first calling glfw.Joystick.present.
///
/// @return An array of button states, or null if the joystick is not present.
///
/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
///
/// @pointer_lifetime The returned array is allocated and freed by GLFW. You should not free it
/// yourself. It is valid until the specified joystick is disconnected or the library is terminated.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: joystick_button
pub inline fn getButtons(self: Joystick) Error!?[]const u8 {
internal_debug.assertInitialized();
var count: c_int = undefined;
const buttons = c.glfwGetJoystickButtons(@enumToInt(self.jid), &count);
getError() catch |err| return switch (err) {
Error.PlatformError => err,
else => unreachable,
};
if (buttons == null) return null;
return buttons[0..@intCast(usize, count)];
}
/// Returns the state of all hats of the specified joystick.
///
/// This function returns the state of all hats of the specified joystick. Each element in the array
/// is one of the following values:
///
/// | Name | Value |
/// |---------------------------|---------------------------------------------|
/// | `glfw.RawHats.centered` | 0 |
/// | `glfw.RawHats.up` | 1 |
/// | `glfw.RawHats.right` | 2 |
/// | `glfw.RawHats.down` | 4 |
/// | `glfw.RawHats.left` | 8 |
/// | `glfw.RawHats.right_up` | `glfw.RawHats.right` \| `glfw.RawHats.up` |
/// | `glfw.RawHats.right_down` | `glfw.RawHats.right` \| `glfw.RawHats.down` |
/// | `glfw.RawHats.left_up` | `glfw.RawHats.left` \| `glfw.RawHats.up` |
/// | `glfw.RawHats.left_down` | `glfw.RawHats.left` \| `glfw.RawHats.down` |
///
/// The diagonal directions are bitwise combinations of the primary (up, right, down and left)
/// directions, since the Zig GLFW wrapper returns a packed struct it is trivial to test for these:
///
/// ```
/// if (hats.up and hats.right) {
/// // up-right!
/// }
/// ```
///
/// If the specified joystick is not present this function will return null but will not generate an
/// error. This can be used instead of first calling glfw.Joystick.present.
///
/// @return An array of hat states, or null if the joystick is not present.
///
/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
///
/// @pointer_lifetime The returned array is allocated and freed by GLFW. You should not free it
/// yourself. It is valid until the specified joystick is disconnected, this function is called
/// again for that joystick or the library is terminated.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: joystick_hat
pub inline fn getHats(self: Joystick) Error!?[]const Hat {
internal_debug.assertInitialized();
var count: c_int = undefined;
const hats = c.glfwGetJoystickHats(@enumToInt(self.jid), &count);
getError() catch |err| return switch (err) {
Error.PlatformError => err,
else => unreachable,
};
if (hats == null) return null;
const slice = hats[0..@intCast(usize, count)];
return @ptrCast(*const []const Hat, &slice).*;
}
/// Returns the name of the specified joystick.
///
/// This function returns the name, encoded as UTF-8, of the specified joystick. The returned string
/// is allocated and freed by GLFW. You should not free it yourself.
///
/// If the specified joystick is not present this function will return null but will not generate an
/// error. This can be used instead of first calling glfw.Joystick.present.
///
/// @return The UTF-8 encoded name of the joystick, or null if the joystick is not present or an
/// error occurred.
///
/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
///
/// @pointer_lifetime The returned string is allocated and freed by GLFW. You should not free it
/// yourself. It is valid until the specified joystick is disconnected or the library is terminated.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: joystick_name
pub inline fn getName(self: Joystick) Error!?[:0]const u8 {
internal_debug.assertInitialized();
const name_opt = c.glfwGetJoystickName(@enumToInt(self.jid));
getError() catch |err| return switch (err) {
Error.PlatformError => err,
else => unreachable,
};
return if (name_opt) |name|
std.mem.span(name)
else
null;
}
/// Returns the SDL compatible GUID of the specified joystick.
///
/// This function returns the SDL compatible GUID, as a UTF-8 encoded hexadecimal string, of the
/// specified joystick. The returned string is allocated and freed by GLFW. You should not free it
/// yourself.
///
/// The GUID is what connects a joystick to a gamepad mapping. A connected joystick will always have
/// a GUID even if there is no gamepad mapping assigned to it.
///
/// If the specified joystick is not present this function will return null but will not generate an
/// error. This can be used instead of first calling glfw.Joystick.present.
///
/// The GUID uses the format introduced in SDL 2.0.5. This GUID tries to uniquely identify the make
/// and model of a joystick but does not identify a specific unit, e.g. all wired Xbox 360
/// controllers will have the same GUID on that platform. The GUID for a unit may vary between
/// platforms depending on what hardware information the platform specific APIs provide.
///
/// @return The UTF-8 encoded GUID of the joystick, or null if the joystick is not present.
///
/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
///
/// @pointer_lifetime The returned string is allocated and freed by GLFW. You should not free it
/// yourself. It is valid until the specified joystick is disconnected or the library is terminated.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: gamepad
pub inline fn getGUID(self: Joystick) Error!?[:0]const u8 {
internal_debug.assertInitialized();
const guid_opt = c.glfwGetJoystickGUID(@enumToInt(self.jid));
getError() catch |err| return switch (err) {
Error.PlatformError => err,
else => unreachable,
};
return if (guid_opt) |guid|
std.mem.span(guid)
else
null;
}
/// Sets the user pointer of the specified joystick.
///
/// This function sets the user-defined pointer of the specified joystick. The current value is
/// retained until the joystick is disconnected. The initial value is null.
///
/// This function may be called from the joystick callback, even for a joystick that is being disconnected.
///
/// @thread_safety This function may be called from any thread. Access is not synchronized.
///
/// see also: joystick_userptr, glfw.Joystick.getUserPointer
pub inline fn setUserPointer(self: Joystick, comptime T: type, pointer: *T) void {
internal_debug.assertInitialized();
c.glfwSetJoystickUserPointer(@enumToInt(self.jid), @ptrCast(*c_void, pointer));
getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible
}
/// Returns the user pointer of the specified joystick.
///
/// This function returns the current value of the user-defined pointer of the specified joystick.
/// The initial value is null.
///
/// This function may be called from the joystick callback, even for a joystick that is being
/// disconnected.
///
/// @thread_safety This function may be called from any thread. Access is not synchronized.
///
/// see also: joystick_userptr, glfw.Joystick.setUserPointer
pub inline fn getUserPointer(self: Joystick, comptime PointerType: type) ?PointerType {
internal_debug.assertInitialized();
const ptr = c.glfwGetJoystickUserPointer(@enumToInt(self.jid));
getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible
if (ptr) |p| return @ptrCast(PointerType, @alignCast(@alignOf(std.meta.Child(PointerType)), p));
return null;
}
/// Describes an event relating to a joystick.
pub const Event = enum(c_int) {
/// The device was connected.
connected = c.GLFW_CONNECTED,
/// The device was disconnected.
disconnected = c.GLFW_DISCONNECTED,
};
var _callback: ?fn (joystick: Joystick, event: Event) void = null;
fn callbackWrapper(jid: c_int, event: c_int) callconv(.C) void {
_callback.?(Joystick{ .jid = @intToEnum(Joystick.Id, jid) }, @intToEnum(Event, event));
}
/// Sets the joystick configuration callback.
///
/// This function sets the joystick configuration callback, or removes the currently set callback.
/// This is called when a joystick is connected to or disconnected from the system.
///
/// For joystick connection and disconnection events to be delivered on all platforms, you need to
/// call one of the event processing (see events) functions. Joystick disconnection may also be
/// detected and the callback called by joystick functions. The function will then return whatever
/// it returns if the joystick is not present.
///
/// @param[in] callback The new callback, or null to remove the currently set callback.
///
/// @callback_param `jid` The joystick that was connected or disconnected.
/// @callback_param `event` One of `.connected` or `.disconnected`. Future releases may add
/// more events.
///
/// Possible errors include glfw.Error.NotInitialized.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: joystick_event
pub inline fn setCallback(callback: ?fn (joystick: Joystick, event: Event) void) void {
internal_debug.assertInitialized();
_callback = callback;
_ = if (_callback != null) c.glfwSetJoystickCallback(callbackWrapper) else c.glfwSetJoystickCallback(null);
getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible
}
/// Adds the specified SDL_GameControllerDB gamepad mappings.
///
/// This function parses the specified ASCII encoded string and updates the internal list with any
/// gamepad mappings it finds. This string may contain either a single gamepad mapping or many
/// mappings separated by newlines. The parser supports the full format of the `gamecontrollerdb.txt`
/// source file including empty lines and comments.
///
/// See gamepad_mapping for a description of the format.
///
/// If there is already a gamepad mapping for a given GUID in the internal list, it will be
/// replaced by the one passed to this function. If the library is terminated and re-initialized
/// the internal list will revert to the built-in default.
///
/// @param[in] string The string containing the gamepad mappings.
///
/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidValue.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: gamepad, glfw.Joystick.isGamepad, glfwGetGamepadName
///
///
/// @ingroup input
pub inline fn updateGamepadMappings(gamepad_mappings: [*:0]const u8) Error!void {
internal_debug.assertInitialized();
_ = c.glfwUpdateGamepadMappings(gamepad_mappings);
getError() catch |err| return switch (err) {
Error.InvalidValue => err, // TODO: Evaluate if this is preventable, or if this is like a parsing error which should definitely be returned
else => unreachable,
};
}
/// Returns whether the specified joystick has a gamepad mapping.
///
/// This function returns whether the specified joystick is both present and has a gamepad mapping.
///
/// If the specified joystick is present but does not have a gamepad mapping this function will
/// return `false` but will not generate an error. Call glfw.Joystick.present to check if a
/// joystick is present regardless of whether it has a mapping.
///
/// @return `true` if a joystick is both present and has a gamepad mapping, or `false` otherwise.
///
/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidEnum.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: gamepad, glfw.Joystick.getGamepadState
pub inline fn isGamepad(self: Joystick) bool {
internal_debug.assertInitialized();
const is_gamepad = c.glfwJoystickIsGamepad(@enumToInt(self.jid));
getError() catch unreachable;
return is_gamepad == c.GLFW_TRUE;
}
/// Returns the human-readable gamepad name for the specified joystick.
///
/// This function returns the human-readable name of the gamepad from the gamepad mapping assigned
/// to the specified joystick.
///
/// If the specified joystick is not present or does not have a gamepad mapping this function will
/// return null, not an error. Call glfw.Joystick.present to check whether it is
/// present regardless of whether it has a mapping.
///
/// @return The UTF-8 encoded name of the gamepad, or null if the joystick is not present or does
/// not have a mapping.
///
/// @pointer_lifetime The returned string is allocated and freed by GLFW. You should not free it
/// yourself. It is valid until the specified joystick is disconnected, the gamepad mappings are
/// updated or the library is terminated.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: gamepad, glfw.Joystick.isGamepad
pub inline fn getGamepadName(self: Joystick) Error!?[:0]const u8 {
internal_debug.assertInitialized();
const name_opt = c.glfwGetGamepadName(@enumToInt(self.jid));
getError() catch |err| return switch (err) {
else => unreachable,
};
return if (name_opt) |name|
std.mem.span(name)
else
null;
}
/// Retrieves the state of the joystick remapped as a gamepad.
///
/// This function retrieves the state of the joystick remapped to an Xbox-like gamepad.
///
/// If the specified joystick is not present or does not have a gamepad mapping this function will
/// return `false`. Call glfw.joystickPresent to check whether it is present regardless of whether
/// it has a mapping.
///
/// The Guide button may not be available for input as it is often hooked by the system or the
/// Steam client.
///
/// Not all devices have all the buttons or axes provided by GamepadState. Unavailable buttons
/// and axes will always report `glfw.Action.release` and 0.0 respectively.
///
/// @param[in] jid The joystick (see joysticks) to query.
/// @param[out] state The gamepad input state of the joystick.
/// @return the gamepad input state if successful, or null if no joystick is connected or it has no
/// gamepad mapping.
///
/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidEnum.
///
/// @thread_safety This function must only be called from the main thread.
///
/// see also: gamepad, glfw.UpdateGamepadMappings, glfw.Joystick.isGamepad
pub inline fn getGamepadState(self: Joystick) ?GamepadState {
internal_debug.assertInitialized();
var state: GamepadState = undefined;
const success = c.glfwGetGamepadState(@enumToInt(self.jid), @ptrCast(*c.GLFWgamepadstate, &state));
getError() catch unreachable;
return if (success == c.GLFW_TRUE) state else null;
}
test "present" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.present() catch |err| std.debug.print("failed to detect joystick, joysticks not supported? error={}\n", .{err});
}
test "getAxes" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.getAxes() catch |err| std.debug.print("failed to get joystick axes, joysticks not supported? error={}\n", .{err});
}
test "getButtons" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.getButtons() catch |err| std.debug.print("failed to get joystick buttons, joysticks not supported? error={}\n", .{err});
}
test "getHats" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.getHats() catch |err| std.debug.print("failed to get joystick hats, joysticks not supported? error={}\n", .{err});
const hats = std.mem.zeroes(Hat);
if (hats.down and hats.up) {
// down-up!
}
}
test "getName" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.getName() catch |err| std.debug.print("failed to get joystick name, joysticks not supported? error={}\n", .{err});
}
test "getGUID" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.getGUID() catch |err| std.debug.print("failed to get joystick GUID, joysticks not supported? error={}\n", .{err});
}
test "setUserPointer_syntax" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
// Must be called from joystick callback, we cannot test it.
_ = joystick.setUserPointer;
}
test "getUserPointer_syntax" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
// Must be called from joystick callback, we cannot test it.
_ = joystick.getUserPointer;
}
test "setCallback" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
glfw.Joystick.setCallback((struct {
pub fn callback(joystick: Joystick, event: Event) void {
_ = joystick;
_ = event;
}
}).callback);
}
test "updateGamepadMappings_syntax" {
// We don't have a gamepad mapping to test with, just confirm the syntax is good.
_ = updateGamepadMappings;
}
test "isGamepad" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.isGamepad();
}
test "getGamepadName" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.getGamepadName() catch |err| std.debug.print("failed to get gamepad name, joysticks not supported? error={}\n", .{err});
}
test "getGamepadState" {
const glfw = @import("main.zig");
try glfw.init(.{});
defer glfw.terminate();
const joystick = glfw.Joystick{ .jid = .one };
_ = joystick.getGamepadState();
_ = (std.mem.zeroes(GamepadState)).getAxis(.left_x);
_ = (std.mem.zeroes(GamepadState)).getButton(.dpad_up);
} | glfw/src/Joystick.zig |
const SDL = @import("sdl.zig");
const c = @import("../binding/sdl.zig");
const std = @import("std");
pub const Context = struct {
ptr: c.SDL_GLContext,
};
pub fn createContext(window: SDL.Window) !Context {
return Context{
.ptr = c.SDL_GL_CreateContext(window.ptr) orelse return SDL.makeError(),
};
}
pub fn makeCurrent(context: Context, window: SDL.Window) !void {
if (c.SDL_GL_MakeCurrent(window.ptr, context.ptr) != 0) {
return SDL.makeError();
}
}
pub fn deleteContext(context: Context) void {
_ = c.SDL_GL_DeleteContext(context.ptr);
}
pub const SwapInterval = enum {
immediate, // immediate updates
vsync, // updates synchronized with the vertical retrace
adaptive_vsync, // same as vsync, but if a frame is missed swaps buffers immediately
};
pub fn setSwapInterval(interval: SwapInterval) !void {
if (c.SDL_GL_SetSwapInterval(switch (interval) {
.immediate => 0,
.vsync => 1,
.adaptive_vsync => -1,
}) != 0) {
return SDL.makeError();
}
}
pub fn swapWindow(window: SDL.Window) void {
c.SDL_GL_SwapWindow(window.ptr);
}
fn attribValueToInt(value: anytype) c_int {
return switch (@TypeOf(value)) {
usize => @intCast(c_int, value),
bool => if (value) @as(c_int, 1) else 0,
ContextFlags => blk: {
var result: c_int = 0;
if (value.debug) {
result |= c.SDL_GL_CONTEXT_DEBUG_FLAG;
}
if (value.forward_compatible) {
result |= c.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG;
}
if (value.robust_access) {
result |= c.SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG;
}
if (value.reset_isolation) {
result |= c.SDL_GL_CONTEXT_RESET_ISOLATION_FLAG;
}
break :blk result;
},
Profile, ReleaseBehaviour => @enumToInt(value),
else => @compileError("Unsupported type for sdl.gl.Attribute"),
};
}
pub fn setAttribute(attrib: Attribute) !void {
inline for (std.meta.fields(Attribute)) |fld| {
if (attrib == @field(AttributeName, fld.name)) {
const res = c.SDL_GL_SetAttribute(
@intToEnum(c.SDL_GLattr, @enumToInt(attrib)),
attribValueToInt(@field(attrib, fld.name)),
);
if (res != 0) {
return SDL.makeError();
} else {
return;
}
}
}
unreachable;
}
pub const Attribute = union(AttributeName) {
red_size: usize,
green_size: usize,
blue_size: usize,
alpha_size: usize,
buffer_size: usize,
doublebuffer: usize,
depth_size: usize,
stencil_size: usize,
accum_red_size: usize,
accum_green_size: usize,
accum_blue_size: usize,
accum_alpha_size: usize,
stereo: usize,
multisamplebuffers: bool,
multisamplesamples: usize,
accelerated_visual: bool,
context_major_version: usize,
context_minor_version: usize,
context_flags: ContextFlags,
context_profile_mask: Profile,
share_with_current_context: usize,
framebuffer_srgb_capable: bool,
context_release_behavior: ReleaseBehaviour,
};
pub const AttributeName = enum(c_int) {
red_size = c.SDL_GL_RED_SIZE,
green_size = c.SDL_GL_GREEN_SIZE,
blue_size = c.SDL_GL_BLUE_SIZE,
alpha_size = c.SDL_GL_ALPHA_SIZE,
buffer_size = c.SDL_GL_BUFFER_SIZE,
doublebuffer = c.SDL_GL_DOUBLEBUFFER,
depth_size = c.SDL_GL_DEPTH_SIZE,
stencil_size = c.SDL_GL_STENCIL_SIZE,
accum_red_size = c.SDL_GL_ACCUM_RED_SIZE,
accum_green_size = c.SDL_GL_ACCUM_GREEN_SIZE,
accum_blue_size = c.SDL_GL_ACCUM_BLUE_SIZE,
accum_alpha_size = c.SDL_GL_ACCUM_ALPHA_SIZE,
stereo = c.SDL_GL_STEREO,
multisamplebuffers = c.SDL_GL_MULTISAMPLEBUFFERS,
multisamplesamples = c.SDL_GL_MULTISAMPLESAMPLES,
accelerated_visual = c.SDL_GL_ACCELERATED_VISUAL,
context_major_version = c.SDL_GL_CONTEXT_MAJOR_VERSION,
context_minor_version = c.SDL_GL_CONTEXT_MINOR_VERSION,
context_flags = c.SDL_GL_CONTEXT_FLAGS,
context_profile_mask = c.SDL_GL_CONTEXT_PROFILE_MASK,
share_with_current_context = c.SDL_GL_SHARE_WITH_CURRENT_CONTEXT,
framebuffer_srgb_capable = c.SDL_GL_FRAMEBUFFER_SRGB_CAPABLE,
context_release_behavior = c.SDL_GL_CONTEXT_RELEASE_BEHAVIOR,
};
pub const ContextFlags = struct {
debug: bool = false,
forward_compatible: bool = false,
robust_access: bool = false,
reset_isolation: bool = false,
};
pub const Profile = enum(c_int) {
core = c.SDL_GL_CONTEXT_PROFILE_CORE,
compatibility = c.SDL_GL_CONTEXT_PROFILE_COMPATIBILITY,
es = c.SDL_GL_CONTEXT_PROFILE_ES,
};
pub const ReleaseBehaviour = enum(c_int) {
none = c.SDL_GL_CONTEXT_RELEASE_BEHAVIOR_NONE,
flush = c.SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH,
}; | src/wrapper/gl.zig |
const std = @import("std");
const vk = @import("vulkan");
const GraphicsContext = @import("graphics_context.zig").GraphicsContext;
const Allocator = std.mem.Allocator;
pub const Swapchain = struct {
pub const PresentState = enum {
optimal,
suboptimal,
};
gc: *const GraphicsContext,
allocator: Allocator,
surface_format: vk.SurfaceFormatKHR,
present_mode: vk.PresentModeKHR,
extent: vk.Extent2D,
handle: vk.SwapchainKHR,
swap_images: []SwapImage,
image_index: u32,
next_image_acquired: vk.Semaphore,
pub fn init(gc: *const GraphicsContext, allocator: Allocator, extent: vk.Extent2D) !Swapchain {
return try initRecycle(gc, allocator, extent, .null_handle);
}
pub fn initRecycle(gc: *const GraphicsContext, allocator: Allocator, extent: vk.Extent2D, old_handle: vk.SwapchainKHR) !Swapchain {
const caps = try gc.vki.getPhysicalDeviceSurfaceCapabilitiesKHR(gc.pdev, gc.surface);
const actual_extent = findActualExtent(caps, extent);
if (actual_extent.width == 0 or actual_extent.height == 0) {
return error.InvalidSurfaceDimensions;
}
const surface_format = try findSurfaceFormat(gc, allocator);
const present_mode = try findPresentMode(gc, allocator);
var image_count = caps.min_image_count + 1;
if (caps.max_image_count > 0) {
image_count = std.math.min(image_count, caps.max_image_count);
}
const qfi = [_]u32{ gc.graphics_queue.family, gc.present_queue.family };
const sharing_mode: vk.SharingMode = if (gc.graphics_queue.family != gc.present_queue.family)
.concurrent
else
.exclusive;
const handle = try gc.vkd.createSwapchainKHR(gc.dev, &.{
.flags = .{},
.surface = gc.surface,
.min_image_count = image_count,
.image_format = surface_format.format,
.image_color_space = surface_format.color_space,
.image_extent = actual_extent,
.image_array_layers = 1,
.image_usage = .{ .color_attachment_bit = true, .transfer_dst_bit = true },
.image_sharing_mode = sharing_mode,
.queue_family_index_count = qfi.len,
.p_queue_family_indices = &qfi,
.pre_transform = caps.current_transform,
.composite_alpha = .{ .opaque_bit_khr = true },
.present_mode = present_mode,
.clipped = vk.TRUE,
.old_swapchain = old_handle,
}, null);
errdefer gc.vkd.destroySwapchainKHR(gc.dev, handle, null);
if (old_handle != .null_handle) {
// Apparently, the old swapchain handle still needs to be destroyed after recreating.
gc.vkd.destroySwapchainKHR(gc.dev, old_handle, null);
}
const swap_images = try initSwapchainImages(gc, handle, surface_format.format, allocator);
errdefer for (swap_images) |si| si.deinit(gc);
var next_image_acquired = try gc.vkd.createSemaphore(gc.dev, &.{ .flags = .{} }, null);
errdefer gc.vkd.destroySemaphore(gc.dev, next_image_acquired, null);
const result = try gc.vkd.acquireNextImageKHR(gc.dev, handle, std.math.maxInt(u64), next_image_acquired, .null_handle);
if (result.result != .success) {
return error.ImageAcquireFailed;
}
std.mem.swap(vk.Semaphore, &swap_images[result.image_index].image_acquired, &next_image_acquired);
return Swapchain{
.gc = gc,
.allocator = allocator,
.surface_format = surface_format,
.present_mode = present_mode,
.extent = actual_extent,
.handle = handle,
.swap_images = swap_images,
.image_index = result.image_index,
.next_image_acquired = next_image_acquired,
};
}
fn deinitExceptSwapchain(self: Swapchain) void {
for (self.swap_images) |si| si.deinit(self.gc);
self.gc.vkd.destroySemaphore(self.gc.dev, self.next_image_acquired, null);
}
pub fn waitForAllFences(self: Swapchain) !void {
for (self.swap_images) |si| si.waitForFence(self.gc) catch {};
}
pub fn deinit(self: Swapchain) void {
self.deinitExceptSwapchain();
self.gc.vkd.destroySwapchainKHR(self.gc.dev, self.handle, null);
}
pub fn recreate(self: *Swapchain, new_extent: vk.Extent2D) !void {
const gc = self.gc;
const allocator = self.allocator;
const old_handle = self.handle;
self.deinitExceptSwapchain();
self.* = try initRecycle(gc, allocator, new_extent, old_handle);
}
pub fn currentImage(self: Swapchain) vk.Image {
return self.swap_images[self.image_index].image;
}
pub fn currentSwapImage(self: Swapchain) *const SwapImage {
return &self.swap_images[self.image_index];
}
pub fn present(self: *Swapchain, cmdbuf: vk.CommandBuffer) !PresentState {
// Simple method:
// 1) Acquire next image
// 2) Wait for and reset fence of the acquired image
// 3) Submit command buffer with fence of acquired image,
// dependendent on the semaphore signalled by the first step.
// 4) Present current frame, dependent on semaphore signalled by previous step
// Problem: This way we can't reference the current image while rendering.
// Better method: Shuffle the steps around such that acquire next image is the last step,
// leaving the swapchain in a state with the current image.
// 1) Wait for and reset fence of current image
// 2) Submit command buffer, signalling fence of current image and dependent on
// the semaphore signalled by step 4.
// 3) Present current frame, dependent on semaphore signalled by the submit
// 4) Acquire next image, signalling its semaphore
// One problem that arises is that we can't know beforehand which semaphore to signal,
// so we keep an extra auxilery semaphore that is swapped around
// Step 1: Make sure the current frame has finished rendering
const current = self.currentSwapImage();
try current.waitForFence(self.gc);
try self.gc.vkd.resetFences(self.gc.dev, 1, @ptrCast([*]const vk.Fence, ¤t.frame_fence));
// Step 2: Submit the command buffer
const wait_stage = [_]vk.PipelineStageFlags{.{ .top_of_pipe_bit = true }};
try self.gc.vkd.queueSubmit(self.gc.graphics_queue.handle, 1, &[_]vk.SubmitInfo{.{
.wait_semaphore_count = 1,
.p_wait_semaphores = @ptrCast([*]const vk.Semaphore, ¤t.image_acquired),
.p_wait_dst_stage_mask = &wait_stage,
.command_buffer_count = 1,
.p_command_buffers = @ptrCast([*]const vk.CommandBuffer, &cmdbuf),
.signal_semaphore_count = 1,
.p_signal_semaphores = @ptrCast([*]const vk.Semaphore, ¤t.render_finished),
}}, current.frame_fence);
// Step 3: Present the current frame
_ = try self.gc.vkd.queuePresentKHR(self.gc.present_queue.handle, &.{
.wait_semaphore_count = 1,
.p_wait_semaphores = @ptrCast([*]const vk.Semaphore, ¤t.render_finished),
.swapchain_count = 1,
.p_swapchains = @ptrCast([*]const vk.SwapchainKHR, &self.handle),
.p_image_indices = @ptrCast([*]const u32, &self.image_index),
.p_results = null,
});
// Step 4: Acquire next frame
const result = try self.gc.vkd.acquireNextImageKHR(
self.gc.dev,
self.handle,
std.math.maxInt(u64),
self.next_image_acquired,
.null_handle,
);
std.mem.swap(vk.Semaphore, &self.swap_images[result.image_index].image_acquired, &self.next_image_acquired);
self.image_index = result.image_index;
return switch (result.result) {
.success => .optimal,
.suboptimal_khr => .suboptimal,
else => unreachable,
};
}
};
const SwapImage = struct {
image: vk.Image,
view: vk.ImageView,
image_acquired: vk.Semaphore,
render_finished: vk.Semaphore,
frame_fence: vk.Fence,
fn init(gc: *const GraphicsContext, image: vk.Image, format: vk.Format) !SwapImage {
const view = try gc.vkd.createImageView(gc.dev, &.{
.flags = .{},
.image = image,
.view_type = .@"2d",
.format = format,
.components = .{ .r = .identity, .g = .identity, .b = .identity, .a = .identity },
.subresource_range = .{
.aspect_mask = .{ .color_bit = true },
.base_mip_level = 0,
.level_count = 1,
.base_array_layer = 0,
.layer_count = 1,
},
}, null);
errdefer gc.vkd.destroyImageView(gc.dev, view, null);
const image_acquired = try gc.vkd.createSemaphore(gc.dev, &.{ .flags = .{} }, null);
errdefer gc.vkd.destroySemaphore(gc.dev, image_acquired, null);
const render_finished = try gc.vkd.createSemaphore(gc.dev, &.{ .flags = .{} }, null);
errdefer gc.vkd.destroySemaphore(gc.dev, image_acquired, null);
const frame_fence = try gc.vkd.createFence(gc.dev, &.{ .flags = .{ .signaled_bit = true } }, null);
errdefer gc.vkd.destroyFence(gc.dev, frame_fence, null);
return SwapImage{
.image = image,
.view = view,
.image_acquired = image_acquired,
.render_finished = render_finished,
.frame_fence = frame_fence,
};
}
fn deinit(self: SwapImage, gc: *const GraphicsContext) void {
self.waitForFence(gc) catch return;
gc.vkd.destroyImageView(gc.dev, self.view, null);
gc.vkd.destroySemaphore(gc.dev, self.image_acquired, null);
gc.vkd.destroySemaphore(gc.dev, self.render_finished, null);
gc.vkd.destroyFence(gc.dev, self.frame_fence, null);
}
fn waitForFence(self: SwapImage, gc: *const GraphicsContext) !void {
_ = try gc.vkd.waitForFences(gc.dev, 1, @ptrCast([*]const vk.Fence, &self.frame_fence), vk.TRUE, std.math.maxInt(u64));
}
};
fn initSwapchainImages(gc: *const GraphicsContext, swapchain: vk.SwapchainKHR, format: vk.Format, allocator: Allocator) ![]SwapImage {
var count: u32 = undefined;
_ = try gc.vkd.getSwapchainImagesKHR(gc.dev, swapchain, &count, null);
const images = try allocator.alloc(vk.Image, count);
defer allocator.free(images);
_ = try gc.vkd.getSwapchainImagesKHR(gc.dev, swapchain, &count, images.ptr);
const swap_images = try allocator.alloc(SwapImage, count);
errdefer allocator.free(swap_images);
var i: usize = 0;
errdefer for (swap_images[0..i]) |si| si.deinit(gc);
for (images) |image| {
swap_images[i] = try SwapImage.init(gc, image, format);
i += 1;
}
return swap_images;
}
fn findSurfaceFormat(gc: *const GraphicsContext, allocator: Allocator) !vk.SurfaceFormatKHR {
const preferred = vk.SurfaceFormatKHR{
.format = .b8g8r8a8_srgb,
.color_space = .srgb_nonlinear_khr,
};
var count: u32 = undefined;
_ = try gc.vki.getPhysicalDeviceSurfaceFormatsKHR(gc.pdev, gc.surface, &count, null);
const surface_formats = try allocator.alloc(vk.SurfaceFormatKHR, count);
defer allocator.free(surface_formats);
_ = try gc.vki.getPhysicalDeviceSurfaceFormatsKHR(gc.pdev, gc.surface, &count, surface_formats.ptr);
for (surface_formats) |sfmt| {
if (std.meta.eql(sfmt, preferred)) {
return preferred;
}
}
return surface_formats[0]; // There must always be at least one supported surface format
}
fn findPresentMode(gc: *const GraphicsContext, allocator: Allocator) !vk.PresentModeKHR {
var count: u32 = undefined;
_ = try gc.vki.getPhysicalDeviceSurfacePresentModesKHR(gc.pdev, gc.surface, &count, null);
const present_modes = try allocator.alloc(vk.PresentModeKHR, count);
defer allocator.free(present_modes);
_ = try gc.vki.getPhysicalDeviceSurfacePresentModesKHR(gc.pdev, gc.surface, &count, present_modes.ptr);
const preferred = [_]vk.PresentModeKHR{
.mailbox_khr,
.immediate_khr,
};
for (preferred) |mode| {
if (std.mem.indexOfScalar(vk.PresentModeKHR, present_modes, mode) != null) {
return mode;
}
}
return .fifo_khr;
}
fn findActualExtent(caps: vk.SurfaceCapabilitiesKHR, extent: vk.Extent2D) vk.Extent2D {
if (caps.current_extent.width != 0xFFFF_FFFF) {
return caps.current_extent;
} else {
return .{
.width = std.math.clamp(extent.width, caps.min_image_extent.width, caps.max_image_extent.width),
.height = std.math.clamp(extent.height, caps.min_image_extent.height, caps.max_image_extent.height),
};
}
} | examples/swapchain.zig |
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
pub fn Pkg(pkgdir: []const u8) type {
return struct {
var ran_git = false;
pub fn link(exe: *LibExeObjStep, system_lib: bool) void {
if (system_lib) {
exe.linkSystemLibrary("raylib");
return;
}
const raylibFlags = &[_][]const u8{
"-std=c99",
"-DPLATFORM_DESKTOP",
"-D_POSIX_C_SOURCE",
"-DGL_SILENCE_DEPRECATION",
};
const target_os = exe.target.toTarget().os.tag;
switch (target_os) {
.windows => {
exe.linkSystemLibrary("winmm");
exe.linkSystemLibrary("gdi32");
exe.linkSystemLibrary("opengl32");
// build vendored glfw as well
exe.addIncludeDir(pkgdir ++ "/raylib/src/external/glfw/include");
exe.addIncludeDir(pkgdir ++ "/raylib/src/external/glfw/deps/mingw");
exe.addCSourceFile(pkgdir ++ "/raylib/src/rglfw.c", raylibFlags);
},
.macos => {
std.debug.warn("Compiling raylib is unsupported on macOS. Please add '-Dsystem-raylib=true' to your build command to use your system raylib.\n", .{});
std.os.exit(1);
},
.freebsd, .openbsd, .netbsd, .dragonfly => {
exe.linkSystemLibrary("glfw");
exe.linkSystemLibrary("GL");
exe.linkSystemLibrary("rt");
exe.linkSystemLibrary("dl");
exe.linkSystemLibrary("m");
exe.linkSystemLibrary("X11");
exe.linkSystemLibrary("Xrandr");
exe.linkSystemLibrary("Xinerama");
exe.linkSystemLibrary("Xi");
exe.linkSystemLibrary("Xxf86vm");
exe.linkSystemLibrary("Xcursor");
},
else => { // linux and possibly others
exe.linkSystemLibrary("glfw");
exe.linkSystemLibrary("GL");
exe.linkSystemLibrary("rt");
exe.linkSystemLibrary("dl");
exe.linkSystemLibrary("m");
exe.linkSystemLibrary("X11");
},
}
exe.linkLibC();
fetchSubmodules(exe.builder) catch
std.debug.warn(
\\Warning:
\\Unable to fetch git submodule(s) Assuming package folder is not under
\\version control. If build fails, this is probably why.
, .{});
exe.addIncludeDir(pkgdir ++ "/raylib/src");
exe.addCSourceFile(pkgdir ++ "/raylib/src/core.c", raylibFlags);
exe.addCSourceFile(pkgdir ++ "/raylib/src/models.c", raylibFlags);
exe.addCSourceFile(pkgdir ++ "/raylib/src/raudio.c", raylibFlags);
exe.addCSourceFile(pkgdir ++ "/raylib/src/shapes.c", raylibFlags);
exe.addCSourceFile(pkgdir ++ "/raylib/src/text.c", raylibFlags);
exe.addCSourceFile(pkgdir ++ "/raylib/src/textures.c", raylibFlags);
exe.addCSourceFile(pkgdir ++ "/raylib/src/utils.c", raylibFlags);
}
fn fetchSubmodules(b: *Builder) !void {
if (ran_git) return;
ran_git = true;
std.debug.warn("attempting to fetch submodule(s)...\n", .{});
const git_proc = std.ChildProcess.init(
&[_][]const u8{ "git", "submodule", "update", "--init" },
b.allocator,
) catch {
std.debug.warn("unable to create child process for git. build interrupted\n", .{});
std.os.exit(1);
};
git_proc.cwd = pkgdir;
const term = git_proc.spawnAndWait() catch {
std.debug.warn("unable to spawn child process for git. build interrupted\n", .{});
std.os.exit(1);
};
switch (term) {
.Exited => |code| if (code != 0) return error.GitFail,
else => {
std.debug.warn("git terminated unexpectedly. build interrupted\n", .{});
std.os.exit(1);
},
}
}
pub fn addAsPackage(name: []const u8, to: *LibExeObjStep) void {
to.addPackagePath(name, pkgdir ++ "/lib/raylib-zig.zig");
}
pub const math = struct {
pub fn addAsPackage(name: []const u8, to: *LibExeObjStep) void {
to.addPackagePath(name, pkgdir ++ "/lib/raylib-zig-math.zig");
}
};
};
} | lib.zig |
pub const WINML_TENSOR_DIMENSION_COUNT_MAX = @as(u32, 4);
//--------------------------------------------------------------------------------
// Section: Types (47)
//--------------------------------------------------------------------------------
pub const WINML_TENSOR_DATA_TYPE = enum(i32) {
UNDEFINED = 0,
FLOAT = 1,
UINT8 = 2,
INT8 = 3,
UINT16 = 4,
INT16 = 5,
INT32 = 6,
INT64 = 7,
STRING = 8,
BOOLEAN = 9,
FLOAT16 = 10,
DOUBLE = 11,
UINT32 = 12,
UINT64 = 13,
COMPLEX64 = 14,
COMPLEX128 = 15,
};
pub const WINML_TENSOR_UNDEFINED = WINML_TENSOR_DATA_TYPE.UNDEFINED;
pub const WINML_TENSOR_FLOAT = WINML_TENSOR_DATA_TYPE.FLOAT;
pub const WINML_TENSOR_UINT8 = WINML_TENSOR_DATA_TYPE.UINT8;
pub const WINML_TENSOR_INT8 = WINML_TENSOR_DATA_TYPE.INT8;
pub const WINML_TENSOR_UINT16 = WINML_TENSOR_DATA_TYPE.UINT16;
pub const WINML_TENSOR_INT16 = WINML_TENSOR_DATA_TYPE.INT16;
pub const WINML_TENSOR_INT32 = WINML_TENSOR_DATA_TYPE.INT32;
pub const WINML_TENSOR_INT64 = WINML_TENSOR_DATA_TYPE.INT64;
pub const WINML_TENSOR_STRING = WINML_TENSOR_DATA_TYPE.STRING;
pub const WINML_TENSOR_BOOLEAN = WINML_TENSOR_DATA_TYPE.BOOLEAN;
pub const WINML_TENSOR_FLOAT16 = WINML_TENSOR_DATA_TYPE.FLOAT16;
pub const WINML_TENSOR_DOUBLE = WINML_TENSOR_DATA_TYPE.DOUBLE;
pub const WINML_TENSOR_UINT32 = WINML_TENSOR_DATA_TYPE.UINT32;
pub const WINML_TENSOR_UINT64 = WINML_TENSOR_DATA_TYPE.UINT64;
pub const WINML_TENSOR_COMPLEX64 = WINML_TENSOR_DATA_TYPE.COMPLEX64;
pub const WINML_TENSOR_COMPLEX128 = WINML_TENSOR_DATA_TYPE.COMPLEX128;
pub const WINML_FEATURE_TYPE = enum(i32) {
UNDEFINED = 0,
TENSOR = 1,
SEQUENCE = 2,
MAP = 3,
IMAGE = 4,
};
pub const WINML_FEATURE_UNDEFINED = WINML_FEATURE_TYPE.UNDEFINED;
pub const WINML_FEATURE_TENSOR = WINML_FEATURE_TYPE.TENSOR;
pub const WINML_FEATURE_SEQUENCE = WINML_FEATURE_TYPE.SEQUENCE;
pub const WINML_FEATURE_MAP = WINML_FEATURE_TYPE.MAP;
pub const WINML_FEATURE_IMAGE = WINML_FEATURE_TYPE.IMAGE;
pub const WINML_BINDING_TYPE = enum(i32) {
UNDEFINED = 0,
TENSOR = 1,
SEQUENCE = 2,
MAP = 3,
IMAGE = 4,
RESOURCE = 5,
};
pub const WINML_BINDING_UNDEFINED = WINML_BINDING_TYPE.UNDEFINED;
pub const WINML_BINDING_TENSOR = WINML_BINDING_TYPE.TENSOR;
pub const WINML_BINDING_SEQUENCE = WINML_BINDING_TYPE.SEQUENCE;
pub const WINML_BINDING_MAP = WINML_BINDING_TYPE.MAP;
pub const WINML_BINDING_IMAGE = WINML_BINDING_TYPE.IMAGE;
pub const WINML_BINDING_RESOURCE = WINML_BINDING_TYPE.RESOURCE;
pub const WINML_TENSOR_BINDING_DESC = extern struct {
DataType: WINML_TENSOR_DATA_TYPE,
NumDimensions: u32,
pShape: ?*i64,
DataSize: u32,
pData: ?*anyopaque,
};
pub const WINML_SEQUENCE_BINDING_DESC = extern struct {
ElementCount: u32,
ElementType: WINML_TENSOR_DATA_TYPE,
Anonymous: extern union {
pStrings: ?*?PWSTR,
pInts: ?*i64,
pFloats: ?*f32,
pDoubles: ?*f64,
},
};
pub const WINML_MAP_BINDING_DESC = extern struct {
ElementCount: u32,
KeyType: WINML_TENSOR_DATA_TYPE,
Anonymous1: extern union {
pStringKeys: ?*?PWSTR,
pIntKeys: ?*i64,
},
Fields: WINML_TENSOR_DATA_TYPE,
Anonymous2: extern union {
pStringFields: ?*?PWSTR,
pIntFields: ?*i64,
pFloatFields: ?*f32,
pDoubleFields: ?*f64,
},
};
pub const WINML_IMAGE_BINDING_DESC = extern struct {
ElementType: WINML_TENSOR_DATA_TYPE,
NumDimensions: u32,
pShape: ?*i64,
DataSize: u32,
pData: ?*anyopaque,
};
pub const WINML_RESOURCE_BINDING_DESC = extern struct {
ElementType: WINML_TENSOR_DATA_TYPE,
NumDimensions: u32,
pShape: ?*i64,
pResource: ?*ID3D12Resource,
};
pub const WINML_BINDING_DESC = extern struct {
Name: ?[*:0]const u16,
BindType: WINML_BINDING_TYPE,
Anonymous: extern union {
Tensor: WINML_TENSOR_BINDING_DESC,
Sequence: WINML_SEQUENCE_BINDING_DESC,
Map: WINML_MAP_BINDING_DESC,
Image: WINML_IMAGE_BINDING_DESC,
Resource: WINML_RESOURCE_BINDING_DESC,
},
};
pub const WINML_TENSOR_VARIABLE_DESC = extern struct {
ElementType: WINML_TENSOR_DATA_TYPE,
NumDimensions: u32,
pShape: ?*i64,
};
pub const WINML_SEQUENCE_VARIABLE_DESC = extern struct {
ElementType: WINML_TENSOR_DATA_TYPE,
};
pub const WINML_MAP_VARIABLE_DESC = extern struct {
KeyType: WINML_TENSOR_DATA_TYPE,
Fields: WINML_TENSOR_DATA_TYPE,
};
pub const WINML_IMAGE_VARIABLE_DESC = extern struct {
ElementType: WINML_TENSOR_DATA_TYPE,
NumDimensions: u32,
pShape: ?*i64,
};
pub const WINML_VARIABLE_DESC = extern struct {
Name: ?PWSTR,
Description: ?PWSTR,
FeatureType: WINML_FEATURE_TYPE,
Required: BOOL,
Anonymous: extern union {
Tensor: WINML_TENSOR_VARIABLE_DESC,
Sequence: WINML_SEQUENCE_VARIABLE_DESC,
Map: WINML_MAP_VARIABLE_DESC,
Image: WINML_IMAGE_VARIABLE_DESC,
},
};
pub const WINML_MODEL_DESC = extern struct {
Author: ?PWSTR,
Name: ?PWSTR,
Domain: ?PWSTR,
Description: ?PWSTR,
Version: usize,
};
// TODO: this type is limited to platform 'windows10.0.17134'
const IID_IWinMLModel_Value = Guid.initString("e2eeb6a9-f31f-4055-a521-e30b5b33664a");
pub const IID_IWinMLModel = &IID_IWinMLModel_Value;
pub const IWinMLModel = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDescription: fn(
self: *const IWinMLModel,
ppDescription: ?*?*WINML_MODEL_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumerateMetadata: fn(
self: *const IWinMLModel,
Index: u32,
pKey: ?*?PWSTR,
pValue: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumerateModelInputs: fn(
self: *const IWinMLModel,
Index: u32,
ppInputDescriptor: ?*?*WINML_VARIABLE_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumerateModelOutputs: fn(
self: *const IWinMLModel,
Index: u32,
ppOutputDescriptor: ?*?*WINML_VARIABLE_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLModel_GetDescription(self: *const T, ppDescription: ?*?*WINML_MODEL_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLModel.VTable, self.vtable).GetDescription(@ptrCast(*const IWinMLModel, self), ppDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLModel_EnumerateMetadata(self: *const T, Index: u32, pKey: ?*?PWSTR, pValue: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLModel.VTable, self.vtable).EnumerateMetadata(@ptrCast(*const IWinMLModel, self), Index, pKey, pValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLModel_EnumerateModelInputs(self: *const T, Index: u32, ppInputDescriptor: ?*?*WINML_VARIABLE_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLModel.VTable, self.vtable).EnumerateModelInputs(@ptrCast(*const IWinMLModel, self), Index, ppInputDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLModel_EnumerateModelOutputs(self: *const T, Index: u32, ppOutputDescriptor: ?*?*WINML_VARIABLE_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLModel.VTable, self.vtable).EnumerateModelOutputs(@ptrCast(*const IWinMLModel, self), Index, ppOutputDescriptor);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.17134'
const IID_IWinMLEvaluationContext_Value = Guid.initString("95848f9e-583d-4054-af12-916387cd8426");
pub const IID_IWinMLEvaluationContext = &IID_IWinMLEvaluationContext_Value;
pub const IWinMLEvaluationContext = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
BindValue: fn(
self: *const IWinMLEvaluationContext,
pDescriptor: ?*WINML_BINDING_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetValueByName: fn(
self: *const IWinMLEvaluationContext,
Name: ?[*:0]const u16,
pDescriptor: ?*?*WINML_BINDING_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clear: fn(
self: *const IWinMLEvaluationContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLEvaluationContext_BindValue(self: *const T, pDescriptor: ?*WINML_BINDING_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLEvaluationContext.VTable, self.vtable).BindValue(@ptrCast(*const IWinMLEvaluationContext, self), pDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLEvaluationContext_GetValueByName(self: *const T, Name: ?[*:0]const u16, pDescriptor: ?*?*WINML_BINDING_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLEvaluationContext.VTable, self.vtable).GetValueByName(@ptrCast(*const IWinMLEvaluationContext, self), Name, pDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLEvaluationContext_Clear(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLEvaluationContext.VTable, self.vtable).Clear(@ptrCast(*const IWinMLEvaluationContext, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.17134'
const IID_IWinMLRuntime_Value = Guid.initString("a0425329-40ae-48d9-bce3-829ef7b8a41a");
pub const IID_IWinMLRuntime = &IID_IWinMLRuntime_Value;
pub const IWinMLRuntime = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
LoadModel: fn(
self: *const IWinMLRuntime,
Path: ?[*:0]const u16,
ppModel: ?*?*IWinMLModel,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateEvaluationContext: fn(
self: *const IWinMLRuntime,
device: ?*ID3D12Device,
ppContext: ?*?*IWinMLEvaluationContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EvaluateModel: fn(
self: *const IWinMLRuntime,
pContext: ?*IWinMLEvaluationContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLRuntime_LoadModel(self: *const T, Path: ?[*:0]const u16, ppModel: ?*?*IWinMLModel) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLRuntime.VTable, self.vtable).LoadModel(@ptrCast(*const IWinMLRuntime, self), Path, ppModel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLRuntime_CreateEvaluationContext(self: *const T, device: ?*ID3D12Device, ppContext: ?*?*IWinMLEvaluationContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLRuntime.VTable, self.vtable).CreateEvaluationContext(@ptrCast(*const IWinMLRuntime, self), device, ppContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLRuntime_EvaluateModel(self: *const T, pContext: ?*IWinMLEvaluationContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLRuntime.VTable, self.vtable).EvaluateModel(@ptrCast(*const IWinMLRuntime, self), pContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WINML_RUNTIME_TYPE = enum(i32) {
K = 0,
};
pub const WINML_RUNTIME_CNTK = WINML_RUNTIME_TYPE.K;
// TODO: this type is limited to platform 'windows10.0.17134'
const IID_IWinMLRuntimeFactory_Value = Guid.initString("a807b84d-4ae5-4bc0-a76a-941aa246bd41");
pub const IID_IWinMLRuntimeFactory = &IID_IWinMLRuntimeFactory_Value;
pub const IWinMLRuntimeFactory = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
CreateRuntime: fn(
self: *const IWinMLRuntimeFactory,
RuntimeType: WINML_RUNTIME_TYPE,
ppRuntime: ?*?*IWinMLRuntime,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWinMLRuntimeFactory_CreateRuntime(self: *const T, RuntimeType: WINML_RUNTIME_TYPE, ppRuntime: ?*?*IWinMLRuntime) callconv(.Inline) HRESULT {
return @ptrCast(*const IWinMLRuntimeFactory.VTable, self.vtable).CreateRuntime(@ptrCast(*const IWinMLRuntimeFactory, self), RuntimeType, ppRuntime);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const MLOperatorAttributeType = enum(u32) {
Undefined = 0,
Float = 2,
Int = 3,
String = 4,
FloatArray = 7,
IntArray = 8,
StringArray = 9,
};
// NOTE: not creating aliases because this enum is 'Scoped'
pub const MLOperatorTensorDataType = enum(u32) {
Undefined = 0,
Float = 1,
UInt8 = 2,
Int8 = 3,
UInt16 = 4,
Int16 = 5,
Int32 = 6,
Int64 = 7,
String = 8,
Bool = 9,
Float16 = 10,
Double = 11,
UInt32 = 12,
UInt64 = 13,
Complex64 = 14,
Complex128 = 15,
};
// NOTE: not creating aliases because this enum is 'Scoped'
pub const MLOperatorEdgeType = enum(u32) {
Undefined = 0,
Tensor = 1,
};
// NOTE: not creating aliases because this enum is 'Scoped'
pub const MLOperatorEdgeDescription = extern struct {
edgeType: MLOperatorEdgeType,
Anonymous: extern union {
reserved: u64,
tensorDataType: MLOperatorTensorDataType,
},
};
const IID_IMLOperatorAttributes_Value = Guid.initString("4b1b1759-ec40-466c-aab4-beb5347fd24c");
pub const IID_IMLOperatorAttributes = &IID_IMLOperatorAttributes_Value;
pub const IMLOperatorAttributes = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetAttributeElementCount: fn(
self: *const IMLOperatorAttributes,
name: ?[*:0]const u8,
type: MLOperatorAttributeType,
elementCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttribute: fn(
self: *const IMLOperatorAttributes,
name: ?[*:0]const u8,
type: MLOperatorAttributeType,
elementCount: u32,
elementByteSize: usize,
value: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStringAttributeElementLength: fn(
self: *const IMLOperatorAttributes,
name: ?[*:0]const u8,
elementIndex: u32,
attributeElementByteSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStringAttributeElement: fn(
self: *const IMLOperatorAttributes,
name: ?[*:0]const u8,
elementIndex: u32,
attributeElementByteSize: u32,
attributeElement: [*:0]u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorAttributes_GetAttributeElementCount(self: *const T, name: ?[*:0]const u8, type_: MLOperatorAttributeType, elementCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorAttributes.VTable, self.vtable).GetAttributeElementCount(@ptrCast(*const IMLOperatorAttributes, self), name, type_, elementCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorAttributes_GetAttribute(self: *const T, name: ?[*:0]const u8, type_: MLOperatorAttributeType, elementCount: u32, elementByteSize: usize, value: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorAttributes.VTable, self.vtable).GetAttribute(@ptrCast(*const IMLOperatorAttributes, self), name, type_, elementCount, elementByteSize, value);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorAttributes_GetStringAttributeElementLength(self: *const T, name: ?[*:0]const u8, elementIndex: u32, attributeElementByteSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorAttributes.VTable, self.vtable).GetStringAttributeElementLength(@ptrCast(*const IMLOperatorAttributes, self), name, elementIndex, attributeElementByteSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorAttributes_GetStringAttributeElement(self: *const T, name: ?[*:0]const u8, elementIndex: u32, attributeElementByteSize: u32, attributeElement: [*:0]u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorAttributes.VTable, self.vtable).GetStringAttributeElement(@ptrCast(*const IMLOperatorAttributes, self), name, elementIndex, attributeElementByteSize, attributeElement);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorTensorShapeDescription_Value = Guid.initString("f20e8cbe-3b28-4248-be95-f96fbc6e4643");
pub const IID_IMLOperatorTensorShapeDescription = &IID_IMLOperatorTensorShapeDescription_Value;
pub const IMLOperatorTensorShapeDescription = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetInputTensorDimensionCount: fn(
self: *const IMLOperatorTensorShapeDescription,
inputIndex: u32,
dimensionCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInputTensorShape: fn(
self: *const IMLOperatorTensorShapeDescription,
inputIndex: u32,
dimensionCount: u32,
dimensions: [*]u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
HasOutputShapeDescription: fn(
self: *const IMLOperatorTensorShapeDescription,
) callconv(@import("std").os.windows.WINAPI) bool,
GetOutputTensorDimensionCount: fn(
self: *const IMLOperatorTensorShapeDescription,
outputIndex: u32,
dimensionCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetOutputTensorShape: fn(
self: *const IMLOperatorTensorShapeDescription,
outputIndex: u32,
dimensionCount: u32,
dimensions: [*]u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensorShapeDescription_GetInputTensorDimensionCount(self: *const T, inputIndex: u32, dimensionCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorTensorShapeDescription.VTable, self.vtable).GetInputTensorDimensionCount(@ptrCast(*const IMLOperatorTensorShapeDescription, self), inputIndex, dimensionCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensorShapeDescription_GetInputTensorShape(self: *const T, inputIndex: u32, dimensionCount: u32, dimensions: [*]u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorTensorShapeDescription.VTable, self.vtable).GetInputTensorShape(@ptrCast(*const IMLOperatorTensorShapeDescription, self), inputIndex, dimensionCount, dimensions);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensorShapeDescription_HasOutputShapeDescription(self: *const T) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorTensorShapeDescription.VTable, self.vtable).HasOutputShapeDescription(@ptrCast(*const IMLOperatorTensorShapeDescription, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensorShapeDescription_GetOutputTensorDimensionCount(self: *const T, outputIndex: u32, dimensionCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorTensorShapeDescription.VTable, self.vtable).GetOutputTensorDimensionCount(@ptrCast(*const IMLOperatorTensorShapeDescription, self), outputIndex, dimensionCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensorShapeDescription_GetOutputTensorShape(self: *const T, outputIndex: u32, dimensionCount: u32, dimensions: [*]u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorTensorShapeDescription.VTable, self.vtable).GetOutputTensorShape(@ptrCast(*const IMLOperatorTensorShapeDescription, self), outputIndex, dimensionCount, dimensions);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorKernelCreationContext_Value = Guid.initString("5459b53d-a0fc-4665-addd-70171ef7e631");
pub const IID_IMLOperatorKernelCreationContext = &IID_IMLOperatorKernelCreationContext_Value;
pub const IMLOperatorKernelCreationContext = extern struct {
pub const VTable = extern struct {
base: IMLOperatorAttributes.VTable,
GetInputCount: fn(
self: *const IMLOperatorKernelCreationContext,
) callconv(@import("std").os.windows.WINAPI) u32,
GetOutputCount: fn(
self: *const IMLOperatorKernelCreationContext,
) callconv(@import("std").os.windows.WINAPI) u32,
IsInputValid: fn(
self: *const IMLOperatorKernelCreationContext,
inputIndex: u32,
) callconv(@import("std").os.windows.WINAPI) bool,
IsOutputValid: fn(
self: *const IMLOperatorKernelCreationContext,
outputIndex: u32,
) callconv(@import("std").os.windows.WINAPI) bool,
GetInputEdgeDescription: fn(
self: *const IMLOperatorKernelCreationContext,
inputIndex: u32,
edgeDescription: ?*MLOperatorEdgeDescription,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetOutputEdgeDescription: fn(
self: *const IMLOperatorKernelCreationContext,
outputIndex: u32,
edgeDescription: ?*MLOperatorEdgeDescription,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
HasTensorShapeDescription: fn(
self: *const IMLOperatorKernelCreationContext,
) callconv(@import("std").os.windows.WINAPI) bool,
GetTensorShapeDescription: fn(
self: *const IMLOperatorKernelCreationContext,
shapeDescription: ?*?*IMLOperatorTensorShapeDescription,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetExecutionInterface: fn(
self: *const IMLOperatorKernelCreationContext,
executionObject: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMLOperatorAttributes.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_GetInputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).GetInputCount(@ptrCast(*const IMLOperatorKernelCreationContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_GetOutputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).GetOutputCount(@ptrCast(*const IMLOperatorKernelCreationContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_IsInputValid(self: *const T, inputIndex: u32) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).IsInputValid(@ptrCast(*const IMLOperatorKernelCreationContext, self), inputIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_IsOutputValid(self: *const T, outputIndex: u32) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).IsOutputValid(@ptrCast(*const IMLOperatorKernelCreationContext, self), outputIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_GetInputEdgeDescription(self: *const T, inputIndex: u32, edgeDescription: ?*MLOperatorEdgeDescription) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).GetInputEdgeDescription(@ptrCast(*const IMLOperatorKernelCreationContext, self), inputIndex, edgeDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_GetOutputEdgeDescription(self: *const T, outputIndex: u32, edgeDescription: ?*MLOperatorEdgeDescription) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).GetOutputEdgeDescription(@ptrCast(*const IMLOperatorKernelCreationContext, self), outputIndex, edgeDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_HasTensorShapeDescription(self: *const T) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).HasTensorShapeDescription(@ptrCast(*const IMLOperatorKernelCreationContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_GetTensorShapeDescription(self: *const T, shapeDescription: ?*?*IMLOperatorTensorShapeDescription) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).GetTensorShapeDescription(@ptrCast(*const IMLOperatorKernelCreationContext, self), shapeDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelCreationContext_GetExecutionInterface(self: *const T, executionObject: ?*?*IUnknown) callconv(.Inline) void {
return @ptrCast(*const IMLOperatorKernelCreationContext.VTable, self.vtable).GetExecutionInterface(@ptrCast(*const IMLOperatorKernelCreationContext, self), executionObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorTensor_Value = Guid.initString("7fe41f41-f430-440e-aece-54416dc8b9db");
pub const IID_IMLOperatorTensor = &IID_IMLOperatorTensor_Value;
pub const IMLOperatorTensor = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDimensionCount: fn(
self: *const IMLOperatorTensor,
) callconv(@import("std").os.windows.WINAPI) u32,
GetShape: fn(
self: *const IMLOperatorTensor,
dimensionCount: u32,
dimensions: [*]u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTensorDataType: fn(
self: *const IMLOperatorTensor,
) callconv(@import("std").os.windows.WINAPI) MLOperatorTensorDataType,
IsCpuData: fn(
self: *const IMLOperatorTensor,
) callconv(@import("std").os.windows.WINAPI) bool,
IsDataInterface: fn(
self: *const IMLOperatorTensor,
) callconv(@import("std").os.windows.WINAPI) bool,
GetData: fn(
self: *const IMLOperatorTensor,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque,
GetDataInterface: fn(
self: *const IMLOperatorTensor,
dataInterface: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensor_GetDimensionCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const IMLOperatorTensor.VTable, self.vtable).GetDimensionCount(@ptrCast(*const IMLOperatorTensor, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensor_GetShape(self: *const T, dimensionCount: u32, dimensions: [*]u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorTensor.VTable, self.vtable).GetShape(@ptrCast(*const IMLOperatorTensor, self), dimensionCount, dimensions);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensor_GetTensorDataType(self: *const T) callconv(.Inline) MLOperatorTensorDataType {
return @ptrCast(*const IMLOperatorTensor.VTable, self.vtable).GetTensorDataType(@ptrCast(*const IMLOperatorTensor, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensor_IsCpuData(self: *const T) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorTensor.VTable, self.vtable).IsCpuData(@ptrCast(*const IMLOperatorTensor, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensor_IsDataInterface(self: *const T) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorTensor.VTable, self.vtable).IsDataInterface(@ptrCast(*const IMLOperatorTensor, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensor_GetData(self: *const T) callconv(.Inline) ?*anyopaque {
return @ptrCast(*const IMLOperatorTensor.VTable, self.vtable).GetData(@ptrCast(*const IMLOperatorTensor, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTensor_GetDataInterface(self: *const T, dataInterface: ?*?*IUnknown) callconv(.Inline) void {
return @ptrCast(*const IMLOperatorTensor.VTable, self.vtable).GetDataInterface(@ptrCast(*const IMLOperatorTensor, self), dataInterface);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorKernelContext_Value = Guid.initString("82536a28-f022-4769-9d3f-8b278f84c0c3");
pub const IID_IMLOperatorKernelContext = &IID_IMLOperatorKernelContext_Value;
pub const IMLOperatorKernelContext = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetInputTensor: fn(
self: *const IMLOperatorKernelContext,
inputIndex: u32,
tensor: ?*?*IMLOperatorTensor,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetOutputTensor: fn(
self: *const IMLOperatorKernelContext,
outputIndex: u32,
dimensionCount: u32,
dimensionSizes: [*]const u32,
tensor: ?*?*IMLOperatorTensor,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetOutputTensor1: fn(
self: *const IMLOperatorKernelContext,
outputIndex: u32,
tensor: ?*?*IMLOperatorTensor,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AllocateTemporaryData: fn(
self: *const IMLOperatorKernelContext,
size: usize,
data: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetExecutionInterface: fn(
self: *const IMLOperatorKernelContext,
executionObject: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelContext_GetInputTensor(self: *const T, inputIndex: u32, tensor: ?*?*IMLOperatorTensor) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernelContext.VTable, self.vtable).GetInputTensor(@ptrCast(*const IMLOperatorKernelContext, self), inputIndex, tensor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelContext_GetOutputTensor(self: *const T, outputIndex: u32, dimensionCount: u32, dimensionSizes: [*]const u32, tensor: ?*?*IMLOperatorTensor) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernelContext.VTable, self.vtable).GetOutputTensor(@ptrCast(*const IMLOperatorKernelContext, self), outputIndex, dimensionCount, dimensionSizes, tensor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelContext_GetOutputTensor1(self: *const T, outputIndex: u32, tensor: ?*?*IMLOperatorTensor) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernelContext.VTable, self.vtable).GetOutputTensor(@ptrCast(*const IMLOperatorKernelContext, self), outputIndex, tensor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelContext_AllocateTemporaryData(self: *const T, size: usize, data: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernelContext.VTable, self.vtable).AllocateTemporaryData(@ptrCast(*const IMLOperatorKernelContext, self), size, data);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelContext_GetExecutionInterface(self: *const T, executionObject: ?*?*IUnknown) callconv(.Inline) void {
return @ptrCast(*const IMLOperatorKernelContext.VTable, self.vtable).GetExecutionInterface(@ptrCast(*const IMLOperatorKernelContext, self), executionObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorKernel_Value = Guid.initString("11c4b4a0-b467-4eaa-a1a6-b961d8d0ed79");
pub const IID_IMLOperatorKernel = &IID_IMLOperatorKernel_Value;
pub const IMLOperatorKernel = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Compute: fn(
self: *const IMLOperatorKernel,
context: ?*IMLOperatorKernelContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernel_Compute(self: *const T, context: ?*IMLOperatorKernelContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernel.VTable, self.vtable).Compute(@ptrCast(*const IMLOperatorKernel, self), context);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const MLOperatorParameterOptions = enum(u32) {
Single = 0,
Optional = 1,
Variadic = 2,
_,
pub fn initFlags(o: struct {
Single: u1 = 0,
Optional: u1 = 0,
Variadic: u1 = 0,
}) MLOperatorParameterOptions {
return @intToEnum(MLOperatorParameterOptions,
(if (o.Single == 1) @enumToInt(MLOperatorParameterOptions.Single) else 0)
| (if (o.Optional == 1) @enumToInt(MLOperatorParameterOptions.Optional) else 0)
| (if (o.Variadic == 1) @enumToInt(MLOperatorParameterOptions.Variadic) else 0)
);
}
};
// NOTE: not creating aliases because this enum is 'Scoped'
pub const MLOperatorSchemaEdgeTypeFormat = enum(i32) {
EdgeDescription = 0,
Label = 1,
};
// NOTE: not creating aliases because this enum is 'Scoped'
pub const MLOperatorSchemaEdgeDescription = extern struct {
options: MLOperatorParameterOptions,
typeFormat: MLOperatorSchemaEdgeTypeFormat,
Anonymous: extern union {
reserved: ?*const anyopaque,
typeLabel: ?[*:0]const u8,
edgeDescription: MLOperatorEdgeDescription,
},
};
pub const MLOperatorEdgeTypeConstraint = extern struct {
typeLabel: ?[*:0]const u8,
allowedTypes: ?*const MLOperatorEdgeDescription,
allowedTypeCount: u32,
};
const IID_IMLOperatorShapeInferenceContext_Value = Guid.initString("105b6b29-5408-4a68-9959-09b5955a3492");
pub const IID_IMLOperatorShapeInferenceContext = &IID_IMLOperatorShapeInferenceContext_Value;
pub const IMLOperatorShapeInferenceContext = extern struct {
pub const VTable = extern struct {
base: IMLOperatorAttributes.VTable,
GetInputCount: fn(
self: *const IMLOperatorShapeInferenceContext,
) callconv(@import("std").os.windows.WINAPI) u32,
GetOutputCount: fn(
self: *const IMLOperatorShapeInferenceContext,
) callconv(@import("std").os.windows.WINAPI) u32,
IsInputValid: fn(
self: *const IMLOperatorShapeInferenceContext,
inputIndex: u32,
) callconv(@import("std").os.windows.WINAPI) bool,
IsOutputValid: fn(
self: *const IMLOperatorShapeInferenceContext,
outputIndex: u32,
) callconv(@import("std").os.windows.WINAPI) bool,
GetInputEdgeDescription: fn(
self: *const IMLOperatorShapeInferenceContext,
inputIndex: u32,
edgeDescription: ?*MLOperatorEdgeDescription,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInputTensorDimensionCount: fn(
self: *const IMLOperatorShapeInferenceContext,
inputIndex: u32,
dimensionCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInputTensorShape: fn(
self: *const IMLOperatorShapeInferenceContext,
inputIndex: u32,
dimensionCount: u32,
dimensions: [*]u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetOutputTensorShape: fn(
self: *const IMLOperatorShapeInferenceContext,
outputIndex: u32,
dimensionCount: u32,
dimensions: ?*const u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMLOperatorAttributes.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferenceContext_GetInputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const IMLOperatorShapeInferenceContext.VTable, self.vtable).GetInputCount(@ptrCast(*const IMLOperatorShapeInferenceContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferenceContext_GetOutputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const IMLOperatorShapeInferenceContext.VTable, self.vtable).GetOutputCount(@ptrCast(*const IMLOperatorShapeInferenceContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferenceContext_IsInputValid(self: *const T, inputIndex: u32) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorShapeInferenceContext.VTable, self.vtable).IsInputValid(@ptrCast(*const IMLOperatorShapeInferenceContext, self), inputIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferenceContext_IsOutputValid(self: *const T, outputIndex: u32) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorShapeInferenceContext.VTable, self.vtable).IsOutputValid(@ptrCast(*const IMLOperatorShapeInferenceContext, self), outputIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferenceContext_GetInputEdgeDescription(self: *const T, inputIndex: u32, edgeDescription: ?*MLOperatorEdgeDescription) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorShapeInferenceContext.VTable, self.vtable).GetInputEdgeDescription(@ptrCast(*const IMLOperatorShapeInferenceContext, self), inputIndex, edgeDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferenceContext_GetInputTensorDimensionCount(self: *const T, inputIndex: u32, dimensionCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorShapeInferenceContext.VTable, self.vtable).GetInputTensorDimensionCount(@ptrCast(*const IMLOperatorShapeInferenceContext, self), inputIndex, dimensionCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferenceContext_GetInputTensorShape(self: *const T, inputIndex: u32, dimensionCount: u32, dimensions: [*]u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorShapeInferenceContext.VTable, self.vtable).GetInputTensorShape(@ptrCast(*const IMLOperatorShapeInferenceContext, self), inputIndex, dimensionCount, dimensions);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferenceContext_SetOutputTensorShape(self: *const T, outputIndex: u32, dimensionCount: u32, dimensions: ?*const u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorShapeInferenceContext.VTable, self.vtable).SetOutputTensorShape(@ptrCast(*const IMLOperatorShapeInferenceContext, self), outputIndex, dimensionCount, dimensions);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorTypeInferenceContext_Value = Guid.initString("ec893bb1-f938-427b-8488-c8dcf775f138");
pub const IID_IMLOperatorTypeInferenceContext = &IID_IMLOperatorTypeInferenceContext_Value;
pub const IMLOperatorTypeInferenceContext = extern struct {
pub const VTable = extern struct {
base: IMLOperatorAttributes.VTable,
GetInputCount: fn(
self: *const IMLOperatorTypeInferenceContext,
) callconv(@import("std").os.windows.WINAPI) u32,
GetOutputCount: fn(
self: *const IMLOperatorTypeInferenceContext,
) callconv(@import("std").os.windows.WINAPI) u32,
IsInputValid: fn(
self: *const IMLOperatorTypeInferenceContext,
inputIndex: u32,
) callconv(@import("std").os.windows.WINAPI) bool,
IsOutputValid: fn(
self: *const IMLOperatorTypeInferenceContext,
outputIndex: u32,
) callconv(@import("std").os.windows.WINAPI) bool,
GetInputEdgeDescription: fn(
self: *const IMLOperatorTypeInferenceContext,
inputIndex: u32,
edgeDescription: ?*MLOperatorEdgeDescription,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetOutputEdgeDescription: fn(
self: *const IMLOperatorTypeInferenceContext,
outputIndex: u32,
edgeDescription: ?*const MLOperatorEdgeDescription,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMLOperatorAttributes.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTypeInferenceContext_GetInputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const IMLOperatorTypeInferenceContext.VTable, self.vtable).GetInputCount(@ptrCast(*const IMLOperatorTypeInferenceContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTypeInferenceContext_GetOutputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const IMLOperatorTypeInferenceContext.VTable, self.vtable).GetOutputCount(@ptrCast(*const IMLOperatorTypeInferenceContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTypeInferenceContext_IsInputValid(self: *const T, inputIndex: u32) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorTypeInferenceContext.VTable, self.vtable).IsInputValid(@ptrCast(*const IMLOperatorTypeInferenceContext, self), inputIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTypeInferenceContext_IsOutputValid(self: *const T, outputIndex: u32) callconv(.Inline) bool {
return @ptrCast(*const IMLOperatorTypeInferenceContext.VTable, self.vtable).IsOutputValid(@ptrCast(*const IMLOperatorTypeInferenceContext, self), outputIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTypeInferenceContext_GetInputEdgeDescription(self: *const T, inputIndex: u32, edgeDescription: ?*MLOperatorEdgeDescription) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorTypeInferenceContext.VTable, self.vtable).GetInputEdgeDescription(@ptrCast(*const IMLOperatorTypeInferenceContext, self), inputIndex, edgeDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTypeInferenceContext_SetOutputEdgeDescription(self: *const T, outputIndex: u32, edgeDescription: ?*const MLOperatorEdgeDescription) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorTypeInferenceContext.VTable, self.vtable).SetOutputEdgeDescription(@ptrCast(*const IMLOperatorTypeInferenceContext, self), outputIndex, edgeDescription);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorTypeInferrer_Value = Guid.initString("781aeb48-9bcb-4797-bf77-8bf455217beb");
pub const IID_IMLOperatorTypeInferrer = &IID_IMLOperatorTypeInferrer_Value;
pub const IMLOperatorTypeInferrer = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
InferOutputTypes: fn(
self: *const IMLOperatorTypeInferrer,
context: ?*IMLOperatorTypeInferenceContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorTypeInferrer_InferOutputTypes(self: *const T, context: ?*IMLOperatorTypeInferenceContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorTypeInferrer.VTable, self.vtable).InferOutputTypes(@ptrCast(*const IMLOperatorTypeInferrer, self), context);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorShapeInferrer_Value = Guid.initString("540be5be-a6c9-40ee-83f6-d2b8b40a7798");
pub const IID_IMLOperatorShapeInferrer = &IID_IMLOperatorShapeInferrer_Value;
pub const IMLOperatorShapeInferrer = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
InferOutputShapes: fn(
self: *const IMLOperatorShapeInferrer,
context: ?*IMLOperatorShapeInferenceContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorShapeInferrer_InferOutputShapes(self: *const T, context: ?*IMLOperatorShapeInferenceContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorShapeInferrer.VTable, self.vtable).InferOutputShapes(@ptrCast(*const IMLOperatorShapeInferrer, self), context);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const MLOperatorAttribute = extern struct {
name: ?[*:0]const u8,
type: MLOperatorAttributeType,
required: bool,
};
pub const MLOperatorAttributeNameValue = extern struct {
name: ?[*:0]const u8,
type: MLOperatorAttributeType,
valueCount: u32,
Anonymous: extern union {
reserved: ?*const anyopaque,
ints: ?*const i64,
strings: ?*const ?*i8,
floats: ?*const f32,
},
};
pub const MLOperatorSchemaDescription = extern struct {
name: ?[*:0]const u8,
operatorSetVersionAtLastChange: i32,
inputs: ?*const MLOperatorSchemaEdgeDescription,
inputCount: u32,
outputs: ?*const MLOperatorSchemaEdgeDescription,
outputCount: u32,
typeConstraints: ?*const MLOperatorEdgeTypeConstraint,
typeConstraintCount: u32,
attributes: ?*const MLOperatorAttribute,
attributeCount: u32,
defaultAttributes: ?*const MLOperatorAttributeNameValue,
defaultAttributeCount: u32,
};
pub const MLOperatorSetId = extern struct {
domain: ?[*:0]const u8,
version: i32,
};
pub const MLOperatorKernelOptions = enum(u32) {
None = 0,
s = 1,
_,
pub fn initFlags(o: struct {
None: u1 = 0,
s: u1 = 0,
}) MLOperatorKernelOptions {
return @intToEnum(MLOperatorKernelOptions,
(if (o.None == 1) @enumToInt(MLOperatorKernelOptions.None) else 0)
| (if (o.s == 1) @enumToInt(MLOperatorKernelOptions.s) else 0)
);
}
};
// NOTE: not creating aliases because this enum is 'Scoped'
pub const MLOperatorExecutionType = enum(u32) {
Undefined = 0,
Cpu = 1,
D3D12 = 2,
};
// NOTE: not creating aliases because this enum is 'Scoped'
pub const MLOperatorKernelDescription = extern struct {
domain: ?[*:0]const u8,
name: ?[*:0]const u8,
minimumOperatorSetVersion: i32,
executionType: MLOperatorExecutionType,
typeConstraints: ?*const MLOperatorEdgeTypeConstraint,
typeConstraintCount: u32,
defaultAttributes: ?*const MLOperatorAttributeNameValue,
defaultAttributeCount: u32,
options: MLOperatorKernelOptions,
executionOptions: u32,
};
const IID_IMLOperatorKernelFactory_Value = Guid.initString("ef15ad6f-0dc9-4908-ab35-a575a30dfbf8");
pub const IID_IMLOperatorKernelFactory = &IID_IMLOperatorKernelFactory_Value;
pub const IMLOperatorKernelFactory = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
CreateKernel: fn(
self: *const IMLOperatorKernelFactory,
context: ?*IMLOperatorKernelCreationContext,
kernel: ?*?*IMLOperatorKernel,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorKernelFactory_CreateKernel(self: *const T, context: ?*IMLOperatorKernelCreationContext, kernel: ?*?*IMLOperatorKernel) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorKernelFactory.VTable, self.vtable).CreateKernel(@ptrCast(*const IMLOperatorKernelFactory, self), context, kernel);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMLOperatorRegistry_Value = Guid.initString("2af9dd2d-b516-4672-9ab5-530c208493ad");
pub const IID_IMLOperatorRegistry = &IID_IMLOperatorRegistry_Value;
pub const IMLOperatorRegistry = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
RegisterOperatorSetSchema: fn(
self: *const IMLOperatorRegistry,
operatorSetId: ?*const MLOperatorSetId,
baselineVersion: i32,
schema: ?[*]const ?*const MLOperatorSchemaDescription,
schemaCount: u32,
typeInferrer: ?*IMLOperatorTypeInferrer,
shapeInferrer: ?*IMLOperatorShapeInferrer,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterOperatorKernel: fn(
self: *const IMLOperatorRegistry,
operatorKernel: ?*const MLOperatorKernelDescription,
operatorKernelFactory: ?*IMLOperatorKernelFactory,
shapeInferrer: ?*IMLOperatorShapeInferrer,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorRegistry_RegisterOperatorSetSchema(self: *const T, operatorSetId: ?*const MLOperatorSetId, baselineVersion: i32, schema: ?[*]const ?*const MLOperatorSchemaDescription, schemaCount: u32, typeInferrer: ?*IMLOperatorTypeInferrer, shapeInferrer: ?*IMLOperatorShapeInferrer) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorRegistry.VTable, self.vtable).RegisterOperatorSetSchema(@ptrCast(*const IMLOperatorRegistry, self), operatorSetId, baselineVersion, schema, schemaCount, typeInferrer, shapeInferrer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMLOperatorRegistry_RegisterOperatorKernel(self: *const T, operatorKernel: ?*const MLOperatorKernelDescription, operatorKernelFactory: ?*IMLOperatorKernelFactory, shapeInferrer: ?*IMLOperatorShapeInferrer) callconv(.Inline) HRESULT {
return @ptrCast(*const IMLOperatorRegistry.VTable, self.vtable).RegisterOperatorKernel(@ptrCast(*const IMLOperatorRegistry, self), operatorKernel, operatorKernelFactory, shapeInferrer);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (2)
//--------------------------------------------------------------------------------
pub extern "winml" fn WinMLCreateRuntime(
runtime: ?*?*IWinMLRuntime,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "windows.ai.machinelearning" fn MLCreateOperatorRegistry(
registry: ?*?*IMLOperatorRegistry,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (8)
//--------------------------------------------------------------------------------
const Guid = @import("../../zig.zig").Guid;
const BOOL = @import("../../foundation.zig").BOOL;
const HRESULT = @import("../../foundation.zig").HRESULT;
const ID3D12Device = @import("../../graphics/direct3d12.zig").ID3D12Device;
const ID3D12Resource = @import("../../graphics/direct3d12.zig").ID3D12Resource;
const IUnknown = @import("../../system/com.zig").IUnknown;
const PSTR = @import("../../foundation.zig").PSTR;
const PWSTR = @import("../../foundation.zig").PWSTR;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/ai/machine_learning/win_ml.zig |
pub const CM_PROB_NOT_CONFIGURED = @as(u32, 1);
pub const CM_PROB_DEVLOADER_FAILED = @as(u32, 2);
pub const CM_PROB_OUT_OF_MEMORY = @as(u32, 3);
pub const CM_PROB_ENTRY_IS_WRONG_TYPE = @as(u32, 4);
pub const CM_PROB_LACKED_ARBITRATOR = @as(u32, 5);
pub const CM_PROB_BOOT_CONFIG_CONFLICT = @as(u32, 6);
pub const CM_PROB_FAILED_FILTER = @as(u32, 7);
pub const CM_PROB_DEVLOADER_NOT_FOUND = @as(u32, 8);
pub const CM_PROB_INVALID_DATA = @as(u32, 9);
pub const CM_PROB_FAILED_START = @as(u32, 10);
pub const CM_PROB_LIAR = @as(u32, 11);
pub const CM_PROB_NORMAL_CONFLICT = @as(u32, 12);
pub const CM_PROB_NOT_VERIFIED = @as(u32, 13);
pub const CM_PROB_NEED_RESTART = @as(u32, 14);
pub const CM_PROB_REENUMERATION = @as(u32, 15);
pub const CM_PROB_PARTIAL_LOG_CONF = @as(u32, 16);
pub const CM_PROB_UNKNOWN_RESOURCE = @as(u32, 17);
pub const CM_PROB_REINSTALL = @as(u32, 18);
pub const CM_PROB_REGISTRY = @as(u32, 19);
pub const CM_PROB_VXDLDR = @as(u32, 20);
pub const CM_PROB_WILL_BE_REMOVED = @as(u32, 21);
pub const CM_PROB_DISABLED = @as(u32, 22);
pub const CM_PROB_DEVLOADER_NOT_READY = @as(u32, 23);
pub const CM_PROB_DEVICE_NOT_THERE = @as(u32, 24);
pub const CM_PROB_MOVED = @as(u32, 25);
pub const CM_PROB_TOO_EARLY = @as(u32, 26);
pub const CM_PROB_NO_VALID_LOG_CONF = @as(u32, 27);
pub const CM_PROB_FAILED_INSTALL = @as(u32, 28);
pub const CM_PROB_HARDWARE_DISABLED = @as(u32, 29);
pub const CM_PROB_CANT_SHARE_IRQ = @as(u32, 30);
pub const CM_PROB_FAILED_ADD = @as(u32, 31);
pub const CM_PROB_DISABLED_SERVICE = @as(u32, 32);
pub const CM_PROB_TRANSLATION_FAILED = @as(u32, 33);
pub const CM_PROB_NO_SOFTCONFIG = @as(u32, 34);
pub const CM_PROB_BIOS_TABLE = @as(u32, 35);
pub const CM_PROB_IRQ_TRANSLATION_FAILED = @as(u32, 36);
pub const CM_PROB_FAILED_DRIVER_ENTRY = @as(u32, 37);
pub const CM_PROB_DRIVER_FAILED_PRIOR_UNLOAD = @as(u32, 38);
pub const CM_PROB_DRIVER_FAILED_LOAD = @as(u32, 39);
pub const CM_PROB_DRIVER_SERVICE_KEY_INVALID = @as(u32, 40);
pub const CM_PROB_LEGACY_SERVICE_NO_DEVICES = @as(u32, 41);
pub const CM_PROB_DUPLICATE_DEVICE = @as(u32, 42);
pub const CM_PROB_FAILED_POST_START = @as(u32, 43);
pub const CM_PROB_HALTED = @as(u32, 44);
pub const CM_PROB_PHANTOM = @as(u32, 45);
pub const CM_PROB_SYSTEM_SHUTDOWN = @as(u32, 46);
pub const CM_PROB_HELD_FOR_EJECT = @as(u32, 47);
pub const CM_PROB_DRIVER_BLOCKED = @as(u32, 48);
pub const CM_PROB_REGISTRY_TOO_LARGE = @as(u32, 49);
pub const CM_PROB_SETPROPERTIES_FAILED = @as(u32, 50);
pub const CM_PROB_WAITING_ON_DEPENDENCY = @as(u32, 51);
pub const CM_PROB_UNSIGNED_DRIVER = @as(u32, 52);
pub const CM_PROB_USED_BY_DEBUGGER = @as(u32, 53);
pub const CM_PROB_DEVICE_RESET = @as(u32, 54);
pub const CM_PROB_CONSOLE_LOCKED = @as(u32, 55);
pub const CM_PROB_NEED_CLASS_CONFIG = @as(u32, 56);
pub const CM_PROB_GUEST_ASSIGNMENT_FAILED = @as(u32, 57);
pub const NUM_CM_PROB_V1 = @as(u32, 37);
pub const NUM_CM_PROB_V2 = @as(u32, 50);
pub const NUM_CM_PROB_V3 = @as(u32, 51);
pub const NUM_CM_PROB_V4 = @as(u32, 52);
pub const NUM_CM_PROB_V5 = @as(u32, 53);
pub const NUM_CM_PROB_V6 = @as(u32, 54);
pub const NUM_CM_PROB_V7 = @as(u32, 55);
pub const NUM_CM_PROB_V8 = @as(u32, 57);
pub const NUM_CM_PROB_V9 = @as(u32, 58);
pub const NUM_CM_PROB = @as(u32, 58);
pub const DN_ROOT_ENUMERATED = @as(u32, 1);
pub const DN_DRIVER_LOADED = @as(u32, 2);
pub const DN_ENUM_LOADED = @as(u32, 4);
pub const DN_STARTED = @as(u32, 8);
pub const DN_MANUAL = @as(u32, 16);
pub const DN_NEED_TO_ENUM = @as(u32, 32);
pub const DN_NOT_FIRST_TIME = @as(u32, 64);
pub const DN_HARDWARE_ENUM = @as(u32, 128);
pub const DN_LIAR = @as(u32, 256);
pub const DN_HAS_MARK = @as(u32, 512);
pub const DN_HAS_PROBLEM = @as(u32, 1024);
pub const DN_FILTERED = @as(u32, 2048);
pub const DN_MOVED = @as(u32, 4096);
pub const DN_DISABLEABLE = @as(u32, 8192);
pub const DN_REMOVABLE = @as(u32, 16384);
pub const DN_PRIVATE_PROBLEM = @as(u32, 32768);
pub const DN_MF_PARENT = @as(u32, 65536);
pub const DN_MF_CHILD = @as(u32, 131072);
pub const DN_WILL_BE_REMOVED = @as(u32, 262144);
pub const DN_NOT_FIRST_TIMEE = @as(u32, 524288);
pub const DN_STOP_FREE_RES = @as(u32, 1048576);
pub const DN_REBAL_CANDIDATE = @as(u32, 2097152);
pub const DN_BAD_PARTIAL = @as(u32, 4194304);
pub const DN_NT_ENUMERATOR = @as(u32, 8388608);
pub const DN_NT_DRIVER = @as(u32, 16777216);
pub const DN_NEEDS_LOCKING = @as(u32, 33554432);
pub const DN_ARM_WAKEUP = @as(u32, 67108864);
pub const DN_APM_ENUMERATOR = @as(u32, 134217728);
pub const DN_APM_DRIVER = @as(u32, 268435456);
pub const DN_SILENT_INSTALL = @as(u32, 536870912);
pub const DN_NO_SHOW_IN_DM = @as(u32, 1073741824);
pub const DN_BOOT_LOG_PROB = @as(u32, 2147483648);
pub const DN_NEED_RESTART = @as(u32, 256);
pub const DN_DRIVER_BLOCKED = @as(u32, 64);
pub const DN_LEGACY_DRIVER = @as(u32, 4096);
pub const DN_CHILD_WITH_INVALID_ID = @as(u32, 512);
pub const DN_DEVICE_DISCONNECTED = @as(u32, 33554432);
pub const DN_QUERY_REMOVE_PENDING = @as(u32, 65536);
pub const DN_QUERY_REMOVE_ACTIVE = @as(u32, 131072);
pub const LCPRI_FORCECONFIG = @as(u32, 0);
pub const LCPRI_BOOTCONFIG = @as(u32, 1);
pub const LCPRI_DESIRED = @as(u32, 8192);
pub const LCPRI_NORMAL = @as(u32, 12288);
pub const LCPRI_LASTBESTCONFIG = @as(u32, 16383);
pub const LCPRI_SUBOPTIMAL = @as(u32, 20480);
pub const LCPRI_LASTSOFTCONFIG = @as(u32, 32767);
pub const LCPRI_RESTART = @as(u32, 32768);
pub const LCPRI_REBOOT = @as(u32, 36864);
pub const LCPRI_POWEROFF = @as(u32, 40960);
pub const LCPRI_HARDRECONFIG = @as(u32, 49152);
pub const LCPRI_HARDWIRED = @as(u32, 57344);
pub const LCPRI_IMPOSSIBLE = @as(u32, 61440);
pub const LCPRI_DISABLED = @as(u32, 65535);
pub const MAX_LCPRI = @as(u32, 65535);
pub const CM_DEVICE_PANEL_SIDE_UNKNOWN = @as(u32, 0);
pub const CM_DEVICE_PANEL_SIDE_TOP = @as(u32, 1);
pub const CM_DEVICE_PANEL_SIDE_BOTTOM = @as(u32, 2);
pub const CM_DEVICE_PANEL_SIDE_LEFT = @as(u32, 3);
pub const CM_DEVICE_PANEL_SIDE_RIGHT = @as(u32, 4);
pub const CM_DEVICE_PANEL_SIDE_FRONT = @as(u32, 5);
pub const CM_DEVICE_PANEL_SIDE_BACK = @as(u32, 6);
pub const CM_DEVICE_PANEL_EDGE_UNKNOWN = @as(u32, 0);
pub const CM_DEVICE_PANEL_EDGE_TOP = @as(u32, 1);
pub const CM_DEVICE_PANEL_EDGE_BOTTOM = @as(u32, 2);
pub const CM_DEVICE_PANEL_EDGE_LEFT = @as(u32, 3);
pub const CM_DEVICE_PANEL_EDGE_RIGHT = @as(u32, 4);
pub const CM_DEVICE_PANEL_SHAPE_UNKNOWN = @as(u32, 0);
pub const CM_DEVICE_PANEL_SHAPE_RECTANGLE = @as(u32, 1);
pub const CM_DEVICE_PANEL_SHAPE_OVAL = @as(u32, 2);
pub const CM_DEVICE_PANEL_ORIENTATION_HORIZONTAL = @as(u32, 0);
pub const CM_DEVICE_PANEL_ORIENTATION_VERTICAL = @as(u32, 1);
pub const CM_DEVICE_PANEL_JOINT_TYPE_UNKNOWN = @as(u32, 0);
pub const CM_DEVICE_PANEL_JOINT_TYPE_PLANAR = @as(u32, 1);
pub const CM_DEVICE_PANEL_JOINT_TYPE_HINGE = @as(u32, 2);
pub const CM_DEVICE_PANEL_JOINT_TYPE_PIVOT = @as(u32, 3);
pub const CM_DEVICE_PANEL_JOINT_TYPE_SWIVEL = @as(u32, 4);
pub const GUID_DEVCLASS_1394 = Guid.initString("6bdd1fc1-810f-11d0-bec7-08002be2092f");
pub const GUID_DEVCLASS_1394DEBUG = Guid.initString("66f250d6-7801-4a64-b139-eea80a450b24");
pub const GUID_DEVCLASS_61883 = Guid.initString("7ebefbc0-3200-11d2-b4c2-00a0c9697d07");
pub const GUID_DEVCLASS_ADAPTER = Guid.initString("4d36e964-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_APMSUPPORT = Guid.initString("d45b1c18-c8fa-11d1-9f77-0000f805f530");
pub const GUID_DEVCLASS_AVC = Guid.initString("c06ff265-ae09-48f0-812c-16753d7cba83");
pub const GUID_DEVCLASS_BATTERY = Guid.initString("72631e54-78a4-11d0-bcf7-00aa00b7b32a");
pub const GUID_DEVCLASS_BIOMETRIC = Guid.initString("53d29ef7-377c-4d14-864b-eb3a85769359");
pub const GUID_DEVCLASS_BLUETOOTH = Guid.initString("e0cbf06c-cd8b-4647-bb8a-263b43f0f974");
pub const GUID_DEVCLASS_CAMERA = Guid.initString("ca3e7ab9-b4c3-4ae6-8251-579ef933890f");
pub const GUID_DEVCLASS_CDROM = Guid.initString("4d36e965-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_COMPUTEACCELERATOR = Guid.initString("f01a9d53-3ff6-48d2-9f97-c8a7004be10c");
pub const GUID_DEVCLASS_COMPUTER = Guid.initString("4d36e966-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_DECODER = Guid.initString("6bdd1fc2-810f-11d0-bec7-08002be2092f");
pub const GUID_DEVCLASS_DISKDRIVE = Guid.initString("4d36e967-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_DISPLAY = Guid.initString("4d36e968-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_DOT4 = Guid.initString("48721b56-6795-11d2-b1a8-0080c72e74a2");
pub const GUID_DEVCLASS_DOT4PRINT = Guid.initString("49ce6ac8-6f86-11d2-b1e5-0080c72e74a2");
pub const GUID_DEVCLASS_EHSTORAGESILO = Guid.initString("9da2b80f-f89f-4a49-a5c2-511b085b9e8a");
pub const GUID_DEVCLASS_ENUM1394 = Guid.initString("c459df55-db08-11d1-b009-00a0c9081ff6");
pub const GUID_DEVCLASS_EXTENSION = Guid.initString("e2f84ce7-8efa-411c-aa69-97454ca4cb57");
pub const GUID_DEVCLASS_FDC = Guid.initString("4d36e969-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_FIRMWARE = Guid.initString("f2e7dd72-6468-4e36-b6f1-6488f42c1b52");
pub const GUID_DEVCLASS_FLOPPYDISK = Guid.initString("4d36e980-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_GPS = Guid.initString("6bdd1fc3-810f-11d0-bec7-08002be2092f");
pub const GUID_DEVCLASS_HDC = Guid.initString("4d36e96a-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_HIDCLASS = Guid.initString("745a17a0-74d3-11d0-b6fe-00a0c90f57da");
pub const GUID_DEVCLASS_HOLOGRAPHIC = Guid.initString("d612553d-06b1-49ca-8938-e39ef80eb16f");
pub const GUID_DEVCLASS_IMAGE = Guid.initString("6bdd1fc6-810f-11d0-bec7-08002be2092f");
pub const GUID_DEVCLASS_INFINIBAND = Guid.initString("30ef7132-d858-4a0c-ac24-b9028a5cca3f");
pub const GUID_DEVCLASS_INFRARED = Guid.initString("6bdd1fc5-810f-11d0-bec7-08002be2092f");
pub const GUID_DEVCLASS_KEYBOARD = Guid.initString("4d36e96b-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_LEGACYDRIVER = Guid.initString("8ecc055d-047f-11d1-a537-0000f8753ed1");
pub const GUID_DEVCLASS_MEDIA = Guid.initString("4d36e96c-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_MEDIUM_CHANGER = Guid.initString("ce5939ae-ebde-11d0-b181-0000f8753ec4");
pub const GUID_DEVCLASS_MEMORY = Guid.initString("5099944a-f6b9-4057-a056-8c550228544c");
pub const GUID_DEVCLASS_MODEM = Guid.initString("4d36e96d-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_MONITOR = Guid.initString("4d36e96e-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_MOUSE = Guid.initString("4d36e96f-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_MTD = Guid.initString("4d36e970-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_MULTIFUNCTION = Guid.initString("4d36e971-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_MULTIPORTSERIAL = Guid.initString("50906cb8-ba12-11d1-bf5d-0000f805f530");
pub const GUID_DEVCLASS_NET = Guid.initString("4d36e972-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_NETCLIENT = Guid.initString("4d36e973-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_NETDRIVER = Guid.initString("87ef9ad1-8f70-49ee-b215-ab1fcadcbe3c");
pub const GUID_DEVCLASS_NETSERVICE = Guid.initString("4d36e974-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_NETTRANS = Guid.initString("4d36e975-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_NETUIO = Guid.initString("78912bc1-cb8e-4b28-a329-f322ebadbe0f");
pub const GUID_DEVCLASS_NODRIVER = Guid.initString("4d36e976-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_PCMCIA = Guid.initString("4d36e977-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_PNPPRINTERS = Guid.initString("4658ee7e-f050-11d1-b6bd-00c04fa372a7");
pub const GUID_DEVCLASS_PORTS = Guid.initString("4d36e978-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_PRINTER = Guid.initString("4d36e979-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_PRINTERUPGRADE = Guid.initString("4d36e97a-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_PRINTQUEUE = Guid.initString("1ed2bbf9-11f0-4084-b21f-ad83a8e6dcdc");
pub const GUID_DEVCLASS_PROCESSOR = Guid.initString("50127dc3-0f36-415e-a6cc-4cb3be910b65");
pub const GUID_DEVCLASS_SBP2 = Guid.initString("d48179be-ec20-11d1-b6b8-00c04fa372a7");
pub const GUID_DEVCLASS_SCMDISK = Guid.initString("53966cb1-4d46-4166-bf23-c522403cd495");
pub const GUID_DEVCLASS_SCMVOLUME = Guid.initString("53ccb149-e543-4c84-b6e0-bce4f6b7e806");
pub const GUID_DEVCLASS_SCSIADAPTER = Guid.initString("4d36e97b-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_SECURITYACCELERATOR = Guid.initString("268c95a1-edfe-11d3-95c3-0010dc4050a5");
pub const GUID_DEVCLASS_SENSOR = Guid.initString("5175d334-c371-4806-b3ba-71fd53c9258d");
pub const GUID_DEVCLASS_SIDESHOW = Guid.initString("997b5d8d-c442-4f2e-baf3-9c8e671e9e21");
pub const GUID_DEVCLASS_SMARTCARDREADER = Guid.initString("50dd5230-ba8a-11d1-bf5d-0000f805f530");
pub const GUID_DEVCLASS_SMRDISK = Guid.initString("53487c23-680f-4585-acc3-1f10d6777e82");
pub const GUID_DEVCLASS_SMRVOLUME = Guid.initString("53b3cf03-8f5a-4788-91b6-d19ed9fcccbf");
pub const GUID_DEVCLASS_SOFTWARECOMPONENT = Guid.initString("5c4c3332-344d-483c-8739-259e934c9cc8");
pub const GUID_DEVCLASS_SOUND = Guid.initString("4d36e97c-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_SYSTEM = Guid.initString("4d36e97d-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_TAPEDRIVE = Guid.initString("6d807884-7d21-11cf-801c-08002be10318");
pub const GUID_DEVCLASS_UNKNOWN = Guid.initString("4d36e97e-e325-11ce-bfc1-08002be10318");
pub const GUID_DEVCLASS_UCM = Guid.initString("e6f1aa1c-7f3b-4473-b2e8-c97d8ac71d53");
pub const GUID_DEVCLASS_USB = Guid.initString("36fc9e60-c465-11cf-8056-444553540000");
pub const GUID_DEVCLASS_VOLUME = Guid.initString("71a27cdd-812a-11d0-bec7-08002be2092f");
pub const GUID_DEVCLASS_VOLUMESNAPSHOT = Guid.initString("533c5b84-ec70-11d2-9505-00c04f79deaf");
pub const GUID_DEVCLASS_WCEUSBS = Guid.initString("25dbce51-6c8f-4a72-8a6d-b54c2b4fc835");
pub const GUID_DEVCLASS_WPD = Guid.initString("eec5ad98-8080-425f-922a-dabf3de3f69a");
pub const GUID_DEVCLASS_FSFILTER_TOP = Guid.initString("b369baf4-5568-4e82-a87e-a93eb16bca87");
pub const GUID_DEVCLASS_FSFILTER_ACTIVITYMONITOR = Guid.initString("b86dff51-a31e-4bac-b3cf-e8cfe75c9fc2");
pub const GUID_DEVCLASS_FSFILTER_UNDELETE = Guid.initString("fe8f1572-c67a-48c0-bbac-0b5c6d66cafb");
pub const GUID_DEVCLASS_FSFILTER_ANTIVIRUS = Guid.initString("b1d1a169-c54f-4379-81db-bee7d88d7454");
pub const GUID_DEVCLASS_FSFILTER_REPLICATION = Guid.initString("48d3ebc4-4cf8-48ff-b869-9c68ad42eb9f");
pub const GUID_DEVCLASS_FSFILTER_CONTINUOUSBACKUP = Guid.initString("71aa14f8-6fad-4622-ad77-92bb9d7e6947");
pub const GUID_DEVCLASS_FSFILTER_CONTENTSCREENER = Guid.initString("3e3f0674-c83c-4558-bb26-9820e1eba5c5");
pub const GUID_DEVCLASS_FSFILTER_QUOTAMANAGEMENT = Guid.initString("8503c911-a6c7-4919-8f79-5028f5866b0c");
pub const GUID_DEVCLASS_FSFILTER_SYSTEMRECOVERY = Guid.initString("2db15374-706e-4131-a0c7-d7c78eb0289a");
pub const GUID_DEVCLASS_FSFILTER_CFSMETADATASERVER = Guid.initString("cdcf0939-b75b-4630-bf76-80f7ba655884");
pub const GUID_DEVCLASS_FSFILTER_HSM = Guid.initString("d546500a-2aeb-45f6-9482-f4b1799c3177");
pub const GUID_DEVCLASS_FSFILTER_COMPRESSION = Guid.initString("f3586baf-b5aa-49b5-8d6c-0569284c639f");
pub const GUID_DEVCLASS_FSFILTER_ENCRYPTION = Guid.initString("a0a701c0-a511-42ff-aa6c-06dc0395576f");
pub const GUID_DEVCLASS_FSFILTER_VIRTUALIZATION = Guid.initString("f75a86c0-10d8-4c3a-b233-ed60e4cdfaac");
pub const GUID_DEVCLASS_FSFILTER_PHYSICALQUOTAMANAGEMENT = Guid.initString("6a0a8e78-bba6-4fc4-a709-1e33cd09d67e");
pub const GUID_DEVCLASS_FSFILTER_OPENFILEBACKUP = Guid.initString("f8ecafa6-66d1-41a5-899b-66585d7216b7");
pub const GUID_DEVCLASS_FSFILTER_SECURITYENHANCER = Guid.initString("d02bc3da-0c8e-4945-9bd5-f1883c226c8c");
pub const GUID_DEVCLASS_FSFILTER_COPYPROTECTION = Guid.initString("89786ff1-9c12-402f-9c9e-17753c7f4375");
pub const GUID_DEVCLASS_FSFILTER_BOTTOM = Guid.initString("37765ea0-5958-4fc9-b04b-2fdfef97e59e");
pub const GUID_DEVCLASS_FSFILTER_SYSTEM = Guid.initString("5d1b9aaa-01e2-46af-849f-272b3f324c46");
pub const GUID_DEVCLASS_FSFILTER_INFRASTRUCTURE = Guid.initString("e55fa6f9-128c-4d04-abab-630c74b1453a");
pub const LINE_LEN = @as(u32, 256);
pub const MAX_INF_STRING_LENGTH = @as(u32, 4096);
pub const MAX_INF_SECTION_NAME_LENGTH = @as(u32, 255);
pub const MAX_TITLE_LEN = @as(u32, 60);
pub const MAX_INSTRUCTION_LEN = @as(u32, 256);
pub const MAX_LABEL_LEN = @as(u32, 30);
pub const MAX_SERVICE_NAME_LEN = @as(u32, 256);
pub const MAX_SUBTITLE_LEN = @as(u32, 256);
pub const SP_MAX_MACHINENAME_LENGTH = @as(u32, 263);
pub const SP_ALTPLATFORM_FLAGS_VERSION_RANGE = @as(u32, 1);
pub const SP_ALTPLATFORM_FLAGS_SUITE_MASK = @as(u32, 2);
pub const INF_STYLE_CACHE_ENABLE = @as(u32, 16);
pub const INF_STYLE_CACHE_DISABLE = @as(u32, 32);
pub const INF_STYLE_CACHE_IGNORE = @as(u32, 64);
pub const DIRID_ABSOLUTE = @as(i32, -1);
pub const DIRID_ABSOLUTE_16BIT = @as(u32, 65535);
pub const DIRID_NULL = @as(u32, 0);
pub const DIRID_SRCPATH = @as(u32, 1);
pub const DIRID_WINDOWS = @as(u32, 10);
pub const DIRID_SYSTEM = @as(u32, 11);
pub const DIRID_DRIVERS = @as(u32, 12);
pub const DIRID_IOSUBSYS = @as(u32, 12);
pub const DIRID_DRIVER_STORE = @as(u32, 13);
pub const DIRID_INF = @as(u32, 17);
pub const DIRID_HELP = @as(u32, 18);
pub const DIRID_FONTS = @as(u32, 20);
pub const DIRID_VIEWERS = @as(u32, 21);
pub const DIRID_COLOR = @as(u32, 23);
pub const DIRID_APPS = @as(u32, 24);
pub const DIRID_SHARED = @as(u32, 25);
pub const DIRID_BOOT = @as(u32, 30);
pub const DIRID_SYSTEM16 = @as(u32, 50);
pub const DIRID_SPOOL = @as(u32, 51);
pub const DIRID_SPOOLDRIVERS = @as(u32, 52);
pub const DIRID_USERPROFILE = @as(u32, 53);
pub const DIRID_LOADER = @as(u32, 54);
pub const DIRID_PRINTPROCESSOR = @as(u32, 55);
pub const DIRID_DEFAULT = @as(u32, 11);
pub const DIRID_COMMON_STARTMENU = @as(u32, 16406);
pub const DIRID_COMMON_PROGRAMS = @as(u32, 16407);
pub const DIRID_COMMON_STARTUP = @as(u32, 16408);
pub const DIRID_COMMON_DESKTOPDIRECTORY = @as(u32, 16409);
pub const DIRID_COMMON_FAVORITES = @as(u32, 16415);
pub const DIRID_COMMON_APPDATA = @as(u32, 16419);
pub const DIRID_PROGRAM_FILES = @as(u32, 16422);
pub const DIRID_SYSTEM_X86 = @as(u32, 16425);
pub const DIRID_PROGRAM_FILES_X86 = @as(u32, 16426);
pub const DIRID_PROGRAM_FILES_COMMON = @as(u32, 16427);
pub const DIRID_PROGRAM_FILES_COMMONX86 = @as(u32, 16428);
pub const DIRID_COMMON_TEMPLATES = @as(u32, 16429);
pub const DIRID_COMMON_DOCUMENTS = @as(u32, 16430);
pub const DIRID_USER = @as(u32, 32768);
pub const SPFILENOTIFY_STARTQUEUE = @as(u32, 1);
pub const SPFILENOTIFY_ENDQUEUE = @as(u32, 2);
pub const SPFILENOTIFY_STARTSUBQUEUE = @as(u32, 3);
pub const SPFILENOTIFY_ENDSUBQUEUE = @as(u32, 4);
pub const SPFILENOTIFY_STARTDELETE = @as(u32, 5);
pub const SPFILENOTIFY_ENDDELETE = @as(u32, 6);
pub const SPFILENOTIFY_DELETEERROR = @as(u32, 7);
pub const SPFILENOTIFY_STARTRENAME = @as(u32, 8);
pub const SPFILENOTIFY_ENDRENAME = @as(u32, 9);
pub const SPFILENOTIFY_RENAMEERROR = @as(u32, 10);
pub const SPFILENOTIFY_STARTCOPY = @as(u32, 11);
pub const SPFILENOTIFY_ENDCOPY = @as(u32, 12);
pub const SPFILENOTIFY_COPYERROR = @as(u32, 13);
pub const SPFILENOTIFY_NEEDMEDIA = @as(u32, 14);
pub const SPFILENOTIFY_QUEUESCAN = @as(u32, 15);
pub const SPFILENOTIFY_CABINETINFO = @as(u32, 16);
pub const SPFILENOTIFY_FILEINCABINET = @as(u32, 17);
pub const SPFILENOTIFY_NEEDNEWCABINET = @as(u32, 18);
pub const SPFILENOTIFY_FILEEXTRACTED = @as(u32, 19);
pub const SPFILENOTIFY_FILEOPDELAYED = @as(u32, 20);
pub const SPFILENOTIFY_STARTBACKUP = @as(u32, 21);
pub const SPFILENOTIFY_BACKUPERROR = @as(u32, 22);
pub const SPFILENOTIFY_ENDBACKUP = @as(u32, 23);
pub const SPFILENOTIFY_QUEUESCAN_EX = @as(u32, 24);
pub const SPFILENOTIFY_STARTREGISTRATION = @as(u32, 25);
pub const SPFILENOTIFY_ENDREGISTRATION = @as(u32, 32);
pub const SPFILENOTIFY_QUEUESCAN_SIGNERINFO = @as(u32, 64);
pub const SPFILENOTIFY_LANGMISMATCH = @as(u32, 65536);
pub const SPFILENOTIFY_TARGETEXISTS = @as(u32, 131072);
pub const SPFILENOTIFY_TARGETNEWER = @as(u32, 262144);
pub const FILEOP_RENAME = @as(u32, 1);
pub const FILEOP_BACKUP = @as(u32, 3);
pub const FILEOP_ABORT = @as(u32, 0);
pub const FILEOP_DOIT = @as(u32, 1);
pub const FILEOP_SKIP = @as(u32, 2);
pub const FILEOP_RETRY = @as(u32, 1);
pub const FILEOP_NEWPATH = @as(u32, 4);
pub const COPYFLG_WARN_IF_SKIP = @as(u32, 1);
pub const COPYFLG_NOSKIP = @as(u32, 2);
pub const COPYFLG_NOVERSIONCHECK = @as(u32, 4);
pub const COPYFLG_FORCE_FILE_IN_USE = @as(u32, 8);
pub const COPYFLG_NO_OVERWRITE = @as(u32, 16);
pub const COPYFLG_NO_VERSION_DIALOG = @as(u32, 32);
pub const COPYFLG_OVERWRITE_OLDER_ONLY = @as(u32, 64);
pub const COPYFLG_PROTECTED_WINDOWS_DRIVER_FILE = @as(u32, 256);
pub const COPYFLG_REPLACEONLY = @as(u32, 1024);
pub const COPYFLG_NODECOMP = @as(u32, 2048);
pub const COPYFLG_REPLACE_BOOT_FILE = @as(u32, 4096);
pub const COPYFLG_NOPRUNE = @as(u32, 8192);
pub const COPYFLG_IN_USE_TRY_RENAME = @as(u32, 16384);
pub const DELFLG_IN_USE = @as(u32, 1);
pub const DELFLG_IN_USE1 = @as(u32, 65536);
pub const SPREG_SUCCESS = @as(u32, 0);
pub const SPREG_LOADLIBRARY = @as(u32, 1);
pub const SPREG_GETPROCADDR = @as(u32, 2);
pub const SPREG_REGSVR = @as(u32, 3);
pub const SPREG_DLLINSTALL = @as(u32, 4);
pub const SPREG_TIMEOUT = @as(u32, 5);
pub const SPREG_UNKNOWN = @as(u32, 4294967295);
pub const SPINT_ACTIVE = @as(u32, 1);
pub const SPINT_DEFAULT = @as(u32, 2);
pub const SPINT_REMOVED = @as(u32, 4);
pub const SPID_ACTIVE = @as(u32, 1);
pub const SPID_DEFAULT = @as(u32, 2);
pub const SPID_REMOVED = @as(u32, 4);
pub const DIF_SELECTDEVICE = @as(u32, 1);
pub const DIF_INSTALLDEVICE = @as(u32, 2);
pub const DIF_ASSIGNRESOURCES = @as(u32, 3);
pub const DIF_PROPERTIES = @as(u32, 4);
pub const DIF_REMOVE = @as(u32, 5);
pub const DIF_FIRSTTIMESETUP = @as(u32, 6);
pub const DIF_FOUNDDEVICE = @as(u32, 7);
pub const DIF_SELECTCLASSDRIVERS = @as(u32, 8);
pub const DIF_VALIDATECLASSDRIVERS = @as(u32, 9);
pub const DIF_INSTALLCLASSDRIVERS = @as(u32, 10);
pub const DIF_CALCDISKSPACE = @as(u32, 11);
pub const DIF_DESTROYPRIVATEDATA = @as(u32, 12);
pub const DIF_VALIDATEDRIVER = @as(u32, 13);
pub const DIF_DETECT = @as(u32, 15);
pub const DIF_INSTALLWIZARD = @as(u32, 16);
pub const DIF_DESTROYWIZARDDATA = @as(u32, 17);
pub const DIF_PROPERTYCHANGE = @as(u32, 18);
pub const DIF_ENABLECLASS = @as(u32, 19);
pub const DIF_DETECTVERIFY = @as(u32, 20);
pub const DIF_INSTALLDEVICEFILES = @as(u32, 21);
pub const DIF_UNREMOVE = @as(u32, 22);
pub const DIF_SELECTBESTCOMPATDRV = @as(u32, 23);
pub const DIF_ALLOW_INSTALL = @as(u32, 24);
pub const DIF_REGISTERDEVICE = @as(u32, 25);
pub const DIF_NEWDEVICEWIZARD_PRESELECT = @as(u32, 26);
pub const DIF_NEWDEVICEWIZARD_SELECT = @as(u32, 27);
pub const DIF_NEWDEVICEWIZARD_PREANALYZE = @as(u32, 28);
pub const DIF_NEWDEVICEWIZARD_POSTANALYZE = @as(u32, 29);
pub const DIF_NEWDEVICEWIZARD_FINISHINSTALL = @as(u32, 30);
pub const DIF_UNUSED1 = @as(u32, 31);
pub const DIF_INSTALLINTERFACES = @as(u32, 32);
pub const DIF_DETECTCANCEL = @as(u32, 33);
pub const DIF_REGISTER_COINSTALLERS = @as(u32, 34);
pub const DIF_ADDPROPERTYPAGE_ADVANCED = @as(u32, 35);
pub const DIF_ADDPROPERTYPAGE_BASIC = @as(u32, 36);
pub const DIF_RESERVED1 = @as(u32, 37);
pub const DIF_TROUBLESHOOTER = @as(u32, 38);
pub const DIF_POWERMESSAGEWAKE = @as(u32, 39);
pub const DIF_ADDREMOTEPROPERTYPAGE_ADVANCED = @as(u32, 40);
pub const DIF_UPDATEDRIVER_UI = @as(u32, 41);
pub const DIF_FINISHINSTALL_ACTION = @as(u32, 42);
pub const DIF_RESERVED2 = @as(u32, 48);
pub const DIF_MOVEDEVICE = @as(u32, 14);
pub const DI_SHOWOEM = @as(i32, 1);
pub const DI_SHOWCOMPAT = @as(i32, 2);
pub const DI_SHOWCLASS = @as(i32, 4);
pub const DI_SHOWALL = @as(i32, 7);
pub const DI_NOVCP = @as(i32, 8);
pub const DI_DIDCOMPAT = @as(i32, 16);
pub const DI_DIDCLASS = @as(i32, 32);
pub const DI_AUTOASSIGNRES = @as(i32, 64);
pub const DI_NEEDRESTART = @as(i32, 128);
pub const DI_NEEDREBOOT = @as(i32, 256);
pub const DI_NOBROWSE = @as(i32, 512);
pub const DI_MULTMFGS = @as(i32, 1024);
pub const DI_DISABLED = @as(i32, 2048);
pub const DI_GENERALPAGE_ADDED = @as(i32, 4096);
pub const DI_RESOURCEPAGE_ADDED = @as(i32, 8192);
pub const DI_PROPERTIES_CHANGE = @as(i32, 16384);
pub const DI_INF_IS_SORTED = @as(i32, 32768);
pub const DI_ENUMSINGLEINF = @as(i32, 65536);
pub const DI_DONOTCALLCONFIGMG = @as(i32, 131072);
pub const DI_INSTALLDISABLED = @as(i32, 262144);
pub const DI_COMPAT_FROM_CLASS = @as(i32, 524288);
pub const DI_CLASSINSTALLPARAMS = @as(i32, 1048576);
pub const DI_NODI_DEFAULTACTION = @as(i32, 2097152);
pub const DI_QUIETINSTALL = @as(i32, 8388608);
pub const DI_NOFILECOPY = @as(i32, 16777216);
pub const DI_FORCECOPY = @as(i32, 33554432);
pub const DI_DRIVERPAGE_ADDED = @as(i32, 67108864);
pub const DI_USECI_SELECTSTRINGS = @as(i32, 134217728);
pub const DI_OVERRIDE_INFFLAGS = @as(i32, 268435456);
pub const DI_PROPS_NOCHANGEUSAGE = @as(i32, 536870912);
pub const DI_NOSELECTICONS = @as(i32, 1073741824);
pub const DI_NOWRITE_IDS = @as(i32, -2147483648);
pub const DI_FLAGSEX_RESERVED2 = @as(i32, 1);
pub const DI_FLAGSEX_RESERVED3 = @as(i32, 2);
pub const DI_FLAGSEX_CI_FAILED = @as(i32, 4);
pub const DI_FLAGSEX_FINISHINSTALL_ACTION = @as(i32, 8);
pub const DI_FLAGSEX_DIDINFOLIST = @as(i32, 16);
pub const DI_FLAGSEX_DIDCOMPATINFO = @as(i32, 32);
pub const DI_FLAGSEX_FILTERCLASSES = @as(i32, 64);
pub const DI_FLAGSEX_SETFAILEDINSTALL = @as(i32, 128);
pub const DI_FLAGSEX_DEVICECHANGE = @as(i32, 256);
pub const DI_FLAGSEX_ALWAYSWRITEIDS = @as(i32, 512);
pub const DI_FLAGSEX_PROPCHANGE_PENDING = @as(i32, 1024);
pub const DI_FLAGSEX_ALLOWEXCLUDEDDRVS = @as(i32, 2048);
pub const DI_FLAGSEX_NOUIONQUERYREMOVE = @as(i32, 4096);
pub const DI_FLAGSEX_USECLASSFORCOMPAT = @as(i32, 8192);
pub const DI_FLAGSEX_RESERVED4 = @as(i32, 16384);
pub const DI_FLAGSEX_NO_DRVREG_MODIFY = @as(i32, 32768);
pub const DI_FLAGSEX_IN_SYSTEM_SETUP = @as(i32, 65536);
pub const DI_FLAGSEX_INET_DRIVER = @as(i32, 131072);
pub const DI_FLAGSEX_APPENDDRIVERLIST = @as(i32, 262144);
pub const DI_FLAGSEX_PREINSTALLBACKUP = @as(i32, 524288);
pub const DI_FLAGSEX_BACKUPONREPLACE = @as(i32, 1048576);
pub const DI_FLAGSEX_DRIVERLIST_FROM_URL = @as(i32, 2097152);
pub const DI_FLAGSEX_RESERVED1 = @as(i32, 4194304);
pub const DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS = @as(i32, 8388608);
pub const DI_FLAGSEX_POWERPAGE_ADDED = @as(i32, 16777216);
pub const DI_FLAGSEX_FILTERSIMILARDRIVERS = @as(i32, 33554432);
pub const DI_FLAGSEX_INSTALLEDDRIVER = @as(i32, 67108864);
pub const DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE = @as(i32, 134217728);
pub const DI_FLAGSEX_ALTPLATFORM_DRVSEARCH = @as(i32, 268435456);
pub const DI_FLAGSEX_RESTART_DEVICE_ONLY = @as(i32, 536870912);
pub const DI_FLAGSEX_RECURSIVESEARCH = @as(i32, 1073741824);
pub const DI_FLAGSEX_SEARCH_PUBLISHED_INFS = @as(i32, -2147483648);
pub const ENABLECLASS_QUERY = @as(u32, 0);
pub const ENABLECLASS_SUCCESS = @as(u32, 1);
pub const ENABLECLASS_FAILURE = @as(u32, 2);
pub const DICS_ENABLE = @as(u32, 1);
pub const DICS_DISABLE = @as(u32, 2);
pub const DICS_PROPCHANGE = @as(u32, 3);
pub const DICS_START = @as(u32, 4);
pub const DICS_STOP = @as(u32, 5);
pub const DICS_FLAG_GLOBAL = @as(u32, 1);
pub const DICS_FLAG_CONFIGSPECIFIC = @as(u32, 2);
pub const DICS_FLAG_CONFIGGENERAL = @as(u32, 4);
pub const DI_REMOVEDEVICE_GLOBAL = @as(u32, 1);
pub const DI_REMOVEDEVICE_CONFIGSPECIFIC = @as(u32, 2);
pub const DI_UNREMOVEDEVICE_CONFIGSPECIFIC = @as(u32, 2);
pub const MAX_INSTALLWIZARD_DYNAPAGES = @as(u32, 20);
pub const NDW_INSTALLFLAG_DIDFACTDEFS = @as(u32, 1);
pub const NDW_INSTALLFLAG_HARDWAREALLREADYIN = @as(u32, 2);
pub const NDW_INSTALLFLAG_NEEDRESTART = @as(i32, 128);
pub const NDW_INSTALLFLAG_NEEDREBOOT = @as(i32, 256);
pub const NDW_INSTALLFLAG_NEEDSHUTDOWN = @as(u32, 512);
pub const NDW_INSTALLFLAG_EXPRESSINTRO = @as(u32, 1024);
pub const NDW_INSTALLFLAG_SKIPISDEVINSTALLED = @as(u32, 2048);
pub const NDW_INSTALLFLAG_NODETECTEDDEVS = @as(u32, 4096);
pub const NDW_INSTALLFLAG_INSTALLSPECIFIC = @as(u32, 8192);
pub const NDW_INSTALLFLAG_SKIPCLASSLIST = @as(u32, 16384);
pub const NDW_INSTALLFLAG_CI_PICKED_OEM = @as(u32, 32768);
pub const NDW_INSTALLFLAG_PCMCIAMODE = @as(u32, 65536);
pub const NDW_INSTALLFLAG_PCMCIADEVICE = @as(u32, 131072);
pub const NDW_INSTALLFLAG_USERCANCEL = @as(u32, 262144);
pub const NDW_INSTALLFLAG_KNOWNCLASS = @as(u32, 524288);
pub const DYNAWIZ_FLAG_PAGESADDED = @as(u32, 1);
pub const DYNAWIZ_FLAG_ANALYZE_HANDLECONFLICT = @as(u32, 8);
pub const DYNAWIZ_FLAG_INSTALLDET_NEXT = @as(u32, 2);
pub const DYNAWIZ_FLAG_INSTALLDET_PREV = @as(u32, 4);
pub const MIN_IDD_DYNAWIZ_RESOURCE_ID = @as(u32, 10000);
pub const MAX_IDD_DYNAWIZ_RESOURCE_ID = @as(u32, 11000);
pub const IDD_DYNAWIZ_FIRSTPAGE = @as(u32, 10000);
pub const IDD_DYNAWIZ_SELECT_PREVPAGE = @as(u32, 10001);
pub const IDD_DYNAWIZ_SELECT_NEXTPAGE = @as(u32, 10002);
pub const IDD_DYNAWIZ_ANALYZE_PREVPAGE = @as(u32, 10003);
pub const IDD_DYNAWIZ_ANALYZE_NEXTPAGE = @as(u32, 10004);
pub const IDD_DYNAWIZ_SELECTDEV_PAGE = @as(u32, 10009);
pub const IDD_DYNAWIZ_ANALYZEDEV_PAGE = @as(u32, 10010);
pub const IDD_DYNAWIZ_INSTALLDETECTEDDEVS_PAGE = @as(u32, 10011);
pub const IDD_DYNAWIZ_SELECTCLASS_PAGE = @as(u32, 10012);
pub const IDD_DYNAWIZ_INSTALLDETECTED_PREVPAGE = @as(u32, 10006);
pub const IDD_DYNAWIZ_INSTALLDETECTED_NEXTPAGE = @as(u32, 10007);
pub const IDD_DYNAWIZ_INSTALLDETECTED_NODEVS = @as(u32, 10008);
pub const DNF_DUPDESC = @as(u32, 1);
pub const DNF_OLDDRIVER = @as(u32, 2);
pub const DNF_EXCLUDEFROMLIST = @as(u32, 4);
pub const DNF_NODRIVER = @as(u32, 8);
pub const DNF_LEGACYINF = @as(u32, 16);
pub const DNF_CLASS_DRIVER = @as(u32, 32);
pub const DNF_COMPATIBLE_DRIVER = @as(u32, 64);
pub const DNF_INET_DRIVER = @as(u32, 128);
pub const DNF_UNUSED1 = @as(u32, 256);
pub const DNF_UNUSED2 = @as(u32, 512);
pub const DNF_OLD_INET_DRIVER = @as(u32, 1024);
pub const DNF_BAD_DRIVER = @as(u32, 2048);
pub const DNF_DUPPROVIDER = @as(u32, 4096);
pub const DNF_INF_IS_SIGNED = @as(u32, 8192);
pub const DNF_OEM_F6_INF = @as(u32, 16384);
pub const DNF_DUPDRIVERVER = @as(u32, 32768);
pub const DNF_BASIC_DRIVER = @as(u32, 65536);
pub const DNF_AUTHENTICODE_SIGNED = @as(u32, 131072);
pub const DNF_INSTALLEDDRIVER = @as(u32, 262144);
pub const DNF_ALWAYSEXCLUDEFROMLIST = @as(u32, 524288);
pub const DNF_INBOX_DRIVER = @as(u32, 1048576);
pub const DNF_REQUESTADDITIONALSOFTWARE = @as(u32, 2097152);
pub const DNF_UNUSED_22 = @as(u32, 4194304);
pub const DNF_UNUSED_23 = @as(u32, 8388608);
pub const DNF_UNUSED_24 = @as(u32, 16777216);
pub const DNF_UNUSED_25 = @as(u32, 33554432);
pub const DNF_UNUSED_26 = @as(u32, 67108864);
pub const DNF_UNUSED_27 = @as(u32, 134217728);
pub const DNF_UNUSED_28 = @as(u32, 268435456);
pub const DNF_UNUSED_29 = @as(u32, 536870912);
pub const DNF_UNUSED_30 = @as(u32, 1073741824);
pub const DNF_UNUSED_31 = @as(u32, 2147483648);
pub const DRIVER_HARDWAREID_RANK = @as(u32, 4095);
pub const DRIVER_HARDWAREID_MASK = @as(u32, 2147487743);
pub const DRIVER_UNTRUSTED_RANK = @as(u32, 2147483648);
pub const DRIVER_W9X_SUSPECT_RANK = @as(u32, 3221225472);
pub const DRIVER_COMPATID_RANK = @as(u32, 16383);
pub const DRIVER_UNTRUSTED_HARDWAREID_RANK = @as(u32, 36863);
pub const DRIVER_UNTRUSTED_COMPATID_RANK = @as(u32, 49151);
pub const DRIVER_W9X_SUSPECT_HARDWAREID_RANK = @as(u32, 53247);
pub const DRIVER_W9X_SUSPECT_COMPATID_RANK = @as(u32, 65535);
pub const SPPSR_SELECT_DEVICE_RESOURCES = @as(u32, 1);
pub const SPPSR_ENUM_BASIC_DEVICE_PROPERTIES = @as(u32, 2);
pub const SPPSR_ENUM_ADV_DEVICE_PROPERTIES = @as(u32, 3);
pub const INFINFO_INF_SPEC_IS_HINF = @as(u32, 1);
pub const INFINFO_INF_NAME_IS_ABSOLUTE = @as(u32, 2);
pub const INFINFO_DEFAULT_SEARCH = @as(u32, 3);
pub const INFINFO_REVERSE_DEFAULT_SEARCH = @as(u32, 4);
pub const INFINFO_INF_PATH_LIST_SEARCH = @as(u32, 5);
pub const FILE_COMPRESSION_NONE = @as(u32, 0);
pub const FILE_COMPRESSION_WINLZA = @as(u32, 1);
pub const FILE_COMPRESSION_MSZIP = @as(u32, 2);
pub const FILE_COMPRESSION_NTCAB = @as(u32, 3);
pub const SRCLIST_TEMPORARY = @as(u32, 1);
pub const SRCLIST_NOBROWSE = @as(u32, 2);
pub const SRCLIST_SYSTEM = @as(u32, 16);
pub const SRCLIST_USER = @as(u32, 32);
pub const SRCLIST_SYSIFADMIN = @as(u32, 64);
pub const SRCLIST_SUBDIRS = @as(u32, 256);
pub const SRCLIST_APPEND = @as(u32, 512);
pub const SRCLIST_NOSTRIPPLATFORM = @as(u32, 1024);
pub const IDF_NOBROWSE = @as(u32, 1);
pub const IDF_NOSKIP = @as(u32, 2);
pub const IDF_NODETAILS = @as(u32, 4);
pub const IDF_NOCOMPRESSED = @as(u32, 8);
pub const IDF_CHECKFIRST = @as(u32, 256);
pub const IDF_NOBEEP = @as(u32, 512);
pub const IDF_NOFOREGROUND = @as(u32, 1024);
pub const IDF_WARNIFSKIP = @as(u32, 2048);
pub const IDF_NOREMOVABLEMEDIAPROMPT = @as(u32, 4096);
pub const IDF_USEDISKNAMEASPROMPT = @as(u32, 8192);
pub const IDF_OEMDISK = @as(u32, 2147483648);
pub const DPROMPT_SUCCESS = @as(u32, 0);
pub const DPROMPT_CANCEL = @as(u32, 1);
pub const DPROMPT_SKIPFILE = @as(u32, 2);
pub const DPROMPT_BUFFERTOOSMALL = @as(u32, 3);
pub const DPROMPT_OUTOFMEMORY = @as(u32, 4);
pub const SETDIRID_NOT_FULL_PATH = @as(u32, 1);
pub const SRCINFO_PATH = @as(u32, 1);
pub const SRCINFO_TAGFILE = @as(u32, 2);
pub const SRCINFO_DESCRIPTION = @as(u32, 3);
pub const SRCINFO_FLAGS = @as(u32, 4);
pub const SRCINFO_TAGFILE2 = @as(u32, 5);
pub const SRC_FLAGS_CABFILE = @as(u32, 16);
pub const SP_FLAG_CABINETCONTINUATION = @as(u32, 2048);
pub const SP_BACKUP_BACKUPPASS = @as(u32, 1);
pub const SP_BACKUP_DEMANDPASS = @as(u32, 2);
pub const SP_BACKUP_SPECIAL = @as(u32, 4);
pub const SP_BACKUP_BOOTFILE = @as(u32, 8);
pub const SPQ_SCAN_FILE_PRESENCE = @as(u32, 1);
pub const SPQ_SCAN_FILE_VALIDITY = @as(u32, 2);
pub const SPQ_SCAN_USE_CALLBACK = @as(u32, 4);
pub const SPQ_SCAN_USE_CALLBACKEX = @as(u32, 8);
pub const SPQ_SCAN_INFORM_USER = @as(u32, 16);
pub const SPQ_SCAN_PRUNE_COPY_QUEUE = @as(u32, 32);
pub const SPQ_SCAN_USE_CALLBACK_SIGNERINFO = @as(u32, 64);
pub const SPQ_SCAN_PRUNE_DELREN = @as(u32, 128);
pub const SPQ_SCAN_FILE_PRESENCE_WITHOUT_SOURCE = @as(u32, 256);
pub const SPQ_SCAN_FILE_COMPARISON = @as(u32, 512);
pub const SPQ_SCAN_ACTIVATE_DRP = @as(u32, 1024);
pub const SPQ_DELAYED_COPY = @as(u32, 1);
pub const SPQ_FLAG_BACKUP_AWARE = @as(u32, 1);
pub const SPQ_FLAG_ABORT_IF_UNSIGNED = @as(u32, 2);
pub const SPQ_FLAG_FILES_MODIFIED = @as(u32, 4);
pub const SPQ_FLAG_DO_SHUFFLEMOVE = @as(u32, 8);
pub const SPQ_FLAG_VALID = @as(u32, 15);
pub const SPOST_MAX = @as(u32, 3);
pub const SUOI_FORCEDELETE = @as(u32, 1);
pub const SUOI_INTERNAL1 = @as(u32, 2);
pub const SPDSL_IGNORE_DISK = @as(u32, 1);
pub const SPDSL_DISALLOW_NEGATIVE_ADJUST = @as(u32, 2);
pub const SPFILEQ_FILE_IN_USE = @as(u32, 1);
pub const SPFILEQ_REBOOT_RECOMMENDED = @as(u32, 2);
pub const SPFILEQ_REBOOT_IN_PROGRESS = @as(u32, 4);
pub const FLG_ADDREG_DELREG_BIT = @as(u32, 32768);
pub const FLG_ADDREG_BINVALUETYPE = @as(u32, 1);
pub const FLG_ADDREG_NOCLOBBER = @as(u32, 2);
pub const FLG_ADDREG_DELVAL = @as(u32, 4);
pub const FLG_ADDREG_APPEND = @as(u32, 8);
pub const FLG_ADDREG_KEYONLY = @as(u32, 16);
pub const FLG_ADDREG_OVERWRITEONLY = @as(u32, 32);
pub const FLG_ADDREG_64BITKEY = @as(u32, 4096);
pub const FLG_ADDREG_KEYONLY_COMMON = @as(u32, 8192);
pub const FLG_ADDREG_32BITKEY = @as(u32, 16384);
pub const FLG_ADDREG_TYPE_SZ = @as(u32, 0);
pub const FLG_ADDREG_TYPE_MULTI_SZ = @as(u32, 65536);
pub const FLG_ADDREG_TYPE_EXPAND_SZ = @as(u32, 131072);
pub const FLG_DELREG_VALUE = @as(u32, 0);
pub const FLG_DELREG_TYPE_SZ = @as(u32, 0);
pub const FLG_DELREG_TYPE_MULTI_SZ = @as(u32, 65536);
pub const FLG_DELREG_TYPE_EXPAND_SZ = @as(u32, 131072);
pub const FLG_DELREG_64BITKEY = @as(u32, 4096);
pub const FLG_DELREG_KEYONLY_COMMON = @as(u32, 8192);
pub const FLG_DELREG_32BITKEY = @as(u32, 16384);
pub const FLG_DELREG_OPERATION_MASK = @as(u32, 254);
pub const FLG_BITREG_CLEARBITS = @as(u32, 0);
pub const FLG_BITREG_SETBITS = @as(u32, 1);
pub const FLG_BITREG_64BITKEY = @as(u32, 4096);
pub const FLG_BITREG_32BITKEY = @as(u32, 16384);
pub const FLG_INI2REG_64BITKEY = @as(u32, 4096);
pub const FLG_INI2REG_32BITKEY = @as(u32, 16384);
pub const FLG_REGSVR_DLLREGISTER = @as(u32, 1);
pub const FLG_REGSVR_DLLINSTALL = @as(u32, 2);
pub const FLG_PROFITEM_CURRENTUSER = @as(u32, 1);
pub const FLG_PROFITEM_DELETE = @as(u32, 2);
pub const FLG_PROFITEM_GROUP = @as(u32, 4);
pub const FLG_PROFITEM_CSIDL = @as(u32, 8);
pub const FLG_ADDPROPERTY_NOCLOBBER = @as(u32, 1);
pub const FLG_ADDPROPERTY_OVERWRITEONLY = @as(u32, 2);
pub const FLG_ADDPROPERTY_APPEND = @as(u32, 4);
pub const FLG_ADDPROPERTY_OR = @as(u32, 8);
pub const FLG_ADDPROPERTY_AND = @as(u32, 16);
pub const FLG_DELPROPERTY_MULTI_SZ_DELSTRING = @as(u32, 1);
pub const SPINST_LOGCONFIG = @as(u32, 1);
pub const SPINST_INIFILES = @as(u32, 2);
pub const SPINST_REGISTRY = @as(u32, 4);
pub const SPINST_INI2REG = @as(u32, 8);
pub const SPINST_FILES = @as(u32, 16);
pub const SPINST_BITREG = @as(u32, 32);
pub const SPINST_REGSVR = @as(u32, 64);
pub const SPINST_UNREGSVR = @as(u32, 128);
pub const SPINST_PROFILEITEMS = @as(u32, 256);
pub const SPINST_COPYINF = @as(u32, 512);
pub const SPINST_PROPERTIES = @as(u32, 1024);
pub const SPINST_ALL = @as(u32, 2047);
pub const SPINST_SINGLESECTION = @as(u32, 65536);
pub const SPINST_LOGCONFIG_IS_FORCED = @as(u32, 131072);
pub const SPINST_LOGCONFIGS_ARE_OVERRIDES = @as(u32, 262144);
pub const SPINST_REGISTERCALLBACKAWARE = @as(u32, 524288);
pub const SPINST_DEVICEINSTALL = @as(u32, 1048576);
pub const SPSVCINST_TAGTOFRONT = @as(u32, 1);
pub const SPSVCINST_ASSOCSERVICE = @as(u32, 2);
pub const SPSVCINST_DELETEEVENTLOGENTRY = @as(u32, 4);
pub const SPSVCINST_NOCLOBBER_DISPLAYNAME = @as(u32, 8);
pub const SPSVCINST_NOCLOBBER_STARTTYPE = @as(u32, 16);
pub const SPSVCINST_NOCLOBBER_ERRORCONTROL = @as(u32, 32);
pub const SPSVCINST_NOCLOBBER_LOADORDERGROUP = @as(u32, 64);
pub const SPSVCINST_NOCLOBBER_DEPENDENCIES = @as(u32, 128);
pub const SPSVCINST_NOCLOBBER_DESCRIPTION = @as(u32, 256);
pub const SPSVCINST_STOPSERVICE = @as(u32, 512);
pub const SPSVCINST_CLOBBER_SECURITY = @as(u32, 1024);
pub const SPSVCINST_STARTSERVICE = @as(u32, 2048);
pub const SPSVCINST_NOCLOBBER_REQUIREDPRIVILEGES = @as(u32, 4096);
pub const SPSVCINST_NOCLOBBER_TRIGGERS = @as(u32, 8192);
pub const SPSVCINST_NOCLOBBER_SERVICESIDTYPE = @as(u32, 16384);
pub const SPSVCINST_NOCLOBBER_DELAYEDAUTOSTART = @as(u32, 32768);
pub const SPSVCINST_UNIQUE_NAME = @as(u32, 65536);
pub const SPFILELOG_SYSTEMLOG = @as(u32, 1);
pub const SPFILELOG_FORCENEW = @as(u32, 2);
pub const SPFILELOG_QUERYONLY = @as(u32, 4);
pub const SPFILELOG_OEMFILE = @as(u32, 1);
pub const LogSevInformation = @as(u32, 0);
pub const LogSevWarning = @as(u32, 1);
pub const LogSevError = @as(u32, 2);
pub const LogSevFatalError = @as(u32, 3);
pub const LogSevMaximum = @as(u32, 4);
pub const DICD_GENERATE_ID = @as(u32, 1);
pub const DICD_INHERIT_CLASSDRVS = @as(u32, 2);
pub const DIOD_INHERIT_CLASSDRVS = @as(u32, 2);
pub const DIOD_CANCEL_REMOVE = @as(u32, 4);
pub const DIODI_NO_ADD = @as(u32, 1);
pub const SPRDI_FIND_DUPS = @as(u32, 1);
pub const SPDIT_NODRIVER = @as(u32, 0);
pub const DIGCF_DEFAULT = @as(u32, 1);
pub const DIGCF_PRESENT = @as(u32, 2);
pub const DIGCF_ALLCLASSES = @as(u32, 4);
pub const DIGCF_PROFILE = @as(u32, 8);
pub const DIGCF_DEVICEINTERFACE = @as(u32, 16);
pub const DIGCF_INTERFACEDEVICE = @as(u32, 16);
pub const DIBCI_NOINSTALLCLASS = @as(u32, 1);
pub const DIBCI_NODISPLAYCLASS = @as(u32, 2);
pub const DIOCR_INSTALLER = @as(u32, 1);
pub const DIOCR_INTERFACE = @as(u32, 2);
pub const DIREG_DEV = @as(u32, 1);
pub const DIREG_DRV = @as(u32, 2);
pub const DIREG_BOTH = @as(u32, 4);
pub const DICLASSPROP_INSTALLER = @as(u32, 1);
pub const DICLASSPROP_INTERFACE = @as(u32, 2);
pub const SPDRP_DEVICEDESC = @as(u32, 0);
pub const SPDRP_HARDWAREID = @as(u32, 1);
pub const SPDRP_COMPATIBLEIDS = @as(u32, 2);
pub const SPDRP_UNUSED0 = @as(u32, 3);
pub const SPDRP_SERVICE = @as(u32, 4);
pub const SPDRP_UNUSED1 = @as(u32, 5);
pub const SPDRP_UNUSED2 = @as(u32, 6);
pub const SPDRP_CLASS = @as(u32, 7);
pub const SPDRP_CLASSGUID = @as(u32, 8);
pub const SPDRP_DRIVER = @as(u32, 9);
pub const SPDRP_CONFIGFLAGS = @as(u32, 10);
pub const SPDRP_MFG = @as(u32, 11);
pub const SPDRP_FRIENDLYNAME = @as(u32, 12);
pub const SPDRP_LOCATION_INFORMATION = @as(u32, 13);
pub const SPDRP_PHYSICAL_DEVICE_OBJECT_NAME = @as(u32, 14);
pub const SPDRP_CAPABILITIES = @as(u32, 15);
pub const SPDRP_UI_NUMBER = @as(u32, 16);
pub const SPDRP_UPPERFILTERS = @as(u32, 17);
pub const SPDRP_LOWERFILTERS = @as(u32, 18);
pub const SPDRP_BUSTYPEGUID = @as(u32, 19);
pub const SPDRP_LEGACYBUSTYPE = @as(u32, 20);
pub const SPDRP_BUSNUMBER = @as(u32, 21);
pub const SPDRP_ENUMERATOR_NAME = @as(u32, 22);
pub const SPDRP_SECURITY = @as(u32, 23);
pub const SPDRP_SECURITY_SDS = @as(u32, 24);
pub const SPDRP_DEVTYPE = @as(u32, 25);
pub const SPDRP_EXCLUSIVE = @as(u32, 26);
pub const SPDRP_CHARACTERISTICS = @as(u32, 27);
pub const SPDRP_ADDRESS = @as(u32, 28);
pub const SPDRP_UI_NUMBER_DESC_FORMAT = @as(u32, 29);
pub const SPDRP_DEVICE_POWER_DATA = @as(u32, 30);
pub const SPDRP_REMOVAL_POLICY = @as(u32, 31);
pub const SPDRP_REMOVAL_POLICY_HW_DEFAULT = @as(u32, 32);
pub const SPDRP_REMOVAL_POLICY_OVERRIDE = @as(u32, 33);
pub const SPDRP_INSTALL_STATE = @as(u32, 34);
pub const SPDRP_LOCATION_PATHS = @as(u32, 35);
pub const SPDRP_BASE_CONTAINERID = @as(u32, 36);
pub const SPDRP_MAXIMUM_PROPERTY = @as(u32, 37);
pub const SPCRP_UPPERFILTERS = @as(u32, 17);
pub const SPCRP_LOWERFILTERS = @as(u32, 18);
pub const SPCRP_SECURITY = @as(u32, 23);
pub const SPCRP_SECURITY_SDS = @as(u32, 24);
pub const SPCRP_DEVTYPE = @as(u32, 25);
pub const SPCRP_EXCLUSIVE = @as(u32, 26);
pub const SPCRP_CHARACTERISTICS = @as(u32, 27);
pub const SPCRP_MAXIMUM_PROPERTY = @as(u32, 28);
pub const DMI_MASK = @as(u32, 1);
pub const DMI_BKCOLOR = @as(u32, 2);
pub const DMI_USERECT = @as(u32, 4);
pub const DIGCDP_FLAG_BASIC = @as(u32, 1);
pub const DIGCDP_FLAG_ADVANCED = @as(u32, 2);
pub const DIGCDP_FLAG_REMOTE_BASIC = @as(u32, 3);
pub const DIGCDP_FLAG_REMOTE_ADVANCED = @as(u32, 4);
pub const IDI_RESOURCEFIRST = @as(u32, 159);
pub const IDI_RESOURCE = @as(u32, 159);
pub const IDI_RESOURCELAST = @as(u32, 161);
pub const IDI_RESOURCEOVERLAYFIRST = @as(u32, 161);
pub const IDI_RESOURCEOVERLAYLAST = @as(u32, 161);
pub const IDI_CONFLICT = @as(u32, 161);
pub const IDI_CLASSICON_OVERLAYFIRST = @as(u32, 500);
pub const IDI_CLASSICON_OVERLAYLAST = @as(u32, 502);
pub const IDI_PROBLEM_OVL = @as(u32, 500);
pub const IDI_DISABLED_OVL = @as(u32, 501);
pub const IDI_FORCED_OVL = @as(u32, 502);
pub const SPWPT_SELECTDEVICE = @as(u32, 1);
pub const SPWP_USE_DEVINFO_DATA = @as(u32, 1);
pub const SIGNERSCORE_UNKNOWN = @as(u32, 4278190080);
pub const SIGNERSCORE_W9X_SUSPECT = @as(u32, 3221225472);
pub const SIGNERSCORE_UNSIGNED = @as(u32, 2147483648);
pub const SIGNERSCORE_AUTHENTICODE = @as(u32, 251658240);
pub const SIGNERSCORE_WHQL = @as(u32, 218103813);
pub const SIGNERSCORE_UNCLASSIFIED = @as(u32, 218103812);
pub const SIGNERSCORE_INBOX = @as(u32, 218103811);
pub const SIGNERSCORE_LOGO_STANDARD = @as(u32, 218103810);
pub const SIGNERSCORE_LOGO_PREMIUM = @as(u32, 218103809);
pub const SIGNERSCORE_MASK = @as(u32, 4278190080);
pub const SIGNERSCORE_SIGNED_MASK = @as(u32, 4026531840);
pub const DICUSTOMDEVPROP_MERGE_MULTISZ = @as(u32, 1);
pub const SCWMI_CLOBBER_SECURITY = @as(u32, 1);
pub const MAX_DEVICE_ID_LEN = @as(u32, 200);
pub const MAX_DEVNODE_ID_LEN = @as(u32, 200);
pub const MAX_GUID_STRING_LEN = @as(u32, 39);
pub const MAX_CLASS_NAME_LEN = @as(u32, 32);
pub const MAX_PROFILE_LEN = @as(u32, 80);
pub const MAX_CONFIG_VALUE = @as(u32, 9999);
pub const MAX_INSTANCE_VALUE = @as(u32, 9999);
pub const MAX_MEM_REGISTERS = @as(u32, 9);
pub const MAX_IO_PORTS = @as(u32, 20);
pub const MAX_IRQS = @as(u32, 7);
pub const MAX_DMA_CHANNELS = @as(u32, 7);
pub const DWORD_MAX = @as(u32, 4294967295);
pub const CONFIGMG_VERSION = @as(u32, 1024);
pub const CM_CDMASK_DEVINST = @as(u32, 1);
pub const CM_CDMASK_RESDES = @as(u32, 2);
pub const CM_CDMASK_FLAGS = @as(u32, 4);
pub const CM_CDMASK_DESCRIPTION = @as(u32, 8);
pub const CM_CDMASK_VALID = @as(u32, 15);
pub const CM_CDFLAGS_DRIVER = @as(u32, 1);
pub const CM_CDFLAGS_ROOT_OWNED = @as(u32, 2);
pub const CM_CDFLAGS_RESERVED = @as(u32, 4);
pub const IO_ALIAS_10_BIT_DECODE = @as(u32, 4);
pub const IO_ALIAS_12_BIT_DECODE = @as(u32, 16);
pub const IO_ALIAS_16_BIT_DECODE = @as(u32, 0);
pub const IO_ALIAS_POSITIVE_DECODE = @as(u32, 255);
pub const IOA_Local = @as(u32, 255);
pub const CM_RESDES_WIDTH_DEFAULT = @as(u32, 0);
pub const CM_RESDES_WIDTH_32 = @as(u32, 1);
pub const CM_RESDES_WIDTH_64 = @as(u32, 2);
pub const CM_RESDES_WIDTH_BITS = @as(u32, 3);
pub const PCD_MAX_MEMORY = @as(u32, 2);
pub const PCD_MAX_IO = @as(u32, 2);
pub const CM_HWPI_NOT_DOCKABLE = @as(u32, 0);
pub const CM_HWPI_UNDOCKED = @as(u32, 1);
pub const CM_HWPI_DOCKED = @as(u32, 2);
pub const ResType_All = @as(u32, 0);
pub const ResType_None = @as(u32, 0);
pub const ResType_Mem = @as(u32, 1);
pub const ResType_IO = @as(u32, 2);
pub const ResType_DMA = @as(u32, 3);
pub const ResType_IRQ = @as(u32, 4);
pub const ResType_DoNotUse = @as(u32, 5);
pub const ResType_BusNumber = @as(u32, 6);
pub const ResType_MemLarge = @as(u32, 7);
pub const ResType_MAX = @as(u32, 7);
pub const ResType_Ignored_Bit = @as(u32, 32768);
pub const ResType_ClassSpecific = @as(u32, 65535);
pub const ResType_Reserved = @as(u32, 32768);
pub const ResType_DevicePrivate = @as(u32, 32769);
pub const ResType_PcCardConfig = @as(u32, 32770);
pub const ResType_MfCardConfig = @as(u32, 32771);
pub const ResType_Connection = @as(u32, 32772);
pub const CM_ADD_RANGE_ADDIFCONFLICT = @as(u32, 0);
pub const CM_ADD_RANGE_DONOTADDIFCONFLICT = @as(u32, 1);
pub const CM_ADD_RANGE_BITS = @as(u32, 1);
pub const BASIC_LOG_CONF = @as(u32, 0);
pub const FILTERED_LOG_CONF = @as(u32, 1);
pub const ALLOC_LOG_CONF = @as(u32, 2);
pub const BOOT_LOG_CONF = @as(u32, 3);
pub const FORCED_LOG_CONF = @as(u32, 4);
pub const OVERRIDE_LOG_CONF = @as(u32, 5);
pub const NUM_LOG_CONF = @as(u32, 6);
pub const LOG_CONF_BITS = @as(u32, 7);
pub const PRIORITY_EQUAL_FIRST = @as(u32, 8);
pub const PRIORITY_EQUAL_LAST = @as(u32, 0);
pub const PRIORITY_BIT = @as(u32, 8);
pub const RegDisposition_OpenAlways = @as(u32, 0);
pub const RegDisposition_OpenExisting = @as(u32, 1);
pub const RegDisposition_Bits = @as(u32, 1);
pub const CM_ADD_ID_HARDWARE = @as(u32, 0);
pub const CM_ADD_ID_COMPATIBLE = @as(u32, 1);
pub const CM_ADD_ID_BITS = @as(u32, 1);
pub const CM_CREATE_DEVNODE_NORMAL = @as(u32, 0);
pub const CM_CREATE_DEVNODE_NO_WAIT_INSTALL = @as(u32, 1);
pub const CM_CREATE_DEVNODE_PHANTOM = @as(u32, 2);
pub const CM_CREATE_DEVNODE_GENERATE_ID = @as(u32, 4);
pub const CM_CREATE_DEVNODE_DO_NOT_INSTALL = @as(u32, 8);
pub const CM_CREATE_DEVNODE_BITS = @as(u32, 15);
pub const CM_CREATE_DEVINST_NORMAL = @as(u32, 0);
pub const CM_CREATE_DEVINST_NO_WAIT_INSTALL = @as(u32, 1);
pub const CM_CREATE_DEVINST_PHANTOM = @as(u32, 2);
pub const CM_CREATE_DEVINST_GENERATE_ID = @as(u32, 4);
pub const CM_CREATE_DEVINST_DO_NOT_INSTALL = @as(u32, 8);
pub const CM_CREATE_DEVINST_BITS = @as(u32, 15);
pub const CM_DELETE_CLASS_ONLY = @as(u32, 0);
pub const CM_DELETE_CLASS_SUBKEYS = @as(u32, 1);
pub const CM_DELETE_CLASS_INTERFACE = @as(u32, 2);
pub const CM_DELETE_CLASS_BITS = @as(u32, 3);
pub const CM_ENUMERATE_CLASSES_INSTALLER = @as(u32, 0);
pub const CM_ENUMERATE_CLASSES_INTERFACE = @as(u32, 1);
pub const CM_ENUMERATE_CLASSES_BITS = @as(u32, 1);
pub const CM_DETECT_NEW_PROFILE = @as(u32, 1);
pub const CM_DETECT_CRASHED = @as(u32, 2);
pub const CM_DETECT_HWPROF_FIRST_BOOT = @as(u32, 4);
pub const CM_DETECT_RUN = @as(u32, 2147483648);
pub const CM_DETECT_BITS = @as(u32, 2147483655);
pub const CM_DISABLE_POLITE = @as(u32, 0);
pub const CM_DISABLE_ABSOLUTE = @as(u32, 1);
pub const CM_DISABLE_HARDWARE = @as(u32, 2);
pub const CM_DISABLE_UI_NOT_OK = @as(u32, 4);
pub const CM_DISABLE_PERSIST = @as(u32, 8);
pub const CM_DISABLE_BITS = @as(u32, 15);
pub const CM_GETIDLIST_FILTER_NONE = @as(u32, 0);
pub const CM_GETIDLIST_FILTER_ENUMERATOR = @as(u32, 1);
pub const CM_GETIDLIST_FILTER_SERVICE = @as(u32, 2);
pub const CM_GETIDLIST_FILTER_EJECTRELATIONS = @as(u32, 4);
pub const CM_GETIDLIST_FILTER_REMOVALRELATIONS = @as(u32, 8);
pub const CM_GETIDLIST_FILTER_POWERRELATIONS = @as(u32, 16);
pub const CM_GETIDLIST_FILTER_BUSRELATIONS = @as(u32, 32);
pub const CM_GETIDLIST_DONOTGENERATE = @as(u32, 268435520);
pub const CM_GETIDLIST_FILTER_BITS = @as(u32, 268435583);
pub const CM_GETIDLIST_FILTER_TRANSPORTRELATIONS = @as(u32, 128);
pub const CM_GETIDLIST_FILTER_PRESENT = @as(u32, 256);
pub const CM_GETIDLIST_FILTER_CLASS = @as(u32, 512);
pub const CM_GET_DEVICE_INTERFACE_LIST_PRESENT = @as(u32, 0);
pub const CM_GET_DEVICE_INTERFACE_LIST_ALL_DEVICES = @as(u32, 1);
pub const CM_GET_DEVICE_INTERFACE_LIST_BITS = @as(u32, 1);
pub const CM_DRP_DEVICEDESC = @as(u32, 1);
pub const CM_DRP_HARDWAREID = @as(u32, 2);
pub const CM_DRP_COMPATIBLEIDS = @as(u32, 3);
pub const CM_DRP_UNUSED0 = @as(u32, 4);
pub const CM_DRP_SERVICE = @as(u32, 5);
pub const CM_DRP_UNUSED1 = @as(u32, 6);
pub const CM_DRP_UNUSED2 = @as(u32, 7);
pub const CM_DRP_CLASS = @as(u32, 8);
pub const CM_DRP_CLASSGUID = @as(u32, 9);
pub const CM_DRP_DRIVER = @as(u32, 10);
pub const CM_DRP_CONFIGFLAGS = @as(u32, 11);
pub const CM_DRP_MFG = @as(u32, 12);
pub const CM_DRP_FRIENDLYNAME = @as(u32, 13);
pub const CM_DRP_LOCATION_INFORMATION = @as(u32, 14);
pub const CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME = @as(u32, 15);
pub const CM_DRP_CAPABILITIES = @as(u32, 16);
pub const CM_DRP_UI_NUMBER = @as(u32, 17);
pub const CM_DRP_UPPERFILTERS = @as(u32, 18);
pub const CM_CRP_UPPERFILTERS = @as(u32, 18);
pub const CM_DRP_LOWERFILTERS = @as(u32, 19);
pub const CM_CRP_LOWERFILTERS = @as(u32, 19);
pub const CM_DRP_BUSTYPEGUID = @as(u32, 20);
pub const CM_DRP_LEGACYBUSTYPE = @as(u32, 21);
pub const CM_DRP_BUSNUMBER = @as(u32, 22);
pub const CM_DRP_ENUMERATOR_NAME = @as(u32, 23);
pub const CM_DRP_SECURITY = @as(u32, 24);
pub const CM_CRP_SECURITY = @as(u32, 24);
pub const CM_DRP_SECURITY_SDS = @as(u32, 25);
pub const CM_CRP_SECURITY_SDS = @as(u32, 25);
pub const CM_DRP_DEVTYPE = @as(u32, 26);
pub const CM_CRP_DEVTYPE = @as(u32, 26);
pub const CM_DRP_EXCLUSIVE = @as(u32, 27);
pub const CM_CRP_EXCLUSIVE = @as(u32, 27);
pub const CM_DRP_CHARACTERISTICS = @as(u32, 28);
pub const CM_CRP_CHARACTERISTICS = @as(u32, 28);
pub const CM_DRP_ADDRESS = @as(u32, 29);
pub const CM_DRP_UI_NUMBER_DESC_FORMAT = @as(u32, 30);
pub const CM_DRP_DEVICE_POWER_DATA = @as(u32, 31);
pub const CM_DRP_REMOVAL_POLICY = @as(u32, 32);
pub const CM_DRP_REMOVAL_POLICY_HW_DEFAULT = @as(u32, 33);
pub const CM_DRP_REMOVAL_POLICY_OVERRIDE = @as(u32, 34);
pub const CM_DRP_INSTALL_STATE = @as(u32, 35);
pub const CM_DRP_LOCATION_PATHS = @as(u32, 36);
pub const CM_DRP_BASE_CONTAINERID = @as(u32, 37);
pub const CM_DRP_MIN = @as(u32, 1);
pub const CM_CRP_MIN = @as(u32, 1);
pub const CM_DRP_MAX = @as(u32, 37);
pub const CM_CRP_MAX = @as(u32, 37);
pub const CM_DEVCAP_LOCKSUPPORTED = @as(u32, 1);
pub const CM_DEVCAP_EJECTSUPPORTED = @as(u32, 2);
pub const CM_DEVCAP_REMOVABLE = @as(u32, 4);
pub const CM_DEVCAP_DOCKDEVICE = @as(u32, 8);
pub const CM_DEVCAP_UNIQUEID = @as(u32, 16);
pub const CM_DEVCAP_SILENTINSTALL = @as(u32, 32);
pub const CM_DEVCAP_RAWDEVICEOK = @as(u32, 64);
pub const CM_DEVCAP_SURPRISEREMOVALOK = @as(u32, 128);
pub const CM_DEVCAP_HARDWAREDISABLED = @as(u32, 256);
pub const CM_DEVCAP_NONDYNAMIC = @as(u32, 512);
pub const CM_DEVCAP_SECUREDEVICE = @as(u32, 1024);
pub const CM_REMOVAL_POLICY_EXPECT_NO_REMOVAL = @as(u32, 1);
pub const CM_REMOVAL_POLICY_EXPECT_ORDERLY_REMOVAL = @as(u32, 2);
pub const CM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVAL = @as(u32, 3);
pub const CM_INSTALL_STATE_INSTALLED = @as(u32, 0);
pub const CM_INSTALL_STATE_NEEDS_REINSTALL = @as(u32, 1);
pub const CM_INSTALL_STATE_FAILED_INSTALL = @as(u32, 2);
pub const CM_INSTALL_STATE_FINISH_INSTALL = @as(u32, 3);
pub const CM_LOCATE_DEVNODE_NORMAL = @as(u32, 0);
pub const CM_LOCATE_DEVNODE_PHANTOM = @as(u32, 1);
pub const CM_LOCATE_DEVNODE_CANCELREMOVE = @as(u32, 2);
pub const CM_LOCATE_DEVNODE_NOVALIDATION = @as(u32, 4);
pub const CM_LOCATE_DEVNODE_BITS = @as(u32, 7);
pub const CM_LOCATE_DEVINST_NORMAL = @as(u32, 0);
pub const CM_LOCATE_DEVINST_PHANTOM = @as(u32, 1);
pub const CM_LOCATE_DEVINST_CANCELREMOVE = @as(u32, 2);
pub const CM_LOCATE_DEVINST_NOVALIDATION = @as(u32, 4);
pub const CM_LOCATE_DEVINST_BITS = @as(u32, 7);
pub const CM_OPEN_CLASS_KEY_INSTALLER = @as(u32, 0);
pub const CM_OPEN_CLASS_KEY_INTERFACE = @as(u32, 1);
pub const CM_OPEN_CLASS_KEY_BITS = @as(u32, 1);
pub const CM_REMOVE_UI_OK = @as(u32, 0);
pub const CM_REMOVE_UI_NOT_OK = @as(u32, 1);
pub const CM_REMOVE_NO_RESTART = @as(u32, 2);
pub const CM_REMOVE_DISABLE = @as(u32, 4);
pub const CM_REMOVE_BITS = @as(u32, 7);
pub const CM_QUERY_REMOVE_UI_OK = @as(u32, 0);
pub const CM_QUERY_REMOVE_UI_NOT_OK = @as(u32, 1);
pub const CM_REENUMERATE_NORMAL = @as(u32, 0);
pub const CM_REENUMERATE_SYNCHRONOUS = @as(u32, 1);
pub const CM_REENUMERATE_RETRY_INSTALLATION = @as(u32, 2);
pub const CM_REENUMERATE_ASYNCHRONOUS = @as(u32, 4);
pub const CM_REENUMERATE_BITS = @as(u32, 7);
pub const CM_REGISTER_DEVICE_DRIVER_STATIC = @as(u32, 0);
pub const CM_REGISTER_DEVICE_DRIVER_DISABLEABLE = @as(u32, 1);
pub const CM_REGISTER_DEVICE_DRIVER_REMOVABLE = @as(u32, 2);
pub const CM_REGISTER_DEVICE_DRIVER_BITS = @as(u32, 3);
pub const CM_REGISTRY_HARDWARE = @as(u32, 0);
pub const CM_REGISTRY_SOFTWARE = @as(u32, 1);
pub const CM_REGISTRY_USER = @as(u32, 256);
pub const CM_REGISTRY_CONFIG = @as(u32, 512);
pub const CM_REGISTRY_BITS = @as(u32, 769);
pub const CM_SET_DEVNODE_PROBLEM_NORMAL = @as(u32, 0);
pub const CM_SET_DEVNODE_PROBLEM_OVERRIDE = @as(u32, 1);
pub const CM_SET_DEVNODE_PROBLEM_BITS = @as(u32, 1);
pub const CM_SET_DEVINST_PROBLEM_NORMAL = @as(u32, 0);
pub const CM_SET_DEVINST_PROBLEM_OVERRIDE = @as(u32, 1);
pub const CM_SET_DEVINST_PROBLEM_BITS = @as(u32, 1);
pub const CM_SET_HW_PROF_FLAGS_UI_NOT_OK = @as(u32, 1);
pub const CM_SET_HW_PROF_FLAGS_BITS = @as(u32, 1);
pub const CM_SETUP_DEVNODE_READY = @as(u32, 0);
pub const CM_SETUP_DEVINST_READY = @as(u32, 0);
pub const CM_SETUP_DOWNLOAD = @as(u32, 1);
pub const CM_SETUP_WRITE_LOG_CONFS = @as(u32, 2);
pub const CM_SETUP_PROP_CHANGE = @as(u32, 3);
pub const CM_SETUP_DEVNODE_RESET = @as(u32, 4);
pub const CM_SETUP_DEVINST_RESET = @as(u32, 4);
pub const CM_SETUP_DEVNODE_CONFIG = @as(u32, 5);
pub const CM_SETUP_DEVINST_CONFIG = @as(u32, 5);
pub const CM_SETUP_DEVNODE_CONFIG_CLASS = @as(u32, 6);
pub const CM_SETUP_DEVINST_CONFIG_CLASS = @as(u32, 6);
pub const CM_SETUP_DEVNODE_CONFIG_EXTENSIONS = @as(u32, 7);
pub const CM_SETUP_DEVINST_CONFIG_EXTENSIONS = @as(u32, 7);
pub const CM_SETUP_DEVNODE_CONFIG_RESET = @as(u32, 8);
pub const CM_SETUP_DEVINST_CONFIG_RESET = @as(u32, 8);
pub const CM_SETUP_BITS = @as(u32, 15);
pub const CM_QUERY_ARBITRATOR_RAW = @as(u32, 0);
pub const CM_QUERY_ARBITRATOR_TRANSLATED = @as(u32, 1);
pub const CM_QUERY_ARBITRATOR_BITS = @as(u32, 1);
pub const CM_CUSTOMDEVPROP_MERGE_MULTISZ = @as(u32, 1);
pub const CM_CUSTOMDEVPROP_BITS = @as(u32, 1);
pub const CM_NAME_ATTRIBUTE_NAME_RETRIEVED_FROM_DEVICE = @as(u32, 1);
pub const CM_NAME_ATTRIBUTE_USER_ASSIGNED_NAME = @as(u32, 2);
pub const CM_CLASS_PROPERTY_INSTALLER = @as(u32, 0);
pub const CM_CLASS_PROPERTY_INTERFACE = @as(u32, 1);
pub const CM_CLASS_PROPERTY_BITS = @as(u32, 1);
pub const CM_NOTIFY_FILTER_FLAG_ALL_INTERFACE_CLASSES = @as(u32, 1);
pub const CM_NOTIFY_FILTER_FLAG_ALL_DEVICE_INSTANCES = @as(u32, 2);
pub const CM_GLOBAL_STATE_CAN_DO_UI = @as(u32, 1);
pub const CM_GLOBAL_STATE_ON_BIG_STACK = @as(u32, 2);
pub const CM_GLOBAL_STATE_SERVICES_AVAILABLE = @as(u32, 4);
pub const CM_GLOBAL_STATE_SHUTTING_DOWN = @as(u32, 8);
pub const CM_GLOBAL_STATE_DETECTION_PENDING = @as(u32, 16);
pub const CM_GLOBAL_STATE_REBOOT_REQUIRED = @as(u32, 32);
pub const INSTALLFLAG_FORCE = @as(u32, 1);
pub const INSTALLFLAG_READONLY = @as(u32, 2);
pub const INSTALLFLAG_NONINTERACTIVE = @as(u32, 4);
pub const INSTALLFLAG_BITS = @as(u32, 7);
pub const DIIDFLAG_SHOWSEARCHUI = @as(u32, 1);
pub const DIIDFLAG_NOFINISHINSTALLUI = @as(u32, 2);
pub const DIIDFLAG_INSTALLNULLDRIVER = @as(u32, 4);
pub const DIIDFLAG_INSTALLCOPYINFDRIVERS = @as(u32, 8);
pub const DIIDFLAG_BITS = @as(u32, 15);
pub const DIIRFLAG_INF_ALREADY_COPIED = @as(u32, 1);
pub const DIIRFLAG_FORCE_INF = @as(u32, 2);
pub const DIIRFLAG_HW_USING_THE_INF = @as(u32, 4);
pub const DIIRFLAG_HOTPATCH = @as(u32, 8);
pub const DIIRFLAG_NOBACKUP = @as(u32, 16);
pub const DIIRFLAG_PRE_CONFIGURE_INF = @as(u32, 32);
pub const DIIRFLAG_INSTALL_AS_SET = @as(u32, 64);
pub const DIURFLAG_NO_REMOVE_INF = @as(u32, 1);
pub const DIURFLAG_RESERVED = @as(u32, 2);
pub const ROLLBACK_FLAG_NO_UI = @as(u32, 1);
pub const ROLLBACK_BITS = @as(u32, 1);
pub const MAX_KEY_LEN = @as(u32, 100);
pub const MAX_PRIORITYSTR_LEN = @as(u32, 16);
pub const MAX_INF_FLAG = @as(u32, 20);
pub const MAX_INFSTR_STRKEY_LEN = @as(u32, 32);
pub const GUID_HWPROFILE_QUERY_CHANGE = Guid.initString("cb3a4001-46f0-11d0-b08f-00609713053f");
pub const GUID_HWPROFILE_CHANGE_CANCELLED = Guid.initString("cb3a4002-46f0-11d0-b08f-00609713053f");
pub const GUID_HWPROFILE_CHANGE_COMPLETE = Guid.initString("cb3a4003-46f0-11d0-b08f-00609713053f");
pub const GUID_DEVICE_INTERFACE_ARRIVAL = Guid.initString("cb3a4004-46f0-11d0-b08f-00609713053f");
pub const GUID_DEVICE_INTERFACE_REMOVAL = Guid.initString("cb3a4005-46f0-11d0-b08f-00609713053f");
pub const GUID_TARGET_DEVICE_QUERY_REMOVE = Guid.initString("cb3a4006-46f0-11d0-b08f-00609713053f");
pub const GUID_TARGET_DEVICE_REMOVE_CANCELLED = Guid.initString("cb3a4007-46f0-11d0-b08f-00609713053f");
pub const GUID_TARGET_DEVICE_REMOVE_COMPLETE = Guid.initString("cb3a4008-46f0-11d0-b08f-00609713053f");
pub const GUID_PNP_CUSTOM_NOTIFICATION = Guid.initString("aca73f8e-8d23-11d1-ac7d-0000f87571d0");
pub const GUID_PNP_POWER_NOTIFICATION = Guid.initString("c2cf0660-eb7a-11d1-bd7f-0000f87571d0");
pub const GUID_PNP_POWER_SETTING_CHANGE = Guid.initString("29c69b3e-c79a-43bf-bbde-a932fa1bea7e");
pub const GUID_TARGET_DEVICE_TRANSPORT_RELATIONS_CHANGED = Guid.initString("fcf528f6-a82f-47b1-ad3a-8050594cad28");
pub const GUID_KERNEL_SOFT_RESTART_PREPARE = Guid.initString("de373def-a85c-4f76-8cbf-f96bea8bd10f");
pub const GUID_KERNEL_SOFT_RESTART_CANCEL = Guid.initString("31d737e7-8c0b-468a-956e-9f433ec358fb");
pub const GUID_RECOVERY_PCI_PREPARE_SHUTDOWN = Guid.initString("90d889de-8704-44cf-8115-ed8528d2b2da");
pub const GUID_RECOVERY_NVMED_PREPARE_SHUTDOWN = Guid.initString("4b9770ea-bde7-400b-a9b9-4f684f54cc2a");
pub const GUID_KERNEL_SOFT_RESTART_FINALIZE = Guid.initString("20e91abd-350a-4d4f-8577-99c81507473a");
pub const GUID_BUS_INTERFACE_STANDARD = Guid.initString("496b8280-6f25-11d0-beaf-08002be2092f");
pub const GUID_PCI_BUS_INTERFACE_STANDARD = Guid.initString("496b8281-6f25-11d0-beaf-08002be2092f");
pub const GUID_PCI_BUS_INTERFACE_STANDARD2 = Guid.initString("de94e966-fdff-4c9c-9998-6747b150e74c");
pub const GUID_ARBITER_INTERFACE_STANDARD = Guid.initString("e644f185-8c0e-11d0-becf-08002be2092f");
pub const GUID_TRANSLATOR_INTERFACE_STANDARD = Guid.initString("6c154a92-aacf-11d0-8d2a-00a0c906b244");
pub const GUID_ACPI_INTERFACE_STANDARD = Guid.initString("b091a08a-ba97-11d0-bd14-00aa00b7b32a");
pub const GUID_INT_ROUTE_INTERFACE_STANDARD = Guid.initString("70941bf4-0073-11d1-a09e-00c04fc340b1");
pub const GUID_PCMCIA_BUS_INTERFACE_STANDARD = Guid.initString("76173af0-c504-11d1-947f-00c04fb960ee");
pub const GUID_ACPI_REGS_INTERFACE_STANDARD = Guid.initString("06141966-7245-6369-462e-4e656c736f6e");
pub const GUID_LEGACY_DEVICE_DETECTION_STANDARD = Guid.initString("50feb0de-596a-11d2-a5b8-0000f81a4619");
pub const GUID_PCI_DEVICE_PRESENT_INTERFACE = Guid.initString("d1b82c26-bf49-45ef-b216-71cbd7889b57");
pub const GUID_MF_ENUMERATION_INTERFACE = Guid.initString("aeb895f0-5586-11d1-8d84-00a0c906b244");
pub const GUID_REENUMERATE_SELF_INTERFACE_STANDARD = Guid.initString("2aeb0243-6a6e-486b-82fc-d815f6b97006");
pub const GUID_AGP_TARGET_BUS_INTERFACE_STANDARD = Guid.initString("b15cfce8-06d1-4d37-9d4c-bedde0c2a6ff");
pub const GUID_ACPI_CMOS_INTERFACE_STANDARD = Guid.initString("3a8d0384-6505-40ca-bc39-56c15f8c5fed");
pub const GUID_ACPI_PORT_RANGES_INTERFACE_STANDARD = Guid.initString("f14f609b-cbbd-4957-a674-bc00213f1c97");
pub const GUID_ACPI_INTERFACE_STANDARD2 = Guid.initString("e8695f63-1831-4870-a8cf-9c2f03f9dcb5");
pub const GUID_PNP_LOCATION_INTERFACE = Guid.initString("70211b0e-0afb-47db-afc1-410bf842497a");
pub const GUID_PCI_EXPRESS_LINK_QUIESCENT_INTERFACE = Guid.initString("146cd41c-dae3-4437-8aff-2af3f038099b");
pub const GUID_PCI_EXPRESS_ROOT_PORT_INTERFACE = Guid.initString("83a7734a-84c7-4161-9a98-6000ed0c4a33");
pub const GUID_MSIX_TABLE_CONFIG_INTERFACE = Guid.initString("1a6a460b-194f-455d-b34b-b84c5b05712b");
pub const GUID_D3COLD_SUPPORT_INTERFACE = Guid.initString("b38290e5-3cd0-4f9d-9937-f5fe2b44d47a");
pub const GUID_PROCESSOR_PCC_INTERFACE_STANDARD = Guid.initString("37b17e9a-c21c-4296-972d-11c4b32b28f0");
pub const GUID_PCI_VIRTUALIZATION_INTERFACE = Guid.initString("64897b47-3a4a-4d75-bc74-89dd6c078293");
pub const GUID_PCC_INTERFACE_STANDARD = Guid.initString("3ee8ba63-0f59-4a24-8a45-35808bdd1249");
pub const GUID_PCC_INTERFACE_INTERNAL = Guid.initString("7cce62ce-c189-4814-a6a7-12112089e938");
pub const GUID_THERMAL_COOLING_INTERFACE = Guid.initString("ecbe47a8-c498-4bb9-bd70-e867e0940d22");
pub const GUID_DMA_CACHE_COHERENCY_INTERFACE = Guid.initString("b520f7fa-8a5a-4e40-a3f6-6be1e162d935");
pub const GUID_DEVICE_RESET_INTERFACE_STANDARD = Guid.initString("649fdf26-3bc0-4813-ad24-7e0c1eda3fa3");
pub const GUID_IOMMU_BUS_INTERFACE = Guid.initString("1efee0b2-d278-4ae4-bddc-1b34dd648043");
pub const GUID_PCI_SECURITY_INTERFACE = Guid.initString("6e7f1451-199e-4acc-ba2d-762b4edf4674");
pub const GUID_SCM_BUS_INTERFACE = Guid.initString("25944783-ce79-4232-815e-4a30014e8eb4");
pub const GUID_SECURE_DRIVER_INTERFACE = Guid.initString("370f67e1-4ff5-4a94-9a35-06c5d9cc30e2");
pub const GUID_SDEV_IDENTIFIER_INTERFACE = Guid.initString("49d67af8-916c-4ee8-9df1-889f17d21e91");
pub const GUID_SCM_BUS_NVD_INTERFACE = Guid.initString("8de064ff-b630-42e4-88ea-6f24c8641175");
pub const GUID_SCM_BUS_LD_INTERFACE = Guid.initString("9b89307d-d76b-4f48-b186-54041ae92e8d");
pub const GUID_SCM_PHYSICAL_NVDIMM_INTERFACE = Guid.initString("0079c21b-917e-405e-a9ce-0732b5bbcebd");
pub const GUID_PNP_EXTENDED_ADDRESS_INTERFACE = Guid.initString("b8e992ec-a797-4dc4-8846-84d041707446");
pub const GUID_D3COLD_AUX_POWER_AND_TIMING_INTERFACE = Guid.initString("0044d8aa-f664-4588-9ffc-2afeaf5950b9");
pub const GUID_PCI_FPGA_CONTROL_INTERFACE = Guid.initString("2df3f7a8-b9b3-4063-9215-b5d14a0b266e");
pub const GUID_PCI_PTM_CONTROL_INTERFACE = Guid.initString("348a5ebb-ba24-44b7-9916-285687735117");
pub const GUID_BUS_RESOURCE_UPDATE_INTERFACE = Guid.initString("27d0102d-bfb2-4164-81dd-dbb82f968b48");
pub const GUID_NPEM_CONTROL_INTERFACE = Guid.initString("4d95573d-b774-488a-b120-4f284a9eff51");
pub const GUID_PCI_ATS_INTERFACE = Guid.initString("010a7fe8-96f5-4943-bedf-95e651b93412");
pub const GUID_BUS_TYPE_INTERNAL = Guid.initString("1530ea73-086b-11d1-a09f-00c04fc340b1");
pub const GUID_BUS_TYPE_PCMCIA = Guid.initString("09343630-af9f-11d0-92e9-0000f81e1b30");
pub const GUID_BUS_TYPE_PCI = Guid.initString("c8ebdfb0-b510-11d0-80e5-00a0c92542e3");
pub const GUID_BUS_TYPE_ISAPNP = Guid.initString("e676f854-d87d-11d0-92b2-00a0c9055fc5");
pub const GUID_BUS_TYPE_EISA = Guid.initString("ddc35509-f3fc-11d0-a537-0000f8753ed1");
pub const GUID_BUS_TYPE_MCA = Guid.initString("1c75997a-dc33-11d0-92b2-00a0c9055fc5");
pub const GUID_BUS_TYPE_SERENUM = Guid.initString("77114a87-8944-11d1-bd90-00a0c906be2d");
pub const GUID_BUS_TYPE_USB = Guid.initString("9d7debbc-c85d-11d1-9eb4-006008c3a19a");
pub const GUID_BUS_TYPE_LPTENUM = Guid.initString("c4ca1000-2ddc-11d5-a17a-00c04f60524d");
pub const GUID_BUS_TYPE_USBPRINT = Guid.initString("441ee000-4342-11d5-a184-00c04f60524d");
pub const GUID_BUS_TYPE_DOT4PRT = Guid.initString("441ee001-4342-11d5-a184-00c04f60524d");
pub const GUID_BUS_TYPE_1394 = Guid.initString("f74e73eb-9ac5-45eb-be4d-772cc71ddfb3");
pub const GUID_BUS_TYPE_HID = Guid.initString("eeaf37d0-1963-47c4-aa48-72476db7cf49");
pub const GUID_BUS_TYPE_AVC = Guid.initString("c06ff265-ae09-48f0-812c-16753d7cba83");
pub const GUID_BUS_TYPE_IRDA = Guid.initString("7ae17dc1-c944-44d6-881f-4c2e61053bc1");
pub const GUID_BUS_TYPE_SD = Guid.initString("e700cc04-4036-4e89-9579-89ebf45f00cd");
pub const GUID_BUS_TYPE_ACPI = Guid.initString("d7b46895-001a-4942-891f-a7d46610a843");
pub const GUID_BUS_TYPE_SW_DEVICE = Guid.initString("06d10322-7de0-4cef-8e25-197d0e7442e2");
pub const GUID_BUS_TYPE_SCM = Guid.initString("375a5912-804c-45aa-bdc2-fdd25a1d9512");
pub const GUID_POWER_DEVICE_ENABLE = Guid.initString("827c0a6f-feb0-11d0-bd26-00aa00b7b32a");
pub const GUID_POWER_DEVICE_TIMEOUTS = Guid.initString("a45da735-feb0-11d0-bd26-00aa00b7b32a");
pub const GUID_POWER_DEVICE_WAKE_ENABLE = Guid.initString("a9546a82-feb0-11d0-bd26-00aa00b7b32a");
pub const GUID_WUDF_DEVICE_HOST_PROBLEM = Guid.initString("c43d25bd-9346-40ee-a2d2-d70c15f8b75b");
pub const GUID_PARTITION_UNIT_INTERFACE_STANDARD = Guid.initString("52363f5b-d891-429b-8195-aec5fef6853c");
pub const GUID_QUERY_CRASHDUMP_FUNCTIONS = Guid.initString("9cc6b8ff-32e2-4834-b1de-b32ef8880a4b");
//--------------------------------------------------------------------------------
// Section: Types (172)
//--------------------------------------------------------------------------------
pub const SP_COPY_STYLE = enum(u32) {
DELETESOURCE = 1,
REPLACEONLY = 2,
NEWER_OR_SAME = 4,
NEWER_ONLY = 65536,
NOOVERWRITE = 8,
NODECOMP = 16,
LANGUAGEAWARE = 32,
SOURCE_ABSOLUTE = 64,
SOURCEPATH_ABSOLUTE = 128,
FORCE_IN_USE = 512,
IN_USE_NEEDS_REBOOT = 256,
NOSKIP = 1024,
FORCE_NOOVERWRITE = 4096,
FORCE_NEWER = 8192,
WARNIFSKIP = 16384,
NOBROWSE = 32768,
// NEWER = 4, this enum value conflicts with NEWER_OR_SAME
RESERVED = 131072,
OEMINF_CATALOG_ONLY = 262144,
REPLACE_BOOT_FILE = 524288,
NOPRUNE = 1048576,
OEM_F6_INF = 2097152,
ALREADYDECOMP = 4194304,
WINDOWS_SIGNED = 16777216,
PNPLOCKED = 33554432,
IN_USE_TRY_RENAME = 67108864,
INBOX_INF = 134217728,
HARDLINK = 268435456,
_,
pub fn initFlags(o: struct {
DELETESOURCE: u1 = 0,
REPLACEONLY: u1 = 0,
NEWER_OR_SAME: u1 = 0,
NEWER_ONLY: u1 = 0,
NOOVERWRITE: u1 = 0,
NODECOMP: u1 = 0,
LANGUAGEAWARE: u1 = 0,
SOURCE_ABSOLUTE: u1 = 0,
SOURCEPATH_ABSOLUTE: u1 = 0,
FORCE_IN_USE: u1 = 0,
IN_USE_NEEDS_REBOOT: u1 = 0,
NOSKIP: u1 = 0,
FORCE_NOOVERWRITE: u1 = 0,
FORCE_NEWER: u1 = 0,
WARNIFSKIP: u1 = 0,
NOBROWSE: u1 = 0,
RESERVED: u1 = 0,
OEMINF_CATALOG_ONLY: u1 = 0,
REPLACE_BOOT_FILE: u1 = 0,
NOPRUNE: u1 = 0,
OEM_F6_INF: u1 = 0,
ALREADYDECOMP: u1 = 0,
WINDOWS_SIGNED: u1 = 0,
PNPLOCKED: u1 = 0,
IN_USE_TRY_RENAME: u1 = 0,
INBOX_INF: u1 = 0,
HARDLINK: u1 = 0,
}) SP_COPY_STYLE {
return @intToEnum(SP_COPY_STYLE,
(if (o.DELETESOURCE == 1) @enumToInt(SP_COPY_STYLE.DELETESOURCE) else 0)
| (if (o.REPLACEONLY == 1) @enumToInt(SP_COPY_STYLE.REPLACEONLY) else 0)
| (if (o.NEWER_OR_SAME == 1) @enumToInt(SP_COPY_STYLE.NEWER_OR_SAME) else 0)
| (if (o.NEWER_ONLY == 1) @enumToInt(SP_COPY_STYLE.NEWER_ONLY) else 0)
| (if (o.NOOVERWRITE == 1) @enumToInt(SP_COPY_STYLE.NOOVERWRITE) else 0)
| (if (o.NODECOMP == 1) @enumToInt(SP_COPY_STYLE.NODECOMP) else 0)
| (if (o.LANGUAGEAWARE == 1) @enumToInt(SP_COPY_STYLE.LANGUAGEAWARE) else 0)
| (if (o.SOURCE_ABSOLUTE == 1) @enumToInt(SP_COPY_STYLE.SOURCE_ABSOLUTE) else 0)
| (if (o.SOURCEPATH_ABSOLUTE == 1) @enumToInt(SP_COPY_STYLE.SOURCEPATH_ABSOLUTE) else 0)
| (if (o.FORCE_IN_USE == 1) @enumToInt(SP_COPY_STYLE.FORCE_IN_USE) else 0)
| (if (o.IN_USE_NEEDS_REBOOT == 1) @enumToInt(SP_COPY_STYLE.IN_USE_NEEDS_REBOOT) else 0)
| (if (o.NOSKIP == 1) @enumToInt(SP_COPY_STYLE.NOSKIP) else 0)
| (if (o.FORCE_NOOVERWRITE == 1) @enumToInt(SP_COPY_STYLE.FORCE_NOOVERWRITE) else 0)
| (if (o.FORCE_NEWER == 1) @enumToInt(SP_COPY_STYLE.FORCE_NEWER) else 0)
| (if (o.WARNIFSKIP == 1) @enumToInt(SP_COPY_STYLE.WARNIFSKIP) else 0)
| (if (o.NOBROWSE == 1) @enumToInt(SP_COPY_STYLE.NOBROWSE) else 0)
| (if (o.RESERVED == 1) @enumToInt(SP_COPY_STYLE.RESERVED) else 0)
| (if (o.OEMINF_CATALOG_ONLY == 1) @enumToInt(SP_COPY_STYLE.OEMINF_CATALOG_ONLY) else 0)
| (if (o.REPLACE_BOOT_FILE == 1) @enumToInt(SP_COPY_STYLE.REPLACE_BOOT_FILE) else 0)
| (if (o.NOPRUNE == 1) @enumToInt(SP_COPY_STYLE.NOPRUNE) else 0)
| (if (o.OEM_F6_INF == 1) @enumToInt(SP_COPY_STYLE.OEM_F6_INF) else 0)
| (if (o.ALREADYDECOMP == 1) @enumToInt(SP_COPY_STYLE.ALREADYDECOMP) else 0)
| (if (o.WINDOWS_SIGNED == 1) @enumToInt(SP_COPY_STYLE.WINDOWS_SIGNED) else 0)
| (if (o.PNPLOCKED == 1) @enumToInt(SP_COPY_STYLE.PNPLOCKED) else 0)
| (if (o.IN_USE_TRY_RENAME == 1) @enumToInt(SP_COPY_STYLE.IN_USE_TRY_RENAME) else 0)
| (if (o.INBOX_INF == 1) @enumToInt(SP_COPY_STYLE.INBOX_INF) else 0)
| (if (o.HARDLINK == 1) @enumToInt(SP_COPY_STYLE.HARDLINK) else 0)
);
}
};
pub const SP_COPY_DELETESOURCE = SP_COPY_STYLE.DELETESOURCE;
pub const SP_COPY_REPLACEONLY = SP_COPY_STYLE.REPLACEONLY;
pub const SP_COPY_NEWER_OR_SAME = SP_COPY_STYLE.NEWER_OR_SAME;
pub const SP_COPY_NEWER_ONLY = SP_COPY_STYLE.NEWER_ONLY;
pub const SP_COPY_NOOVERWRITE = SP_COPY_STYLE.NOOVERWRITE;
pub const SP_COPY_NODECOMP = SP_COPY_STYLE.NODECOMP;
pub const SP_COPY_LANGUAGEAWARE = SP_COPY_STYLE.LANGUAGEAWARE;
pub const SP_COPY_SOURCE_ABSOLUTE = SP_COPY_STYLE.SOURCE_ABSOLUTE;
pub const SP_COPY_SOURCEPATH_ABSOLUTE = SP_COPY_STYLE.SOURCEPATH_ABSOLUTE;
pub const SP_COPY_FORCE_IN_USE = SP_COPY_STYLE.FORCE_IN_USE;
pub const SP_COPY_IN_USE_NEEDS_REBOOT = SP_COPY_STYLE.IN_USE_NEEDS_REBOOT;
pub const SP_COPY_NOSKIP = SP_COPY_STYLE.NOSKIP;
pub const SP_COPY_FORCE_NOOVERWRITE = SP_COPY_STYLE.FORCE_NOOVERWRITE;
pub const SP_COPY_FORCE_NEWER = SP_COPY_STYLE.FORCE_NEWER;
pub const SP_COPY_WARNIFSKIP = SP_COPY_STYLE.WARNIFSKIP;
pub const SP_COPY_NOBROWSE = SP_COPY_STYLE.NOBROWSE;
pub const SP_COPY_NEWER = SP_COPY_STYLE.NEWER_OR_SAME;
pub const SP_COPY_RESERVED = SP_COPY_STYLE.RESERVED;
pub const SP_COPY_OEMINF_CATALOG_ONLY = SP_COPY_STYLE.OEMINF_CATALOG_ONLY;
pub const SP_COPY_REPLACE_BOOT_FILE = SP_COPY_STYLE.REPLACE_BOOT_FILE;
pub const SP_COPY_NOPRUNE = SP_COPY_STYLE.NOPRUNE;
pub const SP_COPY_OEM_F6_INF = SP_COPY_STYLE.OEM_F6_INF;
pub const SP_COPY_ALREADYDECOMP = SP_COPY_STYLE.ALREADYDECOMP;
pub const SP_COPY_WINDOWS_SIGNED = SP_COPY_STYLE.WINDOWS_SIGNED;
pub const SP_COPY_PNPLOCKED = SP_COPY_STYLE.PNPLOCKED;
pub const SP_COPY_IN_USE_TRY_RENAME = SP_COPY_STYLE.IN_USE_TRY_RENAME;
pub const SP_COPY_INBOX_INF = SP_COPY_STYLE.INBOX_INF;
pub const SP_COPY_HARDLINK = SP_COPY_STYLE.HARDLINK;
pub const SETUP_FILE_OPERATION = enum(u32) {
DELETE = 2,
COPY = 0,
};
pub const FILEOP_DELETE = SETUP_FILE_OPERATION.DELETE;
pub const FILEOP_COPY = SETUP_FILE_OPERATION.COPY;
pub const OEM_SOURCE_MEDIA_TYPE = enum(u32) {
NONE = 0,
PATH = 1,
URL = 2,
};
pub const SPOST_NONE = OEM_SOURCE_MEDIA_TYPE.NONE;
pub const SPOST_PATH = OEM_SOURCE_MEDIA_TYPE.PATH;
pub const SPOST_URL = OEM_SOURCE_MEDIA_TYPE.URL;
pub const SETUP_DI_BUILD_DRIVER_DRIVER_TYPE = enum(u32) {
LASSDRIVER = 1,
OMPATDRIVER = 2,
};
pub const SPDIT_CLASSDRIVER = SETUP_DI_BUILD_DRIVER_DRIVER_TYPE.LASSDRIVER;
pub const SPDIT_COMPATDRIVER = SETUP_DI_BUILD_DRIVER_DRIVER_TYPE.OMPATDRIVER;
pub const SP_INF_STYLE = enum(u32) {
NONE = 0,
OLDNT = 1,
WIN4 = 2,
};
pub const INF_STYLE_NONE = SP_INF_STYLE.NONE;
pub const INF_STYLE_OLDNT = SP_INF_STYLE.OLDNT;
pub const INF_STYLE_WIN4 = SP_INF_STYLE.WIN4;
pub const CONFIGRET = enum(u32) {
CR_SUCCESS = 0,
CR_DEFAULT = 1,
CR_OUT_OF_MEMORY = 2,
CR_INVALID_POINTER = 3,
CR_INVALID_FLAG = 4,
CR_INVALID_DEVNODE = 5,
// CR_INVALID_DEVINST = 5, this enum value conflicts with CR_INVALID_DEVNODE
CR_INVALID_RES_DES = 6,
CR_INVALID_LOG_CONF = 7,
CR_INVALID_ARBITRATOR = 8,
CR_INVALID_NODELIST = 9,
CR_DEVNODE_HAS_REQS = 10,
// CR_DEVINST_HAS_REQS = 10, this enum value conflicts with CR_DEVNODE_HAS_REQS
CR_INVALID_RESOURCEID = 11,
CR_DLVXD_NOT_FOUND = 12,
CR_NO_SUCH_DEVNODE = 13,
// CR_NO_SUCH_DEVINST = 13, this enum value conflicts with CR_NO_SUCH_DEVNODE
CR_NO_MORE_LOG_CONF = 14,
CR_NO_MORE_RES_DES = 15,
CR_ALREADY_SUCH_DEVNODE = 16,
// CR_ALREADY_SUCH_DEVINST = 16, this enum value conflicts with CR_ALREADY_SUCH_DEVNODE
CR_INVALID_RANGE_LIST = 17,
CR_INVALID_RANGE = 18,
CR_FAILURE = 19,
CR_NO_SUCH_LOGICAL_DEV = 20,
CR_CREATE_BLOCKED = 21,
CR_NOT_SYSTEM_VM = 22,
CR_REMOVE_VETOED = 23,
CR_APM_VETOED = 24,
CR_INVALID_LOAD_TYPE = 25,
CR_BUFFER_SMALL = 26,
CR_NO_ARBITRATOR = 27,
CR_NO_REGISTRY_HANDLE = 28,
CR_REGISTRY_ERROR = 29,
CR_INVALID_DEVICE_ID = 30,
CR_INVALID_DATA = 31,
CR_INVALID_API = 32,
CR_DEVLOADER_NOT_READY = 33,
CR_NEED_RESTART = 34,
CR_NO_MORE_HW_PROFILES = 35,
CR_DEVICE_NOT_THERE = 36,
CR_NO_SUCH_VALUE = 37,
CR_WRONG_TYPE = 38,
CR_INVALID_PRIORITY = 39,
CR_NOT_DISABLEABLE = 40,
CR_FREE_RESOURCES = 41,
CR_QUERY_VETOED = 42,
CR_CANT_SHARE_IRQ = 43,
CR_NO_DEPENDENT = 44,
CR_SAME_RESOURCES = 45,
CR_NO_SUCH_REGISTRY_KEY = 46,
CR_INVALID_MACHINENAME = 47,
CR_REMOTE_COMM_FAILURE = 48,
CR_MACHINE_UNAVAILABLE = 49,
CR_NO_CM_SERVICES = 50,
CR_ACCESS_DENIED = 51,
CR_CALL_NOT_IMPLEMENTED = 52,
CR_INVALID_PROPERTY = 53,
CR_DEVICE_INTERFACE_ACTIVE = 54,
CR_NO_SUCH_DEVICE_INTERFACE = 55,
CR_INVALID_REFERENCE_STRING = 56,
CR_INVALID_CONFLICT_LIST = 57,
CR_INVALID_INDEX = 58,
CR_INVALID_STRUCTURE_SIZE = 59,
NUM_CR_RESULTS = 60,
};
pub const CR_SUCCESS = CONFIGRET.CR_SUCCESS;
pub const CR_DEFAULT = CONFIGRET.CR_DEFAULT;
pub const CR_OUT_OF_MEMORY = CONFIGRET.CR_OUT_OF_MEMORY;
pub const CR_INVALID_POINTER = CONFIGRET.CR_INVALID_POINTER;
pub const CR_INVALID_FLAG = CONFIGRET.CR_INVALID_FLAG;
pub const CR_INVALID_DEVNODE = CONFIGRET.CR_INVALID_DEVNODE;
pub const CR_INVALID_DEVINST = CONFIGRET.CR_INVALID_DEVNODE;
pub const CR_INVALID_RES_DES = CONFIGRET.CR_INVALID_RES_DES;
pub const CR_INVALID_LOG_CONF = CONFIGRET.CR_INVALID_LOG_CONF;
pub const CR_INVALID_ARBITRATOR = CONFIGRET.CR_INVALID_ARBITRATOR;
pub const CR_INVALID_NODELIST = CONFIGRET.CR_INVALID_NODELIST;
pub const CR_DEVNODE_HAS_REQS = CONFIGRET.CR_DEVNODE_HAS_REQS;
pub const CR_DEVINST_HAS_REQS = CONFIGRET.CR_DEVNODE_HAS_REQS;
pub const CR_INVALID_RESOURCEID = CONFIGRET.CR_INVALID_RESOURCEID;
pub const CR_DLVXD_NOT_FOUND = CONFIGRET.CR_DLVXD_NOT_FOUND;
pub const CR_NO_SUCH_DEVNODE = CONFIGRET.CR_NO_SUCH_DEVNODE;
pub const CR_NO_SUCH_DEVINST = CONFIGRET.CR_NO_SUCH_DEVNODE;
pub const CR_NO_MORE_LOG_CONF = CONFIGRET.CR_NO_MORE_LOG_CONF;
pub const CR_NO_MORE_RES_DES = CONFIGRET.CR_NO_MORE_RES_DES;
pub const CR_ALREADY_SUCH_DEVNODE = CONFIGRET.CR_ALREADY_SUCH_DEVNODE;
pub const CR_ALREADY_SUCH_DEVINST = CONFIGRET.CR_ALREADY_SUCH_DEVNODE;
pub const CR_INVALID_RANGE_LIST = CONFIGRET.CR_INVALID_RANGE_LIST;
pub const CR_INVALID_RANGE = CONFIGRET.CR_INVALID_RANGE;
pub const CR_FAILURE = CONFIGRET.CR_FAILURE;
pub const CR_NO_SUCH_LOGICAL_DEV = CONFIGRET.CR_NO_SUCH_LOGICAL_DEV;
pub const CR_CREATE_BLOCKED = CONFIGRET.CR_CREATE_BLOCKED;
pub const CR_NOT_SYSTEM_VM = CONFIGRET.CR_NOT_SYSTEM_VM;
pub const CR_REMOVE_VETOED = CONFIGRET.CR_REMOVE_VETOED;
pub const CR_APM_VETOED = CONFIGRET.CR_APM_VETOED;
pub const CR_INVALID_LOAD_TYPE = CONFIGRET.CR_INVALID_LOAD_TYPE;
pub const CR_BUFFER_SMALL = CONFIGRET.CR_BUFFER_SMALL;
pub const CR_NO_ARBITRATOR = CONFIGRET.CR_NO_ARBITRATOR;
pub const CR_NO_REGISTRY_HANDLE = CONFIGRET.CR_NO_REGISTRY_HANDLE;
pub const CR_REGISTRY_ERROR = CONFIGRET.CR_REGISTRY_ERROR;
pub const CR_INVALID_DEVICE_ID = CONFIGRET.CR_INVALID_DEVICE_ID;
pub const CR_INVALID_DATA = CONFIGRET.CR_INVALID_DATA;
pub const CR_INVALID_API = CONFIGRET.CR_INVALID_API;
pub const CR_DEVLOADER_NOT_READY = CONFIGRET.CR_DEVLOADER_NOT_READY;
pub const CR_NEED_RESTART = CONFIGRET.CR_NEED_RESTART;
pub const CR_NO_MORE_HW_PROFILES = CONFIGRET.CR_NO_MORE_HW_PROFILES;
pub const CR_DEVICE_NOT_THERE = CONFIGRET.CR_DEVICE_NOT_THERE;
pub const CR_NO_SUCH_VALUE = CONFIGRET.CR_NO_SUCH_VALUE;
pub const CR_WRONG_TYPE = CONFIGRET.CR_WRONG_TYPE;
pub const CR_INVALID_PRIORITY = CONFIGRET.CR_INVALID_PRIORITY;
pub const CR_NOT_DISABLEABLE = CONFIGRET.CR_NOT_DISABLEABLE;
pub const CR_FREE_RESOURCES = CONFIGRET.CR_FREE_RESOURCES;
pub const CR_QUERY_VETOED = CONFIGRET.CR_QUERY_VETOED;
pub const CR_CANT_SHARE_IRQ = CONFIGRET.CR_CANT_SHARE_IRQ;
pub const CR_NO_DEPENDENT = CONFIGRET.CR_NO_DEPENDENT;
pub const CR_SAME_RESOURCES = CONFIGRET.CR_SAME_RESOURCES;
pub const CR_NO_SUCH_REGISTRY_KEY = CONFIGRET.CR_NO_SUCH_REGISTRY_KEY;
pub const CR_INVALID_MACHINENAME = CONFIGRET.CR_INVALID_MACHINENAME;
pub const CR_REMOTE_COMM_FAILURE = CONFIGRET.CR_REMOTE_COMM_FAILURE;
pub const CR_MACHINE_UNAVAILABLE = CONFIGRET.CR_MACHINE_UNAVAILABLE;
pub const CR_NO_CM_SERVICES = CONFIGRET.CR_NO_CM_SERVICES;
pub const CR_ACCESS_DENIED = CONFIGRET.CR_ACCESS_DENIED;
pub const CR_CALL_NOT_IMPLEMENTED = CONFIGRET.CR_CALL_NOT_IMPLEMENTED;
pub const CR_INVALID_PROPERTY = CONFIGRET.CR_INVALID_PROPERTY;
pub const CR_DEVICE_INTERFACE_ACTIVE = CONFIGRET.CR_DEVICE_INTERFACE_ACTIVE;
pub const CR_NO_SUCH_DEVICE_INTERFACE = CONFIGRET.CR_NO_SUCH_DEVICE_INTERFACE;
pub const CR_INVALID_REFERENCE_STRING = CONFIGRET.CR_INVALID_REFERENCE_STRING;
pub const CR_INVALID_CONFLICT_LIST = CONFIGRET.CR_INVALID_CONFLICT_LIST;
pub const CR_INVALID_INDEX = CONFIGRET.CR_INVALID_INDEX;
pub const CR_INVALID_STRUCTURE_SIZE = CONFIGRET.CR_INVALID_STRUCTURE_SIZE;
pub const NUM_CR_RESULTS = CONFIGRET.NUM_CR_RESULTS;
pub const HCMNOTIFICATION = *opaque{};
pub const PSP_FILE_CALLBACK_A = fn(
Context: ?*anyopaque,
Notification: u32,
Param1: usize,
Param2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const PSP_FILE_CALLBACK_W = fn(
Context: ?*anyopaque,
Notification: u32,
Param1: usize,
Param2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const SP_SELECTDEVICE_PARAMS_A = extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Title: [60]CHAR,
Instructions: [256]CHAR,
ListLabel: [30]CHAR,
SubTitle: [256]CHAR,
Reserved: [2]u8,
};
pub const PDETECT_PROGRESS_NOTIFY = fn(
ProgressNotifyParam: ?*anyopaque,
DetectComplete: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const SP_TROUBLESHOOTER_PARAMS_A = extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
ChmFile: [260]CHAR,
HtmlTroubleShooter: [260]CHAR,
};
pub const SP_POWERMESSAGEWAKE_PARAMS_A = extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
PowerMessageWake: [512]CHAR,
};
pub const PSP_DETSIG_CMPPROC = fn(
DeviceInfoSet: ?*anyopaque,
NewDeviceData: ?*SP_DEVINFO_DATA,
ExistingDeviceData: ?*SP_DEVINFO_DATA,
CompareContext: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const SetupFileLogInfo = enum(i32) {
SourceFilename = 0,
Checksum = 1,
DiskTagfile = 2,
DiskDescription = 3,
OtherInfo = 4,
Max = 5,
};
pub const SetupFileLogSourceFilename = SetupFileLogInfo.SourceFilename;
pub const SetupFileLogChecksum = SetupFileLogInfo.Checksum;
pub const SetupFileLogDiskTagfile = SetupFileLogInfo.DiskTagfile;
pub const SetupFileLogDiskDescription = SetupFileLogInfo.DiskDescription;
pub const SetupFileLogOtherInfo = SetupFileLogInfo.OtherInfo;
pub const SetupFileLogMax = SetupFileLogInfo.Max;
pub const PNP_VETO_TYPE = enum(i32) {
TypeUnknown = 0,
LegacyDevice = 1,
PendingClose = 2,
WindowsApp = 3,
WindowsService = 4,
OutstandingOpen = 5,
Device = 6,
Driver = 7,
IllegalDeviceRequest = 8,
InsufficientPower = 9,
NonDisableable = 10,
LegacyDriver = 11,
InsufficientRights = 12,
AlreadyRemoved = 13,
};
pub const PNP_VetoTypeUnknown = PNP_VETO_TYPE.TypeUnknown;
pub const PNP_VetoLegacyDevice = PNP_VETO_TYPE.LegacyDevice;
pub const PNP_VetoPendingClose = PNP_VETO_TYPE.PendingClose;
pub const PNP_VetoWindowsApp = PNP_VETO_TYPE.WindowsApp;
pub const PNP_VetoWindowsService = PNP_VETO_TYPE.WindowsService;
pub const PNP_VetoOutstandingOpen = PNP_VETO_TYPE.OutstandingOpen;
pub const PNP_VetoDevice = PNP_VETO_TYPE.Device;
pub const PNP_VetoDriver = PNP_VETO_TYPE.Driver;
pub const PNP_VetoIllegalDeviceRequest = PNP_VETO_TYPE.IllegalDeviceRequest;
pub const PNP_VetoInsufficientPower = PNP_VETO_TYPE.InsufficientPower;
pub const PNP_VetoNonDisableable = PNP_VETO_TYPE.NonDisableable;
pub const PNP_VetoLegacyDriver = PNP_VETO_TYPE.LegacyDriver;
pub const PNP_VetoInsufficientRights = PNP_VETO_TYPE.InsufficientRights;
pub const PNP_VetoAlreadyRemoved = PNP_VETO_TYPE.AlreadyRemoved;
pub const CONFLICT_DETAILS_A = extern struct {
CD_ulSize: u32,
CD_ulMask: u32,
CD_dnDevInst: u32,
CD_rdResDes: usize,
CD_ulFlags: u32,
CD_szDescription: [260]CHAR,
};
pub const CONFLICT_DETAILS_W = extern struct {
CD_ulSize: u32,
CD_ulMask: u32,
CD_dnDevInst: u32,
CD_rdResDes: usize,
CD_ulFlags: u32,
CD_szDescription: [260]u16,
};
pub const MEM_RANGE = packed struct {
MR_Align: u64,
MR_nBytes: u32,
MR_Min: u64,
MR_Max: u64,
MR_Flags: u32,
MR_Reserved: u32,
};
pub const MEM_DES = packed struct {
MD_Count: u32,
MD_Type: u32,
MD_Alloc_Base: u64,
MD_Alloc_End: u64,
MD_Flags: u32,
MD_Reserved: u32,
};
pub const MEM_RESOURCE = extern struct {
MEM_Header: MEM_DES,
MEM_Data: [1]MEM_RANGE,
};
pub const Mem_Large_Range_s = packed struct {
MLR_Align: u64,
MLR_nBytes: u64,
MLR_Min: u64,
MLR_Max: u64,
MLR_Flags: u32,
MLR_Reserved: u32,
};
pub const Mem_Large_Des_s = packed struct {
MLD_Count: u32,
MLD_Type: u32,
MLD_Alloc_Base: u64,
MLD_Alloc_End: u64,
MLD_Flags: u32,
MLD_Reserved: u32,
};
pub const Mem_Large_Resource_s = extern struct {
MEM_LARGE_Header: Mem_Large_Des_s,
MEM_LARGE_Data: [1]Mem_Large_Range_s,
};
pub const IO_RANGE = packed struct {
IOR_Align: u64,
IOR_nPorts: u32,
IOR_Min: u64,
IOR_Max: u64,
IOR_RangeFlags: u32,
IOR_Alias: u64,
};
pub const IO_DES = packed struct {
IOD_Count: u32,
IOD_Type: u32,
IOD_Alloc_Base: u64,
IOD_Alloc_End: u64,
IOD_DesFlags: u32,
};
pub const IO_RESOURCE = extern struct {
IO_Header: IO_DES,
IO_Data: [1]IO_RANGE,
};
pub const DMA_RANGE = packed struct {
DR_Min: u32,
DR_Max: u32,
DR_Flags: u32,
};
pub const DMA_DES = packed struct {
DD_Count: u32,
DD_Type: u32,
DD_Flags: u32,
DD_Alloc_Chan: u32,
};
pub const DMA_RESOURCE = extern struct {
DMA_Header: DMA_DES,
DMA_Data: [1]DMA_RANGE,
};
pub const IRQ_RANGE = packed struct {
IRQR_Min: u32,
IRQR_Max: u32,
IRQR_Flags: u32,
};
pub const IRQ_DES_32 = packed struct {
IRQD_Count: u32,
IRQD_Type: u32,
IRQD_Flags: u32,
IRQD_Alloc_Num: u32,
IRQD_Affinity: u32,
};
pub const IRQ_DES_64 = packed struct {
IRQD_Count: u32,
IRQD_Type: u32,
IRQD_Flags: u32,
IRQD_Alloc_Num: u32,
IRQD_Affinity: u64,
};
pub const IRQ_RESOURCE_32 = extern struct {
IRQ_Header: IRQ_DES_32,
IRQ_Data: [1]IRQ_RANGE,
};
pub const IRQ_RESOURCE_64 = extern struct {
IRQ_Header: IRQ_DES_64,
IRQ_Data: [1]IRQ_RANGE,
};
pub const DevPrivate_Range_s = packed struct {
PR_Data1: u32,
PR_Data2: u32,
PR_Data3: u32,
};
pub const DevPrivate_Des_s = packed struct {
PD_Count: u32,
PD_Type: u32,
PD_Data1: u32,
PD_Data2: u32,
PD_Data3: u32,
PD_Flags: u32,
};
pub const DevPrivate_Resource_s = extern struct {
PRV_Header: DevPrivate_Des_s,
PRV_Data: [1]DevPrivate_Range_s,
};
pub const CS_DES = packed struct {
CSD_SignatureLength: u32,
CSD_LegacyDataOffset: u32,
CSD_LegacyDataSize: u32,
CSD_Flags: u32,
CSD_ClassGuid: Guid,
CSD_Signature: [1]u8,
};
pub const CS_RESOURCE = extern struct {
CS_Header: CS_DES,
};
pub const PCCARD_DES = packed struct {
PCD_Count: u32,
PCD_Type: u32,
PCD_Flags: u32,
PCD_ConfigIndex: u8,
PCD_Reserved: [3]u8,
PCD_MemoryCardBase1: u32,
PCD_MemoryCardBase2: u32,
PCD_MemoryCardBase: [2]u32,
PCD_MemoryFlags: [2]u16,
PCD_IoFlags: [2]u8,
};
pub const PCCARD_RESOURCE = extern struct {
PcCard_Header: PCCARD_DES,
};
pub const MFCARD_DES = packed struct {
PMF_Count: u32,
PMF_Type: u32,
PMF_Flags: u32,
PMF_ConfigOptions: u8,
PMF_IoResourceIndex: u8,
PMF_Reserved: [2]u8,
PMF_ConfigRegisterBase: u32,
};
pub const MFCARD_RESOURCE = extern struct {
MfCard_Header: MFCARD_DES,
};
pub const BUSNUMBER_RANGE = packed struct {
BUSR_Min: u32,
BUSR_Max: u32,
BUSR_nBusNumbers: u32,
BUSR_Flags: u32,
};
pub const BUSNUMBER_DES = packed struct {
BUSD_Count: u32,
BUSD_Type: u32,
BUSD_Flags: u32,
BUSD_Alloc_Base: u32,
BUSD_Alloc_End: u32,
};
pub const BUSNUMBER_RESOURCE = extern struct {
BusNumber_Header: BUSNUMBER_DES,
BusNumber_Data: [1]BUSNUMBER_RANGE,
};
pub const Connection_Des_s = packed struct {
COND_Type: u32,
COND_Flags: u32,
COND_Class: u8,
COND_ClassType: u8,
COND_Reserved1: u8,
COND_Reserved2: u8,
COND_Id: LARGE_INTEGER,
};
pub const Connection_Resource_s = extern struct {
Connection_Header: Connection_Des_s,
};
pub const HWProfileInfo_sA = packed struct {
HWPI_ulHWProfile: u32,
HWPI_szFriendlyName: [80]CHAR,
HWPI_dwFlags: u32,
};
pub const HWProfileInfo_sW = packed struct {
HWPI_ulHWProfile: u32,
HWPI_szFriendlyName: [80]u16,
HWPI_dwFlags: u32,
};
pub const CM_NOTIFY_FILTER_TYPE = enum(i32) {
DEVICEINTERFACE = 0,
DEVICEHANDLE = 1,
DEVICEINSTANCE = 2,
MAX = 3,
};
pub const CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE = CM_NOTIFY_FILTER_TYPE.DEVICEINTERFACE;
pub const CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE = CM_NOTIFY_FILTER_TYPE.DEVICEHANDLE;
pub const CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE = CM_NOTIFY_FILTER_TYPE.DEVICEINSTANCE;
pub const CM_NOTIFY_FILTER_TYPE_MAX = CM_NOTIFY_FILTER_TYPE.MAX;
pub const CM_NOTIFY_FILTER = extern struct {
cbSize: u32,
Flags: u32,
FilterType: CM_NOTIFY_FILTER_TYPE,
Reserved: u32,
u: extern union {
DeviceInterface: extern struct {
ClassGuid: Guid,
},
DeviceHandle: extern struct {
hTarget: ?HANDLE,
},
DeviceInstance: extern struct {
InstanceId: [200]u16,
},
},
};
pub const CM_NOTIFY_ACTION = enum(i32) {
DEVICEINTERFACEARRIVAL = 0,
DEVICEINTERFACEREMOVAL = 1,
DEVICEQUERYREMOVE = 2,
DEVICEQUERYREMOVEFAILED = 3,
DEVICEREMOVEPENDING = 4,
DEVICEREMOVECOMPLETE = 5,
DEVICECUSTOMEVENT = 6,
DEVICEINSTANCEENUMERATED = 7,
DEVICEINSTANCESTARTED = 8,
DEVICEINSTANCEREMOVED = 9,
MAX = 10,
};
pub const CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL = CM_NOTIFY_ACTION.DEVICEINTERFACEARRIVAL;
pub const CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL = CM_NOTIFY_ACTION.DEVICEINTERFACEREMOVAL;
pub const CM_NOTIFY_ACTION_DEVICEQUERYREMOVE = CM_NOTIFY_ACTION.DEVICEQUERYREMOVE;
pub const CM_NOTIFY_ACTION_DEVICEQUERYREMOVEFAILED = CM_NOTIFY_ACTION.DEVICEQUERYREMOVEFAILED;
pub const CM_NOTIFY_ACTION_DEVICEREMOVEPENDING = CM_NOTIFY_ACTION.DEVICEREMOVEPENDING;
pub const CM_NOTIFY_ACTION_DEVICEREMOVECOMPLETE = CM_NOTIFY_ACTION.DEVICEREMOVECOMPLETE;
pub const CM_NOTIFY_ACTION_DEVICECUSTOMEVENT = CM_NOTIFY_ACTION.DEVICECUSTOMEVENT;
pub const CM_NOTIFY_ACTION_DEVICEINSTANCEENUMERATED = CM_NOTIFY_ACTION.DEVICEINSTANCEENUMERATED;
pub const CM_NOTIFY_ACTION_DEVICEINSTANCESTARTED = CM_NOTIFY_ACTION.DEVICEINSTANCESTARTED;
pub const CM_NOTIFY_ACTION_DEVICEINSTANCEREMOVED = CM_NOTIFY_ACTION.DEVICEINSTANCEREMOVED;
pub const CM_NOTIFY_ACTION_MAX = CM_NOTIFY_ACTION.MAX;
pub const CM_NOTIFY_EVENT_DATA = extern struct {
FilterType: CM_NOTIFY_FILTER_TYPE,
Reserved: u32,
u: extern union {
DeviceInterface: extern struct {
ClassGuid: Guid,
SymbolicLink: [1]u16,
},
DeviceHandle: extern struct {
EventGuid: Guid,
NameOffset: i32,
DataSize: u32,
Data: [1]u8,
},
DeviceInstance: extern struct {
InstanceId: [1]u16,
},
},
};
pub const PCM_NOTIFY_CALLBACK = fn(
hNotify: ?HCMNOTIFICATION,
Context: ?*anyopaque,
Action: CM_NOTIFY_ACTION,
// TODO: what to do with BytesParamIndex 4?
EventData: ?*CM_NOTIFY_EVENT_DATA,
EventDataSize: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const INFCONTEXT = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
Inf: ?*anyopaque,
CurrentInf: ?*anyopaque,
Section: u32,
Line: u32,
},
.X86 => packed struct {
Inf: ?*anyopaque,
CurrentInf: ?*anyopaque,
Section: u32,
Line: u32,
},
};
pub const SP_INF_INFORMATION = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
InfStyle: SP_INF_STYLE,
InfCount: u32,
VersionData: [1]u8,
},
.X86 => packed struct {
InfStyle: SP_INF_STYLE,
InfCount: u32,
VersionData: [1]u8,
},
};
pub const SP_ALTPLATFORM_INFO_V3 = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
Platform: u32,
MajorVersion: u32,
MinorVersion: u32,
ProcessorArchitecture: u16,
Anonymous: extern union {
Reserved: u16,
Flags: u16,
},
FirstValidatedMajorVersion: u32,
FirstValidatedMinorVersion: u32,
ProductType: u8,
SuiteMask: u16,
BuildNumber: u32,
},
.X86 => packed struct {
cbSize: u32,
Platform: u32,
MajorVersion: u32,
MinorVersion: u32,
ProcessorArchitecture: u16,
Anonymous: packed union {
Reserved: u16,
Flags: u16,
},
FirstValidatedMajorVersion: u32,
FirstValidatedMinorVersion: u32,
ProductType: u8,
SuiteMask: u16,
BuildNumber: u32,
},
};
pub const SP_ALTPLATFORM_INFO_V2 = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
Platform: VER_PLATFORM,
MajorVersion: u32,
MinorVersion: u32,
ProcessorArchitecture: u16,
Anonymous: extern union {
Reserved: u16,
Flags: u16,
},
FirstValidatedMajorVersion: u32,
FirstValidatedMinorVersion: u32,
},
.X86 => packed struct {
cbSize: u32,
Platform: VER_PLATFORM,
MajorVersion: u32,
MinorVersion: u32,
ProcessorArchitecture: u16,
Anonymous: packed union {
Reserved: u16,
Flags: u16,
},
FirstValidatedMajorVersion: u32,
FirstValidatedMinorVersion: u32,
},
};
pub const SP_ALTPLATFORM_INFO_V1 = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
Platform: VER_PLATFORM,
MajorVersion: u32,
MinorVersion: u32,
ProcessorArchitecture: u16,
Reserved: u16,
},
.X86 => packed struct {
cbSize: u32,
Platform: VER_PLATFORM,
MajorVersion: u32,
MinorVersion: u32,
ProcessorArchitecture: u16,
Reserved: u16,
},
};
pub const SP_ORIGINAL_FILE_INFO_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
OriginalInfName: [260]CHAR,
OriginalCatalogName: [260]CHAR,
},
.X86 => packed struct {
cbSize: u32,
OriginalInfName: [260]CHAR,
OriginalCatalogName: [260]CHAR,
},
};
pub const SP_ORIGINAL_FILE_INFO_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
OriginalInfName: [260]u16,
OriginalCatalogName: [260]u16,
},
.X86 => packed struct {
cbSize: u32,
OriginalInfName: [260]u16,
OriginalCatalogName: [260]u16,
},
};
pub const FILEPATHS_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
Target: ?[*:0]const u8,
Source: ?[*:0]const u8,
Win32Error: u32,
Flags: u32,
},
.X86 => packed struct {
Target: ?[*:0]const u8,
Source: ?[*:0]const u8,
Win32Error: u32,
Flags: u32,
},
};
pub const FILEPATHS_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
Target: ?[*:0]const u16,
Source: ?[*:0]const u16,
Win32Error: u32,
Flags: u32,
},
.X86 => packed struct {
Target: ?[*:0]const u16,
Source: ?[*:0]const u16,
Win32Error: u32,
Flags: u32,
},
};
pub const FILEPATHS_SIGNERINFO_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
Target: ?[*:0]const u8,
Source: ?[*:0]const u8,
Win32Error: u32,
Flags: u32,
DigitalSigner: ?[*:0]const u8,
Version: ?[*:0]const u8,
CatalogFile: ?[*:0]const u8,
},
.X86 => packed struct {
Target: ?[*:0]const u8,
Source: ?[*:0]const u8,
Win32Error: u32,
Flags: u32,
DigitalSigner: ?[*:0]const u8,
Version: ?[*:0]const u8,
CatalogFile: ?[*:0]const u8,
},
};
pub const FILEPATHS_SIGNERINFO_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
Target: ?[*:0]const u16,
Source: ?[*:0]const u16,
Win32Error: u32,
Flags: u32,
DigitalSigner: ?[*:0]const u16,
Version: ?[*:0]const u16,
CatalogFile: ?[*:0]const u16,
},
.X86 => packed struct {
Target: ?[*:0]const u16,
Source: ?[*:0]const u16,
Win32Error: u32,
Flags: u32,
DigitalSigner: ?[*:0]const u16,
Version: ?[*:0]const u16,
CatalogFile: ?[*:0]const u16,
},
};
pub const SOURCE_MEDIA_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
Reserved: ?[*:0]const u8,
Tagfile: ?[*:0]const u8,
Description: ?[*:0]const u8,
SourcePath: ?[*:0]const u8,
SourceFile: ?[*:0]const u8,
Flags: u32,
},
.X86 => packed struct {
Reserved: ?[*:0]const u8,
Tagfile: ?[*:0]const u8,
Description: ?[*:0]const u8,
SourcePath: ?[*:0]const u8,
SourceFile: ?[*:0]const u8,
Flags: u32,
},
};
pub const SOURCE_MEDIA_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
Reserved: ?[*:0]const u16,
Tagfile: ?[*:0]const u16,
Description: ?[*:0]const u16,
SourcePath: ?[*:0]const u16,
SourceFile: ?[*:0]const u16,
Flags: u32,
},
.X86 => packed struct {
Reserved: ?[*:0]const u16,
Tagfile: ?[*:0]const u16,
Description: ?[*:0]const u16,
SourcePath: ?[*:0]const u16,
SourceFile: ?[*:0]const u16,
Flags: u32,
},
};
pub const CABINET_INFO_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
CabinetPath: ?[*:0]const u8,
CabinetFile: ?[*:0]const u8,
DiskName: ?[*:0]const u8,
SetId: u16,
CabinetNumber: u16,
},
.X86 => packed struct {
CabinetPath: ?[*:0]const u8,
CabinetFile: ?[*:0]const u8,
DiskName: ?[*:0]const u8,
SetId: u16,
CabinetNumber: u16,
},
};
pub const CABINET_INFO_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
CabinetPath: ?[*:0]const u16,
CabinetFile: ?[*:0]const u16,
DiskName: ?[*:0]const u16,
SetId: u16,
CabinetNumber: u16,
},
.X86 => packed struct {
CabinetPath: ?[*:0]const u16,
CabinetFile: ?[*:0]const u16,
DiskName: ?[*:0]const u16,
SetId: u16,
CabinetNumber: u16,
},
};
pub const FILE_IN_CABINET_INFO_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
NameInCabinet: ?[*:0]const u8,
FileSize: u32,
Win32Error: u32,
DosDate: u16,
DosTime: u16,
DosAttribs: u16,
FullTargetName: [260]CHAR,
},
.X86 => packed struct {
NameInCabinet: ?[*:0]const u8,
FileSize: u32,
Win32Error: u32,
DosDate: u16,
DosTime: u16,
DosAttribs: u16,
FullTargetName: [260]CHAR,
},
};
pub const FILE_IN_CABINET_INFO_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
NameInCabinet: ?[*:0]const u16,
FileSize: u32,
Win32Error: u32,
DosDate: u16,
DosTime: u16,
DosAttribs: u16,
FullTargetName: [260]u16,
},
.X86 => packed struct {
NameInCabinet: ?[*:0]const u16,
FileSize: u32,
Win32Error: u32,
DosDate: u16,
DosTime: u16,
DosAttribs: u16,
FullTargetName: [260]u16,
},
};
pub const SP_REGISTER_CONTROL_STATUSA = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
FileName: ?[*:0]const u8,
Win32Error: u32,
FailureCode: u32,
},
.X86 => packed struct {
cbSize: u32,
FileName: ?[*:0]const u8,
Win32Error: u32,
FailureCode: u32,
},
};
pub const SP_REGISTER_CONTROL_STATUSW = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
FileName: ?[*:0]const u16,
Win32Error: u32,
FailureCode: u32,
},
.X86 => packed struct {
cbSize: u32,
FileName: ?[*:0]const u16,
Win32Error: u32,
FailureCode: u32,
},
};
pub const SP_FILE_COPY_PARAMS_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
QueueHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u8,
SourcePath: ?[*:0]const u8,
SourceFilename: ?[*:0]const u8,
SourceDescription: ?[*:0]const u8,
SourceTagfile: ?[*:0]const u8,
TargetDirectory: ?[*:0]const u8,
TargetFilename: ?[*:0]const u8,
CopyStyle: u32,
LayoutInf: ?*anyopaque,
SecurityDescriptor: ?[*:0]const u8,
},
.X86 => packed struct {
cbSize: u32,
QueueHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u8,
SourcePath: ?[*:0]const u8,
SourceFilename: ?[*:0]const u8,
SourceDescription: ?[*:0]const u8,
SourceTagfile: ?[*:0]const u8,
TargetDirectory: ?[*:0]const u8,
TargetFilename: ?[*:0]const u8,
CopyStyle: u32,
LayoutInf: ?*anyopaque,
SecurityDescriptor: ?[*:0]const u8,
},
};
pub const SP_FILE_COPY_PARAMS_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
QueueHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u16,
SourcePath: ?[*:0]const u16,
SourceFilename: ?[*:0]const u16,
SourceDescription: ?[*:0]const u16,
SourceTagfile: ?[*:0]const u16,
TargetDirectory: ?[*:0]const u16,
TargetFilename: ?[*:0]const u16,
CopyStyle: u32,
LayoutInf: ?*anyopaque,
SecurityDescriptor: ?[*:0]const u16,
},
.X86 => packed struct {
cbSize: u32,
QueueHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u16,
SourcePath: ?[*:0]const u16,
SourceFilename: ?[*:0]const u16,
SourceDescription: ?[*:0]const u16,
SourceTagfile: ?[*:0]const u16,
TargetDirectory: ?[*:0]const u16,
TargetFilename: ?[*:0]const u16,
CopyStyle: u32,
LayoutInf: ?*anyopaque,
SecurityDescriptor: ?[*:0]const u16,
},
};
pub const SP_DEVINFO_DATA = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
ClassGuid: Guid,
DevInst: u32,
Reserved: usize,
},
.X86 => packed struct {
cbSize: u32,
ClassGuid: Guid,
DevInst: u32,
Reserved: usize,
},
};
pub const SP_DEVICE_INTERFACE_DATA = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
InterfaceClassGuid: Guid,
Flags: u32,
Reserved: usize,
},
.X86 => packed struct {
cbSize: u32,
InterfaceClassGuid: Guid,
Flags: u32,
Reserved: usize,
},
};
pub const SP_DEVICE_INTERFACE_DETAIL_DATA_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
DevicePath: [1]CHAR,
},
.X86 => packed struct {
cbSize: u32,
DevicePath: [1]CHAR,
},
};
pub const SP_DEVICE_INTERFACE_DETAIL_DATA_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
DevicePath: [1]u16,
},
.X86 => packed struct {
cbSize: u32,
DevicePath: [1]u16,
},
};
pub const SP_DEVINFO_LIST_DETAIL_DATA_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
ClassGuid: Guid,
RemoteMachineHandle: ?HANDLE,
RemoteMachineName: [263]CHAR,
},
.X86 => packed struct {
cbSize: u32,
ClassGuid: Guid,
RemoteMachineHandle: ?HANDLE,
RemoteMachineName: [263]CHAR,
},
};
pub const SP_DEVINFO_LIST_DETAIL_DATA_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
ClassGuid: Guid,
RemoteMachineHandle: ?HANDLE,
RemoteMachineName: [263]u16,
},
.X86 => packed struct {
cbSize: u32,
ClassGuid: Guid,
RemoteMachineHandle: ?HANDLE,
RemoteMachineName: [263]u16,
},
};
pub const SP_DEVINSTALL_PARAMS_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
Flags: u32,
FlagsEx: u32,
hwndParent: ?HWND,
InstallMsgHandler: ?PSP_FILE_CALLBACK_A,
InstallMsgHandlerContext: ?*anyopaque,
FileQueue: ?*anyopaque,
ClassInstallReserved: usize,
Reserved: u32,
DriverPath: [260]CHAR,
},
.X86 => packed struct {
cbSize: u32,
Flags: u32,
FlagsEx: u32,
hwndParent: ?HWND,
InstallMsgHandler: ?PSP_FILE_CALLBACK_A,
InstallMsgHandlerContext: ?*anyopaque,
FileQueue: ?*anyopaque,
ClassInstallReserved: usize,
Reserved: u32,
DriverPath: [260]CHAR,
},
};
pub const SP_DEVINSTALL_PARAMS_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
Flags: u32,
FlagsEx: u32,
hwndParent: ?HWND,
InstallMsgHandler: ?PSP_FILE_CALLBACK_A,
InstallMsgHandlerContext: ?*anyopaque,
FileQueue: ?*anyopaque,
ClassInstallReserved: usize,
Reserved: u32,
DriverPath: [260]u16,
},
.X86 => packed struct {
cbSize: u32,
Flags: u32,
FlagsEx: u32,
hwndParent: ?HWND,
InstallMsgHandler: ?PSP_FILE_CALLBACK_A,
InstallMsgHandlerContext: ?*anyopaque,
FileQueue: ?*anyopaque,
ClassInstallReserved: usize,
Reserved: u32,
DriverPath: [260]u16,
},
};
pub const SP_CLASSINSTALL_HEADER = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
InstallFunction: u32,
},
.X86 => packed struct {
cbSize: u32,
InstallFunction: u32,
},
};
pub const SP_ENABLECLASS_PARAMS = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
ClassGuid: Guid,
EnableMessage: u32,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
ClassGuid: Guid,
EnableMessage: u32,
},
};
pub const SP_PROPCHANGE_PARAMS = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
StateChange: u32,
Scope: u32,
HwProfile: u32,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
StateChange: u32,
Scope: u32,
HwProfile: u32,
},
};
pub const SP_REMOVEDEVICE_PARAMS = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Scope: u32,
HwProfile: u32,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Scope: u32,
HwProfile: u32,
},
};
pub const SP_UNREMOVEDEVICE_PARAMS = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Scope: u32,
HwProfile: u32,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Scope: u32,
HwProfile: u32,
},
};
pub const SP_SELECTDEVICE_PARAMS_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Title: [60]u16,
Instructions: [256]u16,
ListLabel: [30]u16,
SubTitle: [256]u16,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Title: [60]u16,
Instructions: [256]u16,
ListLabel: [30]u16,
SubTitle: [256]u16,
},
};
pub const SP_DETECTDEVICE_PARAMS = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
DetectProgressNotify: ?PDETECT_PROGRESS_NOTIFY,
ProgressNotifyParam: ?*anyopaque,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
DetectProgressNotify: ?PDETECT_PROGRESS_NOTIFY,
ProgressNotifyParam: ?*anyopaque,
},
};
pub const SP_INSTALLWIZARD_DATA = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Flags: u32,
DynamicPages: [20]?HPROPSHEETPAGE,
NumDynamicPages: u32,
DynamicPageFlags: u32,
PrivateFlags: u32,
PrivateData: LPARAM,
hwndWizardDlg: ?HWND,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Flags: u32,
DynamicPages: [20]?HPROPSHEETPAGE,
NumDynamicPages: u32,
DynamicPageFlags: u32,
PrivateFlags: u32,
PrivateData: LPARAM,
hwndWizardDlg: ?HWND,
},
};
pub const SP_NEWDEVICEWIZARD_DATA = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Flags: u32,
DynamicPages: [20]?HPROPSHEETPAGE,
NumDynamicPages: u32,
hwndWizardDlg: ?HWND,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
Flags: u32,
DynamicPages: [20]?HPROPSHEETPAGE,
NumDynamicPages: u32,
hwndWizardDlg: ?HWND,
},
};
pub const SP_TROUBLESHOOTER_PARAMS_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
ChmFile: [260]u16,
HtmlTroubleShooter: [260]u16,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
ChmFile: [260]u16,
HtmlTroubleShooter: [260]u16,
},
};
pub const SP_POWERMESSAGEWAKE_PARAMS_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
PowerMessageWake: [512]u16,
},
.X86 => packed struct {
ClassInstallHeader: SP_CLASSINSTALL_HEADER,
PowerMessageWake: [512]u16,
},
};
pub const SP_DRVINFO_DATA_V2_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
DriverType: u32,
Reserved: usize,
Description: [256]CHAR,
MfgName: [256]CHAR,
ProviderName: [256]CHAR,
DriverDate: FILETIME,
DriverVersion: u64,
},
.X86 => packed struct {
cbSize: u32,
DriverType: u32,
Reserved: usize,
Description: [256]CHAR,
MfgName: [256]CHAR,
ProviderName: [256]CHAR,
DriverDate: FILETIME,
DriverVersion: u64,
},
};
pub const SP_DRVINFO_DATA_V2_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
DriverType: u32,
Reserved: usize,
Description: [256]u16,
MfgName: [256]u16,
ProviderName: [256]u16,
DriverDate: FILETIME,
DriverVersion: u64,
},
.X86 => packed struct {
cbSize: u32,
DriverType: u32,
Reserved: usize,
Description: [256]u16,
MfgName: [256]u16,
ProviderName: [256]u16,
DriverDate: FILETIME,
DriverVersion: u64,
},
};
pub const SP_DRVINFO_DATA_V1_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
DriverType: u32,
Reserved: usize,
Description: [256]CHAR,
MfgName: [256]CHAR,
ProviderName: [256]CHAR,
},
.X86 => packed struct {
cbSize: u32,
DriverType: u32,
Reserved: usize,
Description: [256]CHAR,
MfgName: [256]CHAR,
ProviderName: [256]CHAR,
},
};
pub const SP_DRVINFO_DATA_V1_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
DriverType: u32,
Reserved: usize,
Description: [256]u16,
MfgName: [256]u16,
ProviderName: [256]u16,
},
.X86 => packed struct {
cbSize: u32,
DriverType: u32,
Reserved: usize,
Description: [256]u16,
MfgName: [256]u16,
ProviderName: [256]u16,
},
};
pub const SP_DRVINFO_DETAIL_DATA_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
InfDate: FILETIME,
CompatIDsOffset: u32,
CompatIDsLength: u32,
Reserved: usize,
SectionName: [256]CHAR,
InfFileName: [260]CHAR,
DrvDescription: [256]CHAR,
HardwareID: [1]CHAR,
},
.X86 => packed struct {
cbSize: u32,
InfDate: FILETIME,
CompatIDsOffset: u32,
CompatIDsLength: u32,
Reserved: usize,
SectionName: [256]CHAR,
InfFileName: [260]CHAR,
DrvDescription: [256]CHAR,
HardwareID: [1]CHAR,
},
};
pub const SP_DRVINFO_DETAIL_DATA_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
InfDate: FILETIME,
CompatIDsOffset: u32,
CompatIDsLength: u32,
Reserved: usize,
SectionName: [256]u16,
InfFileName: [260]u16,
DrvDescription: [256]u16,
HardwareID: [1]u16,
},
.X86 => packed struct {
cbSize: u32,
InfDate: FILETIME,
CompatIDsOffset: u32,
CompatIDsLength: u32,
Reserved: usize,
SectionName: [256]u16,
InfFileName: [260]u16,
DrvDescription: [256]u16,
HardwareID: [1]u16,
},
};
pub const SP_DRVINSTALL_PARAMS = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
Rank: u32,
Flags: u32,
PrivateData: usize,
Reserved: u32,
},
.X86 => packed struct {
cbSize: u32,
Rank: u32,
Flags: u32,
PrivateData: usize,
Reserved: u32,
},
};
pub const COINSTALLER_CONTEXT_DATA = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
PostProcessing: BOOL,
InstallResult: u32,
PrivateData: ?*anyopaque,
},
.X86 => packed struct {
PostProcessing: BOOL,
InstallResult: u32,
PrivateData: ?*anyopaque,
},
};
pub const SP_CLASSIMAGELIST_DATA = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
ImageList: ?HIMAGELIST,
Reserved: usize,
},
.X86 => packed struct {
cbSize: u32,
ImageList: ?HIMAGELIST,
Reserved: usize,
},
};
pub const SP_PROPSHEETPAGE_REQUEST = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
PageRequested: u32,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
},
.X86 => packed struct {
cbSize: u32,
PageRequested: u32,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
},
};
pub const SP_BACKUP_QUEUE_PARAMS_V2_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
FullInfPath: [260]CHAR,
FilenameOffset: i32,
ReinstallInstance: [260]CHAR,
},
.X86 => packed struct {
cbSize: u32,
FullInfPath: [260]CHAR,
FilenameOffset: i32,
ReinstallInstance: [260]CHAR,
},
};
pub const SP_BACKUP_QUEUE_PARAMS_V2_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
FullInfPath: [260]u16,
FilenameOffset: i32,
ReinstallInstance: [260]u16,
},
.X86 => packed struct {
cbSize: u32,
FullInfPath: [260]u16,
FilenameOffset: i32,
ReinstallInstance: [260]u16,
},
};
pub const SP_BACKUP_QUEUE_PARAMS_V1_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
FullInfPath: [260]CHAR,
FilenameOffset: i32,
},
.X86 => packed struct {
cbSize: u32,
FullInfPath: [260]CHAR,
FilenameOffset: i32,
},
};
pub const SP_BACKUP_QUEUE_PARAMS_V1_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
FullInfPath: [260]u16,
FilenameOffset: i32,
},
.X86 => packed struct {
cbSize: u32,
FullInfPath: [260]u16,
FilenameOffset: i32,
},
};
pub const SP_INF_SIGNER_INFO_V1_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
CatalogFile: [260]CHAR,
DigitalSigner: [260]CHAR,
DigitalSignerVersion: [260]CHAR,
},
.X86 => packed struct {
cbSize: u32,
CatalogFile: [260]CHAR,
DigitalSigner: [260]CHAR,
DigitalSignerVersion: [260]CHAR,
},
};
pub const SP_INF_SIGNER_INFO_V1_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
CatalogFile: [260]u16,
DigitalSigner: [260]u16,
DigitalSignerVersion: [260]u16,
},
.X86 => packed struct {
cbSize: u32,
CatalogFile: [260]u16,
DigitalSigner: [260]u16,
DigitalSignerVersion: [260]u16,
},
};
pub const SP_INF_SIGNER_INFO_V2_A = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
CatalogFile: [260]CHAR,
DigitalSigner: [260]CHAR,
DigitalSignerVersion: [260]CHAR,
SignerScore: u32,
},
.X86 => packed struct {
cbSize: u32,
CatalogFile: [260]CHAR,
DigitalSigner: [260]CHAR,
DigitalSignerVersion: [260]CHAR,
SignerScore: u32,
},
};
pub const SP_INF_SIGNER_INFO_V2_W = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => extern struct {
cbSize: u32,
CatalogFile: [260]u16,
DigitalSigner: [260]u16,
DigitalSignerVersion: [260]u16,
SignerScore: u32,
},
.X86 => packed struct {
cbSize: u32,
CatalogFile: [260]u16,
DigitalSigner: [260]u16,
DigitalSignerVersion: [260]u16,
SignerScore: u32,
},
};
//--------------------------------------------------------------------------------
// Section: Functions (575)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetInfInformationA(
InfSpec: ?*const anyopaque,
SearchControl: u32,
// TODO: what to do with BytesParamIndex 3?
ReturnBuffer: ?*SP_INF_INFORMATION,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetInfInformationW(
InfSpec: ?*const anyopaque,
SearchControl: u32,
// TODO: what to do with BytesParamIndex 3?
ReturnBuffer: ?*SP_INF_INFORMATION,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryInfFileInformationA(
InfInformation: ?*SP_INF_INFORMATION,
InfIndex: u32,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryInfFileInformationW(
InfInformation: ?*SP_INF_INFORMATION,
InfIndex: u32,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryInfOriginalFileInformationA(
InfInformation: ?*SP_INF_INFORMATION,
InfIndex: u32,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
OriginalFileInfo: ?*SP_ORIGINAL_FILE_INFO_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryInfOriginalFileInformationW(
InfInformation: ?*SP_INF_INFORMATION,
InfIndex: u32,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
OriginalFileInfo: ?*SP_ORIGINAL_FILE_INFO_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryInfVersionInformationA(
InfInformation: ?*SP_INF_INFORMATION,
InfIndex: u32,
Key: ?[*:0]const u8,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryInfVersionInformationW(
InfInformation: ?*SP_INF_INFORMATION,
InfIndex: u32,
Key: ?[*:0]const u16,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupGetInfDriverStoreLocationA(
FileName: ?[*:0]const u8,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
LocaleName: ?[*:0]const u8,
ReturnBuffer: [*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupGetInfDriverStoreLocationW(
FileName: ?[*:0]const u16,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
LocaleName: ?[*:0]const u16,
ReturnBuffer: [*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupGetInfPublishedNameA(
DriverStoreLocation: ?[*:0]const u8,
ReturnBuffer: [*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupGetInfPublishedNameW(
DriverStoreLocation: ?[*:0]const u16,
ReturnBuffer: [*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetInfFileListA(
DirectoryPath: ?[*:0]const u8,
InfStyle: u32,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetInfFileListW(
DirectoryPath: ?[*:0]const u16,
InfStyle: u32,
ReturnBuffer: [*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupOpenInfFileW(
FileName: ?[*:0]const u16,
InfClass: ?[*:0]const u16,
InfStyle: u32,
ErrorLine: ?*u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupOpenInfFileA(
FileName: ?[*:0]const u8,
InfClass: ?[*:0]const u8,
InfStyle: u32,
ErrorLine: ?*u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupOpenMasterInf(
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupOpenAppendInfFileW(
FileName: ?[*:0]const u16,
InfHandle: ?*anyopaque,
ErrorLine: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupOpenAppendInfFileA(
FileName: ?[*:0]const u8,
InfHandle: ?*anyopaque,
ErrorLine: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCloseInfFile(
InfHandle: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupFindFirstLineA(
InfHandle: ?*anyopaque,
Section: ?[*:0]const u8,
Key: ?[*:0]const u8,
Context: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupFindFirstLineW(
InfHandle: ?*anyopaque,
Section: ?[*:0]const u16,
Key: ?[*:0]const u16,
Context: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupFindNextLine(
ContextIn: ?*INFCONTEXT,
ContextOut: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupFindNextMatchLineA(
ContextIn: ?*INFCONTEXT,
Key: ?[*:0]const u8,
ContextOut: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupFindNextMatchLineW(
ContextIn: ?*INFCONTEXT,
Key: ?[*:0]const u16,
ContextOut: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetLineByIndexA(
InfHandle: ?*anyopaque,
Section: ?[*:0]const u8,
Index: u32,
Context: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetLineByIndexW(
InfHandle: ?*anyopaque,
Section: ?[*:0]const u16,
Index: u32,
Context: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetLineCountA(
InfHandle: ?*anyopaque,
Section: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetLineCountW(
InfHandle: ?*anyopaque,
Section: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetLineTextA(
Context: ?*INFCONTEXT,
InfHandle: ?*anyopaque,
Section: ?[*:0]const u8,
Key: ?[*:0]const u8,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetLineTextW(
Context: ?*INFCONTEXT,
InfHandle: ?*anyopaque,
Section: ?[*:0]const u16,
Key: ?[*:0]const u16,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetFieldCount(
Context: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetStringFieldA(
Context: ?*INFCONTEXT,
FieldIndex: u32,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetStringFieldW(
Context: ?*INFCONTEXT,
FieldIndex: u32,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetIntField(
Context: ?*INFCONTEXT,
FieldIndex: u32,
IntegerValue: ?*i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetMultiSzFieldA(
Context: ?*INFCONTEXT,
FieldIndex: u32,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetMultiSzFieldW(
Context: ?*INFCONTEXT,
FieldIndex: u32,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetBinaryField(
Context: ?*INFCONTEXT,
FieldIndex: u32,
// TODO: what to do with BytesParamIndex 3?
ReturnBuffer: ?*u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetFileCompressionInfoA(
SourceFileName: ?[*:0]const u8,
ActualSourceFileName: ?*?PSTR,
SourceFileSize: ?*u32,
TargetFileSize: ?*u32,
CompressionType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetFileCompressionInfoW(
SourceFileName: ?[*:0]const u16,
ActualSourceFileName: ?*?PWSTR,
SourceFileSize: ?*u32,
TargetFileSize: ?*u32,
CompressionType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetFileCompressionInfoExA(
SourceFileName: ?[*:0]const u8,
ActualSourceFileNameBuffer: ?[*:0]u8,
ActualSourceFileNameBufferLen: u32,
RequiredBufferLen: ?*u32,
SourceFileSize: ?*u32,
TargetFileSize: ?*u32,
CompressionType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetFileCompressionInfoExW(
SourceFileName: ?[*:0]const u16,
ActualSourceFileNameBuffer: ?[*:0]u16,
ActualSourceFileNameBufferLen: u32,
RequiredBufferLen: ?*u32,
SourceFileSize: ?*u32,
TargetFileSize: ?*u32,
CompressionType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDecompressOrCopyFileA(
SourceFileName: ?[*:0]const u8,
TargetFileName: ?[*:0]const u8,
CompressionType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDecompressOrCopyFileW(
SourceFileName: ?[*:0]const u16,
TargetFileName: ?[*:0]const u16,
CompressionType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetSourceFileLocationA(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
FileName: ?[*:0]const u8,
SourceId: ?*u32,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetSourceFileLocationW(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
FileName: ?[*:0]const u16,
SourceId: ?*u32,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetSourceFileSizeA(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
FileName: ?[*:0]const u8,
Section: ?[*:0]const u8,
FileSize: ?*u32,
RoundingFactor: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetSourceFileSizeW(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
FileName: ?[*:0]const u16,
Section: ?[*:0]const u16,
FileSize: ?*u32,
RoundingFactor: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetTargetPathA(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
Section: ?[*:0]const u8,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetTargetPathW(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
Section: ?[*:0]const u16,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetSourceListA(
Flags: u32,
SourceList: [*]?PSTR,
SourceCount: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetSourceListW(
Flags: u32,
SourceList: [*]?PWSTR,
SourceCount: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCancelTemporarySourceList(
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAddToSourceListA(
Flags: u32,
Source: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAddToSourceListW(
Flags: u32,
Source: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveFromSourceListA(
Flags: u32,
Source: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveFromSourceListW(
Flags: u32,
Source: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQuerySourceListA(
Flags: u32,
List: ?*?*?PSTR,
Count: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQuerySourceListW(
Flags: u32,
List: ?*?*?PWSTR,
Count: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupFreeSourceListA(
List: [*]?*?PSTR,
Count: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupFreeSourceListW(
List: [*]?*?PWSTR,
Count: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupPromptForDiskA(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u8,
DiskName: ?[*:0]const u8,
PathToSource: ?[*:0]const u8,
FileSought: ?[*:0]const u8,
TagFile: ?[*:0]const u8,
DiskPromptStyle: u32,
PathBuffer: ?[*:0]u8,
PathBufferSize: u32,
PathRequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupPromptForDiskW(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u16,
DiskName: ?[*:0]const u16,
PathToSource: ?[*:0]const u16,
FileSought: ?[*:0]const u16,
TagFile: ?[*:0]const u16,
DiskPromptStyle: u32,
PathBuffer: ?[*:0]u16,
PathBufferSize: u32,
PathRequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCopyErrorA(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u8,
DiskName: ?[*:0]const u8,
PathToSource: ?[*:0]const u8,
SourceFile: ?[*:0]const u8,
TargetPathFile: ?[*:0]const u8,
Win32ErrorCode: u32,
Style: u32,
PathBuffer: ?[*:0]u8,
PathBufferSize: u32,
PathRequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCopyErrorW(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u16,
DiskName: ?[*:0]const u16,
PathToSource: ?[*:0]const u16,
SourceFile: ?[*:0]const u16,
TargetPathFile: ?[*:0]const u16,
Win32ErrorCode: u32,
Style: u32,
PathBuffer: ?[*:0]u16,
PathBufferSize: u32,
PathRequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRenameErrorA(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u8,
SourceFile: ?[*:0]const u8,
TargetFile: ?[*:0]const u8,
Win32ErrorCode: u32,
Style: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRenameErrorW(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u16,
SourceFile: ?[*:0]const u16,
TargetFile: ?[*:0]const u16,
Win32ErrorCode: u32,
Style: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDeleteErrorA(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u8,
File: ?[*:0]const u8,
Win32ErrorCode: u32,
Style: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDeleteErrorW(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u16,
File: ?[*:0]const u16,
Win32ErrorCode: u32,
Style: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupBackupErrorA(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u8,
SourceFile: ?[*:0]const u8,
TargetFile: ?[*:0]const u8,
Win32ErrorCode: u32,
Style: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupBackupErrorW(
hwndParent: ?HWND,
DialogTitle: ?[*:0]const u16,
SourceFile: ?[*:0]const u16,
TargetFile: ?[*:0]const u16,
Win32ErrorCode: u32,
Style: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetDirectoryIdA(
InfHandle: ?*anyopaque,
Id: u32,
Directory: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetDirectoryIdW(
InfHandle: ?*anyopaque,
Id: u32,
Directory: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetDirectoryIdExA(
InfHandle: ?*anyopaque,
Id: u32,
Directory: ?[*:0]const u8,
Flags: u32,
Reserved1: u32,
Reserved2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetDirectoryIdExW(
InfHandle: ?*anyopaque,
Id: u32,
Directory: ?[*:0]const u16,
Flags: u32,
Reserved1: u32,
Reserved2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetSourceInfoA(
InfHandle: ?*anyopaque,
SourceId: u32,
InfoDesired: u32,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetSourceInfoW(
InfHandle: ?*anyopaque,
SourceId: u32,
InfoDesired: u32,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallFileA(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
SourceFile: ?[*:0]const u8,
SourcePathRoot: ?[*:0]const u8,
DestinationName: ?[*:0]const u8,
CopyStyle: SP_COPY_STYLE,
CopyMsgHandler: ?PSP_FILE_CALLBACK_A,
Context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallFileW(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
SourceFile: ?[*:0]const u16,
SourcePathRoot: ?[*:0]const u16,
DestinationName: ?[*:0]const u16,
CopyStyle: SP_COPY_STYLE,
CopyMsgHandler: ?PSP_FILE_CALLBACK_W,
Context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallFileExA(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
SourceFile: ?[*:0]const u8,
SourcePathRoot: ?[*:0]const u8,
DestinationName: ?[*:0]const u8,
CopyStyle: SP_COPY_STYLE,
CopyMsgHandler: ?PSP_FILE_CALLBACK_A,
Context: ?*anyopaque,
FileWasInUse: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallFileExW(
InfHandle: ?*anyopaque,
InfContext: ?*INFCONTEXT,
SourceFile: ?[*:0]const u16,
SourcePathRoot: ?[*:0]const u16,
DestinationName: ?[*:0]const u16,
CopyStyle: SP_COPY_STYLE,
CopyMsgHandler: ?PSP_FILE_CALLBACK_W,
Context: ?*anyopaque,
FileWasInUse: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupOpenFileQueue(
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCloseFileQueue(
QueueHandle: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetFileQueueAlternatePlatformA(
QueueHandle: ?*anyopaque,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
AlternateDefaultCatalogFile: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetFileQueueAlternatePlatformW(
QueueHandle: ?*anyopaque,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
AlternateDefaultCatalogFile: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetPlatformPathOverrideA(
Override: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetPlatformPathOverrideW(
Override: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueCopyA(
QueueHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u8,
SourcePath: ?[*:0]const u8,
SourceFilename: ?[*:0]const u8,
SourceDescription: ?[*:0]const u8,
SourceTagfile: ?[*:0]const u8,
TargetDirectory: ?[*:0]const u8,
TargetFilename: ?[*:0]const u8,
CopyStyle: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueCopyW(
QueueHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u16,
SourcePath: ?[*:0]const u16,
SourceFilename: ?[*:0]const u16,
SourceDescription: ?[*:0]const u16,
SourceTagfile: ?[*:0]const u16,
TargetDirectory: ?[*:0]const u16,
TargetFilename: ?[*:0]const u16,
CopyStyle: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueCopyIndirectA(
CopyParams: ?*SP_FILE_COPY_PARAMS_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueCopyIndirectW(
CopyParams: ?*SP_FILE_COPY_PARAMS_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueDefaultCopyA(
QueueHandle: ?*anyopaque,
InfHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u8,
SourceFilename: ?[*:0]const u8,
TargetFilename: ?[*:0]const u8,
CopyStyle: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueDefaultCopyW(
QueueHandle: ?*anyopaque,
InfHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u16,
SourceFilename: ?[*:0]const u16,
TargetFilename: ?[*:0]const u16,
CopyStyle: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueCopySectionA(
QueueHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u8,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
Section: ?[*:0]const u8,
CopyStyle: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueCopySectionW(
QueueHandle: ?*anyopaque,
SourceRootPath: ?[*:0]const u16,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
Section: ?[*:0]const u16,
CopyStyle: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueDeleteA(
QueueHandle: ?*anyopaque,
PathPart1: ?[*:0]const u8,
PathPart2: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueDeleteW(
QueueHandle: ?*anyopaque,
PathPart1: ?[*:0]const u16,
PathPart2: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueDeleteSectionA(
QueueHandle: ?*anyopaque,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
Section: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueDeleteSectionW(
QueueHandle: ?*anyopaque,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
Section: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueRenameA(
QueueHandle: ?*anyopaque,
SourcePath: ?[*:0]const u8,
SourceFilename: ?[*:0]const u8,
TargetPath: ?[*:0]const u8,
TargetFilename: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueRenameW(
QueueHandle: ?*anyopaque,
SourcePath: ?[*:0]const u16,
SourceFilename: ?[*:0]const u16,
TargetPath: ?[*:0]const u16,
TargetFilename: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueRenameSectionA(
QueueHandle: ?*anyopaque,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
Section: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueueRenameSectionW(
QueueHandle: ?*anyopaque,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
Section: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCommitFileQueueA(
Owner: ?HWND,
QueueHandle: ?*anyopaque,
MsgHandler: ?PSP_FILE_CALLBACK_A,
Context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCommitFileQueueW(
Owner: ?HWND,
QueueHandle: ?*anyopaque,
MsgHandler: ?PSP_FILE_CALLBACK_W,
Context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupScanFileQueueA(
FileQueue: ?*anyopaque,
Flags: u32,
Window: ?HWND,
CallbackRoutine: ?PSP_FILE_CALLBACK_A,
CallbackContext: ?*anyopaque,
Result: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupScanFileQueueW(
FileQueue: ?*anyopaque,
Flags: u32,
Window: ?HWND,
CallbackRoutine: ?PSP_FILE_CALLBACK_W,
CallbackContext: ?*anyopaque,
Result: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetFileQueueCount(
FileQueue: ?*anyopaque,
SubQueueFileOp: u32,
NumOperations: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetFileQueueFlags(
FileQueue: ?*anyopaque,
Flags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetFileQueueFlags(
FileQueue: ?*anyopaque,
FlagMask: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCopyOEMInfA(
SourceInfFileName: ?[*:0]const u8,
OEMSourceMediaLocation: ?[*:0]const u8,
OEMSourceMediaType: OEM_SOURCE_MEDIA_TYPE,
CopyStyle: u32,
DestinationInfFileName: ?[*:0]u8,
DestinationInfFileNameSize: u32,
RequiredSize: ?*u32,
DestinationInfFileNameComponent: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCopyOEMInfW(
SourceInfFileName: ?[*:0]const u16,
OEMSourceMediaLocation: ?[*:0]const u16,
OEMSourceMediaType: OEM_SOURCE_MEDIA_TYPE,
CopyStyle: u32,
DestinationInfFileName: ?[*:0]u16,
DestinationInfFileNameSize: u32,
RequiredSize: ?*u32,
DestinationInfFileNameComponent: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupUninstallOEMInfA(
InfFileName: ?[*:0]const u8,
Flags: u32,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupUninstallOEMInfW(
InfFileName: ?[*:0]const u16,
Flags: u32,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupUninstallNewlyCopiedInfs(
FileQueue: ?*anyopaque,
Flags: u32,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCreateDiskSpaceListA(
Reserved1: ?*anyopaque,
Reserved2: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCreateDiskSpaceListW(
Reserved1: ?*anyopaque,
Reserved2: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDuplicateDiskSpaceListA(
DiskSpace: ?*anyopaque,
Reserved1: ?*anyopaque,
Reserved2: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDuplicateDiskSpaceListW(
DiskSpace: ?*anyopaque,
Reserved1: ?*anyopaque,
Reserved2: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDestroyDiskSpaceList(
DiskSpace: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryDrivesInDiskSpaceListA(
DiskSpace: ?*anyopaque,
ReturnBuffer: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryDrivesInDiskSpaceListW(
DiskSpace: ?*anyopaque,
ReturnBuffer: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQuerySpaceRequiredOnDriveA(
DiskSpace: ?*anyopaque,
DriveSpec: ?[*:0]const u8,
SpaceRequired: ?*i64,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQuerySpaceRequiredOnDriveW(
DiskSpace: ?*anyopaque,
DriveSpec: ?[*:0]const u16,
SpaceRequired: ?*i64,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAdjustDiskSpaceListA(
DiskSpace: ?*anyopaque,
DriveRoot: ?[*:0]const u8,
Amount: i64,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAdjustDiskSpaceListW(
DiskSpace: ?*anyopaque,
DriveRoot: ?[*:0]const u16,
Amount: i64,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAddToDiskSpaceListA(
DiskSpace: ?*anyopaque,
TargetFilespec: ?[*:0]const u8,
FileSize: i64,
Operation: SETUP_FILE_OPERATION,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAddToDiskSpaceListW(
DiskSpace: ?*anyopaque,
TargetFilespec: ?[*:0]const u16,
FileSize: i64,
Operation: SETUP_FILE_OPERATION,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAddSectionToDiskSpaceListA(
DiskSpace: ?*anyopaque,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
SectionName: ?[*:0]const u8,
Operation: SETUP_FILE_OPERATION,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAddSectionToDiskSpaceListW(
DiskSpace: ?*anyopaque,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
SectionName: ?[*:0]const u16,
Operation: SETUP_FILE_OPERATION,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAddInstallSectionToDiskSpaceListA(
DiskSpace: ?*anyopaque,
InfHandle: ?*anyopaque,
LayoutInfHandle: ?*anyopaque,
SectionName: ?[*:0]const u8,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupAddInstallSectionToDiskSpaceListW(
DiskSpace: ?*anyopaque,
InfHandle: ?*anyopaque,
LayoutInfHandle: ?*anyopaque,
SectionName: ?[*:0]const u16,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveFromDiskSpaceListA(
DiskSpace: ?*anyopaque,
TargetFilespec: ?[*:0]const u8,
Operation: SETUP_FILE_OPERATION,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveFromDiskSpaceListW(
DiskSpace: ?*anyopaque,
TargetFilespec: ?[*:0]const u16,
Operation: SETUP_FILE_OPERATION,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveSectionFromDiskSpaceListA(
DiskSpace: ?*anyopaque,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
SectionName: ?[*:0]const u8,
Operation: SETUP_FILE_OPERATION,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveSectionFromDiskSpaceListW(
DiskSpace: ?*anyopaque,
InfHandle: ?*anyopaque,
ListInfHandle: ?*anyopaque,
SectionName: ?[*:0]const u16,
Operation: SETUP_FILE_OPERATION,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveInstallSectionFromDiskSpaceListA(
DiskSpace: ?*anyopaque,
InfHandle: ?*anyopaque,
LayoutInfHandle: ?*anyopaque,
SectionName: ?[*:0]const u8,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveInstallSectionFromDiskSpaceListW(
DiskSpace: ?*anyopaque,
InfHandle: ?*anyopaque,
LayoutInfHandle: ?*anyopaque,
SectionName: ?[*:0]const u16,
Reserved1: ?*anyopaque,
Reserved2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupIterateCabinetA(
CabinetFile: ?[*:0]const u8,
Reserved: u32,
MsgHandler: ?PSP_FILE_CALLBACK_A,
Context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupIterateCabinetW(
CabinetFile: ?[*:0]const u16,
Reserved: u32,
MsgHandler: ?PSP_FILE_CALLBACK_W,
Context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupPromptReboot(
FileQueue: ?*anyopaque,
Owner: ?HWND,
ScanOnly: BOOL,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInitDefaultQueueCallback(
OwnerWindow: ?HWND,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInitDefaultQueueCallbackEx(
OwnerWindow: ?HWND,
AlternateProgressWindow: ?HWND,
ProgressMessage: u32,
Reserved1: u32,
Reserved2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupTermDefaultQueueCallback(
Context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDefaultQueueCallbackA(
Context: ?*anyopaque,
Notification: u32,
Param1: usize,
Param2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDefaultQueueCallbackW(
Context: ?*anyopaque,
Notification: u32,
Param1: usize,
Param2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallFromInfSectionA(
Owner: ?HWND,
InfHandle: ?*anyopaque,
SectionName: ?[*:0]const u8,
Flags: u32,
RelativeKeyRoot: ?HKEY,
SourceRootPath: ?[*:0]const u8,
CopyFlags: u32,
MsgHandler: ?PSP_FILE_CALLBACK_A,
Context: ?*anyopaque,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallFromInfSectionW(
Owner: ?HWND,
InfHandle: ?*anyopaque,
SectionName: ?[*:0]const u16,
Flags: u32,
RelativeKeyRoot: ?HKEY,
SourceRootPath: ?[*:0]const u16,
CopyFlags: u32,
MsgHandler: ?PSP_FILE_CALLBACK_W,
Context: ?*anyopaque,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallFilesFromInfSectionA(
InfHandle: ?*anyopaque,
LayoutInfHandle: ?*anyopaque,
FileQueue: ?*anyopaque,
SectionName: ?[*:0]const u8,
SourceRootPath: ?[*:0]const u8,
CopyFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallFilesFromInfSectionW(
InfHandle: ?*anyopaque,
LayoutInfHandle: ?*anyopaque,
FileQueue: ?*anyopaque,
SectionName: ?[*:0]const u16,
SourceRootPath: ?[*:0]const u16,
CopyFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallServicesFromInfSectionA(
InfHandle: ?*anyopaque,
SectionName: ?[*:0]const u8,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallServicesFromInfSectionW(
InfHandle: ?*anyopaque,
SectionName: ?[*:0]const u16,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallServicesFromInfSectionExA(
InfHandle: ?*anyopaque,
SectionName: ?[*:0]const u8,
Flags: u32,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Reserved1: ?*anyopaque,
Reserved2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInstallServicesFromInfSectionExW(
InfHandle: ?*anyopaque,
SectionName: ?[*:0]const u16,
Flags: u32,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Reserved1: ?*anyopaque,
Reserved2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn InstallHinfSectionA(
Window: ?HWND,
ModuleHandle: ?HINSTANCE,
CommandLine: ?[*:0]const u8,
ShowCommand: i32,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn InstallHinfSectionW(
Window: ?HWND,
ModuleHandle: ?HINSTANCE,
CommandLine: ?[*:0]const u16,
ShowCommand: i32,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInitializeFileLogA(
LogFileName: ?[*:0]const u8,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupInitializeFileLogW(
LogFileName: ?[*:0]const u16,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupTerminateFileLog(
FileLogHandle: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupLogFileA(
FileLogHandle: ?*anyopaque,
LogSectionName: ?[*:0]const u8,
SourceFilename: ?[*:0]const u8,
TargetFilename: ?[*:0]const u8,
Checksum: u32,
DiskTagfile: ?[*:0]const u8,
DiskDescription: ?[*:0]const u8,
OtherInfo: ?[*:0]const u8,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupLogFileW(
FileLogHandle: ?*anyopaque,
LogSectionName: ?[*:0]const u16,
SourceFilename: ?[*:0]const u16,
TargetFilename: ?[*:0]const u16,
Checksum: u32,
DiskTagfile: ?[*:0]const u16,
DiskDescription: ?[*:0]const u16,
OtherInfo: ?[*:0]const u16,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveFileLogEntryA(
FileLogHandle: ?*anyopaque,
LogSectionName: ?[*:0]const u8,
TargetFilename: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupRemoveFileLogEntryW(
FileLogHandle: ?*anyopaque,
LogSectionName: ?[*:0]const u16,
TargetFilename: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryFileLogA(
FileLogHandle: ?*anyopaque,
LogSectionName: ?[*:0]const u8,
TargetFilename: ?[*:0]const u8,
DesiredInfo: SetupFileLogInfo,
DataOut: ?[*:0]u8,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupQueryFileLogW(
FileLogHandle: ?*anyopaque,
LogSectionName: ?[*:0]const u16,
TargetFilename: ?[*:0]const u16,
DesiredInfo: SetupFileLogInfo,
DataOut: ?[*:0]u16,
ReturnBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupOpenLog(
Erase: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupLogErrorA(
MessageString: ?[*:0]const u8,
Severity: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupLogErrorW(
MessageString: ?[*:0]const u16,
Severity: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupCloseLog(
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupGetThreadLogToken(
) callconv(@import("std").os.windows.WINAPI) u64;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupSetThreadLogToken(
LogToken: u64,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupWriteTextLog(
LogToken: u64,
Category: u32,
Flags: u32,
MessageStr: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupWriteTextLogError(
LogToken: u64,
Category: u32,
LogFlags: u32,
Error: u32,
MessageStr: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupWriteTextLogInfLine(
LogToken: u64,
Flags: u32,
InfHandle: ?*anyopaque,
Context: ?*INFCONTEXT,
) callconv(@import("std").os.windows.WINAPI) void;
pub extern "SETUPAPI" fn SetupGetBackupInformationA(
QueueHandle: ?*anyopaque,
BackupParams: ?*SP_BACKUP_QUEUE_PARAMS_V2_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "SETUPAPI" fn SetupGetBackupInformationW(
QueueHandle: ?*anyopaque,
BackupParams: ?*SP_BACKUP_QUEUE_PARAMS_V2_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "SETUPAPI" fn SetupPrepareQueueForRestoreA(
QueueHandle: ?*anyopaque,
BackupPath: ?[*:0]const u8,
RestoreFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "SETUPAPI" fn SetupPrepareQueueForRestoreW(
QueueHandle: ?*anyopaque,
BackupPath: ?[*:0]const u16,
RestoreFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupSetNonInteractiveMode(
NonInteractiveFlag: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupGetNonInteractiveMode(
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInfoList(
ClassGuid: ?*const Guid,
hwndParent: ?HWND,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInfoListExA(
ClassGuid: ?*const Guid,
hwndParent: ?HWND,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInfoListExW(
ClassGuid: ?*const Guid,
hwndParent: ?HWND,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInfoListClass(
DeviceInfoSet: ?*anyopaque,
ClassGuid: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInfoListDetailA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoSetDetailData: ?*SP_DEVINFO_LIST_DETAIL_DATA_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInfoListDetailW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoSetDetailData: ?*SP_DEVINFO_LIST_DETAIL_DATA_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInfoA(
DeviceInfoSet: ?*anyopaque,
DeviceName: ?[*:0]const u8,
ClassGuid: ?*const Guid,
DeviceDescription: ?[*:0]const u8,
hwndParent: ?HWND,
CreationFlags: u32,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInfoW(
DeviceInfoSet: ?*anyopaque,
DeviceName: ?[*:0]const u16,
ClassGuid: ?*const Guid,
DeviceDescription: ?[*:0]const u16,
hwndParent: ?HWND,
CreationFlags: u32,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenDeviceInfoA(
DeviceInfoSet: ?*anyopaque,
DeviceInstanceId: ?[*:0]const u8,
hwndParent: ?HWND,
OpenFlags: u32,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenDeviceInfoW(
DeviceInfoSet: ?*anyopaque,
DeviceInstanceId: ?[*:0]const u16,
hwndParent: ?HWND,
OpenFlags: u32,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInstanceIdA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DeviceInstanceId: ?[*:0]u8,
DeviceInstanceIdSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInstanceIdW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DeviceInstanceId: ?[*:0]u16,
DeviceInstanceIdSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiDeleteDeviceInfo(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiEnumDeviceInfo(
DeviceInfoSet: ?*anyopaque,
MemberIndex: u32,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiDestroyDeviceInfoList(
DeviceInfoSet: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiEnumDeviceInterfaces(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
InterfaceClassGuid: ?*const Guid,
MemberIndex: u32,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInterfaceA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
InterfaceClassGuid: ?*const Guid,
ReferenceString: ?[*:0]const u8,
CreationFlags: u32,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInterfaceW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
InterfaceClassGuid: ?*const Guid,
ReferenceString: ?[*:0]const u16,
CreationFlags: u32,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenDeviceInterfaceA(
DeviceInfoSet: ?*anyopaque,
DevicePath: ?[*:0]const u8,
OpenFlags: u32,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenDeviceInterfaceW(
DeviceInfoSet: ?*anyopaque,
DevicePath: ?[*:0]const u16,
OpenFlags: u32,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInterfaceAlias(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
AliasInterfaceClassGuid: ?*const Guid,
AliasDeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiDeleteDeviceInterfaceData(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiRemoveDeviceInterface(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInterfaceDetailA(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
// TODO: what to do with BytesParamIndex 3?
DeviceInterfaceDetailData: ?*SP_DEVICE_INTERFACE_DETAIL_DATA_A,
DeviceInterfaceDetailDataSize: u32,
RequiredSize: ?*u32,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInterfaceDetailW(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
// TODO: what to do with BytesParamIndex 3?
DeviceInterfaceDetailData: ?*SP_DEVICE_INTERFACE_DETAIL_DATA_W,
DeviceInterfaceDetailDataSize: u32,
RequiredSize: ?*u32,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiInstallDeviceInterfaces(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiSetDeviceInterfaceDefault(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
Flags: u32,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiRegisterDeviceInfo(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Flags: u32,
CompareProc: ?PSP_DETSIG_CMPPROC,
CompareContext: ?*anyopaque,
DupDeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiBuildDriverInfoList(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverType: SETUP_DI_BUILD_DRIVER_DRIVER_TYPE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCancelDriverInfoSearch(
DeviceInfoSet: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiEnumDriverInfoA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverType: u32,
MemberIndex: u32,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiEnumDriverInfoW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverType: u32,
MemberIndex: u32,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetSelectedDriverA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetSelectedDriverW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetSelectedDriverA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetSelectedDriverW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDriverInfoDetailA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_A,
// TODO: what to do with BytesParamIndex 4?
DriverInfoDetailData: ?*SP_DRVINFO_DETAIL_DATA_A,
DriverInfoDetailDataSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDriverInfoDetailW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_W,
// TODO: what to do with BytesParamIndex 4?
DriverInfoDetailData: ?*SP_DRVINFO_DETAIL_DATA_W,
DriverInfoDetailDataSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiDestroyDriverInfoList(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverType: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDevsA(
ClassGuid: ?*const Guid,
Enumerator: ?[*:0]const u8,
hwndParent: ?HWND,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDevsW(
ClassGuid: ?*const Guid,
Enumerator: ?[*:0]const u16,
hwndParent: ?HWND,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDevsExA(
ClassGuid: ?*const Guid,
Enumerator: ?[*:0]const u8,
hwndParent: ?HWND,
Flags: u32,
DeviceInfoSet: ?*anyopaque,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDevsExW(
ClassGuid: ?*const Guid,
Enumerator: ?[*:0]const u16,
hwndParent: ?HWND,
Flags: u32,
DeviceInfoSet: ?*anyopaque,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetINFClassA(
InfName: ?[*:0]const u8,
ClassGuid: ?*Guid,
ClassName: [*:0]u8,
ClassNameSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetINFClassW(
InfName: ?[*:0]const u16,
ClassGuid: ?*Guid,
ClassName: [*:0]u16,
ClassNameSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiBuildClassInfoList(
Flags: u32,
ClassGuidList: ?[*]Guid,
ClassGuidListSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiBuildClassInfoListExA(
Flags: u32,
ClassGuidList: ?[*]Guid,
ClassGuidListSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiBuildClassInfoListExW(
Flags: u32,
ClassGuidList: ?[*]Guid,
ClassGuidListSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDescriptionA(
ClassGuid: ?*const Guid,
ClassDescription: [*:0]u8,
ClassDescriptionSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDescriptionW(
ClassGuid: ?*const Guid,
ClassDescription: [*:0]u16,
ClassDescriptionSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDescriptionExA(
ClassGuid: ?*const Guid,
ClassDescription: [*:0]u8,
ClassDescriptionSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDescriptionExW(
ClassGuid: ?*const Guid,
ClassDescription: [*:0]u16,
ClassDescriptionSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCallClassInstaller(
InstallFunction: u32,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSelectDevice(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSelectBestCompatDrv(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiInstallDevice(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiInstallDriverFiles(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiRegisterCoDeviceInstallers(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiRemoveDevice(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiUnremoveDevice(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "SETUPAPI" fn SetupDiRestartDevices(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiChangeState(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiInstallClassA(
hwndParent: ?HWND,
InfFileName: ?[*:0]const u8,
Flags: u32,
FileQueue: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiInstallClassW(
hwndParent: ?HWND,
InfFileName: ?[*:0]const u16,
Flags: u32,
FileQueue: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiInstallClassExA(
hwndParent: ?HWND,
InfFileName: ?[*:0]const u8,
Flags: u32,
FileQueue: ?*anyopaque,
InterfaceClassGuid: ?*const Guid,
Reserved1: ?*anyopaque,
Reserved2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiInstallClassExW(
hwndParent: ?HWND,
InfFileName: ?[*:0]const u16,
Flags: u32,
FileQueue: ?*anyopaque,
InterfaceClassGuid: ?*const Guid,
Reserved1: ?*anyopaque,
Reserved2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenClassRegKey(
ClassGuid: ?*const Guid,
samDesired: u32,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenClassRegKeyExA(
ClassGuid: ?*const Guid,
samDesired: u32,
Flags: u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenClassRegKeyExW(
ClassGuid: ?*const Guid,
samDesired: u32,
Flags: u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInterfaceRegKeyA(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
Reserved: u32,
samDesired: u32,
InfHandle: ?*anyopaque,
InfSectionName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDeviceInterfaceRegKeyW(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
Reserved: u32,
samDesired: u32,
InfHandle: ?*anyopaque,
InfSectionName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenDeviceInterfaceRegKey(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
Reserved: u32,
samDesired: u32,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiDeleteDeviceInterfaceRegKey(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
Reserved: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDevRegKeyA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Scope: u32,
HwProfile: u32,
KeyType: u32,
InfHandle: ?*anyopaque,
InfSectionName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiCreateDevRegKeyW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Scope: u32,
HwProfile: u32,
KeyType: u32,
InfHandle: ?*anyopaque,
InfSectionName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiOpenDevRegKey(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Scope: u32,
HwProfile: u32,
KeyType: u32,
samDesired: u32,
) callconv(@import("std").os.windows.WINAPI) ?HKEY;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiDeleteDevRegKey(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Scope: u32,
HwProfile: u32,
KeyType: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetHwProfileList(
HwProfileList: [*]u32,
HwProfileListSize: u32,
RequiredSize: ?*u32,
CurrentlyActiveIndex: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetHwProfileListExA(
HwProfileList: [*]u32,
HwProfileListSize: u32,
RequiredSize: ?*u32,
CurrentlyActiveIndex: ?*u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetHwProfileListExW(
HwProfileList: [*]u32,
HwProfileListSize: u32,
RequiredSize: ?*u32,
CurrentlyActiveIndex: ?*u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiGetDevicePropertyKeys(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: u32,
RequiredPropertyKeyCount: ?*u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiGetDevicePropertyW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 5?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiSetDevicePropertyW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 5?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiGetDeviceInterfacePropertyKeys(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: u32,
RequiredPropertyKeyCount: ?*u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiGetDeviceInterfacePropertyW(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 5?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiSetDeviceInterfacePropertyW(
DeviceInfoSet: ?*anyopaque,
DeviceInterfaceData: ?*SP_DEVICE_INTERFACE_DATA,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 5?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiGetClassPropertyKeys(
ClassGuid: ?*const Guid,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: u32,
RequiredPropertyKeyCount: ?*u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiGetClassPropertyKeysExW(
ClassGuid: ?*const Guid,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: u32,
RequiredPropertyKeyCount: ?*u32,
Flags: u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiGetClassPropertyW(
ClassGuid: ?*const Guid,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiGetClassPropertyExW(
ClassGuid: ?*const Guid,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
Flags: u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiSetClassPropertyW(
ClassGuid: ?*const Guid,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiSetClassPropertyExW(
ClassGuid: ?*const Guid,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
Flags: u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceRegistryPropertyA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Property: u32,
PropertyRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 5?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceRegistryPropertyW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Property: u32,
PropertyRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 5?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiGetClassRegistryPropertyA(
ClassGuid: ?*const Guid,
Property: u32,
PropertyRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiGetClassRegistryPropertyW(
ClassGuid: ?*const Guid,
Property: u32,
PropertyRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetDeviceRegistryPropertyA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Property: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetDeviceRegistryPropertyW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Property: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiSetClassRegistryPropertyA(
ClassGuid: ?*const Guid,
Property: u32,
// TODO: what to do with BytesParamIndex 3?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiSetClassRegistryPropertyW(
ClassGuid: ?*const Guid,
Property: u32,
// TODO: what to do with BytesParamIndex 3?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInstallParamsA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DeviceInstallParams: ?*SP_DEVINSTALL_PARAMS_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDeviceInstallParamsW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DeviceInstallParams: ?*SP_DEVINSTALL_PARAMS_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassInstallParamsA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
// TODO: what to do with BytesParamIndex 3?
ClassInstallParams: ?*SP_CLASSINSTALL_HEADER,
ClassInstallParamsSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassInstallParamsW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
// TODO: what to do with BytesParamIndex 3?
ClassInstallParams: ?*SP_CLASSINSTALL_HEADER,
ClassInstallParamsSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetDeviceInstallParamsA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DeviceInstallParams: ?*SP_DEVINSTALL_PARAMS_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetDeviceInstallParamsW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DeviceInstallParams: ?*SP_DEVINSTALL_PARAMS_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetClassInstallParamsA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
// TODO: what to do with BytesParamIndex 3?
ClassInstallParams: ?*SP_CLASSINSTALL_HEADER,
ClassInstallParamsSize: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetClassInstallParamsW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
// TODO: what to do with BytesParamIndex 3?
ClassInstallParams: ?*SP_CLASSINSTALL_HEADER,
ClassInstallParamsSize: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDriverInstallParamsA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_A,
DriverInstallParams: ?*SP_DRVINSTALL_PARAMS,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetDriverInstallParamsW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_W,
DriverInstallParams: ?*SP_DRVINSTALL_PARAMS,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetDriverInstallParamsA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_A,
DriverInstallParams: ?*SP_DRVINSTALL_PARAMS,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetDriverInstallParamsW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_W,
DriverInstallParams: ?*SP_DRVINSTALL_PARAMS,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiLoadClassIcon(
ClassGuid: ?*const Guid,
LargeIcon: ?*?HICON,
MiniIconIndex: ?*i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "SETUPAPI" fn SetupDiLoadDeviceIcon(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
cxIcon: u32,
cyIcon: u32,
Flags: u32,
hIcon: ?*?HICON,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiDrawMiniIcon(
hdc: ?HDC,
rc: RECT,
MiniIconIndex: i32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassBitmapIndex(
ClassGuid: ?*const Guid,
MiniIconIndex: ?*i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassImageList(
ClassImageListData: ?*SP_CLASSIMAGELIST_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassImageListExA(
ClassImageListData: ?*SP_CLASSIMAGELIST_DATA,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassImageListExW(
ClassImageListData: ?*SP_CLASSIMAGELIST_DATA,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassImageIndex(
ClassImageListData: ?*SP_CLASSIMAGELIST_DATA,
ClassGuid: ?*const Guid,
ImageIndex: ?*i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiDestroyClassImageList(
ClassImageListData: ?*SP_CLASSIMAGELIST_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDevPropertySheetsA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
PropertySheetHeader: ?*PROPSHEETHEADERA_V2,
PropertySheetHeaderPageListSize: u32,
RequiredSize: ?*u32,
PropertySheetType: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetClassDevPropertySheetsW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
PropertySheetHeader: ?*PROPSHEETHEADERW_V2,
PropertySheetHeaderPageListSize: u32,
RequiredSize: ?*u32,
PropertySheetType: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiAskForOEMDisk(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSelectOEMDrv(
hwndParent: ?HWND,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiClassNameFromGuidA(
ClassGuid: ?*const Guid,
ClassName: [*:0]u8,
ClassNameSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiClassNameFromGuidW(
ClassGuid: ?*const Guid,
ClassName: [*:0]u16,
ClassNameSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiClassNameFromGuidExA(
ClassGuid: ?*const Guid,
ClassName: [*:0]u8,
ClassNameSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiClassNameFromGuidExW(
ClassGuid: ?*const Guid,
ClassName: [*:0]u16,
ClassNameSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiClassGuidsFromNameA(
ClassName: ?[*:0]const u8,
ClassGuidList: [*]Guid,
ClassGuidListSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiClassGuidsFromNameW(
ClassName: ?[*:0]const u16,
ClassGuidList: [*]Guid,
ClassGuidListSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiClassGuidsFromNameExA(
ClassName: ?[*:0]const u8,
ClassGuidList: [*]Guid,
ClassGuidListSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiClassGuidsFromNameExW(
ClassName: ?[*:0]const u16,
ClassGuidList: [*]Guid,
ClassGuidListSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetHwProfileFriendlyNameA(
HwProfile: u32,
FriendlyName: [*:0]u8,
FriendlyNameSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetHwProfileFriendlyNameW(
HwProfile: u32,
FriendlyName: [*:0]u16,
FriendlyNameSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetHwProfileFriendlyNameExA(
HwProfile: u32,
FriendlyName: [*:0]u8,
FriendlyNameSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u8,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetHwProfileFriendlyNameExW(
HwProfile: u32,
FriendlyName: [*:0]u16,
FriendlyNameSize: u32,
RequiredSize: ?*u32,
MachineName: ?[*:0]const u16,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "SETUPAPI" fn SetupDiGetWizardPage(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
InstallWizardData: ?*SP_INSTALLWIZARD_DATA,
PageType: u32,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) ?HPROPSHEETPAGE;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetSelectedDevice(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiSetSelectedDevice(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "SETUPAPI" fn SetupDiGetActualModelsSectionA(
Context: ?*INFCONTEXT,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
InfSectionWithExt: ?[*:0]u8,
InfSectionWithExtSize: u32,
RequiredSize: ?*u32,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "SETUPAPI" fn SetupDiGetActualModelsSectionW(
Context: ?*INFCONTEXT,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
InfSectionWithExt: ?[*:0]u16,
InfSectionWithExtSize: u32,
RequiredSize: ?*u32,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetActualSectionToInstallA(
InfHandle: ?*anyopaque,
InfSectionName: ?[*:0]const u8,
InfSectionWithExt: ?[*:0]u8,
InfSectionWithExtSize: u32,
RequiredSize: ?*u32,
Extension: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "SETUPAPI" fn SetupDiGetActualSectionToInstallW(
InfHandle: ?*anyopaque,
InfSectionName: ?[*:0]const u16,
InfSectionWithExt: ?[*:0]u16,
InfSectionWithExtSize: u32,
RequiredSize: ?*u32,
Extension: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiGetActualSectionToInstallExA(
InfHandle: ?*anyopaque,
InfSectionName: ?[*:0]const u8,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
InfSectionWithExt: ?[*:0]u8,
InfSectionWithExtSize: u32,
RequiredSize: ?*u32,
Extension: ?*?PSTR,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiGetActualSectionToInstallExW(
InfHandle: ?*anyopaque,
InfSectionName: ?[*:0]const u16,
AlternatePlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
InfSectionWithExt: ?[*:0]u16,
InfSectionWithExtSize: u32,
RequiredSize: ?*u32,
Extension: ?*?PWSTR,
Reserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupEnumInfSectionsA(
InfHandle: ?*anyopaque,
Index: u32,
Buffer: ?[*:0]u8,
Size: u32,
SizeNeeded: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupEnumInfSectionsW(
InfHandle: ?*anyopaque,
Index: u32,
Buffer: ?[*:0]u16,
Size: u32,
SizeNeeded: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupVerifyInfFileA(
InfName: ?[*:0]const u8,
AltPlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
InfSignerInfo: ?*SP_INF_SIGNER_INFO_V2_A,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupVerifyInfFileW(
InfName: ?[*:0]const u16,
AltPlatformInfo: ?*SP_ALTPLATFORM_INFO_V2,
InfSignerInfo: ?*SP_INF_SIGNER_INFO_V2_W,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiGetCustomDevicePropertyA(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
CustomPropertyName: ?[*:0]const u8,
Flags: u32,
PropertyRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 6?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "SETUPAPI" fn SetupDiGetCustomDevicePropertyW(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
CustomPropertyName: ?[*:0]const u16,
Flags: u32,
PropertyRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 6?
PropertyBuffer: ?*u8,
PropertyBufferSize: u32,
RequiredSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windowsServer2003'
pub extern "SETUPAPI" fn SetupConfigureWmiFromInfSectionA(
InfHandle: ?*anyopaque,
SectionName: ?[*:0]const u8,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windowsServer2003'
pub extern "SETUPAPI" fn SetupConfigureWmiFromInfSectionW(
InfHandle: ?*anyopaque,
SectionName: ?[*:0]const u16,
Flags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Add_Empty_Log_Conf(
plcLogConf: ?*usize,
dnDevInst: u32,
Priority: PRIORITY,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Add_Empty_Log_Conf_Ex(
plcLogConf: ?*usize,
dnDevInst: u32,
Priority: PRIORITY,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Add_IDA(
dnDevInst: u32,
pszID: ?PSTR,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Add_IDW(
dnDevInst: u32,
pszID: ?PWSTR,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Add_ID_ExA(
dnDevInst: u32,
pszID: ?PSTR,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Add_ID_ExW(
dnDevInst: u32,
pszID: ?PWSTR,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Add_Range(
ullStartValue: u64,
ullEndValue: u64,
rlh: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Add_Res_Des(
prdResDes: ?*usize,
lcLogConf: usize,
ResourceID: u32,
// TODO: what to do with BytesParamIndex 4?
ResourceData: ?*anyopaque,
ResourceLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Add_Res_Des_Ex(
prdResDes: ?*usize,
lcLogConf: usize,
ResourceID: u32,
// TODO: what to do with BytesParamIndex 4?
ResourceData: ?*anyopaque,
ResourceLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Connect_MachineA(
UNCServerName: ?[*:0]const u8,
phMachine: ?*isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Connect_MachineW(
UNCServerName: ?[*:0]const u16,
phMachine: ?*isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Create_DevNodeA(
pdnDevInst: ?*u32,
pDeviceID: ?*i8,
dnParent: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Create_DevNodeW(
pdnDevInst: ?*u32,
pDeviceID: ?*u16,
dnParent: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Create_DevNode_ExA(
pdnDevInst: ?*u32,
pDeviceID: ?*i8,
dnParent: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Create_DevNode_ExW(
pdnDevInst: ?*u32,
pDeviceID: ?*u16,
dnParent: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Create_Range_List(
prlh: ?*usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Delete_Class_Key(
ClassGuid: ?*Guid,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Delete_Class_Key_Ex(
ClassGuid: ?*Guid,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Delete_DevNode_Key(
dnDevNode: u32,
ulHardwareProfile: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Delete_DevNode_Key_Ex(
dnDevNode: u32,
ulHardwareProfile: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Delete_Range(
ullStartValue: u64,
ullEndValue: u64,
rlh: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Detect_Resource_Conflict(
dnDevInst: u32,
ResourceID: u32,
// TODO: what to do with BytesParamIndex 3?
ResourceData: ?*anyopaque,
ResourceLen: u32,
pbConflictDetected: ?*BOOL,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Detect_Resource_Conflict_Ex(
dnDevInst: u32,
ResourceID: u32,
// TODO: what to do with BytesParamIndex 3?
ResourceData: ?*anyopaque,
ResourceLen: u32,
pbConflictDetected: ?*BOOL,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Disable_DevNode(
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Disable_DevNode_Ex(
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Disconnect_Machine(
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Dup_Range_List(
rlhOld: usize,
rlhNew: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Enable_DevNode(
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Enable_DevNode_Ex(
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Enumerate_Classes(
ulClassIndex: u32,
ClassGuid: ?*Guid,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Enumerate_Classes_Ex(
ulClassIndex: u32,
ClassGuid: ?*Guid,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Enumerate_EnumeratorsA(
ulEnumIndex: u32,
Buffer: [*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Enumerate_EnumeratorsW(
ulEnumIndex: u32,
Buffer: [*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Enumerate_Enumerators_ExA(
ulEnumIndex: u32,
Buffer: [*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Enumerate_Enumerators_ExW(
ulEnumIndex: u32,
Buffer: [*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Find_Range(
pullStart: ?*u64,
ullStart: u64,
ulLength: u32,
ullAlignment: u64,
ullEnd: u64,
rlh: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_First_Range(
rlh: usize,
pullStart: ?*u64,
pullEnd: ?*u64,
preElement: ?*usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Free_Log_Conf(
lcLogConfToBeFreed: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Free_Log_Conf_Ex(
lcLogConfToBeFreed: usize,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Free_Log_Conf_Handle(
lcLogConf: usize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Free_Range_List(
rlh: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Free_Res_Des(
prdResDes: ?*usize,
rdResDes: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Free_Res_Des_Ex(
prdResDes: ?*usize,
rdResDes: usize,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Free_Res_Des_Handle(
rdResDes: usize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Child(
pdnDevInst: ?*u32,
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Child_Ex(
pdnDevInst: ?*u32,
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_NameA(
ClassGuid: ?*Guid,
Buffer: ?[*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_NameW(
ClassGuid: ?*Guid,
Buffer: ?[*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_Name_ExA(
ClassGuid: ?*Guid,
Buffer: ?[*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_Name_ExW(
ClassGuid: ?*Guid,
Buffer: ?[*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_Key_NameA(
ClassGuid: ?*Guid,
pszKeyName: ?[*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_Key_NameW(
ClassGuid: ?*Guid,
pszKeyName: ?[*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_Key_Name_ExA(
ClassGuid: ?*Guid,
pszKeyName: ?[*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_Key_Name_ExW(
ClassGuid: ?*Guid,
pszKeyName: ?[*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Depth(
pulDepth: ?*u32,
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Depth_Ex(
pulDepth: ?*u32,
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_IDA(
dnDevInst: u32,
Buffer: [*:0]u8,
BufferLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_IDW(
dnDevInst: u32,
Buffer: [*:0]u16,
BufferLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_ID_ExA(
dnDevInst: u32,
Buffer: [*:0]u8,
BufferLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_ExW(
dnDevInst: u32,
Buffer: [*:0]u16,
BufferLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_ListA(
pszFilter: ?[*:0]const u8,
Buffer: [*]u8,
BufferLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_ListW(
pszFilter: ?[*:0]const u16,
Buffer: [*]u16,
BufferLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_ID_List_ExA(
pszFilter: ?[*:0]const u8,
Buffer: [*]u8,
BufferLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_List_ExW(
pszFilter: ?[*:0]const u16,
Buffer: [*]u16,
BufferLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_List_SizeA(
pulLen: ?*u32,
pszFilter: ?[*:0]const u8,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_List_SizeW(
pulLen: ?*u32,
pszFilter: ?[*:0]const u16,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_ID_List_Size_ExA(
pulLen: ?*u32,
pszFilter: ?[*:0]const u8,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_List_Size_ExW(
pulLen: ?*u32,
pszFilter: ?[*:0]const u16,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_Size(
pulLen: ?*u32,
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_ID_Size_Ex(
pulLen: ?*u32,
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Get_DevNode_PropertyW(
dnDevInst: u32,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Get_DevNode_Property_ExW(
dnDevInst: u32,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Get_DevNode_Property_Keys(
dnDevInst: u32,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Get_DevNode_Property_Keys_Ex(
dnDevInst: u32,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_DevNode_Registry_PropertyA(
dnDevInst: u32,
ulProperty: u32,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_DevNode_Registry_PropertyW(
dnDevInst: u32,
ulProperty: u32,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_DevNode_Registry_Property_ExA(
dnDevInst: u32,
ulProperty: u32,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_DevNode_Registry_Property_ExW(
dnDevInst: u32,
ulProperty: u32,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_DevNode_Custom_PropertyA(
dnDevInst: u32,
pszCustomPropertyName: ?[*:0]const u8,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_DevNode_Custom_PropertyW(
dnDevInst: u32,
pszCustomPropertyName: ?[*:0]const u16,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_DevNode_Custom_Property_ExA(
dnDevInst: u32,
pszCustomPropertyName: ?[*:0]const u8,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_DevNode_Custom_Property_ExW(
dnDevInst: u32,
pszCustomPropertyName: ?[*:0]const u16,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_DevNode_Status(
pulStatus: ?*u32,
pulProblemNumber: ?*u32,
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_DevNode_Status_Ex(
pulStatus: ?*u32,
pulProblemNumber: ?*u32,
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_First_Log_Conf(
plcLogConf: ?*usize,
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_First_Log_Conf_Ex(
plcLogConf: ?*usize,
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Global_State(
pulState: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Global_State_Ex(
pulState: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Hardware_Profile_InfoA(
ulIndex: u32,
pHWProfileInfo: ?*HWProfileInfo_sA,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Hardware_Profile_Info_ExA(
ulIndex: u32,
pHWProfileInfo: ?*HWProfileInfo_sA,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Hardware_Profile_InfoW(
ulIndex: u32,
pHWProfileInfo: ?*HWProfileInfo_sW,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Hardware_Profile_Info_ExW(
ulIndex: u32,
pHWProfileInfo: ?*HWProfileInfo_sW,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_HW_Prof_FlagsA(
pDeviceID: ?*i8,
ulHardwareProfile: u32,
pulValue: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_HW_Prof_FlagsW(
pDeviceID: ?*u16,
ulHardwareProfile: u32,
pulValue: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_HW_Prof_Flags_ExA(
pDeviceID: ?*i8,
ulHardwareProfile: u32,
pulValue: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_HW_Prof_Flags_ExW(
pDeviceID: ?*u16,
ulHardwareProfile: u32,
pulValue: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_Interface_AliasA(
pszDeviceInterface: ?[*:0]const u8,
AliasInterfaceGuid: ?*Guid,
pszAliasDeviceInterface: [*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_AliasW(
pszDeviceInterface: ?[*:0]const u16,
AliasInterfaceGuid: ?*Guid,
pszAliasDeviceInterface: [*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_Interface_Alias_ExA(
pszDeviceInterface: ?[*:0]const u8,
AliasInterfaceGuid: ?*Guid,
pszAliasDeviceInterface: [*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_Interface_Alias_ExW(
pszDeviceInterface: ?[*:0]const u16,
AliasInterfaceGuid: ?*Guid,
pszAliasDeviceInterface: [*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_ListA(
InterfaceClassGuid: ?*Guid,
pDeviceID: ?*i8,
Buffer: [*]u8,
BufferLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_ListW(
InterfaceClassGuid: ?*Guid,
pDeviceID: ?*u16,
Buffer: [*]u16,
BufferLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_Interface_List_ExA(
InterfaceClassGuid: ?*Guid,
pDeviceID: ?*i8,
Buffer: [*]u8,
BufferLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_Interface_List_ExW(
InterfaceClassGuid: ?*Guid,
pDeviceID: ?*u16,
Buffer: [*]u16,
BufferLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_List_SizeA(
pulLen: ?*u32,
InterfaceClassGuid: ?*Guid,
pDeviceID: ?*i8,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_List_SizeW(
pulLen: ?*u32,
InterfaceClassGuid: ?*Guid,
pDeviceID: ?*u16,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_Interface_List_Size_ExA(
pulLen: ?*u32,
InterfaceClassGuid: ?*Guid,
pDeviceID: ?*i8,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Device_Interface_List_Size_ExW(
pulLen: ?*u32,
InterfaceClassGuid: ?*Guid,
pDeviceID: ?*u16,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_PropertyW(
pszDeviceInterface: ?[*:0]const u16,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_Property_ExW(
pszDeviceInterface: ?[*:0]const u16,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_Property_KeysW(
pszDeviceInterface: ?[*:0]const u16,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Get_Device_Interface_Property_Keys_ExW(
pszDeviceInterface: ?[*:0]const u16,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Log_Conf_Priority(
lcLogConf: usize,
pPriority: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Log_Conf_Priority_Ex(
lcLogConf: usize,
pPriority: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Next_Log_Conf(
plcLogConf: ?*usize,
lcLogConf: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Next_Log_Conf_Ex(
plcLogConf: ?*usize,
lcLogConf: usize,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Parent(
pdnDevInst: ?*u32,
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Parent_Ex(
pdnDevInst: ?*u32,
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Res_Des_Data(
rdResDes: usize,
// TODO: what to do with BytesParamIndex 2?
Buffer: ?*anyopaque,
BufferLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Res_Des_Data_Ex(
rdResDes: usize,
// TODO: what to do with BytesParamIndex 2?
Buffer: ?*anyopaque,
BufferLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Res_Des_Data_Size(
pulSize: ?*u32,
rdResDes: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Res_Des_Data_Size_Ex(
pulSize: ?*u32,
rdResDes: usize,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Sibling(
pdnDevInst: ?*u32,
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Sibling_Ex(
pdnDevInst: ?*u32,
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Version(
) callconv(@import("std").os.windows.WINAPI) u16;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Version_Ex(
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) u16;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CFGMGR32" fn CM_Is_Version_Available(
wVersion: u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CFGMGR32" fn CM_Is_Version_Available_Ex(
wVersion: u16,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "CFGMGR32" fn CM_Intersect_Range_List(
rlhOld1: usize,
rlhOld2: usize,
rlhNew: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Invert_Range_List(
rlhOld: usize,
rlhNew: usize,
ullMaxValue: u64,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Locate_DevNodeA(
pdnDevInst: ?*u32,
pDeviceID: ?*i8,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Locate_DevNodeW(
pdnDevInst: ?*u32,
pDeviceID: ?*u16,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Locate_DevNode_ExA(
pdnDevInst: ?*u32,
pDeviceID: ?*i8,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Locate_DevNode_ExW(
pdnDevInst: ?*u32,
pDeviceID: ?*u16,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Merge_Range_List(
rlhOld1: usize,
rlhOld2: usize,
rlhNew: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Modify_Res_Des(
prdResDes: ?*usize,
rdResDes: usize,
ResourceID: u32,
// TODO: what to do with BytesParamIndex 4?
ResourceData: ?*anyopaque,
ResourceLen: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Modify_Res_Des_Ex(
prdResDes: ?*usize,
rdResDes: usize,
ResourceID: u32,
// TODO: what to do with BytesParamIndex 4?
ResourceData: ?*anyopaque,
ResourceLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Move_DevNode(
dnFromDevInst: u32,
dnToDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Move_DevNode_Ex(
dnFromDevInst: u32,
dnToDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Next_Range(
preElement: ?*usize,
pullStart: ?*u64,
pullEnd: ?*u64,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Next_Res_Des(
prdResDes: ?*usize,
rdResDes: usize,
ForResource: u32,
pResourceID: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Next_Res_Des_Ex(
prdResDes: ?*usize,
rdResDes: usize,
ForResource: u32,
pResourceID: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Open_Class_KeyA(
ClassGuid: ?*Guid,
pszClassName: ?[*:0]const u8,
samDesired: u32,
Disposition: u32,
phkClass: ?*?HKEY,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Open_Class_KeyW(
ClassGuid: ?*Guid,
pszClassName: ?[*:0]const u16,
samDesired: u32,
Disposition: u32,
phkClass: ?*?HKEY,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Open_Class_Key_ExA(
ClassGuid: ?*Guid,
pszClassName: ?[*:0]const u8,
samDesired: u32,
Disposition: u32,
phkClass: ?*?HKEY,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Open_Class_Key_ExW(
ClassGuid: ?*Guid,
pszClassName: ?[*:0]const u16,
samDesired: u32,
Disposition: u32,
phkClass: ?*?HKEY,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Open_DevNode_Key(
dnDevNode: u32,
samDesired: u32,
ulHardwareProfile: u32,
Disposition: u32,
phkDevice: ?*?HKEY,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Open_DevNode_Key_Ex(
dnDevNode: u32,
samDesired: u32,
ulHardwareProfile: u32,
Disposition: u32,
phkDevice: ?*?HKEY,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Open_Device_Interface_KeyA(
pszDeviceInterface: ?[*:0]const u8,
samDesired: u32,
Disposition: u32,
phkDeviceInterface: ?*?HKEY,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Open_Device_Interface_KeyW(
pszDeviceInterface: ?[*:0]const u16,
samDesired: u32,
Disposition: u32,
phkDeviceInterface: ?*?HKEY,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Open_Device_Interface_Key_ExA(
pszDeviceInterface: ?[*:0]const u8,
samDesired: u32,
Disposition: u32,
phkDeviceInterface: ?*?HKEY,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Open_Device_Interface_Key_ExW(
pszDeviceInterface: ?[*:0]const u16,
samDesired: u32,
Disposition: u32,
phkDeviceInterface: ?*?HKEY,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Delete_Device_Interface_KeyA(
pszDeviceInterface: ?[*:0]const u8,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Delete_Device_Interface_KeyW(
pszDeviceInterface: ?[*:0]const u16,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Delete_Device_Interface_Key_ExA(
pszDeviceInterface: ?[*:0]const u8,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Delete_Device_Interface_Key_ExW(
pszDeviceInterface: ?[*:0]const u16,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Query_Arbitrator_Free_Data(
// TODO: what to do with BytesParamIndex 1?
pData: ?*anyopaque,
DataLen: u32,
dnDevInst: u32,
ResourceID: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Query_Arbitrator_Free_Data_Ex(
// TODO: what to do with BytesParamIndex 1?
pData: ?*anyopaque,
DataLen: u32,
dnDevInst: u32,
ResourceID: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Query_Arbitrator_Free_Size(
pulSize: ?*u32,
dnDevInst: u32,
ResourceID: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Query_Arbitrator_Free_Size_Ex(
pulSize: ?*u32,
dnDevInst: u32,
ResourceID: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Query_Remove_SubTree(
dnAncestor: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Query_Remove_SubTree_Ex(
dnAncestor: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Query_And_Remove_SubTreeA(
dnAncestor: u32,
pVetoType: ?*PNP_VETO_TYPE,
pszVetoName: ?[*:0]u8,
ulNameLength: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Query_And_Remove_SubTreeW(
dnAncestor: u32,
pVetoType: ?*PNP_VETO_TYPE,
pszVetoName: ?[*:0]u16,
ulNameLength: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Query_And_Remove_SubTree_ExA(
dnAncestor: u32,
pVetoType: ?*PNP_VETO_TYPE,
pszVetoName: ?[*:0]u8,
ulNameLength: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Query_And_Remove_SubTree_ExW(
dnAncestor: u32,
pVetoType: ?*PNP_VETO_TYPE,
pszVetoName: ?[*:0]u16,
ulNameLength: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Request_Device_EjectA(
dnDevInst: u32,
pVetoType: ?*PNP_VETO_TYPE,
pszVetoName: ?[*:0]u8,
ulNameLength: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Request_Device_Eject_ExA(
dnDevInst: u32,
pVetoType: ?*PNP_VETO_TYPE,
pszVetoName: ?[*:0]u8,
ulNameLength: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Request_Device_EjectW(
dnDevInst: u32,
pVetoType: ?*PNP_VETO_TYPE,
pszVetoName: ?[*:0]u16,
ulNameLength: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Request_Device_Eject_ExW(
dnDevInst: u32,
pVetoType: ?*PNP_VETO_TYPE,
pszVetoName: ?[*:0]u16,
ulNameLength: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Reenumerate_DevNode(
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Reenumerate_DevNode_Ex(
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Register_Device_InterfaceA(
dnDevInst: u32,
InterfaceClassGuid: ?*Guid,
pszReference: ?[*:0]const u8,
pszDeviceInterface: [*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Register_Device_InterfaceW(
dnDevInst: u32,
InterfaceClassGuid: ?*Guid,
pszReference: ?[*:0]const u16,
pszDeviceInterface: [*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Register_Device_Interface_ExA(
dnDevInst: u32,
InterfaceClassGuid: ?*Guid,
pszReference: ?[*:0]const u8,
pszDeviceInterface: [*:0]u8,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Register_Device_Interface_ExW(
dnDevInst: u32,
InterfaceClassGuid: ?*Guid,
pszReference: ?[*:0]const u16,
pszDeviceInterface: [*:0]u16,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Set_DevNode_Problem_Ex(
dnDevInst: u32,
ulProblem: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Set_DevNode_Problem(
dnDevInst: u32,
ulProblem: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Unregister_Device_InterfaceA(
pszDeviceInterface: ?[*:0]const u8,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Unregister_Device_InterfaceW(
pszDeviceInterface: ?[*:0]const u16,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Unregister_Device_Interface_ExA(
pszDeviceInterface: ?[*:0]const u8,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Unregister_Device_Interface_ExW(
pszDeviceInterface: ?[*:0]const u16,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Register_Device_Driver(
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Register_Device_Driver_Ex(
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Remove_SubTree(
dnAncestor: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Remove_SubTree_Ex(
dnAncestor: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Set_DevNode_PropertyW(
dnDevInst: u32,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Set_DevNode_Property_ExW(
dnDevInst: u32,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_DevNode_Registry_PropertyA(
dnDevInst: u32,
ulProperty: u32,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*anyopaque,
ulLength: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'Windows 2000'
pub extern "CFGMGR32" fn CM_Set_DevNode_Registry_PropertyW(
dnDevInst: u32,
ulProperty: u32,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*anyopaque,
ulLength: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_DevNode_Registry_Property_ExA(
dnDevInst: u32,
ulProperty: u32,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*anyopaque,
ulLength: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_DevNode_Registry_Property_ExW(
dnDevInst: u32,
ulProperty: u32,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*anyopaque,
ulLength: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Set_Device_Interface_PropertyW(
pszDeviceInterface: ?[*:0]const u16,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Set_Device_Interface_Property_ExW(
pszDeviceInterface: ?[*:0]const u16,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Is_Dock_Station_Present(
pbPresent: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Is_Dock_Station_Present_Ex(
pbPresent: ?*BOOL,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Request_Eject_PC(
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Request_Eject_PC_Ex(
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_HW_Prof_FlagsA(
pDeviceID: ?*i8,
ulConfig: u32,
ulValue: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_HW_Prof_FlagsW(
pDeviceID: ?*u16,
ulConfig: u32,
ulValue: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_HW_Prof_Flags_ExA(
pDeviceID: ?*i8,
ulConfig: u32,
ulValue: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_HW_Prof_Flags_ExW(
pDeviceID: ?*u16,
ulConfig: u32,
ulValue: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Setup_DevNode(
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Setup_DevNode_Ex(
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Test_Range_Available(
ullStartValue: u64,
ullEndValue: u64,
rlh: usize,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Uninstall_DevNode(
dnDevInst: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Uninstall_DevNode_Ex(
dnDevInst: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Run_Detection(
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Run_Detection_Ex(
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_HW_Prof(
ulHardwareProfile: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_HW_Prof_Ex(
ulHardwareProfile: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Query_Resource_Conflict_List(
pclConflictList: ?*usize,
dnDevInst: u32,
ResourceID: u32,
// TODO: what to do with BytesParamIndex 4?
ResourceData: ?*anyopaque,
ResourceLen: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Free_Resource_Conflict_Handle(
clConflictList: usize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Resource_Conflict_Count(
clConflictList: usize,
pulCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Resource_Conflict_DetailsA(
clConflictList: usize,
ulIndex: u32,
pConflictDetails: ?*CONFLICT_DETAILS_A,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Resource_Conflict_DetailsW(
clConflictList: usize,
ulIndex: u32,
pConflictDetails: ?*CONFLICT_DETAILS_W,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Get_Class_PropertyW(
ClassGUID: ?*const Guid,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Get_Class_Property_ExW(
ClassGUID: ?*const Guid,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*u8,
PropertyBufferSize: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Get_Class_Property_Keys(
ClassGUID: ?*const Guid,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: ?*u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Get_Class_Property_Keys_Ex(
ClassGUID: ?*const Guid,
PropertyKeyArray: ?[*]DEVPROPKEY,
PropertyKeyCount: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CFGMGR32" fn CM_Set_Class_PropertyW(
ClassGUID: ?*const Guid,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CFGMGR32" fn CM_Set_Class_Property_ExW(
ClassGUID: ?*const Guid,
PropertyKey: ?*const DEVPROPKEY,
PropertyType: u32,
// TODO: what to do with BytesParamIndex 4?
PropertyBuffer: ?*const u8,
PropertyBufferSize: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Get_Class_Registry_PropertyA(
ClassGuid: ?*Guid,
ulProperty: u32,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Get_Class_Registry_PropertyW(
ClassGuid: ?*Guid,
ulProperty: u32,
pulRegDataType: ?*u32,
// TODO: what to do with BytesParamIndex 4?
Buffer: ?*anyopaque,
pulLength: ?*u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CM_Set_Class_Registry_PropertyA(
ClassGuid: ?*Guid,
ulProperty: u32,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*anyopaque,
ulLength: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows5.0'
pub extern "CFGMGR32" fn CM_Set_Class_Registry_PropertyW(
ClassGuid: ?*Guid,
ulProperty: u32,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*anyopaque,
ulLength: u32,
ulFlags: u32,
hMachine: isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
pub extern "CFGMGR32" fn CMP_WaitNoPendingInstallEvents(
dwTimeout: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "CFGMGR32" fn CM_Register_Notification(
pFilter: ?*CM_NOTIFY_FILTER,
pContext: ?*anyopaque,
pCallback: ?PCM_NOTIFY_CALLBACK,
pNotifyContext: ?*isize,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows8.0'
pub extern "CFGMGR32" fn CM_Unregister_Notification(
NotifyContext: ?HCMNOTIFICATION,
) callconv(@import("std").os.windows.WINAPI) CONFIGRET;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CFGMGR32" fn CM_MapCrToWin32Err(
CmReturnCode: CONFIGRET,
DefaultErr: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "newdev" fn UpdateDriverForPlugAndPlayDevicesA(
hwndParent: ?HWND,
HardwareId: ?[*:0]const u8,
FullInfPath: ?[*:0]const u8,
InstallFlags: u32,
bRebootRequired: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "newdev" fn UpdateDriverForPlugAndPlayDevicesW(
hwndParent: ?HWND,
HardwareId: ?[*:0]const u16,
FullInfPath: ?[*:0]const u16,
InstallFlags: u32,
bRebootRequired: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "newdev" fn DiInstallDevice(
hwndParent: ?HWND,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
DriverInfoData: ?*SP_DRVINFO_DATA_V2_A,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "newdev" fn DiInstallDriverW(
hwndParent: ?HWND,
InfPath: ?[*:0]const u16,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "newdev" fn DiInstallDriverA(
hwndParent: ?HWND,
InfPath: ?[*:0]const u8,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.1'
pub extern "newdev" fn DiUninstallDevice(
hwndParent: ?HWND,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "newdev" fn DiUninstallDriverW(
hwndParent: ?HWND,
InfPath: ?[*:0]const u16,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "newdev" fn DiUninstallDriverA(
hwndParent: ?HWND,
InfPath: ?[*:0]const u8,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "newdev" fn DiShowUpdateDevice(
hwndParent: ?HWND,
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "newdev" fn DiRollbackDriver(
DeviceInfoSet: ?*anyopaque,
DeviceInfoData: ?*SP_DEVINFO_DATA,
hwndParent: ?HWND,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "newdev" fn DiShowUpdateDriver(
hwndParent: ?HWND,
FilePath: ?[*:0]const u16,
Flags: u32,
NeedReboot: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (206)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
pub const SP_ORIGINAL_FILE_INFO_ = thismodule.SP_ORIGINAL_FILE_INFO_A;
pub const PSP_FILE_CALLBACK_ = thismodule.PSP_FILE_CALLBACK_A;
pub const FILEPATHS_ = thismodule.FILEPATHS_A;
pub const FILEPATHS_SIGNERINFO_ = thismodule.FILEPATHS_SIGNERINFO_A;
pub const SOURCE_MEDIA_ = thismodule.SOURCE_MEDIA_A;
pub const CABINET_INFO_ = thismodule.CABINET_INFO_A;
pub const FILE_IN_CABINET_INFO_ = thismodule.FILE_IN_CABINET_INFO_A;
pub const SP_REGISTER_CONTROL_STATUS = thismodule.SP_REGISTER_CONTROL_STATUSA;
pub const SP_FILE_COPY_PARAMS_ = thismodule.SP_FILE_COPY_PARAMS_A;
pub const SP_DEVICE_INTERFACE_DETAIL_DATA_ = thismodule.SP_DEVICE_INTERFACE_DETAIL_DATA_A;
pub const SP_DEVINFO_LIST_DETAIL_DATA_ = thismodule.SP_DEVINFO_LIST_DETAIL_DATA_A;
pub const SP_DEVINSTALL_PARAMS_ = thismodule.SP_DEVINSTALL_PARAMS_A;
pub const SP_SELECTDEVICE_PARAMS_ = thismodule.SP_SELECTDEVICE_PARAMS_A;
pub const SP_TROUBLESHOOTER_PARAMS_ = thismodule.SP_TROUBLESHOOTER_PARAMS_A;
pub const SP_POWERMESSAGEWAKE_PARAMS_ = thismodule.SP_POWERMESSAGEWAKE_PARAMS_A;
pub const SP_DRVINFO_DATA_V2_ = thismodule.SP_DRVINFO_DATA_V2_A;
pub const SP_DRVINFO_DATA_V1_ = thismodule.SP_DRVINFO_DATA_V1_A;
pub const SP_DRVINFO_DETAIL_DATA_ = thismodule.SP_DRVINFO_DETAIL_DATA_A;
pub const SP_BACKUP_QUEUE_PARAMS_V2_ = thismodule.SP_BACKUP_QUEUE_PARAMS_V2_A;
pub const SP_BACKUP_QUEUE_PARAMS_V1_ = thismodule.SP_BACKUP_QUEUE_PARAMS_V1_A;
pub const SP_INF_SIGNER_INFO_V1_ = thismodule.SP_INF_SIGNER_INFO_V1_A;
pub const SP_INF_SIGNER_INFO_V2_ = thismodule.SP_INF_SIGNER_INFO_V2_A;
pub const CONFLICT_DETAILS_ = thismodule.CONFLICT_DETAILS_A;
pub const HWProfileInfo_s = thismodule.HWProfileInfo_sA;
pub const SetupGetInfInformation = thismodule.SetupGetInfInformationA;
pub const SetupQueryInfFileInformation = thismodule.SetupQueryInfFileInformationA;
pub const SetupQueryInfOriginalFileInformation = thismodule.SetupQueryInfOriginalFileInformationA;
pub const SetupQueryInfVersionInformation = thismodule.SetupQueryInfVersionInformationA;
pub const SetupGetInfDriverStoreLocation = thismodule.SetupGetInfDriverStoreLocationA;
pub const SetupGetInfPublishedName = thismodule.SetupGetInfPublishedNameA;
pub const SetupGetInfFileList = thismodule.SetupGetInfFileListA;
pub const SetupOpenInfFile = thismodule.SetupOpenInfFileA;
pub const SetupOpenAppendInfFile = thismodule.SetupOpenAppendInfFileA;
pub const SetupFindFirstLine = thismodule.SetupFindFirstLineA;
pub const SetupFindNextMatchLine = thismodule.SetupFindNextMatchLineA;
pub const SetupGetLineByIndex = thismodule.SetupGetLineByIndexA;
pub const SetupGetLineCount = thismodule.SetupGetLineCountA;
pub const SetupGetLineText = thismodule.SetupGetLineTextA;
pub const SetupGetStringField = thismodule.SetupGetStringFieldA;
pub const SetupGetMultiSzField = thismodule.SetupGetMultiSzFieldA;
pub const SetupGetFileCompressionInfo = thismodule.SetupGetFileCompressionInfoA;
pub const SetupGetFileCompressionInfoEx = thismodule.SetupGetFileCompressionInfoExA;
pub const SetupDecompressOrCopyFile = thismodule.SetupDecompressOrCopyFileA;
pub const SetupGetSourceFileLocation = thismodule.SetupGetSourceFileLocationA;
pub const SetupGetSourceFileSize = thismodule.SetupGetSourceFileSizeA;
pub const SetupGetTargetPath = thismodule.SetupGetTargetPathA;
pub const SetupSetSourceList = thismodule.SetupSetSourceListA;
pub const SetupAddToSourceList = thismodule.SetupAddToSourceListA;
pub const SetupRemoveFromSourceList = thismodule.SetupRemoveFromSourceListA;
pub const SetupQuerySourceList = thismodule.SetupQuerySourceListA;
pub const SetupFreeSourceList = thismodule.SetupFreeSourceListA;
pub const SetupPromptForDisk = thismodule.SetupPromptForDiskA;
pub const SetupCopyError = thismodule.SetupCopyErrorA;
pub const SetupRenameError = thismodule.SetupRenameErrorA;
pub const SetupDeleteError = thismodule.SetupDeleteErrorA;
pub const SetupBackupError = thismodule.SetupBackupErrorA;
pub const SetupSetDirectoryId = thismodule.SetupSetDirectoryIdA;
pub const SetupSetDirectoryIdEx = thismodule.SetupSetDirectoryIdExA;
pub const SetupGetSourceInfo = thismodule.SetupGetSourceInfoA;
pub const SetupInstallFile = thismodule.SetupInstallFileA;
pub const SetupInstallFileEx = thismodule.SetupInstallFileExA;
pub const SetupSetFileQueueAlternatePlatform = thismodule.SetupSetFileQueueAlternatePlatformA;
pub const SetupSetPlatformPathOverride = thismodule.SetupSetPlatformPathOverrideA;
pub const SetupQueueCopy = thismodule.SetupQueueCopyA;
pub const SetupQueueCopyIndirect = thismodule.SetupQueueCopyIndirectA;
pub const SetupQueueDefaultCopy = thismodule.SetupQueueDefaultCopyA;
pub const SetupQueueCopySection = thismodule.SetupQueueCopySectionA;
pub const SetupQueueDelete = thismodule.SetupQueueDeleteA;
pub const SetupQueueDeleteSection = thismodule.SetupQueueDeleteSectionA;
pub const SetupQueueRename = thismodule.SetupQueueRenameA;
pub const SetupQueueRenameSection = thismodule.SetupQueueRenameSectionA;
pub const SetupCommitFileQueue = thismodule.SetupCommitFileQueueA;
pub const SetupScanFileQueue = thismodule.SetupScanFileQueueA;
pub const SetupCopyOEMInf = thismodule.SetupCopyOEMInfA;
pub const SetupUninstallOEMInf = thismodule.SetupUninstallOEMInfA;
pub const SetupCreateDiskSpaceList = thismodule.SetupCreateDiskSpaceListA;
pub const SetupDuplicateDiskSpaceList = thismodule.SetupDuplicateDiskSpaceListA;
pub const SetupQueryDrivesInDiskSpaceList = thismodule.SetupQueryDrivesInDiskSpaceListA;
pub const SetupQuerySpaceRequiredOnDrive = thismodule.SetupQuerySpaceRequiredOnDriveA;
pub const SetupAdjustDiskSpaceList = thismodule.SetupAdjustDiskSpaceListA;
pub const SetupAddToDiskSpaceList = thismodule.SetupAddToDiskSpaceListA;
pub const SetupAddSectionToDiskSpaceList = thismodule.SetupAddSectionToDiskSpaceListA;
pub const SetupAddInstallSectionToDiskSpaceList = thismodule.SetupAddInstallSectionToDiskSpaceListA;
pub const SetupRemoveFromDiskSpaceList = thismodule.SetupRemoveFromDiskSpaceListA;
pub const SetupRemoveSectionFromDiskSpaceList = thismodule.SetupRemoveSectionFromDiskSpaceListA;
pub const SetupRemoveInstallSectionFromDiskSpaceList = thismodule.SetupRemoveInstallSectionFromDiskSpaceListA;
pub const SetupIterateCabinet = thismodule.SetupIterateCabinetA;
pub const SetupDefaultQueueCallback = thismodule.SetupDefaultQueueCallbackA;
pub const SetupInstallFromInfSection = thismodule.SetupInstallFromInfSectionA;
pub const SetupInstallFilesFromInfSection = thismodule.SetupInstallFilesFromInfSectionA;
pub const SetupInstallServicesFromInfSection = thismodule.SetupInstallServicesFromInfSectionA;
pub const SetupInstallServicesFromInfSectionEx = thismodule.SetupInstallServicesFromInfSectionExA;
pub const InstallHinfSection = thismodule.InstallHinfSectionA;
pub const SetupInitializeFileLog = thismodule.SetupInitializeFileLogA;
pub const SetupLogFile = thismodule.SetupLogFileA;
pub const SetupRemoveFileLogEntry = thismodule.SetupRemoveFileLogEntryA;
pub const SetupQueryFileLog = thismodule.SetupQueryFileLogA;
pub const SetupLogError = thismodule.SetupLogErrorA;
pub const SetupGetBackupInformation = thismodule.SetupGetBackupInformationA;
pub const SetupPrepareQueueForRestore = thismodule.SetupPrepareQueueForRestoreA;
pub const SetupDiCreateDeviceInfoListEx = thismodule.SetupDiCreateDeviceInfoListExA;
pub const SetupDiGetDeviceInfoListDetail = thismodule.SetupDiGetDeviceInfoListDetailA;
pub const SetupDiCreateDeviceInfo = thismodule.SetupDiCreateDeviceInfoA;
pub const SetupDiOpenDeviceInfo = thismodule.SetupDiOpenDeviceInfoA;
pub const SetupDiGetDeviceInstanceId = thismodule.SetupDiGetDeviceInstanceIdA;
pub const SetupDiCreateDeviceInterface = thismodule.SetupDiCreateDeviceInterfaceA;
pub const SetupDiOpenDeviceInterface = thismodule.SetupDiOpenDeviceInterfaceA;
pub const SetupDiGetDeviceInterfaceDetail = thismodule.SetupDiGetDeviceInterfaceDetailA;
pub const SetupDiEnumDriverInfo = thismodule.SetupDiEnumDriverInfoA;
pub const SetupDiGetSelectedDriver = thismodule.SetupDiGetSelectedDriverA;
pub const SetupDiSetSelectedDriver = thismodule.SetupDiSetSelectedDriverA;
pub const SetupDiGetDriverInfoDetail = thismodule.SetupDiGetDriverInfoDetailA;
pub const SetupDiGetClassDevs = thismodule.SetupDiGetClassDevsA;
pub const SetupDiGetClassDevsEx = thismodule.SetupDiGetClassDevsExA;
pub const SetupDiGetINFClass = thismodule.SetupDiGetINFClassA;
pub const SetupDiBuildClassInfoListEx = thismodule.SetupDiBuildClassInfoListExA;
pub const SetupDiGetClassDescription = thismodule.SetupDiGetClassDescriptionA;
pub const SetupDiGetClassDescriptionEx = thismodule.SetupDiGetClassDescriptionExA;
pub const SetupDiInstallClass = thismodule.SetupDiInstallClassA;
pub const SetupDiInstallClassEx = thismodule.SetupDiInstallClassExA;
pub const SetupDiOpenClassRegKeyEx = thismodule.SetupDiOpenClassRegKeyExA;
pub const SetupDiCreateDeviceInterfaceRegKey = thismodule.SetupDiCreateDeviceInterfaceRegKeyA;
pub const SetupDiCreateDevRegKey = thismodule.SetupDiCreateDevRegKeyA;
pub const SetupDiGetHwProfileListEx = thismodule.SetupDiGetHwProfileListExA;
pub const SetupDiGetDeviceRegistryProperty = thismodule.SetupDiGetDeviceRegistryPropertyA;
pub const SetupDiGetClassRegistryProperty = thismodule.SetupDiGetClassRegistryPropertyA;
pub const SetupDiSetDeviceRegistryProperty = thismodule.SetupDiSetDeviceRegistryPropertyA;
pub const SetupDiSetClassRegistryProperty = thismodule.SetupDiSetClassRegistryPropertyA;
pub const SetupDiGetDeviceInstallParams = thismodule.SetupDiGetDeviceInstallParamsA;
pub const SetupDiGetClassInstallParams = thismodule.SetupDiGetClassInstallParamsA;
pub const SetupDiSetDeviceInstallParams = thismodule.SetupDiSetDeviceInstallParamsA;
pub const SetupDiSetClassInstallParams = thismodule.SetupDiSetClassInstallParamsA;
pub const SetupDiGetDriverInstallParams = thismodule.SetupDiGetDriverInstallParamsA;
pub const SetupDiSetDriverInstallParams = thismodule.SetupDiSetDriverInstallParamsA;
pub const SetupDiGetClassImageListEx = thismodule.SetupDiGetClassImageListExA;
pub const SetupDiGetClassDevPropertySheets = thismodule.SetupDiGetClassDevPropertySheetsA;
pub const SetupDiClassNameFromGuid = thismodule.SetupDiClassNameFromGuidA;
pub const SetupDiClassNameFromGuidEx = thismodule.SetupDiClassNameFromGuidExA;
pub const SetupDiClassGuidsFromName = thismodule.SetupDiClassGuidsFromNameA;
pub const SetupDiClassGuidsFromNameEx = thismodule.SetupDiClassGuidsFromNameExA;
pub const SetupDiGetHwProfileFriendlyName = thismodule.SetupDiGetHwProfileFriendlyNameA;
pub const SetupDiGetHwProfileFriendlyNameEx = thismodule.SetupDiGetHwProfileFriendlyNameExA;
pub const SetupDiGetActualModelsSection = thismodule.SetupDiGetActualModelsSectionA;
pub const SetupDiGetActualSectionToInstall = thismodule.SetupDiGetActualSectionToInstallA;
pub const SetupDiGetActualSectionToInstallEx = thismodule.SetupDiGetActualSectionToInstallExA;
pub const SetupEnumInfSections = thismodule.SetupEnumInfSectionsA;
pub const SetupVerifyInfFile = thismodule.SetupVerifyInfFileA;
pub const SetupDiGetCustomDeviceProperty = thismodule.SetupDiGetCustomDevicePropertyA;
pub const SetupConfigureWmiFromInfSection = thismodule.SetupConfigureWmiFromInfSectionA;
pub const CM_Add_ID = thismodule.CM_Add_IDA;
pub const CM_Add_ID_Ex = thismodule.CM_Add_ID_ExA;
pub const CM_Connect_Machine = thismodule.CM_Connect_MachineA;
pub const CM_Create_DevNode = thismodule.CM_Create_DevNodeA;
pub const CM_Create_DevNode_Ex = thismodule.CM_Create_DevNode_ExA;
pub const CM_Enumerate_Enumerators = thismodule.CM_Enumerate_EnumeratorsA;
pub const CM_Enumerate_Enumerators_Ex = thismodule.CM_Enumerate_Enumerators_ExA;
pub const CM_Get_Class_Name = thismodule.CM_Get_Class_NameA;
pub const CM_Get_Class_Name_Ex = thismodule.CM_Get_Class_Name_ExA;
pub const CM_Get_Class_Key_Name = thismodule.CM_Get_Class_Key_NameA;
pub const CM_Get_Class_Key_Name_Ex = thismodule.CM_Get_Class_Key_Name_ExA;
pub const CM_Get_Device_ID = thismodule.CM_Get_Device_IDA;
pub const CM_Get_Device_ID_Ex = thismodule.CM_Get_Device_ID_ExA;
pub const CM_Get_Device_ID_List = thismodule.CM_Get_Device_ID_ListA;
pub const CM_Get_Device_ID_List_Ex = thismodule.CM_Get_Device_ID_List_ExA;
pub const CM_Get_Device_ID_List_Size = thismodule.CM_Get_Device_ID_List_SizeA;
pub const CM_Get_Device_ID_List_Size_Ex = thismodule.CM_Get_Device_ID_List_Size_ExA;
pub const CM_Get_DevNode_Registry_Property = thismodule.CM_Get_DevNode_Registry_PropertyA;
pub const CM_Get_DevNode_Registry_Property_Ex = thismodule.CM_Get_DevNode_Registry_Property_ExA;
pub const CM_Get_DevNode_Custom_Property = thismodule.CM_Get_DevNode_Custom_PropertyA;
pub const CM_Get_DevNode_Custom_Property_Ex = thismodule.CM_Get_DevNode_Custom_Property_ExA;
pub const CM_Get_Hardware_Profile_Info = thismodule.CM_Get_Hardware_Profile_InfoA;
pub const CM_Get_Hardware_Profile_Info_Ex = thismodule.CM_Get_Hardware_Profile_Info_ExA;
pub const CM_Get_HW_Prof_Flags = thismodule.CM_Get_HW_Prof_FlagsA;
pub const CM_Get_HW_Prof_Flags_Ex = thismodule.CM_Get_HW_Prof_Flags_ExA;
pub const CM_Get_Device_Interface_Alias = thismodule.CM_Get_Device_Interface_AliasA;
pub const CM_Get_Device_Interface_Alias_Ex = thismodule.CM_Get_Device_Interface_Alias_ExA;
pub const CM_Get_Device_Interface_List = thismodule.CM_Get_Device_Interface_ListA;
pub const CM_Get_Device_Interface_List_Ex = thismodule.CM_Get_Device_Interface_List_ExA;
pub const CM_Get_Device_Interface_List_Size = thismodule.CM_Get_Device_Interface_List_SizeA;
pub const CM_Get_Device_Interface_List_Size_Ex = thismodule.CM_Get_Device_Interface_List_Size_ExA;
pub const CM_Locate_DevNode = thismodule.CM_Locate_DevNodeA;
pub const CM_Locate_DevNode_Ex = thismodule.CM_Locate_DevNode_ExA;
pub const CM_Open_Class_Key = thismodule.CM_Open_Class_KeyA;
pub const CM_Open_Class_Key_Ex = thismodule.CM_Open_Class_Key_ExA;
pub const CM_Open_Device_Interface_Key = thismodule.CM_Open_Device_Interface_KeyA;
pub const CM_Open_Device_Interface_Key_Ex = thismodule.CM_Open_Device_Interface_Key_ExA;
pub const CM_Delete_Device_Interface_Key = thismodule.CM_Delete_Device_Interface_KeyA;
pub const CM_Delete_Device_Interface_Key_Ex = thismodule.CM_Delete_Device_Interface_Key_ExA;
pub const CM_Query_And_Remove_SubTree = thismodule.CM_Query_And_Remove_SubTreeA;
pub const CM_Query_And_Remove_SubTree_Ex = thismodule.CM_Query_And_Remove_SubTree_ExA;
pub const CM_Request_Device_Eject = thismodule.CM_Request_Device_EjectA;
pub const CM_Request_Device_Eject_Ex = thismodule.CM_Request_Device_Eject_ExA;
pub const CM_Register_Device_Interface = thismodule.CM_Register_Device_InterfaceA;
pub const CM_Register_Device_Interface_Ex = thismodule.CM_Register_Device_Interface_ExA;
pub const CM_Unregister_Device_Interface = thismodule.CM_Unregister_Device_InterfaceA;
pub const CM_Unregister_Device_Interface_Ex = thismodule.CM_Unregister_Device_Interface_ExA;
pub const CM_Set_DevNode_Registry_Property = thismodule.CM_Set_DevNode_Registry_PropertyA;
pub const CM_Set_DevNode_Registry_Property_Ex = thismodule.CM_Set_DevNode_Registry_Property_ExA;
pub const CM_Set_HW_Prof_Flags = thismodule.CM_Set_HW_Prof_FlagsA;
pub const CM_Set_HW_Prof_Flags_Ex = thismodule.CM_Set_HW_Prof_Flags_ExA;
pub const CM_Get_Resource_Conflict_Details = thismodule.CM_Get_Resource_Conflict_DetailsA;
pub const CM_Get_Class_Registry_Property = thismodule.CM_Get_Class_Registry_PropertyA;
pub const CM_Set_Class_Registry_Property = thismodule.CM_Set_Class_Registry_PropertyA;
pub const UpdateDriverForPlugAndPlayDevices = thismodule.UpdateDriverForPlugAndPlayDevicesA;
pub const DiInstallDriver = thismodule.DiInstallDriverA;
pub const DiUninstallDriver = thismodule.DiUninstallDriverA;
},
.wide => struct {
pub const SP_ORIGINAL_FILE_INFO_ = thismodule.SP_ORIGINAL_FILE_INFO_W;
pub const PSP_FILE_CALLBACK_ = thismodule.PSP_FILE_CALLBACK_W;
pub const FILEPATHS_ = thismodule.FILEPATHS_W;
pub const FILEPATHS_SIGNERINFO_ = thismodule.FILEPATHS_SIGNERINFO_W;
pub const SOURCE_MEDIA_ = thismodule.SOURCE_MEDIA_W;
pub const CABINET_INFO_ = thismodule.CABINET_INFO_W;
pub const FILE_IN_CABINET_INFO_ = thismodule.FILE_IN_CABINET_INFO_W;
pub const SP_REGISTER_CONTROL_STATUS = thismodule.SP_REGISTER_CONTROL_STATUSW;
pub const SP_FILE_COPY_PARAMS_ = thismodule.SP_FILE_COPY_PARAMS_W;
pub const SP_DEVICE_INTERFACE_DETAIL_DATA_ = thismodule.SP_DEVICE_INTERFACE_DETAIL_DATA_W;
pub const SP_DEVINFO_LIST_DETAIL_DATA_ = thismodule.SP_DEVINFO_LIST_DETAIL_DATA_W;
pub const SP_DEVINSTALL_PARAMS_ = thismodule.SP_DEVINSTALL_PARAMS_W;
pub const SP_SELECTDEVICE_PARAMS_ = thismodule.SP_SELECTDEVICE_PARAMS_W;
pub const SP_TROUBLESHOOTER_PARAMS_ = thismodule.SP_TROUBLESHOOTER_PARAMS_W;
pub const SP_POWERMESSAGEWAKE_PARAMS_ = thismodule.SP_POWERMESSAGEWAKE_PARAMS_W;
pub const SP_DRVINFO_DATA_V2_ = thismodule.SP_DRVINFO_DATA_V2_W;
pub const SP_DRVINFO_DATA_V1_ = thismodule.SP_DRVINFO_DATA_V1_W;
pub const SP_DRVINFO_DETAIL_DATA_ = thismodule.SP_DRVINFO_DETAIL_DATA_W;
pub const SP_BACKUP_QUEUE_PARAMS_V2_ = thismodule.SP_BACKUP_QUEUE_PARAMS_V2_W;
pub const SP_BACKUP_QUEUE_PARAMS_V1_ = thismodule.SP_BACKUP_QUEUE_PARAMS_V1_W;
pub const SP_INF_SIGNER_INFO_V1_ = thismodule.SP_INF_SIGNER_INFO_V1_W;
pub const SP_INF_SIGNER_INFO_V2_ = thismodule.SP_INF_SIGNER_INFO_V2_W;
pub const CONFLICT_DETAILS_ = thismodule.CONFLICT_DETAILS_W;
pub const HWProfileInfo_s = thismodule.HWProfileInfo_sW;
pub const SetupGetInfInformation = thismodule.SetupGetInfInformationW;
pub const SetupQueryInfFileInformation = thismodule.SetupQueryInfFileInformationW;
pub const SetupQueryInfOriginalFileInformation = thismodule.SetupQueryInfOriginalFileInformationW;
pub const SetupQueryInfVersionInformation = thismodule.SetupQueryInfVersionInformationW;
pub const SetupGetInfDriverStoreLocation = thismodule.SetupGetInfDriverStoreLocationW;
pub const SetupGetInfPublishedName = thismodule.SetupGetInfPublishedNameW;
pub const SetupGetInfFileList = thismodule.SetupGetInfFileListW;
pub const SetupOpenInfFile = thismodule.SetupOpenInfFileW;
pub const SetupOpenAppendInfFile = thismodule.SetupOpenAppendInfFileW;
pub const SetupFindFirstLine = thismodule.SetupFindFirstLineW;
pub const SetupFindNextMatchLine = thismodule.SetupFindNextMatchLineW;
pub const SetupGetLineByIndex = thismodule.SetupGetLineByIndexW;
pub const SetupGetLineCount = thismodule.SetupGetLineCountW;
pub const SetupGetLineText = thismodule.SetupGetLineTextW;
pub const SetupGetStringField = thismodule.SetupGetStringFieldW;
pub const SetupGetMultiSzField = thismodule.SetupGetMultiSzFieldW;
pub const SetupGetFileCompressionInfo = thismodule.SetupGetFileCompressionInfoW;
pub const SetupGetFileCompressionInfoEx = thismodule.SetupGetFileCompressionInfoExW;
pub const SetupDecompressOrCopyFile = thismodule.SetupDecompressOrCopyFileW;
pub const SetupGetSourceFileLocation = thismodule.SetupGetSourceFileLocationW;
pub const SetupGetSourceFileSize = thismodule.SetupGetSourceFileSizeW;
pub const SetupGetTargetPath = thismodule.SetupGetTargetPathW;
pub const SetupSetSourceList = thismodule.SetupSetSourceListW;
pub const SetupAddToSourceList = thismodule.SetupAddToSourceListW;
pub const SetupRemoveFromSourceList = thismodule.SetupRemoveFromSourceListW;
pub const SetupQuerySourceList = thismodule.SetupQuerySourceListW;
pub const SetupFreeSourceList = thismodule.SetupFreeSourceListW;
pub const SetupPromptForDisk = thismodule.SetupPromptForDiskW;
pub const SetupCopyError = thismodule.SetupCopyErrorW;
pub const SetupRenameError = thismodule.SetupRenameErrorW;
pub const SetupDeleteError = thismodule.SetupDeleteErrorW;
pub const SetupBackupError = thismodule.SetupBackupErrorW;
pub const SetupSetDirectoryId = thismodule.SetupSetDirectoryIdW;
pub const SetupSetDirectoryIdEx = thismodule.SetupSetDirectoryIdExW;
pub const SetupGetSourceInfo = thismodule.SetupGetSourceInfoW;
pub const SetupInstallFile = thismodule.SetupInstallFileW;
pub const SetupInstallFileEx = thismodule.SetupInstallFileExW;
pub const SetupSetFileQueueAlternatePlatform = thismodule.SetupSetFileQueueAlternatePlatformW;
pub const SetupSetPlatformPathOverride = thismodule.SetupSetPlatformPathOverrideW;
pub const SetupQueueCopy = thismodule.SetupQueueCopyW;
pub const SetupQueueCopyIndirect = thismodule.SetupQueueCopyIndirectW;
pub const SetupQueueDefaultCopy = thismodule.SetupQueueDefaultCopyW;
pub const SetupQueueCopySection = thismodule.SetupQueueCopySectionW;
pub const SetupQueueDelete = thismodule.SetupQueueDeleteW;
pub const SetupQueueDeleteSection = thismodule.SetupQueueDeleteSectionW;
pub const SetupQueueRename = thismodule.SetupQueueRenameW;
pub const SetupQueueRenameSection = thismodule.SetupQueueRenameSectionW;
pub const SetupCommitFileQueue = thismodule.SetupCommitFileQueueW;
pub const SetupScanFileQueue = thismodule.SetupScanFileQueueW;
pub const SetupCopyOEMInf = thismodule.SetupCopyOEMInfW;
pub const SetupUninstallOEMInf = thismodule.SetupUninstallOEMInfW;
pub const SetupCreateDiskSpaceList = thismodule.SetupCreateDiskSpaceListW;
pub const SetupDuplicateDiskSpaceList = thismodule.SetupDuplicateDiskSpaceListW;
pub const SetupQueryDrivesInDiskSpaceList = thismodule.SetupQueryDrivesInDiskSpaceListW;
pub const SetupQuerySpaceRequiredOnDrive = thismodule.SetupQuerySpaceRequiredOnDriveW;
pub const SetupAdjustDiskSpaceList = thismodule.SetupAdjustDiskSpaceListW;
pub const SetupAddToDiskSpaceList = thismodule.SetupAddToDiskSpaceListW;
pub const SetupAddSectionToDiskSpaceList = thismodule.SetupAddSectionToDiskSpaceListW;
pub const SetupAddInstallSectionToDiskSpaceList = thismodule.SetupAddInstallSectionToDiskSpaceListW;
pub const SetupRemoveFromDiskSpaceList = thismodule.SetupRemoveFromDiskSpaceListW;
pub const SetupRemoveSectionFromDiskSpaceList = thismodule.SetupRemoveSectionFromDiskSpaceListW;
pub const SetupRemoveInstallSectionFromDiskSpaceList = thismodule.SetupRemoveInstallSectionFromDiskSpaceListW;
pub const SetupIterateCabinet = thismodule.SetupIterateCabinetW;
pub const SetupDefaultQueueCallback = thismodule.SetupDefaultQueueCallbackW;
pub const SetupInstallFromInfSection = thismodule.SetupInstallFromInfSectionW;
pub const SetupInstallFilesFromInfSection = thismodule.SetupInstallFilesFromInfSectionW;
pub const SetupInstallServicesFromInfSection = thismodule.SetupInstallServicesFromInfSectionW;
pub const SetupInstallServicesFromInfSectionEx = thismodule.SetupInstallServicesFromInfSectionExW;
pub const InstallHinfSection = thismodule.InstallHinfSectionW;
pub const SetupInitializeFileLog = thismodule.SetupInitializeFileLogW;
pub const SetupLogFile = thismodule.SetupLogFileW;
pub const SetupRemoveFileLogEntry = thismodule.SetupRemoveFileLogEntryW;
pub const SetupQueryFileLog = thismodule.SetupQueryFileLogW;
pub const SetupLogError = thismodule.SetupLogErrorW;
pub const SetupGetBackupInformation = thismodule.SetupGetBackupInformationW;
pub const SetupPrepareQueueForRestore = thismodule.SetupPrepareQueueForRestoreW;
pub const SetupDiCreateDeviceInfoListEx = thismodule.SetupDiCreateDeviceInfoListExW;
pub const SetupDiGetDeviceInfoListDetail = thismodule.SetupDiGetDeviceInfoListDetailW;
pub const SetupDiCreateDeviceInfo = thismodule.SetupDiCreateDeviceInfoW;
pub const SetupDiOpenDeviceInfo = thismodule.SetupDiOpenDeviceInfoW;
pub const SetupDiGetDeviceInstanceId = thismodule.SetupDiGetDeviceInstanceIdW;
pub const SetupDiCreateDeviceInterface = thismodule.SetupDiCreateDeviceInterfaceW;
pub const SetupDiOpenDeviceInterface = thismodule.SetupDiOpenDeviceInterfaceW;
pub const SetupDiGetDeviceInterfaceDetail = thismodule.SetupDiGetDeviceInterfaceDetailW;
pub const SetupDiEnumDriverInfo = thismodule.SetupDiEnumDriverInfoW;
pub const SetupDiGetSelectedDriver = thismodule.SetupDiGetSelectedDriverW;
pub const SetupDiSetSelectedDriver = thismodule.SetupDiSetSelectedDriverW;
pub const SetupDiGetDriverInfoDetail = thismodule.SetupDiGetDriverInfoDetailW;
pub const SetupDiGetClassDevs = thismodule.SetupDiGetClassDevsW;
pub const SetupDiGetClassDevsEx = thismodule.SetupDiGetClassDevsExW;
pub const SetupDiGetINFClass = thismodule.SetupDiGetINFClassW;
pub const SetupDiBuildClassInfoListEx = thismodule.SetupDiBuildClassInfoListExW;
pub const SetupDiGetClassDescription = thismodule.SetupDiGetClassDescriptionW;
pub const SetupDiGetClassDescriptionEx = thismodule.SetupDiGetClassDescriptionExW;
pub const SetupDiInstallClass = thismodule.SetupDiInstallClassW;
pub const SetupDiInstallClassEx = thismodule.SetupDiInstallClassExW;
pub const SetupDiOpenClassRegKeyEx = thismodule.SetupDiOpenClassRegKeyExW;
pub const SetupDiCreateDeviceInterfaceRegKey = thismodule.SetupDiCreateDeviceInterfaceRegKeyW;
pub const SetupDiCreateDevRegKey = thismodule.SetupDiCreateDevRegKeyW;
pub const SetupDiGetHwProfileListEx = thismodule.SetupDiGetHwProfileListExW;
pub const SetupDiGetDeviceRegistryProperty = thismodule.SetupDiGetDeviceRegistryPropertyW;
pub const SetupDiGetClassRegistryProperty = thismodule.SetupDiGetClassRegistryPropertyW;
pub const SetupDiSetDeviceRegistryProperty = thismodule.SetupDiSetDeviceRegistryPropertyW;
pub const SetupDiSetClassRegistryProperty = thismodule.SetupDiSetClassRegistryPropertyW;
pub const SetupDiGetDeviceInstallParams = thismodule.SetupDiGetDeviceInstallParamsW;
pub const SetupDiGetClassInstallParams = thismodule.SetupDiGetClassInstallParamsW;
pub const SetupDiSetDeviceInstallParams = thismodule.SetupDiSetDeviceInstallParamsW;
pub const SetupDiSetClassInstallParams = thismodule.SetupDiSetClassInstallParamsW;
pub const SetupDiGetDriverInstallParams = thismodule.SetupDiGetDriverInstallParamsW;
pub const SetupDiSetDriverInstallParams = thismodule.SetupDiSetDriverInstallParamsW;
pub const SetupDiGetClassImageListEx = thismodule.SetupDiGetClassImageListExW;
pub const SetupDiGetClassDevPropertySheets = thismodule.SetupDiGetClassDevPropertySheetsW;
pub const SetupDiClassNameFromGuid = thismodule.SetupDiClassNameFromGuidW;
pub const SetupDiClassNameFromGuidEx = thismodule.SetupDiClassNameFromGuidExW;
pub const SetupDiClassGuidsFromName = thismodule.SetupDiClassGuidsFromNameW;
pub const SetupDiClassGuidsFromNameEx = thismodule.SetupDiClassGuidsFromNameExW;
pub const SetupDiGetHwProfileFriendlyName = thismodule.SetupDiGetHwProfileFriendlyNameW;
pub const SetupDiGetHwProfileFriendlyNameEx = thismodule.SetupDiGetHwProfileFriendlyNameExW;
pub const SetupDiGetActualModelsSection = thismodule.SetupDiGetActualModelsSectionW;
pub const SetupDiGetActualSectionToInstall = thismodule.SetupDiGetActualSectionToInstallW;
pub const SetupDiGetActualSectionToInstallEx = thismodule.SetupDiGetActualSectionToInstallExW;
pub const SetupEnumInfSections = thismodule.SetupEnumInfSectionsW;
pub const SetupVerifyInfFile = thismodule.SetupVerifyInfFileW;
pub const SetupDiGetCustomDeviceProperty = thismodule.SetupDiGetCustomDevicePropertyW;
pub const SetupConfigureWmiFromInfSection = thismodule.SetupConfigureWmiFromInfSectionW;
pub const CM_Add_ID = thismodule.CM_Add_IDW;
pub const CM_Add_ID_Ex = thismodule.CM_Add_ID_ExW;
pub const CM_Connect_Machine = thismodule.CM_Connect_MachineW;
pub const CM_Create_DevNode = thismodule.CM_Create_DevNodeW;
pub const CM_Create_DevNode_Ex = thismodule.CM_Create_DevNode_ExW;
pub const CM_Enumerate_Enumerators = thismodule.CM_Enumerate_EnumeratorsW;
pub const CM_Enumerate_Enumerators_Ex = thismodule.CM_Enumerate_Enumerators_ExW;
pub const CM_Get_Class_Name = thismodule.CM_Get_Class_NameW;
pub const CM_Get_Class_Name_Ex = thismodule.CM_Get_Class_Name_ExW;
pub const CM_Get_Class_Key_Name = thismodule.CM_Get_Class_Key_NameW;
pub const CM_Get_Class_Key_Name_Ex = thismodule.CM_Get_Class_Key_Name_ExW;
pub const CM_Get_Device_ID = thismodule.CM_Get_Device_IDW;
pub const CM_Get_Device_ID_Ex = thismodule.CM_Get_Device_ID_ExW;
pub const CM_Get_Device_ID_List = thismodule.CM_Get_Device_ID_ListW;
pub const CM_Get_Device_ID_List_Ex = thismodule.CM_Get_Device_ID_List_ExW;
pub const CM_Get_Device_ID_List_Size = thismodule.CM_Get_Device_ID_List_SizeW;
pub const CM_Get_Device_ID_List_Size_Ex = thismodule.CM_Get_Device_ID_List_Size_ExW;
pub const CM_Get_DevNode_Registry_Property = thismodule.CM_Get_DevNode_Registry_PropertyW;
pub const CM_Get_DevNode_Registry_Property_Ex = thismodule.CM_Get_DevNode_Registry_Property_ExW;
pub const CM_Get_DevNode_Custom_Property = thismodule.CM_Get_DevNode_Custom_PropertyW;
pub const CM_Get_DevNode_Custom_Property_Ex = thismodule.CM_Get_DevNode_Custom_Property_ExW;
pub const CM_Get_Hardware_Profile_Info = thismodule.CM_Get_Hardware_Profile_InfoW;
pub const CM_Get_Hardware_Profile_Info_Ex = thismodule.CM_Get_Hardware_Profile_Info_ExW;
pub const CM_Get_HW_Prof_Flags = thismodule.CM_Get_HW_Prof_FlagsW;
pub const CM_Get_HW_Prof_Flags_Ex = thismodule.CM_Get_HW_Prof_Flags_ExW;
pub const CM_Get_Device_Interface_Alias = thismodule.CM_Get_Device_Interface_AliasW;
pub const CM_Get_Device_Interface_Alias_Ex = thismodule.CM_Get_Device_Interface_Alias_ExW;
pub const CM_Get_Device_Interface_List = thismodule.CM_Get_Device_Interface_ListW;
pub const CM_Get_Device_Interface_List_Ex = thismodule.CM_Get_Device_Interface_List_ExW;
pub const CM_Get_Device_Interface_List_Size = thismodule.CM_Get_Device_Interface_List_SizeW;
pub const CM_Get_Device_Interface_List_Size_Ex = thismodule.CM_Get_Device_Interface_List_Size_ExW;
pub const CM_Locate_DevNode = thismodule.CM_Locate_DevNodeW;
pub const CM_Locate_DevNode_Ex = thismodule.CM_Locate_DevNode_ExW;
pub const CM_Open_Class_Key = thismodule.CM_Open_Class_KeyW;
pub const CM_Open_Class_Key_Ex = thismodule.CM_Open_Class_Key_ExW;
pub const CM_Open_Device_Interface_Key = thismodule.CM_Open_Device_Interface_KeyW;
pub const CM_Open_Device_Interface_Key_Ex = thismodule.CM_Open_Device_Interface_Key_ExW;
pub const CM_Delete_Device_Interface_Key = thismodule.CM_Delete_Device_Interface_KeyW;
pub const CM_Delete_Device_Interface_Key_Ex = thismodule.CM_Delete_Device_Interface_Key_ExW;
pub const CM_Query_And_Remove_SubTree = thismodule.CM_Query_And_Remove_SubTreeW;
pub const CM_Query_And_Remove_SubTree_Ex = thismodule.CM_Query_And_Remove_SubTree_ExW;
pub const CM_Request_Device_Eject = thismodule.CM_Request_Device_EjectW;
pub const CM_Request_Device_Eject_Ex = thismodule.CM_Request_Device_Eject_ExW;
pub const CM_Register_Device_Interface = thismodule.CM_Register_Device_InterfaceW;
pub const CM_Register_Device_Interface_Ex = thismodule.CM_Register_Device_Interface_ExW;
pub const CM_Unregister_Device_Interface = thismodule.CM_Unregister_Device_InterfaceW;
pub const CM_Unregister_Device_Interface_Ex = thismodule.CM_Unregister_Device_Interface_ExW;
pub const CM_Set_DevNode_Registry_Property = thismodule.CM_Set_DevNode_Registry_PropertyW;
pub const CM_Set_DevNode_Registry_Property_Ex = thismodule.CM_Set_DevNode_Registry_Property_ExW;
pub const CM_Set_HW_Prof_Flags = thismodule.CM_Set_HW_Prof_FlagsW;
pub const CM_Set_HW_Prof_Flags_Ex = thismodule.CM_Set_HW_Prof_Flags_ExW;
pub const CM_Get_Resource_Conflict_Details = thismodule.CM_Get_Resource_Conflict_DetailsW;
pub const CM_Get_Class_Registry_Property = thismodule.CM_Get_Class_Registry_PropertyW;
pub const CM_Set_Class_Registry_Property = thismodule.CM_Set_Class_Registry_PropertyW;
pub const UpdateDriverForPlugAndPlayDevices = thismodule.UpdateDriverForPlugAndPlayDevicesW;
pub const DiInstallDriver = thismodule.DiInstallDriverW;
pub const DiUninstallDriver = thismodule.DiUninstallDriverW;
},
.unspecified => if (@import("builtin").is_test) struct {
pub const SP_ORIGINAL_FILE_INFO_ = *opaque{};
pub const PSP_FILE_CALLBACK_ = *opaque{};
pub const FILEPATHS_ = *opaque{};
pub const FILEPATHS_SIGNERINFO_ = *opaque{};
pub const SOURCE_MEDIA_ = *opaque{};
pub const CABINET_INFO_ = *opaque{};
pub const FILE_IN_CABINET_INFO_ = *opaque{};
pub const SP_REGISTER_CONTROL_STATUS = *opaque{};
pub const SP_FILE_COPY_PARAMS_ = *opaque{};
pub const SP_DEVICE_INTERFACE_DETAIL_DATA_ = *opaque{};
pub const SP_DEVINFO_LIST_DETAIL_DATA_ = *opaque{};
pub const SP_DEVINSTALL_PARAMS_ = *opaque{};
pub const SP_SELECTDEVICE_PARAMS_ = *opaque{};
pub const SP_TROUBLESHOOTER_PARAMS_ = *opaque{};
pub const SP_POWERMESSAGEWAKE_PARAMS_ = *opaque{};
pub const SP_DRVINFO_DATA_V2_ = *opaque{};
pub const SP_DRVINFO_DATA_V1_ = *opaque{};
pub const SP_DRVINFO_DETAIL_DATA_ = *opaque{};
pub const SP_BACKUP_QUEUE_PARAMS_V2_ = *opaque{};
pub const SP_BACKUP_QUEUE_PARAMS_V1_ = *opaque{};
pub const SP_INF_SIGNER_INFO_V1_ = *opaque{};
pub const SP_INF_SIGNER_INFO_V2_ = *opaque{};
pub const CONFLICT_DETAILS_ = *opaque{};
pub const HWProfileInfo_s = *opaque{};
pub const SetupGetInfInformation = *opaque{};
pub const SetupQueryInfFileInformation = *opaque{};
pub const SetupQueryInfOriginalFileInformation = *opaque{};
pub const SetupQueryInfVersionInformation = *opaque{};
pub const SetupGetInfDriverStoreLocation = *opaque{};
pub const SetupGetInfPublishedName = *opaque{};
pub const SetupGetInfFileList = *opaque{};
pub const SetupOpenInfFile = *opaque{};
pub const SetupOpenAppendInfFile = *opaque{};
pub const SetupFindFirstLine = *opaque{};
pub const SetupFindNextMatchLine = *opaque{};
pub const SetupGetLineByIndex = *opaque{};
pub const SetupGetLineCount = *opaque{};
pub const SetupGetLineText = *opaque{};
pub const SetupGetStringField = *opaque{};
pub const SetupGetMultiSzField = *opaque{};
pub const SetupGetFileCompressionInfo = *opaque{};
pub const SetupGetFileCompressionInfoEx = *opaque{};
pub const SetupDecompressOrCopyFile = *opaque{};
pub const SetupGetSourceFileLocation = *opaque{};
pub const SetupGetSourceFileSize = *opaque{};
pub const SetupGetTargetPath = *opaque{};
pub const SetupSetSourceList = *opaque{};
pub const SetupAddToSourceList = *opaque{};
pub const SetupRemoveFromSourceList = *opaque{};
pub const SetupQuerySourceList = *opaque{};
pub const SetupFreeSourceList = *opaque{};
pub const SetupPromptForDisk = *opaque{};
pub const SetupCopyError = *opaque{};
pub const SetupRenameError = *opaque{};
pub const SetupDeleteError = *opaque{};
pub const SetupBackupError = *opaque{};
pub const SetupSetDirectoryId = *opaque{};
pub const SetupSetDirectoryIdEx = *opaque{};
pub const SetupGetSourceInfo = *opaque{};
pub const SetupInstallFile = *opaque{};
pub const SetupInstallFileEx = *opaque{};
pub const SetupSetFileQueueAlternatePlatform = *opaque{};
pub const SetupSetPlatformPathOverride = *opaque{};
pub const SetupQueueCopy = *opaque{};
pub const SetupQueueCopyIndirect = *opaque{};
pub const SetupQueueDefaultCopy = *opaque{};
pub const SetupQueueCopySection = *opaque{};
pub const SetupQueueDelete = *opaque{};
pub const SetupQueueDeleteSection = *opaque{};
pub const SetupQueueRename = *opaque{};
pub const SetupQueueRenameSection = *opaque{};
pub const SetupCommitFileQueue = *opaque{};
pub const SetupScanFileQueue = *opaque{};
pub const SetupCopyOEMInf = *opaque{};
pub const SetupUninstallOEMInf = *opaque{};
pub const SetupCreateDiskSpaceList = *opaque{};
pub const SetupDuplicateDiskSpaceList = *opaque{};
pub const SetupQueryDrivesInDiskSpaceList = *opaque{};
pub const SetupQuerySpaceRequiredOnDrive = *opaque{};
pub const SetupAdjustDiskSpaceList = *opaque{};
pub const SetupAddToDiskSpaceList = *opaque{};
pub const SetupAddSectionToDiskSpaceList = *opaque{};
pub const SetupAddInstallSectionToDiskSpaceList = *opaque{};
pub const SetupRemoveFromDiskSpaceList = *opaque{};
pub const SetupRemoveSectionFromDiskSpaceList = *opaque{};
pub const SetupRemoveInstallSectionFromDiskSpaceList = *opaque{};
pub const SetupIterateCabinet = *opaque{};
pub const SetupDefaultQueueCallback = *opaque{};
pub const SetupInstallFromInfSection = *opaque{};
pub const SetupInstallFilesFromInfSection = *opaque{};
pub const SetupInstallServicesFromInfSection = *opaque{};
pub const SetupInstallServicesFromInfSectionEx = *opaque{};
pub const InstallHinfSection = *opaque{};
pub const SetupInitializeFileLog = *opaque{};
pub const SetupLogFile = *opaque{};
pub const SetupRemoveFileLogEntry = *opaque{};
pub const SetupQueryFileLog = *opaque{};
pub const SetupLogError = *opaque{};
pub const SetupGetBackupInformation = *opaque{};
pub const SetupPrepareQueueForRestore = *opaque{};
pub const SetupDiCreateDeviceInfoListEx = *opaque{};
pub const SetupDiGetDeviceInfoListDetail = *opaque{};
pub const SetupDiCreateDeviceInfo = *opaque{};
pub const SetupDiOpenDeviceInfo = *opaque{};
pub const SetupDiGetDeviceInstanceId = *opaque{};
pub const SetupDiCreateDeviceInterface = *opaque{};
pub const SetupDiOpenDeviceInterface = *opaque{};
pub const SetupDiGetDeviceInterfaceDetail = *opaque{};
pub const SetupDiEnumDriverInfo = *opaque{};
pub const SetupDiGetSelectedDriver = *opaque{};
pub const SetupDiSetSelectedDriver = *opaque{};
pub const SetupDiGetDriverInfoDetail = *opaque{};
pub const SetupDiGetClassDevs = *opaque{};
pub const SetupDiGetClassDevsEx = *opaque{};
pub const SetupDiGetINFClass = *opaque{};
pub const SetupDiBuildClassInfoListEx = *opaque{};
pub const SetupDiGetClassDescription = *opaque{};
pub const SetupDiGetClassDescriptionEx = *opaque{};
pub const SetupDiInstallClass = *opaque{};
pub const SetupDiInstallClassEx = *opaque{};
pub const SetupDiOpenClassRegKeyEx = *opaque{};
pub const SetupDiCreateDeviceInterfaceRegKey = *opaque{};
pub const SetupDiCreateDevRegKey = *opaque{};
pub const SetupDiGetHwProfileListEx = *opaque{};
pub const SetupDiGetDeviceRegistryProperty = *opaque{};
pub const SetupDiGetClassRegistryProperty = *opaque{};
pub const SetupDiSetDeviceRegistryProperty = *opaque{};
pub const SetupDiSetClassRegistryProperty = *opaque{};
pub const SetupDiGetDeviceInstallParams = *opaque{};
pub const SetupDiGetClassInstallParams = *opaque{};
pub const SetupDiSetDeviceInstallParams = *opaque{};
pub const SetupDiSetClassInstallParams = *opaque{};
pub const SetupDiGetDriverInstallParams = *opaque{};
pub const SetupDiSetDriverInstallParams = *opaque{};
pub const SetupDiGetClassImageListEx = *opaque{};
pub const SetupDiGetClassDevPropertySheets = *opaque{};
pub const SetupDiClassNameFromGuid = *opaque{};
pub const SetupDiClassNameFromGuidEx = *opaque{};
pub const SetupDiClassGuidsFromName = *opaque{};
pub const SetupDiClassGuidsFromNameEx = *opaque{};
pub const SetupDiGetHwProfileFriendlyName = *opaque{};
pub const SetupDiGetHwProfileFriendlyNameEx = *opaque{};
pub const SetupDiGetActualModelsSection = *opaque{};
pub const SetupDiGetActualSectionToInstall = *opaque{};
pub const SetupDiGetActualSectionToInstallEx = *opaque{};
pub const SetupEnumInfSections = *opaque{};
pub const SetupVerifyInfFile = *opaque{};
pub const SetupDiGetCustomDeviceProperty = *opaque{};
pub const SetupConfigureWmiFromInfSection = *opaque{};
pub const CM_Add_ID = *opaque{};
pub const CM_Add_ID_Ex = *opaque{};
pub const CM_Connect_Machine = *opaque{};
pub const CM_Create_DevNode = *opaque{};
pub const CM_Create_DevNode_Ex = *opaque{};
pub const CM_Enumerate_Enumerators = *opaque{};
pub const CM_Enumerate_Enumerators_Ex = *opaque{};
pub const CM_Get_Class_Name = *opaque{};
pub const CM_Get_Class_Name_Ex = *opaque{};
pub const CM_Get_Class_Key_Name = *opaque{};
pub const CM_Get_Class_Key_Name_Ex = *opaque{};
pub const CM_Get_Device_ID = *opaque{};
pub const CM_Get_Device_ID_Ex = *opaque{};
pub const CM_Get_Device_ID_List = *opaque{};
pub const CM_Get_Device_ID_List_Ex = *opaque{};
pub const CM_Get_Device_ID_List_Size = *opaque{};
pub const CM_Get_Device_ID_List_Size_Ex = *opaque{};
pub const CM_Get_DevNode_Registry_Property = *opaque{};
pub const CM_Get_DevNode_Registry_Property_Ex = *opaque{};
pub const CM_Get_DevNode_Custom_Property = *opaque{};
pub const CM_Get_DevNode_Custom_Property_Ex = *opaque{};
pub const CM_Get_Hardware_Profile_Info = *opaque{};
pub const CM_Get_Hardware_Profile_Info_Ex = *opaque{};
pub const CM_Get_HW_Prof_Flags = *opaque{};
pub const CM_Get_HW_Prof_Flags_Ex = *opaque{};
pub const CM_Get_Device_Interface_Alias = *opaque{};
pub const CM_Get_Device_Interface_Alias_Ex = *opaque{};
pub const CM_Get_Device_Interface_List = *opaque{};
pub const CM_Get_Device_Interface_List_Ex = *opaque{};
pub const CM_Get_Device_Interface_List_Size = *opaque{};
pub const CM_Get_Device_Interface_List_Size_Ex = *opaque{};
pub const CM_Locate_DevNode = *opaque{};
pub const CM_Locate_DevNode_Ex = *opaque{};
pub const CM_Open_Class_Key = *opaque{};
pub const CM_Open_Class_Key_Ex = *opaque{};
pub const CM_Open_Device_Interface_Key = *opaque{};
pub const CM_Open_Device_Interface_Key_Ex = *opaque{};
pub const CM_Delete_Device_Interface_Key = *opaque{};
pub const CM_Delete_Device_Interface_Key_Ex = *opaque{};
pub const CM_Query_And_Remove_SubTree = *opaque{};
pub const CM_Query_And_Remove_SubTree_Ex = *opaque{};
pub const CM_Request_Device_Eject = *opaque{};
pub const CM_Request_Device_Eject_Ex = *opaque{};
pub const CM_Register_Device_Interface = *opaque{};
pub const CM_Register_Device_Interface_Ex = *opaque{};
pub const CM_Unregister_Device_Interface = *opaque{};
pub const CM_Unregister_Device_Interface_Ex = *opaque{};
pub const CM_Set_DevNode_Registry_Property = *opaque{};
pub const CM_Set_DevNode_Registry_Property_Ex = *opaque{};
pub const CM_Set_HW_Prof_Flags = *opaque{};
pub const CM_Set_HW_Prof_Flags_Ex = *opaque{};
pub const CM_Get_Resource_Conflict_Details = *opaque{};
pub const CM_Get_Class_Registry_Property = *opaque{};
pub const CM_Set_Class_Registry_Property = *opaque{};
pub const UpdateDriverForPlugAndPlayDevices = *opaque{};
pub const DiInstallDriver = *opaque{};
pub const DiUninstallDriver = *opaque{};
} else struct {
pub const SP_ORIGINAL_FILE_INFO_ = @compileError("'SP_ORIGINAL_FILE_INFO_' requires that UNICODE be set to true or false in the root module");
pub const PSP_FILE_CALLBACK_ = @compileError("'PSP_FILE_CALLBACK_' requires that UNICODE be set to true or false in the root module");
pub const FILEPATHS_ = @compileError("'FILEPATHS_' requires that UNICODE be set to true or false in the root module");
pub const FILEPATHS_SIGNERINFO_ = @compileError("'FILEPATHS_SIGNERINFO_' requires that UNICODE be set to true or false in the root module");
pub const SOURCE_MEDIA_ = @compileError("'SOURCE_MEDIA_' requires that UNICODE be set to true or false in the root module");
pub const CABINET_INFO_ = @compileError("'CABINET_INFO_' requires that UNICODE be set to true or false in the root module");
pub const FILE_IN_CABINET_INFO_ = @compileError("'FILE_IN_CABINET_INFO_' requires that UNICODE be set to true or false in the root module");
pub const SP_REGISTER_CONTROL_STATUS = @compileError("'SP_REGISTER_CONTROL_STATUS' requires that UNICODE be set to true or false in the root module");
pub const SP_FILE_COPY_PARAMS_ = @compileError("'SP_FILE_COPY_PARAMS_' requires that UNICODE be set to true or false in the root module");
pub const SP_DEVICE_INTERFACE_DETAIL_DATA_ = @compileError("'SP_DEVICE_INTERFACE_DETAIL_DATA_' requires that UNICODE be set to true or false in the root module");
pub const SP_DEVINFO_LIST_DETAIL_DATA_ = @compileError("'SP_DEVINFO_LIST_DETAIL_DATA_' requires that UNICODE be set to true or false in the root module");
pub const SP_DEVINSTALL_PARAMS_ = @compileError("'SP_DEVINSTALL_PARAMS_' requires that UNICODE be set to true or false in the root module");
pub const SP_SELECTDEVICE_PARAMS_ = @compileError("'SP_SELECTDEVICE_PARAMS_' requires that UNICODE be set to true or false in the root module");
pub const SP_TROUBLESHOOTER_PARAMS_ = @compileError("'SP_TROUBLESHOOTER_PARAMS_' requires that UNICODE be set to true or false in the root module");
pub const SP_POWERMESSAGEWAKE_PARAMS_ = @compileError("'SP_POWERMESSAGEWAKE_PARAMS_' requires that UNICODE be set to true or false in the root module");
pub const SP_DRVINFO_DATA_V2_ = @compileError("'SP_DRVINFO_DATA_V2_' requires that UNICODE be set to true or false in the root module");
pub const SP_DRVINFO_DATA_V1_ = @compileError("'SP_DRVINFO_DATA_V1_' requires that UNICODE be set to true or false in the root module");
pub const SP_DRVINFO_DETAIL_DATA_ = @compileError("'SP_DRVINFO_DETAIL_DATA_' requires that UNICODE be set to true or false in the root module");
pub const SP_BACKUP_QUEUE_PARAMS_V2_ = @compileError("'SP_BACKUP_QUEUE_PARAMS_V2_' requires that UNICODE be set to true or false in the root module");
pub const SP_BACKUP_QUEUE_PARAMS_V1_ = @compileError("'SP_BACKUP_QUEUE_PARAMS_V1_' requires that UNICODE be set to true or false in the root module");
pub const SP_INF_SIGNER_INFO_V1_ = @compileError("'SP_INF_SIGNER_INFO_V1_' requires that UNICODE be set to true or false in the root module");
pub const SP_INF_SIGNER_INFO_V2_ = @compileError("'SP_INF_SIGNER_INFO_V2_' requires that UNICODE be set to true or false in the root module");
pub const CONFLICT_DETAILS_ = @compileError("'CONFLICT_DETAILS_' requires that UNICODE be set to true or false in the root module");
pub const HWProfileInfo_s = @compileError("'HWProfileInfo_s' requires that UNICODE be set to true or false in the root module");
pub const SetupGetInfInformation = @compileError("'SetupGetInfInformation' requires that UNICODE be set to true or false in the root module");
pub const SetupQueryInfFileInformation = @compileError("'SetupQueryInfFileInformation' requires that UNICODE be set to true or false in the root module");
pub const SetupQueryInfOriginalFileInformation = @compileError("'SetupQueryInfOriginalFileInformation' requires that UNICODE be set to true or false in the root module");
pub const SetupQueryInfVersionInformation = @compileError("'SetupQueryInfVersionInformation' requires that UNICODE be set to true or false in the root module");
pub const SetupGetInfDriverStoreLocation = @compileError("'SetupGetInfDriverStoreLocation' requires that UNICODE be set to true or false in the root module");
pub const SetupGetInfPublishedName = @compileError("'SetupGetInfPublishedName' requires that UNICODE be set to true or false in the root module");
pub const SetupGetInfFileList = @compileError("'SetupGetInfFileList' requires that UNICODE be set to true or false in the root module");
pub const SetupOpenInfFile = @compileError("'SetupOpenInfFile' requires that UNICODE be set to true or false in the root module");
pub const SetupOpenAppendInfFile = @compileError("'SetupOpenAppendInfFile' requires that UNICODE be set to true or false in the root module");
pub const SetupFindFirstLine = @compileError("'SetupFindFirstLine' requires that UNICODE be set to true or false in the root module");
pub const SetupFindNextMatchLine = @compileError("'SetupFindNextMatchLine' requires that UNICODE be set to true or false in the root module");
pub const SetupGetLineByIndex = @compileError("'SetupGetLineByIndex' requires that UNICODE be set to true or false in the root module");
pub const SetupGetLineCount = @compileError("'SetupGetLineCount' requires that UNICODE be set to true or false in the root module");
pub const SetupGetLineText = @compileError("'SetupGetLineText' requires that UNICODE be set to true or false in the root module");
pub const SetupGetStringField = @compileError("'SetupGetStringField' requires that UNICODE be set to true or false in the root module");
pub const SetupGetMultiSzField = @compileError("'SetupGetMultiSzField' requires that UNICODE be set to true or false in the root module");
pub const SetupGetFileCompressionInfo = @compileError("'SetupGetFileCompressionInfo' requires that UNICODE be set to true or false in the root module");
pub const SetupGetFileCompressionInfoEx = @compileError("'SetupGetFileCompressionInfoEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDecompressOrCopyFile = @compileError("'SetupDecompressOrCopyFile' requires that UNICODE be set to true or false in the root module");
pub const SetupGetSourceFileLocation = @compileError("'SetupGetSourceFileLocation' requires that UNICODE be set to true or false in the root module");
pub const SetupGetSourceFileSize = @compileError("'SetupGetSourceFileSize' requires that UNICODE be set to true or false in the root module");
pub const SetupGetTargetPath = @compileError("'SetupGetTargetPath' requires that UNICODE be set to true or false in the root module");
pub const SetupSetSourceList = @compileError("'SetupSetSourceList' requires that UNICODE be set to true or false in the root module");
pub const SetupAddToSourceList = @compileError("'SetupAddToSourceList' requires that UNICODE be set to true or false in the root module");
pub const SetupRemoveFromSourceList = @compileError("'SetupRemoveFromSourceList' requires that UNICODE be set to true or false in the root module");
pub const SetupQuerySourceList = @compileError("'SetupQuerySourceList' requires that UNICODE be set to true or false in the root module");
pub const SetupFreeSourceList = @compileError("'SetupFreeSourceList' requires that UNICODE be set to true or false in the root module");
pub const SetupPromptForDisk = @compileError("'SetupPromptForDisk' requires that UNICODE be set to true or false in the root module");
pub const SetupCopyError = @compileError("'SetupCopyError' requires that UNICODE be set to true or false in the root module");
pub const SetupRenameError = @compileError("'SetupRenameError' requires that UNICODE be set to true or false in the root module");
pub const SetupDeleteError = @compileError("'SetupDeleteError' requires that UNICODE be set to true or false in the root module");
pub const SetupBackupError = @compileError("'SetupBackupError' requires that UNICODE be set to true or false in the root module");
pub const SetupSetDirectoryId = @compileError("'SetupSetDirectoryId' requires that UNICODE be set to true or false in the root module");
pub const SetupSetDirectoryIdEx = @compileError("'SetupSetDirectoryIdEx' requires that UNICODE be set to true or false in the root module");
pub const SetupGetSourceInfo = @compileError("'SetupGetSourceInfo' requires that UNICODE be set to true or false in the root module");
pub const SetupInstallFile = @compileError("'SetupInstallFile' requires that UNICODE be set to true or false in the root module");
pub const SetupInstallFileEx = @compileError("'SetupInstallFileEx' requires that UNICODE be set to true or false in the root module");
pub const SetupSetFileQueueAlternatePlatform = @compileError("'SetupSetFileQueueAlternatePlatform' requires that UNICODE be set to true or false in the root module");
pub const SetupSetPlatformPathOverride = @compileError("'SetupSetPlatformPathOverride' requires that UNICODE be set to true or false in the root module");
pub const SetupQueueCopy = @compileError("'SetupQueueCopy' requires that UNICODE be set to true or false in the root module");
pub const SetupQueueCopyIndirect = @compileError("'SetupQueueCopyIndirect' requires that UNICODE be set to true or false in the root module");
pub const SetupQueueDefaultCopy = @compileError("'SetupQueueDefaultCopy' requires that UNICODE be set to true or false in the root module");
pub const SetupQueueCopySection = @compileError("'SetupQueueCopySection' requires that UNICODE be set to true or false in the root module");
pub const SetupQueueDelete = @compileError("'SetupQueueDelete' requires that UNICODE be set to true or false in the root module");
pub const SetupQueueDeleteSection = @compileError("'SetupQueueDeleteSection' requires that UNICODE be set to true or false in the root module");
pub const SetupQueueRename = @compileError("'SetupQueueRename' requires that UNICODE be set to true or false in the root module");
pub const SetupQueueRenameSection = @compileError("'SetupQueueRenameSection' requires that UNICODE be set to true or false in the root module");
pub const SetupCommitFileQueue = @compileError("'SetupCommitFileQueue' requires that UNICODE be set to true or false in the root module");
pub const SetupScanFileQueue = @compileError("'SetupScanFileQueue' requires that UNICODE be set to true or false in the root module");
pub const SetupCopyOEMInf = @compileError("'SetupCopyOEMInf' requires that UNICODE be set to true or false in the root module");
pub const SetupUninstallOEMInf = @compileError("'SetupUninstallOEMInf' requires that UNICODE be set to true or false in the root module");
pub const SetupCreateDiskSpaceList = @compileError("'SetupCreateDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupDuplicateDiskSpaceList = @compileError("'SetupDuplicateDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupQueryDrivesInDiskSpaceList = @compileError("'SetupQueryDrivesInDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupQuerySpaceRequiredOnDrive = @compileError("'SetupQuerySpaceRequiredOnDrive' requires that UNICODE be set to true or false in the root module");
pub const SetupAdjustDiskSpaceList = @compileError("'SetupAdjustDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupAddToDiskSpaceList = @compileError("'SetupAddToDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupAddSectionToDiskSpaceList = @compileError("'SetupAddSectionToDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupAddInstallSectionToDiskSpaceList = @compileError("'SetupAddInstallSectionToDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupRemoveFromDiskSpaceList = @compileError("'SetupRemoveFromDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupRemoveSectionFromDiskSpaceList = @compileError("'SetupRemoveSectionFromDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupRemoveInstallSectionFromDiskSpaceList = @compileError("'SetupRemoveInstallSectionFromDiskSpaceList' requires that UNICODE be set to true or false in the root module");
pub const SetupIterateCabinet = @compileError("'SetupIterateCabinet' requires that UNICODE be set to true or false in the root module");
pub const SetupDefaultQueueCallback = @compileError("'SetupDefaultQueueCallback' requires that UNICODE be set to true or false in the root module");
pub const SetupInstallFromInfSection = @compileError("'SetupInstallFromInfSection' requires that UNICODE be set to true or false in the root module");
pub const SetupInstallFilesFromInfSection = @compileError("'SetupInstallFilesFromInfSection' requires that UNICODE be set to true or false in the root module");
pub const SetupInstallServicesFromInfSection = @compileError("'SetupInstallServicesFromInfSection' requires that UNICODE be set to true or false in the root module");
pub const SetupInstallServicesFromInfSectionEx = @compileError("'SetupInstallServicesFromInfSectionEx' requires that UNICODE be set to true or false in the root module");
pub const InstallHinfSection = @compileError("'InstallHinfSection' requires that UNICODE be set to true or false in the root module");
pub const SetupInitializeFileLog = @compileError("'SetupInitializeFileLog' requires that UNICODE be set to true or false in the root module");
pub const SetupLogFile = @compileError("'SetupLogFile' requires that UNICODE be set to true or false in the root module");
pub const SetupRemoveFileLogEntry = @compileError("'SetupRemoveFileLogEntry' requires that UNICODE be set to true or false in the root module");
pub const SetupQueryFileLog = @compileError("'SetupQueryFileLog' requires that UNICODE be set to true or false in the root module");
pub const SetupLogError = @compileError("'SetupLogError' requires that UNICODE be set to true or false in the root module");
pub const SetupGetBackupInformation = @compileError("'SetupGetBackupInformation' requires that UNICODE be set to true or false in the root module");
pub const SetupPrepareQueueForRestore = @compileError("'SetupPrepareQueueForRestore' requires that UNICODE be set to true or false in the root module");
pub const SetupDiCreateDeviceInfoListEx = @compileError("'SetupDiCreateDeviceInfoListEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetDeviceInfoListDetail = @compileError("'SetupDiGetDeviceInfoListDetail' requires that UNICODE be set to true or false in the root module");
pub const SetupDiCreateDeviceInfo = @compileError("'SetupDiCreateDeviceInfo' requires that UNICODE be set to true or false in the root module");
pub const SetupDiOpenDeviceInfo = @compileError("'SetupDiOpenDeviceInfo' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetDeviceInstanceId = @compileError("'SetupDiGetDeviceInstanceId' requires that UNICODE be set to true or false in the root module");
pub const SetupDiCreateDeviceInterface = @compileError("'SetupDiCreateDeviceInterface' requires that UNICODE be set to true or false in the root module");
pub const SetupDiOpenDeviceInterface = @compileError("'SetupDiOpenDeviceInterface' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetDeviceInterfaceDetail = @compileError("'SetupDiGetDeviceInterfaceDetail' requires that UNICODE be set to true or false in the root module");
pub const SetupDiEnumDriverInfo = @compileError("'SetupDiEnumDriverInfo' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetSelectedDriver = @compileError("'SetupDiGetSelectedDriver' requires that UNICODE be set to true or false in the root module");
pub const SetupDiSetSelectedDriver = @compileError("'SetupDiSetSelectedDriver' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetDriverInfoDetail = @compileError("'SetupDiGetDriverInfoDetail' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetClassDevs = @compileError("'SetupDiGetClassDevs' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetClassDevsEx = @compileError("'SetupDiGetClassDevsEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetINFClass = @compileError("'SetupDiGetINFClass' requires that UNICODE be set to true or false in the root module");
pub const SetupDiBuildClassInfoListEx = @compileError("'SetupDiBuildClassInfoListEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetClassDescription = @compileError("'SetupDiGetClassDescription' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetClassDescriptionEx = @compileError("'SetupDiGetClassDescriptionEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiInstallClass = @compileError("'SetupDiInstallClass' requires that UNICODE be set to true or false in the root module");
pub const SetupDiInstallClassEx = @compileError("'SetupDiInstallClassEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiOpenClassRegKeyEx = @compileError("'SetupDiOpenClassRegKeyEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiCreateDeviceInterfaceRegKey = @compileError("'SetupDiCreateDeviceInterfaceRegKey' requires that UNICODE be set to true or false in the root module");
pub const SetupDiCreateDevRegKey = @compileError("'SetupDiCreateDevRegKey' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetHwProfileListEx = @compileError("'SetupDiGetHwProfileListEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetDeviceRegistryProperty = @compileError("'SetupDiGetDeviceRegistryProperty' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetClassRegistryProperty = @compileError("'SetupDiGetClassRegistryProperty' requires that UNICODE be set to true or false in the root module");
pub const SetupDiSetDeviceRegistryProperty = @compileError("'SetupDiSetDeviceRegistryProperty' requires that UNICODE be set to true or false in the root module");
pub const SetupDiSetClassRegistryProperty = @compileError("'SetupDiSetClassRegistryProperty' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetDeviceInstallParams = @compileError("'SetupDiGetDeviceInstallParams' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetClassInstallParams = @compileError("'SetupDiGetClassInstallParams' requires that UNICODE be set to true or false in the root module");
pub const SetupDiSetDeviceInstallParams = @compileError("'SetupDiSetDeviceInstallParams' requires that UNICODE be set to true or false in the root module");
pub const SetupDiSetClassInstallParams = @compileError("'SetupDiSetClassInstallParams' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetDriverInstallParams = @compileError("'SetupDiGetDriverInstallParams' requires that UNICODE be set to true or false in the root module");
pub const SetupDiSetDriverInstallParams = @compileError("'SetupDiSetDriverInstallParams' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetClassImageListEx = @compileError("'SetupDiGetClassImageListEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetClassDevPropertySheets = @compileError("'SetupDiGetClassDevPropertySheets' requires that UNICODE be set to true or false in the root module");
pub const SetupDiClassNameFromGuid = @compileError("'SetupDiClassNameFromGuid' requires that UNICODE be set to true or false in the root module");
pub const SetupDiClassNameFromGuidEx = @compileError("'SetupDiClassNameFromGuidEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiClassGuidsFromName = @compileError("'SetupDiClassGuidsFromName' requires that UNICODE be set to true or false in the root module");
pub const SetupDiClassGuidsFromNameEx = @compileError("'SetupDiClassGuidsFromNameEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetHwProfileFriendlyName = @compileError("'SetupDiGetHwProfileFriendlyName' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetHwProfileFriendlyNameEx = @compileError("'SetupDiGetHwProfileFriendlyNameEx' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetActualModelsSection = @compileError("'SetupDiGetActualModelsSection' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetActualSectionToInstall = @compileError("'SetupDiGetActualSectionToInstall' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetActualSectionToInstallEx = @compileError("'SetupDiGetActualSectionToInstallEx' requires that UNICODE be set to true or false in the root module");
pub const SetupEnumInfSections = @compileError("'SetupEnumInfSections' requires that UNICODE be set to true or false in the root module");
pub const SetupVerifyInfFile = @compileError("'SetupVerifyInfFile' requires that UNICODE be set to true or false in the root module");
pub const SetupDiGetCustomDeviceProperty = @compileError("'SetupDiGetCustomDeviceProperty' requires that UNICODE be set to true or false in the root module");
pub const SetupConfigureWmiFromInfSection = @compileError("'SetupConfigureWmiFromInfSection' requires that UNICODE be set to true or false in the root module");
pub const CM_Add_ID = @compileError("'CM_Add_ID' requires that UNICODE be set to true or false in the root module");
pub const CM_Add_ID_Ex = @compileError("'CM_Add_ID_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Connect_Machine = @compileError("'CM_Connect_Machine' requires that UNICODE be set to true or false in the root module");
pub const CM_Create_DevNode = @compileError("'CM_Create_DevNode' requires that UNICODE be set to true or false in the root module");
pub const CM_Create_DevNode_Ex = @compileError("'CM_Create_DevNode_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Enumerate_Enumerators = @compileError("'CM_Enumerate_Enumerators' requires that UNICODE be set to true or false in the root module");
pub const CM_Enumerate_Enumerators_Ex = @compileError("'CM_Enumerate_Enumerators_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Class_Name = @compileError("'CM_Get_Class_Name' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Class_Name_Ex = @compileError("'CM_Get_Class_Name_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Class_Key_Name = @compileError("'CM_Get_Class_Key_Name' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Class_Key_Name_Ex = @compileError("'CM_Get_Class_Key_Name_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_ID = @compileError("'CM_Get_Device_ID' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_ID_Ex = @compileError("'CM_Get_Device_ID_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_ID_List = @compileError("'CM_Get_Device_ID_List' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_ID_List_Ex = @compileError("'CM_Get_Device_ID_List_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_ID_List_Size = @compileError("'CM_Get_Device_ID_List_Size' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_ID_List_Size_Ex = @compileError("'CM_Get_Device_ID_List_Size_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_DevNode_Registry_Property = @compileError("'CM_Get_DevNode_Registry_Property' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_DevNode_Registry_Property_Ex = @compileError("'CM_Get_DevNode_Registry_Property_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_DevNode_Custom_Property = @compileError("'CM_Get_DevNode_Custom_Property' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_DevNode_Custom_Property_Ex = @compileError("'CM_Get_DevNode_Custom_Property_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Hardware_Profile_Info = @compileError("'CM_Get_Hardware_Profile_Info' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Hardware_Profile_Info_Ex = @compileError("'CM_Get_Hardware_Profile_Info_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_HW_Prof_Flags = @compileError("'CM_Get_HW_Prof_Flags' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_HW_Prof_Flags_Ex = @compileError("'CM_Get_HW_Prof_Flags_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_Interface_Alias = @compileError("'CM_Get_Device_Interface_Alias' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_Interface_Alias_Ex = @compileError("'CM_Get_Device_Interface_Alias_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_Interface_List = @compileError("'CM_Get_Device_Interface_List' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_Interface_List_Ex = @compileError("'CM_Get_Device_Interface_List_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_Interface_List_Size = @compileError("'CM_Get_Device_Interface_List_Size' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Device_Interface_List_Size_Ex = @compileError("'CM_Get_Device_Interface_List_Size_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Locate_DevNode = @compileError("'CM_Locate_DevNode' requires that UNICODE be set to true or false in the root module");
pub const CM_Locate_DevNode_Ex = @compileError("'CM_Locate_DevNode_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Open_Class_Key = @compileError("'CM_Open_Class_Key' requires that UNICODE be set to true or false in the root module");
pub const CM_Open_Class_Key_Ex = @compileError("'CM_Open_Class_Key_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Open_Device_Interface_Key = @compileError("'CM_Open_Device_Interface_Key' requires that UNICODE be set to true or false in the root module");
pub const CM_Open_Device_Interface_Key_Ex = @compileError("'CM_Open_Device_Interface_Key_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Delete_Device_Interface_Key = @compileError("'CM_Delete_Device_Interface_Key' requires that UNICODE be set to true or false in the root module");
pub const CM_Delete_Device_Interface_Key_Ex = @compileError("'CM_Delete_Device_Interface_Key_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Query_And_Remove_SubTree = @compileError("'CM_Query_And_Remove_SubTree' requires that UNICODE be set to true or false in the root module");
pub const CM_Query_And_Remove_SubTree_Ex = @compileError("'CM_Query_And_Remove_SubTree_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Request_Device_Eject = @compileError("'CM_Request_Device_Eject' requires that UNICODE be set to true or false in the root module");
pub const CM_Request_Device_Eject_Ex = @compileError("'CM_Request_Device_Eject_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Register_Device_Interface = @compileError("'CM_Register_Device_Interface' requires that UNICODE be set to true or false in the root module");
pub const CM_Register_Device_Interface_Ex = @compileError("'CM_Register_Device_Interface_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Unregister_Device_Interface = @compileError("'CM_Unregister_Device_Interface' requires that UNICODE be set to true or false in the root module");
pub const CM_Unregister_Device_Interface_Ex = @compileError("'CM_Unregister_Device_Interface_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Set_DevNode_Registry_Property = @compileError("'CM_Set_DevNode_Registry_Property' requires that UNICODE be set to true or false in the root module");
pub const CM_Set_DevNode_Registry_Property_Ex = @compileError("'CM_Set_DevNode_Registry_Property_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Set_HW_Prof_Flags = @compileError("'CM_Set_HW_Prof_Flags' requires that UNICODE be set to true or false in the root module");
pub const CM_Set_HW_Prof_Flags_Ex = @compileError("'CM_Set_HW_Prof_Flags_Ex' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Resource_Conflict_Details = @compileError("'CM_Get_Resource_Conflict_Details' requires that UNICODE be set to true or false in the root module");
pub const CM_Get_Class_Registry_Property = @compileError("'CM_Get_Class_Registry_Property' requires that UNICODE be set to true or false in the root module");
pub const CM_Set_Class_Registry_Property = @compileError("'CM_Set_Class_Registry_Property' requires that UNICODE be set to true or false in the root module");
pub const UpdateDriverForPlugAndPlayDevices = @compileError("'UpdateDriverForPlugAndPlayDevices' requires that UNICODE be set to true or false in the root module");
pub const DiInstallDriver = @compileError("'DiInstallDriver' requires that UNICODE be set to true or false in the root module");
pub const DiUninstallDriver = @compileError("'DiUninstallDriver' requires that UNICODE be set to true or false in the root module");
},
};
//--------------------------------------------------------------------------------
// Section: Imports (22)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const CHAR = @import("../foundation.zig").CHAR;
const DEVPROPKEY = @import("../devices/properties.zig").DEVPROPKEY;
const FILETIME = @import("../foundation.zig").FILETIME;
const HANDLE = @import("../foundation.zig").HANDLE;
const HDC = @import("../graphics/gdi.zig").HDC;
const HICON = @import("../ui/windows_and_messaging.zig").HICON;
const HIMAGELIST = @import("../ui/controls.zig").HIMAGELIST;
const HINSTANCE = @import("../foundation.zig").HINSTANCE;
const HKEY = @import("../system/registry.zig").HKEY;
const HPROPSHEETPAGE = @import("../ui/controls.zig").HPROPSHEETPAGE;
const HWND = @import("../foundation.zig").HWND;
const LARGE_INTEGER = @import("../foundation.zig").LARGE_INTEGER;
const LPARAM = @import("../foundation.zig").LPARAM;
const PRIORITY = @import("../data/html_help.zig").PRIORITY;
const PROPSHEETHEADERA_V2 = @import("../ui/controls.zig").PROPSHEETHEADERA_V2;
const PROPSHEETHEADERW_V2 = @import("../ui/controls.zig").PROPSHEETHEADERW_V2;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;
const RECT = @import("../foundation.zig").RECT;
const VER_PLATFORM = @import("../system/diagnostics/debug.zig").VER_PLATFORM;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "PSP_FILE_CALLBACK_A")) { _ = PSP_FILE_CALLBACK_A; }
if (@hasDecl(@This(), "PSP_FILE_CALLBACK_W")) { _ = PSP_FILE_CALLBACK_W; }
if (@hasDecl(@This(), "PDETECT_PROGRESS_NOTIFY")) { _ = PDETECT_PROGRESS_NOTIFY; }
if (@hasDecl(@This(), "PSP_DETSIG_CMPPROC")) { _ = PSP_DETSIG_CMPPROC; }
if (@hasDecl(@This(), "PCM_NOTIFY_CALLBACK")) { _ = PCM_NOTIFY_CALLBACK; }
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/devices/device_and_driver_installation.zig |
pub const APPEND = @import("./strings/append.zig").APPEND;
pub const BITCOUNT = @import("./strings/bitcount.zig").BITCOUNT;
// pub const BITFIELD = @import("./strings/bitfield.zig").BITFIELD;
pub const BITOP = @import("./strings/bitop.zig").BITOP;
pub const BITPOS = @import("./strings/bitpos.zig").BITPOS;
pub const DECR = @import("./strings/decr.zig").DECR;
pub const DECRBY = @import("./strings/decrby.zig").DECRBY;
pub const GET = @import("./strings/get.zig").GET;
pub const GETBIT = @import("./strings/getbit.zig").GETBIT;
pub const GETRANGE = @import("./strings/getrange.zig").GETRANGE;
pub const GETSET = @import("./strings/getset.zig").GETSET;
pub const INCR = @import("./strings/incr.zig").INCR;
pub const INCRBY = @import("./strings/incrby.zig").INCRBY;
pub const INCRBYFLOAT = @import("./strings/incrbyfloat.zig").INCRBYFLOAT;
pub const MGET = @import("./strings/mget.zig").MGET;
// pub const MSET = @import("./strings/mset.zig").MSET;
// pub const MSETNX = @import("./strings/msetnx.zig").MSETNX;
// pub const PSETEX = @import("./strings/psetex.zig").PSETEX;
pub const SET = @import("./strings/set.zig").SET;
pub const SETBIT = @import("./strings/setbit.zig").SETBIT;
pub const utils = struct {
pub const Value = @import("./_common_utils.zig").Value;
};
test "strings" {
_ = @import("./strings/append.zig");
_ = @import("./strings/bitcount.zig");
_ = @import("./strings/bitfield.zig");
_ = @import("./strings/bitop.zig");
_ = @import("./strings/bitpos.zig");
_ = @import("./strings/decr.zig");
_ = @import("./strings/decrby.zig");
_ = @import("./strings/get.zig");
_ = @import("./strings/getbit.zig");
_ = @import("./strings/getrange.zig");
_ = @import("./strings/getset.zig");
_ = @import("./strings/incr.zig");
_ = @import("./strings/incrby.zig");
_ = @import("./strings/incrbyfloat.zig");
_ = @import("./strings/mget.zig");
_ = @import("./strings/mset.zig");
_ = @import("./strings/msetnx.zig");
_ = @import("./strings/psetex.zig");
_ = @import("./strings/set.zig");
_ = @import("./strings/setbit.zig");
}
test "docs" {
const std = @import("std");
std.meta.refAllDecls(@This());
} | src/commands/strings.zig |
const std = @import("std");
const mem = std.mem;
const art = @import("art.zig");
const Art = art.Art;
const tal = &std.testing.allocator;
const warn = std.log.warn;
// set to test against many value types (increases test run time)
const test_all_ValueTypes = false;
const ValueTypes = if (test_all_ValueTypes) [_]type{ u8, u16, u32, u64, usize, f32, f64, bool, [24]u8, [3]usize } else [_]type{usize};
fn valAsType(comptime T: type, i: usize) T {
return switch (@typeInfo(T)) {
.Int => @truncate(T, i),
.Bool => i != 0,
.Float => @intToFloat(T, i),
.Array => |ti| blk: {
var v: T = undefined;
for (v) |*it| {
it.* = @truncate(ti.child, i);
}
break :blk v;
},
else => @compileLog(T, @typeInfo(T)),
};
}
test "basic" {
inline for (ValueTypes) |T| {
var t = Art(T).init(tal);
defer t.deinit();
const words = [_][:0]const u8{
"Aaron",
"Aaronic",
"Aaronical",
};
for (words) |w, i| {
_ = try t.insert(w, valAsType(T, i));
}
}
}
// TODO make iterator() for Art with same api as StringHashMap
fn free_keys(container: anytype) !void {
const T = @TypeOf(container.*);
if (T == std.StringHashMap(usize)) {
var it = container.iterator();
while (it.next()) |entry| {
container.allocator.free(entry.key_ptr.*);
}
} else {
const cbf = struct {
pub fn f(n: *T.Node, tree: anytype, _: usize) TestingError!bool {
tree.allocator.free(n.leaf.key);
return false;
}
}.f;
_ = try container.iter(cbf, container, TestingError!bool);
}
}
const doInsert = struct {
fn func(line: [:0]const u8, linei: usize, container: anytype, _: anytype, comptime T: type) anyerror!void {
const line_ = try container.allocator.dupeZ(u8, line);
const result = try container.insert(line_, valAsType(T, linei));
try testing.expect(result == .missing);
}
}.func;
test "insert many keys" {
inline for (ValueTypes) |T| {
var t = Art(T).init(tal);
defer {
free_keys(&t) catch unreachable;
t.deinit();
}
const filename = "./testdata/words.txt";
const lines = try fileEachLine(doInsert, filename, &t, null, T);
try testing.expectEqual(t.size, lines);
}
}
fn fileEachLine(comptime do: fn (line: [:0]const u8, linei: usize, container: anytype, data: anytype, comptime T: type) anyerror!void, filename: []const u8, container: anytype, data: anytype, comptime T: type) !usize {
const f = try std.fs.cwd().openFile(filename, .{ .mode = .read_only });
defer f.close();
var linei: usize = 1;
const reader = &f.reader();
var buf: [512:0]u8 = undefined;
while (try reader.readUntilDelimiterOrEof(&buf, '\n')) |line| {
buf[line.len] = 0;
try do(buf[0..line.len :0], linei, container, data, T);
linei += 1;
}
return linei - 1;
}
test "insert delete many" {
inline for (ValueTypes) |T| {
var t = Art(T).init(tal);
defer t.deinit();
const filename = "./testdata/words.txt";
const lines = try fileEachLine(doInsert, filename, &t, null, T);
const doDelete = struct {
fn func(line: [:0]const u8, linei: usize, _t: anytype, data: anytype, comptime _: type) anyerror!void {
const result = try _t.delete(line);
try testing.expect(result == .found);
_t.allocator.free(result.found.key);
try testing.expectEqual(result.found.value, valAsType(T, linei));
const nlines = data;
try testing.expectEqual(_t.size, nlines - linei);
}
}.func;
_ = try fileEachLine(doDelete, filename, &t, lines, T);
try testing.expectEqual(t.size, 0);
try free_keys(&t);
}
}
const testing = std.testing;
test "long prefix" {
var t = Art(usize).init(tal);
defer t.deinit();
try testing.expectEqual(t.insert("this:key:has:a:long:prefix:3", 3), .missing);
try testing.expectEqual(t.insert("this:key:has:a:long:common:prefix:2", 2), .missing);
try testing.expectEqual(t.insert("this:key:has:a:long:common:prefix:1", 1), .missing);
var result = t.search("this:key:has:a:long:common:prefix:1");
try testing.expectEqual(result.found.value, 1);
result = t.search("this:key:has:a:long:common:prefix:2");
try testing.expectEqual(result.found.value, 2);
result = t.search("this:key:has:a:long:prefix:3");
try testing.expectEqual(result.found.value, 3);
const expected = [_][]const u8{
"this:key:has:a:long:common:prefix:1",
"this:key:has:a:long:common:prefix:2",
"this:key:has:a:long:prefix:3",
};
var p = prefix_data{ .count = 0, .max_count = 3, .expected = &expected };
try testing.expect(!try t.iterPrefix("this:key:has", test_prefix_cb, &p, TestingError!bool));
try testing.expectEqual(p.count, p.max_count);
}
test "insert search uuid" {
inline for (ValueTypes) |T| {
var t = Art(T).init(tal);
defer t.deinit();
const filename = "./testdata/uuid.txt";
_ = try fileEachLine(doInsert, filename, &t, null, T);
const doSearch = struct {
fn func(line: [:0]const u8, linei: usize, _t: anytype, data: anytype, comptime _: type) anyerror!void {
_ = data;
const result = _t.search(line);
try testing.expect(result == .found);
// TODO uncomment this line
try testing.expectEqualSlices(u8, result.found.key[0 .. result.found.key.len - 1], line);
try testing.expectEqual(result.found.value, valAsType(T, linei));
}
}.func;
_ = try fileEachLine(doSearch, filename, &t, null, T);
var l = Art(T).minimum(t.root);
try testing.expect(l != null);
// TODO uncomment this line
// try testing.expectEqualStrings("00026bda-e0ea-4cda-8245-522764e9f325\x00", l.?.key);
l = Art(T).maximum(t.root);
try testing.expect(l != null);
// TODO uncomment this line
// try testing.expectEqualStrings("ffffcb46-a92e-4822-82af-a7190f9c1ec5\x00", l.?.key);
try free_keys(&t);
}
}
const prefix_data = struct {
count: usize,
max_count: usize,
expected: []const []const u8,
};
const TestingError = error{ TestUnexpectedResult, TestExpectedEqual } || art.Error;
fn test_prefix_cb(n: anytype, data: *prefix_data, _: usize) TestingError!bool {
if (n.* == .leaf) {
const k = n.*.leaf.key;
try testing.expect(data.count < data.max_count);
var expected = data.expected[data.count];
expected.len += 1;
try testing.expectEqualSlices(u8, k, expected);
data.count += 1;
}
return false;
}
test "iter prefix" {
var t = Art(usize).init(tal);
defer t.deinit();
const s1 = "api.foo.bar";
const s2 = "api.foo.baz";
const s3 = "api.foe.fum";
const s4 = "abc.123.456";
const s5 = "api.foo";
const s6 = "api";
try testing.expectEqual(t.insert(s1, 0), .missing);
try testing.expectEqual(t.insert(s2, 0), .missing);
try testing.expectEqual(t.insert(s3, 0), .missing);
try testing.expectEqual(t.insert(s4, 0), .missing);
try testing.expectEqual(t.insert(s5, 0), .missing);
try testing.expectEqual(t.insert(s6, 0), .missing);
// Iterate over api
const expected = [_][]const u8{ s6, s3, s5, s1, s2 };
var p = prefix_data{ .count = 0, .max_count = 5, .expected = &expected };
try testing.expect(!try t.iterPrefix("api", test_prefix_cb, &p, TestingError!bool));
try testing.expectEqual(p.max_count, p.count);
// Iterate over 'a'
const expected2 = [_][]const u8{ s4, s6, s3, s5, s1, s2 };
var p2 = prefix_data{ .count = 0, .max_count = 6, .expected = &expected2 };
try testing.expect(!try t.iterPrefix("a", test_prefix_cb, &p2, TestingError!bool));
try testing.expectEqual(p2.max_count, p2.count);
// Check a failed iteration
var p3 = prefix_data{ .count = 0, .max_count = 6, .expected = &[_][]const u8{} };
try testing.expect(!try t.iterPrefix("b", test_prefix_cb, &p3, TestingError!bool));
try testing.expectEqual(p3.count, 0);
// Iterate over api.
const expected4 = [_][]const u8{ s3, s5, s1, s2 };
var p4 = prefix_data{ .count = 0, .max_count = 4, .expected = &expected4 };
try testing.expect(!try t.iterPrefix("api.", test_prefix_cb, &p4, TestingError!bool));
try testing.expectEqual(p4.max_count, p4.count);
// Iterate over api.foo.ba
const expected5 = [_][]const u8{s1};
var p5 = prefix_data{ .count = 0, .max_count = 1, .expected = &expected5 };
try testing.expect(!try t.iterPrefix("api.foo.bar", test_prefix_cb, &p5, TestingError!bool));
try testing.expectEqual(p5.max_count, p5.count);
// Check a failed iteration on api.end
var p6 = prefix_data{ .count = 0, .max_count = 0, .expected = &[_][]const u8{} };
try testing.expect(!try t.iterPrefix("api.end", test_prefix_cb, &p6, TestingError!bool));
try testing.expectEqual(p6.count, 0);
// Iterate over empty prefix
var p7 = prefix_data{ .count = 0, .max_count = 6, .expected = &expected2 };
try testing.expect(!try t.iterPrefix("", test_prefix_cb, &p7, TestingError!bool));
try testing.expectEqual(p7.max_count, p7.count);
}
test "insert very long key" {
var t = Art(void).init(tal);
defer t.deinit();
const key1 = [_:0]u8{
16, 0, 0, 0, 7, 10, 0, 0, 0, 2, 17, 10, 0, 0,
0, 120, 10, 0, 0, 0, 120, 10, 0, 0, 0, 216, 10, 0,
0, 0, 202, 10, 0, 0, 0, 194, 10, 0, 0, 0, 224, 10,
0, 0, 0, 230, 10, 0, 0, 0, 210, 10, 0, 0, 0, 206,
10, 0, 0, 0, 208, 10, 0, 0, 0, 232, 10, 0, 0, 0,
124, 10, 0, 0, 0, 124, 2, 16, 0, 0, 0, 2, 12, 185,
89, 44, 213, 251, 173, 202, 211, 95, 185, 89, 110, 118, 251, 173,
202, 199, 101, 0, 8, 18, 182, 92, 236, 147, 171, 101, 150, 195,
112, 185, 218, 108, 246, 139, 164, 234, 195, 58, 177, 0, 8, 16,
0, 0, 0, 2, 12, 185, 89, 44, 213, 251, 173, 202, 211, 95,
185, 89, 110, 118, 251, 173, 202, 199, 101, 0, 8, 18, 180, 93,
46, 151, 9, 212, 190, 95, 102, 178, 217, 44, 178, 235, 29, 190,
218, 8, 16, 0, 0, 0, 2, 12, 185, 89, 44, 213, 251, 173,
202, 211, 95, 185, 89, 110, 118, 251, 173, 202, 199, 101, 0, 8,
18, 180, 93, 46, 151, 9, 212, 190, 95, 102, 183, 219, 229, 214,
59, 125, 182, 71, 108, 180, 220, 238, 150, 91, 117, 150, 201, 84,
183, 128, 8, 16, 0, 0, 0, 2, 12, 185, 89, 44, 213, 251,
173, 202, 211, 95, 185, 89, 110, 118, 251, 173, 202, 199, 101, 0,
8, 18, 180, 93, 46, 151, 9, 212, 190, 95, 108, 176, 217, 47,
50, 219, 61, 134, 207, 97, 151, 88, 237, 246, 208, 8, 18, 255,
255, 255, 219, 191, 198, 134, 5, 223, 212, 72, 44, 208, 250, 180,
14, 1, 0, 0, 8, 0,
};
const key2 = [_:0]u8{
16, 0, 0, 0, 7, 10, 0, 0, 0, 2, 17, 10, 0, 0, 0,
120, 10, 0, 0, 0, 120, 10, 0, 0, 0, 216, 10, 0, 0, 0,
202, 10, 0, 0, 0, 194, 10, 0, 0, 0, 224, 10, 0, 0, 0,
230, 10, 0, 0, 0, 210, 10, 0, 0, 0, 206, 10, 0, 0, 0,
208, 10, 0, 0, 0, 232, 10, 0, 0, 0, 124, 10, 0, 0, 0,
124, 2, 16, 0, 0, 0, 2, 12, 185, 89, 44, 213, 251, 173, 202,
211, 95, 185, 89, 110, 118, 251, 173, 202, 199, 101, 0, 8, 18, 182,
92, 236, 147, 171, 101, 150, 195, 112, 185, 218, 108, 246, 139, 164, 234,
195, 58, 177, 0, 8, 16, 0, 0, 0, 2, 12, 185, 89, 44, 213,
251, 173, 202, 211, 95, 185, 89, 110, 118, 251, 173, 202, 199, 101, 0,
8, 18, 180, 93, 46, 151, 9, 212, 190, 95, 102, 178, 217, 44, 178,
235, 29, 190, 218, 8, 16, 0, 0, 0, 2, 12, 185, 89, 44, 213,
251, 173, 202, 211, 95, 185, 89, 110, 118, 251, 173, 202, 199, 101, 0,
8, 18, 180, 93, 46, 151, 9, 212, 190, 95, 102, 183, 219, 229, 214,
59, 125, 182, 71, 108, 180, 220, 238, 150, 91, 117, 150, 201, 84, 183,
128, 8, 16, 0, 0, 0, 3, 12, 185, 89, 44, 213, 251, 133, 178,
195, 105, 183, 87, 237, 150, 155, 165, 150, 229, 97, 182, 0, 8, 18,
161, 91, 239, 50, 10, 61, 150, 223, 114, 179, 217, 64, 8, 12, 186,
219, 172, 150, 91, 53, 166, 221, 101, 178, 0, 8, 18, 255, 255, 255,
219, 191, 198, 134, 5, 208, 212, 72, 44, 208, 250, 180, 14, 1, 0,
0, 8, 0,
};
try testing.expect((try t.insert(&key1, {})) == .missing);
try testing.expect((try t.insert(&key2, {})) == .missing);
_ = try t.insert(&key2, {});
try testing.expectEqual(t.size, 2);
}
test "insert search" {
inline for (ValueTypes) |T| {
var t = Art(T).init(tal);
defer t.deinit();
const filename = "./testdata/words.txt";
_ = try fileEachLine(doInsert, filename, &t, null, T);
const doSearch = struct {
fn func(line: [:0]const u8, linei: usize, _t: anytype, data: anytype, comptime _: type) anyerror!void {
_ = data;
const result = _t.search(line);
try testing.expect(result == .found);
try testing.expectEqual(result.found.value, valAsType(T, linei));
}
}.func;
_ = try fileEachLine(doSearch, filename, &t, null, T);
var l = Art(T).minimum(t.root);
try testing.expectEqualSlices(u8, l.?.key, "A\x00");
l = Art(T).maximum(t.root);
// TODO uncomment this line
// try testing.expectEqualSlices(u8, l.?.key, "<KEY>");
try free_keys(&t);
}
}
fn sizeCb(n: anytype, data: *usize, _: usize) TestingError!bool {
if (n.* == .leaf) {
data.* += 1;
}
return false;
}
test "insert search delete" {
var t = Art(usize).init(tal);
defer t.deinit();
const filename = "./testdata/words.txt";
const lines = try fileEachLine(doInsert, filename, &t, null, usize);
const doSearchDelete = struct {
fn func(line: [:0]const u8, linei: usize, _t: anytype, data: anytype, comptime _: type) anyerror!void {
const nlines = data;
const result = _t.search(line);
try testing.expect(result == .found);
try testing.expectEqual(result.found.value, linei);
const result2 = try _t.delete(line);
try testing.expect(result2 == .found);
_t.allocator.free(result2.found.key);
try testing.expectEqual(result2.found.value, linei);
const expected_size = nlines - linei;
try testing.expectEqual(expected_size, _t.size);
}
}.func;
_ = try fileEachLine(doSearchDelete, filename, &t, lines, usize);
var l = Art(usize).minimum(t.root);
try testing.expectEqual(l, null);
l = Art(usize).maximum(t.root);
try testing.expectEqual(l, null);
try free_keys(&t);
}
const letters = [_][:0]const u8{ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };
test "insert search delete 2" {
var t = Art(usize).init(tal);
defer t.deinit();
var linei: usize = 1;
for (letters) |letter| {
_ = try t.insert(letter, linei);
linei += 1;
}
{
var l = Art(usize).minimum(t.root);
try testing.expectEqualSlices(u8, l.?.key, "A\x00");
l = Art(usize).maximum(t.root);
try testing.expectEqualSlices(u8, l.?.key, "z\x00");
}
const nlines = linei - 1;
// Search for each line
linei = 1;
for (letters) |letter| {
const result = t.search(letter);
try testing.expect(result == .found);
try testing.expectEqual(result.found.value, linei);
const result2 = try t.delete(letter);
try testing.expect(result2 == .found);
try testing.expectEqual(result2.found.value, linei);
const expected_size = nlines - linei;
try testing.expectEqual(expected_size, t.size);
var iter_size: usize = 0;
_ = try t.iter(sizeCb, &iter_size, TestingError!bool);
try testing.expectEqual(expected_size, iter_size);
linei += 1;
}
var l = Art(usize).minimum(t.root);
try testing.expectEqual(l, null);
l = Art(usize).maximum(t.root);
try testing.expectEqual(l, null);
}
test "insert random delete" {
var t = Art(usize).init(tal);
defer t.deinit();
const filename = "./testdata/words.txt";
_ = try fileEachLine(doInsert, filename, &t, null, usize);
const key_to_delete = "A";
const lineno = 1;
const result = t.search(key_to_delete);
try testing.expect(result == .found);
try testing.expectEqual(result.found.value, lineno);
const result2 = try t.delete(key_to_delete);
t.allocator.free(result2.found.key);
try testing.expect(result2 == .found);
try testing.expectEqual(result2.found.value, lineno);
const result3 = t.search(key_to_delete);
try testing.expect(result3 == .missing);
try free_keys(&t);
}
fn iter_cb(n: anytype, out: *[2]u64, _: usize) TestingError!bool {
const l = n.leaf;
const line = l.value;
const mask = (line * (l.key[0] + l.key.len - 1));
out[0] += 1;
out[1] ^= mask;
return false;
}
test "insert iter" {
var t = Art(usize).init(tal);
defer t.deinit();
const filename = "./testdata/words.txt";
var xor_mask: u64 = 0;
const doInsert_ = struct {
fn func(line: [:0]const u8, linei: usize, _t: anytype, _xor_mask: anytype, comptime _: type) anyerror!void {
const line_ = try _t.allocator.dupeZ(u8, line);
const result = try _t.insert(line_, linei);
try testing.expect(result == .missing);
_xor_mask.* ^= (linei * (line[0] + line.len));
}
}.func;
const nlines = try fileEachLine(doInsert_, filename, &t, &xor_mask, usize);
var out = [1]u64{0} ** 2;
_ = try t.iter(iter_cb, &out, TestingError!bool);
try testing.expectEqual(nlines, out[0]);
try testing.expectEqual(xor_mask, out[1]);
try free_keys(&t);
}
test "max prefix len iter" {
var t = Art(usize).init(tal);
defer t.deinit();
const key1 = "foobarbaz1-test1-foo";
const key2 = "foobarbaz1-test1-bar";
const key3 = "foobarbaz1-test2-foo";
try testing.expectEqual(t.insert(key1, 1), .missing);
try testing.expectEqual(t.insert(key2, 2), .missing);
try testing.expectEqual(t.insert(key3, 3), .missing);
try testing.expectEqual(t.size, 3);
const expected = [_][]const u8{ key2, key1 };
var p = prefix_data{ .count = 0, .max_count = 2, .expected = &expected };
try testing.expect(!try t.iterPrefix("foobarbaz1-test1", test_prefix_cb, &p, TestingError!bool));
try testing.expectEqual(p.count, p.max_count);
}
const DummyStream = struct {
const Self = @This();
pub const WriteError = error{};
pub fn print(self: *Self, comptime fmt: []const u8, _: anytype) WriteError!usize {
_ = fmt;
_ = self;
return 0;
}
};
test "display children" {
testing.log_level = .debug;
const letter_ranges = [_][2]u8{ .{ 0, 4 }, .{ 0, 16 }, .{ 0, 26 }, .{ 0, letters.len } };
for (letter_ranges) |range| {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allr = &arena.allocator();
var t = Art(usize).init(allr);
defer t.deinit();
for (letters[range[0]..range[1]]) |word, i| {
var j: u8 = 0;
while (j < 10) : (j += 1) {
const nt_letter = try arena.allocator().allocSentinel(u8, word.len + j, 0);
mem.set(u8, nt_letter, word[0]);
try testing.expectEqual(t.insert(nt_letter, i), .missing);
}
}
var dummyStream = DummyStream{};
Art(usize).displayNode(&dummyStream, t.root, 0);
Art(usize).displayChildren(&dummyStream, t.root, 0);
}
}
const CustomType = struct { a: f32, b: struct { c: bool } };
const Uab = union(enum) { a, b };
const IterTypes = [_]type{ u8, u16, i32, bool, f32, f64, @Vector(10, u8), [10]u8, CustomType, Uab, [10]*u32, *u16, *isize };
fn defaultFor(comptime T: type) T {
const ti = @typeInfo(T);
return switch (ti) {
.Void => {},
.Int, .Float => 42,
.Pointer => blk: {
var x: ti.Pointer.child = 42;
var y = @as(ti.Pointer.child, x);
break :blk &y;
},
.Bool => true,
.Array => [1]ti.Array.child{defaultFor(ti.Array.child)} ** ti.Array.len,
.Vector => [1]ti.Vector.child{defaultFor(ti.Vector.child)} ** ti.Vector.len,
.Struct => switch (T) {
CustomType => .{ .a = 42, .b = .{ .c = true } },
else => @compileLog(ti),
},
.Union => switch (T) {
Uab => .a,
else => @compileLog(ti),
},
else => @compileLog(ti),
};
}
fn cb(node: anytype, data: anytype, _: usize) TestingError!bool {
_ = node;
const ti = @typeInfo(@TypeOf(data));
if (ti != .Pointer)
try testing.expectEqual(defaultFor(@TypeOf(data)), data);
return false;
}
test "iter data types" {
inline for (IterTypes) |T| {
var t = Art(usize).init(tal);
defer t.deinit();
_ = try t.insert("A", 0);
_ = try t.iter(cb, defaultFor(T), TestingError!bool);
}
}
test "print to stream" {
var list = std.ArrayList(u8).init(tal.*);
defer list.deinit();
var writer = &list.writer();
var t = Art(usize).init(tal);
defer t.deinit();
for (letters) |l| {
_ = try t.insert(l, 0);
}
try t.printToStream(writer);
}
fn bench(container: anytype, comptime appen_fn_name: []const u8, comptime get_fn_name: []const u8, comptime del_fn_name: []const u8) !void {
const filename = "./testdata/words.txt";
var timer = try std.time.Timer.start();
const doInsert_ = struct {
fn func(line: [:0]const u8, linei: usize, _container: anytype, _: anytype, comptime U: type) anyerror!void {
_ = U;
const append_fn = @field(_container, appen_fn_name);
const line_ = try _container.allocator.dupeZ(u8, line);
_ = try append_fn(line_, linei);
}
}.func;
_ = try fileEachLine(doInsert_, filename, container, null, usize);
const t1 = timer.read();
timer.reset();
const doSearch = struct {
fn func(line: [:0]const u8, linei: usize, _container: anytype, _: anytype, comptime U: type) anyerror!void {
_ = U;
_ = linei;
const get_fn = @field(_container, get_fn_name);
if (@TypeOf(_container) == *Art(usize)) {
const result = get_fn(line);
try testing.expect(result == .found);
} else {
const result = get_fn(line);
try testing.expect(result != null);
}
}
}.func;
_ = try fileEachLine(doSearch, filename, container, null, usize);
const t2 = timer.read();
timer.reset();
const doDelete = struct {
fn func(line: [:0]const u8, linei: usize, _container: anytype, _: anytype, comptime U: type) anyerror!void {
_ = U;
_ = linei;
const del_fn = @field(_container, del_fn_name);
// @compileLog(@TypeOf(_container));
if (@TypeOf(_container) == *Art(usize)) {
const result = try del_fn(line);
try testing.expect(result == .found);
} else {
const result = del_fn(line);
try testing.expect(result);
}
}
}.func;
_ = try fileEachLine(doDelete, filename, container, null, usize);
const t3 = timer.read();
warn("insert {}ms, search {}ms, delete {}ms, combined {}ms\n", .{ t1 / 1000000, t2 / 1000000, t3 / 1000000, (t1 + t2 + t3) / 1000000 });
try free_keys(container);
}
test "bench against StringHashMap" {
{
var arena = std.heap.ArenaAllocator.init(tal.*);
var aa = &arena.allocator();
var map = std.StringHashMap(usize).init(aa.*);
defer arena.deinit();
warn("\nStringHashMap\n", .{});
try bench(&map, "put", "get", "remove");
}
{
var arena = std.heap.ArenaAllocator.init(tal.*);
var aa = &arena.allocator();
var t = Art(usize).init(aa);
defer arena.deinit();
warn("\nArt\n", .{});
try bench(&t, "insert", "search", "delete");
}
}
test "fuzz" {
var t = Art(u8).init(tal);
defer t.deinit();
// generate random keys and values
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
var rnd = std.rand.DefaultPrng.init(@intCast(u64, std.time.nanoTimestamp()));
var found = std.StringHashMap(void).init(arena.allocator());
const num_keys = 100000;
var keys: [num_keys][:0]const u8 = undefined;
var i: usize = 0;
while (i < num_keys) : (i += 1) {
const klen = std.rand.Random.intRangeLessThan(rnd.random(), u8, 1, 255);
var key = try arena.allocator().allocSentinel(u8, klen, 0);
for (key) |*c|
c.* = std.rand.Random.intRangeLessThan(rnd.random(), u8, 1, 255);
keys[i] = key;
_ = try t.insert(key, klen);
}
for (keys) |key| {
const prev_found = found.get(key);
const already_deleted = prev_found == null;
const result = t.search(key);
if (result != .found and already_deleted) {
std.log.err("result != .found, already_deleted?: {}, key.len: {} key: '{s}' tree.size: {}", .{ already_deleted, key.len, key, t.size });
} else {
try found.put(key, .{});
}
if (prev_found == null) {
try testing.expect(result == .found);
try testing.expectEqual(result.found.value, @truncate(u8, key.len));
}
_ = try t.delete(key);
}
} | src/test_art.zig |
const std = @import("std");
// dross-zig
// ------------------------------------------------
// -----------------------------------------
// - Math -
// -----------------------------------------
pub const Math = struct {
/// Returns the value that is the `percentage` of the distance
/// between `start` and `end`.
pub fn lerp(start: f32, end: f32, percentage: f32) f32 {
return (1 - percentage) * start + end * percentage;
}
/// Returns the absolute value of `value`
pub fn abs(value: f32) f32 {
if (value < 0.0) return value * -1.0;
return value;
}
/// Returns the `value` clamped between `min` and `max`
pub fn clamp(value: anytype, min_value: anytype, max_value: anytype) @TypeOf(value) { //type {
const info_value = @TypeOf(value);
const info_min = @TypeOf(min_value);
const info_max = @TypeOf(max_value);
if (info_value != info_min or info_value != info_max) @compileError("[Math]: The type of value, min_value, and max_value must match to use Math.clamp!");
switch (info_value) {
i8 => {
var converted_value: i8 = value;
var converted_min: i8 = min_value;
var converted_max: i8 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
i16 => {
var converted_value: i16 = value;
var converted_min: i16 = min_value;
var converted_max: i16 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
i32 => {
var converted_value: i32 = value;
var converted_min: i32 = min_value;
var converted_max: i32 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
i64 => {
var converted_value: i64 = value;
var converted_min: i64 = min_value;
var converted_max: i64 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
i128 => {
var converted_value: i128 = value;
var converted_min: i128 = min_value;
var converted_max: i128 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
u8 => {
var converted_value: u8 = value;
var converted_min: u8 = min_value;
var converted_max: u8 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
u16 => {
var converted_value: u16 = value;
var converted_min: u16 = min_value;
var converted_max: u16 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
u32 => {
var converted_value: u32 = value;
var converted_min: u32 = min_value;
var converted_max: u32 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
u64 => {
var converted_value: u64 = value;
var converted_min: u64 = min_value;
var converted_max: u64 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
u128 => {
var converted_value: u128 = value;
var converted_min: u128 = min_value;
var converted_max: u128 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
f32 => {
var converted_value: f32 = value;
var converted_min: f32 = min_value;
var converted_max: f32 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
f64 => {
var converted_value: f64 = value;
var converted_min: f64 = min_value;
var converted_max: f64 = max_value;
return Math.min(Math.max(converted_value, converted_min), converted_max);
},
else => @compileError("[Math]: Math.clamp only supports i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, f32, and f64!"),
}
}
/// Returns the larger of the two values
pub fn max(value: anytype, other: anytype) @TypeOf(value) {
const info_value = @TypeOf(value);
const info_other = @TypeOf(other);
if (info_value != info_other) @compileError("[Math]: The type of value and other must match to use Math.max!");
switch (info_value) {
i8 => {
var converted_value: i8 = value;
var converted_other: i8 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
i16 => {
var converted_value: i16 = value;
var converted_other: i16 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
i32 => {
var converted_value: i32 = value;
var converted_other: i32 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
i64 => {
var converted_value: i64 = value;
var converted_other: i64 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
i128 => {
var converted_value: i128 = value;
var converted_other: i128 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
u8 => {
var converted_value: u8 = value;
var converted_other: u8 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
u16 => {
var converted_value: u16 = value;
var converted_other: u16 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
u32 => {
var converted_value: u32 = value;
var converted_other: u32 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
u64 => {
var converted_value: u64 = value;
var converted_other: u64 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
u128 => {
var converted_value: u128 = value;
var converted_other: u128 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
f32 => {
var converted_value: f32 = value;
var converted_other: f32 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
f64 => {
var converted_value: f64 = value;
var converted_other: f64 = other;
return if (converted_value >= converted_other) converted_value else converted_other;
},
else => @compileError("[Math]: Math.max only supports i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, f32, and f64!"),
}
}
/// Returns the smallest of the two values
pub fn min(value: anytype, other: anytype) @TypeOf(value) {
const info_value = @TypeOf(value);
const info_other = @TypeOf(other);
if (info_value != info_other) @compileError("[Math]: The type of value and other must match to use Math.min!");
switch (info_value) {
i8 => {
var converted_value: i8 = value;
var converted_other: i8 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
i16 => {
var converted_value: i16 = value;
var converted_other: i16 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
i32 => {
var converted_value: i32 = value;
var converted_other: i32 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
i64 => {
var converted_value: i64 = value;
var converted_other: i64 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
i128 => {
var converted_value: i128 = value;
var converted_other: i128 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
u8 => {
var converted_value: u8 = value;
var converted_other: u8 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
u16 => {
var converted_value: u16 = value;
var converted_other: u16 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
u32 => {
var converted_value: u32 = value;
var converted_other: u32 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
u64 => {
var converted_value: u64 = value;
var converted_other: u64 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
u128 => {
var converted_value: u128 = value;
var converted_other: u128 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
f32 => {
var converted_value: f32 = value;
var converted_other: f32 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
f64 => {
var converted_value: f64 = value;
var converted_other: f64 = other;
return if (converted_value <= converted_other) converted_value else converted_other;
},
else => @compileError("[Math]: Math.min only supports i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, f32, and f64!"),
}
}
};
test "min and max" {
const test_i8_one: i8 = 2;
const test_i8_two: i8 = 5;
std.testing.expect(Math.min(test_i8_one, test_i8_two) == 2);
std.testing.expect(Math.min(test_i8_two, test_i8_one) == 2);
std.testing.expect(Math.max(test_i8_one, test_i8_two) == 5);
std.testing.expect(Math.max(test_i8_two, test_i8_one) == 5);
}
test "clamp" {
const value: i8 = 2;
const min_value: i8 = -1;
const max_value: i8 = 3;
std.testing.expect(Math.clamp(value, min_value, max_value) == @intCast(i8, 2));
std.testing.expect(Math.clamp(value + @intCast(i8, 2), min_value, max_value) == max_value);
std.testing.expect(Math.clamp(value - @intCast(i8, 6), min_value, max_value) == min_value);
} | src/math/math.zig |
//--------------------------------------------------------------------------------
// Section: Types (13)
//--------------------------------------------------------------------------------
const CLSID_WSCProductList_Value = @import("../zig.zig").Guid.initString("17072f7b-9abe-4a74-a261-1eb76b55107a");
pub const CLSID_WSCProductList = &CLSID_WSCProductList_Value;
const CLSID_WSCDefaultProduct_Value = @import("../zig.zig").Guid.initString("2981a36e-f22d-11e5-9ce9-5e5517507c66");
pub const CLSID_WSCDefaultProduct = &CLSID_WSCDefaultProduct_Value;
pub const WSC_SECURITY_PRODUCT_SUBSTATUS = enum(i32) {
NOT_SET = 0,
NO_ACTION = 1,
ACTION_RECOMMENDED = 2,
ACTION_NEEDED = 3,
};
pub const WSC_SECURITY_PRODUCT_SUBSTATUS_NOT_SET = WSC_SECURITY_PRODUCT_SUBSTATUS.NOT_SET;
pub const WSC_SECURITY_PRODUCT_SUBSTATUS_NO_ACTION = WSC_SECURITY_PRODUCT_SUBSTATUS.NO_ACTION;
pub const WSC_SECURITY_PRODUCT_SUBSTATUS_ACTION_RECOMMENDED = WSC_SECURITY_PRODUCT_SUBSTATUS.ACTION_RECOMMENDED;
pub const WSC_SECURITY_PRODUCT_SUBSTATUS_ACTION_NEEDED = WSC_SECURITY_PRODUCT_SUBSTATUS.ACTION_NEEDED;
pub const WSC_SECURITY_PRODUCT_STATE = enum(i32) {
ON = 0,
OFF = 1,
SNOOZED = 2,
EXPIRED = 3,
};
pub const WSC_SECURITY_PRODUCT_STATE_ON = WSC_SECURITY_PRODUCT_STATE.ON;
pub const WSC_SECURITY_PRODUCT_STATE_OFF = WSC_SECURITY_PRODUCT_STATE.OFF;
pub const WSC_SECURITY_PRODUCT_STATE_SNOOZED = WSC_SECURITY_PRODUCT_STATE.SNOOZED;
pub const WSC_SECURITY_PRODUCT_STATE_EXPIRED = WSC_SECURITY_PRODUCT_STATE.EXPIRED;
pub const SECURITY_PRODUCT_TYPE = enum(i32) {
ANTIVIRUS = 0,
FIREWALL = 1,
ANTISPYWARE = 2,
};
pub const SECURITY_PRODUCT_TYPE_ANTIVIRUS = SECURITY_PRODUCT_TYPE.ANTIVIRUS;
pub const SECURITY_PRODUCT_TYPE_FIREWALL = SECURITY_PRODUCT_TYPE.FIREWALL;
pub const SECURITY_PRODUCT_TYPE_ANTISPYWARE = SECURITY_PRODUCT_TYPE.ANTISPYWARE;
pub const WSC_SECURITY_SIGNATURE_STATUS = enum(i32) {
OUT_OF_DATE = 0,
UP_TO_DATE = 1,
};
pub const WSC_SECURITY_PRODUCT_OUT_OF_DATE = WSC_SECURITY_SIGNATURE_STATUS.OUT_OF_DATE;
pub const WSC_SECURITY_PRODUCT_UP_TO_DATE = WSC_SECURITY_SIGNATURE_STATUS.UP_TO_DATE;
// TODO: this type is limited to platform 'windows8.0'
const IID_IWscProduct_Value = @import("../zig.zig").Guid.initString("8c38232e-3a45-4a27-92b0-1a16a975f669");
pub const IID_IWscProduct = &IID_IWscProduct_Value;
pub const IWscProduct = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ProductName: fn(
self: *const IWscProduct,
pVal: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ProductState: fn(
self: *const IWscProduct,
pVal: ?*WSC_SECURITY_PRODUCT_STATE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_SignatureStatus: fn(
self: *const IWscProduct,
pVal: ?*WSC_SECURITY_SIGNATURE_STATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_RemediationPath: fn(
self: *const IWscProduct,
pVal: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ProductStateTimestamp: fn(
self: *const IWscProduct,
pVal: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ProductGuid: fn(
self: *const IWscProduct,
pVal: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ProductIsDefault: fn(
self: *const IWscProduct,
pVal: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct_get_ProductName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct.VTable, self.vtable).get_ProductName(@ptrCast(*const IWscProduct, self), pVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct_get_ProductState(self: *const T, pVal: ?*WSC_SECURITY_PRODUCT_STATE) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct.VTable, self.vtable).get_ProductState(@ptrCast(*const IWscProduct, self), pVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct_get_SignatureStatus(self: *const T, pVal: ?*WSC_SECURITY_SIGNATURE_STATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct.VTable, self.vtable).get_SignatureStatus(@ptrCast(*const IWscProduct, self), pVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct_get_RemediationPath(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct.VTable, self.vtable).get_RemediationPath(@ptrCast(*const IWscProduct, self), pVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct_get_ProductStateTimestamp(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct.VTable, self.vtable).get_ProductStateTimestamp(@ptrCast(*const IWscProduct, self), pVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct_get_ProductGuid(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct.VTable, self.vtable).get_ProductGuid(@ptrCast(*const IWscProduct, self), pVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct_get_ProductIsDefault(self: *const T, pVal: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct.VTable, self.vtable).get_ProductIsDefault(@ptrCast(*const IWscProduct, self), pVal);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWscProduct2_Value = @import("../zig.zig").Guid.initString("f896ca54-fe09-4403-86d4-23cb488d81d8");
pub const IID_IWscProduct2 = &IID_IWscProduct2_Value;
pub const IWscProduct2 = extern struct {
pub const VTable = extern struct {
base: IWscProduct.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AntivirusScanSubstatus: fn(
self: *const IWscProduct2,
peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AntivirusSettingsSubstatus: fn(
self: *const IWscProduct2,
peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AntivirusProtectionUpdateSubstatus: fn(
self: *const IWscProduct2,
peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_FirewallDomainProfileSubstatus: fn(
self: *const IWscProduct2,
peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_FirewallPrivateProfileSubstatus: fn(
self: *const IWscProduct2,
peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_FirewallPublicProfileSubstatus: fn(
self: *const IWscProduct2,
peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWscProduct.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct2_get_AntivirusScanSubstatus(self: *const T, peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct2.VTable, self.vtable).get_AntivirusScanSubstatus(@ptrCast(*const IWscProduct2, self), peStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct2_get_AntivirusSettingsSubstatus(self: *const T, peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct2.VTable, self.vtable).get_AntivirusSettingsSubstatus(@ptrCast(*const IWscProduct2, self), peStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct2_get_AntivirusProtectionUpdateSubstatus(self: *const T, peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct2.VTable, self.vtable).get_AntivirusProtectionUpdateSubstatus(@ptrCast(*const IWscProduct2, self), peStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct2_get_FirewallDomainProfileSubstatus(self: *const T, peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct2.VTable, self.vtable).get_FirewallDomainProfileSubstatus(@ptrCast(*const IWscProduct2, self), peStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct2_get_FirewallPrivateProfileSubstatus(self: *const T, peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct2.VTable, self.vtable).get_FirewallPrivateProfileSubstatus(@ptrCast(*const IWscProduct2, self), peStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct2_get_FirewallPublicProfileSubstatus(self: *const T, peStatus: ?*WSC_SECURITY_PRODUCT_SUBSTATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct2.VTable, self.vtable).get_FirewallPublicProfileSubstatus(@ptrCast(*const IWscProduct2, self), peStatus);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWscProduct3_Value = @import("../zig.zig").Guid.initString("55536524-d1d1-4726-8c7c-04996a1904e7");
pub const IID_IWscProduct3 = &IID_IWscProduct3_Value;
pub const IWscProduct3 = extern struct {
pub const VTable = extern struct {
base: IWscProduct2.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AntivirusDaysUntilExpired: fn(
self: *const IWscProduct3,
pdwDays: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWscProduct2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWscProduct3_get_AntivirusDaysUntilExpired(self: *const T, pdwDays: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWscProduct3.VTable, self.vtable).get_AntivirusDaysUntilExpired(@ptrCast(*const IWscProduct3, self), pdwDays);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IWSCProductList_Value = @import("../zig.zig").Guid.initString("722a338c-6e8e-4e72-ac27-1417fb0c81c2");
pub const IID_IWSCProductList = &IID_IWSCProductList_Value;
pub const IWSCProductList = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
Initialize: fn(
self: *const IWSCProductList,
provider: WSC_SECURITY_PROVIDER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const IWSCProductList,
pVal: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Item: fn(
self: *const IWSCProductList,
index: u32,
pVal: ?*?*IWscProduct,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWSCProductList_Initialize(self: *const T, provider: WSC_SECURITY_PROVIDER) callconv(.Inline) HRESULT {
return @ptrCast(*const IWSCProductList.VTable, self.vtable).Initialize(@ptrCast(*const IWSCProductList, self), provider);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWSCProductList_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWSCProductList.VTable, self.vtable).get_Count(@ptrCast(*const IWSCProductList, self), pVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWSCProductList_get_Item(self: *const T, index: u32, pVal: ?*?*IWscProduct) callconv(.Inline) HRESULT {
return @ptrCast(*const IWSCProductList.VTable, self.vtable).get_Item(@ptrCast(*const IWSCProductList, self), index, pVal);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWSCDefaultProduct_Value = @import("../zig.zig").Guid.initString("0476d69c-f21a-11e5-9ce9-5e5517507c66");
pub const IID_IWSCDefaultProduct = &IID_IWSCDefaultProduct_Value;
pub const IWSCDefaultProduct = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
SetDefaultProduct: fn(
self: *const IWSCDefaultProduct,
eType: SECURITY_PRODUCT_TYPE,
pGuid: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWSCDefaultProduct_SetDefaultProduct(self: *const T, eType: SECURITY_PRODUCT_TYPE, pGuid: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWSCDefaultProduct.VTable, self.vtable).SetDefaultProduct(@ptrCast(*const IWSCDefaultProduct, self), eType, pGuid);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WSC_SECURITY_PROVIDER = enum(i32) {
FIREWALL = 1,
AUTOUPDATE_SETTINGS = 2,
ANTIVIRUS = 4,
ANTISPYWARE = 8,
INTERNET_SETTINGS = 16,
USER_ACCOUNT_CONTROL = 32,
SERVICE = 64,
NONE = 0,
ALL = 127,
};
pub const WSC_SECURITY_PROVIDER_FIREWALL = WSC_SECURITY_PROVIDER.FIREWALL;
pub const WSC_SECURITY_PROVIDER_AUTOUPDATE_SETTINGS = WSC_SECURITY_PROVIDER.AUTOUPDATE_SETTINGS;
pub const WSC_SECURITY_PROVIDER_ANTIVIRUS = WSC_SECURITY_PROVIDER.ANTIVIRUS;
pub const WSC_SECURITY_PROVIDER_ANTISPYWARE = WSC_SECURITY_PROVIDER.ANTISPYWARE;
pub const WSC_SECURITY_PROVIDER_INTERNET_SETTINGS = WSC_SECURITY_PROVIDER.INTERNET_SETTINGS;
pub const WSC_SECURITY_PROVIDER_USER_ACCOUNT_CONTROL = WSC_SECURITY_PROVIDER.USER_ACCOUNT_CONTROL;
pub const WSC_SECURITY_PROVIDER_SERVICE = WSC_SECURITY_PROVIDER.SERVICE;
pub const WSC_SECURITY_PROVIDER_NONE = WSC_SECURITY_PROVIDER.NONE;
pub const WSC_SECURITY_PROVIDER_ALL = WSC_SECURITY_PROVIDER.ALL;
pub const WSC_SECURITY_PROVIDER_HEALTH = enum(i32) {
GOOD = 0,
NOTMONITORED = 1,
POOR = 2,
SNOOZE = 3,
};
pub const WSC_SECURITY_PROVIDER_HEALTH_GOOD = WSC_SECURITY_PROVIDER_HEALTH.GOOD;
pub const WSC_SECURITY_PROVIDER_HEALTH_NOTMONITORED = WSC_SECURITY_PROVIDER_HEALTH.NOTMONITORED;
pub const WSC_SECURITY_PROVIDER_HEALTH_POOR = WSC_SECURITY_PROVIDER_HEALTH.POOR;
pub const WSC_SECURITY_PROVIDER_HEALTH_SNOOZE = WSC_SECURITY_PROVIDER_HEALTH.SNOOZE;
//--------------------------------------------------------------------------------
// Section: Functions (6)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WSCAPI" fn WscRegisterForChanges(
Reserved: ?*anyopaque,
phCallbackRegistration: ?*?HANDLE,
lpCallbackAddress: ?LPTHREAD_START_ROUTINE,
pContext: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WSCAPI" fn WscUnRegisterChanges(
hRegistrationHandle: ?HANDLE,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "WSCAPI" fn WscRegisterForUserNotifications(
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WSCAPI" fn WscGetSecurityProviderHealth(
Providers: u32,
pHealth: ?*WSC_SECURITY_PROVIDER_HEALTH,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "WSCAPI" fn WscQueryAntiMalwareUri(
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "WSCAPI" fn WscGetAntiMalwareUri(
ppszUri: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (7)
//--------------------------------------------------------------------------------
const BOOL = @import("../foundation.zig").BOOL;
const BSTR = @import("../foundation.zig").BSTR;
const HANDLE = @import("../foundation.zig").HANDLE;
const HRESULT = @import("../foundation.zig").HRESULT;
const IDispatch = @import("../system/com.zig").IDispatch;
const LPTHREAD_START_ROUTINE = @import("../system/threading.zig").LPTHREAD_START_ROUTINE;
const PWSTR = @import("../foundation.zig").PWSTR;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/system/security_center.zig |
pub const Key = enum {
Key_a,
Key_b,
Key_c,
Key_d,
Key_e,
Key_f,
Key_g,
Key_h,
Key_i,
Key_j,
Key_k,
Key_l,
Key_m,
Key_n,
Key_o,
Key_p,
Key_q,
Key_r,
Key_s,
Key_t,
Key_u,
Key_v,
Key_w,
Key_x,
Key_y,
Key_z,
Key_A,
Key_B,
Key_C,
Key_D,
Key_E,
Key_F,
Key_G,
Key_H,
Key_I,
Key_J,
Key_K,
Key_L,
Key_M,
Key_N,
Key_O,
Key_P,
Key_Q,
Key_R,
Key_S,
Key_T,
Key_U,
Key_V,
Key_W,
Key_X,
Key_Y,
Key_Z,
Key_0,
Key_1,
Key_2,
Key_3,
Key_4,
Key_5,
Key_6,
Key_7,
Key_8,
Key_9,
Key_Keypad0,
Key_Keypad1,
Key_Keypad2,
Key_Keypad3,
Key_Keypad4,
Key_Keypad5,
Key_Keypad6,
Key_Keypad7,
Key_Keypad8,
Key_Keypad9,
Key_Enter,
Key_KeypadEnter,
Key_Tab,
Key_Backspace,
Key_Space,
Key_Slash,
Key_KeypadSlash,
Key_Backslash,
Key_Period,
Key_KeypadPeriod,
Key_Question,
Key_Exclamation,
Key_Comma,
Key_Colon,
Key_SemiColon,
Key_BackTick,
Key_SingleQuote,
Key_DoubleQuote,
Key_Asterisk,
Key_KeypadAsterisk,
Key_At,
Key_Ampersand,
Key_Percent,
Key_Caret,
Key_Pipe,
Key_Tilde,
Key_Underscore,
Key_Pound,
Key_Dollar,
Key_Plus,
Key_KeypadPlus,
Key_Minus,
Key_KeypadMinus,
Key_Equals,
Key_GreaterThan,
Key_LessThan,
Key_LeftBrace,
Key_RightBrace,
Key_LeftSquareBracket,
Key_RightSquareBracket,
Key_LeftParentheses,
Key_RightParentheses,
Key_Escape,
Key_LeftShift,
Key_RightShift,
Key_LeftAlt,
Key_RightAlt,
Key_LeftControl,
Key_RightControl,
Key_CapsLock,
Key_NumberLock,
Key_ScrollLock,
Key_F1,
Key_F2,
Key_F3,
Key_F4,
Key_F5,
Key_F6,
Key_F7,
Key_F8,
Key_F9,
Key_F10,
Key_F11,
Key_F12,
Key_CursorLeft,
Key_CursorRight,
Key_CursorUp,
Key_CursorDown,
Key_PageUp,
Key_PageDown,
Key_AcpiPower,
Key_AcpiSleep,
Key_AcpiWake,
Key_Home,
Key_End,
Key_Insert,
Key_Delete,
Key_PrintScreen,
Key_Pause,
}; | libs/georgios/keys.zig |
pub const EPERM = 1; // Operation not permitted
pub const ENOENT = 2; // No such file or directory
pub const ESRCH = 3; // No such process
pub const EINTR = 4; // Interrupted system call
pub const EIO = 5; // Input/output error
pub const ENXIO = 6; // Device not configured
pub const E2BIG = 7; // Argument list too long
pub const ENOEXEC = 8; // Exec format error
pub const EBADF = 9; // Bad file descriptor
pub const ECHILD = 10; // No child processes
pub const EDEADLK = 11; // Resource deadlock avoided
// 11 was EAGAIN
pub const ENOMEM = 12; // Cannot allocate memory
pub const EACCES = 13; // Permission denied
pub const EFAULT = 14; // Bad address
pub const ENOTBLK = 15; // Block device required
pub const EBUSY = 16; // Device busy
pub const EEXIST = 17; // File exists
pub const EXDEV = 18; // Cross-device link
pub const ENODEV = 19; // Operation not supported by device
pub const ENOTDIR = 20; // Not a directory
pub const EISDIR = 21; // Is a directory
pub const EINVAL = 22; // Invalid argument
pub const ENFILE = 23; // Too many open files in system
pub const EMFILE = 24; // Too many open files
pub const ENOTTY = 25; // Inappropriate ioctl for device
pub const ETXTBSY = 26; // Text file busy
pub const EFBIG = 27; // File too large
pub const ENOSPC = 28; // No space left on device
pub const ESPIPE = 29; // Illegal seek
pub const EROFS = 30; // Read-only filesystem
pub const EMLINK = 31; // Too many links
pub const EPIPE = 32; // Broken pipe
// math software
pub const EDOM = 33; // Numerical argument out of domain
pub const ERANGE = 34; // Result too large
// non-blocking and interrupt i/o
pub const EAGAIN = 35; // Resource temporarily unavailable
pub const EWOULDBLOCK = EAGAIN; // Operation would block
pub const EINPROGRESS = 36; // Operation now in progress
pub const EALREADY = 37; // Operation already in progress
// ipc/network software -- argument errors
pub const ENOTSOCK = 38; // Socket operation on non-socket
pub const EDESTADDRREQ = 39; // Destination address required
pub const EMSGSIZE = 40; // Message too long
pub const EPROTOTYPE = 41; // Protocol wrong type for socket
pub const ENOPROTOOPT = 42; // Protocol not available
pub const EPROTONOSUPPORT = 43; // Protocol not supported
pub const ESOCKTNOSUPPORT = 44; // Socket type not supported
pub const EOPNOTSUPP = 45; // Operation not supported
pub const ENOTSUP = EOPNOTSUPP; // Operation not supported
pub const EPFNOSUPPORT = 46; // Protocol family not supported
pub const EAFNOSUPPORT = 47; // Address family not supported by protocol family
pub const EADDRINUSE = 48; // Address already in use
pub const EADDRNOTAVAIL = 49; // Can't assign requested address
// ipc/network software -- operational errors
pub const ENETDOWN = 50; // Network is down
pub const ENETUNREACH = 51; // Network is unreachable
pub const ENETRESET = 52; // Network dropped connection on reset
pub const ECONNABORTED = 53; // Software caused connection abort
pub const ECONNRESET = 54; // Connection reset by peer
pub const ENOBUFS = 55; // No buffer space available
pub const EISCONN = 56; // Socket is already connected
pub const ENOTCONN = 57; // Socket is not connected
pub const ESHUTDOWN = 58; // Can't send after socket shutdown
pub const ETOOMANYREFS = 59; // Too many references: can't splice
pub const ETIMEDOUT = 60; // Operation timed out
pub const ECONNREFUSED = 61; // Connection refused
pub const ELOOP = 62; // Too many levels of symbolic links
pub const ENAMETOOLONG = 63; // File name too long
// should be rearranged
pub const EHOSTDOWN = 64; // Host is down
pub const EHOSTUNREACH = 65; // No route to host
pub const ENOTEMPTY = 66; // Directory not empty
// quotas & mush
pub const EPROCLIM = 67; // Too many processes
pub const EUSERS = 68; // Too many users
pub const EDQUOT = 69; // Disc quota exceeded
// Network File System
pub const ESTALE = 70; // Stale NFS file handle
pub const EREMOTE = 71; // Too many levels of remote in path
pub const EBADRPC = 72; // RPC struct is bad
pub const ERPCMISMATCH = 73; // RPC version wrong
pub const EPROGUNAVAIL = 74; // RPC prog. not avail
pub const EPROGMISMATCH = 75; // Program version wrong
pub const EPROCUNAVAIL = 76; // Bad procedure for program
pub const ENOLCK = 77; // No locks available
pub const ENOSYS = 78; // Function not implemented
pub const EFTYPE = 79; // Inappropriate file type or format
pub const EAUTH = 80; // Authentication error
pub const ENEEDAUTH = 81; // Need authenticator
pub const EIDRM = 82; // Identifier removed
pub const ENOMSG = 83; // No message of desired type
pub const EOVERFLOW = 84; // Value too large to be stored in data type
pub const ECANCELED = 85; // Operation canceled
pub const EILSEQ = 86; // Illegal byte sequence
pub const ENOATTR = 87; // Attribute not found
pub const EDOOFUS = 88; // Programming error
pub const EBADMSG = 89; // Bad message
pub const EMULTIHOP = 90; // Multihop attempted
pub const ENOLINK = 91; // Link has been severed
pub const EPROTO = 92; // Protocol error
pub const ENOTCAPABLE = 93; // Capabilities insufficient
pub const ECAPMODE = 94; // Not permitted in capability mode
pub const ENOTRECOVERABLE = 95; // State not recoverable
pub const EOWNERDEAD = 96; // Previous owner died
pub const ELAST = 96; // Must be equal largest errno | std/os/freebsd/errno.zig |
const std = @import("std.zig");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
pub const Error = error{
InvalidCharacter,
InvalidPadding,
NoSpaceLeft,
};
/// Base64 codecs
pub const Codecs = struct {
alphabet_chars: [64]u8,
pad_char: ?u8,
decoderWithIgnore: fn (ignore: []const u8) Base64DecoderWithIgnore,
Encoder: Base64Encoder,
Decoder: Base64Decoder,
};
pub const standard_alphabet_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".*;
fn standardBase64DecoderWithIgnore(ignore: []const u8) Base64DecoderWithIgnore {
return Base64DecoderWithIgnore.init(standard_alphabet_chars, '=', ignore);
}
/// Standard Base64 codecs, with padding
pub const standard = Codecs{
.alphabet_chars = standard_alphabet_chars,
.pad_char = '=',
.decoderWithIgnore = standardBase64DecoderWithIgnore,
.Encoder = Base64Encoder.init(standard_alphabet_chars, '='),
.Decoder = Base64Decoder.init(standard_alphabet_chars, '='),
};
/// Standard Base64 codecs, without padding
pub const standard_no_pad = Codecs{
.alphabet_chars = standard_alphabet_chars,
.pad_char = null,
.decoderWithIgnore = standardBase64DecoderWithIgnore,
.Encoder = Base64Encoder.init(standard_alphabet_chars, null),
.Decoder = Base64Decoder.init(standard_alphabet_chars, null),
};
pub const url_safe_alphabet_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".*;
fn urlSafeBase64DecoderWithIgnore(ignore: []const u8) Base64DecoderWithIgnore {
return Base64DecoderWithIgnore.init(url_safe_alphabet_chars, null, ignore);
}
/// URL-safe Base64 codecs, with padding
pub const url_safe = Codecs{
.alphabet_chars = url_safe_alphabet_chars,
.pad_char = '=',
.decoderWithIgnore = urlSafeBase64DecoderWithIgnore,
.Encoder = Base64Encoder.init(url_safe_alphabet_chars, '='),
.Decoder = Base64Decoder.init(url_safe_alphabet_chars, '='),
};
/// URL-safe Base64 codecs, without padding
pub const url_safe_no_pad = Codecs{
.alphabet_chars = url_safe_alphabet_chars,
.pad_char = null,
.decoderWithIgnore = urlSafeBase64DecoderWithIgnore,
.Encoder = Base64Encoder.init(url_safe_alphabet_chars, null),
.Decoder = Base64Decoder.init(url_safe_alphabet_chars, null),
};
// Backwards compatibility
/// Deprecated - Use `standard.pad_char`
pub const standard_pad_char = standard.pad_char;
/// Deprecated - Use `standard.Encoder`
pub const standard_encoder = standard.Encoder;
/// Deprecated - Use `standard.Decoder`
pub const standard_decoder = standard.Decoder;
pub const Base64Encoder = struct {
alphabet_chars: [64]u8,
pad_char: ?u8,
/// A bunch of assertions, then simply pass the data right through.
pub fn init(alphabet_chars: [64]u8, pad_char: ?u8) Base64Encoder {
assert(alphabet_chars.len == 64);
var char_in_alphabet = [_]bool{false} ** 256;
for (alphabet_chars) |c| {
assert(!char_in_alphabet[c]);
assert(pad_char == null or c != pad_char.?);
char_in_alphabet[c] = true;
}
return Base64Encoder{
.alphabet_chars = alphabet_chars,
.pad_char = pad_char,
};
}
/// Compute the encoded length
pub fn calcSize(encoder: *const Base64Encoder, source_len: usize) usize {
if (encoder.pad_char != null) {
return @divTrunc(source_len + 2, 3) * 4;
} else {
const leftover = source_len % 3;
return @divTrunc(source_len, 3) * 4 + @divTrunc(leftover * 4 + 2, 3);
}
}
/// dest.len must at least be what you get from ::calcSize.
pub fn encode(encoder: *const Base64Encoder, dest: []u8, source: []const u8) []const u8 {
const out_len = encoder.calcSize(source.len);
assert(dest.len >= out_len);
const nibbles = source.len / 3;
const leftover = source.len - 3 * nibbles;
var acc: u12 = 0;
var acc_len: u4 = 0;
var out_idx: usize = 0;
for (source) |v| {
acc = (acc << 8) + v;
acc_len += 8;
while (acc_len >= 6) {
acc_len -= 6;
dest[out_idx] = encoder.alphabet_chars[@truncate(u6, (acc >> acc_len))];
out_idx += 1;
}
}
if (acc_len > 0) {
dest[out_idx] = encoder.alphabet_chars[@truncate(u6, (acc << 6 - acc_len))];
out_idx += 1;
}
if (encoder.pad_char) |pad_char| {
for (dest[out_idx..]) |*pad| {
pad.* = pad_char;
}
}
return dest[0..out_len];
}
};
pub const Base64Decoder = struct {
const invalid_char: u8 = 0xff;
/// e.g. 'A' => 0.
/// `invalid_char` for any value not in the 64 alphabet chars.
char_to_index: [256]u8,
pad_char: ?u8,
pub fn init(alphabet_chars: [64]u8, pad_char: ?u8) Base64Decoder {
var result = Base64Decoder{
.char_to_index = [_]u8{invalid_char} ** 256,
.pad_char = pad_char,
};
var char_in_alphabet = [_]bool{false} ** 256;
for (alphabet_chars) |c, i| {
assert(!char_in_alphabet[c]);
assert(pad_char == null or c != pad_char.?);
result.char_to_index[c] = @intCast(u8, i);
char_in_alphabet[c] = true;
}
return result;
}
/// Return the maximum possible decoded size for a given input length - The actual length may be less if the input includes padding.
/// `InvalidPadding` is returned if the input length is not valid.
pub fn calcSizeUpperBound(decoder: *const Base64Decoder, source_len: usize) Error!usize {
var result = source_len / 4 * 3;
const leftover = source_len % 4;
if (decoder.pad_char != null) {
if (leftover % 4 != 0) return error.InvalidPadding;
} else {
if (leftover % 4 == 1) return error.InvalidPadding;
result += leftover * 3 / 4;
}
return result;
}
/// Return the exact decoded size for a slice.
/// `InvalidPadding` is returned if the input length is not valid.
pub fn calcSizeForSlice(decoder: *const Base64Decoder, source: []const u8) Error!usize {
const source_len = source.len;
var result = try decoder.calcSizeUpperBound(source_len);
if (decoder.pad_char) |pad_char| {
if (source_len >= 1 and source[source_len - 1] == pad_char) result -= 1;
if (source_len >= 2 and source[source_len - 2] == pad_char) result -= 1;
}
return result;
}
/// dest.len must be what you get from ::calcSize.
/// invalid characters result in error.InvalidCharacter.
/// invalid padding results in error.InvalidPadding.
pub fn decode(decoder: *const Base64Decoder, dest: []u8, source: []const u8) Error!void {
if (decoder.pad_char != null and source.len % 4 != 0) return error.InvalidPadding;
var acc: u12 = 0;
var acc_len: u4 = 0;
var dest_idx: usize = 0;
var leftover_idx: ?usize = null;
for (source) |c, src_idx| {
const d = decoder.char_to_index[c];
if (d == invalid_char) {
if (decoder.pad_char == null or c != decoder.pad_char.?) return error.InvalidCharacter;
leftover_idx = src_idx;
break;
}
acc = (acc << 6) + d;
acc_len += 6;
if (acc_len >= 8) {
acc_len -= 8;
dest[dest_idx] = @truncate(u8, acc >> acc_len);
dest_idx += 1;
}
}
if (acc_len > 4 or (acc & (@as(u12, 1) << acc_len) - 1) != 0) {
return error.InvalidPadding;
}
if (leftover_idx == null) return;
var leftover = source[leftover_idx.?..];
if (decoder.pad_char) |pad_char| {
const padding_len = acc_len / 2;
var padding_chars: usize = 0;
var i: usize = 0;
for (leftover) |c| {
if (c != pad_char) {
return if (c == Base64Decoder.invalid_char) error.InvalidCharacter else error.InvalidPadding;
}
padding_chars += 1;
}
if (padding_chars != padding_len) return error.InvalidPadding;
}
}
};
pub const Base64DecoderWithIgnore = struct {
decoder: Base64Decoder,
char_is_ignored: [256]bool,
pub fn init(alphabet_chars: [64]u8, pad_char: ?u8, ignore_chars: []const u8) Base64DecoderWithIgnore {
var result = Base64DecoderWithIgnore{
.decoder = Base64Decoder.init(alphabet_chars, pad_char),
.char_is_ignored = [_]bool{false} ** 256,
};
for (ignore_chars) |c| {
assert(result.decoder.char_to_index[c] == Base64Decoder.invalid_char);
assert(!result.char_is_ignored[c]);
assert(result.decoder.pad_char != c);
result.char_is_ignored[c] = true;
}
return result;
}
/// Return the maximum possible decoded size for a given input length - The actual length may be less if the input includes padding
/// `InvalidPadding` is returned if the input length is not valid.
pub fn calcSizeUpperBound(decoder_with_ignore: *const Base64DecoderWithIgnore, source_len: usize) Error!usize {
var result = source_len / 4 * 3;
if (decoder_with_ignore.decoder.pad_char == null) {
const leftover = source_len % 4;
result += leftover * 3 / 4;
}
return result;
}
/// Invalid characters that are not ignored result in error.InvalidCharacter.
/// Invalid padding results in error.InvalidPadding.
/// Decoding more data than can fit in dest results in error.NoSpaceLeft. See also ::calcSizeUpperBound.
/// Returns the number of bytes written to dest.
pub fn decode(decoder_with_ignore: *const Base64DecoderWithIgnore, dest: []u8, source: []const u8) Error!usize {
const decoder = &decoder_with_ignore.decoder;
var acc: u12 = 0;
var acc_len: u4 = 0;
var dest_idx: usize = 0;
var leftover_idx: ?usize = null;
for (source) |c, src_idx| {
if (decoder_with_ignore.char_is_ignored[c]) continue;
const d = decoder.char_to_index[c];
if (d == Base64Decoder.invalid_char) {
if (decoder.pad_char == null or c != decoder.pad_char.?) return error.InvalidCharacter;
leftover_idx = src_idx;
break;
}
acc = (acc << 6) + d;
acc_len += 6;
if (acc_len >= 8) {
if (dest_idx == dest.len) return error.NoSpaceLeft;
acc_len -= 8;
dest[dest_idx] = @truncate(u8, acc >> acc_len);
dest_idx += 1;
}
}
if (acc_len > 4 or (acc & (@as(u12, 1) << acc_len) - 1) != 0) {
return error.InvalidPadding;
}
const padding_len = acc_len / 2;
if (leftover_idx == null) {
if (decoder.pad_char != null and padding_len != 0) return error.InvalidPadding;
return dest_idx;
}
var leftover = source[leftover_idx.?..];
if (decoder.pad_char) |pad_char| {
var padding_chars: usize = 0;
var i: usize = 0;
for (leftover) |c| {
if (decoder_with_ignore.char_is_ignored[c]) continue;
if (c != pad_char) {
return if (c == Base64Decoder.invalid_char) error.InvalidCharacter else error.InvalidPadding;
}
padding_chars += 1;
}
if (padding_chars != padding_len) return error.InvalidPadding;
}
return dest_idx;
}
};
test "base64" {
@setEvalBranchQuota(8000);
testBase64() catch unreachable;
comptime testAllApis(standard, "comptime", "Y29tcHRpbWU=") catch unreachable;
}
test "base64 url_safe_no_pad" {
@setEvalBranchQuota(8000);
testBase64UrlSafeNoPad() catch unreachable;
comptime testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU") catch unreachable;
}
fn testBase64() !void {
const codecs = standard;
try testAllApis(codecs, "", "");
try testAllApis(codecs, "f", "Zg==");
try testAllApis(codecs, "fo", "Zm8=");
try testAllApis(codecs, "foo", "Zm9v");
try testAllApis(codecs, "foob", "Zm9vYg==");
try testAllApis(codecs, "fooba", "Zm9vYmE=");
try testAllApis(codecs, "foobar", "Zm9vYmFy");
try testDecodeIgnoreSpace(codecs, "", " ");
try testDecodeIgnoreSpace(codecs, "f", "Z g= =");
try testDecodeIgnoreSpace(codecs, "fo", " Zm8=");
try testDecodeIgnoreSpace(codecs, "foo", "Zm9v ");
try testDecodeIgnoreSpace(codecs, "foob", "Zm9vYg = = ");
try testDecodeIgnoreSpace(codecs, "fooba", "Zm9v YmE=");
try testDecodeIgnoreSpace(codecs, "foobar", " Z m 9 v Y m F y ");
// test getting some api errors
try testError(codecs, "A", error.InvalidPadding);
try testError(codecs, "AA", error.InvalidPadding);
try testError(codecs, "AAA", error.InvalidPadding);
try testError(codecs, "A..A", error.InvalidCharacter);
try testError(codecs, "AA=A", error.InvalidPadding);
try testError(codecs, "AA/=", error.InvalidPadding);
try testError(codecs, "A/==", error.InvalidPadding);
try testError(codecs, "A===", error.InvalidPadding);
try testError(codecs, "====", error.InvalidPadding);
try testNoSpaceLeftError(codecs, "AA==");
try testNoSpaceLeftError(codecs, "AAA=");
try testNoSpaceLeftError(codecs, "AAAA");
try testNoSpaceLeftError(codecs, "AAAAAA==");
}
fn testBase64UrlSafeNoPad() !void {
const codecs = url_safe_no_pad;
try testAllApis(codecs, "", "");
try testAllApis(codecs, "f", "Zg");
try testAllApis(codecs, "fo", "Zm8");
try testAllApis(codecs, "foo", "Zm9v");
try testAllApis(codecs, "foob", "Zm9vYg");
try testAllApis(codecs, "fooba", "Zm9vYmE");
try testAllApis(codecs, "foobar", "Zm9vYmFy");
try testDecodeIgnoreSpace(codecs, "", " ");
try testDecodeIgnoreSpace(codecs, "f", "Z g ");
try testDecodeIgnoreSpace(codecs, "fo", " Zm8");
try testDecodeIgnoreSpace(codecs, "foo", "Zm9v ");
try testDecodeIgnoreSpace(codecs, "foob", "Zm9vYg ");
try testDecodeIgnoreSpace(codecs, "fooba", "Zm9v YmE");
try testDecodeIgnoreSpace(codecs, "foobar", " Z m 9 v Y m F y ");
// test getting some api errors
try testError(codecs, "A", error.InvalidPadding);
try testError(codecs, "AAA=", error.InvalidCharacter);
try testError(codecs, "A..A", error.InvalidCharacter);
try testError(codecs, "AA=A", error.InvalidCharacter);
try testError(codecs, "AA/=", error.InvalidCharacter);
try testError(codecs, "A/==", error.InvalidCharacter);
try testError(codecs, "A===", error.InvalidCharacter);
try testError(codecs, "====", error.InvalidCharacter);
try testNoSpaceLeftError(codecs, "AA");
try testNoSpaceLeftError(codecs, "AAA");
try testNoSpaceLeftError(codecs, "AAAA");
try testNoSpaceLeftError(codecs, "AAAAAA");
}
fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: []const u8) !void {
// Base64Encoder
{
var buffer: [0x100]u8 = undefined;
const encoded = codecs.Encoder.encode(&buffer, expected_decoded);
testing.expectEqualSlices(u8, expected_encoded, encoded);
}
// Base64Decoder
{
var buffer: [0x100]u8 = undefined;
var decoded = buffer[0..try codecs.Decoder.calcSizeForSlice(expected_encoded)];
try codecs.Decoder.decode(decoded, expected_encoded);
testing.expectEqualSlices(u8, expected_decoded, decoded);
}
// Base64DecoderWithIgnore
{
const decoder_ignore_nothing = codecs.decoderWithIgnore("");
var buffer: [0x100]u8 = undefined;
var decoded = buffer[0..try decoder_ignore_nothing.calcSizeUpperBound(expected_encoded.len)];
var written = try decoder_ignore_nothing.decode(decoded, expected_encoded);
testing.expect(written <= decoded.len);
testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);
}
}
fn testDecodeIgnoreSpace(codecs: Codecs, expected_decoded: []const u8, encoded: []const u8) !void {
const decoder_ignore_space = codecs.decoderWithIgnore(" ");
var buffer: [0x100]u8 = undefined;
var decoded = buffer[0..try decoder_ignore_space.calcSizeUpperBound(encoded.len)];
var written = try decoder_ignore_space.decode(decoded, encoded);
testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);
}
fn testError(codecs: Codecs, encoded: []const u8, expected_err: anyerror) !void {
const decoder_ignore_space = codecs.decoderWithIgnore(" ");
var buffer: [0x100]u8 = undefined;
if (codecs.Decoder.calcSizeForSlice(encoded)) |decoded_size| {
var decoded = buffer[0..decoded_size];
if (codecs.Decoder.decode(decoded, encoded)) |_| {
return error.ExpectedError;
} else |err| if (err != expected_err) return err;
} else |err| if (err != expected_err) return err;
if (decoder_ignore_space.decode(buffer[0..], encoded)) |_| {
return error.ExpectedError;
} else |err| if (err != expected_err) return err;
}
fn testNoSpaceLeftError(codecs: Codecs, encoded: []const u8) !void {
const decoder_ignore_space = codecs.decoderWithIgnore(" ");
var buffer: [0x100]u8 = undefined;
var decoded = buffer[0 .. (try codecs.Decoder.calcSizeForSlice(encoded)) - 1];
if (decoder_ignore_space.decode(decoded, encoded)) |_| {
return error.ExpectedError;
} else |err| if (err != error.NoSpaceLeft) return err;
} | lib/std/base64.zig |
const std = @import("std");
const c = @import("c.zig");
const main = @import("main.zig");
const cfg = @import("config.zig");
const Bitset = @import("util.zig").Bitset;
pub inline fn divceil(n: anytype, d: @TypeOf(n)) @TypeOf(n) {
return @divTrunc(n + (d - 1), d);
}
pub inline fn ATTRCMP(a: Glyph, b: Glyph) bool {
return a.mode.bits != b.mode.bits or a.fg != b.fg or a.bg != b.bg;
}
pub inline fn MODBIT(x: anytype, set: bool, bit: @typeInfo(@TypeOf(x)).Pointer.child) void {
if (set) x.* |= bit else x.* &= ~bit;
}
pub inline fn TIMEDIFF(t1: c.struct_timespec, t2: c.struct_timespec) c_long {
return (t1.tv_sec - t2.tv_sec) * 1000 + @divTrunc(t1.tv_nsec - t2.tv_nsec, 1_000_000);
}
pub const Attr = Bitset(enum {
Bold,
Faint,
Italic,
Underline,
Blink,
Reverse,
Invisible,
Struck,
Wrap,
Wide,
WDummy,
});
const SelectionMode = enum { Idle, Empty, Ready };
pub const SelectionType = enum(u2) { Regular = 1, Rectangular = 2 };
pub const SelectionSnap = enum(u2) { None = 0, SnapWord = 1, SnapLine = 2 };
pub const Rune = u32;
pub const Glyph = struct {
u: Rune = 0,
mode: Attr = Attr.empty,
fg: u32,
bg: u32,
};
pub const Line = [*]Glyph;
pub const Arg = union {
i: c_int,
ui: c_uint,
f: f64,
v: ?*c_void,
none: void,
pub const None = &Arg{ .none = {} };
};
pub inline fn limit(x: anytype, low: @TypeOf(x), hi: @TypeOf(x)) @TypeOf(x) {
return if (x < low) low else if (x > hi) hi else x;
}
// Arbitrary sizes
const utf_invalid = 0xFFFD;
const utf_size = 4;
const esc_buf_size = 128 * utf_size;
const esc_arg_size = 16;
const str_buf_size = esc_buf_size;
const str_arg_size = esc_arg_size;
// Macros
inline fn ISCONTROLC0(ch: Rune) bool {
return (0 <= ch and ch <= 0x1f) or ch == 0o177;
}
inline fn ISCONTROLC1(ch: Rune) bool {
return 0x80 <= ch and ch <= 0x9f;
}
inline fn ISCONTROL(ch: Rune) bool {
return ISCONTROLC0(ch) or ISCONTROLC1(ch);
}
inline fn ISDELIM(u: Rune) bool {
return u and c.wcschr(cfg.worddelimiters, @intCast(c.wchar_t, u)) != null;
}
const TermMode = Bitset(enum {
Wrap,
Insert,
Altscreen,
CrLf,
Echo,
Print,
Utf8,
Sixel,
});
const CursorMovement = enum { Save, Load };
const CURSOR_DEFAULT: u8 = 0;
const CURSOR_WRAPNEXT: u8 = 1;
const CURSOR_ORIGIN: u8 = 2;
const Charset = enum { Graphic0, Graphic1, Uk, Usa, Multi, Ger, Fin };
const ESC_START = 1;
const ESC_CSI = 2;
const ESC_STR = 4; // OSC, PM, APC
const ESC_ALTCHARSET = 8;
const ESC_STR_END = 16; // a final string was encountered
const ESC_TEST = 32; // Enter in test mode
const ESC_UTF8 = 64;
const ESC_DCS = 128;
const TCursor = struct {
attr: Glyph,
x: u32 = 0,
y: u32 = 0,
state: u8 = 0,
};
const Selection = struct {
const Coords = struct { x: u32 = 0, y: u32 = 0 };
pub const no_sel = std.math.maxInt(u32);
mode: SelectionMode,
@"type": SelectionType,
snap: SelectionSnap,
/// normalized begin
nb: Coords,
/// normalized end
ne: Coords,
/// original begin
/// ob.x is set to `no_sel` (`maxInt(u32)`) if there's no selection
ob: Coords,
/// original end
oe: Coords,
alt: bool,
};
const Term = struct {
row: u32 = 0,
col: u32 = 0,
line: [*c]Line = null,
alt: [*c]Line = null,
dirty: [*c]bool = null,
c: TCursor,
ocx: u32 = 0,
ocy: u32 = 0,
top: u32 = 0,
bot: u32 = 0,
mode: TermMode = TermMode.empty,
esc: u32 = 0,
trantbl: [4]Charset = undefined,
charset: u32 = 0,
icharset: u32 = 0,
tabs: [*c]u32 = null,
};
/// CSI Escape sequence structs
/// `ESC '[' [[ [<priv>] <arg> [;]] <mode> [<mode>]]`
const CSIEscape = struct {
buf: [esc_buf_size]u8,
len: usize,
priv: u8,
arg: [esc_arg_size]u32,
narg: usize,
mode: [2]u8,
};
/// STR Escape sequence structs
/// `ESC type [[ [<priv>] <arg> [;]] <mode>] ESC '\'`
const STREscape = struct {
@"type": u8,
buf: [str_buf_siz]u8,
len: usize,
args: [str_arg_siz][]const u8,
narg: usize,
};
// Globals
var term: Term = undefined;
var sel: Selection = undefined;
var csi_esc_seq: CSIEscape = undefined;
var str_esc_seq: STREscape = undefined;
var iofd: c_int = 1;
var cmdfd: c_int = undefined;
var pid: c.pid_t = undefined;
const utfbyte = [utf_size + 1]u8{ 0x80, 0, 0xC0, 0xE0, 0xF0 };
const utfmask = [utf_size + 1]u8{ 0xC0, 0x80, 0xE0, 0xF0, 0xF8 };
const utfmin = [utf_size + 1]Rune{ 0, 0, 0x80, 0x800, 0x10000 };
const utfmax = [utf_size + 1]Rune{ 0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF };
fn xwrite(fd: c_int, str: []const u8) isize {
var left = str.len;
var s = str.ptr;
while (left > 0) {
const written = c.write(fd, s, left);
if (written < 0) return written;
const r = @intCast(usize, written);
left -= r;
s += r;
}
return @intCast(isize, str.len);
}
pub fn xmalloc(len: usize) *c_void {
const p = c.malloc(len);
return p orelse die("malloc: {}\n", .{c.strerror(std.c._errno().*)});
}
pub fn xrealloc(p: *allowzero c_void, len: usize) *c_void {
const newp = c.realloc(p, len);
return newp orelse die("realloc: {}\n", .{@as([*:0]const u8, c.strerror(std.c._errno().*))});
}
pub fn xstrdup(s: [*:0]u8) [*:0]u8 {
const ns = @as(?[*:0]u8, c.strdup(s));
return ns orelse die("strdup: {}\n", .{c.strerror(std.c._errno().*)});
}
fn utf8decode(ch: []const u8, u: *Rune) usize {
u.* = utf_invalid;
if (ch.len == 0) return 0;
var len: usize = undefined;
var udecoded = utf8decodebyte(ch[0], &len);
if (!(1 <= len and len <= utf_size)) return 1;
var i: usize = 1;
var j: usize = 1;
while (i < ch.len and j < len) : ({
i += 1;
j += 1;
}) {
var chtype: usize = undefined;
udecoded = (udecoded << 6) | utf8decodebyte(ch[i], &chtype);
if (chtype != 0) return j;
}
if (j < len)
return 0;
u.* = udecoded;
_ = utf8validate(u, len);
return len;
}
fn utf8decodebyte(ch: u8, i: *usize) Rune {
i.* = 0;
while (i.* < utfmask.len) : (i.* += 1) {
if ((ch & utfmask[i.*]) == utfbyte[i.*])
return ch & ~utfmask[i.*];
}
return 0;
}
pub fn utf8encode(uni: Rune, ch: [*]u8) usize {
var u = uni;
const len = utf8validate(&u, 0);
if (len > utf_size)
return 0;
var i: usize = len - 1;
while (i > 0) : (i -= 1) {
ch[i] = utf8encodebyte(u, 0);
u >>= 6;
}
ch[0] = utf8encodebyte(u, len);
return len;
}
fn utf8encodebyte(u: Rune, i: usize) u8 {
return @truncate(u8, utfbyte[i] | (u & ~utfmask[i]));
}
fn utf8validate(u: *Rune, i: usize) usize {
if (!(utfmin[i] <= u.* and u.* <= utfmax[i]) or (0xD800 <= u.* and u.* <= 0xDFFF))
u.* = utf_invalid;
var ni: usize = 1;
while (u.* > utfmax[ni]) ni += 1;
return ni;
}
fn base64dec_getc(src: *[*:0]const u8) u8 {
@compileError("TODO base64dec_getc");
}
fn base64dec(src: [*:0]const u8) [*:0]u8 {
@compileError("TODO base64dec");
}
pub fn selinit() void {
sel.mode = .Idle;
sel.snap = .None;
sel.ob.x = Selection.no_sel;
}
fn tlinelen(y: u32) u32 {
var i = term.col;
if (term.line[y][i - 1].mode.get(.Wrap))
return i;
while (i > 0 and term.line[y][i - 1].u == ' ')
i -= 1;
return i;
}
pub fn selstart(col: u32, row: u32, snap: SelectionSnap) void {
selclear();
sel.mode = .Empty;
sel.@"type" = .Regular;
sel.alt = term.mode.get(.Altscreen);
sel.snap = snap;
sel.oe.x = col;
sel.ob.x = col;
sel.oe.y = row;
sel.ob.y = row;
selnormalize();
if (sel.snap != .None) sel.mode = .Ready;
tsetdirt(sel.nb.y, sel.ne.y);
}
pub fn selextend(col: u32, row: u32, typ: SelectionType, done: bool) void {
if (sel.mode == .Idle) return;
if (done and sel.mode == .Empty) {
selclear();
return;
}
const oldey = sel.oe.y;
const oldex = sel.oe.x;
const oldsby = sel.nb.y;
const oldsey = sel.ne.y;
const oldtype = sel.@"type";
sel.oe.x = col;
sel.oe.y = row;
selnormalize();
sel.@"type" = typ;
if (oldey != sel.oe.y or oldex != sel.oe.x or oldtype != sel.@"type" or sel.mode == .Empty)
tsetdirt(std.math.min(sel.nb.y, oldsby), std.math.max(sel.ne.y, oldsey));
sel.mode = if (done) .Idle else .Ready;
}
fn selnormalize() void {
if (sel.@"type" == .Regular and sel.ob.y != sel.oe.y) {
sel.nb.x = if (sel.ob.y < sel.oe.y) sel.ob.x else sel.oe.x;
sel.ne.x = if (sel.ob.y < sel.oe.y) sel.oe.x else sel.ob.x;
} else {
sel.nb.x = std.math.min(sel.ob.x, sel.oe.x);
sel.ne.x = std.math.max(sel.ob.x, sel.oe.x);
}
selsnap(&sel.nb.x, &sel.nb.y, -1);
selsnap(&sel.ne.x, &sel.ne.y, 1);
// expand selection over line breaks
if (sel.@"type" == .Rectangular)
return;
const i = tlinelen(sel.nb.y);
if (i < sel.nb.x)
sel.nb.x = i;
if (tlinelen(sel.ne.y) <= sel.ne.x)
sel.ne.x = term.col - 1;
}
pub fn selected(x: u32, y: u32) bool {
if (sel.mode == .Empty or sel.ob.x == Selection.no_sel or sel.alt != term.mode.get(.Altscreen))
return false;
if (sel.@"type" == .Rectangular)
return sel.nb.y <= y and y <= sel.ne.y;
return (sel.nb.y <= y and y <= sel.ne.y) //
and (y != sel.nb.y or x >= sel.nb.x) //
and (y != sel.ne.y or x <= sel.ne.x);
}
/// direction must be either +1 or -1
fn selsnap(x: *u32, y: *u32, direction: i2) void {
@compileError("TODO selsnap");
}
/// caller owns returned memory
pub fn getsel() ?[*:0]u8 {
if (sel.ob.x == Selection.no_sel)
return null;
const bufsize = (term.col + 1) * (sel.ne.y - sel.nb.y + 1) * utf_size;
const str = @ptrCast([*]u8, xmalloc(bufsize));
var ptr = str;
// append every set & selected glyph to the selection
var y = sel.nb.y;
while (y <= sel.ne.y) : (y += 1) {
const linelen = tlinelen(y);
if (linelen == 0) {
ptr.* = '\n';
ptr += 1;
continue;
}
var gp: [*]Glyph = undefined;
var lastx: u32 = undefined;
if (sel.@"type" == .Rectangular) {
gp = term.line[y] + sel.nb.x;
lastx = sel.ne.x;
} else {
gp = term.line[y] + (if (sel.nb.y == y) sel.nb.x else 0);
lastx = if (sel.ne.y == y) sel.ne.x else term.col - 1;
}
var last: [*]Glyph = term.line[y] + std.math.min(lastx, linelen - 1);
while (@ptrToInt(last) >= @ptrToInt(gp) and last.*.u == ' ')
last -= 1;
while (@ptrToInt(gp) <= @ptrToInt(last)) : (gp += 1) {
if (gp.*.mode.get(.WDummy))
continue;
ptr += utf8encode(gp.*.u, ptr);
}
// Copy and pasting of line endings is inconsistent
// in the inconsistent terminal and GUI world.
// The best solution seems like to produce '\n' when
// something is copied from st and convert '\n' to
// '\r', when something to be pasted is received by
// st.
// FIXME: Fix the computer world.
if ((y < sel.ne.y or lastx >= linelen) and !last.*.mode.get(.Wrap)) {
ptr.* = '\n';
ptr += 1;
}
}
ptr.* = 0;
return @ptrCast([*:0]u8, str);
}
pub fn selclear() void {
if (sel.ob.x == Selection.no_sel) return;
sel.mode = .Idle;
sel.ob.x = Selection.no_sel;
tsetdirt(sel.nb.y, sel.ne.y);
}
pub fn die(comptime msg: []const u8, params: anytype) noreturn {
std.debug.print(msg, params);
std.os.exit(1);
}
fn execsh(cmd: [*:0]const u8, arguments: ?[*:null]const ?[*:0]const u8) void {
std.c._errno().* = 0;
const pw = @as(?*c.struct_passwd, c.getpwuid(c.getuid())) orelse {
if (std.c._errno().* != 0)
die("getpwuid: {}\n", .{c.strerror(std.c._errno().*)})
else
die("who are you?\n", .{});
};
const sh = @ptrCast(?[*:0]const u8, c.getenv("SHELL")) orelse
if (pw.pw_shell[0] != 0) @as([*:0]const u8, pw.pw_shell) else cmd;
var prog = if (arguments) |args|
args[0]
else if (cfg.utmp) |utmp|
utmp
else
sh;
const args = arguments orelse &[_:null]?[*:0]const u8{prog};
_ = c.unsetenv("COLUMNS");
_ = c.unsetenv("LINES");
_ = c.unsetenv("TERMCAP");
_ = c.setenv("LOGNAME", pw.pw_name, 1);
_ = c.setenv("USER", pw.pw_name, 1);
_ = c.setenv("SHELL", sh, 1);
_ = c.setenv("HOME", pw.pw_dir, 1);
_ = c.setenv("TERM", cfg.termname, 1);
const SIG_DFL = null;
_ = c.signal(c.SIGCHLD, SIG_DFL);
_ = c.signal(c.SIGHUP, SIG_DFL);
_ = c.signal(c.SIGINT, SIG_DFL);
_ = c.signal(c.SIGQUIT, SIG_DFL);
_ = c.signal(c.SIGTERM, SIG_DFL);
_ = c.signal(c.SIGALRM, SIG_DFL);
// another monstrosity because of wrong qualifiers on C pointers
_ = c.execvp(prog, @intToPtr([*c]const [*c]u8, @ptrToInt(args)));
c._exit(1);
}
fn sigchld(a: c_int) callconv(.C) void {
@compileError("TODO sigchld");
}
fn stty(arguments: ?[*:null]const ?[*:0]const u8) void {
var cmd: [c._POSIX_ARG_MAX]u8 = undefined;
var n = cfg.stty_args.len;
if (n > cmd.len - 1)
die("incorrect stty parameters\n", .{});
std.mem.copy(u8, cmd[0..], cfg.stty_args);
var q = cmd[n..];
if (arguments) |args| {
var p = args;
while (p.*) |s| : (p += 1) {
const a = std.mem.span(s);
if (a.len > q.len - 1)
die("stty parameter length too long\n", .{});
q[0] = ' ';
std.mem.copy(u8, q[1..], a);
q = q[a.len + 1 ..];
}
}
q[0] = 0;
if (c.system(&cmd) != 0)
c.perror("Couldn't call stty");
}
pub fn ttynew(line: ?[*:0]const u8, cmd: [*:0]const u8, out: ?[*:0]const u8, args: ?[*:null]const ?[*:0]const u8) std.os.fd_t {
var m: c_int = undefined;
var s: c_int = undefined;
if (out != null) {
term.mode.set(.Print, true);
iofd = if (c.strcmp(out, "-") == 0) 1 else c.open(out, c.O_WRONLY | c.O_CREAT, 0o666);
if (iofd < 0) {
_ = c.fprintf(c.stderr, "Error opening %s:%s\n", out, c.strerror(std.c._errno().*));
}
}
if (line != null) {
cmdfd = c.open(line, c.O_RDWR);
if (cmdfd < 0)
die("open line '{}' failed: {}\n", .{ line, c.strerror(std.c._errno().*) });
_ = c.dup2(cmdfd, 0);
stty(args);
return cmdfd;
}
// seems to work fine on linux, openbsd and freebsd
if (c.openpty(&m, &s, null, null, null) < 0) die("openpty failed: {}\n", .{c.strerror(std.c._errno().*)});
pid = c.fork();
switch (pid) {
-1 => die("fork failed: {}\n", .{c.strerror(std.c._errno().*)}),
0 => {
_ = c.close(iofd);
_ = c.setsid(); // create a new process group
_ = c.dup2(s, 0);
_ = c.dup2(s, 1);
_ = c.dup2(s, 2);
if (c.ioctl(s, c.TIOCSCTTY, null) < 0)
die("ioctl TIOCSCTTY failed: {}\n", .{c.strerror(std.c._errno().*)});
_ = c.close(s);
_ = c.close(m);
if (std.builtin.os.tag == .openbsd) {
if (c.pledge("stdio getpw proc exec", null) == -1) die("pledge\n", .{});
}
execsh(cmd, args);
},
else => {
if (std.builtin.os.tag == .openbsd) {
if (c.pledge("stdio rpath tty proc", null) == -1) die("pledge\n", .{});
}
_ = c.close(s);
cmdfd = m;
_ = c.signal(c.SIGCHLD, sigchld);
},
}
return cmdfd;
}
var ttyread_buf = [_]u8{0} ** c.BUFSIZ;
var ttyread_buflen: usize = 0;
pub fn ttyread() usize {
var written: usize = undefined;
var ret = c.read(cmdfd, &ttyread_buf + ttyread_buflen, ttyread_buf.len - ttyread_buflen);
if (ret < 0)
die("couldn't read from shell: {}\n", .{c.strerror(std.c._errno().*)});
ttyread_buflen += @intCast(usize, ret);
written = twrite(ttyread_buf[0..ttyread_buflen], false);
ttyread_buflen -= written;
// keep any uncomplete utf8 char for the next call
if (ttyread_buflen > 0)
std.mem.copy(u8, ttyread_buf[0..], ttyread_buf[written .. written + ttyread_buflen]);
return @intCast(usize, ret);
}
pub fn ttywrite(str: []const u8, may_echo: bool) void {
if (may_echo and term.mode.get(.Echo))
_ = twrite(str, true);
if (!term.mode.get(.CrLf)) {
ttywriteraw(str);
return;
}
// This is similar to how the kernel handles ONLCR for ttys
var i: usize = 0;
while (i < str.len) {
var n: usize = undefined;
if (str[i] == '\r') {
n = 1;
ttywriteraw("\r\n");
} else {
n = std.mem.indexOfScalar(u8, str[i..], '\r') orelse str.len - i;
ttywriteraw(str[i .. i + n]);
}
i += n;
}
}
fn ttywriteraw(s: []const u8) void {
var lim: usize = 256;
// Remember that we are using a pty, which might be a modem line.
// Writing too much will clog the line. That's why we are doing this
// dance.
// FIXME: Migrate the world to Plan 9.
var i: usize = 0;
while (i < s.len) {
const n = s.len - i;
var wfd: c.fd_set = undefined;
var rfd: c.fd_set = undefined;
c._FD_ZERO(&wfd);
c._FD_ZERO(&rfd);
c._FD_SET(cmdfd, &wfd);
c._FD_SET(cmdfd, &rfd);
// Check if we can write.
if (c.pselect(cmdfd + 1, &rfd, &wfd, null, null, null) < 0) {
if (std.c._errno().* == c.EINTR) continue;
die("select failed: {}\n", .{c.strerror(std.c._errno().*)});
}
if (c._FD_ISSET(cmdfd, &wfd)) {
// Only write the bytes written by ttywrite() or the
// default of 256. This seems to be a reasonable value
// for a serial line. Bigger values might clog the I/O.
const written = c.write(cmdfd, s[i..].ptr, std.math.min(n, lim));
if (written < 0)
die("write error on tty: {}\n", .{c.strerror(std.c._errno().*)});
const r = @intCast(usize, written);
if (r < n) {
// We weren't able to write out everything.
// This means the buffer is getting full again. Empty it.
if (n < lim) lim = ttyread();
i += r;
} else {
// All bytes have been written.
break;
}
}
if (c._FD_ISSET(cmdfd, &rfd))
lim = ttyread();
}
return;
}
pub fn ttyresize(tw: u32, th: u32) void {
var w: c.struct_winsize = .{
.ws_row = @intCast(c_ushort, term.row),
.ws_col = @intCast(c_ushort, term.col),
.ws_xpixel = @intCast(c_ushort, tw),
.ws_ypixel = @intCast(c_ushort, th),
};
if (c.ioctl(cmdfd, c.TIOCSWINSZ, &w) < 0)
_ = c.fprintf(c.stderr, "Couldn't set window size: %s\n", c.strerror(std.c._errno().*));
}
pub fn ttyhangup() void {
// Send SIGHUP to shell
_ = c.kill(pid, c.SIGHUP);
}
pub fn tattrset(attr: Attr.Elem) bool {
// Send SIGHUP to shell
var i: usize = 0;
while (i < (term.row - 1)) : (i += 1) {
var j: usize = 0;
while (j < (term.col - 1)) : (j += 1) {
if (term.line[i][j].mode.get(attr)) return true;
}
}
return false;
}
fn tsetdirt(top: u32, bot: u32) void {
const t = limit(top, 0, term.row - 1);
const b = limit(bot, 0, term.row - 1);
var i: u32 = 0;
while (i <= b) : (i += 1)
term.dirty[i] = true;
}
pub fn tsetdirtattr(attr: Attr.Elem) void {
var i: u32 = 0;
while (i < (term.row - 1)) : (i += 1) {
var j: u32 = 0;
while (j < (term.col - 1)) : (j += 1) {
if (term.line[i][j].mode.get(attr)) {
tsetdirt(i, i);
break;
}
}
}
}
fn tfulldirt() void {
tsetdirt(0, term.row - 1);
}
var tcursor_c: [2]TCursor = undefined;
fn tcursor(mode: CursorMovement) void {
var alt = @boolToInt(term.mode.get(.Altscreen));
if (mode == .Save) {
tcursor_c[alt] = term.c;
} else if (mode == .Load) {
term.c = tcursor_c[alt];
tmoveto(tcursor_c[alt].x, tcursor_c[alt].y);
}
}
fn treset() void {
term.c = .{
.attr = .{
.mode = Attr.empty,
.fg = cfg.defaultfg,
.bg = cfg.defaultbg,
},
.x = 0,
.y = 0,
.state = CURSOR_DEFAULT,
};
std.mem.set(u32, term.tabs[0..term.col], 0);
var i: u32 = cfg.tabspaces;
while (i < term.col) : (i += cfg.tabspaces) term.tabs[i] = 1;
term.top = 0;
term.bot = term.row - 1;
term.mode = TermMode.init_with(.{ .Wrap, .Utf8 });
std.mem.set(Charset, term.trantbl[0..], Charset.Usa);
term.charset = 0;
i = 0;
while (i < 2) : (i += 1) {
tmoveto(0, 0);
tcursor(.Save);
tclearregion(0, 0, term.col - 1, term.row - 1);
tswapscreen();
}
}
pub fn tnew(col: u32, row: u32) void {
term = .{ .c = .{ .attr = .{ .fg = cfg.defaultfg, .bg = cfg.defaultbg } } };
tresize(col, row);
treset();
}
fn tswapscreen() void {
const temp = term.line;
term.line = term.alt;
term.alt = temp;
term.mode.toggle(.Altscreen);
tfulldirt();
}
fn tscrolldown(orig: u32, nlines: u32) void {
const n = limit(nlines, 0, term.bot - orig + 1);
tsetdirt(orig, term.bot - n);
tclearregion(0, term.bot - n + 1, term.col - 1, term.bot);
var i = term.bot;
while (i >= orig + n) : (i -= 1) {
const temp = term.line[i];
term.line[i] = term.line[i - n];
term.line[i - n] = temp;
}
selscroll(orig, n);
}
fn tscrollup(orig: u32, n: u32) void {
@compileError("TODO tscrollup");
}
fn selscroll(orig: u32, n: u32) void {
@compileError("TODO selscroll");
}
fn tnewline(first_col: u32) void {
@compileError("TODO tnewline");
}
fn csiparse() void {
@compileError("TODO csiparse");
}
fn tmoveato(x: u32, y: u32) void {
@compileError("TODO tmoveato");
}
fn tmoveto(x: u32, y: u32) void {
var miny: u32 = undefined;
var maxy: u32 = undefined;
if (term.c.state & CURSOR_ORIGIN != 0) {
miny = term.top;
maxy = term.bot;
} else {
miny = 0;
maxy = term.row - 1;
}
term.c.state &= ~CURSOR_WRAPNEXT;
term.c.x = limit(x, 0, term.col - 1);
term.c.y = limit(y, miny, maxy);
}
fn tsetchar(u: Rune, attr: *Glyph, x: u32, y: u32) void {
@compileError("TODO tsetchar");
}
fn tclearregion(x_start: u32, y_start: u32, x_end: u32, y_end: u32) void {
var x1 = x_start;
var y1 = y_start;
var x2 = x_end;
var y2 = y_end;
if (x1 > x2) {
const tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
const tmp = y1;
y1 = y2;
y2 = tmp;
}
x1 = limit(x1, 0, term.col - 1);
x2 = limit(x2, 0, term.col - 1);
y1 = limit(y1, 0, term.row - 1);
y2 = limit(y2, 0, term.row - 1);
var y = y1;
while (y <= y2) : (y += 1) {
term.dirty[y] = true;
var x = x1;
while (x <= x2) : (x += 1) {
var gp = &term.line[y][x];
if (selected(x, y)) selclear();
gp.fg = term.c.attr.fg;
gp.bg = term.c.attr.bg;
gp.mode = Attr.empty;
gp.u = ' ';
}
}
}
fn tdeletechar(n: u32) void {
@compileError("TODO tdeletechar");
}
fn tinsertblank(n: u32) void {
@compileError("TODO tinsertblank");
}
fn tinsertblankline(n: u32) void {
@compileError("TODO tinsertblankline");
}
fn tdeleteline(n: u32) void {
@compileError("TODO tdeleteline");
}
fn tdefcolor(attr: *u32, npar: *u32, l: u32) u32 {
@compileError("TODO tdefcolor");
}
fn tsetattr(attr: *u32, l: u32) void {
@compileError("TODO tsetattr");
}
fn tsetscroll(top: u32, bot: u32) void {
var t = limit(top, 0, term.row - 1);
var b = limit(bot, 0, term.row - 1);
if (t > b) {
const temp = t;
t = b;
b = temp;
}
term.top = t;
term.bot = b;
}
fn tsetmode(priv: u32, set: u32, args: [*]u32, narg: usize) void {
@compileError("TODO tsetmode");
}
fn csihandle() void {
@compileError("TODO csihandle");
}
fn csidump() void {
@compileError("TODO csidump");
}
fn csireset() void {
@compileError("TODO csireset");
}
fn strhandle() void {
@compileError("TODO strhandle");
}
fn strparse() void {
@compileError("TODO strparse");
}
fn strdump() void {
@compileError("TODO strdump");
}
fn strreset() void {
strescseq = std.mem.zeroes(STREscape);
}
pub fn sendbreak(arg: *const Arg) void {
if (c.tcsendbreak(cmdfd, 0) != 0)
c.perror("Error sending break");
}
fn tprinter(s: []const u8) void {
if (iofd != -1 and xwrite(iofd, s) < 0) {
c.perror("Error writing to output file");
_ = c.close(iofd);
iofd = -1;
}
}
pub fn toggleprinter(_: *const Arg) void {
term.mode.toggle(.Print);
}
pub fn printscreen(_: *const Arg) void {
tdump();
}
pub fn printsel(_: *const Arg) void {
tdumpsel();
}
fn tdumpsel() void {
if (getsel()) |ptr| {
tprinter(std.mem.span(ptr));
c.free(ptr);
}
}
fn tdumpline(n: u32) void {
@compileError("TODO tdumpline");
}
fn tdump() void {
var i: u32 = 0;
while (i < term.row) : (i += 1)
tdumpline(i);
}
fn tputtab(n: u32) void {
@compileError("TODO tputtab");
}
fn tdefutf8(ascii: u8) void {
@compileError("TODO tdefutf8");
}
fn tdeftran(ascii: u8) void {
@compileError("TODO tdeftran");
}
fn tdectest(c: u8) void {
@compileError("TODO tdectest");
}
fn tstrsequence(c: u8) void {
@compileError("TODO tstrsequence");
}
fn tcontrolcode(ascii: u8) void {
@compileError("TODO tcontrolcode");
}
fn eschandle(ascii: u8) bool {
@compileError("TODO eschandle");
}
fn tputc(u: Rune) void {
@compileError("TODO tputc");
}
fn twrite(buf: []const u8, show_ctrl: bool) usize {
var charsize: usize = undefined;
var n: usize = 0;
while (n < buf.len) : (n += charsize) {
var u: Rune = undefined;
if (term.mode.get(.Utf8) and !term.mode.get(.Sixel)) {
// process a complete utf8 char
charsize = utf8decode(buf[n..], &u);
if (charsize == 0) break;
} else {
u = buf[n] & 0xFF;
charsize = 1;
}
if (show_ctrl and ISCONTROL(u)) {
if (u & 0x80 != 0) {
u &= 0x7f;
tputc('^');
tputc('[');
} else if (u != '\n' and u != '\r' and u != '\t') {
u ^= 0x40;
tputc('^');
}
}
tputc(u);
}
return n;
}
pub fn tresize(col: u32, row: u32) void {
const minrow = std.math.min(row, term.row);
const mincol = std.math.min(col, term.col);
if (col < 1 or row < 1) {
std.debug.warn("tresize: error resizing to {}x{}\n", .{ col, row });
return;
}
// slide screen to keep cursor where we expect it -
// tscrollup would work here, but we can optimize to
// memmove because we're freeing the earlier lines
var i: usize = 0;
while (i <= @as(i33, term.c.y) - @as(i33, row)) : (i += 1) {
c.free(term.line[i]);
c.free(term.alt[i]);
}
// ensure that both src and dst are not null
if (i > 0) {
std.mem.copy(Line, term.line[0..term.row], term.line[i .. i + row]);
std.mem.copy(Line, term.alt[0..term.row], term.alt[i .. i + row]);
}
i += row;
while (i < term.row) : (i += 1) {
c.free(term.line[i]);
c.free(term.alt[i]);
}
// resize to new height
term.line = @ptrCast([*]Line, @alignCast(@alignOf([*]Line), xrealloc(@ptrCast(*allowzero c_void, term.line), row * @sizeOf(Line))));
term.alt = @ptrCast([*]Line, @alignCast(@alignOf([*]Line), xrealloc(@ptrCast(*allowzero c_void, term.alt), row * @sizeOf(Line))));
term.dirty = @ptrCast([*]bool, @alignCast(@alignOf([*]bool), xrealloc(@ptrCast(*allowzero c_void, term.dirty), row * @sizeOf(bool))));
term.tabs = @ptrCast([*]u32, @alignCast(@alignOf([*]u32), xrealloc(@ptrCast(*allowzero c_void, term.tabs), col * @sizeOf(u32))));
// resize each row to new width, zero-pad if needed
i = 0;
while (i < minrow) : (i += 1) {
term.line[i] = @ptrCast(Line, @alignCast(@alignOf(Line), xrealloc(term.line[i], col * @sizeOf(Glyph))));
term.alt[i] = @ptrCast(Line, @alignCast(@alignOf(Line), xrealloc(term.alt[i], col * @sizeOf(Glyph))));
}
// ( i = minrow ) now
while (i < row) : (i += 1) {
term.line[i] = @ptrCast(Line, @alignCast(@alignOf(Line), xmalloc(col * @sizeOf(Glyph))));
term.alt[i] = @ptrCast(Line, @alignCast(@alignOf(Line), xmalloc(col * @sizeOf(Glyph))));
}
if (col > term.col) {
var bp = term.tabs + term.col;
std.mem.set(u32, bp[0..(col - term.col)], 0);
bp -= 1;
while (@ptrToInt(bp) > @ptrToInt(term.tabs) and bp[0] != 0) bp -= 1;
bp += cfg.tabspaces;
while (@ptrToInt(bp) < @ptrToInt(term.tabs + col)) : (bp += cfg.tabspaces) bp.* = 1;
}
// update terminal size
term.col = col;
term.row = row;
// reset scrolling region
tsetscroll(0, row - 1);
// make use of the LIMIT in tmoveto
tmoveto(term.c.x, term.c.y);
// Clearing both screens (it makes all lines dirty)
const cur = term.c;
i = 0;
while (i < 2) : (i += 1) {
if (mincol < col and 0 < minrow) {
tclearregion(mincol, 0, col - 1, minrow - 1);
}
if (0 < col and minrow < row) {
tclearregion(0, minrow, col - 1, row - 1);
}
tswapscreen();
tcursor(.Load);
}
term.c = cur;
}
fn drawregion(x1: u32, y1: u32, x2: u32, y2: u32) void {
var y = y1;
while (y < y2) : (y += 1) {
if (!term.dirty[y]) continue;
term.dirty[y] = false;
main.xdrawline(term.line[y], x1, y, x2);
}
}
pub fn draw() void {
var cx = term.c.x;
if (!main.xstartdraw()) return;
term.ocx = limit(term.ocx, 0, term.col - 1);
term.ocy = limit(term.ocx, 0, term.row - 1);
if (term.line[term.ocy][term.ocx].mode.get(.WDummy))
term.ocx -= 1;
if (term.line[term.c.y][cx].mode.get(.WDummy))
cx -= 1;
drawregion(0, 0, term.col, term.row);
main.xdrawcursor(
cx,
term.c.y,
term.line[term.c.y][cx],
term.ocx,
term.ocy,
term.line[term.ocy][term.ocx],
);
term.ocx = cx;
term.ocy = term.c.y;
main.xfinishdraw();
main.xximspot(term.ocx, term.ocy);
}
pub fn redraw() void {
tfulldirt();
draw();
} | src/st.zig |
const wlr = @import("../wlroots.zig");
const wayland = @import("wayland");
const wl = wayland.server.wl;
pub const Cursor = extern struct {
pub const State = opaque {};
state: *State,
x: f64,
y: f64,
events: extern struct {
motion: wl.Signal(*wlr.Pointer.event.Motion),
motion_absolute: wl.Signal(*wlr.Pointer.event.MotionAbsolute),
button: wl.Signal(*wlr.Pointer.event.Button),
axis: wl.Signal(*wlr.Pointer.event.Axis),
frame: wl.Signal(*Cursor),
swipe_begin: wl.Signal(*wlr.Pointer.event.SwipeBegin),
swipe_update: wl.Signal(*wlr.Pointer.event.SwipeUpdate),
swipe_end: wl.Signal(*wlr.Pointer.event.SwipeEnd),
pinch_begin: wl.Signal(*wlr.Pointer.event.PinchBegin),
pinch_update: wl.Signal(*wlr.Pointer.event.PinchUpdate),
pinch_end: wl.Signal(*wlr.Pointer.event.PinchEnd),
touch_up: wl.Signal(*wlr.Touch.event.Up),
touch_down: wl.Signal(*wlr.Touch.event.Down),
touch_motion: wl.Signal(*wlr.Touch.event.Motion),
touch_cancel: wl.Signal(*wlr.Touch.event.Cancel),
tablet_tool_axis: wl.Signal(*wlr.Tablet.event.Axis),
tablet_tool_proximity: wl.Signal(*wlr.Tablet.event.Proximity),
tablet_tool_tip: wl.Signal(*wlr.Tablet.event.Tip),
tablet_tool_button: wl.Signal(*wlr.Tablet.event.Button),
},
data: usize,
extern fn wlr_cursor_create() ?*Cursor;
pub fn create() !*Cursor {
return wlr_cursor_create() orelse error.OutOfMemory;
}
extern fn wlr_cursor_destroy(cur: *Cursor) void;
pub const destroy = wlr_cursor_destroy;
extern fn wlr_cursor_warp(cur: *Cursor, dev: ?*wlr.InputDevice, lx: f64, ly: f64) bool;
pub const warp = wlr_cursor_warp;
extern fn wlr_cursor_absolute_to_layout_coords(cur: *Cursor, dev: ?*wlr.InputDevice, x: f64, y: f64, lx: *f64, ly: *f64) void;
pub const absoluteToLayoutCoords = wlr_cursor_absolute_to_layout_coords;
extern fn wlr_cursor_warp_closest(cur: *Cursor, dev: ?*wlr.InputDevice, x: f64, y: f64) void;
pub const warpClosest = wlr_cursor_warp_closest;
extern fn wlr_cursor_warp_absolute(cur: *Cursor, dev: ?*wlr.InputDevice, x: f64, y: f64) void;
pub const warpAbsolute = wlr_cursor_warp_absolute;
extern fn wlr_cursor_move(cur: *Cursor, dev: ?*wlr.InputDevice, delta_x: f64, delta_y: f64) void;
pub const move = wlr_cursor_move;
extern fn wlr_cursor_set_image(cur: *Cursor, pixels: [*c]const u8, stride: i32, width: u32, height: u32, hotspot_x: i32, hotspot_y: i32, scale: f32) void;
pub const setImage = wlr_cursor_set_image;
extern fn wlr_cursor_set_surface(cur: *Cursor, surface: ?*wlr.Surface, hotspot_x: i32, hotspot_y: i32) void;
pub const setSurface = wlr_cursor_set_surface;
extern fn wlr_cursor_attach_input_device(cur: *Cursor, dev: *wlr.InputDevice) void;
pub const attachInputDevice = wlr_cursor_attach_input_device;
extern fn wlr_cursor_detach_input_device(cur: *Cursor, dev: *wlr.InputDevice) void;
pub const detachInputDevice = wlr_cursor_detach_input_device;
extern fn wlr_cursor_attach_output_layout(cur: *Cursor, l: *wlr.OutputLayout) void;
pub const attachOutputLayout = wlr_cursor_attach_output_layout;
extern fn wlr_cursor_map_to_output(cur: *Cursor, output: *wlr.Output) void;
pub const mapToOutput = wlr_cursor_map_to_output;
extern fn wlr_cursor_map_input_to_output(cur: *Cursor, dev: *wlr.InputDevice, output: *wlr.Output) void;
pub const mapInputToOutput = wlr_cursor_map_input_to_output;
extern fn wlr_cursor_map_to_region(cur: *Cursor, box: *wlr.Box) void;
pub const mapToRegion = wlr_cursor_map_to_region;
extern fn wlr_cursor_map_input_to_region(cur: *Cursor, dev: *wlr.InputDevice, box: *wlr.Box) void;
pub const mapInputToRegion = wlr_cursor_map_input_to_region;
}; | src/types/cursor.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const zua = @import("zua.zig");
const Instruction = zua.opcodes.Instruction;
const Node = zua.ast.Node;
const Function = zua.object.Function;
const Constant = zua.object.Constant;
const Lexer = zua.lex.Lexer;
const Parser = zua.parse.Parser;
const max_stack_size = zua.parse.max_stack_size;
const OpCode = zua.opcodes.OpCode;
const Token = zua.lex.Token;
/// LUAI_MAXVARS from lconf.h
pub const max_vars = 200;
pub fn compile(allocator: *Allocator, source: []const u8) !Function {
var lexer = Lexer.init(source, source);
var parser = Parser.init(&lexer);
var tree = try parser.parse(allocator);
defer tree.deinit();
var arena_allocator = std.heap.ArenaAllocator.init(allocator);
defer arena_allocator.deinit();
const arena = &arena_allocator.allocator;
var compiler = Compiler{
.source = source,
.arena = arena,
.allocator = allocator,
.func = undefined,
};
defer compiler.deinit();
const main_func = try compiler.genChunk(tree.chunk());
return Function{
.name = "",
.code = try allocator.dupe(Instruction, main_func.code.items),
.constants = try allocator.dupe(Constant, main_func.constants.items),
.allocator = allocator,
.max_stack_size = main_func.max_stack_size,
.varargs = main_func.varargs,
};
}
pub const Compiler = struct {
source: []const u8,
arena: *Allocator,
allocator: *Allocator,
func: *Func,
pub const Error = error{CompileError} || Allocator.Error;
pub fn deinit(self: *Compiler) void {
// TODO
_ = self;
}
/// State for an incomplete/to-be-compiled function
/// Analogous to FuncState in PUC Lua
pub const Func = struct {
max_stack_size: u8 = 2, // registers 0/1 are always valid
free_register: u8 = 0, // TODO what should this type actually be?
cur_exp: ExpDesc = .{ .desc = .{ .@"void" = {} } },
code: std.ArrayList(Instruction),
constants: std.ArrayList(Constant),
constants_map: Constant.Map,
varargs: Function.VarArgs,
prev: ?*Func,
num_active_local_vars: u8 = 0,
active_local_vars: [max_vars]usize = undefined,
local_vars: std.ArrayList(LocalVar),
pub const LocalVar = struct {
name_token: Token,
active_instruction_index: usize,
dead_instruction_index: usize,
};
pub fn checkstack(self: *Func, n: u8) !void {
const newstack = self.free_register + n;
if (newstack > self.max_stack_size) {
if (newstack >= max_stack_size) {
@panic("TODO function or expression too complex");
}
self.max_stack_size = newstack;
}
}
pub fn reserveregs(self: *Func, n: u8) !void {
try self.checkstack(n);
self.free_register += n;
}
pub fn exp2nextreg(self: *Func, e: *ExpDesc) !u8 {
try self.dischargevars(e);
try self.freeexp(e);
try self.reserveregs(1);
const reg = self.free_register - 1;
try self.exp2reg(e, reg);
return reg;
}
pub fn exp2anyreg(self: *Func, e: *ExpDesc) !u8 {
try self.dischargevars(e);
if (e.desc == .nonreloc) {
const reg = e.desc.nonreloc.result_register;
// exp is already in a register
if (!e.hasjumps()) return reg;
// reg is not a local?
if (reg >= self.num_active_local_vars) {
try self.exp2reg(e, reg);
return reg;
}
}
return try self.exp2nextreg(e);
}
pub fn dischargevars(self: *Func, e: *ExpDesc) !void {
switch (e.desc) {
.local_register => {
const reg = e.desc.local_register;
e.desc = .{ .nonreloc = .{ .result_register = reg } };
},
.upvalue_index => {
//const index = try self.emitABC(.getupval, 0, @intCast(u18, e.val.?), 0);
//e.val = @intCast(isize, index);
e.desc = .{ .relocable = .{ .instruction_index = 0 } };
@panic("TODO");
},
.global => {
const index = try self.emitABx(.getglobal, 0, @intCast(u18, e.desc.global.name_constant_index));
e.desc = .{ .relocable = .{ .instruction_index = index } };
},
.indexed => {
self.freereg(e.desc.indexed.key_register_or_constant_index);
self.freereg(e.desc.indexed.table_register);
const instruction_index = try self.emitABC(.gettable, 0, e.desc.indexed.table_register, e.desc.indexed.key_register_or_constant_index);
e.desc = .{ .relocable = .{ .instruction_index = instruction_index } };
},
.vararg, .call => {
try self.setoneret(e);
},
else => {}, // there is one value available (somewhere)
}
}
pub fn setoneret(self: *Func, e: *ExpDesc) !void {
if (e.desc == .call) {
const instruction = self.getcode(e);
e.desc = .{ .nonreloc = .{ .result_register = instruction.a } };
} else if (e.desc == .vararg) {
const instruction = self.getcode(e);
const instructionABC = @ptrCast(*Instruction.ABC, instruction);
instructionABC.*.b = 2;
const instruction_index = e.desc.vararg.instruction_index;
e.desc = .{ .relocable = .{ .instruction_index = instruction_index } };
}
}
pub fn freeexp(self: *Func, e: *ExpDesc) !void {
if (e.desc == .nonreloc) {
self.freereg(e.desc.nonreloc.result_register);
}
}
pub fn freereg(self: *Func, reg: u9) void {
if (!zua.opcodes.isConstant(reg) and reg >= self.num_active_local_vars) {
self.free_register -= 1;
std.debug.assert(reg == self.free_register);
}
}
pub fn getcode(self: *Func, e: *ExpDesc) *Instruction {
const index: usize = switch (e.desc) {
.jmp, .relocable, .call, .vararg => |desc| desc.instruction_index,
else => unreachable,
};
return &self.code.items[index];
}
pub fn exp2reg(self: *Func, e: *ExpDesc, reg: u8) !void {
try self.discharge2reg(e, reg);
if (e.desc == .jmp) {
//self.concat(...)
@panic("TODO");
}
if (e.hasjumps()) {
@panic("TODO");
}
e.* = .{
.desc = .{
.nonreloc = .{ .result_register = reg },
},
.patch_list = null,
};
}
pub fn discharge2reg(self: *Func, e: *ExpDesc, reg: u8) !void {
try self.dischargevars(e);
switch (e.desc) {
.nil => {
_ = try self.emitNil(reg, 1);
},
.@"false", .@"true" => {
_ = try self.emitInstruction(Instruction.LoadBool.init(reg, e.desc == .@"true", false));
},
.constant_index => {
_ = try self.emitABx(.loadk, reg, @intCast(u18, e.desc.constant_index));
},
.number => {
// Need to add number constants to the constant table here instead of,
// in genLiteral because not every constant is needed in the final
// bytecode, i.e. `return 1 + 2` should be resolved to only need the
// constant `3` (1 and 2 are not in the final bytecode)
const index = try self.putConstant(Constant{ .number = e.desc.number });
_ = try self.emitABx(.loadk, reg, @intCast(u18, index));
},
.relocable => {
const instruction = self.getcode(e);
const instructionABC = @ptrCast(*Instruction.ABC, instruction);
instructionABC.*.a = reg;
},
.nonreloc => {
if (reg != e.desc.nonreloc.result_register) {
const result_register = e.desc.nonreloc.result_register;
_ = try self.emitABC(.move, reg, result_register, 0);
}
},
.@"void", .jmp => return, // nothing to do
else => unreachable,
}
e.desc = .{ .nonreloc = .{ .result_register = reg } };
}
/// luaK_ret equivalent
pub fn emitReturn(self: *Func, first_return_reg: u8, num_returns: ?u9) !usize {
return self.emitInstruction(Instruction.Return.init(first_return_reg, num_returns));
}
// TODO better param names
pub fn emitNil(self: *Func, from: u8, n: usize) !?usize {
// TODO other branches
if (true) { // TODO fs->pc > fs->lasttarget
if (self.pc() == 0) { // function start?
if (from >= self.num_active_local_vars) {
return null; // positions are already clean
}
}
}
const b = @intCast(u9, from + n - 1);
if (self.emitInstruction(Instruction.ABC.init(.loadnil, from, b, 0))) |index| {
return index;
} else |err| {
return err;
}
}
/// Appends a new instruction to the Func's code and returns the
/// index of the added instruction
pub fn emitInstruction(self: *Func, instruction: anytype) !usize {
try self.code.append(@bitCast(Instruction, instruction));
return self.pc() - 1;
}
/// Appends a new instruction to the Func's code and returns the
/// index of the added instruction
/// luaK_codeABC equivalent
pub fn emitABC(self: *Func, op: OpCode, a: u8, b: u9, c: u9) !usize {
return self.emitInstruction(Instruction.ABC.init(op, a, b, c));
}
/// Appends a new instruction to the Func's code and returns the
/// index of the added instruction
/// luaK_codeABx equivalent
pub fn emitABx(self: *Func, op: OpCode, a: u8, bx: u18) !usize {
return self.emitInstruction(Instruction.ABx.init(op, a, bx));
}
pub fn putConstant(self: *Func, constant: Constant) Error!usize {
const result = try self.constants_map.getOrPut(constant);
if (result.found_existing) {
return result.value_ptr.*;
} else {
result.value_ptr.* = self.constants.items.len;
try self.constants.append(constant);
return result.value_ptr.*;
}
}
pub fn new_localvar(self: *Func, name_token: Token, var_index: usize) Error!void {
const active_local_var_index = self.num_active_local_vars + var_index;
if (active_local_var_index >= max_vars) {
@panic("TODO too many local vars error");
}
self.active_local_vars[active_local_var_index] = try self.registerlocalvar(name_token);
}
pub fn registerlocalvar(self: *Func, name_token: Token) Error!usize {
try self.local_vars.append(.{
.name_token = name_token,
// to be filled in later
.active_instruction_index = undefined,
.dead_instruction_index = undefined,
});
return self.local_vars.items.len - 1;
}
pub fn adjust_assign(self: *Func, num_vars: usize, num_values: usize, e: *ExpDesc) !void {
var extra: isize = @intCast(isize, num_vars) - @intCast(isize, num_values);
if (e.hasmultret()) {
extra += 1;
if (extra < 0) extra = 0;
try self.setreturns(e, @intCast(u9, extra));
if (extra > 1) {
try self.reserveregs(@intCast(u8, extra - 1));
}
} else {
if (e.desc != .@"void") {
_ = try self.exp2nextreg(e);
}
if (extra > 0) {
const reg = self.free_register;
try self.reserveregs(@intCast(u8, extra));
_ = try self.emitNil(reg, @intCast(usize, extra));
}
}
}
pub fn setreturns(self: *Func, e: *ExpDesc, num_results: ?u9) !void {
if (e.desc == .call) {
const instruction = @ptrCast(*Instruction.Call, self.getcode(e));
instruction.setNumReturnValues(num_results);
} else if (e.desc == .vararg) {
const instruction = @ptrCast(*Instruction.VarArg, self.getcode(e));
instruction.setNumReturnValues(num_results);
instruction.setFirstReturnValueRegister(self.free_register);
try self.reserveregs(1);
}
}
pub fn setmultret(self: *Func, e: *ExpDesc) !void {
return self.setreturns(e, null);
}
pub fn adjustlocalvars(self: *Func, num_vars: usize) !void {
self.num_active_local_vars += @intCast(u8, num_vars);
var num_vars_remaining = num_vars;
while (num_vars_remaining > 0) : (num_vars_remaining -= 1) {
const local_var = self.getlocvar(self.num_active_local_vars - num_vars_remaining);
local_var.active_instruction_index = self.pc();
}
}
pub fn removevars(self: *Func, to_level: u8) !void {
while (self.num_active_local_vars > to_level) {
self.num_active_local_vars -= 1;
const local_var = self.getlocvar(self.num_active_local_vars);
local_var.dead_instruction_index = self.pc();
}
}
pub fn getlocvar(self: *Func, active_local_var_index: usize) *LocalVar {
const local_var_index = self.active_local_vars[active_local_var_index];
return &self.local_vars.items[local_var_index];
}
/// searchvar equivalent
/// Returns the index to the active local var, if found
pub fn findLocalVarByToken(self: *Func, name_token: Token, source: []const u8) ?usize {
if (self.num_active_local_vars == 0) return null;
const name_to_find = source[name_token.start..name_token.end];
var i: usize = self.num_active_local_vars - 1;
while (true) : (i -= 1) {
const cur_name_token = self.getlocvar(i).name_token;
const cur_name = source[cur_name_token.start..cur_name_token.end];
if (std.mem.eql(u8, cur_name, name_to_find)) {
return i;
}
if (i == 0) break;
}
return null;
}
pub fn exp2val(self: *Func, e: *ExpDesc) !void {
if (e.hasjumps()) {
_ = try self.exp2anyreg(e);
} else {
try self.dischargevars(e);
}
}
pub fn exp2RK(self: *Func, e: *ExpDesc) !u9 {
try self.exp2val(e);
switch (e.desc) {
.number, .@"true", .@"false", .nil => {
if (self.constants.items.len <= zua.opcodes.max_constant_index) {
var constant: Constant = switch (e.desc) {
.nil => Constant{ .nil = {} },
.@"true", .@"false" => Constant{ .boolean = e.desc == .@"true" },
.number => Constant{ .number = e.desc.number },
else => unreachable,
};
const index = try self.putConstant(constant);
return zua.opcodes.constantIndexToRK(@intCast(u9, index));
}
},
.constant_index => {
if (e.desc.constant_index <= zua.opcodes.max_constant_index) {
return zua.opcodes.constantIndexToRK(@intCast(u9, e.desc.constant_index));
}
},
else => {},
}
// not a constant in the right range, put it in a register
return @intCast(u9, try self.exp2anyreg(e));
}
pub fn indexed(self: *Func, table: *ExpDesc, key: *ExpDesc) !void {
const key_register_or_constant_index = try self.exp2RK(key);
// TODO can this be some other type here?
const table_register = table.desc.nonreloc.result_register;
table.desc = .{
.indexed = .{
.table_register = table_register,
.key_register_or_constant_index = key_register_or_constant_index,
},
};
}
/// luaK_self equivalent
pub fn handleSelf(self: *Func, e: *ExpDesc, key: *ExpDesc) !void {
_ = try self.exp2anyreg(e);
try self.freeexp(e);
const func_reg = self.free_register;
try self.reserveregs(2);
// TODO can this be a different type?
const result_register = e.desc.nonreloc.result_register;
const key_rk = try self.exp2RK(key);
_ = try self.emitABC(.self, func_reg, result_register, key_rk);
try self.freeexp(key);
e.desc = .{ .nonreloc = .{ .result_register = func_reg } };
}
pub fn storevar(self: *Func, var_e: *ExpDesc, e: *ExpDesc) !void {
switch (var_e.desc) {
.local_register => {
@panic("TODO");
},
.upvalue_index => {
@panic("TODO");
},
.global => {
const reg = try self.exp2anyreg(e);
const name_constant_index = var_e.desc.global.name_constant_index;
_ = try self.emitABx(.setglobal, reg, @intCast(u18, name_constant_index));
},
.indexed => {
@panic("TODO");
},
else => unreachable,
}
try self.freeexp(e);
}
pub fn setlist(self: *Func, base: u8, num_values: usize, to_store: ?usize) !void {
const flush_batch_num: usize = (num_values - 1) / Instruction.SetList.fields_per_flush + 1;
const num_values_in_batch: u9 = if (to_store == null) 0 else @intCast(u9, to_store.?);
if (flush_batch_num <= Instruction.ABC.max_c) {
_ = try self.emitABC(.setlist, base, num_values_in_batch, @intCast(u9, flush_batch_num));
} else {
_ = try self.emitABC(.setlist, base, num_values_in_batch, 0);
// if the batch number can't fit in the C field, then
// we use an entire 'instruction' to represent it, but the instruction
// is just the value itself (no opcode, etc)
_ = try self.emitInstruction(@intCast(u32, flush_batch_num));
}
self.free_register = base + 1;
}
pub fn codenot(self: *Func, e: *ExpDesc) !void {
try self.dischargevars(e);
switch (e.desc) {
.nil, .@"false" => {
e.desc = .{ .@"true" = {} };
},
.constant_index, .number, .@"true" => {
e.desc = .{ .@"false" = {} };
},
.jmp => @panic("TODO"),
.relocable, .nonreloc => @panic("TODO"),
else => unreachable,
}
if (e.patch_list != null) {
@panic("TODO");
}
}
pub fn prefix(self: *Func, un_op: Token, e: *ExpDesc) !void {
switch (un_op.id) {
.keyword_not => try self.codenot(e),
.single_char => switch (un_op.char.?) {
'-' => {
if (!e.isnumeral()) {
_ = try self.exp2anyreg(e);
}
try self.codearith(.unm, e, null);
},
'#' => {
_ = try self.exp2anyreg(e);
try self.codearith(.len, e, null);
},
else => unreachable,
},
else => unreachable,
}
}
pub fn infix(self: *Func, bin_op: Token, e: *ExpDesc) !void {
switch (bin_op.id) {
.keyword_and => @panic("TODO"),
.keyword_or => @panic("TODO"),
.concat => _ = try self.exp2nextreg(e),
.single_char => switch (bin_op.char.?) {
'+', '-', '*', '/', '%', '^' => {
if (!e.isnumeral()) {
_ = try self.exp2RK(e);
}
return;
},
else => {},
},
else => {},
}
_ = try self.exp2RK(e);
}
pub fn posfix(self: *Func, bin_op: Token, e1: *ExpDesc, e2: *ExpDesc) !void {
switch (bin_op.id) {
.keyword_and => @panic("TODO"),
.keyword_or => @panic("TODO"),
.concat => {
try self.exp2val(e2);
if (e2.desc == .relocable and self.getcode(e2).op == .concat) {
const e1_result_register = e1.desc.nonreloc.result_register;
var e2_instruction = @ptrCast(*Instruction.ABC, self.getcode(e2));
std.debug.assert(e1_result_register == e2_instruction.b - 1);
try self.freeexp(e1);
e2_instruction.b = e1_result_register;
e1.desc = .{ .relocable = .{ .instruction_index = e2.desc.relocable.instruction_index } };
} else {
// operand must be on the 'stack'
// Note: Doing this avoids hitting unreachable when concatting
// two number literals, since it would force a literal into
// a register here (so the numeral check when const folding will fail).
_ = try self.exp2nextreg(e2);
try self.codearith(.concat, e1, e2);
}
},
.single_char => switch (bin_op.char.?) {
'+', '-', '*', '/', '%', '^' => try self.codearith(Instruction.BinaryMath.tokenToOpCode(bin_op), e1, e2),
'>' => @panic("TODO"),
'<' => @panic("TODO"),
else => unreachable,
},
.eq => @panic("TODO"),
.ne => @panic("TODO"),
.le => @panic("TODO"),
.ge => @panic("TODO"),
else => unreachable,
}
}
pub fn codearith(self: *Func, op: OpCode, e1: *ExpDesc, e2: ?*ExpDesc) !void {
if (try self.constfolding(op, e1, e2)) {
return;
} else {
const o2 = if (e2 != null) try self.exp2RK(e2.?) else 0;
const o1 = try self.exp2RK(e1);
if (o1 > o2) {
try self.freeexp(e1);
if (e2 != null) {
try self.freeexp(e2.?);
}
} else {
if (e2 != null) {
try self.freeexp(e2.?);
}
try self.freeexp(e1);
}
const instruction_index = try self.emitInstruction(Instruction.BinaryMath.init(op, 0, o1, o2));
e1.desc = .{ .relocable = .{ .instruction_index = instruction_index } };
}
}
pub fn constfolding(self: *Func, op: OpCode, e1: *ExpDesc, e2: ?*ExpDesc) !bool {
_ = self; // TODO: is there a better way to avoid this unused param error?
// can only fold number literals
if (e2 == null and !e1.isnumeral()) return false;
if (e2 != null and (!e1.isnumeral() or !e2.?.isnumeral())) return false;
const v1: f64 = e1.desc.number;
const v2: f64 = if (e2 != null) e2.?.desc.number else 0;
var r: f64 = 0;
switch (op) {
.add => r = v1 + v2,
.sub => r = v1 - v2,
.mul => r = v1 * v2,
.div => {
if (v2 == 0) return false; // don't divide by 0
r = v1 / v2;
},
.mod => {
if (v2 == 0) return false; // don't mod by 0
r = @mod(v1, v2);
},
.pow => r = std.math.pow(f64, v1, v2),
.unm => r = -v1,
.len => return false,
else => unreachable,
}
// TODO numisnan
e1.desc.number = r;
return true;
}
/// Current instruction pointer
pub fn pc(self: *Func) usize {
return self.code.items.len;
}
};
pub const ExpDesc = struct {
desc: union(ExpDesc.Kind) {
@"void": void,
nil: void,
@"true": void,
@"false": void,
constant_index: usize,
number: f64,
local_register: u8,
upvalue_index: usize,
global: struct {
name_constant_index: usize,
},
indexed: struct {
table_register: u8,
key_register_or_constant_index: u9,
},
jmp: InstructionIndex,
relocable: InstructionIndex,
nonreloc: struct {
result_register: u8,
},
call: InstructionIndex,
vararg: InstructionIndex,
},
// TODO the types here should be revisited
patch_list: ?struct {
exit_when_true: ?i32,
exit_when_false: ?i32,
} = null,
// A wrapper struct for usize so that it can have a descriptive name
// and each tag that uses it can share the same type
pub const InstructionIndex = struct {
instruction_index: usize,
};
pub const Kind = enum {
@"void",
nil,
@"true",
@"false",
constant_index,
number,
local_register,
upvalue_index,
global,
indexed,
jmp,
relocable,
nonreloc,
call,
vararg,
};
pub fn hasjumps(self: *ExpDesc) bool {
return self.patch_list != null;
}
pub fn hasmultret(self: *ExpDesc) bool {
return self.desc == .call or self.desc == .vararg;
}
pub fn isnumeral(self: *ExpDesc) bool {
return self.desc == .number and self.patch_list == null;
}
};
pub fn genChunk(self: *Compiler, chunk: *Node.Chunk) Error!*Func {
var main_func: *Func = try self.arena.create(Func);
main_func.* = .{
.code = std.ArrayList(Instruction).init(self.arena),
.constants = std.ArrayList(Constant).init(self.arena),
.constants_map = Constant.Map.init(self.arena),
.local_vars = std.ArrayList(Func.LocalVar).init(self.arena),
.varargs = .{ .is_var_arg = true }, // main func is always vararg
.prev = null,
};
self.func = main_func;
for (chunk.body) |node| {
try self.genNode(node);
std.debug.assert(self.func.max_stack_size >= self.func.free_register);
std.debug.assert(self.func.free_register >= self.func.num_active_local_vars);
self.func.free_register = self.func.num_active_local_vars;
}
try self.func.removevars(0);
// In the PUC Lua implementation, this final return is added in close_func.
// It is added regardless of whether or not there is already a return, e.g.
// a file with just `return 1` in it will actually have 2 return instructions
// (one for the explicit return and then this one)
_ = try self.func.emitReturn(0, 0);
return main_func;
}
pub fn genNode(self: *Compiler, node: *Node) Error!void {
switch (node.id) {
.chunk => unreachable, // should call genChunk directly, it should always be the root of a tree
.call => try self.genCall(@fieldParentPtr(Node.Call, "base", node)),
.assignment_statement => try self.genAssignmentStatement(@fieldParentPtr(Node.AssignmentStatement, "base", node)),
.literal => try self.genLiteral(@fieldParentPtr(Node.Literal, "base", node)),
.identifier => try self.genIdentifier(@fieldParentPtr(Node.Identifier, "base", node)),
.return_statement => try self.genReturnStatement(@fieldParentPtr(Node.ReturnStatement, "base", node)),
.field_access => try self.genFieldAccess(@fieldParentPtr(Node.FieldAccess, "base", node)),
.index_access => try self.genIndexAccess(@fieldParentPtr(Node.IndexAccess, "base", node)),
.table_constructor => try self.genTableConstructor(@fieldParentPtr(Node.TableConstructor, "base", node)),
.table_field => unreachable, // should never be called outside of genTableConstructor
.binary_expression => try self.genBinaryExpression(@fieldParentPtr(Node.BinaryExpression, "base", node)),
.grouped_expression => try self.genGroupedExpression(@fieldParentPtr(Node.GroupedExpression, "base", node)),
.unary_expression => try self.genUnaryExpression(@fieldParentPtr(Node.UnaryExpression, "base", node)),
else => unreachable, // TODO
}
}
pub fn genUnaryExpression(self: *Compiler, unary_expression: *Node.UnaryExpression) Error!void {
try self.genNode(unary_expression.argument);
try self.func.prefix(unary_expression.operator, &self.func.cur_exp);
}
pub fn genBinaryExpression(self: *Compiler, binary_expression: *Node.BinaryExpression) Error!void {
try self.genNode(binary_expression.left);
try self.func.infix(binary_expression.operator, &self.func.cur_exp);
var left_exp = self.func.cur_exp;
try self.genNode(binary_expression.right);
try self.func.posfix(binary_expression.operator, &left_exp, &self.func.cur_exp);
// posfix modifies the left_exp for its result, meaning we need to set it as the current
// TODO this seems like a kind of dumb way to do this, revisit this
self.func.cur_exp = left_exp;
}
pub fn genGroupedExpression(self: *Compiler, grouped_expression: *Node.GroupedExpression) Error!void {
return self.genNode(grouped_expression.expression);
}
pub fn genTableConstructor(self: *Compiler, table_constructor: *Node.TableConstructor) Error!void {
const instruction_index = try self.func.emitABC(.newtable, 0, 0, 0);
self.func.cur_exp = .{ .desc = .{ .relocable = .{ .instruction_index = instruction_index } } };
const table_reg = try self.func.exp2nextreg(&self.func.cur_exp);
var num_keyed_values: zua.object.FloatingPointByteIntType = 0;
var num_array_values: zua.object.FloatingPointByteIntType = 0;
var unflushed_array_values: u8 = 0;
var array_value_exp: ExpDesc = .{ .desc = .{ .@"void" = {} } };
for (table_constructor.fields) |field_node_base| {
const prev_exp = self.func.cur_exp;
// this is here so that the last array value does not get exp2nextreg called
// on it, because we need to handle it differently if it has an unknown number
// of returns
if (array_value_exp.desc != .@"void") {
_ = try self.func.exp2nextreg(&array_value_exp);
array_value_exp = .{ .desc = .{ .@"void" = {} } };
if (unflushed_array_values >= Instruction.SetList.fields_per_flush) {
try self.func.setlist(table_reg, num_array_values, unflushed_array_values);
unflushed_array_values = 0;
}
}
const field_node = @fieldParentPtr(Node.TableField, "base", field_node_base);
try self.genTableField(field_node);
if (field_node.key == null) {
num_array_values += 1;
unflushed_array_values += 1;
array_value_exp = self.func.cur_exp;
} else {
num_keyed_values += 1;
}
self.func.cur_exp = prev_exp;
}
if (unflushed_array_values > 0) {
if (array_value_exp.hasmultret()) {
try self.func.setmultret(&array_value_exp);
try self.func.setlist(table_reg, num_array_values, null);
// don't count this when pre-allocating the table, since
// we don't know how many elements will actually be added
num_array_values -= 1;
} else {
if (array_value_exp.desc != .@"void") {
_ = try self.func.exp2nextreg(&array_value_exp);
}
try self.func.setlist(table_reg, num_array_values, unflushed_array_values);
}
}
if (table_constructor.fields.len > 0) {
const newtable_instruction = @ptrCast(*Instruction.NewTable, &self.func.code.items[instruction_index]);
newtable_instruction.setArraySize(num_array_values);
newtable_instruction.setTableSize(num_keyed_values);
}
}
pub fn genTableField(self: *Compiler, table_field: *Node.TableField) Error!void {
if (table_field.key == null) {
try self.genNode(table_field.value);
} else {
const table_reg = self.func.cur_exp.desc.nonreloc.result_register;
const prev_free_reg = self.func.free_register;
try self.genNode(table_field.key.?);
const key_rk = try self.func.exp2RK(&self.func.cur_exp);
try self.genNode(table_field.value);
const val_rk = try self.func.exp2RK(&self.func.cur_exp);
_ = try self.func.emitInstruction(Instruction.SetTable.init(table_reg, key_rk, val_rk));
self.func.free_register = prev_free_reg;
}
}
pub fn genAssignmentStatement(self: *Compiler, assignment_statement: *Node.AssignmentStatement) Error!void {
if (assignment_statement.is_local) {
for (assignment_statement.variables) |variable_node, i| {
// we can be certain that this is an identifier when assigning with the local keyword
const identifier_node = @fieldParentPtr(Node.Identifier, "base", variable_node);
const name_token = identifier_node.token;
try self.func.new_localvar(name_token, i);
}
try self.genExpList1(assignment_statement.values);
if (assignment_statement.values.len == 0) {
self.func.cur_exp = .{
.desc = .{ .@"void" = {} },
};
}
try self.func.adjust_assign(assignment_statement.variables.len, assignment_statement.values.len, &self.func.cur_exp);
try self.func.adjustlocalvars(assignment_statement.variables.len);
} else {
// TODO check_conflict
// TODO checklimit 'variables in assignment'
const var_exps = try self.arena.alloc(ExpDesc, assignment_statement.variables.len);
defer self.arena.free(var_exps);
for (assignment_statement.variables) |variable_node, i| {
try self.genNode(variable_node);
// store the ExpDesc's for use later
var_exps[i] = self.func.cur_exp;
}
try self.genExpList1(assignment_statement.values);
var last_taken_care_of = false;
if (assignment_statement.values.len != assignment_statement.variables.len) {
try self.func.adjust_assign(assignment_statement.variables.len, assignment_statement.values.len, &self.func.cur_exp);
if (assignment_statement.values.len > assignment_statement.variables.len) {
// remove extra values
self.func.free_register -= @intCast(u8, assignment_statement.values.len - assignment_statement.variables.len);
}
} else {
try self.func.setoneret(&self.func.cur_exp);
try self.func.storevar(&var_exps[var_exps.len - 1], &self.func.cur_exp);
last_taken_care_of = true;
}
// traverse in reverse order to maintain compatibility with
// PUC Lua bytecode order
var unstored_index: usize = assignment_statement.variables.len - 1;
if (last_taken_care_of and unstored_index > 0) unstored_index -= 1;
const finished: bool = unstored_index == 0 and last_taken_care_of;
while (!finished) : (unstored_index -= 1) {
self.func.cur_exp = .{ .desc = .{ .nonreloc = .{ .result_register = self.func.free_register - 1 } } };
try self.func.storevar(&var_exps[unstored_index], &self.func.cur_exp);
if (unstored_index == 0) break;
}
}
}
/// helper function equivalent to explist1 in lparser.c
fn genExpList1(self: *Compiler, nodes: []*Node) Error!void {
for (nodes) |node, i| {
try self.genNode(node);
// skip the last one
if (i != nodes.len - 1) {
_ = try self.func.exp2nextreg(&self.func.cur_exp);
}
}
}
pub fn genReturnStatement(self: *Compiler, return_statement: *Node.ReturnStatement) Error!void {
var first_return_reg: u8 = 0;
var num_return_values: ?u9 = @intCast(u9, return_statement.values.len);
if (num_return_values.? > 0) {
try self.genExpList1(return_statement.values);
if (self.func.cur_exp.hasmultret()) {
try self.func.setmultret(&self.func.cur_exp);
// tail call?
if (self.func.cur_exp.desc == .call and num_return_values.? == 1) {
const instruction = self.func.getcode(&self.func.cur_exp);
instruction.op = .tailcall;
std.debug.assert(instruction.a == self.func.num_active_local_vars);
}
first_return_reg = self.func.num_active_local_vars;
num_return_values = null;
} else {
if (num_return_values.? == 1) {
first_return_reg = try self.func.exp2anyreg(&self.func.cur_exp);
} else {
_ = try self.func.exp2nextreg(&self.func.cur_exp);
first_return_reg = self.func.num_active_local_vars;
std.debug.assert(num_return_values.? == self.func.free_register - first_return_reg);
}
}
}
_ = try self.func.emitReturn(first_return_reg, num_return_values);
}
pub fn genCall(self: *Compiler, call: *Node.Call) Error!void {
try self.genNode(call.expression);
var is_self_call = false;
if (call.expression.id == .field_access) {
const field_access_node = @fieldParentPtr(Node.FieldAccess, "base", call.expression);
is_self_call = field_access_node.separator.isChar(':');
}
if (!is_self_call) {
_ = try self.func.exp2nextreg(&self.func.cur_exp);
}
const func_exp = self.func.cur_exp;
std.debug.assert(func_exp.desc == .nonreloc);
const base: u8 = @intCast(u8, func_exp.desc.nonreloc.result_register);
for (call.arguments) |argument_node| {
try self.genNode(argument_node);
_ = try self.func.exp2nextreg(&self.func.cur_exp);
}
var nparams = self.func.free_register - (base + 1);
// assume 1 return value if this is not a statement, will be modified as necessary later
const num_return_values: u9 = if (call.is_statement) 0 else 1;
const index = try self.func.emitInstruction(Instruction.Call.init(base, @intCast(u9, nparams), num_return_values));
self.func.cur_exp = .{ .desc = .{ .call = .{ .instruction_index = index } } };
// call removes function and arguments, and leaves (unless changed) one result
self.func.free_register = base + 1;
}
pub fn genLiteral(self: *Compiler, literal: *Node.Literal) Error!void {
switch (literal.token.id) {
.string => {
const string_source = self.source[literal.token.start..literal.token.end];
var buf = try self.arena.alloc(u8, string_source.len);
defer self.arena.free(buf);
const parsed = zua.parse_literal.parseString(string_source, buf);
const index = try self.putConstant(Constant{ .string = parsed });
self.func.cur_exp.desc = .{ .constant_index = index };
},
.number => {
const number_source = self.source[literal.token.start..literal.token.end];
const parsed = zua.parse_literal.parseNumber(number_source);
self.func.cur_exp.desc = .{ .number = parsed };
},
.keyword_true => {
self.func.cur_exp.desc = .{ .@"true" = .{} };
},
.keyword_false => {
self.func.cur_exp.desc = .{ .@"false" = .{} };
},
.keyword_nil => {
self.func.cur_exp.desc = .{ .nil = {} };
},
.ellipsis => {
const instruction_index = try self.func.emitInstruction(Instruction.VarArg.init(0, 0));
self.func.cur_exp = .{ .desc = .{ .vararg = .{ .instruction_index = instruction_index } } };
},
.name => {
const name = self.source[literal.token.start..literal.token.end];
const constant_index = try self.putConstant(Constant{ .string = name });
self.func.cur_exp = .{ .desc = .{ .constant_index = constant_index } };
},
else => unreachable,
}
}
pub fn genIdentifier(self: *Compiler, node: *Node.Identifier) Error!void {
if (self.func.findLocalVarByToken(node.token, self.source)) |active_local_var_index| {
self.func.cur_exp = .{ .desc = .{ .local_register = @intCast(u8, active_local_var_index) } };
// TODO if (!base) markupval()
} else {
// TODO upvalues
const name = self.source[node.token.start..node.token.end];
const index = try self.putConstant(Constant{ .string = name });
self.func.cur_exp = .{ .desc = .{ .global = .{ .name_constant_index = index } } };
}
}
pub fn genFieldAccess(self: *Compiler, node: *Node.FieldAccess) Error!void {
if (node.separator.isChar(':')) {
try self.genNode(node.prefix);
const name = self.source[node.field.start..node.field.end];
const constant_index = try self.putConstant(Constant{ .string = name });
var key = ExpDesc{ .desc = .{ .constant_index = constant_index } };
try self.func.handleSelf(&self.func.cur_exp, &key);
} else {
try self.genNode(node.prefix);
_ = try self.func.exp2anyreg(&self.func.cur_exp);
const name = self.source[node.field.start..node.field.end];
const constant_index = try self.putConstant(Constant{ .string = name });
var key = ExpDesc{ .desc = .{ .constant_index = constant_index } };
try self.func.indexed(&self.func.cur_exp, &key);
}
}
pub fn genIndexAccess(self: *Compiler, node: *Node.IndexAccess) Error!void {
try self.genNode(node.prefix);
_ = try self.func.exp2anyreg(&self.func.cur_exp);
var table_exp = self.func.cur_exp;
// reset and then restore afterwards
self.func.cur_exp = ExpDesc{ .desc = .{ .@"void" = {} } };
try self.genNode(node.index);
try self.func.exp2val(&self.func.cur_exp);
try self.func.indexed(&table_exp, &self.func.cur_exp);
self.func.cur_exp = table_exp;
}
pub fn putConstant(self: *Compiler, constant: Constant) Error!usize {
var final_constant = constant;
if (constant == .string and !self.func.constants_map.contains(constant)) {
// dupe the string so that the resulting Function owns all the memory
// TODO how should this memory get cleaned up on compile error?
const dupe = try self.allocator.dupe(u8, constant.string);
final_constant = Constant{ .string = dupe };
}
return self.func.putConstant(final_constant);
}
};
fn getLuacDump(allocator: *Allocator, source: []const u8) ![]const u8 {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
const child = try std.ChildProcess.init(&[_][]const u8{
"luac",
"-s",
"-",
}, allocator);
defer child.deinit();
child.stdin_behavior = .Pipe;
child.stdout_behavior = .Ignore;
child.stderr_behavior = .Ignore;
child.cwd = &tmp.sub_path;
child.cwd_dir = tmp.dir;
try child.spawn();
try child.stdin.?.writer().writeAll(source);
// close stdin and mark it as closed
// TODO is there a more intended way to signal stdin EOF?
child.stdin.?.close();
child.stdin = null;
const term = try child.wait();
switch (term) {
.Exited => |code| {
if (code != 0) {
return error.ExitCodeFailure;
}
},
.Signal, .Stopped, .Unknown => {
return error.ProcessTerminated;
},
}
return tmp.dir.readFileAlloc(allocator, "luac.out", std.math.maxInt(usize));
}
fn testCompile(source: []const u8) !void {
var chunk = try compile(std.testing.allocator, source);
defer chunk.deinit();
try zua.debug.checkcode(&chunk);
var buf = std.ArrayList(u8).init(std.testing.allocator);
defer buf.deinit();
try zua.dump.write(chunk, buf.writer());
const luacDump = try getLuacDump(std.testing.allocator, source);
defer std.testing.allocator.free(luacDump);
//std.debug.print("\n", .{});
//chunk.printCode();
try std.testing.expectEqualSlices(u8, luacDump, buf.items);
}
test "compile hello world" {
try testCompile("print \"hello world\"");
}
test "compile print multiple literals" {
try testCompile("print(nil, true)");
try testCompile("print(nil, true, false, 1)");
}
test "compile return statements" {
try testCompile("return");
try testCompile("return false");
try testCompile("return false, true, \"hello\"");
}
test "compile local statements" {
try testCompile("local a = 1");
try testCompile(
\\local a = "hello world"
\\print(a)
);
try testCompile("local a, b");
try testCompile("local a, b = 1");
try testCompile("local a, b = 1, 2, 3");
}
test "assignment from function return values" {
try testCompile("local a = f()");
try testCompile(
\\local a = f()
\\print(a)
);
try testCompile("local a, b = f()");
try testCompile("local a, b = f(), g()");
}
test "vararg" {
try testCompile("local a = ...");
try testCompile("local a, b, c = ...");
try testCompile(
\\local a, b, c = ...
\\print(a, b, c)
);
try testCompile("return ...");
}
test "gettable" {
try testCompile("a.b()");
try testCompile("a.b(c.a)");
try testCompile("a[true]()");
try testCompile("a[1]()");
}
test "self" {
try testCompile("a:b()");
try testCompile("a:b(1,2,3)");
}
test "setglobal" {
try testCompile("a = 1");
try testCompile("a, b, c = 1, 2, 3");
try testCompile("a = 1, 2, 3");
try testCompile("a, b, c = 1");
}
test "newtable" {
try testCompile("return {}");
try testCompile("return {a=1}");
try testCompile("return {[a]=1}");
try testCompile("return {a=1, b=2, c=3}");
try testCompile("return {1}");
try testCompile("return {1,2,3}");
try testCompile("return {1, a=2, 3}");
try testCompile("return {1, 2, a=b, 3}");
try testCompile("return {a=f()}");
try testCompile("return {" ++ ("a," ** (Instruction.SetList.fields_per_flush + 1)) ++ "}");
try testCompile("return {...}");
try testCompile("return {f()}");
try testCompile("return {f(), 1, 2, 3}");
try testCompile("return {..., 1, 2, 3}");
// massive number of array-like values to overflow the u9 with number of batches
try testCompile("return {" ++ ("a," ** (std.math.maxInt(u9) * Instruction.SetList.fields_per_flush + 1)) ++ "}");
}
test "binary math operators" {
try testCompile("return a + b");
try testCompile("return a + b, b + c");
try testCompile("return a + b / c * d ^ e % f");
// const folding (the compiled version will fold this into a single constant)
try testCompile("return (1 + 2) / 3 * 4 ^ 5 % 6");
}
test "unary minus" {
try testCompile("return -a");
try testCompile("return -1");
try testCompile("return -(1+2)");
}
test "length operator" {
try testCompile("return #a");
try testCompile("return #(1+2)");
try testCompile("return #{}");
}
test "not operator" {
try testCompile("return not true");
try testCompile("return not false");
try testCompile("return not 1");
try testCompile("return not 0");
try testCompile("return not ''");
}
test "concat operator" {
try testCompile("return 'a'..'b'");
try testCompile("return 'a'..'b'..'c'");
// this is a runtime error but it compiles
try testCompile("return 1 .. 2");
}
test "tail call" {
try testCompile("return f()");
} | src/compiler.zig |
const builtin = @import("builtin");
pub const IndexType: type = blk: {
if (!builtin.is_test) {
const options = @import("zmesh_options");
if (@hasDecl(options, "shape_use_32bit_indices")) {
if (options.shape_use_32bit_indices)
break :blk u32;
break :blk u16;
}
break :blk u16;
} else break :blk u16;
};
pub const ShapeHandle = *opaque {};
pub const Shape = @This();
indices: []IndexType,
positions: [][3]f32,
normals: ?[][3]f32,
texcoords: ?[][2]f32,
handle: ShapeHandle,
pub fn deinit(mesh: Shape) void {
par_shapes_free_mesh(mesh.handle);
}
pub fn saveToObj(mesh: Shape, filename: [*:0]const u8) void {
par_shapes_export(mesh.handle, filename);
}
pub fn computeAabb(mesh: Shape, aabb: *[6]f32) void {
par_shapes_compute_aabb(mesh.handle, aabb);
}
pub fn clone(mesh: Shape) Shape {
return initShape(par_shapes_clone(mesh.handle, null));
}
pub fn merge(mesh: *Shape, src_mesh: Shape) void {
par_shapes_merge(mesh.handle, src_mesh.handle);
mesh.* = initShape(mesh.handle);
}
pub fn translate(mesh: *Shape, x: f32, y: f32, z: f32) void {
par_shapes_translate(mesh.handle, x, y, z);
mesh.* = initShape(mesh.handle);
}
pub fn rotate(mesh: *Shape, radians: f32, x: f32, y: f32, z: f32) void {
par_shapes_rotate(mesh.handle, radians, &.{ x, y, z });
mesh.* = initShape(mesh.handle);
}
pub fn scale(mesh: *Shape, x: f32, y: f32, z: f32) void {
par_shapes_scale(mesh.handle, x, y, z);
mesh.* = initShape(mesh.handle);
}
pub fn invert(mesh: *Shape, start_face: i32, num_faces: i32) void {
par_shapes_invert(mesh.handle, start_face, num_faces);
mesh.* = initShape(mesh.handle);
}
pub fn removeDegenerate(mesh: *Shape, min_area: f32) void {
par_shapes_remove_degenerate(mesh.handle, min_area);
mesh.* = initShape(mesh.handle);
}
pub fn unweld(mesh: *Shape) void {
par_shapes_unweld(mesh.handle, true);
mesh.* = initShape(mesh.handle);
}
pub fn weld(mesh: *Shape, epsilon: f32, mapping: ?[*]IndexType) void {
const new_mesh = par_shapes_weld(mesh.handle, epsilon, mapping);
par_shapes_free_mesh(mesh.handle);
mesh.* = initShape(new_mesh);
}
pub fn computeNormals(mesh: *Shape) void {
par_shapes_compute_normals(mesh.handle);
mesh.* = initShape(mesh.handle);
}
fn initShape(handle: ShapeHandle) Shape {
const parmesh = @ptrCast(
*ParShape,
@alignCast(@alignOf(ParShape), handle),
);
return .{
.handle = handle,
.positions = @ptrCast(
[*][3]f32,
parmesh.points,
)[0..@intCast(usize, parmesh.npoints)],
.indices = parmesh.triangles[0..@intCast(usize, parmesh.ntriangles * 3)],
.normals = if (parmesh.normals == null)
null
else
@ptrCast(
[*][3]f32,
parmesh.normals.?,
)[0..@intCast(usize, parmesh.npoints)],
.texcoords = if (parmesh.tcoords == null)
null
else
@ptrCast(
[*][2]f32,
parmesh.tcoords.?,
)[0..@intCast(usize, parmesh.npoints)],
};
}
pub fn initCylinder(slices: i32, stacks: i32) Shape {
return initShape(par_shapes_create_cylinder(slices, stacks));
}
pub fn initCone(slices: i32, stacks: i32) Shape {
return initShape(par_shapes_create_cone(slices, stacks));
}
pub fn initParametricDisk(slices: i32, stacks: i32) Shape {
return initShape(par_shapes_create_parametric_disk(slices, stacks));
}
pub fn initTorus(slices: i32, stacks: i32, radius: f32) Shape {
return initShape(par_shapes_create_torus(slices, stacks, radius));
}
pub fn initParametricSphere(slices: i32, stacks: i32) Shape {
return initShape(par_shapes_create_parametric_sphere(slices, stacks));
}
pub fn initSubdividedSphere(num_subdivisions: i32) Shape {
return initShape(par_shapes_create_subdivided_sphere(num_subdivisions));
}
pub fn initTrefoilKnot(slices: i32, stacks: i32, radius: f32) Shape {
return initShape(par_shapes_create_trefoil_knot(slices, stacks, radius));
}
pub fn initHemisphere(slices: i32, stacks: i32) Shape {
return initShape(par_shapes_create_hemisphere(slices, stacks));
}
pub fn initPlane(slices: i32, stacks: i32) Shape {
return initShape(par_shapes_create_plane(slices, stacks));
}
pub fn initIcosahedron() Shape {
return initShape(par_shapes_create_icosahedron());
}
pub fn initDodecahedron() Shape {
return initShape(par_shapes_create_dodecahedron());
}
pub fn initOctahedron() Shape {
return initShape(par_shapes_create_octahedron());
}
pub fn initTetrahedron() Shape {
return initShape(par_shapes_create_tetrahedron());
}
pub fn initCube() Shape {
return initShape(par_shapes_create_cube());
}
pub fn initDisk(
radius: f32,
slices: i32,
center: *const [3]f32,
normal: *const [3]f32,
) Shape {
return initShape(par_shapes_create_disk(radius, slices, center, normal));
}
pub fn initRock(seed: i32, num_subdivisions: i32) Shape {
return initShape(par_shapes_create_rock(seed, num_subdivisions));
}
pub const UvToPositionFn = fn (
uv: *const [2]f32,
position: *[3]f32,
userdata: ?*anyopaque,
) callconv(.C) void;
pub fn initParametric(
fun: UvToPositionFn,
slices: i32,
stacks: i32,
userdata: ?*anyopaque,
) Shape {
return initShape(par_shapes_create_parametric(fun, slices, stacks, userdata));
}
const ParShape = extern struct {
points: [*]f32,
npoints: c_int,
triangles: [*]IndexType,
ntriangles: c_int,
normals: ?[*]f32,
tcoords: ?[*]f32,
};
extern fn par_shapes_free_mesh(mesh: ShapeHandle) void;
extern fn par_shapes_export(mesh: ShapeHandle, filename: [*:0]const u8) void;
extern fn par_shapes_compute_aabb(mesh: ShapeHandle, aabb: *[6]f32) void;
extern fn par_shapes_clone(mesh: ShapeHandle, target: ?ShapeHandle) ShapeHandle;
extern fn par_shapes_merge(mesh: ShapeHandle, src_mesh: ShapeHandle) void;
extern fn par_shapes_translate(mesh: ShapeHandle, x: f32, y: f32, z: f32) void;
extern fn par_shapes_rotate(
mesh: ShapeHandle,
radians: f32,
axis: *const [3]f32,
) void;
extern fn par_shapes_scale(mesh: ShapeHandle, x: f32, y: f32, z: f32) void;
extern fn par_shapes_invert(
mesh: ShapeHandle,
start_face: i32,
num_faces: i32,
) void;
extern fn par_shapes_remove_degenerate(mesh: ShapeHandle, min_area: f32) void;
extern fn par_shapes_unweld(mesh: ShapeHandle, create_indices: bool) void;
extern fn par_shapes_weld(
mesh: ShapeHandle,
epsilon: f32,
mapping: ?[*]IndexType,
) ShapeHandle;
extern fn par_shapes_compute_normals(mesh: ShapeHandle) void;
extern fn par_shapes_create_cylinder(slices: i32, stacks: i32) ShapeHandle;
extern fn par_shapes_create_cone(slices: i32, stacks: i32) ShapeHandle;
extern fn par_shapes_create_parametric_disk(slices: i32, stacks: i32) ShapeHandle;
extern fn par_shapes_create_torus(slices: i32, stacks: i32, radius: f32) ShapeHandle;
extern fn par_shapes_create_parametric_sphere(slices: i32, stacks: i32) ShapeHandle;
extern fn par_shapes_create_subdivided_sphere(num_subdivisions: i32) ShapeHandle;
extern fn par_shapes_create_trefoil_knot(
slices: i32,
stacks: i32,
radius: f32,
) ShapeHandle;
extern fn par_shapes_create_hemisphere(slices: i32, stacks: i32) ShapeHandle;
extern fn par_shapes_create_plane(slices: i32, stacks: i32) ShapeHandle;
extern fn par_shapes_create_icosahedron() ShapeHandle;
extern fn par_shapes_create_dodecahedron() ShapeHandle;
extern fn par_shapes_create_octahedron() ShapeHandle;
extern fn par_shapes_create_tetrahedron() ShapeHandle;
extern fn par_shapes_create_cube() ShapeHandle;
extern fn par_shapes_create_disk(
radius: f32,
slices: i32,
center: *const [3]f32,
normal: *const [3]f32,
) ShapeHandle;
extern fn par_shapes_create_rock(seed: i32, num_subdivisions: i32) ShapeHandle;
extern fn par_shapes_create_parametric(
fun: UvToPositionFn,
slices: i32,
stacks: i32,
userdata: ?*anyopaque,
) ShapeHandle;
const std = @import("std");
const zmesh = @import("main.zig");
const save = false;
const expect = std.testing.expect;
test "zmesh.basic" {
zmesh.init(std.testing.allocator);
defer zmesh.deinit();
const cylinder = Shape.initCylinder(10, 10);
defer cylinder.deinit();
if (save) cylinder.saveToObj("zmesh.cylinder.obj");
const cone = Shape.initCone(10, 10);
defer cone.deinit();
if (save) cone.saveToObj("zmesh.cone.obj");
const pdisk = Shape.initParametricDisk(10, 10);
defer pdisk.deinit();
if (save) pdisk.saveToObj("zmesh.pdisk.obj");
const torus = Shape.initTorus(10, 10, 0.2);
defer torus.deinit();
if (save) torus.saveToObj("zmesh.torus.obj");
const psphere = Shape.initParametricSphere(10, 10);
defer psphere.deinit();
if (save) psphere.saveToObj("zmesh.psphere.obj");
const subdsphere = Shape.initSubdividedSphere(3);
defer subdsphere.deinit();
if (save) subdsphere.saveToObj("zmesh.subdsphere.obj");
const trefoil_knot = Shape.initTrefoilKnot(10, 100, 0.6);
defer trefoil_knot.deinit();
if (save) trefoil_knot.saveToObj("zmesh.trefoil_knot.obj");
const hemisphere = Shape.initHemisphere(10, 10);
defer hemisphere.deinit();
if (save) hemisphere.saveToObj("zmesh.hemisphere.obj");
const plane = Shape.initPlane(10, 10);
defer plane.deinit();
if (save) plane.saveToObj("zmesh.plane.obj");
const icosahedron = Shape.initIcosahedron();
defer icosahedron.deinit();
if (save) icosahedron.saveToObj("zmesh.icosahedron.obj");
const dodecahedron = Shape.initDodecahedron();
defer dodecahedron.deinit();
if (save) dodecahedron.saveToObj("zmesh.dodecahedron.obj");
const octahedron = Shape.initOctahedron();
defer octahedron.deinit();
if (save) octahedron.saveToObj("zmesh.octahedron.obj");
const tetrahedron = Shape.initTetrahedron();
defer tetrahedron.deinit();
if (save) tetrahedron.saveToObj("zmesh.tetrahedron.obj");
var cube = Shape.initCube();
defer cube.deinit();
cube.unweld();
cube.computeNormals();
if (save) cube.saveToObj("zmesh.cube.obj");
const rock = Shape.initRock(1337, 3);
defer rock.deinit();
if (save) rock.saveToObj("zmesh.rock.obj");
const disk = Shape.initDisk(3.0, 10, &.{ 1, 2, 3 }, &.{ 0, 1, 0 });
defer disk.deinit();
if (save) disk.saveToObj("zmesh.disk.obj");
}
test "zmesh.clone" {
zmesh.init(std.testing.allocator);
defer zmesh.deinit();
const cube = Shape.initCube();
defer cube.deinit();
var clone0 = cube.clone();
defer clone0.deinit();
try expect(@ptrToInt(clone0.handle) != @ptrToInt(cube.handle));
}
test "zmesh.merge" {
zmesh.init(std.testing.allocator);
defer zmesh.deinit();
var cube = Shape.initCube();
defer cube.deinit();
var sphere = Shape.initSubdividedSphere(3);
defer sphere.deinit();
cube.translate(0, 2, 0);
sphere.merge(cube);
cube.translate(0, 2, 0);
sphere.merge(cube);
if (save) sphere.saveToObj("zmesh.merge.obj");
}
test "zmesh.invert" {
zmesh.init(std.testing.allocator);
defer zmesh.deinit();
var hemisphere = Shape.initParametricSphere(10, 10);
defer hemisphere.deinit();
hemisphere.invert(0, 0);
hemisphere.removeDegenerate(0.001);
hemisphere.unweld();
hemisphere.weld(0.001, null);
if (save) hemisphere.saveToObj("zmesh.invert.obj");
} | libs/zmesh/src/Shape.zig |
const std = @import("std");
const windows = @import("windows.zig");
const IUnknown = windows.IUnknown;
const BYTE = windows.BYTE;
const UINT = windows.UINT;
const UINT32 = windows.UINT32;
const UINT64 = windows.UINT64;
const WINAPI = windows.WINAPI;
const LPCWSTR = windows.LPCWSTR;
const BOOL = windows.BOOL;
const DWORD = windows.DWORD;
const GUID = windows.GUID;
const HRESULT = windows.HRESULT;
const WAVEFORMATEX = @import("wasapi.zig").WAVEFORMATEX;
const L = std.unicode.utf8ToUtf16LeStringLiteral;
// NOTE(mziulek):
// xaudio2redist.h uses tight field packing so we need to use 'packed struct' instead of 'extern struct' in
// all non-interface structure definitions.
pub const COMMIT_NOW: UINT32 = 0;
pub const COMMIT_ALL: UINT32 = 0;
pub const INVALID_OPSET: UINT32 = 0xffff_ffff;
pub const NO_LOOP_REGION: UINT32 = 0;
pub const LOOP_INFINITE: UINT32 = 255;
pub const DEFAULT_CHANNELS: UINT32 = 0;
pub const DEFAULT_SAMPLERATE: UINT32 = 0;
pub const MAX_BUFFER_BYTES: UINT32 = 0x8000_0000;
pub const MAX_QUEUED_BUFFERS: UINT32 = 64;
pub const MAX_BUFFERS_SYSTEM: UINT32 = 2;
pub const MAX_AUDIO_CHANNELS: UINT32 = 64;
pub const MIN_SAMPLE_RATE: UINT32 = 1000;
pub const MAX_SAMPLE_RATE: UINT32 = 200000;
pub const MAX_VOLUME_LEVEL: f32 = 16777216.0;
pub const MIN_FREQ_RATIO: f32 = 1.0 / 1024.0;
pub const MAX_FREQ_RATIO: f32 = 1024.0;
pub const DEFAULT_FREQ_RATIO: f32 = 2.0;
pub const MAX_FILTER_ONEOVERQ: f32 = 1.5;
pub const MAX_FILTER_FREQUENCY: f32 = 1.0;
pub const MAX_LOOP_COUNT: UINT32 = 254;
pub const MAX_INSTANCES: UINT32 = 8;
pub const DEBUG_ENGINE: UINT32 = 0x0001;
pub const VOICE_NOPITCH: UINT32 = 0x0002;
pub const VOICE_NOSRC: UINT32 = 0x0004;
pub const VOICE_USEFILTER: UINT32 = 0x0008;
pub const PLAY_TAILS: UINT32 = 0x0020;
pub const END_OF_STREAM: UINT32 = 0x0040;
pub const SEND_USEFILTER: UINT32 = 0x0080;
pub const VOICE_NOSAMPLESPLAYED: UINT32 = 0x0100;
pub const STOP_ENGINE_WHEN_IDLE: UINT32 = 0x2000;
pub const NO_VIRTUAL_AUDIO_CLIENT: UINT32 = 0x10000;
pub const VOICE_DETAILS = packed struct {
CreationFlags: UINT32,
ActiveFlags: UINT32,
InputChannels: UINT32,
InputSampleRate: UINT32,
};
pub const SEND_DESCRIPTOR = packed struct {
Flags: UINT32,
pOutputVoice: *IVoice,
};
pub const VOICE_SENDS = packed struct {
SendCount: UINT32,
pSends: [*]SEND_DESCRIPTOR,
};
pub const EFFECT_DESCRIPTOR = packed struct {
pEffect: *IUnknown,
InitialState: BOOL,
OutputChannels: UINT32,
};
pub const EFFECT_CHAIN = packed struct {
EffectCount: UINT32,
pEffectDescriptors: [*]EFFECT_DESCRIPTOR,
};
pub const FILTER_TYPE = enum(UINT32) {
LowPassFilter,
BandPassFilter,
HighPassFilter,
NotchFilter,
LowPassOnePoleFilter,
HighPassOnePoleFilter,
};
pub const AUDIO_STREAM_CATEGORY = enum(UINT32) {
Other = 0,
ForegroundOnlyMedia = 1,
Communications = 3,
Alerts = 4,
SoundEffects = 5,
GameEffects = 6,
GameMedia = 7,
GameChat = 8,
Speech = 9,
Movie = 10,
Media = 11,
};
pub const FILTER_PARAMETERS = packed struct {
Type: FILTER_TYPE,
Frequency: f32,
OneOverQ: f32,
};
pub const BUFFER = packed struct {
Flags: UINT32,
AudioBytes: UINT32,
pAudioData: [*]const BYTE,
PlayBegin: UINT32,
PlayLength: UINT32,
LoopBegin: UINT32,
LoopLength: UINT32,
LoopCount: UINT32,
pContext: ?*anyopaque,
};
pub const BUFFER_WMA = packed struct {
pDecodedPacketCumulativeBytes: *const UINT32,
PacketCount: UINT32,
};
pub const VOICE_STATE = packed struct {
pCurrentBufferContext: ?*anyopaque,
BuffersQueued: UINT32,
SamplesPlayed: UINT64,
};
pub const PERFORMANCE_DATA = packed struct {
AudioCyclesSinceLastQuery: UINT64,
TotalCyclesSinceLastQuery: UINT64,
MinimumCyclesPerQuantum: UINT32,
MaximumCyclesPerQuantum: UINT32,
MemoryUsageInBytes: UINT32,
CurrentLatencyInSamples: UINT32,
GlitchesSinceEngineStarted: UINT32,
ActiveSourceVoiceCount: UINT32,
TotalSourceVoiceCount: UINT32,
ActiveSubmixVoiceCount: UINT32,
ActiveResamplerCount: UINT32,
ActiveMatrixMixCount: UINT32,
ActiveXmaSourceVoices: UINT32,
ActiveXmaStreams: UINT32,
};
pub const LOG_ERRORS: UINT = 0x0001;
pub const LOG_WARNINGS: UINT = 0x0002;
pub const LOG_INFO: UINT = 0x0004;
pub const LOG_DETAIL: UINT = 0x0008;
pub const LOG_API_CALLS: UINT = 0x0010;
pub const LOG_FUNC_CALLS: UINT = 0x0020;
pub const LOG_TIMING: UINT = 0x0040;
pub const LOG_LOCKS: UINT = 0x0080;
pub const LOG_MEMORY: UINT = 0x0100;
pub const LOG_STREAMING: UINT = 0x1000;
pub const DEBUG_CONFIGURATION = packed struct {
TraceMask: UINT32,
BreakMask: UINT32,
LogThreadID: BOOL,
LogFileline: BOOL,
LogFunctionName: BOOL,
LogTiming: BOOL,
};
pub const IXAudio2 = extern struct {
const Self = @This();
v: *const extern struct {
unknown: IUnknown.VTable(Self),
xaudio2: VTable(Self),
},
usingnamespace IUnknown.Methods(Self);
usingnamespace Methods(Self);
pub fn Methods(comptime T: type) type {
return extern struct {
pub inline fn RegisterForCallbacks(self: *T, cb: *IEngineCallback) HRESULT {
return self.v.xaudio2.RegisterForCallbacks(self, cb);
}
pub inline fn UnregisterForCallbacks(self: *T, cb: *IEngineCallback) void {
self.v.xaudio2.UnregisterForCallbacks(self, cb);
}
pub inline fn CreateSourceVoice(
self: *T,
source_voice: *?*ISourceVoice,
source_format: *const WAVEFORMATEX,
flags: UINT32,
max_frequency_ratio: f32,
callback: ?*IVoiceCallback,
send_list: ?*const VOICE_SENDS,
effect_chain: ?*const EFFECT_CHAIN,
) HRESULT {
return self.v.xaudio2.CreateSourceVoice(
self,
source_voice,
source_format,
flags,
max_frequency_ratio,
callback,
send_list,
effect_chain,
);
}
pub inline fn CreateSubmixVoice(
self: *T,
submix_voice: *?*ISubmixVoice,
input_channels: UINT32,
input_sample_rate: UINT32,
flags: UINT32,
processing_stage: UINT32,
send_list: ?*const VOICE_SENDS,
effect_chain: ?*const EFFECT_CHAIN,
) HRESULT {
return self.v.xaudio2.CreateSubmixVoice(
self,
submix_voice,
input_channels,
input_sample_rate,
flags,
processing_stage,
send_list,
effect_chain,
);
}
pub inline fn CreateMasteringVoice(
self: *T,
mastering_voice: *?*IMasteringVoice,
input_channels: UINT32,
input_sample_rate: UINT32,
flags: UINT32,
device_id: ?LPCWSTR,
effect_chain: ?*const EFFECT_CHAIN,
stream_category: AUDIO_STREAM_CATEGORY,
) HRESULT {
return self.v.xaudio2.CreateMasteringVoice(
self,
mastering_voice,
input_channels,
input_sample_rate,
flags,
device_id,
effect_chain,
stream_category,
);
}
pub inline fn StartEngine(self: *T) HRESULT {
return self.v.xaudio2.StartEngine(self);
}
pub inline fn StopEngine(self: *T) void {
self.v.xaudio2.StopEngine(self);
}
pub inline fn CommitChanges(self: *T, operation_set: UINT32) HRESULT {
return self.v.xaudio2.CommitChanges(self, operation_set);
}
pub inline fn GetPerformanceData(self: *T, data: *PERFORMANCE_DATA) void {
self.v.xaudio2.GetPerformanceData(self, data);
}
pub inline fn SetDebugConfiguration(
self: *T,
config: ?*const DEBUG_CONFIGURATION,
reserved: ?*anyopaque,
) void {
self.v.xaudio2.SetDebugConfiguration(self, config, reserved);
}
};
}
pub fn VTable(comptime T: type) type {
return extern struct {
RegisterForCallbacks: fn (*T, *IEngineCallback) callconv(WINAPI) HRESULT,
UnregisterForCallbacks: fn (*T, *IEngineCallback) callconv(WINAPI) void,
CreateSourceVoice: fn (
*T,
*?*ISourceVoice,
*const WAVEFORMATEX,
UINT32,
f32,
?*IVoiceCallback,
?*const VOICE_SENDS,
?*const EFFECT_CHAIN,
) callconv(WINAPI) HRESULT,
CreateSubmixVoice: fn (
*T,
*?*ISubmixVoice,
UINT32,
UINT32,
UINT32,
UINT32,
?*const VOICE_SENDS,
?*const EFFECT_CHAIN,
) callconv(WINAPI) HRESULT,
CreateMasteringVoice: fn (
*T,
*?*IMasteringVoice,
UINT32,
UINT32,
UINT32,
?LPCWSTR,
?*const EFFECT_CHAIN,
AUDIO_STREAM_CATEGORY,
) callconv(WINAPI) HRESULT,
StartEngine: fn (*T) callconv(WINAPI) HRESULT,
StopEngine: fn (*T) callconv(WINAPI) void,
CommitChanges: fn (*T, UINT32) callconv(WINAPI) HRESULT,
GetPerformanceData: fn (*T, *PERFORMANCE_DATA) callconv(WINAPI) void,
SetDebugConfiguration: fn (*T, ?*const DEBUG_CONFIGURATION, ?*anyopaque) callconv(WINAPI) void,
};
}
};
pub const IVoice = extern struct {
const Self = @This();
v: *const extern struct {
voice: VTable(Self),
},
usingnamespace Methods(Self);
pub fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetVoiceDetails(self: *T, details: *VOICE_DETAILS) void {
self.v.voice.GetVoiceDetails(self, details);
}
pub inline fn SetOutputVoices(self: *T, send_list: ?*const VOICE_SENDS) HRESULT {
return self.v.voice.SetOutputVoices(self, send_list);
}
pub inline fn SetEffectChain(self: *T, effect_chain: ?*const EFFECT_CHAIN) HRESULT {
return self.v.voice.SetEffectChain(self, effect_chain);
}
pub inline fn EnableEffect(self: *T, effect_index: UINT32, operation_set: UINT32) HRESULT {
return self.v.voice.EnableEffect(self, effect_index, operation_set);
}
pub inline fn DisableEffect(self: *T, effect_index: UINT32, operation_set: UINT32) HRESULT {
return self.v.voice.DisableEffect(self, effect_index, operation_set);
}
pub inline fn GetEffectState(self: *T, effect_index: UINT32, enabled: *BOOL) void {
self.v.voice.GetEffectState(self, effect_index, enabled);
}
pub inline fn SetEffectParameters(
self: *T,
effect_index: UINT32,
params: *const anyopaque,
params_size: UINT32,
operation_set: UINT32,
) HRESULT {
return self.v.voice.SetEffectParameters(self, effect_index, params, params_size, operation_set);
}
pub inline fn GetEffectParameters(
self: *T,
effect_index: UINT32,
params: *anyopaque,
params_size: UINT32,
) HRESULT {
return self.v.voice.GetEffectParameters(self, effect_index, params, params_size);
}
pub inline fn SetFilterParameters(
self: *T,
params: *const FILTER_PARAMETERS,
operation_set: UINT32,
) HRESULT {
return self.v.voice.SetFilterParameters(self, params, operation_set);
}
pub inline fn GetFilterParameters(self: *T, params: *FILTER_PARAMETERS) void {
self.v.voice.GetFilterParameters(self, params);
}
pub inline fn SetOutputFilterParameters(
self: *T,
dst_voice: ?*IVoice,
params: *const FILTER_PARAMETERS,
operation_set: UINT32,
) HRESULT {
return self.v.voice.SetOutputFilterParameters(self, dst_voice, params, operation_set);
}
pub inline fn GetOutputFilterParameters(self: *T, dst_voice: ?*IVoice, params: *FILTER_PARAMETERS) void {
self.v.voice.GetOutputFilterParameters(self, dst_voice, params);
}
pub inline fn SetVolume(self: *T, volume: f32) HRESULT {
return self.v.voice.SetVolume(self, volume);
}
pub inline fn GetVolume(self: *T, volume: *f32) void {
self.v.voice.GetVolume(self, volume);
}
pub inline fn SetChannelVolumes(
self: *T,
num_channels: UINT32,
volumes: [*]const f32,
operation_set: UINT32,
) HRESULT {
return self.v.voice.SetChannelVolumes(self, num_channels, volumes, operation_set);
}
pub inline fn GetChannelVolumes(self: *T, num_channels: UINT32, volumes: [*]f32) void {
self.v.voice.GetChannelVolumes(self, num_channels, volumes);
}
pub inline fn DestroyVoice(self: *T) void {
self.v.voice.DestroyVoice(self);
}
};
}
pub fn VTable(comptime T: type) type {
return extern struct {
GetVoiceDetails: fn (*T, *VOICE_DETAILS) callconv(WINAPI) void,
SetOutputVoices: fn (*T, ?*const VOICE_SENDS) callconv(WINAPI) HRESULT,
SetEffectChain: fn (*T, ?*const EFFECT_CHAIN) callconv(WINAPI) HRESULT,
EnableEffect: fn (*T, UINT32, UINT32) callconv(WINAPI) HRESULT,
DisableEffect: fn (*T, UINT32, UINT32) callconv(WINAPI) HRESULT,
GetEffectState: fn (*T, UINT32, *BOOL) callconv(WINAPI) void,
SetEffectParameters: fn (*T, UINT32, *const anyopaque, UINT32, UINT32) callconv(WINAPI) HRESULT,
GetEffectParameters: fn (*T, UINT32, *anyopaque, UINT32) callconv(WINAPI) HRESULT,
SetFilterParameters: fn (*T, *const FILTER_PARAMETERS, UINT32) callconv(WINAPI) HRESULT,
GetFilterParameters: fn (*T, *FILTER_PARAMETERS) callconv(WINAPI) void,
SetOutputFilterParameters: fn (*T, ?*IVoice, *const FILTER_PARAMETERS, UINT32) callconv(WINAPI) HRESULT,
GetOutputFilterParameters: fn (*T, ?*IVoice, *FILTER_PARAMETERS) callconv(WINAPI) void,
SetVolume: fn (*T, f32) callconv(WINAPI) HRESULT,
GetVolume: fn (*T, *f32) callconv(WINAPI) void,
SetChannelVolumes: fn (*T, UINT32, [*]const f32, UINT32) callconv(WINAPI) HRESULT,
GetChannelVolumes: fn (*T, UINT32, [*]f32) callconv(WINAPI) void,
SetOutputMatrix: *anyopaque,
GetOutputMatrix: *anyopaque,
DestroyVoice: fn (*T) callconv(WINAPI) void,
};
}
};
pub const ISourceVoice = extern struct {
const Self = @This();
v: *const extern struct {
voice: IVoice.VTable(Self),
srcvoice: VTable(Self),
},
usingnamespace IVoice.Methods(Self);
usingnamespace Methods(Self);
pub fn Methods(comptime T: type) type {
return extern struct {
pub inline fn Start(self: *T, flags: UINT32, operation_set: UINT32) HRESULT {
return self.v.srcvoice.Start(self, flags, operation_set);
}
pub inline fn Stop(self: *T, flags: UINT32, operation_set: UINT32) HRESULT {
return self.v.srcvoice.Stop(self, flags, operation_set);
}
pub inline fn SubmitSourceBuffer(self: *T, buffer: *const BUFFER, wmabuffer: ?*const BUFFER_WMA) HRESULT {
return self.v.srcvoice.SubmitSourceBuffer(self, buffer, wmabuffer);
}
pub inline fn FlushSourceBuffers(self: *T) HRESULT {
return self.v.srcvoice.FlushSourceBuffers(self);
}
pub inline fn Discontinuity(self: *T) HRESULT {
return self.v.srcvoice.Discontinuity(self);
}
pub inline fn ExitLoop(self: *T, operation_set: UINT32) HRESULT {
return self.v.srcvoice.ExitLoop(self, operation_set);
}
pub inline fn GetState(self: *T, state: *VOICE_STATE, flags: UINT32) void {
self.v.srcvoice.GetState(self, state, flags);
}
pub inline fn SetFrequencyRatio(self: *T, ratio: f32, operation_set: UINT32) HRESULT {
return self.v.srcvoice.SetFrequencyRatio(self, ratio, operation_set);
}
pub inline fn GetFrequencyRatio(self: *T, ratio: *f32) void {
self.v.srcvoice.GetFrequencyRatio(self, ratio);
}
pub inline fn SetSourceSampleRate(self: *T, sample_rate: UINT32) HRESULT {
return self.v.srcvoice.SetSourceSampleRate(self, sample_rate);
}
};
}
pub fn VTable(comptime T: type) type {
return extern struct {
Start: fn (*T, UINT32, UINT32) callconv(WINAPI) HRESULT,
Stop: fn (*T, UINT32, UINT32) callconv(WINAPI) HRESULT,
SubmitSourceBuffer: fn (*T, *const BUFFER, ?*const BUFFER_WMA) callconv(WINAPI) HRESULT,
FlushSourceBuffers: fn (*T) callconv(WINAPI) HRESULT,
Discontinuity: fn (*T) callconv(WINAPI) HRESULT,
ExitLoop: fn (*T, UINT32) callconv(WINAPI) HRESULT,
GetState: fn (*T, *VOICE_STATE, UINT32) callconv(WINAPI) void,
SetFrequencyRatio: fn (*T, f32, UINT32) callconv(WINAPI) HRESULT,
GetFrequencyRatio: fn (*T, *f32) callconv(WINAPI) void,
SetSourceSampleRate: fn (*T, UINT32) callconv(WINAPI) HRESULT,
};
}
};
pub const ISubmixVoice = extern struct {
const Self = @This();
v: *const extern struct {
voice: IVoice.VTable(Self),
submixvoice: VTable(Self),
},
usingnamespace IVoice.Methods(Self);
usingnamespace Methods(Self);
pub fn Methods(comptime T: type) type {
_ = T;
return extern struct {};
}
pub fn VTable(comptime T: type) type {
_ = T;
return extern struct {};
}
};
pub const IMasteringVoice = extern struct {
const Self = @This();
v: *const extern struct {
voice: IVoice.VTable(Self),
mastervoice: VTable(Self),
},
usingnamespace IVoice.Methods(Self);
usingnamespace Methods(Self);
pub fn Methods(comptime T: type) type {
return extern struct {
pub inline fn GetChannelMask(self: *T, channel_mask: *DWORD) HRESULT {
return self.v.mastervoice.GetChannelMask(self, channel_mask);
}
};
}
pub fn VTable(comptime T: type) type {
return extern struct {
GetChannelMask: fn (*T, *DWORD) callconv(WINAPI) HRESULT,
};
}
};
pub fn IEngineCallbackVTable(comptime T: type) type {
return extern struct {
ecb: extern struct {
OnProcessingPassStart: fn (*T) callconv(WINAPI) void,
OnProcessingPassEnd: fn (*T) callconv(WINAPI) void,
OnCriticalError: fn (*T, HRESULT) callconv(WINAPI) void,
},
};
}
pub const IEngineCallback = extern struct {
v: *const IEngineCallbackVTable(Self),
const Self = @This();
usingnamespace Methods(Self);
pub fn Methods(comptime T: type) type {
return extern struct {
pub inline fn OnProcessingPassStart(self: *T) void {
self.v.ecb.OnProcessingPassStart(self);
}
pub inline fn OnProcessingPassEnd(self: *T) void {
self.v.ecb.OnProcessingPassEnd(self);
}
pub inline fn OnCriticalError(self: *T, err: HRESULT) void {
self.v.ecb.OnCriticalError(self, err);
}
};
}
};
pub fn IVoiceCallbackVTable(comptime T: type) type {
return extern struct {
vcb: extern struct {
OnVoiceProcessingPassStart: fn (*T, UINT32) callconv(WINAPI) void,
OnVoiceProcessingPassEnd: fn (*T) callconv(WINAPI) void,
OnStreamEnd: fn (*T) callconv(WINAPI) void,
OnBufferStart: fn (*T, ?*anyopaque) callconv(WINAPI) void,
OnBufferEnd: fn (*T, ?*anyopaque) callconv(WINAPI) void,
OnLoopEnd: fn (*T, ?*anyopaque) callconv(WINAPI) void,
OnVoiceError: fn (*T, ?*anyopaque, HRESULT) callconv(WINAPI) void,
},
};
}
pub const IVoiceCallback = extern struct {
v: *const IVoiceCallbackVTable(Self),
const Self = @This();
usingnamespace Methods(Self);
pub fn Methods(comptime T: type) type {
return extern struct {
pub inline fn OnVoiceProcessingPassStart(self: *T, bytes_required: UINT32) void {
self.v.vcb.OnVoiceProcessingPassStart(self, bytes_required);
}
pub inline fn OnVoiceProcessingPassEnd(self: *T) void {
self.v.vcb.OnVoiceProcessingPassEnd(self);
}
pub inline fn OnStreamEnd(self: *T) void {
self.v.vcb.OnStreamEnd(self);
}
pub inline fn OnBufferStart(self: *T, context: ?*anyopaque) void {
self.v.vcb.OnBufferStart(self, context);
}
pub inline fn OnBufferEnd(self: *T, context: ?*anyopaque) void {
self.v.vcb.OnBufferEnd(self, context);
}
pub inline fn OnLoopEnd(self: *T, context: ?*anyopaque) void {
self.v.vcb.OnLoopEnd(self, context);
}
pub inline fn OnVoiceError(self: *T, context: ?*anyopaque, err: HRESULT) void {
self.v.vcb.OnVoiceError(self, context, err);
}
};
}
};
pub fn create(
ppv: *?*IXAudio2,
flags: UINT32, // 0
processor: UINT32, // 0
) HRESULT {
var xaudio2_dll = windows.kernel32.GetModuleHandleW(L("xaudio2_9redist.dll"));
if (xaudio2_dll == null) {
xaudio2_dll = (std.DynLib.openZ("xaudio2_9redist.dll") catch unreachable).dll;
}
var XAudio2Create: fn (*?*IXAudio2, UINT32, UINT32) callconv(WINAPI) HRESULT = undefined;
XAudio2Create = @ptrCast(
@TypeOf(XAudio2Create),
windows.kernel32.GetProcAddress(xaudio2_dll.?, "XAudio2Create").?,
);
return XAudio2Create(ppv, flags, processor);
} | modules/platform/vendored/zwin32/src/xaudio2.zig |
const std = @import("std");
const builtin = @import("builtin");
const stdx = @import("stdx");
const Vec2 = stdx.math.Vec2;
const vec2 = Vec2.init;
const WasmJsBuffer = stdx.wasm.WasmJsBuffer;
const graphics = @import("../../graphics.zig");
const Image = graphics.Image;
const ImageId = graphics.ImageId;
const svg = graphics.svg;
const BlendMode = graphics.BlendMode;
const Color = graphics.Color;
const FontId = graphics.font.FontId;
const FontGroupId = graphics.font.FontGroupId;
const UserVMetrics = graphics.font.UserVMetrics;
const TextMeasure = graphics.TextMeasure;
const log = stdx.log.scoped(.graphics_canvas);
extern "graphics" fn jsSave() void;
extern "graphics" fn jsRestore() void;
extern "graphics" fn jsClipRect(x: f32, y: f32, width: f32, height: f32) void;
extern "graphics" fn jsDrawRect(x: f32, y: f32, width: f32, height: f32) void;
extern "graphics" fn jsFillRect(x: f32, y: f32, width: f32, height: f32) void;
extern "graphics" fn jsFillCircle(x: f32, y: f32, radius: f32) void;
extern "graphics" fn jsDrawCircle(x: f32, y: f32, radius: f32) void;
extern "graphics" fn jsFillCircleSector(x: f32, y: f32, radius: f32, start_rad: f32, end_rad: f32) void;
extern "graphics" fn jsDrawCircleArc(x: f32, y: f32, radius: f32, start_rad: f32, end_rad: f32) void;
extern "graphics" fn jsFillEllipse(x: f32, y: f32, h_radius: f32, v_radius: f32) void;
extern "graphics" fn jsDrawEllipse(x: f32, y: f32, h_radius: f32, v_radius: f32) void;
extern "graphics" fn jsFillEllipseSector(x: f32, y: f32, h_radius: f32, v_radius: f32, start_rad: f32, end_rad: f32) void;
extern "graphics" fn jsDrawEllipseArc(x: f32, y: f32, h_radius: f32, v_radius: f32, start_rad: f32, end_rad: f32) void;
extern "graphics" fn jsFillTriangle(x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32) void;
extern "graphics" fn jsFillPolygon(buf_ptr: [*]const u8, num_verts: u32) void;
extern "graphics" fn jsDrawPolygon(buf_ptr: [*]const u8, num_verts: u32) void;
extern "graphics" fn jsFillRoundRect(x: f32, y: f32, width: f32, height: f32, radius: f32) void;
extern "graphics" fn jsDrawRoundRect(x: f32, y: f32, width: f32, height: f32, radius: f32) void;
extern "graphics" fn jsDrawPoint(x: f32, y: f32) void;
extern "graphics" fn jsDrawLine(x1: f32, y1: f32, x2: f32, y2: f32) void;
extern "graphics" fn jsDrawCubicBezierCurve(x1: f32, y1: f32, c1x: f32, c1y: f32, c2x: f32, c2y: f32, x2: f32, y2: f32) void;
extern "graphics" fn jsDrawQuadraticBezierCurve(x1: f32, y1: f32, cx: f32, cy: f32, x2: f32, y2: f32) void;
extern "graphics" fn jsFillStyle(r: f32, g: f32, b: f32, a: f32) void;
extern "graphics" fn jsStrokeStyle(r: f32, g: f32, b: f32, a: f32) void;
extern "graphics" fn jsSetClearColor(r: f32, g: f32, b: f32, a: f32) void;
extern "graphics" fn jsFillText(x: f32, y: f32, ptr: [*]const u8, len: usize) void;
extern "graphics" fn jsSetLineWidth(width: f32) void;
extern "graphics" fn jsMeasureTexts(args_buffer: [*]const u8) usize;
extern "graphics" fn jsGetPrimaryFontVMetrics(font_gid: usize, font_size: f32, res_ptr: [*]const u8) void;
extern "graphics" fn jsAddFont(path_ptr: [*]const u8, path_len: usize, name_ptr: [*]const u8, name_len: usize) FontId;
extern "graphics" fn jsGetFont(name_ptr: [*]const u8, name_len: usize) FontId;
extern "graphics" fn jsSetFontStyle(font_gid: FontGroupId, font_size: f32) void;
extern "graphics" fn jsTranslate(x: f32, y: f32) void;
extern "graphics" fn jsRotate(rad: f32) void;
extern "graphics" fn jsScale(x: f32, y: f32) void;
extern "graphics" fn jsResetTransform() void;
extern "graphics" fn jsCreateImage(promise_id: u32, ptr: [*]const u8, len: usize) void;
extern "graphics" fn jsDrawImageSized(image_id: u32, x: f32, y: f32, width: f32, height: f32) void;
extern "graphics" fn jsDrawImage(image_id: u32, x: f32, y: f32) void;
// Incremental path ops.
extern "graphics" fn jsFill() void;
extern "graphics" fn jsStroke() void;
extern "graphics" fn jsClosePath() void;
extern "graphics" fn jsMoveTo(x: f32, y: f32) void;
extern "graphics" fn jsLineTo(x: f32, y: f32) void;
extern "graphics" fn jsQuadraticCurveTo(cx: f32, cy: f32, x2: f32, y2: f32) void;
extern "graphics" fn jsCubicCurveTo(c1x: f32, c1y: f32, c2x: f32, c2y: f32, x2: f32, y2: f32) void;
pub const Graphics = struct {
const Self = @This();
js_buf: *WasmJsBuffer,
clear_color: Color,
cur_stroke_color: Color,
cur_fill_color: Color,
cur_font_gid: FontGroupId,
cur_font_size: f32,
cur_line_width: f32,
// Used to keep link results back to TextMeasures
text_measures_buffer: std.ArrayList(*TextMeasure),
pub fn init(self: *Self, alloc: std.mem.Allocator) void {
_ = alloc;
self.* = .{
.clear_color = Color.initFloat(0, 0, 0, 1.0),
.text_measures_buffer = std.ArrayList(*TextMeasure).init(alloc),
.cur_stroke_color = undefined,
.cur_fill_color = undefined,
.cur_font_gid = 0,
.cur_font_size = 0,
.cur_line_width = undefined,
.js_buf = stdx.wasm.getJsBuffer(),
};
self.setClearColor(self.clear_color);
self.forceSetFillColor(Color.Black);
self.forceSetStrokeColor(Color.Black);
self.setLineWidth(1);
}
pub fn deinit(self: *Self) void {
_ = self;
self.text_measures_buffer.deinit();
self.text_buf.deinit();
}
pub fn endCmd(self: *Self) void {
_ = self;
}
pub fn save(self: *Self) void {
_ = self;
jsSave();
}
pub fn clipRect(self: *Self, x: f32, y: f32, width: f32, height: f32) void {
_ = self;
jsClipRect(x, y, width, height);
}
pub fn restore(self: *Self) void {
_ = self;
jsRestore();
}
pub fn setBlendMode(self: *Self, mode: BlendMode) void {
_ = mode;
_ = self;
stdx.unsupported();
}
pub fn resetTransform(self: *Self) void {
_ = self;
jsResetTransform();
}
pub fn scale(self: *Self, x: f32, y: f32) void {
_ = self;
jsScale(x, y);
}
pub fn rotate(self: *Self, rad: f32) void {
_ = self;
jsRotate(rad);
}
pub fn translate(self: *Self, x: f32, y: f32) void {
_ = self;
jsTranslate(x, y);
}
pub fn getLineWidth(self: Self) f32 {
return self.cur_line_width;
}
pub fn setLineWidth(self: *Self, width: f32) void {
_ = self;
self.cur_line_width = width;
jsSetLineWidth(width);
}
// This might be useful:
// https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/textBaseline
pub fn fillText(self: *Self, x: f32, y: f32, text: []const u8) void {
_ = self;
jsFillText(x, y, text.ptr, text.len);
}
pub fn drawRect(self: *Self, x: f32, y: f32, width: f32, height: f32) void {
_ = self;
jsDrawRect(x, y, width, height);
}
pub fn fillRect(self: *Self, x: f32, y: f32, width: f32, height: f32) void {
_ = self;
jsFillRect(x, y, width, height);
}
pub fn fillCircle(self: *Self, x: f32, y: f32, radius: f32) void {
_ = self;
jsFillCircle(x, y, radius);
}
pub fn drawCircle(self: *Self, x: f32, y: f32, radius: f32) void {
_ = self;
jsDrawCircle(x, y, radius);
}
pub fn fillCircleSector(self: *Self, x: f32, y: f32, radius: f32, start_rad: f32, sweep_rad: f32) void {
_ = self;
if (sweep_rad < 0) {
jsFillCircleSector(x, y, radius, start_rad + sweep_rad, start_rad);
} else {
jsFillCircleSector(x, y, radius, start_rad, start_rad + sweep_rad);
}
}
pub fn drawCircleArc(self: *Self, x: f32, y: f32, radius: f32, start_rad: f32, sweep_rad: f32) void {
_ = self;
if (sweep_rad < 0) {
jsDrawCircleArc(x, y, radius, start_rad + sweep_rad, start_rad);
} else {
jsDrawCircleArc(x, y, radius, start_rad, start_rad + sweep_rad);
}
}
pub fn fillEllipse(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32) void {
_ = self;
jsFillEllipse(x, y, h_radius, v_radius);
}
pub fn drawEllipse(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32) void {
_ = self;
jsDrawEllipse(x, y, h_radius, v_radius);
}
pub fn fillEllipseSector(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32, start_rad: f32, sweep_rad: f32) void {
_ = self;
if (sweep_rad < 0) {
jsFillEllipseSector(x, y, h_radius, v_radius, start_rad + sweep_rad, start_rad);
} else {
jsFillEllipseSector(x, y, h_radius, v_radius, start_rad, start_rad + sweep_rad);
}
}
pub fn drawEllipseArc(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32, start_rad: f32, sweep_rad: f32) void {
_ = self;
if (sweep_rad < 0) {
jsDrawEllipseArc(x, y, h_radius, v_radius, start_rad + sweep_rad, start_rad);
} else {
jsDrawEllipseArc(x, y, h_radius, v_radius, start_rad, start_rad + sweep_rad);
}
}
pub fn fillTriangle(self: *Self, x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32) void {
_ = self;
jsFillTriangle(x1, y1, x2, y2, x3, y3);
}
pub fn fillPolygon(self: *Self, pts: []const Vec2) void {
_ = self;
self.js_buf.clearOutput();
for (pts) |pt| {
self.js_buf.appendF32(pt.x);
self.js_buf.appendF32(pt.y);
}
jsFillPolygon(self.js_buf.getOutputPtr(), pts.len);
}
pub fn drawPolygon(self: *Self, pts: []const Vec2) void {
_ = self;
self.js_buf.clearOutput();
for (pts) |pt| {
self.js_buf.appendF32(pt.x);
self.js_buf.appendF32(pt.y);
}
jsDrawPolygon(self.js_buf.getOutputPtr(), pts.len);
}
pub fn fillRoundRect(self: *Self, x: f32, y: f32, width: f32, height: f32, radius: f32) void {
_ = self;
jsFillRoundRect(x, y, width, height, radius);
}
pub fn drawRoundRect(self: *Self, x: f32, y: f32, width: f32, height: f32, radius: f32) void {
_ = self;
jsDrawRoundRect(x, y, width, height, radius);
}
pub fn drawPoint(self: *Self, x: f32, y: f32) void {
_ = self;
jsDrawPoint(x, y);
}
pub fn drawLine(self: *Self, x1: f32, y1: f32, x2: f32, y2: f32) void {
_ = self;
jsDrawLine(x1, y1, x2, y2);
}
pub fn drawQuadraticBezierCurve(self: *Self, x1: f32, y1: f32, cx: f32, cy: f32, x2: f32, y2: f32) void {
_ = self;
jsDrawQuadraticBezierCurve(x1, y1, cx, cy, x2, y2);
}
pub fn drawCubicBezierCurve(self: *Self, x1: f32, y1: f32, c1x: f32, c1y: f32, c2x: f32, c2y: f32, x2: f32, y2: f32) void {
_ = self;
jsDrawCubicBezierCurve(x1, y1, c1x, c1y, c2x, c2y, x2, y2);
}
// Iterator of TextMeasure data
pub fn measureTexts(self: *Self, iter: anytype) void {
_ = self;
var _iter = iter;
// Write text ptrs to wasm output buffer.
// Skip headers and numTexts until we finish the iterator.
self.js_buf.clearOutputWithSize(10);
self.text_measures_buffer.shrinkRetainingCapacity(0);
while (_iter.nextPtr()) |it| {
if (it.needs_measure) {
it.needs_measure = false;
// Empty text has size 0.
if (it.text.len == 0) {
it.size.width = 0;
continue;
}
// Record TextMeasure to link with result.
self.text_measures_buffer.append(it) catch unreachable;
self.js_buf.appendInt(u32, @ptrToInt(it.text.ptr));
self.js_buf.appendInt(u16, it.text.len);
// log.debug("len from zig {}", .{@intCast(u16, it.text.len)});
self.js_buf.appendInt(u16, it.font_gid);
self.js_buf.appendF32(it.font_size);
}
}
if (self.text_measures_buffer.items.len == 0) {
return;
}
// Write headers.
self.js_buf.writeIntAt(u32, 0, @ptrToInt(self.js_buf.input_buf.items.ptr));
self.js_buf.writeIntAt(u32, 4, self.js_buf.input_buf.capacity);
self.js_buf.writeIntAt(u16, 8, @intCast(u16, self.text_measures_buffer.items.len));
const input_len = jsMeasureTexts(self.js_buf.output_buf.items.ptr);
self.js_buf.input_buf.resize(input_len) catch unreachable;
var offset: usize = 0;
for (self.text_measures_buffer.items) |it| {
const width = self.js_buf.readF32At(offset);
it.size.width = width;
it.needs_measure = false;
offset += 4;
}
const last = self.text_measures_buffer.items[self.text_measures_buffer.items.len - 1];
self.cur_font_gid = last.font_gid;
self.cur_font_size = last.font_size;
}
fn setClearColor(self: *Self, color: Color) void {
_ = self;
jsSetClearColor(@intToFloat(f32, color.channels.r), @intToFloat(f32, color.channels.g), @intToFloat(f32, color.channels.b), @intToFloat(f32, color.channels.a) / 255);
}
fn forceSetStrokeColor(self: *Self, color: Color) void {
jsStrokeStyle(@intToFloat(f32, color.channels.r), @intToFloat(f32, color.channels.g), @intToFloat(f32, color.channels.b), @intToFloat(f32, color.channels.a) / 255);
self.cur_stroke_color = color;
}
fn forceSetFillColor(self: *Self, color: Color) void {
jsFillStyle(@intToFloat(f32, color.channels.r), @intToFloat(f32, color.channels.g), @intToFloat(f32, color.channels.b), @intToFloat(f32, color.channels.a) / 255);
self.cur_fill_color = color;
}
pub fn setFont(self: *Self, font_gid: FontGroupId, font_size: f32) void {
if (font_gid != self.cur_font_gid or font_size != self.cur_font_size) {
jsSetFontStyle(font_gid, font_size);
self.cur_font_gid = font_gid;
self.cur_font_size = font_size;
}
}
pub fn setFontSize(self: *Self, font_size: f32) void {
if (font_size != self.cur_font_size) {
jsSetFontStyle(self.cur_font_gid, font_size);
self.cur_font_size = font_size;
}
}
pub fn getStrokeColor(self: Self) Color {
return self.cur_stroke_color;
}
pub fn setStrokeColor(self: *Self, color: Color) void {
if (!std.meta.eql(color, self.cur_stroke_color)) {
self.forceSetStrokeColor(color);
}
}
pub fn getFillColor(self: Self) Color {
return self.cur_fill_color;
}
pub fn setFillColor(self: *Self, color: Color) void {
if (!std.meta.eql(color, self.cur_fill_color)) {
self.forceSetFillColor(color);
}
}
// NOTE: Does not support UserVMetrics.line_gap.
// ascent/height are estimated since they do not come from the underlying font file but from dom measurement.
pub fn getPrimaryFontVMetrics(self: *const Self, font_gid: FontGroupId, font_size: f32) UserVMetrics {
_ = self;
self.js_buf.input_buf.resize(8) catch unreachable;
jsGetPrimaryFontVMetrics(font_gid, font_size, self.js_buf.input_buf.items.ptr);
const ascent = self.js_buf.readF32At(0);
const height = self.js_buf.readF32At(4);
const descent = -(height - ascent);
return .{
.ascender = ascent,
.descender = descent,
.height = height,
.line_gap = 0,
};
}
/// Path is absolute or relative to the current web dir.
pub fn addTTF_FontFromPath(self: *Self, path: []const u8, name: []const u8) FontId {
_ = self;
return jsAddFont(path.ptr, path.len, name.ptr, name.len);
}
pub fn getFontByName(self: *Self, name: []const u8) FontId {
_ = self;
return jsGetFont(name.ptr, name.len);
}
// pub fn getFontGroupBySingleFontName(self: *Self, name: []const u8) FontGroupId {
// _ = self;
// return jsGetFontGroup(name.ptr, name.len);
// }
pub fn fillSvgPath(self: *Self, x: f32, y: f32, path: *const svg.SvgPath) void {
self.drawSvgPath(x, y, path, true);
}
pub fn strokeSvgPath(self: *Self, x: f32, y: f32, path: *const svg.SvgPath) void {
self.drawSvgPath(x, y, path, false);
}
fn drawSvgPath(self: *Self, x: f32, y: f32, path: *const svg.SvgPath, fill: bool) void {
_ = self;
// log.debug("drawSvgPath {}", .{path.cmds.len});
_ = x;
_ = y;
var cur_pos = vec2(0, 0);
var cur_data_idx: u32 = 0;
var last_control_pos = vec2(0, 0);
var last_cmd_was_curveto = false;
for (path.cmds) |it| {
var cmd_is_curveto = false;
switch (it) {
.MoveTo => {
// log.debug("lyon begin", .{});
const data = path.getData(.MoveTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.MoveTo)) / 4;
cur_pos.x = data.x;
cur_pos.y = data.y;
jsMoveTo(cur_pos.x, cur_pos.y);
},
.MoveToRel => {
const data = path.getData(.MoveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.MoveToRel)) / 4;
cur_pos.x += data.x;
cur_pos.y += data.y;
jsMoveTo(cur_pos.x, cur_pos.y);
},
.VertLineTo => {
const data = path.getData(.VertLineTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.VertLineTo)) / 4;
cur_pos.y = data.y;
jsLineTo(cur_pos.x, cur_pos.y);
},
.VertLineToRel => {
const data = path.getData(.VertLineToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.VertLineToRel)) / 4;
cur_pos.y += data.y;
jsLineTo(cur_pos.x, cur_pos.y);
},
.LineTo => {
const data = path.getData(.LineTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.LineTo)) / 4;
cur_pos.x = data.x;
cur_pos.y = data.y;
jsLineTo(cur_pos.x, cur_pos.y);
},
.LineToRel => {
const data = path.getData(.LineToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.LineToRel)) / 4;
cur_pos.x += data.x;
cur_pos.y += data.y;
jsLineTo(cur_pos.x, cur_pos.y);
},
.CurveTo => {
const data = path.getData(.CurveTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.CurveTo)) / 4;
cur_pos.x = data.x;
cur_pos.y = data.y;
last_control_pos.x = data.cb_x;
last_control_pos.y = data.cb_y;
cmd_is_curveto = true;
jsCubicCurveTo(data.ca_x, data.ca_y, last_control_pos.x, last_control_pos.y, cur_pos.x, cur_pos.y);
},
.CurveToRel => {
const data = path.getData(.CurveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.CurveToRel)) / 4;
const prev_x = cur_pos.x;
const prev_y = cur_pos.y;
cur_pos.x += data.x;
cur_pos.y += data.y;
last_control_pos.x = prev_x + data.cb_x;
last_control_pos.y = prev_y + data.cb_y;
cmd_is_curveto = true;
jsCubicCurveTo(prev_x + data.ca_x, prev_y + data.ca_y, last_control_pos.x, last_control_pos.y, cur_pos.x, cur_pos.y);
},
.SmoothCurveTo => {
const data = path.getData(.SmoothCurveTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.SmoothCurveTo)) / 4;
// Reflection of last control point over current pos.
var c1_x: f32 = undefined;
var c1_y: f32 = undefined;
if (last_cmd_was_curveto) {
c1_x = cur_pos.x + (cur_pos.x - last_control_pos.x);
c1_y = cur_pos.y + (cur_pos.y - last_control_pos.y);
} else {
c1_x = cur_pos.x;
c1_y = cur_pos.y;
}
cur_pos.x = data.x;
cur_pos.y = data.y;
last_control_pos.x = data.c2_x;
last_control_pos.y = data.c2_y;
cmd_is_curveto = true;
jsCubicCurveTo(c1_x, c1_y, last_control_pos.x, last_control_pos.y, cur_pos.x, cur_pos.y);
},
.SmoothCurveToRel => {
const data = path.getData(.SmoothCurveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.SmoothCurveToRel)) / 4;
const prev_x = cur_pos.x;
const prev_y = cur_pos.y;
var c1_x: f32 = undefined;
var c1_y: f32 = undefined;
if (last_cmd_was_curveto) {
// Reflection of last control point over current pos.
c1_x = cur_pos.x + (cur_pos.x - last_control_pos.x);
c1_y = cur_pos.y + (cur_pos.y - last_control_pos.y);
} else {
c1_x = cur_pos.x;
c1_y = cur_pos.y;
}
cur_pos.x += data.x;
cur_pos.y += data.y;
last_control_pos.x = prev_x + data.c2_x;
last_control_pos.y = prev_y + data.c2_y;
cmd_is_curveto = true;
jsCubicCurveTo(c1_x, c1_y, last_control_pos.x, last_control_pos.y, cur_pos.x, cur_pos.y);
},
.ClosePath => {
jsClosePath();
},
}
last_cmd_was_curveto = cmd_is_curveto;
}
if (fill) {
jsFill();
} else {
jsStroke();
}
}
pub fn createImageFromPathPromise(self: *Self, path: []const u8) stdx.wasm.Promise(Image) {
_ = self;
const p = stdx.wasm.createPromise(Image);
jsCreateImage(p.id, path.ptr, path.len);
return p;
}
pub fn drawImageSized(self: *Self, x: f32, y: f32, width: f32, height: f32, image_id: ImageId) void {
_ = self;
jsDrawImageSized(image_id, x, y, width, height);
}
pub fn drawImage(self: *Self, x: f32, y: f32, image_id: ImageId) void {
_ = self;
jsDrawImage(image_id, x, y);
}
};
comptime {
// Conditionally export, or desktop builds will have the wrong malloc.
if (builtin.target.isWasm()) {
@export(wasmResolveImagePromise, .{ .name = "wasmResolveImagePromise", .linkage = .Strong });
}
}
fn wasmResolveImagePromise(promise_id: stdx.wasm.PromiseId, image_id: ImageId, width: usize, height: usize) callconv(.C) void {
stdx.wasm.resolvePromise(promise_id, Image{
.id = image_id,
.width = width,
.height = height,
});
} | graphics/src/backend/canvas/graphics.zig |
const std = @import("std");
const lola = @import("lola");
////
// Minimal API example:
// This example shows how to get started with the LoLa library.
// Compiles and runs the Hello-World program.
//
const example_source =
\\Print("Hello, World!");
\\
;
// This is required for the runtime library to be able to provide
// object implementations.
pub const ObjectPool = lola.runtime.ObjectPool([_]type{
lola.libs.runtime.LoLaDictionary,
lola.libs.runtime.LoLaList,
});
pub fn main() anyerror!u8 {
var gpa_state = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa_state.deinit();
const allocator = &gpa_state.allocator;
// Step 1: Compile the source code into a compile unit
// This stores the error messages and warnings, we
// just keep it and print all messages on exit (if any).
var diagnostics = lola.compiler.Diagnostics.init(allocator);
defer {
for (diagnostics.messages.items) |msg| {
std.debug.print("{}\n", .{msg});
}
diagnostics.deinit();
}
// This compiles a piece of source code into a compile unit.
// A compile unit is a piece of LoLa IR code with metadata for
// all existing functions, debug symbols and so on. It can be loaded into
// a environment and be executed.
var compile_unit = (try lola.compiler.compile(allocator, &diagnostics, "example_source", example_source)) orelse {
std.debug.print("failed to compile example_source!\n", .{});
return 1;
};
defer compile_unit.deinit();
// A object pool is required for garabge collecting object handles
// stored in several LoLa environments and virtual machines.
var pool = ObjectPool.init(allocator);
defer pool.deinit();
// A environment stores global variables and provides functions
// to the virtual machines. It is also a possible LoLa object that
// can be passed into virtual machines.
var env = try lola.runtime.Environment.init(allocator, &compile_unit, pool.interface());
defer env.deinit();
// Install both standard and runtime library into
// our environment. You can see how to implement custom
// functions if you check out the implementation of both
// libraries!
try lola.libs.std.install(&env, allocator);
try lola.libs.runtime.install(&env, allocator);
// Create a virtual machine that is used to execute LoLa bytecode.
// Using `.init` will always run the top-level code.
var vm = try lola.runtime.VM.init(allocator, &env);
defer vm.deinit();
// The main interpreter loop:
while (true) {
// Run the virtual machine for up to 150 instructions
var result = vm.execute(150) catch |err| {
// When the virtua machine panics, we receive a Zig error
std.debug.print("LoLa panic: {}\n", .{@errorName(err)});
return 1;
};
// Prepare a garbage collection cycle:
pool.clearUsageCounters();
// Mark all objects currently referenced in the environment
try pool.walkEnvironment(env);
// Mark all objects currently referenced in the virtual machine
try pool.walkVM(vm);
// Delete all objects that are not referenced by our system anymore
pool.collectGarbage();
switch (result) {
// This means that our script execution has ended and
// the top-level code has come to an end
.completed => break,
// This means the VM has exhausted its provided instruction quota
// and returned control to the host.
.exhausted => {
std.debug.print("Execution exhausted after 150 instructions!\n", .{});
},
// This means the virtual machine was suspended via a async function call.
.paused => std.time.sleep(100),
}
}
return 0;
} | examples/host/minimal-host/main.zig |
const std = @import("std");
const ast = std.zig.ast;
const Token = std.zig.Token;
use @import("clang.zig");
pub const Mode = enum {
import,
translate,
};
pub const ClangErrMsg = Stage2ErrorMsg;
pub const Error = error {
OutOfMemory,
};
const Context = struct {
tree: *ast.Tree,
source_buffer: *std.Buffer,
err: Error,
};
pub fn translate(
backing_allocator: *std.mem.Allocator,
args_begin: [*]?[*]const u8,
args_end: [*]?[*]const u8,
mode: Mode,
errors: *[]ClangErrMsg,
resources_path: [*]const u8,
) !*ast.Tree {
const ast_unit = ZigClangLoadFromCommandLine(
args_begin,
args_end,
&errors.ptr,
&errors.len,
resources_path,
) orelse {
if (errors.len == 0) return error.OutOfMemory;
return error.SemanticAnalyzeFail;
};
defer ZigClangASTUnit_delete(ast_unit);
var tree_arena = std.heap.ArenaAllocator.init(backing_allocator);
errdefer tree_arena.deinit();
const arena = &tree_arena.allocator;
const root_node = try arena.create(ast.Node.Root);
root_node.* = ast.Node.Root{
.base = ast.Node{ .id = ast.Node.Id.Root },
.decls = ast.Node.Root.DeclList.init(arena),
.doc_comments = null,
// initialized with the eof token at the end
.eof_token = undefined,
};
const tree = try arena.create(ast.Tree);
tree.* = ast.Tree{
.source = undefined, // need to use Buffer.toOwnedSlice later
.root_node = root_node,
.arena_allocator = tree_arena,
.tokens = ast.Tree.TokenList.init(arena),
.errors = ast.Tree.ErrorList.init(arena),
};
var source_buffer = try std.Buffer.initSize(arena, 0);
var context = Context{
.tree = tree,
.source_buffer = &source_buffer,
.err = undefined,
};
if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, &context, declVisitorC)) {
return context.err;
}
try appendToken(&context, .Eof, "");
tree.source = source_buffer.toOwnedSlice();
return tree;
}
extern fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) bool {
const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context));
declVisitor(c, decl) catch |err| {
c.err = err;
return false;
};
return true;
}
fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void {
switch (ZigClangDecl_getKind(decl)) {
.Function => {
try appendToken(c, .LineComment, "// TODO translate function decl");
},
.Typedef => {
try appendToken(c, .LineComment, "// TODO translate typedef");
},
.Enum => {
try appendToken(c, .LineComment, "// TODO translate enum");
},
.Record => {
try appendToken(c, .LineComment, "// TODO translate struct");
},
.Var => {
try appendToken(c, .LineComment, "// TODO translate variable");
},
else => {
// TODO emit_warning(c, bitcast(decl->getLocation()), "ignoring %s decl", decl->getDeclKindName());
try appendToken(c, .LineComment, "// TODO translate unknown decl");
},
}
}
fn appendToken(c: *Context, token_id: Token.Id, src_text: []const u8) !void {
const start_index = c.source_buffer.len();
try c.source_buffer.append(src_text);
const end_index = c.source_buffer.len();
const new_token = try c.tree.tokens.addOne();
new_token.* = Token{
.id = token_id,
.start = start_index,
.end = end_index,
};
try c.source_buffer.appendByte('\n');
}
pub fn freeErrors(errors: []ClangErrMsg) void {
ZigClangErrorMsg_delete(errors.ptr, errors.len);
} | src-self-hosted/translate_c.zig |
const std = @import("std");
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const nitori = @import("nitori");
const interface = nitori.interface;
//;
// start is used for initializing load routines
// init data and allocate
// TODO should statemachine return allocator errors?
// stop is used for deiniting data
// states will need to allocate
// better to do it in start and stop rather than init and deinit
// states are usually single purpose and only serve to be put in the state machine
// allocations for the actual state instances should be handled by some global ctx
// state machine doesnt care
//;
pub const Transition = union(enum) {
Pop,
Push: State,
Swap: State,
};
pub const State = struct {
pub const VTable = struct {
start: fn (State) void = _start,
stop: fn (State) void = _stop,
pause: fn (State) void = _pause,
unpause: fn (State) void = _unpause,
frame: fn (State) ?Transition = _frame,
fixed_frame: fn (State) void = _fixed_frame,
frame_hidden: fn (State) void = _frame_hidden,
fixed_frame_hidden: fn (State) void = _fixed_frame_hidden,
pub fn _start(_s: State) void {}
pub fn _stop(_s: State) void {}
pub fn _pause(_s: State) void {}
pub fn _unpause(_s: State) void {}
pub fn _frame(_s: State) ?Transition {
return null;
}
pub fn _fixed_frame(_s: State) void {}
pub fn _frame_hidden(_s: State) void {}
pub fn _fixed_frame_hidden(_s: State) void {}
};
impl: interface.Impl,
vtable: *const VTable,
};
pub const StateMachine = struct {
const Self = @This();
states: ArrayList(State),
transition: ?Transition,
pub fn init(allocator: *Allocator) Self {
const states = ArrayList(State).init(allocator);
return .{
.states = states,
.transition = null,
};
}
pub fn deinit(self: *Self) void {
self.states.deinit();
}
//;
pub fn start(self: *Self, state: State) Allocator.Error!void {
try self.states.append(state);
state.vtable.start(state);
}
pub fn stop(self: *Self) void {
// TODO
// assert theres only one state?
// stop all states
}
pub fn maybe_do_transition(self: *Self) Allocator.Error!void {
if (self.transition) |tr| {
switch (tr) {
.Pop => self.pop(),
.Push => |st| try self.push(st),
.Swap => |st| try self.swap(st),
}
}
}
pub fn frame(self: *Self) void {
assert(self.states.items.len > 0);
for (self.states.items[0..(self.states.items.len - 1)]) |state| {
state.vtable.frame_hidden(state);
}
const last_state = self.states.items[self.states.items.len - 1];
self.transition = last_state.vtable.frame(last_state);
}
pub fn fixed_frame(self: *Self) void {
assert(self.states.items.len > 0);
for (self.states.items[0..(self.states.items.len - 1)]) |state| {
state.vtable.fixed_frame_hidden(state);
}
const last_state = self.states.items[self.states.items.len - 1];
last_state.vtable.fixed_frame(last_state);
}
//;
fn pop(self: *Self) void {
assert(self.states.items.len != 0);
assert(self.states.items.len != 1);
var prev = self.states.pop();
prev.vtable.stop(prev);
var next = self.states.items[self.states.items.len - 1];
next.vtable.unpause(next);
}
fn push(self: *Self, state: State) Allocator.Error!void {
var prev = self.states.items[self.states.items.len - 1];
prev.vtable.pause(prev);
try self.states.append(state);
var next = self.states.items[self.states.items.len - 1];
next.vtable.start(next);
}
fn swap(self: *Self, state: State) Allocator.Error!void {
assert(self.states.items.len != 0);
var prev = self.states.pop();
prev.vtable.stop(prev);
try self.states.append(state);
var next = self.states.items[self.states.items.len - 1];
next.vtable.start(next);
}
};
// tests ===
const A = struct {
const Self = @This();
x: u8,
fn state(self: *Self) State {
return .{
.impl = interface.Impl.init(self),
.vtable = &comptime State.VTable{
.start = start,
.stop = stop,
.pause = pause,
.unpause = unpause,
.frame = frame,
.fixed_frame = fixed_frame,
.frame_hidden = frame_hidden,
.fixed_frame_hidden = fixed_frame_hidden,
},
};
}
fn start(s: State) void {
var self = s.impl.cast(Self);
std.log.warn("start A {}\n", .{self.x});
}
fn stop(s: State) void {
var self = s.impl.cast(Self);
std.log.warn("stop A {}\n", .{self.x});
}
fn pause(s: State) void {
var self = s.impl.cast(Self);
std.log.warn("pause A {}\n", .{self.x});
}
fn unpause(s: State) void {
var self = s.impl.cast(Self);
std.log.warn("unpause A {}\n", .{self.x});
}
fn frame(s: State) ?Transition {
var self = s.impl.cast(Self);
std.log.warn("frame A {}\n", .{self.x});
return null;
}
fn fixed_frame(s: State) void {
var self = s.impl.cast(Self);
std.log.warn("fixed_frame A {}\n", .{self.x});
}
fn frame_hidden(s: State) void {
var self = s.impl.cast(Self);
std.log.warn("frame_hidden A {}\n", .{self.x});
}
fn fixed_frame_hidden(s: State) void {
var self = s.impl.cast(Self);
std.log.warn("fixed_frame_hidden A {}\n", .{self.x});
}
};
// tests ===
// TODO test transitions work when returned from frame funcs
test "StateMachine" {
var sm = StateMachine.init(std.testing.allocator);
defer sm.deinit();
var a1 = A{ .x = 1 };
var a2 = A{ .x = 2 };
var a3 = A{ .x = 3 };
try sm.start(a1.state());
sm.frame();
sm.fixed_frame();
try sm.push(a2.state());
sm.frame();
sm.fixed_frame();
try sm.swap(a3.state());
sm.frame();
sm.fixed_frame();
sm.pop();
sm.stop();
} | src/states.zig |
pub const LBER_ERROR = @as(i32, -1);
pub const LBER_DEFAULT = @as(i32, -1);
pub const LDAP_UNICODE = @as(u32, 1);
pub const LDAP_PORT = @as(u32, 389);
pub const LDAP_SSL_PORT = @as(u32, 636);
pub const LDAP_GC_PORT = @as(u32, 3268);
pub const LDAP_SSL_GC_PORT = @as(u32, 3269);
pub const LDAP_VERSION1 = @as(u32, 1);
pub const LDAP_VERSION2 = @as(u32, 2);
pub const LDAP_VERSION3 = @as(u32, 3);
pub const LDAP_VERSION = @as(u32, 2);
pub const LDAP_BIND_CMD = @as(i32, 96);
pub const LDAP_UNBIND_CMD = @as(i32, 66);
pub const LDAP_SEARCH_CMD = @as(i32, 99);
pub const LDAP_MODIFY_CMD = @as(i32, 102);
pub const LDAP_ADD_CMD = @as(i32, 104);
pub const LDAP_DELETE_CMD = @as(i32, 74);
pub const LDAP_MODRDN_CMD = @as(i32, 108);
pub const LDAP_COMPARE_CMD = @as(i32, 110);
pub const LDAP_ABANDON_CMD = @as(i32, 80);
pub const LDAP_SESSION_CMD = @as(i32, 113);
pub const LDAP_EXTENDED_CMD = @as(i32, 119);
pub const LDAP_RES_BIND = @as(i32, 97);
pub const LDAP_RES_SEARCH_ENTRY = @as(i32, 100);
pub const LDAP_RES_SEARCH_RESULT = @as(i32, 101);
pub const LDAP_RES_MODIFY = @as(i32, 103);
pub const LDAP_RES_ADD = @as(i32, 105);
pub const LDAP_RES_DELETE = @as(i32, 107);
pub const LDAP_RES_MODRDN = @as(i32, 109);
pub const LDAP_RES_COMPARE = @as(i32, 111);
pub const LDAP_RES_SESSION = @as(i32, 114);
pub const LDAP_RES_REFERRAL = @as(i32, 115);
pub const LDAP_RES_EXTENDED = @as(i32, 120);
pub const LDAP_RES_ANY = @as(i32, -1);
pub const LDAP_INVALID_CMD = @as(u32, 255);
pub const LDAP_INVALID_RES = @as(u32, 255);
pub const LDAP_AUTH_SIMPLE = @as(i32, 128);
pub const LDAP_AUTH_SASL = @as(i32, 131);
pub const LDAP_AUTH_OTHERKIND = @as(i32, 134);
pub const LDAP_FILTER_AND = @as(u32, 160);
pub const LDAP_FILTER_OR = @as(u32, 161);
pub const LDAP_FILTER_NOT = @as(u32, 162);
pub const LDAP_FILTER_EQUALITY = @as(u32, 163);
pub const LDAP_FILTER_SUBSTRINGS = @as(u32, 164);
pub const LDAP_FILTER_GE = @as(u32, 165);
pub const LDAP_FILTER_LE = @as(u32, 166);
pub const LDAP_FILTER_PRESENT = @as(u32, 135);
pub const LDAP_FILTER_APPROX = @as(u32, 168);
pub const LDAP_FILTER_EXTENSIBLE = @as(u32, 169);
pub const LDAP_SUBSTRING_INITIAL = @as(i32, 128);
pub const LDAP_SUBSTRING_ANY = @as(i32, 129);
pub const LDAP_SUBSTRING_FINAL = @as(i32, 130);
pub const LDAP_DEREF_NEVER = @as(u32, 0);
pub const LDAP_DEREF_SEARCHING = @as(u32, 1);
pub const LDAP_DEREF_FINDING = @as(u32, 2);
pub const LDAP_DEREF_ALWAYS = @as(u32, 3);
pub const LDAP_NO_LIMIT = @as(u32, 0);
pub const LDAP_OPT_DNS = @as(u32, 1);
pub const LDAP_OPT_CHASE_REFERRALS = @as(u32, 2);
pub const LDAP_OPT_RETURN_REFS = @as(u32, 4);
pub const LDAP_MOD_ADD = @as(u32, 0);
pub const LDAP_MOD_DELETE = @as(u32, 1);
pub const LDAP_MOD_REPLACE = @as(u32, 2);
pub const LDAP_MOD_BVALUES = @as(u32, 128);
pub const LDAP_OPT_API_INFO = @as(u32, 0);
pub const LDAP_OPT_DESC = @as(u32, 1);
pub const LDAP_OPT_DEREF = @as(u32, 2);
pub const LDAP_OPT_SIZELIMIT = @as(u32, 3);
pub const LDAP_OPT_TIMELIMIT = @as(u32, 4);
pub const LDAP_OPT_THREAD_FN_PTRS = @as(u32, 5);
pub const LDAP_OPT_REBIND_FN = @as(u32, 6);
pub const LDAP_OPT_REBIND_ARG = @as(u32, 7);
pub const LDAP_OPT_REFERRALS = @as(u32, 8);
pub const LDAP_OPT_RESTART = @as(u32, 9);
pub const LDAP_OPT_SSL = @as(u32, 10);
pub const LDAP_OPT_IO_FN_PTRS = @as(u32, 11);
pub const LDAP_OPT_CACHE_FN_PTRS = @as(u32, 13);
pub const LDAP_OPT_CACHE_STRATEGY = @as(u32, 14);
pub const LDAP_OPT_CACHE_ENABLE = @as(u32, 15);
pub const LDAP_OPT_REFERRAL_HOP_LIMIT = @as(u32, 16);
pub const LDAP_OPT_PROTOCOL_VERSION = @as(u32, 17);
pub const LDAP_OPT_VERSION = @as(u32, 17);
pub const LDAP_OPT_API_FEATURE_INFO = @as(u32, 21);
pub const LDAP_OPT_HOST_NAME = @as(u32, 48);
pub const LDAP_OPT_ERROR_NUMBER = @as(u32, 49);
pub const LDAP_OPT_ERROR_STRING = @as(u32, 50);
pub const LDAP_OPT_SERVER_ERROR = @as(u32, 51);
pub const LDAP_OPT_SERVER_EXT_ERROR = @as(u32, 52);
pub const LDAP_OPT_HOST_REACHABLE = @as(u32, 62);
pub const LDAP_OPT_PING_KEEP_ALIVE = @as(u32, 54);
pub const LDAP_OPT_PING_WAIT_TIME = @as(u32, 55);
pub const LDAP_OPT_PING_LIMIT = @as(u32, 56);
pub const LDAP_OPT_DNSDOMAIN_NAME = @as(u32, 59);
pub const LDAP_OPT_GETDSNAME_FLAGS = @as(u32, 61);
pub const LDAP_OPT_PROMPT_CREDENTIALS = @as(u32, 63);
pub const LDAP_OPT_AUTO_RECONNECT = @as(u32, 145);
pub const LDAP_OPT_SSPI_FLAGS = @as(u32, 146);
pub const LDAP_OPT_SSL_INFO = @as(u32, 147);
pub const LDAP_OPT_TLS = @as(u32, 10);
pub const LDAP_OPT_TLS_INFO = @as(u32, 147);
pub const LDAP_OPT_SIGN = @as(u32, 149);
pub const LDAP_OPT_ENCRYPT = @as(u32, 150);
pub const LDAP_OPT_SASL_METHOD = @as(u32, 151);
pub const LDAP_OPT_AREC_EXCLUSIVE = @as(u32, 152);
pub const LDAP_OPT_SECURITY_CONTEXT = @as(u32, 153);
pub const LDAP_OPT_ROOTDSE_CACHE = @as(u32, 154);
pub const LDAP_OPT_TCP_KEEPALIVE = @as(u32, 64);
pub const LDAP_OPT_FAST_CONCURRENT_BIND = @as(u32, 65);
pub const LDAP_OPT_SEND_TIMEOUT = @as(u32, 66);
pub const LDAP_OPT_SCH_FLAGS = @as(u32, 67);
pub const LDAP_OPT_SOCKET_BIND_ADDRESSES = @as(u32, 68);
pub const LDAP_CHASE_SUBORDINATE_REFERRALS = @as(u32, 32);
pub const LDAP_CHASE_EXTERNAL_REFERRALS = @as(u32, 64);
pub const LDAP_SCOPE_BASE = @as(u32, 0);
pub const LDAP_SCOPE_ONELEVEL = @as(u32, 1);
pub const LDAP_SCOPE_SUBTREE = @as(u32, 2);
pub const LDAP_MSG_ONE = @as(u32, 0);
pub const LDAP_MSG_ALL = @as(u32, 1);
pub const LDAP_MSG_RECEIVED = @as(u32, 2);
pub const LBER_USE_DER = @as(u32, 1);
pub const LBER_USE_INDEFINITE_LEN = @as(u32, 2);
pub const LBER_TRANSLATE_STRINGS = @as(u32, 4);
pub const LAPI_MAJOR_VER1 = @as(u32, 1);
pub const LAPI_MINOR_VER1 = @as(u32, 1);
pub const LDAP_API_INFO_VERSION = @as(u32, 1);
pub const LDAP_API_VERSION = @as(u32, 2004);
pub const LDAP_VERSION_MIN = @as(u32, 2);
pub const LDAP_VERSION_MAX = @as(u32, 3);
pub const LDAP_VENDOR_VERSION = @as(u32, 510);
pub const LDAP_FEATURE_INFO_VERSION = @as(u32, 1);
pub const LDAP_API_FEATURE_VIRTUAL_LIST_VIEW = @as(u32, 1001);
pub const LDAP_VLVINFO_VERSION = @as(u32, 1);
pub const LDAP_OPT_REFERRAL_CALLBACK = @as(u32, 112);
pub const LDAP_OPT_CLIENT_CERTIFICATE = @as(u32, 128);
pub const LDAP_OPT_SERVER_CERTIFICATE = @as(u32, 129);
pub const LDAP_OPT_REF_DEREF_CONN_PER_MSG = @as(u32, 148);
pub const SERVER_SEARCH_FLAG_DOMAIN_SCOPE = @as(u32, 1);
pub const SERVER_SEARCH_FLAG_PHANTOM_ROOT = @as(u32, 2);
pub const LDAP_DIRSYNC_OBJECT_SECURITY = @as(u32, 1);
pub const LDAP_DIRSYNC_ANCESTORS_FIRST_ORDER = @as(u32, 2048);
pub const LDAP_DIRSYNC_PUBLIC_DATA_ONLY = @as(u32, 8192);
pub const LDAP_DIRSYNC_INCREMENTAL_VALUES = @as(u32, 2147483648);
pub const LDAP_DIRSYNC_ROPAS_DATA_ONLY = @as(u32, 1073741824);
pub const LDAP_POLICYHINT_APPLY_FULLPWDPOLICY = @as(u32, 1);
//--------------------------------------------------------------------------------
// Section: Types (26)
//--------------------------------------------------------------------------------
pub const LDAP_RETCODE = enum(i32) {
SUCCESS = 0,
OPERATIONS_ERROR = 1,
PROTOCOL_ERROR = 2,
TIMELIMIT_EXCEEDED = 3,
SIZELIMIT_EXCEEDED = 4,
COMPARE_FALSE = 5,
COMPARE_TRUE = 6,
AUTH_METHOD_NOT_SUPPORTED = 7,
STRONG_AUTH_REQUIRED = 8,
REFERRAL_V2 = 9,
// PARTIAL_RESULTS = 9, this enum value conflicts with REFERRAL_V2
REFERRAL = 10,
ADMIN_LIMIT_EXCEEDED = 11,
UNAVAILABLE_CRIT_EXTENSION = 12,
CONFIDENTIALITY_REQUIRED = 13,
SASL_BIND_IN_PROGRESS = 14,
NO_SUCH_ATTRIBUTE = 16,
UNDEFINED_TYPE = 17,
INAPPROPRIATE_MATCHING = 18,
CONSTRAINT_VIOLATION = 19,
ATTRIBUTE_OR_VALUE_EXISTS = 20,
INVALID_SYNTAX = 21,
NO_SUCH_OBJECT = 32,
ALIAS_PROBLEM = 33,
INVALID_DN_SYNTAX = 34,
IS_LEAF = 35,
ALIAS_DEREF_PROBLEM = 36,
INAPPROPRIATE_AUTH = 48,
INVALID_CREDENTIALS = 49,
INSUFFICIENT_RIGHTS = 50,
BUSY = 51,
UNAVAILABLE = 52,
UNWILLING_TO_PERFORM = 53,
LOOP_DETECT = 54,
SORT_CONTROL_MISSING = 60,
OFFSET_RANGE_ERROR = 61,
NAMING_VIOLATION = 64,
OBJECT_CLASS_VIOLATION = 65,
NOT_ALLOWED_ON_NONLEAF = 66,
NOT_ALLOWED_ON_RDN = 67,
ALREADY_EXISTS = 68,
NO_OBJECT_CLASS_MODS = 69,
RESULTS_TOO_LARGE = 70,
AFFECTS_MULTIPLE_DSAS = 71,
VIRTUAL_LIST_VIEW_ERROR = 76,
OTHER = 80,
SERVER_DOWN = 81,
LOCAL_ERROR = 82,
ENCODING_ERROR = 83,
DECODING_ERROR = 84,
TIMEOUT = 85,
AUTH_UNKNOWN = 86,
FILTER_ERROR = 87,
USER_CANCELLED = 88,
PARAM_ERROR = 89,
NO_MEMORY = 90,
CONNECT_ERROR = 91,
NOT_SUPPORTED = 92,
NO_RESULTS_RETURNED = 94,
CONTROL_NOT_FOUND = 93,
MORE_RESULTS_TO_RETURN = 95,
CLIENT_LOOP = 96,
REFERRAL_LIMIT_EXCEEDED = 97,
};
pub const LDAP_SUCCESS = LDAP_RETCODE.SUCCESS;
pub const LDAP_OPERATIONS_ERROR = LDAP_RETCODE.OPERATIONS_ERROR;
pub const LDAP_PROTOCOL_ERROR = LDAP_RETCODE.PROTOCOL_ERROR;
pub const LDAP_TIMELIMIT_EXCEEDED = LDAP_RETCODE.TIMELIMIT_EXCEEDED;
pub const LDAP_SIZELIMIT_EXCEEDED = LDAP_RETCODE.SIZELIMIT_EXCEEDED;
pub const LDAP_COMPARE_FALSE = LDAP_RETCODE.COMPARE_FALSE;
pub const LDAP_COMPARE_TRUE = LDAP_RETCODE.COMPARE_TRUE;
pub const LDAP_AUTH_METHOD_NOT_SUPPORTED = LDAP_RETCODE.AUTH_METHOD_NOT_SUPPORTED;
pub const LDAP_STRONG_AUTH_REQUIRED = LDAP_RETCODE.STRONG_AUTH_REQUIRED;
pub const LDAP_REFERRAL_V2 = LDAP_RETCODE.REFERRAL_V2;
pub const LDAP_PARTIAL_RESULTS = LDAP_RETCODE.REFERRAL_V2;
pub const LDAP_REFERRAL = LDAP_RETCODE.REFERRAL;
pub const LDAP_ADMIN_LIMIT_EXCEEDED = LDAP_RETCODE.ADMIN_LIMIT_EXCEEDED;
pub const LDAP_UNAVAILABLE_CRIT_EXTENSION = LDAP_RETCODE.UNAVAILABLE_CRIT_EXTENSION;
pub const LDAP_CONFIDENTIALITY_REQUIRED = LDAP_RETCODE.CONFIDENTIALITY_REQUIRED;
pub const LDAP_SASL_BIND_IN_PROGRESS = LDAP_RETCODE.SASL_BIND_IN_PROGRESS;
pub const LDAP_NO_SUCH_ATTRIBUTE = LDAP_RETCODE.NO_SUCH_ATTRIBUTE;
pub const LDAP_UNDEFINED_TYPE = LDAP_RETCODE.UNDEFINED_TYPE;
pub const LDAP_INAPPROPRIATE_MATCHING = LDAP_RETCODE.INAPPROPRIATE_MATCHING;
pub const LDAP_CONSTRAINT_VIOLATION = LDAP_RETCODE.CONSTRAINT_VIOLATION;
pub const LDAP_ATTRIBUTE_OR_VALUE_EXISTS = LDAP_RETCODE.ATTRIBUTE_OR_VALUE_EXISTS;
pub const LDAP_INVALID_SYNTAX = LDAP_RETCODE.INVALID_SYNTAX;
pub const LDAP_NO_SUCH_OBJECT = LDAP_RETCODE.NO_SUCH_OBJECT;
pub const LDAP_ALIAS_PROBLEM = LDAP_RETCODE.ALIAS_PROBLEM;
pub const LDAP_INVALID_DN_SYNTAX = LDAP_RETCODE.INVALID_DN_SYNTAX;
pub const LDAP_IS_LEAF = LDAP_RETCODE.IS_LEAF;
pub const LDAP_ALIAS_DEREF_PROBLEM = LDAP_RETCODE.ALIAS_DEREF_PROBLEM;
pub const LDAP_INAPPROPRIATE_AUTH = LDAP_RETCODE.INAPPROPRIATE_AUTH;
pub const LDAP_INVALID_CREDENTIALS = LDAP_RETCODE.INVALID_CREDENTIALS;
pub const LDAP_INSUFFICIENT_RIGHTS = LDAP_RETCODE.INSUFFICIENT_RIGHTS;
pub const LDAP_BUSY = LDAP_RETCODE.BUSY;
pub const LDAP_UNAVAILABLE = LDAP_RETCODE.UNAVAILABLE;
pub const LDAP_UNWILLING_TO_PERFORM = LDAP_RETCODE.UNWILLING_TO_PERFORM;
pub const LDAP_LOOP_DETECT = LDAP_RETCODE.LOOP_DETECT;
pub const LDAP_SORT_CONTROL_MISSING = LDAP_RETCODE.SORT_CONTROL_MISSING;
pub const LDAP_OFFSET_RANGE_ERROR = LDAP_RETCODE.OFFSET_RANGE_ERROR;
pub const LDAP_NAMING_VIOLATION = LDAP_RETCODE.NAMING_VIOLATION;
pub const LDAP_OBJECT_CLASS_VIOLATION = LDAP_RETCODE.OBJECT_CLASS_VIOLATION;
pub const LDAP_NOT_ALLOWED_ON_NONLEAF = LDAP_RETCODE.NOT_ALLOWED_ON_NONLEAF;
pub const LDAP_NOT_ALLOWED_ON_RDN = LDAP_RETCODE.NOT_ALLOWED_ON_RDN;
pub const LDAP_ALREADY_EXISTS = LDAP_RETCODE.ALREADY_EXISTS;
pub const LDAP_NO_OBJECT_CLASS_MODS = LDAP_RETCODE.NO_OBJECT_CLASS_MODS;
pub const LDAP_RESULTS_TOO_LARGE = LDAP_RETCODE.RESULTS_TOO_LARGE;
pub const LDAP_AFFECTS_MULTIPLE_DSAS = LDAP_RETCODE.AFFECTS_MULTIPLE_DSAS;
pub const LDAP_VIRTUAL_LIST_VIEW_ERROR = LDAP_RETCODE.VIRTUAL_LIST_VIEW_ERROR;
pub const LDAP_OTHER = LDAP_RETCODE.OTHER;
pub const LDAP_SERVER_DOWN = LDAP_RETCODE.SERVER_DOWN;
pub const LDAP_LOCAL_ERROR = LDAP_RETCODE.LOCAL_ERROR;
pub const LDAP_ENCODING_ERROR = LDAP_RETCODE.ENCODING_ERROR;
pub const LDAP_DECODING_ERROR = LDAP_RETCODE.DECODING_ERROR;
pub const LDAP_TIMEOUT = LDAP_RETCODE.TIMEOUT;
pub const LDAP_AUTH_UNKNOWN = LDAP_RETCODE.AUTH_UNKNOWN;
pub const LDAP_FILTER_ERROR = LDAP_RETCODE.FILTER_ERROR;
pub const LDAP_USER_CANCELLED = LDAP_RETCODE.USER_CANCELLED;
pub const LDAP_PARAM_ERROR = LDAP_RETCODE.PARAM_ERROR;
pub const LDAP_NO_MEMORY = LDAP_RETCODE.NO_MEMORY;
pub const LDAP_CONNECT_ERROR = LDAP_RETCODE.CONNECT_ERROR;
pub const LDAP_NOT_SUPPORTED = LDAP_RETCODE.NOT_SUPPORTED;
pub const LDAP_NO_RESULTS_RETURNED = LDAP_RETCODE.NO_RESULTS_RETURNED;
pub const LDAP_CONTROL_NOT_FOUND = LDAP_RETCODE.CONTROL_NOT_FOUND;
pub const LDAP_MORE_RESULTS_TO_RETURN = LDAP_RETCODE.MORE_RESULTS_TO_RETURN;
pub const LDAP_CLIENT_LOOP = LDAP_RETCODE.CLIENT_LOOP;
pub const LDAP_REFERRAL_LIMIT_EXCEEDED = LDAP_RETCODE.REFERRAL_LIMIT_EXCEEDED;
pub const ldap = extern struct {
ld_sb: extern struct {
sb_sd: usize,
Reserved1: [41]u8,
sb_naddr: usize,
Reserved2: [24]u8,
},
ld_host: ?[*]u8,
ld_version: u32,
ld_lberoptions: u8,
ld_deref: u32,
ld_timelimit: u32,
ld_sizelimit: u32,
ld_errno: u32,
ld_matched: ?[*]u8,
ld_error: ?[*]u8,
ld_msgid: u32,
Reserved3: [25]u8,
ld_cldaptries: u32,
ld_cldaptimeout: u32,
ld_refhoplimit: u32,
ld_options: u32,
};
pub const LDAP_TIMEVAL = extern struct {
tv_sec: i32,
tv_usec: i32,
};
pub const LDAP_BERVAL = extern struct {
bv_len: u32,
bv_val: ?[*]u8,
};
pub const LDAPMessage = extern struct {
lm_msgid: u32,
lm_msgtype: u32,
lm_ber: ?*anyopaque,
lm_chain: ?*LDAPMessage,
lm_next: ?*LDAPMessage,
lm_time: u32,
Connection: ?*ldap,
Request: ?*anyopaque,
lm_returncode: u32,
lm_referral: u16,
lm_chased: BOOLEAN,
lm_eom: BOOLEAN,
ConnectionReferenced: BOOLEAN,
};
pub const ldapcontrolA = extern struct {
ldctl_oid: ?[*]u8,
ldctl_value: LDAP_BERVAL,
ldctl_iscritical: BOOLEAN,
};
pub const ldapcontrolW = extern struct {
ldctl_oid: ?[*]u16,
ldctl_value: LDAP_BERVAL,
ldctl_iscritical: BOOLEAN,
};
pub const ldapmodW = extern struct {
mod_op: u32,
mod_type: ?[*]u16,
mod_vals: extern union {
modv_strvals: ?*?PWSTR,
modv_bvals: ?*?*LDAP_BERVAL,
},
};
pub const ldapmodA = extern struct {
mod_op: u32,
mod_type: ?[*]u8,
mod_vals: extern union {
modv_strvals: ?*?PSTR,
modv_bvals: ?*?*LDAP_BERVAL,
},
};
pub const berelement = extern struct {
@"opaque": ?[*]u8,
};
pub const ldap_version_info = extern struct {
lv_size: u32,
lv_major: u32,
lv_minor: u32,
};
pub const ldapapiinfoA = extern struct {
ldapai_info_version: i32,
ldapai_api_version: i32,
ldapai_protocol_version: i32,
ldapai_extensions: ?*?*i8,
ldapai_vendor_name: ?PSTR,
ldapai_vendor_version: i32,
};
pub const ldapapiinfoW = extern struct {
ldapai_info_version: i32,
ldapai_api_version: i32,
ldapai_protocol_version: i32,
ldapai_extensions: ?*?PWSTR,
ldapai_vendor_name: ?[*]u16,
ldapai_vendor_version: i32,
};
pub const LDAPAPIFeatureInfoA = extern struct {
ldapaif_info_version: i32,
ldapaif_name: ?PSTR,
ldapaif_version: i32,
};
pub const LDAPAPIFeatureInfoW = extern struct {
ldapaif_info_version: i32,
ldapaif_name: ?[*]u16,
ldapaif_version: i32,
};
pub const DBGPRINT = fn(
Format: ?[*]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ldapsearch = extern struct {
placeholder: usize, // TODO: why is this type empty?
};
pub const ldapsortkeyW = extern struct {
sk_attrtype: ?[*]u16,
sk_matchruleoid: ?[*]u16,
sk_reverseorder: BOOLEAN,
};
pub const ldapsortkeyA = extern struct {
sk_attrtype: ?[*]u8,
sk_matchruleoid: ?[*]u8,
sk_reverseorder: BOOLEAN,
};
pub const ldapvlvinfo = extern struct {
ldvlv_version: i32,
ldvlv_before_count: u32,
ldvlv_after_count: u32,
ldvlv_offset: u32,
ldvlv_count: u32,
ldvlv_attrvalue: ?*LDAP_BERVAL,
ldvlv_context: ?*LDAP_BERVAL,
ldvlv_extradata: ?*anyopaque,
};
pub const QUERYFORCONNECTION = fn(
PrimaryConnection: ?*ldap,
ReferralFromConnection: ?*ldap,
NewDN: ?[*]u16,
HostName: ?[*]u8,
PortNumber: u32,
SecAuthIdentity: ?*anyopaque,
CurrentUserToken: ?*anyopaque,
ConnectionToUse: ?*?*ldap,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const NOTIFYOFNEWCONNECTION = fn(
PrimaryConnection: ?*ldap,
ReferralFromConnection: ?*ldap,
NewDN: ?[*]u16,
HostName: ?[*]u8,
NewConnection: ?*ldap,
PortNumber: u32,
SecAuthIdentity: ?*anyopaque,
CurrentUser: ?*anyopaque,
ErrorCodeFromBind: u32,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;
pub const DEREFERENCECONNECTION = fn(
PrimaryConnection: ?*ldap,
ConnectionToDereference: ?*ldap,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const LDAP_REFERRAL_CALLBACK = extern struct {
SizeOfCallbacks: u32,
QueryForConnection: ?QUERYFORCONNECTION,
NotifyRoutine: ?NOTIFYOFNEWCONNECTION,
DereferenceRoutine: ?DEREFERENCECONNECTION,
};
pub const QUERYCLIENTCERT = fn(
Connection: ?*ldap,
trusted_CAs: ?*SecPkgContext_IssuerListInfoEx,
ppCertificate: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;
pub const VERIFYSERVERCERT = fn(
Connection: ?*ldap,
pServerCert: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;
//--------------------------------------------------------------------------------
// Section: Functions (243)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_openW(
HostName: ?[*:0]const u16,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_openA(
HostName: ?[*:0]const u8,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_initW(
HostName: ?[*:0]const u16,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_initA(
HostName: ?[*:0]const u8,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_sslinitW(
HostName: ?PWSTR,
PortNumber: u32,
secure: i32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_sslinitA(
HostName: ?PSTR,
PortNumber: u32,
secure: i32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_connect(
ld: ?*ldap,
timeout: ?*LDAP_TIMEVAL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_open(
HostName: ?PSTR,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_init(
HostName: ?PSTR,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_sslinit(
HostName: ?PSTR,
PortNumber: u32,
secure: i32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn cldap_openW(
HostName: ?PWSTR,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn cldap_openA(
HostName: ?PSTR,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn cldap_open(
HostName: ?PSTR,
PortNumber: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_unbind(
ld: ?*ldap,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_unbind_s(
ld: ?*ldap,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_option(
ld: ?*ldap,
option: i32,
outvalue: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_optionW(
ld: ?*ldap,
option: i32,
outvalue: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_set_option(
ld: ?*ldap,
option: i32,
invalue: ?*const anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_set_optionW(
ld: ?*ldap,
option: i32,
invalue: ?*const anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_simple_bindW(
ld: ?*ldap,
dn: ?PWSTR,
passwd: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_simple_bindA(
ld: ?*ldap,
dn: ?PSTR,
passwd: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_simple_bind_sW(
ld: ?*ldap,
dn: ?PWSTR,
passwd: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_simple_bind_sA(
ld: ?*ldap,
dn: ?PSTR,
passwd: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_bindW(
ld: ?*ldap,
dn: ?PWSTR,
cred: ?[*]u16,
method: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_bindA(
ld: ?*ldap,
dn: ?PSTR,
cred: ?[*]u8,
method: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_bind_sW(
ld: ?*ldap,
dn: ?PWSTR,
cred: ?[*]u16,
method: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_bind_sA(
ld: ?*ldap,
dn: ?PSTR,
cred: ?[*]u8,
method: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_sasl_bindA(
ExternalHandle: ?*ldap,
DistName: ?[*:0]const u8,
AuthMechanism: ?[*:0]const u8,
cred: ?*const LDAP_BERVAL,
ServerCtrls: ?*?*ldapcontrolA,
ClientCtrls: ?*?*ldapcontrolA,
MessageNumber: ?*i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_sasl_bindW(
ExternalHandle: ?*ldap,
DistName: ?[*:0]const u16,
AuthMechanism: ?[*:0]const u16,
cred: ?*const LDAP_BERVAL,
ServerCtrls: ?*?*ldapcontrolW,
ClientCtrls: ?*?*ldapcontrolW,
MessageNumber: ?*i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_sasl_bind_sA(
ExternalHandle: ?*ldap,
DistName: ?[*:0]const u8,
AuthMechanism: ?[*:0]const u8,
cred: ?*const LDAP_BERVAL,
ServerCtrls: ?*?*ldapcontrolA,
ClientCtrls: ?*?*ldapcontrolA,
ServerData: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_sasl_bind_sW(
ExternalHandle: ?*ldap,
DistName: ?[*:0]const u16,
AuthMechanism: ?[*:0]const u16,
cred: ?*const LDAP_BERVAL,
ServerCtrls: ?*?*ldapcontrolW,
ClientCtrls: ?*?*ldapcontrolW,
ServerData: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_simple_bind(
ld: ?*ldap,
dn: ?[*:0]const u8,
passwd: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_simple_bind_s(
ld: ?*ldap,
dn: ?[*:0]const u8,
passwd: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_bind(
ld: ?*ldap,
dn: ?[*:0]const u8,
cred: ?[*:0]const u8,
method: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_bind_s(
ld: ?*ldap,
dn: ?[*:0]const u8,
cred: ?[*:0]const u8,
method: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_searchW(
ld: ?*ldap,
base: ?[*:0]const u16,
scope: u32,
filter: ?[*:0]const u16,
attrs: ?*?*u16,
attrsonly: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_searchA(
ld: ?*ldap,
base: ?[*:0]const u8,
scope: u32,
filter: ?[*:0]const u8,
attrs: ?*?*i8,
attrsonly: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_sW(
ld: ?*ldap,
base: ?[*:0]const u16,
scope: u32,
filter: ?[*:0]const u16,
attrs: ?*?*u16,
attrsonly: u32,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_sA(
ld: ?*ldap,
base: ?[*:0]const u8,
scope: u32,
filter: ?[*:0]const u8,
attrs: ?*?*i8,
attrsonly: u32,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_stW(
ld: ?*ldap,
base: ?[*:0]const u16,
scope: u32,
filter: ?[*:0]const u16,
attrs: ?*?*u16,
attrsonly: u32,
timeout: ?*LDAP_TIMEVAL,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_stA(
ld: ?*ldap,
base: ?[*:0]const u8,
scope: u32,
filter: ?[*:0]const u8,
attrs: ?*?*i8,
attrsonly: u32,
timeout: ?*LDAP_TIMEVAL,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_extW(
ld: ?*ldap,
base: ?[*:0]const u16,
scope: u32,
filter: ?[*:0]const u16,
attrs: ?*?*u16,
attrsonly: u32,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
TimeLimit: u32,
SizeLimit: u32,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_extA(
ld: ?*ldap,
base: ?[*:0]const u8,
scope: u32,
filter: ?[*:0]const u8,
attrs: ?*?*i8,
attrsonly: u32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
TimeLimit: u32,
SizeLimit: u32,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_ext_sW(
ld: ?*ldap,
base: ?[*:0]const u16,
scope: u32,
filter: ?[*:0]const u16,
attrs: ?*?*u16,
attrsonly: u32,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
timeout: ?*LDAP_TIMEVAL,
SizeLimit: u32,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_ext_sA(
ld: ?*ldap,
base: ?[*:0]const u8,
scope: u32,
filter: ?[*:0]const u8,
attrs: ?*?*i8,
attrsonly: u32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
timeout: ?*LDAP_TIMEVAL,
SizeLimit: u32,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search(
ld: ?*ldap,
base: ?PSTR,
scope: u32,
filter: ?PSTR,
attrs: ?*?*i8,
attrsonly: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_s(
ld: ?*ldap,
base: ?PSTR,
scope: u32,
filter: ?PSTR,
attrs: ?*?*i8,
attrsonly: u32,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_st(
ld: ?*ldap,
base: ?PSTR,
scope: u32,
filter: ?PSTR,
attrs: ?*?*i8,
attrsonly: u32,
timeout: ?*LDAP_TIMEVAL,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_ext(
ld: ?*ldap,
base: ?PSTR,
scope: u32,
filter: ?PSTR,
attrs: ?*?*i8,
attrsonly: u32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
TimeLimit: u32,
SizeLimit: u32,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_ext_s(
ld: ?*ldap,
base: ?PSTR,
scope: u32,
filter: ?PSTR,
attrs: ?*?*i8,
attrsonly: u32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
timeout: ?*LDAP_TIMEVAL,
SizeLimit: u32,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_check_filterW(
ld: ?*ldap,
SearchFilter: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_check_filterA(
ld: ?*ldap,
SearchFilter: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modifyW(
ld: ?*ldap,
dn: ?PWSTR,
mods: ?*?*ldapmodW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modifyA(
ld: ?*ldap,
dn: ?PSTR,
mods: ?*?*ldapmodA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_sW(
ld: ?*ldap,
dn: ?PWSTR,
mods: ?*?*ldapmodW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_sA(
ld: ?*ldap,
dn: ?PSTR,
mods: ?*?*ldapmodA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_extW(
ld: ?*ldap,
dn: ?[*:0]const u16,
mods: ?*?*ldapmodW,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_extA(
ld: ?*ldap,
dn: ?[*:0]const u8,
mods: ?*?*ldapmodA,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_ext_sW(
ld: ?*ldap,
dn: ?[*:0]const u16,
mods: ?*?*ldapmodW,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_ext_sA(
ld: ?*ldap,
dn: ?[*:0]const u8,
mods: ?*?*ldapmodA,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify(
ld: ?*ldap,
dn: ?PSTR,
mods: ?*?*ldapmodA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_s(
ld: ?*ldap,
dn: ?PSTR,
mods: ?*?*ldapmodA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_ext(
ld: ?*ldap,
dn: ?[*:0]const u8,
mods: ?*?*ldapmodA,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modify_ext_s(
ld: ?*ldap,
dn: ?[*:0]const u8,
mods: ?*?*ldapmodA,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn2W(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u16,
NewDistinguishedName: ?[*:0]const u16,
DeleteOldRdn: i32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn2A(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
NewDistinguishedName: ?[*:0]const u8,
DeleteOldRdn: i32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdnW(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u16,
NewDistinguishedName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdnA(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
NewDistinguishedName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn2_sW(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u16,
NewDistinguishedName: ?[*:0]const u16,
DeleteOldRdn: i32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn2_sA(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
NewDistinguishedName: ?[*:0]const u8,
DeleteOldRdn: i32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn_sW(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u16,
NewDistinguishedName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn_sA(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
NewDistinguishedName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn2(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
NewDistinguishedName: ?[*:0]const u8,
DeleteOldRdn: i32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
NewDistinguishedName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn2_s(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
NewDistinguishedName: ?[*:0]const u8,
DeleteOldRdn: i32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_modrdn_s(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
NewDistinguishedName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_rename_extW(
ld: ?*ldap,
dn: ?[*:0]const u16,
NewRDN: ?[*:0]const u16,
NewParent: ?[*:0]const u16,
DeleteOldRdn: i32,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_rename_extA(
ld: ?*ldap,
dn: ?[*:0]const u8,
NewRDN: ?[*:0]const u8,
NewParent: ?[*:0]const u8,
DeleteOldRdn: i32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_rename_ext_sW(
ld: ?*ldap,
dn: ?[*:0]const u16,
NewRDN: ?[*:0]const u16,
NewParent: ?[*:0]const u16,
DeleteOldRdn: i32,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_rename_ext_sA(
ld: ?*ldap,
dn: ?[*:0]const u8,
NewRDN: ?[*:0]const u8,
NewParent: ?[*:0]const u8,
DeleteOldRdn: i32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_rename_ext(
ld: ?*ldap,
dn: ?[*:0]const u8,
NewRDN: ?[*:0]const u8,
NewParent: ?[*:0]const u8,
DeleteOldRdn: i32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_rename_ext_s(
ld: ?*ldap,
dn: ?[*:0]const u8,
NewRDN: ?[*:0]const u8,
NewParent: ?[*:0]const u8,
DeleteOldRdn: i32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_addW(
ld: ?*ldap,
dn: ?PWSTR,
attrs: ?*?*ldapmodW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_addA(
ld: ?*ldap,
dn: ?PSTR,
attrs: ?*?*ldapmodA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_sW(
ld: ?*ldap,
dn: ?PWSTR,
attrs: ?*?*ldapmodW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_sA(
ld: ?*ldap,
dn: ?PSTR,
attrs: ?*?*ldapmodA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_extW(
ld: ?*ldap,
dn: ?[*:0]const u16,
attrs: ?*?*ldapmodW,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_extA(
ld: ?*ldap,
dn: ?[*:0]const u8,
attrs: ?*?*ldapmodA,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_ext_sW(
ld: ?*ldap,
dn: ?[*:0]const u16,
attrs: ?*?*ldapmodW,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_ext_sA(
ld: ?*ldap,
dn: ?[*:0]const u8,
attrs: ?*?*ldapmodA,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add(
ld: ?*ldap,
dn: ?PSTR,
attrs: ?*?*ldapmodA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_s(
ld: ?*ldap,
dn: ?PSTR,
attrs: ?*?*ldapmodA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_ext(
ld: ?*ldap,
dn: ?[*:0]const u8,
attrs: ?*?*ldapmodA,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_add_ext_s(
ld: ?*ldap,
dn: ?[*:0]const u8,
attrs: ?*?*ldapmodA,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compareW(
ld: ?*ldap,
dn: ?[*:0]const u16,
attr: ?[*:0]const u16,
value: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compareA(
ld: ?*ldap,
dn: ?[*:0]const u8,
attr: ?[*:0]const u8,
value: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_sW(
ld: ?*ldap,
dn: ?[*:0]const u16,
attr: ?[*:0]const u16,
value: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_sA(
ld: ?*ldap,
dn: ?[*:0]const u8,
attr: ?[*:0]const u8,
value: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare(
ld: ?*ldap,
dn: ?[*:0]const u8,
attr: ?[*:0]const u8,
value: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_s(
ld: ?*ldap,
dn: ?[*:0]const u8,
attr: ?[*:0]const u8,
value: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_extW(
ld: ?*ldap,
dn: ?[*:0]const u16,
Attr: ?[*:0]const u16,
Value: ?[*:0]const u16,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_extA(
ld: ?*ldap,
dn: ?[*:0]const u8,
Attr: ?[*:0]const u8,
Value: ?[*:0]const u8,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_ext_sW(
ld: ?*ldap,
dn: ?[*:0]const u16,
Attr: ?[*:0]const u16,
Value: ?[*:0]const u16,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_ext_sA(
ld: ?*ldap,
dn: ?[*:0]const u8,
Attr: ?[*:0]const u8,
Value: ?[*:0]const u8,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_ext(
ld: ?*ldap,
dn: ?[*:0]const u8,
Attr: ?[*:0]const u8,
Value: ?[*:0]const u8,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_compare_ext_s(
ld: ?*ldap,
dn: ?[*:0]const u8,
Attr: ?[*:0]const u8,
Value: ?[*:0]const u8,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_deleteW(
ld: ?*ldap,
dn: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_deleteA(
ld: ?*ldap,
dn: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_sW(
ld: ?*ldap,
dn: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_sA(
ld: ?*ldap,
dn: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_extW(
ld: ?*ldap,
dn: ?[*:0]const u16,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_extA(
ld: ?*ldap,
dn: ?[*:0]const u8,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_ext_sW(
ld: ?*ldap,
dn: ?[*:0]const u16,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_ext_sA(
ld: ?*ldap,
dn: ?[*:0]const u8,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete(
ld: ?*ldap,
dn: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_s(
ld: ?*ldap,
dn: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_ext(
ld: ?*ldap,
dn: ?[*:0]const u8,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_delete_ext_s(
ld: ?*ldap,
dn: ?[*:0]const u8,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_abandon(
ld: ?*ldap,
msgid: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_result(
ld: ?*ldap,
msgid: u32,
all: u32,
timeout: ?*LDAP_TIMEVAL,
res: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_msgfree(
res: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_result2error(
ld: ?*ldap,
res: ?*LDAPMessage,
freeit: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_resultW(
Connection: ?*ldap,
ResultMessage: ?*LDAPMessage,
ReturnCode: ?*u32,
MatchedDNs: ?*?PWSTR,
ErrorMessage: ?*?PWSTR,
Referrals: ?*?*?*u16,
ServerControls: ?*?*?*ldapcontrolW,
Freeit: BOOLEAN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_resultA(
Connection: ?*ldap,
ResultMessage: ?*LDAPMessage,
ReturnCode: ?*u32,
MatchedDNs: ?*?PSTR,
ErrorMessage: ?*?PSTR,
Referrals: ?*?*?*i8,
ServerControls: ?*?*?*ldapcontrolA,
Freeit: BOOLEAN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_extended_resultA(
Connection: ?*ldap,
ResultMessage: ?*LDAPMessage,
ResultOID: ?*?PSTR,
ResultData: ?*?*LDAP_BERVAL,
Freeit: BOOLEAN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_extended_resultW(
Connection: ?*ldap,
ResultMessage: ?*LDAPMessage,
ResultOID: ?*?PWSTR,
ResultData: ?*?*LDAP_BERVAL,
Freeit: BOOLEAN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_controls_freeA(
Controls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_control_freeA(
Controls: ?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_controls_freeW(
Control: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_control_freeW(
Control: ?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_free_controlsW(
Controls: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_free_controlsA(
Controls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_result(
Connection: ?*ldap,
ResultMessage: ?*LDAPMessage,
ReturnCode: ?*u32,
MatchedDNs: ?*?PSTR,
ErrorMessage: ?*?PSTR,
Referrals: ?*?*?PSTR,
ServerControls: ?*?*?*ldapcontrolA,
Freeit: BOOLEAN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_controls_free(
Controls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_control_free(
Control: ?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_free_controls(
Controls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_err2stringW(
err: u32,
) callconv(@import("std").os.windows.WINAPI) ?PWSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_err2stringA(
err: u32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_err2string(
err: u32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_perror(
ld: ?*ldap,
msg: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_first_entry(
ld: ?*ldap,
res: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) ?*LDAPMessage;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_next_entry(
ld: ?*ldap,
entry: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) ?*LDAPMessage;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_count_entries(
ld: ?*ldap,
res: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_first_attributeW(
ld: ?*ldap,
entry: ?*LDAPMessage,
ptr: ?*?*berelement,
) callconv(@import("std").os.windows.WINAPI) ?PWSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_first_attributeA(
ld: ?*ldap,
entry: ?*LDAPMessage,
ptr: ?*?*berelement,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_first_attribute(
ld: ?*ldap,
entry: ?*LDAPMessage,
ptr: ?*?*berelement,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_next_attributeW(
ld: ?*ldap,
entry: ?*LDAPMessage,
ptr: ?*berelement,
) callconv(@import("std").os.windows.WINAPI) ?PWSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_next_attributeA(
ld: ?*ldap,
entry: ?*LDAPMessage,
ptr: ?*berelement,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_next_attribute(
ld: ?*ldap,
entry: ?*LDAPMessage,
ptr: ?*berelement,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_valuesW(
ld: ?*ldap,
entry: ?*LDAPMessage,
attr: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?*?PWSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_valuesA(
ld: ?*ldap,
entry: ?*LDAPMessage,
attr: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_values(
ld: ?*ldap,
entry: ?*LDAPMessage,
attr: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_values_lenW(
ExternalHandle: ?*ldap,
Message: ?*LDAPMessage,
attr: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?*?*LDAP_BERVAL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_values_lenA(
ExternalHandle: ?*ldap,
Message: ?*LDAPMessage,
attr: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*?*LDAP_BERVAL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_values_len(
ExternalHandle: ?*ldap,
Message: ?*LDAPMessage,
attr: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*?*LDAP_BERVAL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_count_valuesW(
vals: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_count_valuesA(
vals: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_count_values(
vals: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_count_values_len(
vals: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_value_freeW(
vals: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_value_freeA(
vals: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_value_free(
vals: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_value_free_len(
vals: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_dnW(
ld: ?*ldap,
entry: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) ?PWSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_dnA(
ld: ?*ldap,
entry: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_dn(
ld: ?*ldap,
entry: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_explode_dnW(
dn: ?[*:0]const u16,
notypes: u32,
) callconv(@import("std").os.windows.WINAPI) ?*?PWSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_explode_dnA(
dn: ?[*:0]const u8,
notypes: u32,
) callconv(@import("std").os.windows.WINAPI) ?*?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_explode_dn(
dn: ?[*:0]const u8,
notypes: u32,
) callconv(@import("std").os.windows.WINAPI) ?*?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_dn2ufnW(
dn: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?PWSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_dn2ufnA(
dn: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_dn2ufn(
dn: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_memfreeW(
Block: ?[*]u16,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_memfreeA(
Block: ?[*]u8,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_bvfree(
bv: ?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_memfree(
Block: ?[*]u8,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_ufn2dnW(
ufn: ?[*:0]const u16,
pDn: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_ufn2dnA(
ufn: ?[*:0]const u8,
pDn: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_ufn2dn(
ufn: ?[*:0]const u8,
pDn: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WLDAP32" fn ldap_startup(
version: ?*ldap_version_info,
Instance: ?*?HANDLE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_cleanup(
hInstance: ?HANDLE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_escape_filter_elementW(
// TODO: what to do with BytesParamIndex 1?
sourceFilterElement: ?[*]u8,
sourceLength: u32,
// TODO: what to do with BytesParamIndex 3?
destFilterElement: ?[*]u16,
destLength: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_escape_filter_elementA(
// TODO: what to do with BytesParamIndex 1?
sourceFilterElement: ?[*]u8,
sourceLength: u32,
// TODO: what to do with BytesParamIndex 3?
destFilterElement: ?[*]u8,
destLength: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_escape_filter_element(
// TODO: what to do with BytesParamIndex 1?
sourceFilterElement: ?[*]u8,
sourceLength: u32,
// TODO: what to do with BytesParamIndex 3?
destFilterElement: ?[*]u8,
destLength: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WLDAP32" fn ldap_set_dbg_flags(
NewFlags: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WLDAP32" fn ldap_set_dbg_routine(
DebugPrintRoutine: ?DBGPRINT,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn LdapUTF8ToUnicode(
lpSrcStr: [*:0]const u8,
cchSrc: i32,
lpDestStr: [*:0]u16,
cchDest: i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn LdapUnicodeToUTF8(
lpSrcStr: [*:0]const u16,
cchSrc: i32,
lpDestStr: [*:0]u8,
cchDest: i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_create_sort_controlA(
ExternalHandle: ?*ldap,
SortKeys: ?*?*ldapsortkeyA,
IsCritical: u8,
Control: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_create_sort_controlW(
ExternalHandle: ?*ldap,
SortKeys: ?*?*ldapsortkeyW,
IsCritical: u8,
Control: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_sort_controlA(
ExternalHandle: ?*ldap,
Control: ?*?*ldapcontrolA,
Result: ?*u32,
Attribute: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_sort_controlW(
ExternalHandle: ?*ldap,
Control: ?*?*ldapcontrolW,
Result: ?*u32,
Attribute: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_create_sort_control(
ExternalHandle: ?*ldap,
SortKeys: ?*?*ldapsortkeyA,
IsCritical: u8,
Control: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_sort_control(
ExternalHandle: ?*ldap,
Control: ?*?*ldapcontrolA,
Result: ?*u32,
Attribute: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_encode_sort_controlW(
ExternalHandle: ?*ldap,
SortKeys: ?*?*ldapsortkeyW,
Control: ?*ldapcontrolW,
Criticality: BOOLEAN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_encode_sort_controlA(
ExternalHandle: ?*ldap,
SortKeys: ?*?*ldapsortkeyA,
Control: ?*ldapcontrolA,
Criticality: BOOLEAN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_create_page_controlW(
ExternalHandle: ?*ldap,
PageSize: u32,
Cookie: ?*LDAP_BERVAL,
IsCritical: u8,
Control: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_create_page_controlA(
ExternalHandle: ?*ldap,
PageSize: u32,
Cookie: ?*LDAP_BERVAL,
IsCritical: u8,
Control: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_page_controlW(
ExternalHandle: ?*ldap,
ServerControls: ?*?*ldapcontrolW,
TotalCount: ?*u32,
Cookie: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_page_controlA(
ExternalHandle: ?*ldap,
ServerControls: ?*?*ldapcontrolA,
TotalCount: ?*u32,
Cookie: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_create_page_control(
ExternalHandle: ?*ldap,
PageSize: u32,
Cookie: ?*LDAP_BERVAL,
IsCritical: u8,
Control: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_page_control(
ExternalHandle: ?*ldap,
ServerControls: ?*?*ldapcontrolA,
TotalCount: ?*u32,
Cookie: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_init_pageW(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u16,
ScopeOfSearch: u32,
SearchFilter: ?[*:0]const u16,
AttributeList: ?*?*u16,
AttributesOnly: u32,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
PageTimeLimit: u32,
TotalSizeLimit: u32,
SortKeys: ?*?*ldapsortkeyW,
) callconv(@import("std").os.windows.WINAPI) ?*ldapsearch;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_init_pageA(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
ScopeOfSearch: u32,
SearchFilter: ?[*:0]const u8,
AttributeList: ?*?*i8,
AttributesOnly: u32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
PageTimeLimit: u32,
TotalSizeLimit: u32,
SortKeys: ?*?*ldapsortkeyA,
) callconv(@import("std").os.windows.WINAPI) ?*ldapsearch;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_init_page(
ExternalHandle: ?*ldap,
DistinguishedName: ?[*:0]const u8,
ScopeOfSearch: u32,
SearchFilter: ?[*:0]const u8,
AttributeList: ?*?*i8,
AttributesOnly: u32,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
PageTimeLimit: u32,
TotalSizeLimit: u32,
SortKeys: ?*?*ldapsortkeyA,
) callconv(@import("std").os.windows.WINAPI) ?*ldapsearch;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_next_page(
ExternalHandle: ?*ldap,
SearchHandle: ?*ldapsearch,
PageSize: u32,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_next_page_s(
ExternalHandle: ?*ldap,
SearchHandle: ?*ldapsearch,
timeout: ?*LDAP_TIMEVAL,
PageSize: u32,
TotalCount: ?*u32,
Results: ?*?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_get_paged_count(
ExternalHandle: ?*ldap,
SearchBlock: ?*ldapsearch,
TotalCount: ?*u32,
Results: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_search_abandon_page(
ExternalHandle: ?*ldap,
SearchBlock: ?*ldapsearch,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_create_vlv_controlW(
ExternalHandle: ?*ldap,
VlvInfo: ?*ldapvlvinfo,
IsCritical: u8,
Control: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_create_vlv_controlA(
ExternalHandle: ?*ldap,
VlvInfo: ?*ldapvlvinfo,
IsCritical: u8,
Control: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_vlv_controlW(
ExternalHandle: ?*ldap,
Control: ?*?*ldapcontrolW,
TargetPos: ?*u32,
ListCount: ?*u32,
Context: ?*?*LDAP_BERVAL,
ErrCode: ?*i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_vlv_controlA(
ExternalHandle: ?*ldap,
Control: ?*?*ldapcontrolA,
TargetPos: ?*u32,
ListCount: ?*u32,
Context: ?*?*LDAP_BERVAL,
ErrCode: ?*i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_start_tls_sW(
ExternalHandle: ?*ldap,
ServerReturnValue: ?*u32,
result: ?*?*LDAPMessage,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_start_tls_sA(
ExternalHandle: ?*ldap,
ServerReturnValue: ?*u32,
result: ?*?*LDAPMessage,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_stop_tls_s(
ExternalHandle: ?*ldap,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_first_reference(
ld: ?*ldap,
res: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) ?*LDAPMessage;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_next_reference(
ld: ?*ldap,
entry: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) ?*LDAPMessage;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_count_references(
ld: ?*ldap,
res: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_referenceW(
Connection: ?*ldap,
ResultMessage: ?*LDAPMessage,
Referrals: ?*?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_referenceA(
Connection: ?*ldap,
ResultMessage: ?*LDAPMessage,
Referrals: ?*?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_parse_reference(
Connection: ?*ldap,
ResultMessage: ?*LDAPMessage,
Referrals: ?*?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_extended_operationW(
ld: ?*ldap,
Oid: ?[*:0]const u16,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_extended_operationA(
ld: ?*ldap,
Oid: ?[*:0]const u8,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_extended_operation_sA(
ExternalHandle: ?*ldap,
Oid: ?PSTR,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
ReturnedOid: ?*?PSTR,
ReturnedData: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_extended_operation_sW(
ExternalHandle: ?*ldap,
Oid: ?PWSTR,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolW,
ClientControls: ?*?*ldapcontrolW,
ReturnedOid: ?*?PWSTR,
ReturnedData: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_extended_operation(
ld: ?*ldap,
Oid: ?[*:0]const u8,
Data: ?*LDAP_BERVAL,
ServerControls: ?*?*ldapcontrolA,
ClientControls: ?*?*ldapcontrolA,
MessageNumber: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_close_extended_op(
ld: ?*ldap,
MessageNumber: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn LdapGetLastError(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn LdapMapErrorToWin32(
LdapError: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ldap_conn_from_msg(
PrimaryConn: ?*ldap,
res: ?*LDAPMessage,
) callconv(@import("std").os.windows.WINAPI) ?*ldap;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_init(
pBerVal: ?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) ?*berelement;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_free(
pBerElement: ?*berelement,
fbuf: i32,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_bvecfree(
pBerVal: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_bvdup(
pBerVal: ?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) ?*LDAP_BERVAL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_alloc_t(
options: i32,
) callconv(@import("std").os.windows.WINAPI) ?*berelement;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_skip_tag(
pBerElement: ?*berelement,
pLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_peek_tag(
pBerElement: ?*berelement,
pLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_first_element(
pBerElement: ?*berelement,
pLen: ?*u32,
ppOpaque: ?*?*CHAR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_next_element(
pBerElement: ?*berelement,
pLen: ?*u32,
@"opaque": ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_flatten(
pBerElement: ?*berelement,
pBerVal: ?*?*LDAP_BERVAL,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_printf(
pBerElement: ?*berelement,
fmt: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "WLDAP32" fn ber_scanf(
pBerElement: ?*berelement,
fmt: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) u32;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (14)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
pub const ldapcontrol = thismodule.ldapcontrolA;
pub const ldapmod = thismodule.ldapmodA;
pub const ldapapiinfo = thismodule.ldapapiinfoA;
pub const LDAPAPIFeatureInfo = thismodule.LDAPAPIFeatureInfoA;
pub const ldapsortkey = thismodule.ldapsortkeyA;
pub const ldap_sasl_bind = thismodule.ldap_sasl_bindA;
pub const ldap_sasl_bind_s = thismodule.ldap_sasl_bind_sA;
pub const ldap_check_filter = thismodule.ldap_check_filterA;
pub const ldap_parse_extended_result = thismodule.ldap_parse_extended_resultA;
pub const ldap_encode_sort_control = thismodule.ldap_encode_sort_controlA;
pub const ldap_create_vlv_control = thismodule.ldap_create_vlv_controlA;
pub const ldap_parse_vlv_control = thismodule.ldap_parse_vlv_controlA;
pub const ldap_start_tls_s = thismodule.ldap_start_tls_sA;
pub const ldap_extended_operation_s = thismodule.ldap_extended_operation_sA;
},
.wide => struct {
pub const ldapcontrol = thismodule.ldapcontrolW;
pub const ldapmod = thismodule.ldapmodW;
pub const ldapapiinfo = thismodule.ldapapiinfoW;
pub const LDAPAPIFeatureInfo = thismodule.LDAPAPIFeatureInfoW;
pub const ldapsortkey = thismodule.ldapsortkeyW;
pub const ldap_sasl_bind = thismodule.ldap_sasl_bindW;
pub const ldap_sasl_bind_s = thismodule.ldap_sasl_bind_sW;
pub const ldap_check_filter = thismodule.ldap_check_filterW;
pub const ldap_parse_extended_result = thismodule.ldap_parse_extended_resultW;
pub const ldap_encode_sort_control = thismodule.ldap_encode_sort_controlW;
pub const ldap_create_vlv_control = thismodule.ldap_create_vlv_controlW;
pub const ldap_parse_vlv_control = thismodule.ldap_parse_vlv_controlW;
pub const ldap_start_tls_s = thismodule.ldap_start_tls_sW;
pub const ldap_extended_operation_s = thismodule.ldap_extended_operation_sW;
},
.unspecified => if (@import("builtin").is_test) struct {
pub const ldapcontrol = *opaque{};
pub const ldapmod = *opaque{};
pub const ldapapiinfo = *opaque{};
pub const LDAPAPIFeatureInfo = *opaque{};
pub const ldapsortkey = *opaque{};
pub const ldap_sasl_bind = *opaque{};
pub const ldap_sasl_bind_s = *opaque{};
pub const ldap_check_filter = *opaque{};
pub const ldap_parse_extended_result = *opaque{};
pub const ldap_encode_sort_control = *opaque{};
pub const ldap_create_vlv_control = *opaque{};
pub const ldap_parse_vlv_control = *opaque{};
pub const ldap_start_tls_s = *opaque{};
pub const ldap_extended_operation_s = *opaque{};
} else struct {
pub const ldapcontrol = @compileError("'ldapcontrol' requires that UNICODE be set to true or false in the root module");
pub const ldapmod = @compileError("'ldapmod' requires that UNICODE be set to true or false in the root module");
pub const ldapapiinfo = @compileError("'ldapapiinfo' requires that UNICODE be set to true or false in the root module");
pub const LDAPAPIFeatureInfo = @compileError("'LDAPAPIFeatureInfo' requires that UNICODE be set to true or false in the root module");
pub const ldapsortkey = @compileError("'ldapsortkey' requires that UNICODE be set to true or false in the root module");
pub const ldap_sasl_bind = @compileError("'ldap_sasl_bind' requires that UNICODE be set to true or false in the root module");
pub const ldap_sasl_bind_s = @compileError("'ldap_sasl_bind_s' requires that UNICODE be set to true or false in the root module");
pub const ldap_check_filter = @compileError("'ldap_check_filter' requires that UNICODE be set to true or false in the root module");
pub const ldap_parse_extended_result = @compileError("'ldap_parse_extended_result' requires that UNICODE be set to true or false in the root module");
pub const ldap_encode_sort_control = @compileError("'ldap_encode_sort_control' requires that UNICODE be set to true or false in the root module");
pub const ldap_create_vlv_control = @compileError("'ldap_create_vlv_control' requires that UNICODE be set to true or false in the root module");
pub const ldap_parse_vlv_control = @compileError("'ldap_parse_vlv_control' requires that UNICODE be set to true or false in the root module");
pub const ldap_start_tls_s = @compileError("'ldap_start_tls_s' requires that UNICODE be set to true or false in the root module");
pub const ldap_extended_operation_s = @compileError("'ldap_extended_operation_s' requires that UNICODE be set to true or false in the root module");
},
};
//--------------------------------------------------------------------------------
// Section: Imports (7)
//--------------------------------------------------------------------------------
const BOOLEAN = @import("../foundation.zig").BOOLEAN;
const CERT_CONTEXT = @import("../security/cryptography.zig").CERT_CONTEXT;
const CHAR = @import("../foundation.zig").CHAR;
const HANDLE = @import("../foundation.zig").HANDLE;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;
const SecPkgContext_IssuerListInfoEx = @import("../security/authentication/identity.zig").SecPkgContext_IssuerListInfoEx;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "DBGPRINT")) { _ = DBGPRINT; }
if (@hasDecl(@This(), "QUERYFORCONNECTION")) { _ = QUERYFORCONNECTION; }
if (@hasDecl(@This(), "NOTIFYOFNEWCONNECTION")) { _ = NOTIFYOFNEWCONNECTION; }
if (@hasDecl(@This(), "DEREFERENCECONNECTION")) { _ = DEREFERENCECONNECTION; }
if (@hasDecl(@This(), "QUERYCLIENTCERT")) { _ = QUERYCLIENTCERT; }
if (@hasDecl(@This(), "VERIFYSERVERCERT")) { _ = VERIFYSERVERCERT; }
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/networking/ldap.zig |
pub const SYS = enum(usize) {
restart_syscall = 0x00,
exit = 0x01,
fork = 0x02,
read = 0x03,
write = 0x04,
open = 0x05,
close = 0x06,
waitpid = 0x07,
creat = 0x08,
link = 0x09,
unlink = 0x0a,
execve = 0x0b,
chdir = 0x0c,
time = 0x0d,
mknod = 0x0e,
chmod = 0x0f,
lchown = 0x10,
@"break" = 0x11,
oldstat = 0x12,
lseek = 0x13,
getpid = 0x14,
mount = 0x15,
umount = 0x16,
setuid = 0x17,
getuid = 0x18,
stime = 0x19,
ptrace = 0x1a,
alarm = 0x1b,
oldfstat = 0x1c,
pause = 0x1d,
utime = 0x1e,
stty = 0x1f,
gtty = 0x20,
access = 0x21,
nice = 0x22,
ftime = 0x23,
sync = 0x24,
kill = 0x25,
rename = 0x26,
mkdir = 0x27,
rmdir = 0x28,
dup = 0x29,
pipe = 0x2a,
times = 0x2b,
prof = 0x2c,
brk = 0x2d,
setgid = 0x2e,
getgid = 0x2f,
signal = 0x30,
geteuid = 0x31,
getegid = 0x32,
acct = 0x33,
umount2 = 0x34,
lock = 0x35,
ioctl = 0x36,
fcntl = 0x37,
mpx = 0x38,
setpgid = 0x39,
ulimit = 0x3a,
oldolduname = 0x3b,
umask = 0x3c,
chroot = 0x3d,
ustat = 0x3e,
dup2 = 0x3f,
getppid = 0x40,
getpgrp = 0x41,
setsid = 0x42,
sigaction = 0x43,
sgetmask = 0x44,
ssetmask = 0x45,
setreuid = 0x46,
setregid = 0x47,
sigsuspend = 0x48,
sigpending = 0x49,
sethostname = 0x4a,
setrlimit = 0x4b,
getrlimit = 0x4c,
getrusage = 0x4d,
gettimeofday = 0x4e,
settimeofday = 0x4f,
getgroups = 0x50,
setgroups = 0x51,
select = 0x52,
symlink = 0x53,
oldlstat = 0x54,
readlink = 0x55,
uselib = 0x56,
swapon = 0x57,
reboot = 0x58,
readdir = 0x59,
mmap = 0x5a,
munmap = 0x5b,
truncate = 0x5c,
ftruncate = 0x5d,
fchmod = 0x5e,
fchown = 0x5f,
getpriority = 0x60,
setpriority = 0x61,
profil = 0x62,
statfs = 0x63,
fstatfs = 0x64,
ioperm = 0x65,
socketcall = 0x66,
syslog = 0x67,
setitimer = 0x68,
getitimer = 0x69,
stat = 0x6a,
lstat = 0x6b,
fstat = 0x6c,
olduname = 0x6d,
iopl = 0x6e,
vhangup = 0x6f,
idle = 0x70,
vm86old = 0x71,
wait4 = 0x72,
swapoff = 0x73,
sysinfo = 0x74,
ipc = 0x75,
fsync = 0x76,
sigreturn = 0x77,
clone = 0x78,
setdomainname = 0x79,
uname = 0x7a,
modify_ldt = 0x7b,
adjtimex = 0x7c,
mprotect = 0x7d,
sigprocmask = 0x7e,
create_module = 0x7f,
init_module = 0x80,
delete_module = 0x81,
get_kernel_syms = 0x82,
quotactl = 0x83,
getpgid = 0x84,
fchdir = 0x85,
bdflush = 0x86,
sysfs = 0x87,
personality = 0x88,
afs_syscall = 0x89,
setfsuid = 0x8a,
setfsgid = 0x8b,
_llseek = 0x8c,
getdents = 0x8d,
_newselect = 0x8e,
flock = 0x8f,
msync = 0x90,
readv = 0x91,
writev = 0x92,
getsid = 0x93,
fdatasync = 0x94,
_sysctl = 0x95,
mlock = 0x96,
munlock = 0x97,
mlockall = 0x98,
munlockall = 0x99,
sched_setparam = 0x9a,
sched_getparam = 0x9b,
sched_setscheduler = 0x9c,
sched_getscheduler = 0x9d,
sched_yield = 0x9e,
sched_get_priority_max = 0x9f,
sched_get_priority_min = 0xa0,
sched_rr_get_interval = 0xa1,
nanosleep = 0xa2,
mremap = 0xa3,
setresuid = 0xa4,
getresuid = 0xa5,
vm86 = 0xa6,
query_module = 0xa7,
poll = 0xa8,
nfsservctl = 0xa9,
setresgid = 0xaa,
getresgid = 0xab,
prctl = 0xac,
rt_sigreturn = 0xad,
rt_sigaction = 0xae,
rt_sigprocmask = 0xaf,
rt_sigpending = 0xb0,
rt_sigtimedwait = 0xb1,
rt_sigqueueinfo = 0xb2,
rt_sigsuspend = 0xb3,
pread64 = 0xb4,
pwrite64 = 0xb5,
chown = 0xb6,
getcwd = 0xb7,
capget = 0xb8,
capset = 0xb9,
sigaltstack = 0xba,
sendfile = 0xbb,
getpmsg = 0xbc,
putpmsg = 0xbd,
vfork = 0xbe,
ugetrlimit = 0xbf,
mmap2 = 0xc0,
truncate64 = 0xc1,
ftruncate64 = 0xc2,
stat64 = 0xc3,
lstat64 = 0xc4,
fstat64 = 0xc5,
lchown32 = 0xc6,
getuid32 = 0xc7,
getgid32 = 0xc8,
geteuid32 = 0xc9,
getegid32 = 0xca,
setreuid32 = 0xcb,
setregid32 = 0xcc,
getgroups32 = 0xcd,
setgroups32 = 0xce,
fchown32 = 0xcf,
setresuid32 = 0xd0,
getresuid32 = 0xd1,
setresgid32 = 0xd2,
getresgid32 = 0xd3,
chown32 = 0xd4,
setuid32 = 0xd5,
setgid32 = 0xd6,
setfsuid32 = 0xd7,
setfsgid32 = 0xd8,
pivot_root = 0xd9,
mincore = 0xda,
madvise = 0xdb,
getdents64 = 0xdc,
fcntl64 = 0xdd,
gettid = 0xe0,
readahead = 0xe1,
setxattr = 0xe2,
lsetxattr = 0xe3,
fsetxattr = 0xe4,
getxattr = 0xe5,
lgetxattr = 0xe6,
fgetxattr = 0xe7,
listxattr = 0xe8,
llistxattr = 0xe9,
flistxattr = 0xea,
removexattr = 0xeb,
lremovexattr = 0xec,
fremovexattr = 0xed,
tkill = 0xee,
sendfile64 = 0xef,
futex = 0xf0,
sched_setaffinity = 0xf1,
sched_getaffinity = 0xf2,
set_thread_area = 0xf3,
get_thread_area = 0xf4,
io_setup = 0xf5,
io_destroy = 0xf6,
io_getevents = 0xf7,
io_submit = 0xf8,
io_cancel = 0xf9,
fadvise64 = 0xfa,
exit_group = 0xfc,
lookup_dcookie = 0xfd,
epoll_create = 0xfe,
epoll_ctl = 0xff,
epoll_wait = 0x100,
remap_file_pages = 0x101,
set_tid_address = 0x102,
timer_create = 0x103,
timer_settime = 0x104,
timer_gettime = 0x105,
timer_getoverrun = 0x106,
timer_delete = 0x107,
clock_settime = 0x108,
clock_gettime = 0x109,
clock_getres = 0x10a,
clock_nanosleep = 0x10b,
statfs64 = 0x10c,
fstatfs64 = 0x10d,
tgkill = 0x10e,
utimes = 0x10f,
fadvise64_64 = 0x110,
vserver = 0x111,
mbind = 0x112,
get_mempolicy = 0x113,
set_mempolicy = 0x114,
mq_open = 0x115,
mq_unlink = 0x116,
mq_timedsend = 0x117,
mq_timedreceive = 0x118,
mq_notify = 0x119,
mq_getsetattr = 0x11a,
kexec_load = 0x11b,
waitid = 0x11c,
add_key = 0x11e,
request_key = 0x11f,
keyctl = 0x120,
ioprio_set = 0x121,
ioprio_get = 0x122,
inotify_init = 0x123,
inotify_add_watch = 0x124,
inotify_rm_watch = 0x125,
migrate_pages = 0x126,
openat = 0x127,
mkdirat = 0x128,
mknodat = 0x129,
fchownat = 0x12a,
futimesat = 0x12b,
fstatat64 = 0x12c,
unlinkat = 0x12d,
renameat = 0x12e,
linkat = 0x12f,
symlinkat = 0x130,
readlinkat = 0x131,
fchmodat = 0x132,
faccessat = 0x133,
pselect6 = 0x134,
ppoll = 0x135,
unshare = 0x136,
set_robust_list = 0x137,
get_robust_list = 0x138,
splice = 0x139,
sync_file_range = 0x13a,
tee = 0x13b,
vmsplice = 0x13c,
move_pages = 0x13d,
getcpu = 0x13e,
epoll_pwait = 0x13f,
utimensat = 0x140,
signalfd = 0x141,
timerfd_create = 0x142,
eventfd = 0x143,
fallocate = 0x144,
timerfd_settime = 0x145,
timerfd_gettime = 0x146,
signalfd4 = 0x147,
eventfd2 = 0x148,
epoll_create1 = 0x149,
dup3 = 0x14a,
pipe2 = 0x14b,
inotify_init1 = 0x14c,
preadv = 0x14d,
pwritev = 0x14e,
rt_tgsigqueueinfo = 0x14f,
perf_event_open = 0x150,
recvmmsg = 0x151,
fanotify_init = 0x152,
fanotify_mark = 0x153,
prlimit64 = 0x154,
name_to_handle_at = 0x155,
open_by_handle_at = 0x156,
clock_adjtime = 0x157,
syncfs = 0x158,
sendmmsg = 0x159,
setns = 0x15a,
process_vm_readv = 0x15b,
process_vm_writev = 0x15c,
kcmp = 0x15d,
finit_module = 0x15e,
sched_setattr = 0x15f,
sched_getattr = 0x160,
renameat2 = 0x161,
seccomp = 0x162,
getrandom = 0x163,
memfd_create = 0x164,
bpf = 0x165,
execveat = 0x166,
socket = 0x167,
socketpair = 0x168,
bind = 0x169,
connect = 0x16a,
listen = 0x16b,
accept4 = 0x16c,
getsockopt = 0x16d,
setsockopt = 0x16e,
getsockname = 0x16f,
getpeername = 0x170,
sendto = 0x171,
sendmsg = 0x172,
recvfrom = 0x173,
recvmsg = 0x174,
shutdown = 0x175,
userfaultfd = 0x176,
membarrier = 0x177,
mlock2 = 0x178,
copy_file_range = 0x179,
preadv2 = 0x17a,
pwritev2 = 0x17b,
pkey_mprotect = 0x17c,
pkey_alloc = 0x17d,
pkey_free = 0x17e,
statx = 0x17f,
arch_prctl = 0x180,
}; | src/linux/i386/consts.zig |
const std = @import("std");
pub const Relocation = struct {
/// Represents the type of the `Relocation`
relocation_type: RelocationType,
/// Offset of the value to rewrite relative to the relevant section's contents.
/// When `offset` is zero, its position is immediately after the id and size of the section.
offset: u32,
/// The index of the symbol used.
/// When the type is `R_WASM_TYPE_INDEX_LEB`, it represents the index of the type.
index: u32,
/// Addend to add to the address.
/// This field is only non-null for `R_WASM_MEMORY_ADDR_*`, `R_WASM_FUNCTION_OFFSET_I32` and `R_WASM_SECTION_OFFSET_I32`.
addend: ?u32 = null,
/// All possible relocation types currently existing.
/// This enum is exhaustive as the spec is WIP and new types
/// can be added which means that a generated binary will be invalid,
/// so instead we will show an error in such cases.
pub const RelocationType = enum(u8) {
R_WASM_FUNCTION_INDEX_LEB = 0,
R_WASM_TABLE_INDEX_SLEB = 1,
R_WASM_TABLE_INDEX_I32 = 2,
R_WASM_MEMORY_ADDR_LEB = 3,
R_WASM_MEMORY_ADDR_SLEB = 4,
R_WASM_MEMORY_ADDR_I32 = 5,
R_WASM_TYPE_INDEX_LEB = 6,
R_WASM_GLOBAL_INDEX_LEB = 7,
R_WASM_FUNCTION_OFFSET_I32 = 8,
R_WASM_SECTION_OFFSET_I32 = 9,
R_WASM_EVENT_INDEX_LEB = 10,
R_WASM_GLOBAL_INDEX_I32 = 13,
R_WASM_MEMORY_ADDR_LEB64 = 14,
R_WASM_MEMORY_ADDR_SLEB64 = 15,
R_WASM_MEMORY_ADDR_I64 = 16,
R_WASM_TABLE_INDEX_SLEB64 = 18,
R_WASM_TABLE_INDEX_I64 = 19,
R_WASM_TABLE_NUMBER_LEB = 20,
/// Returns true for relocation types where the `addend` field is present.
pub fn addendIsPresent(self: RelocationType) bool {
return switch (self) {
.R_WASM_MEMORY_ADDR_LEB,
.R_WASM_MEMORY_ADDR_SLEB,
.R_WASM_MEMORY_ADDR_I32,
.R_WASM_MEMORY_ADDR_LEB64,
.R_WASM_MEMORY_ADDR_SLEB64,
.R_WASM_MEMORY_ADDR_I64,
.R_WASM_FUNCTION_OFFSET_I32,
.R_WASM_SECTION_OFFSET_I32,
=> true,
else => false,
};
}
};
/// Verifies the relocation type of a given `Relocation` and returns
/// true when the relocation references a function call or address to a function.
pub fn isFunction(self: Relocation) bool {
return switch (self.relocation_type) {
.R_WASM_FUNCTION_INDEX_LEB,
.R_WASM_TABLE_INDEX_SLEB,
=> true,
else => false,
};
}
/// Returns true when the relocation represents a table index relocatable
pub fn isTableIndex(self: Relocation) bool {
return switch (self.relocation_type) {
.R_WASM_TABLE_INDEX_I32,
.R_WASM_TABLE_INDEX_I64,
.R_WASM_TABLE_INDEX_SLEB,
.R_WASM_TABLE_INDEX_SLEB64,
=> true,
else => false,
};
}
pub fn format(self: Relocation, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = fmt;
_ = options;
try writer.print("{s} offset=0x{x:0>6} symbol={d}", .{
@tagName(self.relocation_type),
self.offset,
self.index,
});
}
};
/// Unlike the `Import` object defined by the wasm spec, and existing
/// in the std.wasm namespace, this construct saves the 'module name' and 'name'
/// of the import using offsets into a string table, rather than the slices itself.
/// This saves us (potentially) 24 bytes per import on 64bit machines.
pub const Import = struct {
module_name: u32,
name: u32,
kind: std.wasm.Import.Kind,
};
/// Unlike the `Export` object defined by the wasm spec, and existing
/// in the std.wasm namespace, this construct saves the 'name'
/// of the export using offsets into a string table, rather than the slice itself.
/// This saves us (potentially) 12 bytes per export on 64bit machines.
pub const Export = struct {
name: u32,
index: u32,
kind: std.wasm.ExternalKind,
};
pub const SubsectionType = enum(u8) {
WASM_SEGMENT_INFO = 5,
WASM_INIT_FUNCS = 6,
WASM_COMDAT_INFO = 7,
WASM_SYMBOL_TABLE = 8,
};
pub const Segment = struct {
/// Segment's name, encoded as UTF-8 bytes.
name: []const u8,
/// The required alignment of the segment, encoded as a power of 2
alignment: u32,
/// Bitfield containing flags for a segment
flags: u32,
pub fn outputName(self: Segment, merge_segments: bool) []const u8 {
if (!merge_segments) return self.name;
if (std.mem.startsWith(u8, self.name, ".rodata.")) {
return ".rodata";
} else if (std.mem.startsWith(u8, self.name, ".text.")) {
return ".text";
} else if (std.mem.startsWith(u8, self.name, ".rodata.")) {
return ".rodata";
} else if (std.mem.startsWith(u8, self.name, ".data.")) {
return ".data";
} else if (std.mem.startsWith(u8, self.name, ".bss.")) {
return ".bss";
}
return self.name;
}
};
pub const InitFunc = struct {
/// Priority of the init function
priority: u32,
/// The symbol index of init function (not the function index).
symbol_index: u32,
};
pub const Comdat = struct {
name: []const u8,
/// Must be zero, no flags are currently defined by the tool-convention.
flags: u32,
symbols: []const ComdatSym,
};
pub const ComdatSym = struct {
kind: Type,
/// Index of the data segment/function/global/event/table within a WASM module.
/// The object must not be an import.
index: u32,
pub const Type = enum(u8) {
WASM_COMDAT_DATA = 0,
WASM_COMDAT_FUNCTION = 1,
WASM_COMDAT_GLOBAL = 2,
WASM_COMDAT_EVENT = 3,
WASM_COMDAT_TABLE = 4,
WASM_COMDAT_SECTION = 5,
};
};
pub const Feature = struct {
/// Provides information about the usage of the feature.
/// - '0x2b' (+): Object uses this feature, and the link fails if feature is not in the allowed set.
/// - '0x2d' (-): Object does not use this feature, and the link fails if this feature is in the allowed set.
/// - '0x3d' (=): Object uses this feature, and the link fails if this feature is not in the allowed set,
/// or if any object does not use this feature.
prefix: Prefix,
/// Type of the feature, must be unique in the sequence of features.
tag: Tag,
pub const Tag = enum {
atomics,
bulk_memory,
exception_handling,
multivalue,
mutable_globals,
nontrapping_fptoint,
sign_ext,
simd128,
tail_call,
};
pub const Prefix = enum(u8) {
used = '+',
disallowed = '-',
required = '=',
};
pub fn toString(self: Feature) []const u8 {
return switch (self.tag) {
.bulk_memory => "bulk-memory",
.exception_handling => "exception-handling",
.mutable_globals => "mutable-globals",
.nontrapping_fptoint => "nontrapping-fptoint",
.sign_ext => "sign-ext",
.tail_call => "tail-call",
else => @tagName(self),
};
}
pub fn format(self: Feature, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void {
_ = opt;
_ = fmt;
try writer.print("{c} {s}", .{ self.prefix, self.toString() });
}
};
pub const known_features = std.ComptimeStringMap(Feature.Tag, .{
.{ "atomics", .atomics },
.{ "bulk-memory", .bulk_memory },
.{ "exception-handling", .exception_handling },
.{ "multivalue", .multivalue },
.{ "mutable-globals", .mutable_globals },
.{ "nontrapping-fptoint", .nontrapping_fptoint },
.{ "sign-ext", .sign_ext },
.{ "simd128", .simd128 },
.{ "tail-call", .tail_call },
}); | src/link/Wasm/types.zig |
pub const heap = @import("./heap.zig");
pub const vm = @import("./interpreter/vm.zig");
pub const Frame = @import("./interpreter/Frame.zig");
pub const schedule = scheduler.schedule;
pub const notify = notification.notify;
const std = @import("std");
const notification = @import("./interpreter/notification.zig");
const scheduler = @import("./interpreter/scheduler.zig");
const example_tasks = @import("./interpreter/example_tasks.zig");
const uart = @import("./uart.zig");
const ReadLine = @import("lib/ReadLine.zig");
/// The task that should get the next compute cycle.
pub var active_task: *Frame.List.Node = undefined;
/// All tasks.
pub var tasks = Frame.List{};
/// The last as of yet never used ID
var new_id: u32 = 0;
/// What we ought to be doing right now
pub var state: enum { running, task_switching } = .running;
/// This just idles all the time.
var root_task = Frame.List.Node.init(.{
.id = 0,
.program = &[_]Frame.Instruction{},
.waiting = true,
});
const debug = @import("build_options").log_vm;
/// Set up the root task and (for now at least) example tasks
pub fn init() void {
if (comptime debug) uart.print("init interpreter...\n", .{});
tasks.prepend(&root_task);
active_task = &root_task;
shell.foreground_task = &root_task;
if (comptime debug) uart.print(" set up root idle task\n", .{});
createTask(example_tasks.echo[0..]) catch @panic("Kernel OOM");
createTask(example_tasks.echo[0..]) catch @panic("Kernel OOM");
createTask(example_tasks.just_think[0..]) catch @panic("Kernel OOM");
createTask(example_tasks.did_you_know[0..]) catch @panic("Kernel OOM");
}
/// Create a task to be executed based on a slice of instructions
pub fn createTask(program: []const Frame.Instruction) !void {
new_id += 1;
errdefer new_id -= 1;
var node = try heap.kpagealloc.create(Frame.List.Node);
node.* = Frame.List.Node.init(.{
.program = program,
.id = new_id,
});
tasks.prepend(node);
}
/// Kill a task and deallocate its resources.
pub fn destroyTask(task: *Frame.List.Node) void {
task.data.deinit();
tasks.remove(task);
heap.kpagealloc.destroy(task);
active_task = &root_task;
}
pub fn statistics(kind: enum { tasks_total }) usize {
return switch (kind) {
.tasks_total => blk: {
var c: usize = 0;
var it = tasks.first;
while (it) |node| : (it = node.next) {
c += 1;
}
break :blk c;
},
};
}
/// Hand over control of this hart to the VM.
pub fn run() void {
while (true) {
switch (state) {
.running => vm.step(active_task),
.task_switching => shell.TaskSwitcher.update(),
}
}
}
pub const shell = struct {
pub var foreground_task: *Frame.List.Node = undefined;
const SGR = uart.ANSIFormat.SGR;
pub const TaskSwitcher = struct {
pub var line = ReadLine.init(&heap.kpagealloc);
var previous_state: @TypeOf(state) = undefined;
pub fn activate() void {
if (state == .task_switching) return;
previous_state = state;
state = .task_switching;
uart.print("\n{} ", .{SGR.render("Switch Task", SGR.RenderOpts{ .bold = true })});
}
pub fn update() void {
if (line.get()) |chars| {
defer {
state = previous_state;
line.deinit();
line = ReadLine.init(&heap.kpagealloc);
}
if (std.fmt.parseInt(u32, chars, 10) catch null) |new_task_id| {
var it = tasks.first;
while (it) |node| : (it = node.next) {
if (node.data.id == new_task_id) {
foreground_task = node;
state = .running;
uart.print("{} is now in foreground.\n", .{new_task_id});
return;
}
}
uart.print("{} is not a task id.\n", .{chars});
} else {
uart.print("{} is not a task id.\n", .{chars});
}
}
}
};
}; | src/interpreter.zig |
const c = @cImport({
@cDefine("_GNU_SOURCE",{});
@cInclude("sys/mman.h");
@cInclude("sys/stat.h");
@cInclude("fcntl.h");
@cInclude("sys/types.h");
@cInclude("unistd.h");
@cInclude("errno.h");
@cInclude("sched.h");
});
const std = @import("std");
pub fn spinUntilChange( spinPtr:*const u64, lastValue:u64) callconv(.Inline) u64 {
var newValue = lastValue;
while( newValue == lastValue ) {
std.atomic.spinLoopHint();
newValue = @atomicLoad(u64, spinPtr, std.builtin.AtomicOrder.Monotonic );
}
return newValue;
}
// pub fn SuspendHelper(comptime T:type ) type {
// return struct {
// const Self = @This();
// value: T,
// suspend_context : ?anyframe = null,
// pub fn suspendMe(self:*Self) T {
// if(self.suspend_context) |_| {
// std.debug.panic("suspend context already exists. re-enternat code. die\n",.{});
// } else {
// suspend {
// self.suspend_context = @frame(); // this is how you suspend in zig.
// }
// }
// return self.value;
// }
// pub fn resumeMe(self:*Self, value:T) void {
// if(self.suspend_context) |w| {
// self.value = value;
// const tmp = w;
// self.suspend_context = null;
// resume tmp;
// } else {
// std.debug.print("suspend : resume called w/ no frame.",.{});
// }
// }
// };
// }
const SetupError = error {
C_Func_Error
};
const SetupReturn = struct {
clientPtr : *const u64,
serverPtr : *u64,
};
pub fn doSetup() anyerror!SetupReturn {
const allocator = std.heap.c_allocator;
var args = std.process.args();
// don't care about my exe name.
_ = args.skip();
const tmp = try args.next(allocator).?;
const cpuPinNum = try std.fmt.parseInt( u6, tmp, 10 );
// std.log.err("setting cpu num to {}\n",.{cpuPinNum});
var memHandle : c_int = c.shm_open(
"/spinnmem",
c.O_RDWR,
c.S_IRUSR | c.S_IWUSR | c.S_IRGRP | c.S_IWGRP
);
if( memHandle < 0 ) {
std.log.err("can't open shm location. error code {}",.{std.os.system._errno().*});
return SetupError.C_Func_Error;
}
if( c.ftruncate(memHandle, 4096 ) < 0 ) return SetupError.C_Func_Error;
const memPtr = try std.os.mmap(
null,
4096,
c.PROT_READ | c.PROT_WRITE,
c.MAP_SHARED,
memHandle,
0
);
// zig can't parse any of the CPU_ZERO or CPU_SET macors in
// sched.h and cpu-set.h. So gotta do it by hand.
// I *think* it's just a bit mask. 1 bit for every cpu.
// but not 100% sure.
var cpuMask : c.cpu_set_t = std.mem.zeroes( c.cpu_set_t);
const cpuSetSize = @sizeOf(c.cpu_set_t);
cpuMask.__bits[0] = @as(c_ulong,1) << cpuPinNum;
if( c.sched_setaffinity(0,cpuSetSize,&cpuMask) < 0 ) {
std.log.err("can't set cpu affinity. error code {}",.{std.os.system._errno().*});
return SetupError.C_Func_Error;
}
return SetupReturn{
.clientPtr = std.mem.bytesAsValue( u64, memPtr[0..8]),
.serverPtr = std.mem.bytesAsValue( u64, memPtr[2048..(2048+8)])
};
} | zig/src/common.zig |
const CPU = @This();
const pkg = @import("zig80.zig");
const Flags = pkg.Flags;
const Interface = pkg.Interface;
const InterruptMode = pkg.InterruptMode;
/// The extra cycle counts for the main instructions
const CYCLE_COUNTS = [256]u8 {
0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 2, 0, 0, 0, 0,
1, 0, 0, 2, 0, 0, 0, 0, 5, 7, 0, 2, 0, 0, 0, 0,
0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 2, 0, 0, 0, 0,
0, 0, 0, 2, 1, 1, 0, 0, 0, 7, 0, 2, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1,
1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1,
1, 0, 0, 3, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1,
1, 0, 0, 0, 0, 1, 0, 1, 1, 2, 0, 0, 0, 0, 0, 1,
};
/// The extra cycle counts for the extended instructions
const ED_CYCLE_COUNTS = [256]u8 {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 7, 0, 0, 0, 0, 1, 0, 0, 7, 0, 0, 0, 0, 1,
0, 0, 7, 0, 0, 0, 0, 1, 0, 0, 7, 0, 0, 0, 0, 1,
0, 0, 7, 0, 0, 0, 0, 4, 0, 0, 7, 0, 0, 0, 0, 4,
0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 5, 5, 5, 0, 0, 0, 0, 2, 5, 5, 5, 0, 0, 0, 0,
2, 5, 5, 5, 0, 0, 0, 0, 2, 5, 5, 5, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
/// The extra cycle counts for the indexed instructions
const IZ_CYCLE_COUNTS = [256]u8 {
0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0,
0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 2, 0, 0, 0, 0,
0, 0, 0, 0, 6, 6, 2, 0, 0, 7, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0,
5, 5, 5, 5, 5, 5, 0, 5, 0, 0, 0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
};
/// A register pair, accessible as a single word or a pair of bytes.
const Pair = packed union {
w: u16,
b: switch (@import("builtin").cpu.arch.endian()) {
.Big => packed struct { h: u8, l: u8 },
.Little => packed struct { l: u8, h: u8 },
},
};
/// Create a word from two bytes.
inline fn word(h: u8, l: u8) u16 {
return (@as(u16, h) << 8) | l;
}
/// Get the high byte of a word.
inline fn hiByte(w: u16) u8 {
return @intCast(u8, w >> 8);
}
/// Get the low byte of a word.
inline fn loByte(w: u16) u8 {
return @truncate(u8, w);
}
interface: Interface,
af: Pair = .{ .w = 0xffff },
bc: Pair = .{ .w = 0 },
de: Pair = .{ .w = 0 },
hl: Pair = .{ .w = 0 },
pc: u16 = 0,
sp: u16 = 0,
ix: Pair = .{ .w = 0 },
iy: Pair = .{ .w = 0 },
/// internal "memptr" register
wz: u16 = 0,
af2: Pair = .{ .w = 0 },
bc2: Pair = .{ .w = 0 },
de2: Pair = .{ .w = 0 },
hl2: Pair = .{ .w = 0 },
i: u8 = 0,
r: u8 = 0,
im: InterruptMode = .Mode0,
iff1: bool = false,
iff2: bool = false,
int_delay: bool = false,
int_read: bool = false,
ld_ir: bool = false,
halted: bool = false,
index_type: enum { HL, IX, IY } = .HL,
cycles: u32 = 0,
fn readByte(self: *CPU, addr: u16) u8 {
self.addCycles(3);
return self.interface.read(addr);
}
inline fn readWord(self: *CPU, addr: u16) u16 {
const lo = self.readByte(addr);
const hi = self.readByte(addr +% 1);
return word(hi, lo);
}
fn readWordMemPtr(self: *CPU) u16 {
self.wz = self.fetchWord() +% 1;
return self.readWord(self.wz -% 1);
}
fn writeByte(self: *CPU, addr: u16, value: u8) void {
self.addCycles(3);
return self.interface.write(addr, value);
}
inline fn writeWord(self: *CPU, addr: u16, value: u16) void {
self.writeByte(addr, loByte(value));
self.writeByte(addr +% 1, hiByte(value));
}
fn writeWordMemPtr(self: *CPU, value: u16) void {
self.wz = self.fetchWord() +% 1;
self.writeWord(self.wz -% 1, value);
}
fn in(self: *CPU, port: u16) u8 {
self.addCycles(4);
return self.interface.in(port);
}
fn out(self: *CPU, port: u16, value: u8) void {
self.addCycles(4);
return self.interface.out(port, value);
}
fn fetchByte(self: *CPU) u8 {
if (self.int_read) {
return self.interface.irq();
} else {
self.pc +%= 1;
return self.readByte(self.pc -% 1);
}
}
inline fn fetchOpcode(self: *CPU) u8 {
self.addCycles(1);
return self.fetchByte();
}
inline fn fetchWord(self: *CPU) u16 {
const lo = self.fetchByte();
const hi = self.fetchByte();
return word(hi, lo);
}
fn signedByte(value: u8) u16 {
return @bitCast(u16, @as(i16, @bitCast(i8, value)));
}
inline fn izd(self: *CPU, iz: u16) u16 {
self.wz = iz +% signedByte(self.fetchByte());
return self.wz;
}
inline fn readIZD(self: *CPU, iz: u16) u8 {
return self.readByte(self.izd(iz));
}
inline fn refresh(self: *CPU) void {
self.r = ((self.r +% 1) & 0x7f) | (self.r & 0x80);
}
inline fn push(self: *CPU, value: u16) void {
self.sp -%= 2;
return self.writeWord(self.sp, value);
}
inline fn pop(self: *CPU) u16 {
self.sp +%= 2;
return self.readWord(self.sp -% 2);
}
inline fn getCarry(self: *const CPU) bool {
return @bitCast(bool, @truncate(u1, self.getF()));
}
inline fn checkFlag(self: *const CPU, flag: u8) bool {
return self.getF() & flag != 0;
}
inline fn andFlags(self: *CPU, flags: u8) void {
self.setF(self.getF() & flags);
}
inline fn orFlags(self: *CPU, flags: u8) void {
self.setF(self.getF() | flags);
}
inline fn flipFlags(self: *CPU, flags: u8) void {
self.setF(self.getF() ^ flags);
}
// register getters
pub inline fn getA(self: *const CPU) u8 { return self.af.b.h; }
pub inline fn getF(self: *const CPU) u8 { return self.af.b.l; }
pub inline fn getB(self: *const CPU) u8 { return self.bc.b.h; }
pub inline fn getC(self: *const CPU) u8 { return self.bc.b.l; }
pub inline fn getD(self: *const CPU) u8 { return self.de.b.h; }
pub inline fn getE(self: *const CPU) u8 { return self.de.b.l; }
pub inline fn getH(self: *const CPU) u8 { return self.hl.b.h; }
pub inline fn getL(self: *const CPU) u8 { return self.hl.b.l; }
// register setters
pub inline fn setA(self: *CPU, value: u8) void { self.af.b.h = value; }
pub inline fn setF(self: *CPU, value: u8) void { self.af.b.l = value; }
pub inline fn setB(self: *CPU, value: u8) void { self.bc.b.h = value; }
pub inline fn setC(self: *CPU, value: u8) void { self.bc.b.l = value; }
pub inline fn setD(self: *CPU, value: u8) void { self.de.b.h = value; }
pub inline fn setE(self: *CPU, value: u8) void { self.de.b.l = value; }
pub inline fn setH(self: *CPU, value: u8) void { self.hl.b.h = value; }
pub inline fn setL(self: *CPU, value: u8) void { self.hl.b.l = value; }
// register pair getters
pub inline fn getAF(self: *const CPU) u16 { return self.af.w; }
pub inline fn getBC(self: *const CPU) u16 { return self.bc.w; }
pub inline fn getDE(self: *const CPU) u16 { return self.de.w; }
pub inline fn getHL(self: *const CPU) u16 { return self.hl.w; }
// register pair setters
pub inline fn setAF(self: *CPU, value: u16) void { self.af.w = value; }
pub inline fn setBC(self: *CPU, value: u16) void { self.bc.w = value; }
pub inline fn setDE(self: *CPU, value: u16) void { self.de.w = value; }
pub inline fn setHL(self: *CPU, value: u16) void { self.hl.w = value; }
// register pair increment
pub inline fn incAF(self: *CPU) void { self.af.w +%= 1; }
pub inline fn incBC(self: *CPU) void { self.bc.w +%= 1; }
pub inline fn incDE(self: *CPU) void { self.de.w +%= 1; }
pub inline fn incHL(self: *CPU) void { self.hl.w +%= 1; }
// regiser pair decrement
pub inline fn decAF(self: *CPU) void { self.af.w -%= 1; }
pub inline fn decBC(self: *CPU) void { self.bc.w -%= 1; }
pub inline fn decDE(self: *CPU) void { self.de.w -%= 1; }
pub inline fn decHL(self: *CPU) void { self.hl.w -%= 1; }
inline fn addCycles(self: *CPU, amount: u32) void {
self.cycles +%= amount;
}
fn readAWithMemPtr(self: *CPU, addr: u16) void {
self.setA(self.readByte(addr));
self.wz = addr +% 1;
}
fn writeAWithMemPtr(self: *CPU, addr: u16) void {
self.writeByte(addr, self.getA());
self.wz = word(self.getA(), loByte(addr) +% 1);
}
inline fn readPairWithMemPtr(self: *CPU) u16 {
self.wz = self.fetchWord() +% 1;
return self.readWord(self.wz -% 1);
}
inline fn writePairWithMemPtr(self: *CPU, pair: u16) void {
self.wz = self.fetchWord() +% 1;
return self.writeWord(self.wz -% 1, pair);
}
fn readHL(self: *CPU) u8 {
return self.readByte(self.getHL());
}
fn writeHL(self: *CPU, value: u8) void {
self.writeByte(self.getHL(), value);
}
fn addBytes(self: *CPU, v1: u8, v2: u8, carry: bool) u8 {
const long = @as(u16, v1) + v2 + @boolToInt(carry);
const result = loByte(long);
const carry_flag = hiByte(long);
const carry_mask = v1 ^ v2 ^ result;
self.setF(0);
self.orFlags(result & (Flags.S | Flags.X | Flags.Y)); // sign and undoc
if (result == 0) self.orFlags(Flags.Z); // zero
self.orFlags(carry_mask & Flags.H); // half-carry
self.orFlags(((carry_mask >> 7) ^ carry_flag) << 2); // overflow
self.orFlags(carry_flag); // carry
return result;
}
fn subBytes(self: *CPU, v1: u8, v2: u8, carry: bool) u8 {
const result = self.addBytes(v1, ~v2, !carry);
self.flipFlags(Flags.C | Flags.H | Flags.N);
return result;
}
fn addWords(self: *CPU, v1: u16, v2: u16, carry: bool) u16 {
const lo = self.addBytes(loByte(v1), loByte(v2), carry);
const hi = self.addBytes(hiByte(v1), hiByte(v2), self.getCarry());
const result = word(hi, lo);
self.andFlags(~Flags.Z);
if (result == 0) self.orFlags(Flags.Z);
self.wz = v1 +% 1;
return result;
}
fn subWords(self: *CPU, v1: u16, v2: u16, carry: bool) u16 {
const lo = self.subBytes(loByte(v1), loByte(v2), carry);
const hi = self.subBytes(hiByte(v1), hiByte(v2), self.getCarry());
const result = word(hi, lo);
self.andFlags(~Flags.Z);
if (result == 0) self.orFlags(Flags.Z);
self.wz = v1 +% 1;
return result;
}
fn addA(self: *CPU, value: u8) void {
self.setA(self.addBytes(self.getA(), value, false));
}
fn adcA(self: *CPU, value: u8) void {
self.setA(self.addBytes(self.getA(), value, self.getCarry()));
}
fn subA(self: *CPU, value: u8) void {
self.setA(self.subBytes(self.getA(), value, false));
}
fn sbcA(self: *CPU, value: u8) void {
self.setA(self.subBytes(self.getA(), value, self.getCarry()));
}
fn addHL(self: *CPU, value: u16) void {
const unaffected_flags = self.getF() & (Flags.S | Flags.Z | Flags.PV);
self.setHL(self.addWords(self.getHL(), value, false));
self.andFlags(~(Flags.S | Flags.Z | Flags.PV));
self.orFlags(unaffected_flags);
}
fn adcHL(self: *CPU, value: u16) void {
self.setHL(self.addWords(self.getHL(), value, self.getCarry()));
}
fn sbcHL(self: *CPU, value: u16) void {
self.setHL(self.subWords(self.getHL(), value, self.getCarry()));
}
fn addIZ(self: *CPU, iz: *Pair, value: u16) void {
const unaffected_flags = self.getF() & (Flags.S | Flags.Z | Flags.PV);
iz.w = self.addWords(iz.w, value, false);
self.andFlags(~(Flags.S | Flags.Z | Flags.PV));
self.orFlags(unaffected_flags);
}
fn parityCheck(value: u8) bool {
var result: u1 = 1;
var i: u8 = 0;
var v = value;
while (i < 8) : (i += 1) {
result ^= @truncate(u1, v);
v >>= 1;
}
return @bitCast(bool, result);
}
fn bitwiseFlags(self: *CPU, value: u8) void {
// sign and undoc flags
self.orFlags(value & (Flags.S | Flags.X | Flags.Y));
// zero flag
if (value == 0) self.orFlags(Flags.Z);
// parity flag
if (parityCheck(value)) self.orFlags(Flags.PV);
}
fn andA(self: *CPU, value: u8) void {
self.setA(self.getA() & value);
self.setF(Flags.H);
self.bitwiseFlags(self.getA());
}
fn orA(self: *CPU, value: u8) void {
self.setA(self.getA() | value);
self.setF(0);
self.bitwiseFlags(self.getA());
}
fn xor(self: *CPU, value: u8) void {
self.setA(self.getA() ^ value);
self.setF(0);
self.bitwiseFlags(self.getA());
}
fn cp(self: *CPU, value: u8) void {
_ = self.subBytes(self.getA(), value, false);
// xy flags take from operand instead of result
self.andFlags(~(Flags.X | Flags.Y));
self.orFlags(value & (Flags.X | Flags.Y));
}
fn inc(self: *CPU, value: u8) u8 {
const carry = self.getF() & Flags.C;
const result = self.addBytes(value, 1, false);
// carry is not affected
self.andFlags(~Flags.C);
self.orFlags(carry);
return result;
}
fn incMem(self: *CPU, addr: u16) void {
self.writeByte(addr, self.inc(self.readByte(addr)));
}
fn dec(self: *CPU, value: u8) u8 {
const carry = self.getF() & Flags.C;
const result = self.subBytes(value, 1, false);
// carry is not affected
self.andFlags(~Flags.C);
self.orFlags(carry);
return result;
}
fn decMem(self: *CPU, addr: u16) void {
self.writeByte(addr, self.dec(self.readByte(addr)));
}
fn daa(self: *CPU) void {
var diff: u8 = 0;
if (self.checkFlag(Flags.H) or self.getA() & 0x0f > 0x09) {
diff += 0x06;
}
if (self.checkFlag(Flags.C) or self.getA() > 0x99) {
self.orFlags(Flags.C);
diff += 0x60;
}
if (self.checkFlag(Flags.N)) {
if (self.getA() & 0x0f > 0x05) self.andFlags(~Flags.H);
self.setA(self.getA() -% diff);
} else {
if (self.getA() & 0x0f > 0x09) {
self.orFlags(Flags.H);
} else {
self.andFlags(~Flags.H);
}
self.setA(self.getA() +% diff);
}
self.andFlags(~(Flags.PV | Flags.S | Flags.X | Flags.Y | Flags.Z));
self.bitwiseFlags(self.getA());
}
fn cpl(self: *CPU) void {
self.setA(~self.getA());
self.andFlags(~(Flags.X | Flags.Y));
self.orFlags(Flags.H | Flags.N | (self.getA() & (Flags.X | Flags.Y)));
}
fn neg(self: *CPU) void {
self.setA(self.subBytes(0, self.getA(), false));
}
fn ccf(self: *CPU) void {
self.andFlags(~(Flags.H | Flags.N | Flags.X | Flags.Y));
if (self.checkFlag(Flags.C)) self.orFlags(Flags.H);
self.flipFlags(Flags.C);
self.orFlags(self.getA() & (Flags.X | Flags.Y));
}
fn scf(self: *CPU) void {
self.andFlags(~(Flags.H | Flags.N | Flags.X | Flags.Y));
self.orFlags(Flags.C | (self.getA() & (Flags.X | Flags.Y)));
}
fn rlca(self: *CPU) void {
self.andFlags(Flags.S | Flags.Z | Flags.PV | Flags.C);
self.rlc(&self.af.b.h);
self.orFlags(self.getA() & (Flags.X | Flags.Y));
}
fn rla(self: *CPU) void {
self.andFlags(Flags.S | Flags.Z | Flags.PV | Flags.C);
self.rl(&self.af.b.h);
self.orFlags(self.getA() & (Flags.X | Flags.Y));
}
fn rrca(self: *CPU) void {
self.andFlags(Flags.S | Flags.Z | Flags.PV | Flags.C);
self.rrc(&self.af.b.h);
self.orFlags(self.getA() & (Flags.X | Flags.Y));
}
fn rra(self: *CPU) void {
self.andFlags(Flags.S | Flags.Z | Flags.PV | Flags.C);
self.rr(&self.af.b.h);
self.orFlags(self.getA() & (Flags.X | Flags.Y));
}
fn rlc(self: *CPU, reg: *u8) void {
reg.* = (reg.* << 1) | (reg.* >> 7);
self.andFlags(~Flags.C);
self.orFlags(reg.* & Flags.C);
}
fn rrc(self: *CPU, reg: *u8) void {
self.andFlags(~Flags.C);
self.orFlags(reg.* & Flags.C);
reg.* = (reg.* >> 1) | (reg.* << 7);
}
fn rl(self: *CPU, reg: *u8) void {
const new_carry = reg.* >> 7;
reg.* = (reg.* << 1) | (self.getF() & Flags.C);
self.andFlags(~Flags.C);
self.orFlags(new_carry);
}
fn rr(self: *CPU, reg: *u8) void {
const new_carry = reg.* & Flags.C;
reg.* = (reg.* >> 1) | (self.getF() << 7);
self.andFlags(~Flags.C);
self.orFlags(new_carry);
}
fn sla(self: *CPU, reg: *u8) void {
self.setF(reg.* >> 7);
reg.* <<= 1;
}
fn sra(self: *CPU, reg: *u8) void {
self.setF(reg.* & Flags.C);
reg.* = (reg.* >> 1) | (reg.* & 0x80);
}
fn sll(self: *CPU, reg: *u8) void {
self.setF(reg.* >> 7);
reg.* = (reg.* << 1) | 1;
}
fn srl(self: *CPU, reg: *u8) void {
self.setF(reg.* & Flags.C);
reg.* >>= 1;
}
fn jump(self: *CPU, addr: u16) void {
self.pc = addr;
self.wz = addr;
}
inline fn jumpIf(self: *CPU, condition: bool) void {
self.wz = self.fetchWord();
if (condition) self.pc = self.wz;
}
fn relJump(self: *CPU, relative: u8) void {
self.pc +%= signedByte(relative);
self.wz = self.pc;
}
inline fn relJumpIf(self: *CPU, condition: bool) void {
const dest = self.fetchByte();
if (condition) {
self.relJump(dest);
self.addCycles(5);
}
}
fn djnz(self: *CPU) void {
self.setB(self.getB() -% 1);
self.relJumpIf(self.getB() != 0);
}
fn call(self: *CPU, addr: u16) void {
self.push(self.pc);
self.pc = addr;
self.wz = addr;
}
inline fn callIf(self: *CPU, condition: bool) void {
self.wz = self.fetchWord();
if (condition) {
self.push(self.pc);
self.pc = self.wz;
self.addCycles(1);
}
}
fn ret(self: *CPU) void {
self.pc = self.pop();
self.wz = self.pc;
}
inline fn retIf(self: *CPU, condition: bool) void {
if (condition) {
self.ret();
}
}
fn inFromC(self: *CPU) u8 {
const value = self.in(self.getBC());
self.andFlags(Flags.C);
self.bitwiseFlags(value);
return value;
}
fn outToC(self: *CPU, value: u8) void {
self.out(self.getBC(), value);
}
fn di(self: *CPU) void {
self.iff1 = false;
self.iff2 = false;
}
fn ei(self: *CPU) void {
self.iff1 = true;
self.iff2 = true;
self.int_delay = true;
}
inline fn swap(p1: *Pair, p2: *Pair) void {
const temp = p1.*;
p1.* = p2.*;
p2.* = temp;
}
fn exx(self: *CPU) void {
swap(&self.bc, &self.bc2);
swap(&self.de, &self.de2);
swap(&self.hl, &self.hl2);
}
fn exSP(self: *CPU, p: *Pair) void {
self.wz = self.readWord(self.sp);
self.writeWord(self.sp, p.w);
p.w = self.wz;
}
fn transferFlags(self: *CPU, value: u8) void {
self.orFlags((value & Flags.X) | ((value << 4) & Flags.Y));
if (self.getBC() != 0) self.orFlags(Flags.PV);
}
fn loadBlockByte(self: *CPU) void {
const value = self.readHL();
self.writeByte(self.getDE(), value);
self.decBC();
const sum = value +% self.getA();
self.andFlags(Flags.S | Flags.Z | Flags.C);
self.transferFlags(sum);
}
fn repeatBlockTransfer(self: *CPU) void {
if (self.getBC() != 0) {
self.pc -%= 2;
self.addCycles(5);
self.wz = self.pc +% 1;
}
}
fn ldi(self: *CPU) void {
self.loadBlockByte();
self.incDE();
self.incHL();
}
fn ldir(self: *CPU) void {
self.ldi();
self.repeatBlockTransfer();
}
fn ldd(self: *CPU) void {
self.loadBlockByte();
self.decDE();
self.decHL();
}
fn lddr(self: *CPU) void {
self.ldd();
self.repeatBlockTransfer();
}
fn compareBlockByte(self: *CPU) void {
const carry = self.getF() & Flags.C;
const result = self.subBytes(self.getA(), self.readHL(), false);
self.decBC();
self.andFlags(~(Flags.X | Flags.Y | Flags.PV | Flags.C));
self.transferFlags(result -% @boolToInt(self.checkFlag(Flags.H)));
self.orFlags(carry);
}
fn repeatBlockCompare(self: *CPU) void {
if (self.getBC() != 0 and !self.checkFlag(Flags.Z)) {
self.pc -%= 2;
self.addCycles(5);
self.wz = self.pc +% 1;
} else {
self.wz +%= 1;
}
}
fn cpi(self: *CPU) void {
self.compareBlockByte();
self.incHL();
self.wz +%= 1;
}
fn cpir(self: *CPU) void {
self.cpi();
self.repeatBlockCompare();
}
fn cpd(self: *CPU) void {
self.compareBlockByte();
self.decHL();
self.wz -%= 1;
}
fn cpdr(self: *CPU) void {
self.cpd();
self.repeatBlockCompare();
}
fn ioBlockByte(self: *CPU, value: u8, reg: u8) void {
self.setB(self.getB() -% 1);
self.setF(self.getB() & (Flags.S | Flags.X | Flags.Y));
if (self.getB() == 0) self.orFlags(Flags.Z);
if (value & 0x80 != 0) self.orFlags(Flags.N);
const k = @as(u16, value) + reg;
if (k > 255) self.orFlags(Flags.C | Flags.H);
if (parityCheck(@truncate(u3, k) ^ self.getB())) {
self.orFlags(Flags.PV);
}
}
fn inBlockByte(self: *CPU) u8 {
const value = self.in(word(self.getB() -% 1, self.getC()));
self.writeHL(value);
return value;
}
fn ini(self: *CPU) void {
const value = self.inBlockByte();
self.incHL();
self.wz = self.getBC() +% 1;
self.ioBlockByte(value, self.getC() +% 1);
}
fn inir(self: *CPU) void {
self.ini();
self.repeatBlockTransfer();
}
fn ind(self: *CPU) void {
const value = self.inBlockByte();
self.decHL();
self.wz = self.getBC() -% 1;
self.ioBlockByte(value, self.getC() -% 1);
}
fn indr(self: *CPU) void {
self.ind();
self.repeatBlockTransfer();
}
fn outBlockByte(self: *CPU) u8 {
const value = self.readHL();
self.outToC(value);
return value;
}
fn outi(self: *CPU) void {
const value = self.outBlockByte();
self.incHL();
self.ioBlockByte(value, self.getL());
self.wz = self.getBC() +% 1;
}
fn otir(self: *CPU) void {
self.outi();
self.repeatBlockTransfer();
}
fn outd(self: *CPU) void {
const value = self.outBlockByte();
self.decHL();
self.ioBlockByte(value, self.getL());
self.wz = self.getBC() -% 1;
}
fn otdr(self: *CPU) void {
self.outd();
self.repeatBlockTransfer();
}
fn rld(self: *CPU) void {
const value = self.readHL();
self.writeHL((value << 4) | (self.getA() & 0x0f));
self.setA((self.getA() & 0xf0) | (value >> 4));
self.andFlags(Flags.C);
self.bitwiseFlags(self.getA());
self.wz = self.getHL() +% 1;
}
fn rrd(self: *CPU) void {
const value = self.readHL();
self.writeHL((self.getA() << 4) | (value >> 4));
self.setA((self.getA() & 0xf0) | (value & 0x0f));
self.andFlags(Flags.C);
self.bitwiseFlags(self.getA());
self.wz = self.getHL() +% 1;
}
fn reti(self: *CPU) void {
self.retn();
self.interface.reti();
}
fn retn(self: *CPU) void {
self.iff1 = self.iff2;
self.ret();
}
fn inA(self: *CPU, port: u8) void {
self.wz = (self.getAF() & 0xff00) +% port +% 1;
self.setA(self.in(word(self.getA(), port)));
}
fn inAFromC(self: *CPU) void {
self.setA(self.inFromC());
self.wz = self.getBC() +% 1;
}
fn outA(self: *CPU, port: u8) void {
self.wz = word(self.getA(), port +% 1);
self.out(word(self.getA(), port), self.getA());
}
fn outAToC(self: *CPU) void {
self.outToC(self.getA());
self.wz = self.getBC() +% 1;
}
fn setAToIR(self: *CPU, value: u8) void {
self.setA(value);
self.andFlags(Flags.C);
if (self.getA() == 0) self.orFlags(Flags.Z);
if (self.iff2) self.orFlags(Flags.PV);
self.orFlags(self.getA() & (Flags.S | Flags.X | Flags.Y));
self.ld_ir = true;
}
inline fn irBug(self: *CPU) void {
if (self.ld_ir) self.andFlags(~Flags.PV);
}
inline fn unhalt(self: *CPU) void {
self.halted = false;
}
/// Step the processor.
pub fn step(self: *CPU) void {
self.ld_ir = false;
switch (self.index_type) {
.HL => if (self.halted) {
self.addCycles(4);
self.main(0);
} else {
self.main(self.fetchOpcode());
},
.IX => {
self.index_type = .HL;
self.indexed(&self.ix);
},
.IY => {
self.index_type = .HL;
self.indexed(&self.iy);
},
}
if (self.index_type == .HL) {
// instruction is over, stop reading instruction bytes from data bus if we are for im 0
self.int_read = false;
} else {
// cannot execute an interrupt in the middle of an iz-prefixed instruction
self.int_delay = true;
}
}
// main opcodes (non-prefixed)
fn main(self: *CPU, opcode: u8) void {
self.refresh();
self.addCycles(CYCLE_COUNTS[opcode]);
// we can take interrupts after this execution
self.int_delay = false;
// perform opcode operation
switch (opcode) {
// 8-bit load group
0x7f => self.setA(self.getA()), // ld a,a
0x47 => self.setB(self.getA()), // ld b,a
0x4f => self.setC(self.getA()), // ld c,a
0x57 => self.setD(self.getA()), // ld d,a
0x5f => self.setE(self.getA()), // ld e,a
0x67 => self.setH(self.getA()), // ld h,a
0x6f => self.setL(self.getA()), // ld l,a
0x78 => self.setA(self.getB()), // ld a,b
0x40 => self.setB(self.getB()), // ld b,b
0x48 => self.setC(self.getB()), // ld c,b
0x50 => self.setD(self.getB()), // ld d,b
0x58 => self.setE(self.getB()), // ld e,b
0x60 => self.setH(self.getB()), // ld h,b
0x68 => self.setL(self.getB()), // ld l,b
0x79 => self.setA(self.getC()), // ld a,c
0x41 => self.setB(self.getC()), // ld b,c
0x49 => self.setC(self.getC()), // ld c,c
0x51 => self.setD(self.getC()), // ld d,c
0x59 => self.setE(self.getC()), // ld e,c
0x61 => self.setH(self.getC()), // ld h,c
0x69 => self.setL(self.getC()), // ld l,c
0x7a => self.setA(self.getD()), // ld a,d
0x42 => self.setB(self.getD()), // ld b,d
0x4a => self.setC(self.getD()), // ld c,d
0x52 => self.setD(self.getD()), // ld d,d
0x5a => self.setE(self.getD()), // ld e,d
0x62 => self.setH(self.getD()), // ld h,d
0x6a => self.setL(self.getD()), // ld l,d
0x7b => self.setA(self.getE()), // ld a,e
0x43 => self.setB(self.getE()), // ld b,e
0x4b => self.setC(self.getE()), // ld c,e
0x53 => self.setD(self.getE()), // ld d,e
0x5b => self.setE(self.getE()), // ld e,e
0x63 => self.setH(self.getE()), // ld h,e
0x6b => self.setL(self.getE()), // ld l,e
0x7c => self.setA(self.getH()), // ld a,h
0x44 => self.setB(self.getH()), // ld b,h
0x4c => self.setC(self.getH()), // ld c,h
0x54 => self.setD(self.getH()), // ld d,h
0x5c => self.setE(self.getH()), // ld e,h
0x64 => self.setH(self.getH()), // ld h,h
0x6c => self.setL(self.getH()), // ld l,h
0x7d => self.setA(self.getL()), // ld a,l
0x45 => self.setB(self.getL()), // ld b,l
0x4d => self.setC(self.getL()), // ld c,l
0x55 => self.setD(self.getL()), // ld d,l
0x5d => self.setE(self.getL()), // ld e,l
0x65 => self.setH(self.getL()), // ld h,l
0x6d => self.setL(self.getL()), // ld l,l
0x3e => self.setA(self.fetchByte()), // ld a,*
0x06 => self.setB(self.fetchByte()), // ld b,*
0x0e => self.setC(self.fetchByte()), // ld c,*
0x16 => self.setD(self.fetchByte()), // ld d,*
0x1e => self.setE(self.fetchByte()), // ld e,*
0x26 => self.setH(self.fetchByte()), // ld h,*
0x2e => self.setL(self.fetchByte()), // ld l,*
0x7e => self.setA(self.readHL()), // ld a,(hl)
0x46 => self.setB(self.readHL()), // ld b,(hl)
0x4e => self.setC(self.readHL()), // ld c,(hl)
0x56 => self.setD(self.readHL()), // ld d,(hl)
0x5e => self.setE(self.readHL()), // ld e,(hl)
0x66 => self.setH(self.readHL()), // ld h,(hl)
0x6e => self.setL(self.readHL()), // ld l,(hl)
0x77 => self.writeHL(self.getA()), // ld (hl),a
0x70 => self.writeHL(self.getB()), // ld (hl),b
0x71 => self.writeHL(self.getC()), // ld (hl),c
0x72 => self.writeHL(self.getD()), // ld (hl),d
0x73 => self.writeHL(self.getE()), // ld (hl),e
0x74 => self.writeHL(self.getH()), // ld (hl),h
0x75 => self.writeHL(self.getL()), // ld (hl),l
0x36 => self.writeHL(self.fetchByte()), // ld (hl),*
0x0a => self.readAWithMemPtr(self.getBC()), // ld a,(bc)
0x1a => self.readAWithMemPtr(self.getDE()), // ld a,(de)
0x3a => self.readAWithMemPtr(self.fetchWord()), // ld a,(**)
0x02 => self.writeAWithMemPtr(self.getBC()), // ld (bc),a
0x12 => self.writeAWithMemPtr(self.getDE()), // ld (de),a
0x32 => self.writeAWithMemPtr(self.fetchWord()), // ld (**),a
// 16-bit load group
0x01 => self.setBC(self.fetchWord()), // ld bc,**
0x11 => self.setDE(self.fetchWord()), // ld de,**
0x21 => self.setHL(self.fetchWord()), // ld hl,**
0x31 => self.sp = self.fetchWord(), // ld sp,**
0x2a => self.setHL(self.readPairWithMemPtr()), // ld hl,(**)
0x22 => self.writePairWithMemPtr(self.getHL()), // ld (**),hl
0xf9 => self.sp = self.getHL(), // ld sp,hl
0xf5 => self.push(self.getAF()), // push af
0xc5 => self.push(self.getBC()), // push bc
0xd5 => self.push(self.getDE()), // push de
0xe5 => self.push(self.getHL()), // push hl
0xf1 => self.setAF(self.pop()), // pop af
0xc1 => self.setBC(self.pop()), // pop bc
0xd1 => self.setDE(self.pop()), // pop de
0xe1 => self.setHL(self.pop()), // pop hl
// exchange, block transfer, and search group
0xeb => swap(&self.de, &self.hl), // ex de,hl
0x08 => swap(&self.af, &self.af2), // ex af,af'
0xd9 => self.exx(), // exx
0xe3 => self.exSP(&self.hl), // ex (sp),hl
// 8-bit arithmetic group
0x87 => self.addA(self.getA()), // add a,a
0x80 => self.addA(self.getB()), // add a,b
0x81 => self.addA(self.getC()), // add a,c
0x82 => self.addA(self.getD()), // add a,d
0x83 => self.addA(self.getE()), // add a,e
0x84 => self.addA(self.getH()), // add a,h
0x85 => self.addA(self.getL()), // add a,l
0xc6 => self.addA(self.fetchByte()), // add a,*
0x86 => self.addA(self.readHL()), // add a,(hl)
0x8f => self.adcA(self.getA()), // adc a,a
0x88 => self.adcA(self.getB()), // adc a,b
0x89 => self.adcA(self.getC()), // adc a,c
0x8a => self.adcA(self.getD()), // adc a,d
0x8b => self.adcA(self.getE()), // adc a,e
0x8c => self.adcA(self.getH()), // adc a,h
0x8d => self.adcA(self.getL()), // adc a,l
0xce => self.adcA(self.fetchByte()), // adc a,*
0x8e => self.adcA(self.readHL()), // adc a,(hl)
0x97 => self.subA(self.getA()), // sub a
0x90 => self.subA(self.getB()), // sub b
0x91 => self.subA(self.getC()), // sub c
0x92 => self.subA(self.getD()), // sub d
0x93 => self.subA(self.getE()), // sub e
0x94 => self.subA(self.getH()), // sub h
0x95 => self.subA(self.getL()), // sub l
0xd6 => self.subA(self.fetchByte()), // sub *
0x96 => self.subA(self.readHL()), // sub (hl)
0x9f => self.sbcA(self.getA()), // sbc a,a
0x98 => self.sbcA(self.getB()), // sbc a,b
0x99 => self.sbcA(self.getC()), // sbc a,c
0x9a => self.sbcA(self.getD()), // sbc a,d
0x9b => self.sbcA(self.getE()), // sbc a,e
0x9c => self.sbcA(self.getH()), // sbc a,h
0x9d => self.sbcA(self.getL()), // sbc a,l
0xde => self.sbcA(self.fetchByte()), // sbc a,*
0x9e => self.sbcA(self.readHL()), // sbc a,(hl)
0xa7 => self.andA(self.getA()), // and a
0xa0 => self.andA(self.getB()), // and b
0xa1 => self.andA(self.getC()), // and c
0xa2 => self.andA(self.getD()), // and d
0xa3 => self.andA(self.getE()), // and e
0xa4 => self.andA(self.getH()), // and h
0xa5 => self.andA(self.getL()), // and l
0xe6 => self.andA(self.fetchByte()), // and *
0xa6 => self.andA(self.readHL()), // and (hl)
0xb7 => self.orA(self.getA()), // or a
0xb0 => self.orA(self.getB()), // or b
0xb1 => self.orA(self.getC()), // or c
0xb2 => self.orA(self.getD()), // or d
0xb3 => self.orA(self.getE()), // or e
0xb4 => self.orA(self.getH()), // or h
0xb5 => self.orA(self.getL()), // or l
0xf6 => self.orA(self.fetchByte()), // or *
0xb6 => self.orA(self.readHL()), // or (hl)
0xaf => self.xor(self.getA()), // xor a
0xa8 => self.xor(self.getB()), // xor b
0xa9 => self.xor(self.getC()), // xor c
0xaa => self.xor(self.getD()), // xor d
0xab => self.xor(self.getE()), // xor e
0xac => self.xor(self.getH()), // xor h
0xad => self.xor(self.getL()), // xor l
0xee => self.xor(self.fetchByte()), // xor *
0xae => self.xor(self.readHL()), // xor (hl)
0xbf => self.cp(self.getA()), // cp a
0xb8 => self.cp(self.getB()), // cp b
0xb9 => self.cp(self.getC()), // cp c
0xba => self.cp(self.getD()), // cp d
0xbb => self.cp(self.getE()), // cp e
0xbc => self.cp(self.getH()), // cp h
0xbd => self.cp(self.getL()), // cp l
0xfe => self.cp(self.fetchByte()), // cp *
0xbe => self.cp(self.readHL()), // cp (hl)
0x3c => self.setA(self.inc(self.getA())), // inc a
0x04 => self.setB(self.inc(self.getB())), // inc b
0x0c => self.setC(self.inc(self.getC())), // inc c
0x14 => self.setD(self.inc(self.getD())), // inc d
0x1c => self.setE(self.inc(self.getE())), // inc e
0x24 => self.setH(self.inc(self.getH())), // inc h
0x2c => self.setL(self.inc(self.getL())), // inc l
0x34 => self.incMem(self.getHL()), // inc (hl)
0x3d => self.setA(self.dec(self.getA())), // dec a
0x05 => self.setB(self.dec(self.getB())), // dec b
0x0d => self.setC(self.dec(self.getC())), // dec c
0x15 => self.setD(self.dec(self.getD())), // dec d
0x1d => self.setE(self.dec(self.getE())), // dec e
0x25 => self.setH(self.dec(self.getH())), // dec h
0x2d => self.setL(self.dec(self.getL())), // dec l
0x35 => self.decMem(self.getHL()), // dec (hl)
// general-purpose arithmetic and cpu control groups
0x27 => self.daa(), // daa
0x2f => self.cpl(), // cpl
0x3f => self.ccf(), // ccf
0x37 => self.scf(), // scf
0x00 => {}, // nop
0x76 => self.halted = true, // halt
0xf3 => self.di(), // di
0xfb => self.ei(), // ei
// 16-bit arithmetic group
0x09 => self.addHL(self.getBC()), // add hl,bc
0x19 => self.addHL(self.getDE()), // add hl,de
0x29 => self.addHL(self.getHL()), // add hl,hl
0x39 => self.addHL(self.sp), // add hl,sp
0x03 => self.incBC(), // inc bc
0x13 => self.incDE(), // inc de
0x23 => self.incHL(), // inc hl
0x33 => self.sp +%= 1, // inc sp
0x0b => self.decBC(), // dec bc
0x1b => self.decDE(), // dec de
0x2b => self.decHL(), // dec hl
0x3b => self.sp -%= 1, // dec sp
// rotate and shift group
0x07 => self.rlca(), // rlca
0x17 => self.rla(), // rla
0x0f => self.rrca(), // rrca
0x1f => self.rra(), // rra
// jump group
0xc3 => self.jump(self.fetchWord()), // jp **
0xc2 => self.jumpIf(!self.checkFlag(Flags.Z)), // jp nz,**
0xca => self.jumpIf(self.checkFlag(Flags.Z)), // jp z,**
0xd2 => self.jumpIf(!self.checkFlag(Flags.C)), // jp nc,**
0xda => self.jumpIf(self.checkFlag(Flags.C)), // jp c,**
0xe2 => self.jumpIf(!self.checkFlag(Flags.PV)), // jp po,**
0xea => self.jumpIf(self.checkFlag(Flags.PV)), // jp pe,**
0xf2 => self.jumpIf(!self.checkFlag(Flags.S)), // jp p,**
0xfa => self.jumpIf(self.checkFlag(Flags.S)), // jp m,**
0x18 => self.relJump(self.fetchByte()), // jr
0x20 => self.relJumpIf(!self.checkFlag(Flags.Z)), // jr nz,*
0x28 => self.relJumpIf(self.checkFlag(Flags.Z)), // jr z,*
0x30 => self.relJumpIf(!self.checkFlag(Flags.C)), // jr nc,*
0x38 => self.relJumpIf(self.checkFlag(Flags.C)), // jr c,*
0xe9 => self.pc = self.getHL(), // jp (hl)
0x10 => self.djnz(), // djnz e
// call and return group
0xcd => self.call(self.fetchWord()), // call **
0xc4 => self.callIf(!self.checkFlag(Flags.Z)), // call nz,**
0xcc => self.callIf(self.checkFlag(Flags.Z)), // call z,**
0xd4 => self.callIf(!self.checkFlag(Flags.C)), // call nc,**
0xdc => self.callIf(self.checkFlag(Flags.C)), // call c,**
0xe4 => self.callIf(!self.checkFlag(Flags.PV)), // call po,**
0xec => self.callIf(self.checkFlag(Flags.PV)), // call pe,**
0xf4 => self.callIf(!self.checkFlag(Flags.S)), // call p,**
0xfc => self.callIf(self.checkFlag(Flags.S)), // call m,**
0xc9 => self.ret(), // ret
0xc0 => self.retIf(!self.checkFlag(Flags.Z)), // ret nz
0xc8 => self.retIf(self.checkFlag(Flags.Z)), // ret z
0xd0 => self.retIf(!self.checkFlag(Flags.C)), // ret nc
0xd8 => self.retIf(self.checkFlag(Flags.C)), // ret c
0xe0 => self.retIf(!self.checkFlag(Flags.PV)), // ret po
0xe8 => self.retIf(self.checkFlag(Flags.PV)), // ret pe
0xf0 => self.retIf(!self.checkFlag(Flags.S)), // ret p
0xf8 => self.retIf(self.checkFlag(Flags.S)), // ret m
0xc7 => self.call(0x00), // rst 00h
0xcf => self.call(0x08), // rst 08h
0xd7 => self.call(0x10), // rst 10h
0xdf => self.call(0x18), // rst 18h
0xe7 => self.call(0x20), // rst 20h
0xef => self.call(0x28), // rst 28h
0xf7 => self.call(0x30), // rst 30h
0xff => self.call(0x38), // rst 38h
// input and output group
0xdb => self.inA(self.fetchByte()), // in a,(*)
0xd3 => self.outA(self.fetchByte()), // out (*),a
// bit instructions
0xcb => self.bits(self.getHL(), false),
// ix instructions
0xdd => self.index_type = .IX,
// extended instructions
0xed => self.extended(),
// iy instructions
0xfd => self.index_type = .IY,
}
}
/// bit opcodes (cb prefixed)
fn bits(self: *CPU, address: u16, comptime is_indexed: bool) void {
// fetch and refresh
const opcode = self.fetchOpcode();
self.refresh();
// opcode parameters
const operand = @truncate(u3, opcode);
const bit_index = @truncate(u3, opcode >> 3);
const group = @intCast(u2, opcode >> 6);
const bitmask = @as(u8, 1) << bit_index;
// get register pointer (memory values use local variable)
// based on implementation in https://github.com/superzazu/z80
var mem: u8 = undefined;
const reg = switch (operand) {
0 => &self.bc.b.h, 1 => &self.bc.b.l,
2 => &self.de.b.h, 3 => &self.de.b.l,
4 => &self.hl.b.h, 5 => &self.hl.b.l,
6 => &mem, 7 => &self.af.b.h,
};
if (is_indexed or reg == &mem) {
// in indexed mode, data is always read from (iz+*), even if a register is specified.
// this will overwrite the register value.
// in non-indexed mode, data is only read when the operand is (hl).
reg.* = self.readByte(address);
}
// select operation from group
switch (group) {
// shift/rotate
0 => {
self.andFlags(Flags.C);
switch (bit_index) {
0 => self.rlc(reg),
1 => self.rrc(reg),
2 => self.rl(reg),
3 => self.rr(reg),
4 => self.sla(reg),
5 => self.sra(reg),
6 => self.sll(reg),
7 => self.srl(reg),
}
self.bitwiseFlags(reg.*);
},
// bit
1 => {
const result = reg.* & bitmask;
self.andFlags(Flags.C);
self.orFlags(Flags.H | (result & Flags.S) | (reg.* & (Flags.X | Flags.Y)));
if (result == 0) self.orFlags(Flags.Z | Flags.PV);
if (is_indexed) reg.* = result;
},
2 => reg.* &= ~bitmask, // res
3 => reg.* |= bitmask, // set
}
if (is_indexed) {
self.addCycles(2);
} else if (reg == &mem) {
self.addCycles(1);
} else {
return;
}
if (group == 1) {
// if bit operation, override xy flags with high byte of memptr
self.andFlags(~(Flags.X | Flags.Y));
self.orFlags(hiByte(self.wz) & (Flags.X | Flags.Y));
} else {
// otherwise, write memory
self.writeByte(address, reg.*);
}
}
/// indexed opcodes (ix or iy)
fn indexed(self: *CPU, iz: *Pair) void {
const opcode = self.fetchOpcode();
const old_r = self.r;
self.refresh();
self.addCycles(IZ_CYCLE_COUNTS[opcode]);
switch (opcode) {
// 8-bit load group
0x67 => iz.b.h = self.getA(), // ld izh,a
0x6f => iz.b.l = self.getA(), // ld izl,a
0x60 => iz.b.h = self.getB(), // ld izh,b
0x68 => iz.b.l = self.getB(), // ld izl,b
0x61 => iz.b.h = self.getC(), // ld izh,c
0x69 => iz.b.l = self.getC(), // ld izl,c
0x62 => iz.b.h = self.getD(), // ld izh,d
0x6a => iz.b.l = self.getD(), // ld izl,d
0x63 => iz.b.h = self.getE(), // ld izh,e
0x6b => iz.b.l = self.getE(), // ld izl,e
0x7c => self.setA(iz.b.h), // ld a,izh
0x44 => self.setB(iz.b.h), // ld b,izh
0x4c => self.setC(iz.b.h), // ld c,izh
0x54 => self.setD(iz.b.h), // ld d,izh
0x5c => self.setE(iz.b.h), // ld e,izh
0x64 => iz.b.h = iz.b.h, // ld izh,izh
0x6c => iz.b.l = iz.b.h, // ld izl,izh
0x7d => self.setA(iz.b.l), // ld a,izl
0x45 => self.setB(iz.b.l), // ld b,izl
0x4d => self.setC(iz.b.l), // ld c,izl
0x55 => self.setD(iz.b.l), // ld d,izl
0x5d => self.setE(iz.b.l), // ld e,izl
0x65 => iz.b.h = iz.b.l, // ld izh,izl
0x6d => iz.b.l = iz.b.l, // ld izl,izl
0x26 => iz.b.h = self.fetchByte(), // ld izh,*
0x2e => iz.b.l = self.fetchByte(), // ld izl,*
0x7e => self.setA(self.readIZD(iz.w)), // ld a,(iz+*)
0x46 => self.setB(self.readIZD(iz.w)), // ld b,(iz+*)
0x4e => self.setC(self.readIZD(iz.w)), // ld c,(iz+*)
0x56 => self.setD(self.readIZD(iz.w)), // ld d,(iz+*)
0x5e => self.setE(self.readIZD(iz.w)), // ld e,(iz+*)
0x66 => self.setH(self.readIZD(iz.w)), // ld h,(iz+*)
0x6e => self.setL(self.readIZD(iz.w)), // ld l,(iz+*)
0x77 => self.writeByte(self.izd(iz.w), self.getA()), // ld (iz+*),a
0x70 => self.writeByte(self.izd(iz.w), self.getB()), // ld (iz+*),b
0x71 => self.writeByte(self.izd(iz.w), self.getC()), // ld (iz+*),c
0x72 => self.writeByte(self.izd(iz.w), self.getD()), // ld (iz+*),d
0x73 => self.writeByte(self.izd(iz.w), self.getE()), // ld (iz+*),e
0x74 => self.writeByte(self.izd(iz.w), self.getH()), // ld (iz+*),h
0x75 => self.writeByte(self.izd(iz.w), self.getL()), // ld (iz+*),l
0x36 => self.writeByte(self.izd(iz.w), self.fetchByte()), // ld (iz+*),*
// 16-bit load group
0x21 => iz.w = self.fetchWord(), // ld iz,**
0x2a => iz.w = self.readPairWithMemPtr(), // ld iz,(**)
0x22 => self.writePairWithMemPtr(iz.w), // ld (**),iz
0xf9 => self.sp = iz.w, // ld sp,iz
0xe5 => self.push(iz.w), // push iz
0xe1 => iz.w = self.pop(), // pop iz
// exchange, block transfer, and search group
0xe3 => self.exSP(iz), // ex (sp),iz
// 8-bit arithmetic group
0x84 => self.addA(iz.b.h), // add a,izh
0x85 => self.addA(iz.b.l), // add a,izl
0x86 => self.addA(self.readIZD(iz.w)), // add a,(iz+*)
0x8c => self.adcA(iz.b.h), // adc a,izh
0x8d => self.adcA(iz.b.l), // adc a,izl
0x8e => self.adcA(self.readIZD(iz.w)), // adc a,(iz+*)
0x94 => self.subA(iz.b.h), // sub izh
0x95 => self.subA(iz.b.l), // sub izl
0x96 => self.subA(self.readIZD(iz.w)), // sub (iz+*)
0x9c => self.sbcA(iz.b.h), // sbc a,izh
0x9d => self.sbcA(iz.b.l), // sbc a,izl
0x9e => self.sbcA(self.readIZD(iz.w)), // sbc a,(iz+*)
0xa4 => self.andA(iz.b.h), // and izh
0xa5 => self.andA(iz.b.l), // and izl
0xa6 => self.andA(self.readIZD(iz.w)), // and (iz+*)
0xb4 => self.orA(iz.b.h), // or izh
0xb5 => self.orA(iz.b.l), // or izl
0xb6 => self.orA(self.readIZD(iz.w)), // or (iz+*)
0xac => self.xor(iz.b.h), // xor izh
0xad => self.xor(iz.b.l), // xor izl
0xae => self.xor(self.readIZD(iz.w)), // xor (iz+*)
0xbc => self.cp(iz.b.h), // cp izh
0xbd => self.cp(iz.b.l), // cp izl
0xbe => self.cp(self.readIZD(iz.w)), // cp (iz+*)
0x24 => iz.b.h = self.inc(iz.b.h), // inc izh
0x2c => iz.b.l = self.inc(iz.b.l), // inc izl
0x34 => self.incMem(self.izd(iz.w)), // inc (iz+*)
0x25 => iz.b.h = self.dec(iz.b.h), // dec izh
0x2d => iz.b.l = self.dec(iz.b.l), // dec izl
0x35 => self.decMem(self.izd(iz.w)), // dec (iz+*)
// 16-bit arithmetic group
0x09 => self.addIZ(iz, self.getBC()), // add iz,bc
0x19 => self.addIZ(iz, self.getDE()), // add iz,de
0x29 => self.addIZ(iz, iz.w), // add iz,iz
0x39 => self.addIZ(iz, self.sp), // add iz,sp
0x23 => iz.w +%= 1, // inc iz
0x2b => iz.w -%= 1, // dec iz
// jump group
0xe9 => self.pc = iz.w, // jp (iz)
// bit instructions
0xcb => self.bits(self.izd(iz.w), true),
// all other opcodes are identical to base opcodes
else => {
// undo refresh operation
self.r = old_r;
// execute from main opcode table
self.main(opcode);
},
}
}
/// extended opcodes (ed-prefixed)
fn extended(self: *CPU) void {
const opcode = self.fetchOpcode();
self.refresh();
self.addCycles(ED_CYCLE_COUNTS[opcode]);
switch (opcode) {
// 8-bit load group
0x57 => self.setAToIR(self.i), // ld a,i
0x5f => self.setAToIR(self.r), // ld a,r
0x47 => self.i = self.getA(), // ld i,a
0x4f => self.r = self.getA(), // ld r,a
// 16-bit load group
0x4b => self.setBC(self.readWordMemPtr()), // ld bc,(**)
0x5b => self.setDE(self.readWordMemPtr()), // ld de,(**)
0x6b => self.setHL(self.readWordMemPtr()), // ld hl,(**)
0x7b => self.sp = self.readWordMemPtr(), // ld sp,(**)
0x43 => self.writeWordMemPtr(self.getBC()), // ld (**),bc
0x53 => self.writeWordMemPtr(self.getDE()), // ld (**),de
0x63 => self.writeWordMemPtr(self.getHL()), // ld (**),hl
0x73 => self.writeWordMemPtr(self.sp), // ld (**),sp
// exchange, block transfer, and search group
0xa0 => self.ldi(), // ldi
0xb0 => self.ldir(), // ldir
0xa8 => self.ldd(), // ldd
0xb8 => self.lddr(), // lddr
0xa1 => self.cpi(), // cpi
0xb1 => self.cpir(), // cpir
0xa9 => self.cpd(), // cpd
0xb9 => self.cpdr(), // cpdr
// general-purpose arithmetic and cpu control groups
0x44 => self.neg(), // neg
0x4c => self.neg(), // neg
0x54 => self.neg(), // neg
0x5c => self.neg(), // neg
0x64 => self.neg(), // neg
0x6c => self.neg(), // neg
0x74 => self.neg(), // neg
0x7c => self.neg(), // neg
0x46 => self.im = .Mode0, // im 0
0x4e => self.im = .Mode0, // im 0
0x66 => self.im = .Mode0, // im 0
0x6e => self.im = .Mode0, // im 0
0x56 => self.im = .Mode1, // im 1
0x76 => self.im = .Mode1, // im 1
0x5e => self.im = .Mode2, // im 2
0x7e => self.im = .Mode2, // im 2
// 16-bit arithmetic group
0x4a => self.adcHL(self.getBC()), // adc hl,bc
0x5a => self.adcHL(self.getDE()), // adc hl,de
0x6a => self.adcHL(self.getHL()), // adc hl,hl
0x7a => self.adcHL(self.sp), // adc hl,sp
0x42 => self.sbcHL(self.getBC()), // sbc hl,bc
0x52 => self.sbcHL(self.getDE()), // sbc hl,de
0x62 => self.sbcHL(self.getHL()), // sbc hl,hl
0x72 => self.sbcHL(self.sp), // sbc hl,sp
// rotate and shift group
0x6f => self.rld(), // rld
0x67 => self.rrd(), // rrd
// call and return group
0x4d => self.reti(), // reti
0x45 => self.retn(), // retn
0x55 => self.retn(), // retn
0x5d => self.retn(), // retn
0x65 => self.retn(), // retn
0x6d => self.retn(), // retn
0x75 => self.retn(), // retn
0x7d => self.retn(), // retn
// input and output group
0x78 => self.inAFromC(), // in a,(c)
0x40 => self.setB(self.inFromC()), // in b,(c)
0x48 => self.setC(self.inFromC()), // in c,(c)
0x50 => self.setD(self.inFromC()), // in d,(c)
0x58 => self.setE(self.inFromC()), // in e,(c)
0x60 => self.setH(self.inFromC()), // in h,(c)
0x68 => self.setL(self.inFromC()), // in l,(c)
0x70 => _ = self.inFromC(), // in (c)
0xa2 => self.ini(), // ini
0xb2 => self.inir(), // inir
0xaa => self.ind(), // ind
0xba => self.indr(), // indr
0x79 => self.outAToC(), // out (c),a
0x41 => self.outToC(self.getB()), // out (c),b
0x49 => self.outToC(self.getC()), // out (c),c
0x51 => self.outToC(self.getD()), // out (c),d
0x59 => self.outToC(self.getE()), // out (c),e
0x61 => self.outToC(self.getH()), // out (c),h
0x69 => self.outToC(self.getL()), // out (c),l
0x71 => self.outToC(0), // out (c),0
0xa3 => self.outi(), // outi
0xb3 => self.otir(), // otir
0xab => self.outd(), // outd
0xbb => self.otdr(), // otdr
// remaining opcodes are considered nops
else => {},
}
}
/// Attempt to perform a maskable interrupt. Returns true if the interrupt was acknowledged.
pub fn irq(self: *CPU) bool {
// request ignored if interrupts disabled or if not yet ready
if (self.int_delay or !self.iff1) return false;
// set up for response
self.unhalt();
self.di();
self.irBug();
// choose action depending on mode
switch (self.im) {
.Mode0 => {
// read action from data bus
self.addCycles(2);
self.int_read = true;
},
.Mode1 => {
// rst 38h
self.addCycles(7);
self.refresh();
self.call(0x38);
},
.Mode2 => {
self.addCycles(7);
self.refresh();
const indirect = word(self.i, self.interface.irq());
const address = self.readWord(indirect);
self.call(address);
},
}
// acknowledge interrupt
return true;
}
/// Attempt to perform a non-maskable interrupt. Returns true if the interrupt was acknowledged.
pub fn nmi(self: *CPU) bool {
// request ignored if not yet ready
if (self.int_delay) return false;
// set up for response
self.unhalt();
self.irBug();
self.refresh();
self.addCycles(5);
self.iff1 = false;
// call nmi handler
self.call(0x66);
// acknowledge interrupt
return true;
}
/// Performs a reset. This will only perform defined reset operations, and will take three cycles.
pub fn reset(self: *CPU) void {
self.iff1 = false;
self.iff2 = false;
self.im = .Mode0;
self.pc = 0;
self.i = 0;
self.r = 0;
self.sp = 0xffff;
self.setAF(0xffff);
self.addCycles(3);
} | src/CPU.zig |
const dcommon = @import("common/dcommon.zig");
pub fn halt() noreturn {
asm volatile ("msr daifset, #15");
while (true) {
asm volatile ("wfi");
}
}
pub fn transfer(entry_data: *dcommon.EntryData, uart_base: u64, adjusted_entry: u64) callconv(.Inline) noreturn {
// Check for EL2: we get
// and pass to DAINKRNL.
asm volatile (
// For QEMU's sake: clear x29, x30. (? Still need this on U-Boot ?)
// EDK2 trips over when generating stacks otherwise.
\\mov x29, xzr
\\mov x30, xzr
// Disable MMU, alignment checking, SP alignment checking;
// set little endian in EL0 and EL1.
\\mov x10, #0x0800
\\movk x10, #0x30d0, lsl #16
\\msr sctlr_el1, x10
\\isb
// Check if other cores are running.
\\mrs x10, mpidr_el1
\\and x10, x10, #3
\\cbz x10, .cpu_zero
// Non-zero core
\\mov x10, #0x44 // XXX Record progress "D"
\\strb w10, [x7] // XXX
\\1: wfe
\\b 1b
// Check if we're in EL1 (EDK2 does this for us).
// If so, go straight to DAINKRNL.
\\.cpu_zero:
\\mrs x10, CurrentEL
\\cmp x10, #0x4
\\b.ne .not_el1
\\mov x10, #0x45 // XXX Record progress "E"
\\strb w10, [x7] // XXX
\\br x9
// Assert we are in EL2.
\\.not_el1:
\\cmp x10, #0x8
\\b.eq .el2
\\brk #1
// U-Boot leaves us in EL2. Prepare to eret down to EL1
// to DAINKRNL.
\\.el2:
// Copy our stack.
\\mov x10, sp
\\msr sp_el1, x10
// Don't trap EL0/EL1 accesses to the EL1 physical counter and timer registers.
\\mrs x10, cnthctl_el2
\\orr x10, x10, #3
\\msr cnthctl_el2, x10
// Reset virtual offset register.
\\msr cntvoff_el2, xzr
// Set EL1 execution state to AArch64, not AArch32.
\\mov x10, #(1 << 31)
// EL1 execution of DC ISW performs the same invalidation as DC CISW.
\\orr x10, x10, #(1 << 1)
\\msr hcr_el2, x10
\\mrs x10, hcr_el2
// Clear hypervisor system trap register.
\\msr hstr_el2, xzr
// I saw someone on StackOverflow set this this way.
// "The CPTR_EL2 controls trapping to EL2 for accesses to CPACR, Trace functionality
// and registers associated with Advanced SIMD and floating-point execution. It also
// controls EL2 access to this functionality."
// This sets TFP to 0, TCPAC to 0, and everything else to RES values.
\\mov x10, #0x33ff
\\msr cptr_el2, x10
// Allow EL0/1 to use Advanced SIMD and FP.
// https://developer.arm.com/documentation/100442/0100/register-descriptions/aarch64-system-registers/cpacr-el1--architectural-feature-access-control-register--el1
// Set FPEN, [21:20] to 0b11.
\\mov x10, #0x300000
\\msr CPACR_EL1, x10
// Prepare the simulated exception.
// Trying EL1t (0x3c4) didn't make a difference in practice.
\\mov x10, #0x3c5 // DAIF+EL1+h (h = 0b1 = use SP_ELx, not SP0)
\\msr spsr_el2, x10
// Prepare the return address.
\\adr x10, .eret_target
\\msr elr_el2, x10
\\mov x10, #0x46 // XXX Record progress "F"
\\strb w10, [x7] // XXX
// Fire.
\\eret
\\brk #1 // Should not execute; if it did, U-Boot would say hi.
// Are we in EL1 yet?
\\.eret_target:
\\br x9
:
: [entry_data] "{x0}" (entry_data),
[uart_base] "{x7}" (uart_base),
[entry] "{x9}" (adjusted_entry)
: "memory"
);
unreachable;
}
pub fn cleanInvalidateDCacheICache(start: u64, len: u64) callconv(.Inline) void {
// Clean and invalidate D- and I-caches for loaded code.
// https://developer.arm.com/documentation/den0024/a/Caches/Cache-maintenance
// Also consider referecing https://gitlab.denx.de/u-boot/u-boot/blob/master/arch/arm/cpu/armv8/cache.S,
// but it uses set/way.
// See also https://android.googlesource.com/kernel/msm.git/+/android-msm-anthias-3.10-lollipop-wear-release/arch/arm64/mm/cache.S.
// This used DSB SY instead of ISH, and we will too, just in case.
asm volatile (
\\ ADD x1, x1, x0 // Base Address + Length
\\ MRS X2, CTR_EL0 // Read Cache Type Register
\\ // Get the minimun data cache line
\\ //
\\ UBFX X4, X2, #16, #4 // Extract DminLine (log2 of the cache line)
\\ MOV X3, #4 // Dminline iss the number of words (4 bytes)
\\ LSL X3, X3, X4 // X3 should contain the cache line
\\ SUB X4, X3, #1 // get the mask for the cache line
\\
\\ BIC X4, X0, X4 // Aligned the base address of the region
\\1:
\\ DC CVAU, X4 // Clean data cache line by VA to PoU
\\ ADD X4, X4, X3 // Next cache line
\\ CMP X4, X1 // Is X4 (current cache line) smaller than the end
\\ // of the region
\\ B.LT 1b // while (address < end_address)
\\
\\ DSB SY // Ensure visibility of the data cleaned from cache
\\
\\ //
\\ //Clean the instruction cache by VA
\\ //
\\
\\ // Get the minimum instruction cache line (X2 contains ctr_el0)
\\ AND X2, X2, #0xF // Extract IminLine (log2 of the cache line)
\\ MOV X3, #4 // IminLine is the number of words (4 bytes)
\\ LSL X3, X3, X2 // X3 should contain the cache line
\\ SUB x4, x3, #1 // Get the mask for the cache line
\\
\\ BIC X4, X0, X4 // Aligned the base address of the region
\\2:
\\ IC IVAU, X4 // Clean instruction cache line by VA to PoU
\\ ADD X4, X4, X3 // Next cache line
\\ CMP X4, X1 // Is X4 (current cache line) smaller than the end
\\ // of the region
\\ B.LT 2b // while (address < end_address)
\\
\\ DSB SY // Ensure completion of the invalidations
\\ ISB // Synchronize the fetched instruction stream
:
: [start] "{x0}" (start),
[len] "{x1}" (len)
: "memory", "x2", "x3", "x4"
);
} | dainboot/src/arm64.zig |
const std = @import("std");
const time = std.time;
const Timer = time.Timer;
const xorfilter = @import("main.zig");
const MeasuredAllocator = @import("MeasuredAllocator.zig");
fn formatTime(writer: anytype, comptime spec: []const u8, start: u64, end: u64, division: usize) !void {
const ns = @intToFloat(f64, (end - start) / division);
if (ns <= time.ns_per_ms) {
try std.fmt.format(writer, spec, .{ ns, "ns " });
return;
}
if (ns <= time.ns_per_s) {
try std.fmt.format(writer, spec, .{ ns / @intToFloat(f64, time.ns_per_ms), "ms " });
return;
}
if (ns <= time.ns_per_min) {
try std.fmt.format(writer, spec, .{ ns / @intToFloat(f64, time.ns_per_s), "s " });
return;
}
try std.fmt.format(writer, spec, .{ ns / @intToFloat(f64, time.ns_per_min), "min" });
return;
}
fn formatBytes(writer: anytype, comptime spec: []const u8, bytes: u64) !void {
const kib = 1024;
const mib = 1024 * kib;
const gib = 1024 * mib;
if (bytes < kib) {
try std.fmt.format(writer, spec, .{ bytes, "B " });
}
if (bytes < mib) {
try std.fmt.format(writer, spec, .{ bytes / kib, "KiB" });
return;
}
if (bytes < gib) {
try std.fmt.format(writer, spec, .{ bytes / mib, "MiB" });
return;
}
try std.fmt.format(writer, spec, .{ bytes / gib, "GiB" });
return;
}
fn bench(algorithm: []const u8, Filter: anytype, size: usize, trials: usize) !void {
const allocator = std.heap.page_allocator;
var filterMA = MeasuredAllocator.init(allocator);
var filterAllocator = &filterMA.allocator;
var buildMA = MeasuredAllocator.init(allocator);
var buildAllocator = &buildMA.allocator;
const stdout = std.io.getStdOut().writer();
var timer = try Timer.start();
// Initialize filter.
const filter = try Filter.init(filterAllocator, size);
defer filter.deinit();
// Generate keys.
var keys = try allocator.alloc(u64, size);
defer allocator.free(keys);
for (keys) |_, i| {
keys[i] = i;
}
// Populate filter.
timer.reset();
const populateTimeStart = timer.lap();
try filter.populate(buildAllocator, keys[0..]);
const populateTimeEnd = timer.read();
// Perform random matches.
var random_matches: u64 = 0;
var i: u64 = 0;
var rng = std.rand.DefaultPrng.init(0);
const random = rng.random();
timer.reset();
const randomMatchesTimeStart = timer.lap();
while (i < trials) : (i += 1) {
var random_key: u64 = random.uintAtMost(u64, std.math.maxInt(u64));
if (filter.contain(random_key)) {
if (random_key >= keys.len) {
random_matches += 1;
}
}
}
const randomMatchesTimeEnd = timer.read();
const fpp = @intToFloat(f64, random_matches) * 1.0 / @intToFloat(f64, trials);
const bitsPerEntry = @intToFloat(f64, filter.sizeInBytes()) * 8.0 / @intToFloat(f64, size);
const filterBitsPerEntry = @intToFloat(f64, filterMA.state.peak_memory_usage_bytes) * 8.0 / @intToFloat(f64, size);
if (!std.math.approxEqAbs(f64, filterBitsPerEntry, bitsPerEntry, 0.001)) {
@panic("sizeInBytes reporting wrong numbers?");
}
try stdout.print("| {s: <12} ", .{algorithm});
try stdout.print("| {: <10} ", .{keys.len});
try stdout.print("| ", .{});
try formatTime(stdout, "{d: >7.1}{s}", populateTimeStart, populateTimeEnd, 1);
try stdout.print(" | ", .{});
try formatTime(stdout, "{d: >8.1}{s}", randomMatchesTimeStart, randomMatchesTimeEnd, trials);
try stdout.print(" | {d: >12} ", .{fpp});
try stdout.print("| {d: >14.2} ", .{bitsPerEntry});
try stdout.print("| ", .{});
try formatBytes(stdout, "{: >9} {s}", buildMA.state.peak_memory_usage_bytes);
try formatBytes(stdout, " | {: >8} {s}", filterMA.state.peak_memory_usage_bytes);
try stdout.print(" |\n", .{});
}
fn usage() void {
std.debug.warn(
\\benchmark [options]
\\
\\Options:
\\ --num-trials [int=10000000] number of trials / containment checks to perform
\\ --help
\\
, .{});
}
pub fn main() !void {
var buffer: [1024]u8 = undefined;
var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]);
const args = try std.process.argsAlloc(&fixed.allocator);
var num_trials: usize = 100_000_000;
var i: usize = 1;
while (i < args.len) : (i += 1) {
if (std.mem.eql(u8, args[i], "--num-trials")) {
i += 1;
if (i == args.len) {
usage();
std.os.exit(1);
}
num_trials = try std.fmt.parseUnsigned(usize, args[i], 10);
}
}
const stdout = std.io.getStdOut().writer();
try stdout.print("| Algorithm | # of keys | populate | contains(k) | false+ prob. | bits per entry | peak populate | filter total |\n", .{});
try stdout.print("|--------------|------------|------------|-------------|--------------|----------------|---------------|--------------|\n", .{});
try bench("binaryfuse8", xorfilter.BinaryFuse(u8), 1_000_000, num_trials);
try bench("binaryfuse16", xorfilter.BinaryFuse(u16), 1_000_000, num_trials);
try bench("binaryfuse32", xorfilter.BinaryFuse(u32), 1_000_000, num_trials);
try bench("xor2", xorfilter.Xor(u2), 1_000_000, num_trials);
try bench("xor4", xorfilter.Xor(u4), 1_000_000, num_trials);
try bench("xor8", xorfilter.Xor(u8), 1_000_000, num_trials);
try bench("xor16", xorfilter.Xor(u16), 1_000_000, num_trials);
try bench("xor32", xorfilter.Xor(u32), 1_000_000, num_trials);
try stdout.print("| | | | | | | | |\n", .{});
try bench("binaryfuse8", xorfilter.BinaryFuse(u8), 10_000_000, num_trials / 10);
try bench("binaryfuse16", xorfilter.BinaryFuse(u16), 10_000_000, num_trials / 10);
try bench("binaryfuse32", xorfilter.BinaryFuse(u32), 10_000_000, num_trials / 10);
try bench("xor2", xorfilter.Xor(u2), 10_000_000, num_trials / 10);
try bench("xor4", xorfilter.Xor(u4), 10_000_000, num_trials / 10);
try bench("xor8", xorfilter.Xor(u8), 10_000_000, num_trials / 10);
try bench("xor16", xorfilter.Xor(u16), 10_000_000, num_trials / 10);
try bench("xor32", xorfilter.Xor(u32), 10_000_000, num_trials / 10);
try stdout.print("| | | | | | | | |\n", .{});
try bench("binaryfuse8", xorfilter.BinaryFuse(u8), 100_000_000, num_trials / 100);
try bench("binaryfuse16", xorfilter.BinaryFuse(u16), 100_000_000, num_trials / 100);
try bench("binaryfuse32", xorfilter.BinaryFuse(u32), 100_000_000, num_trials / 100);
try bench("xor2", xorfilter.Xor(u2), 100_000_000, num_trials / 100);
try bench("xor4", xorfilter.Xor(u4), 100_000_000, num_trials / 100);
try bench("xor8", xorfilter.Xor(u8), 100_000_000, num_trials / 100);
try bench("xor16", xorfilter.Xor(u16), 100_000_000, num_trials / 100);
try bench("xor32", xorfilter.Xor(u32), 100_000_000, num_trials / 100);
try stdout.print("| | | | | | | | |\n", .{});
try stdout.print("\n", .{});
try stdout.print("Legend:\n\n", .{});
try stdout.print("* **contains(k)**: The time taken to check if a key is in the filter\n", .{});
try stdout.print("* **false+ prob.**: False positive probability, the probability that a containment check will erroneously return true for a key that has not actually been added to the filter.\n", .{});
try stdout.print("* **bits per entry**: The amount of memory in bits the filter uses to store a single entry.\n", .{});
try stdout.print("* **peak populate**: Amount of memory consumed during filter population, excluding keys themselves (8 bytes * num_keys.)\n", .{});
try stdout.print("* **filter total**: Amount of memory consumed for filter itself in total (bits per entry * entries.)\n", .{});
} | src/benchmark.zig |
const macro = @import("pspmacros.zig");
comptime {
asm (macro.import_module_start("sceMpegbase", "0x00090000", "9"));
asm (macro.import_function("sceMpegbase", "0xBE45C284", "sceMpegBaseYCrCbCopyVme"));
asm (macro.import_function("sceMpegbase", "0x492B5E4B", "sceMpegBaseCscInit"));
asm (macro.import_function("sceMpegbase", "0xCE8EB837", "sceMpegBaseCscVme"));
asm (macro.import_function("sceMpegbase", "0x0530BE4E", "sceMpegbase_0530BE4E"));
asm (macro.import_function("sceMpegbase", "0x304882E1", "sceMpegbase_304882E1"));
asm (macro.import_function("sceMpegbase", "0x7AC0321A", "sceMpegBaseYCrCbCopy"));
asm (macro.import_function("sceMpegbase", "0x91929A21", "sceMpegBaseCscAvc"));
asm (macro.import_function("sceMpegbase", "0xAC9E717E", "sceMpegbase_AC9E717E"));
asm (macro.import_function("sceMpegbase", "0xBEA18F91", "sceMpegbase_BEA18F91"));
asm (macro.import_module_start("sceMpeg", "0x00090000", "38"));
asm (macro.import_function("sceMpeg", "0x21FF80E4", "sceMpegQueryStreamOffset"));
asm (macro.import_function("sceMpeg", "0x611E9E11", "sceMpegQueryStreamSize"));
asm (macro.import_function("sceMpeg", "0x682A619B", "sceMpegInit"));
asm (macro.import_function("sceMpeg", "0x874624D6", "sceMpegFinish"));
asm (macro.import_function("sceMpeg", "0xC132E22F", "sceMpegQueryMemSize"));
asm (macro.import_function("sceMpeg", "0xD8C5F121", "sceMpegCreate_stub"));
asm (macro.import_function("sceMpeg", "0x606A4649", "sceMpegDelete"));
asm (macro.import_function("sceMpeg", "0x42560F23", "sceMpegRegistStream"));
asm (macro.import_function("sceMpeg", "0x591A4AA2", "sceMpegUnRegistStream"));
asm (macro.import_function("sceMpeg", "0xA780CF7E", "sceMpegMallocAvcEsBuf"));
asm (macro.import_function("sceMpeg", "0xCEB870B1", "sceMpegFreeAvcEsBuf"));
asm (macro.import_function("sceMpeg", "0xF8DCB679", "sceMpegQueryAtracEsSize"));
asm (macro.import_function("sceMpeg", "0xC02CF6B5", "sceMpegQueryPcmEsSize"));
asm (macro.import_function("sceMpeg", "0x167AFD9E", "sceMpegInitAu"));
asm (macro.import_function("sceMpeg", "0x234586AE", "sceMpegChangeGetAvcAuMode"));
asm (macro.import_function("sceMpeg", "0x9DCFB7EA", "sceMpegChangeGetAuMode"));
asm (macro.import_function("sceMpeg", "0xFE246728", "sceMpegGetAvcAu"));
asm (macro.import_function("sceMpeg", "0x8C1E027D", "sceMpegGetPcmAu"));
asm (macro.import_function("sceMpeg", "0xE1CE83A7", "sceMpegGetAtracAu"));
asm (macro.import_function("sceMpeg", "0x500F0429", "sceMpegFlushStream"));
asm (macro.import_function("sceMpeg", "0x707B7629", "sceMpegFlushAllStream"));
asm (macro.import_function("sceMpeg", "0x0E3C2E9D", "sceMpegAvcDecode_stub"));
asm (macro.import_function("sceMpeg", "0x0F6C18D7", "sceMpegAvcDecodeDetail"));
asm (macro.import_function("sceMpeg", "0xA11C7026", "sceMpegAvcDecodeMode"));
asm (macro.import_function("sceMpeg", "0x740FCCD1", "sceMpegAvcDecodeStop"));
asm (macro.import_function("sceMpeg", "0x800C44DF", "sceMpegAtracDecode"));
asm (macro.import_function("sceMpeg", "0xD7A29F46", "sceMpegRingbufferQueryMemSize"));
asm (macro.import_function("sceMpeg", "0x37295ED8", "sceMpegRingbufferConstruct_stub"));
asm (macro.import_function("sceMpeg", "0x13407F13", "sceMpegRingbufferDestruct"));
asm (macro.import_function("sceMpeg", "0xB240A59E", "sceMpegRingbufferPut"));
asm (macro.import_function("sceMpeg", "0xB5F6DC87", "sceMpegRingbufferAvailableSize"));
asm (macro.import_function("sceMpeg", "0x11CAB459", "sceMpeg_11CAB459"));
asm (macro.import_function("sceMpeg", "0x3C37A7A6", "sceMpeg_3C37A7A6"));
asm (macro.import_function("sceMpeg", "0xB27711A8", "sceMpeg_B27711A8"));
asm (macro.import_function("sceMpeg", "0xD4DD6E75", "sceMpeg_D4DD6E75"));
asm (macro.import_function("sceMpeg", "0xC345DED2", "sceMpeg_C345DED2"));
asm (macro.import_function("sceMpeg", "0xCF3547A2", "sceMpegAvcDecodeDetail2"));
asm (macro.import_function("sceMpeg", "0x988E9E12", "sceMpeg_988E9E12"));
asm (macro.generic_abi_wrapper("sceMpegCreate", 7));
asm (macro.generic_abi_wrapper("sceMpegRingbufferConstruct", 6));
asm (macro.generic_abi_wrapper("sceMpegAvcDecode", 5));
} | src/psp/nids/pspmpeg.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const config = @import("config.zig");
const vsr = @import("vsr.zig");
const Header = vsr.Header;
comptime {
// message_size_max must be a multiple of sector_size for Direct I/O
assert(config.message_size_max % config.sector_size == 0);
}
/// Add an extra sector_size bytes to allow a partially received subsequent
/// message to be shifted to make space for 0 padding to vsr.sector_ceil.
const message_size_max_padded = config.message_size_max + config.sector_size;
/// A pool of reference-counted Messages, memory for which is allocated only once
/// during initialization and reused thereafter. The config.message_bus_messages_max
/// and config.message_bus_headers_max values determine the size of this pool.
pub const MessagePool = struct {
pub const Message = struct {
// TODO: replace this with a header() function to save memory
header: *Header,
/// Unless this Message is header only, this buffer is in aligned to config.sector_size
/// and casting to that alignment in order to perform Direct I/O is safe.
buffer: []u8,
references: u32 = 0,
next: ?*Message,
/// Increment the reference count of the message and return the same pointer passed.
pub fn ref(message: *Message) *Message {
message.references += 1;
return message;
}
pub fn body(message: *Message) []u8 {
return message.buffer[@sizeOf(Header)..message.header.size];
}
fn header_only(message: Message) bool {
const ret = message.buffer.len == @sizeOf(Header);
assert(ret or message.buffer.len == message_size_max_padded);
return ret;
}
};
/// List of currently unused messages of message_size_max_padded
free_list: ?*Message,
/// List of currently usused header-sized messages
header_only_free_list: ?*Message,
pub fn init(allocator: *mem.Allocator) error{OutOfMemory}!MessagePool {
var ret: MessagePool = .{
.free_list = null,
.header_only_free_list = null,
};
{
var i: usize = 0;
while (i < config.message_bus_messages_max) : (i += 1) {
const buffer = try allocator.allocAdvanced(
u8,
config.sector_size,
message_size_max_padded,
.exact,
);
const message = try allocator.create(Message);
message.* = .{
.header = mem.bytesAsValue(Header, buffer[0..@sizeOf(Header)]),
.buffer = buffer,
.next = ret.free_list,
};
ret.free_list = message;
}
}
{
var i: usize = 0;
while (i < config.message_bus_headers_max) : (i += 1) {
const header = try allocator.create(Header);
const message = try allocator.create(Message);
message.* = .{
.header = header,
.buffer = mem.asBytes(header),
.next = ret.header_only_free_list,
};
ret.header_only_free_list = message;
}
}
return ret;
}
/// Get an unused message with a buffer of config.message_size_max. If no such message is
/// available, an error is returned. The returned message has exactly one reference.
pub fn get_message(pool: *MessagePool) ?*Message {
const ret = pool.free_list orelse return null;
pool.free_list = ret.next;
ret.next = null;
assert(!ret.header_only());
assert(ret.references == 0);
ret.references = 1;
return ret;
}
/// Get an unused message with a buffer only large enough to hold a header. If no such message
/// is available, an error is returned. The returned message has exactly one reference.
pub fn get_header_only_message(pool: *MessagePool) ?*Message {
const ret = pool.header_only_free_list orelse return null;
pool.header_only_free_list = ret.next;
ret.next = null;
assert(ret.header_only());
assert(ret.references == 0);
ret.references = 1;
return ret;
}
/// Decrement the reference count of the message, possibly freeing it.
pub fn unref(pool: *MessagePool, message: *Message) void {
message.references -= 1;
if (message.references == 0) {
if (std.builtin.mode == .Debug) mem.set(u8, message.buffer, undefined);
if (message.header_only()) {
message.next = pool.header_only_free_list;
pool.header_only_free_list = message;
} else {
message.next = pool.free_list;
pool.free_list = message;
}
}
}
}; | src/message_pool.zig |
const std = @import("std");
const allocators = @import("limp/allocators.zig");
pub fn build(b: *std.build.Builder) void {
const target = b.standardTargetOptions(.{});
const mode = b.standardReleaseOptions();
const exe = b.addExecutable("limp", "limp/main.zig");
exe.setTarget(target);
exe.setBuildMode(mode);
exe.linkLibC();
exe.addIncludeDir("lua/");
exe.addIncludeDir("zlib/");
var extraSpace = std.fmt.comptimePrint("{}", .{@sizeOf(allocators.TempAllocator)});
exe.defineCMacro("LUA_EXTRASPACE", extraSpace);
exe.defineCMacro("Z_SOLO", "");
exe.defineCMacro("ZLIB_CONST", "");
const lua_c_files = [_][]const u8{
"lapi.c", "lcode.c", "lctype.c", "ldebug.c",
"ldo.c", "ldump.c", "lfunc.c", "lgc.c",
"llex.c", "lmem.c", "lobject.c", "lopcodes.c",
"lparser.c", "lstate.c", "lstring.c", "ltable.c",
"ltm.c", "lundump.c", "lvm.c", "lzio.c",
"lauxlib.c", "lbaselib.c", "lcorolib.c", "ldblib.c",
"liolib.c", "lmathlib.c", "loadlib.c", "loslib.c",
"lstrlib.c", "ltablib.c", "lutf8lib.c", "linit.c",
};
const zlib_c_files = [_][]const u8{
"adler32.c", "crc32.c", "deflate.c", "inflate.c",
"inftrees.c", "inffast.c", "trees.c", "zutil.c",
};
const c_flags = [_][]const u8{
"-std=c99",
"-O2",
"-Wall",
"-Wextra",
};
inline for (lua_c_files) |c_file| {
exe.addCSourceFile("lua/" ++ c_file, &c_flags);
}
inline for (zlib_c_files) |c_file| {
exe.addCSourceFile("zlib/" ++ c_file, &c_flags);
}
exe.install();
const run_cmd = exe.run();
run_cmd.step.dependOn(b.getInstallStep());
if (b.args) |args| {
run_cmd.addArgs(args);
}
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
const exe_tests = b.addTest("limp/main.zig");
exe_tests.setTarget(target);
exe_tests.setBuildMode(mode);
const test_step = b.step("test", "Run unit tests");
test_step.dependOn(&exe_tests.step);
} | build.zig |
pub use @import("wasi/core.zig");
// Based on https://github.com/CraneStation/wasi-sysroot/blob/wasi/libc-bottom-half/headers/public/wasi/core.h
// and https://github.com/CraneStation/wasmtime/blob/master/docs/WASI-api.md
pub const STDIN_FILENO = 0;
pub const STDOUT_FILENO = 1;
pub const STDERR_FILENO = 2;
pub const ESUCCESS = 0;
pub const E2BIG = 1;
pub const EACCES = 2;
pub const EADDRINUSE = 3;
pub const EADDRNOTAVAIL = 4;
pub const EAFNOSUPPORT = 5;
pub const EAGAIN = 6;
pub const EALREADY = 7;
pub const EBADF = 8;
pub const EBADMSG = 9;
pub const EBUSY = 10;
pub const ECANCELED = 11;
pub const ECHILD = 12;
pub const ECONNABORTED = 13;
pub const ECONNREFUSED = 14;
pub const ECONNRESET = 15;
pub const EDEADLK = 16;
pub const EDESTADDRREQ = 17;
pub const EDOM = 18;
pub const EDQUOT = 19;
pub const EEXIST = 20;
pub const EFAULT = 21;
pub const EFBIG = 22;
pub const EHOSTUNREACH = 23;
pub const EIDRM = 24;
pub const EILSEQ = 25;
pub const EINPROGRESS = 26;
pub const EINTR = 27;
pub const EINVAL = 28;
pub const EIO = 29;
pub const EISCONN = 30;
pub const EISDIR = 31;
pub const ELOOP = 32;
pub const EMFILE = 33;
pub const EMLINK = 34;
pub const EMSGSIZE = 35;
pub const EMULTIHOP = 36;
pub const ENAMETOOLONG = 37;
pub const ENETDOWN = 38;
pub const ENETRESET = 39;
pub const ENETUNREACH = 40;
pub const ENFILE = 41;
pub const ENOBUFS = 42;
pub const ENODEV = 43;
pub const ENOENT = 44;
pub const ENOEXEC = 45;
pub const ENOLCK = 46;
pub const ENOLINK = 47;
pub const ENOMEM = 48;
pub const ENOMSG = 49;
pub const ENOPROTOOPT = 50;
pub const ENOSPC = 51;
pub const ENOSYS = 52;
pub const ENOTCONN = 53;
pub const ENOTDIR = 54;
pub const ENOTEMPTY = 55;
pub const ENOTRECOVERABLE = 56;
pub const ENOTSOCK = 57;
pub const ENOTSUP = 58;
pub const ENOTTY = 59;
pub const ENXIO = 60;
pub const EOVERFLOW = 61;
pub const EOWNERDEAD = 62;
pub const EPERM = 63;
pub const EPIPE = 64;
pub const EPROTO = 65;
pub const EPROTONOSUPPORT = 66;
pub const EPROTOTYPE = 67;
pub const ERANGE = 68;
pub const EROFS = 69;
pub const ESPIPE = 70;
pub const ESRCH = 71;
pub const ESTALE = 72;
pub const ETIMEDOUT = 73;
pub const ETXTBSY = 74;
pub const EXDEV = 75;
pub const ENOTCAPABLE = 76;
// TODO: implement this like darwin does
pub fn getErrno(r: usize) usize {
const signed_r = @bitCast(isize, r);
return if (signed_r > -4096 and signed_r < 0) @intCast(usize, -signed_r) else 0;
}
pub fn exit(status: i32) noreturn {
proc_exit(@bitCast(exitcode_t, isize(status)));
}
pub fn write(fd: i32, buf: [*]const u8, count: usize) usize {
var nwritten: usize = undefined;
const iovs = []ciovec_t{ciovec_t{
.buf = buf,
.buf_len = count,
}};
_ = fd_write(@bitCast(fd_t, isize(fd)), &iovs[0], iovs.len, &nwritten);
return nwritten;
} | std/os/wasi.zig |
const std = @import("std");
const aoc = @import("aoc-lib.zig");
test "examples" {
const test0 = try aoc.Ints(aoc.talloc, i64, aoc.test0file);
defer aoc.talloc.free(test0);
const test1 = try aoc.Ints(aoc.talloc, i64, aoc.test1file);
defer aoc.talloc.free(test1);
const test2 = try aoc.Ints(aoc.talloc, i64, aoc.test2file);
defer aoc.talloc.free(test2);
const inp = try aoc.Ints(aoc.talloc, i64, aoc.inputfile);
defer aoc.talloc.free(inp);
try aoc.assertEq(@as(i64, 8), part1(aoc.talloc, test0));
try aoc.assertEq(@as(i64, 4), part2(aoc.talloc, test0));
try aoc.assertEq(@as(i64, 35), part1(aoc.talloc, test1));
try aoc.assertEq(@as(i64, 8), part2(aoc.talloc, test1));
try aoc.assertEq(@as(i64, 220), part1(aoc.talloc, test2));
try aoc.assertEq(@as(i64, 19208), part2(aoc.talloc, test2));
try aoc.assertEq(@as(i64, 1920), part1(aoc.talloc, inp));
try aoc.assertEq(@as(i64, 1511207993344), part2(aoc.talloc, inp));
}
fn part1(alloc: std.mem.Allocator, in: []const i64) i64 {
var nums: []i64 = alloc.dupe(i64, in) catch unreachable;
defer alloc.free(nums);
std.sort.sort(i64, nums, {}, aoc.i64LessThan);
var cj: i64 = 0;
var c = std.AutoHashMap(i64, i64).init(alloc);
defer c.deinit();
for (nums) |j| {
const d = j - cj;
c.put(d, (c.get(d) orelse 0) + 1) catch unreachable;
cj = j;
}
if (cj - nums[nums.len - 1] == 1) {
return (1 + c.get(1).?) * c.get(3).?;
} else {
return c.get(1).? * (c.get(3).? + 1);
}
}
fn count(cj: i64, tj: i64, ni: usize, nums: []i64, state: *std.AutoHashMap(usize, i64)) i64 {
const k: usize = std.math.absCast(cj) + ni * nums.len;
if (state.contains(k)) {
return state.get(k).?;
}
if (ni >= nums.len) {
return 1;
}
var c: i64 = 0;
var i: usize = 0;
while (ni + i < nums.len and i < 3) : (i += 1) {
var j = nums[ni + i];
if ((j - cj) <= 3) {
c += count(j, tj, ni + i + 1, nums, state);
}
}
state.put(k, c) catch unreachable;
return c;
}
fn part2(alloc: std.mem.Allocator, in: []const i64) i64 {
var nums: []i64 = alloc.dupe(i64, in) catch unreachable;
defer alloc.free(nums);
std.sort.sort(i64, nums, {}, aoc.i64LessThan);
var state = std.AutoHashMap(usize, i64).init(alloc);
defer state.deinit();
return count(0, in[in.len - 1], 0, nums, &state);
}
fn day10(inp: []const u8, bench: bool) anyerror!void {
var nums = try aoc.Ints(aoc.halloc, i64, inp);
defer aoc.halloc.free(nums);
var p1 = part1(aoc.halloc, nums);
var p2 = part2(aoc.halloc, nums);
if (!bench) {
try aoc.print("Part 1: {}\nPart 2: {}\n", .{ p1, p2 });
}
}
pub fn main() anyerror!void {
try aoc.benchme(aoc.input(), day10);
} | 2020/10/aoc.zig |
const std = @import("std");
pub fn initializeKernelExe(b: *std.build.Builder, target: std.zig.CrossTarget, mode: std.builtin.Mode) *std.build.LibExeObjStep {
const exe = b.addExecutable("kernel", "kernel/main.zig");
exe.setLinkerScriptPath("kernel/linker_script.ld");
exe.addAssemblyFile("kernel/initialize.s");
exe.setTarget(target);
exe.setBuildMode(mode);
exe.install();
return exe;
}
pub fn build(b: *std.build.Builder) void {
var features_to_add = std.Target.Cpu.Feature.Set.empty;
// features_to_add.addFeature(@enumToInt(std.Target.x86.Feature.soft_float));
var features_to_remove = std.Target.Cpu.Feature.Set.empty;
features_to_remove.addFeature(@enumToInt(std.Target.x86.Feature.sse));
features_to_remove.addFeature(@enumToInt(std.Target.x86.Feature.sse2));
const target = b.standardTargetOptions(.{ .whitelist = null, .default_target = .{
.cpu_arch = .i386,
.cpu_model = .{ .baseline = {} },
.cpu_features_add = features_to_add,
.cpu_features_sub = features_to_remove,
.os_tag = .freestanding,
.os_version_min = null,
.os_version_max = null,
.glibc_version = null,
.abi = .none,
.dynamic_linker = std.zig.system.NativeTargetInfo.DynamicLinker.init(null),
} });
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const mode = b.standardReleaseOptions();
// Binary executables
const kernel_exe = initializeKernelExe(b, target, mode);
const qemu_cmd = b.addSystemCommand(&[_][]const u8{ "qemu-system-i386", "-serial", "stdio", "-kernel" });
qemu_cmd.addArtifactArg(kernel_exe);
qemu_cmd.step.dependOn(b.getInstallStep());
b.step("run", "Run the OS in the QEMU").dependOn(&qemu_cmd.step);
// -S pauses QEMU whatn started, so that we can setup breakpoints before letting QEMU execute the code.
const qemu_dbg_cmd = b.addSystemCommand(&[_][]const u8{ "qemu-system-i386", "-serial", "stdio", "-gdb", "tcp::9000", "-S", "-kernel" });
qemu_dbg_cmd.addArtifactArg(kernel_exe);
qemu_dbg_cmd.step.dependOn(b.getInstallStep());
b.step("dbgd", "Sams as run, but also runs GDB server").dependOn(&qemu_dbg_cmd.step);
// -ex 'target remote localhost:9000' -> Connect to QEMU GDB server
// -ex 'b panic' -> Set breakpoint on when panic() is called.
const gdb_cmd = b.addSystemCommand(&[_][]const u8{ "gdb", "-ex", "target remote localhost:9000", "-ex", "b panic" });
gdb_cmd.addArtifactArg(kernel_exe);
b.step("dbg", "Connect to GDB server launched by dbgd").dependOn(&gdb_cmd.step);
// -ex 'target remote localhost:9000' -> Connect to QEMU GDB server
// -ex 'b panic' -> Set breakpoint on when panic() is called.
// -ex 'c' -> Continue execution(until it panics and hits the breakpoint).
// -ex 'bt' -> Dump backtrace
// -ex 'detach' -> Detach the target
// -ex 'quit' -> Exit the GDB
const gdb_cmd_for_panic = b.addSystemCommand(&[_][]const u8{ "gdb", "-ex", "target remote localhost:9000", "-ex", "b panic", "-ex", "c", "-ex", "bt", "-ex", "detach", "-ex", "quit" });
gdb_cmd_for_panic.addArtifactArg(kernel_exe);
b.step("pdbg", "Similar to pdbg, but just shows panic backtrace and exit.").dependOn(&gdb_cmd_for_panic.step);
} | build.zig |
const std = @import("std");
const print = std.debug.print;
const getopt = @import("getopt.zig");
const zero = std.crypto.utils.secureZero;
const impl = @import("signify-format.zig");
const getpass = @import("getpass.zig");
const ExitError = error.ExitError;
var argv: [][:0]const u8 = undefined;
pub fn main() !void {
//const allocator = std.heap.page_allocator;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var err_context: []u8 = try allocator.alloc(u8, 0);
defer allocator.free(err_context);
argv = try std.process.argsAlloc(allocator);
defer {
// for (argv) |arg|
// allocator.free(arg); // why is this not needed?
allocator.free(argv);
}
const args = Args.parse_cmdline() catch std.os.exit(1);
args.run(&err_context, allocator) catch |err| {
handle_file_error(err_context, err) catch |moderr| switch (moderr) {
ExitError => {},
else => return moderr,
};
std.os.exit(1);
};
}
const Args = struct {
const Operation = enum {
Generate,
Sign,
Verify,
VerifyList,
};
operation: ?Operation = null,
embedded: bool = false,
comment: ?[]const u8 = null,
msgfile: ?[]const u8 = null,
usepass: bool = true,
pubkeyfile: ?[]const u8 = null,
seckeyfile: ?[]const u8 = null,
sigfile: ?[]const u8 = null,
const Usage = error{Usage};
fn usage() Usage!void {
print(
\\usage: {0s} -G [-c comment] [-n] -p pubkey -s seckey
\\ {0s} -S [-e] [-x sigfile] -s seckey -m msgfile
\\ {0s} -V [-e] -p pubkey [-x sigfile] -m msgfile
\\ {0s} -C -p pubkey -x sigfile
\\
\\modes:
\\ -G generate new key pair (-n to not use a passphrase for encryption)
\\ -S sign file, -e embeds the message into the signature file.
\\ -V verify file, -e indicates sigfile contains the message, which is written to msgfile.
\\
, .{std.fs.path.basename(std.mem.sliceTo(argv[0], 0))});
return error.Usage;
}
fn set_op(self: *Args, operation: Operation) Usage!void {
if (self.operation != null)
return usage();
self.operation = operation;
}
fn parse_cmdline() Usage!Args {
var opts = getopt.OptionsIterator{ .argv = argv, .opts = "GSVChec:m:np:s:x:" };
var self = Args{};
while (opts.next()) |maybe_opt| {
if (maybe_opt) |opt| {
switch (opt.opt) {
// Generate key pair
'G' => try self.set_op(.Generate),
// Sign message
'S' => try self.set_op(.Sign),
// Verify message
'V' => try self.set_op(.Verify),
// Verify signed checksum list, then verify checksum of each listed file
'C' => try self.set_op(.VerifyList),
// Flags
'h' => try usage(),
'e' => self.embedded = true,
'c' => self.comment = opt.arg.?,
'm' => self.msgfile = opt.arg.?,
'n' => self.usepass = false,
'p' => self.pubkeyfile = opt.arg.?,
's' => self.seckeyfile = opt.arg.?,
'x' => self.sigfile = opt.arg.?,
else => unreachable,
}
} else break;
} else |err| {
switch (err) {
getopt.Error.InvalidOption => print("invalid option: -{c}\n", .{opts.optopt}),
getopt.Error.MissingArgument => print("option requires an argument: -{c}\n", .{opts.optopt}),
}
return error.Usage;
}
if (self.operation == null)
try usage();
switch (self.operation.?) {
.Generate => if (self.seckeyfile == null or self.pubkeyfile == null) try usage(),
.Sign => if (self.seckeyfile == null or self.msgfile == null) try usage(),
.Verify => if (self.pubkeyfile == null or self.msgfile == null) try usage(),
.VerifyList => if (self.pubkeyfile == null or self.sigfile == null) try usage(),
}
if (self.seckeyfile) |secname| {
if (!std.mem.endsWith(u8, secname, ".sec")) {
print("key files need to be named keyname.pub and keyname.sec\n", .{});
return error.Usage;
}
if (self.pubkeyfile) |pubname| {
if (!std.mem.endsWith(u8, pubname, ".pub") or
!std.mem.eql(u8, secname[0 .. secname.len - 3], pubname[0 .. pubname.len - 3]))
{
print("key files need to be named keyname.pub and keyname.sec\n", .{});
return error.Usage;
}
}
}
return self;
}
fn run(args: *const Args, err_context: *[]u8, allocator: std.mem.Allocator) !void {
const default_sigfile = if (args.msgfile) |msgfile|
try std.mem.concat(allocator, u8, &[_][]const u8{ msgfile, ".sig" })
else
null;
defer if (default_sigfile) |df| allocator.free(df); // so unconditional defer, conditional free
switch (args.operation.?) {
.Generate => try generate_key(args.pubkeyfile.?, args.seckeyfile.?, args.usepass, args.comment, err_context, allocator),
.Sign => try sign_file(args.seckeyfile.?, args.msgfile.?, args.sigfile orelse default_sigfile.?, args.embedded, err_context, allocator),
.Verify => {
const result = if (args.embedded)
verify_embedded_file(args.pubkeyfile.?, args.msgfile.?, args.sigfile orelse default_sigfile.?, err_context, allocator)
else
verify_file(args.pubkeyfile.?, args.msgfile.?, args.sigfile orelse default_sigfile.?, err_context, allocator);
if (result) {
print("Signature verified\n", .{});
} else |err| switch (err) {
error.SignatureVerificationFailed => {
print("Signature verification failed\n", .{});
std.os.exit(1);
},
else => return err,
}
},
.VerifyList => unreachable,
}
}
};
fn generate_key(pubkeyfile: []const u8, seckeyfile: []const u8, encrypt: bool, comment: ?[]const u8, err_context: *[]u8, allocator: std.mem.Allocator) !void {
var pwstor: [1024]u8 = undefined;
defer zero(u8, &pwstor);
const passphrase = if (encrypt)
getpass.getpass("Passphrase for new key: ", &pwstor) catch |err| switch (err) {
getpass.NoPassphraseGiven => {
print("If you wish to not encrypt the key, use the -n switch.\n", .{});
return ExitError;
},
else => return err,
}
else
"";
if (encrypt) {
var pwstor2: [1024]u8 = undefined;
defer zero(u8, &pwstor2);
const confirm_passphrase = try getpass.getpass("Confirm passphrase for new key: ", &pwstor);
if (!std.mem.eql(u8, passphrase, confirm_passphrase)) {
print("Passphrases do no match.\n", .{});
return ExitError;
}
}
const seccomment = try std.mem.concat(allocator, u8, &[_][]const u8{ comment orelse "signify", " secret key" });
defer allocator.free(seccomment);
const pubcomment = try std.mem.concat(allocator, u8, &[_][]const u8{ comment orelse "signify", " public key" });
defer allocator.free(pubcomment);
const pair = try impl.generate_keypair(passphrase);
try set_err_context(allocator, err_context, seckeyfile);
try impl.write_base64_file(seckeyfile, seccomment, impl.as_bytes(pair.seckey), allocator);
try set_err_context(allocator, err_context, pubkeyfile);
try impl.write_base64_file(pubkeyfile, pubcomment, impl.as_bytes(pair.pubkey), allocator);
}
fn sign_file(seckeyfile: []const u8, msgfile: []const u8, sigfile: []const u8, embedded: bool, err_context: *[]u8, allocator: std.mem.Allocator) !void {
try set_err_context(allocator, err_context, seckeyfile);
const encseckey = try impl.from_file(impl.SecretKey, seckeyfile, null, allocator);
try set_err_context(allocator, err_context, msgfile);
const msg = try read_file(msgfile, 65535, allocator); // XXX 64K<1G
defer allocator.free(msg);
try set_err_context(allocator, err_context, seckeyfile);
var seckey = try decrypt_secret_key(&encseckey);
defer impl.zerosingle(&seckey);
const signature = try impl.sign_message(seckey, msg);
const keyname = std.fs.path.basename(seckeyfile);
const comment = try std.mem.concat(allocator, u8, &[_][]const u8{ "verify with ", keyname[0 .. keyname.len - 3], "pub" });
defer allocator.free(comment);
try set_err_context(allocator, err_context, sigfile);
try impl.write_base64_file(sigfile, comment, impl.as_bytes(signature), allocator);
if (embedded) {
const file = try std.fs.cwd().openFile(sigfile, .{ .write = true });
defer file.close();
try file.seekFromEnd(0);
try file.writeAll(msg);
}
}
fn verify_file(pubkeyfile: []const u8, msgfile: []const u8, sigfile: []const u8, err_context: *[]u8, allocator: std.mem.Allocator) !void {
try set_err_context(allocator, err_context, pubkeyfile);
const pubkey = try impl.from_file(impl.PubKey, pubkeyfile, null, allocator);
try set_err_context(allocator, err_context, sigfile);
const sig = try impl.from_file(impl.Signature, sigfile, null, allocator);
try set_err_context(allocator, err_context, msgfile);
const msg = try read_file(msgfile, 65535, allocator); // XXX 64K<1G
defer allocator.free(msg);
try impl.verify_message(pubkey, sig, msg);
}
fn verify_embedded_file(pubkeyfile: []const u8, msgfile: []const u8, sigfile: []const u8, err_context: *[]u8, allocator: std.mem.Allocator) !void {
try set_err_context(allocator, err_context, pubkeyfile);
const pubkey = try impl.from_file(impl.PubKey, pubkeyfile, null, allocator);
var siglen: usize = undefined;
try set_err_context(allocator, err_context, sigfile);
const sig = try impl.from_file(impl.Signature, sigfile, &siglen, allocator);
const msg = try read_file_offset(sigfile, siglen, allocator);
defer allocator.free(msg);
try impl.verify_message(pubkey, sig, msg);
// write verified contents to -m msgfile
try set_err_context(allocator, err_context, msgfile);
const file = try std.fs.cwd().createFile(msgfile, .{ .exclusive = true });
defer file.close();
try file.writeAll(msg);
}
fn read_file_offset(filename: []const u8, offset: usize, allocator: std.mem.Allocator) ![]const u8 {
const file = try std.fs.cwd().openFile(filename, .{});
defer file.close();
try file.seekTo(offset);
return try file.readToEndAlloc(allocator, 123456); // XXX <1G
}
fn read_file(path: []const u8, max_size: u32, allocator: std.mem.Allocator) ![]u8 {
return try std.fs.cwd().readFileAlloc(allocator, path, max_size);
}
fn decrypt_secret_key(seckey: *const impl.SecretKey) !impl.DecryptedSecretKey {
if (seckey.is_encrypted()) {
var pwstor: [1024]u8 = undefined;
defer zero(u8, &pwstor);
const passphrase = try getpass.getpass("Passphrase: ", &pwstor);
return try seckey.decrypt(passphrase);
} else {
return try seckey.decrypt("");
}
}
fn set_err_context(allocator: std.mem.Allocator, err_context: *[]u8, ctx: []const u8) !void {
if (err_context.len < ctx.len) {
allocator.free(err_context.*);
err_context.* = try allocator.alloc(u8, ctx.len);
}
std.mem.copy(u8, err_context.*, ctx);
}
fn handle_file_error(file: []const u8, err: anyerror) !void {
const msg = switch (err) {
error.UnsupportedAlgorithm => "Signature algorithm used is not supported by this tool",
error.InvalidLength => "Invalid length of encoded data",
error.GarbageAtEndOfFile => "Unexpected data at end of file",
error.InvalidFile => "File has invalid format",
error.WrongPassphrase => "Wrong passphrase or corrupted secret key",
error.WrongPublicKey => "Signed with a different public key",
error.NoPassphraseGiven => "Passphrase is required",
error.PassphraseTooLong => "Passphrase is too long",
// XXX: there is probably a better way to do this than re-do strerror() here, yeah?
error.AccessDenied => "Access denied",
error.BadPathName => "Bad path name",
error.BrokenPipe => "Broken pipe",
error.ConnectionResetByPeer => "Connection reset by peer",
error.ConnectionTimedOut => "Connection timed out",
error.DeviceBusy => "Device busy",
error.FileLocksNotSupported => "File locks not supported",
error.FileNotFound => "File not found",
error.FileTooBig => "File too big",
error.InputOutput => "I/O error",
error.InvalidCharacter => "Invalid character",
error.InvalidPadding => "Invalid padding",
error.InvalidUtf8 => "Invalid UTF-8 path",
error.IsDir => "Is a directory",
error.NameTooLong => "Name too long",
error.NoDevice => "No device",
error.NoSpaceLeft => "No space left on device",
error.NotDir => "Not a directory",
error.NotOpenForReading => "Not opened for reading",
error.OperationAborted => "Operation aborted",
error.OutOfMemory => "Out of memory",
error.PathAlreadyExists => "File already exists",
error.PipeBusy => "Pipe busy",
error.ProcessFdQuotaExceeded => "Process fd quota exceeded",
error.SharingViolation => "Sharing violation",
error.SymLinkLoop => "Symlink loop",
error.SystemFdQuotaExceeded => "System fd quota exceeded",
error.SystemResources => "Kernel is out of memory",
error.Unexpected => "Unexpected error?",
error.Unseekable => "Unseekable file",
error.WouldBlock => "Operation would block",
else => return err,
};
print("{s}: {s}\n", .{ file, msg });
return ExitError;
} | zignify.zig |
const RuleSet = @import("./rules.zig").RuleSet;
const Rule = @import("./rules.zig").Rule;
const Attr = @import("./rules.zig").Attr;
pub const rules = RuleSet{
.rules = &[_]Rule{
Rule{
.kind = 0, // light red
.attrs = &[_]Attr{
Attr{ .kind = 1, .n = 1 }, // bright white
Attr{ .kind = 2, .n = 2 }, // muted yellow
},
},
Rule{
.kind = 1, // bright white
.attrs = &[_]Attr{
Attr{ .kind = 4, .n = 1 }, // shiny gold
},
},
Rule{
.kind = 2, // muted yellow
.attrs = &[_]Attr{
Attr{ .kind = 4, .n = 2 }, // shiny gold
Attr{ .kind = 5, .n = 9 }, // faded blue
},
},
Rule{
.kind = 3, // dark orange
.attrs = &[_]Attr{
Attr{ .kind = 1, .n = 3 }, // bright white
Attr{ .kind = 2, .n = 4 }, // muted yellow
},
},
Rule{
.kind = 4, // shiny gold
.attrs = &[_]Attr{
Attr{ .kind = 6, .n = 1 }, // dark olive
Attr{ .kind = 7, .n = 2 }, // vibrant plum
},
},
Rule{
.kind = 5, // faded blue
.attrs = &[_]Attr{},
},
Rule{
.kind = 6, // dark olive
.attrs = &[_]Attr{
Attr{ .kind = 5, .n = 3 }, // faded blue
Attr{ .kind = 8, .n = 4 }, // dotted black
},
},
Rule{
.kind = 7, // vibrant plum
.attrs = &[_]Attr{
Attr{ .kind = 5, .n = 5 }, // faded blue
Attr{ .kind = 8, .n = 6 }, // dotted black
},
},
Rule{
.kind = 8, // dotted black
.attrs = &[_]Attr{},
},
},
.names = &[_][]const u8{
"light red",
"bright white",
"muted yellow",
"dark orange",
"shiny gold",
"faded blue",
"dark olive",
"vibrant plum",
"dotted black",
},
}; | day7/src/sample_rules.zig |
pub fn CompTrie(comptime V: type) type {
const TrieNode = struct {
const Self = @This();
value: ?V = null,
children: [256]?*Self = [_]?*Self{null} ** 256,
};
return struct {
const Self = @This();
root: ?*TrieNode = null,
pub fn put(self: *Self, key: []const u8, value: V) void {
if (self.root == null) {
var rootNode = TrieNode{};
self.root = &rootNode;
}
var node = self.root.?;
for (key) |c| {
if (node.children[c]) |n| {
node = n;
} else {
var trieNode = TrieNode{};
node.children[c] = &trieNode;
node = node.children[c].?;
}
}
node.value = value;
}
pub fn get(self: *const Self, key: []const u8) ?V {
var node: *TrieNode = self.root.?;
for (key) |c| {
if (node.children[c]) |n| {
node = n;
} else {
return null;
}
}
return node.value;
}
};
}
fn buildTestTrie() Trie(u32) {
var trie = Trie(u32){};
trie.put("await", 0);
trie.put("async", 1);
trie.put("awaitable", 2);
trie.put("wait", 3);
return trie;
}
test "Get correctly gets inserted elements" {
const std = @import("std");
const testing = std.testing;
var trie = comptime buildTestTrie();
try testing.expect(trie.get("await") == @as(u32, 0));
try testing.expect(trie.get("async") == @as(u32, 1));
try testing.expect(trie.get("awaitable") == @as(u32, 2));
try testing.expect(trie.get("wait") == @as(u32, 3));
}
test "Get returns null when partial or no match is found" {
const std = @import("std");
const testing = std.testing;
var trie = comptime buildTestTrie();
try testing.expect(trie.get("awit") == null);
try testing.expect(trie.get("asinc") == null);
try testing.expect(trie.get("table") == null);
try testing.expect(trie.get("aws") == null);
} | comptrie.zig |
const util = @import("../sdf_util.zig");
pub const info: util.SdfInfo = .{
.name = "Bezier Curve",
.data_size = @sizeOf(Data),
.function_definition = function_definition,
.enter_command_fn = util.surfaceEnterCommand(Data),
.exit_command_fn = util.surfaceExitCommand(Data, exitCommand),
.append_mat_check_fn = util.surfaceMatCheckCommand(Data),
.sphere_bound_fn = sphereBound,
};
pub const Data = struct {
point_a: util.math.vec3,
point_b: util.math.vec3,
point_c: util.math.vec3,
width_start: f32,
width_end: f32,
mat: usize,
};
// http://research.microsoft.com/en-us/um/people/hoppe/ravg.pdf
const function_definition: []const u8 =
\\vec3 sdBezierGetClosest(vec2 b0, vec2 b1, vec2 b2) {
\\ float a = det(b0, b2);
\\ float b = 2.0 * det(b1, b0);
\\ float d = 2.0 * det(b2, b1);
\\ float f = b * d - a * a;
\\ vec2 d21 = b2 - b1;
\\ vec2 d10 = b1 - b0;
\\ vec2 d20 = b2 - b0;
\\ vec2 gf = 2.0 * (b * d21 + d * d10 + a * d20);
\\ gf = vec2(gf.y, -gf.x);
\\ vec2 pp = -f * gf / dot(gf, gf);
\\ vec2 d0p = b0 - pp;
\\ float ap = det(d0p, d20);
\\ float bp = 2.0 * det(d10, d0p);
\\ float t = clamp((ap + bp) / (2.0 * a + b + d), 0.0, 1.0);
\\ return vec3(mix(mix(b0, b1, t), mix(b1, b2, t), t), t);
\\}
\\
\\float sdBezier(vec3 p, vec3 a, vec3 b, vec3 c, float w0, float wd){
\\ vec3 w = normalize(cross(c - b, a - b));
\\ vec3 u = normalize(c - b);
\\ vec3 v = normalize(cross(w, u));
\\
\\ vec2 a2 = vec2(dot(a - b, u), dot(a - b, v));
\\ vec2 b2 = vec2(0.0);
\\ vec2 c2 = vec2(dot(c - b, u), dot(c - b, v));
\\ vec3 p3 = vec3(dot(p - b, u), dot(p - b, v), dot(p - b, w));
\\
\\ vec3 cp = sdBezierGetClosest(a2 - p3.xy, b2 - p3.xy, c2 - p3.xy);
\\
\\ return sqrt(dot(cp.xy, cp.xy) + p3.z * p3.z) - (w0 + wd * cp.z);
\\}
\\
;
fn exitCommand(data: *Data, enter_index: usize, cur_point_name: []const u8, allocator: util.std.mem.Allocator) []const u8 {
const format: []const u8 = "float d{d} = sdBezier({s}, vec3({d:.5},{d:.5},{d:.5}), vec3({d:.5},{d:.5},{d:.5}), vec3({d:.5},{d:.5},{d:.5}), {d:.5}, {d:.5});";
return util.std.fmt.allocPrint(allocator, format, .{
enter_index,
cur_point_name,
data.point_a[0],
data.point_a[1],
data.point_a[2],
data.point_b[0],
data.point_b[1],
data.point_b[2],
data.point_c[0],
data.point_c[1],
data.point_c[2],
data.width_start,
data.width_end - data.width_start,
}) catch unreachable;
}
fn sphereBound(buffer: *[]u8, bound: *util.math.sphereBound, children: []util.math.sphereBound) void {
_ = children;
const data: *Data = @ptrCast(*Data, @alignCast(@alignOf(Data), buffer.ptr));
bound.* = util.math.SphereBound.merge(
.{
.pos = data.point_a,
.r = data.width_start,
},
.{
.pos = data.point_c,
.r = data.width_end,
},
);
} | src/sdf/surfaces/bezier_curve.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Map = std.AutoHashMap;
const StrMap = std.StringHashMap;
const BitSet = std.DynamicBitSet;
const Str = []const u8;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day06.txt");
pub fn main() !void {
const input: []u8 = blk: {
var iter = tokenize(u8, data, ",\n\r");
var list = std.ArrayList(u8).init(gpa);
while (iter.next()) |s| {
const n = try parseInt(u8, s, 10);
try list.append(n);
}
break :blk list.toOwnedSlice();
};
{ // part 1
var list = std.ArrayList(u8).init(gpa);
for (input) |n| {
try list.append(n);
}
var day: usize = 0; while(day < 80) : (day += 1) {
var additions = std.ArrayList(u8).init(gpa);
for (list.items) |*fish| {
if (fish.* == 0) {
fish.* = 6;
try additions.append(8);
} else {
fish.* -= 1;
}
}
for (additions.items) |new_fish| {
try list.append(new_fish);
}
}
print("{d}\n", .{list.items.len});
}
{ // part 2
// we cannot keep track of each individual fish. There are too many.
// instead, track the number of fish of each age
// set initial fish population
var fish = [_]u64{0} ** 9;
for (input) |n| {
fish[n] += 1;
}
var day: usize = 0; while (day < 256) : (day += 1) {
const new_fish: u64 = fish[0];
fish[0] = fish[1];
fish[1] = fish[2];
fish[2] = fish[3];
fish[3] = fish[4];
fish[4] = fish[5];
fish[5] = fish[6];
fish[6] = fish[7] + new_fish;
fish[7] = fish[8];
fish[8] = new_fish;
}
var sum: u64 = 0;
for (fish) |n| {
sum += n;
}
print("{d}\n", .{sum});
}
}
// Useful stdlib functions
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const indexOf = std.mem.indexOfScalar;
const indexOfAny = std.mem.indexOfAny;
const indexOfStr = std.mem.indexOfPosLinear;
const lastIndexOf = std.mem.lastIndexOfScalar;
const lastIndexOfAny = std.mem.lastIndexOfAny;
const lastIndexOfStr = std.mem.lastIndexOfLinear;
const trim = std.mem.trim;
const sliceMin = std.mem.min;
const sliceMax = std.mem.max;
const parseInt = std.fmt.parseInt;
const parseFloat = std.fmt.parseFloat;
const min = std.math.min;
const min3 = std.math.min3;
const max = std.math.max;
const max3 = std.math.max3;
const print = std.debug.print;
const assert = std.debug.assert;
const sort = std.sort.sort;
const asc = std.sort.asc;
const desc = std.sort.desc; | src/day06.zig |
pub const D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES = @as(u32, 4096);
pub const D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING = @as(u32, 5768);
pub const D3D12_16BIT_INDEX_STRIP_CUT_VALUE = @as(u32, 65535);
pub const D3D12_32BIT_INDEX_STRIP_CUT_VALUE = @as(u32, 4294967295);
pub const D3D12_8BIT_INDEX_STRIP_CUT_VALUE = @as(u32, 255);
pub const D3D12_APPEND_ALIGNED_ELEMENT = @as(u32, 4294967295);
pub const D3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = @as(u32, 9);
pub const D3D12_CLIP_OR_CULL_DISTANCE_COUNT = @as(u32, 8);
pub const D3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = @as(u32, 2);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = @as(u32, 14);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = @as(u32, 4);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = @as(u32, 15);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT = @as(u32, 16);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = @as(u32, 15);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = @as(u32, 1);
pub const D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = @as(u32, 64);
pub const D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = @as(u32, 1);
pub const D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = @as(u32, 128);
pub const D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = @as(u32, 1);
pub const D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = @as(u32, 128);
pub const D3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_COMMONSHADER_SAMPLER_REGISTER_COUNT = @as(u32, 16);
pub const D3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = @as(u32, 1);
pub const D3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_COMMONSHADER_SAMPLER_SLOT_COUNT = @as(u32, 16);
pub const D3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = @as(u32, 32);
pub const D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_COMMONSHADER_TEMP_REGISTER_COUNT = @as(u32, 4096);
pub const D3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = @as(u32, 3);
pub const D3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTS = @as(u32, 3);
pub const D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = @as(u32, 10);
pub const D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = @as(i32, -10);
pub const D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = @as(i32, -8);
pub const D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = @as(u32, 7);
pub const D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT = @as(u32, 256);
pub const D3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 256);
pub const D3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP = @as(u32, 64);
pub const D3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 240);
pub const D3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP = @as(u32, 68);
pub const D3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 224);
pub const D3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP = @as(u32, 72);
pub const D3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 208);
pub const D3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP = @as(u32, 76);
pub const D3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 192);
pub const D3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP = @as(u32, 84);
pub const D3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 176);
pub const D3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP = @as(u32, 92);
pub const D3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 160);
pub const D3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP = @as(u32, 100);
pub const D3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 144);
pub const D3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP = @as(u32, 112);
pub const D3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 128);
pub const D3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP = @as(u32, 128);
pub const D3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 112);
pub const D3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP = @as(u32, 144);
pub const D3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 96);
pub const D3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP = @as(u32, 168);
pub const D3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 80);
pub const D3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP = @as(u32, 204);
pub const D3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 64);
pub const D3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP = @as(u32, 256);
pub const D3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 48);
pub const D3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP = @as(u32, 340);
pub const D3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 32);
pub const D3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP = @as(u32, 512);
pub const D3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = @as(u32, 16);
pub const D3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP = @as(u32, 768);
pub const D3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION = @as(u32, 1);
pub const D3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENT = @as(u32, 256);
pub const D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP = @as(u32, 768);
pub const D3D12_CS_4_X_THREAD_GROUP_MAX_X = @as(u32, 768);
pub const D3D12_CS_4_X_THREAD_GROUP_MAX_Y = @as(u32, 768);
pub const D3D12_CS_4_X_UAV_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION = @as(u32, 65535);
pub const D3D12_CS_TGSM_REGISTER_COUNT = @as(u32, 8192);
pub const D3D12_CS_TGSM_REGISTER_READS_PER_INST = @as(u32, 1);
pub const D3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_CS_THREADGROUPID_REGISTER_COMPONENTS = @as(u32, 3);
pub const D3D12_CS_THREADGROUPID_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTS = @as(u32, 3);
pub const D3D12_CS_THREADIDINGROUP_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_CS_THREADID_REGISTER_COMPONENTS = @as(u32, 3);
pub const D3D12_CS_THREADID_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP = @as(u32, 1024);
pub const D3D12_CS_THREAD_GROUP_MAX_X = @as(u32, 1024);
pub const D3D12_CS_THREAD_GROUP_MAX_Y = @as(u32, 1024);
pub const D3D12_CS_THREAD_GROUP_MAX_Z = @as(u32, 64);
pub const D3D12_CS_THREAD_GROUP_MIN_X = @as(u32, 1);
pub const D3D12_CS_THREAD_GROUP_MIN_Y = @as(u32, 1);
pub const D3D12_CS_THREAD_GROUP_MIN_Z = @as(u32, 1);
pub const D3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOL = @as(u32, 16384);
pub const D3D12_DEFAULT_BLEND_FACTOR_ALPHA = @as(f32, 1);
pub const D3D12_DEFAULT_BLEND_FACTOR_BLUE = @as(f32, 1);
pub const D3D12_DEFAULT_BLEND_FACTOR_GREEN = @as(f32, 1);
pub const D3D12_DEFAULT_BLEND_FACTOR_RED = @as(f32, 1);
pub const D3D12_DEFAULT_BORDER_COLOR_COMPONENT = @as(f32, 0);
pub const D3D12_DEFAULT_DEPTH_BIAS = @as(i32, 0);
pub const D3D12_DEFAULT_DEPTH_BIAS_CLAMP = @as(f32, 0);
pub const D3D12_DEFAULT_MAX_ANISOTROPY = @as(u32, 16);
pub const D3D12_DEFAULT_MIP_LOD_BIAS = @as(f32, 0);
pub const D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = @as(u32, 4194304);
pub const D3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEX = @as(u32, 0);
pub const D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT = @as(u32, 65536);
pub const D3D12_DEFAULT_SAMPLE_MASK = @as(u32, 4294967295);
pub const D3D12_DEFAULT_SCISSOR_ENDX = @as(u32, 0);
pub const D3D12_DEFAULT_SCISSOR_ENDY = @as(u32, 0);
pub const D3D12_DEFAULT_SCISSOR_STARTX = @as(u32, 0);
pub const D3D12_DEFAULT_SCISSOR_STARTY = @as(u32, 0);
pub const D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS = @as(f32, 0);
pub const D3D12_DEFAULT_STENCIL_READ_MASK = @as(u32, 255);
pub const D3D12_DEFAULT_STENCIL_REFERENCE = @as(u32, 0);
pub const D3D12_DEFAULT_STENCIL_WRITE_MASK = @as(u32, 255);
pub const D3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = @as(u32, 0);
pub const D3D12_DEFAULT_VIEWPORT_HEIGHT = @as(u32, 0);
pub const D3D12_DEFAULT_VIEWPORT_MAX_DEPTH = @as(f32, 0);
pub const D3D12_DEFAULT_VIEWPORT_MIN_DEPTH = @as(f32, 0);
pub const D3D12_DEFAULT_VIEWPORT_TOPLEFTX = @as(u32, 0);
pub const D3D12_DEFAULT_VIEWPORT_TOPLEFTY = @as(u32, 0);
pub const D3D12_DEFAULT_VIEWPORT_WIDTH = @as(u32, 0);
pub const D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND = @as(u32, 4294967295);
pub const D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_END = @as(u32, 4294967287);
pub const D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_START = @as(u32, 4294967280);
pub const D3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = @as(u32, 3968);
pub const D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS = @as(u32, 3);
pub const D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_DS_OUTPUT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_DS_OUTPUT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_FLOAT16_FUSED_TOLERANCE_IN_ULP = @as(f64, 6.0e-01);
pub const D3D12_FLOAT32_MAX = @as(f32, 3.4028235e+38);
pub const D3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP = @as(f32, 6.0e-01);
pub const D3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR = @as(f32, 2.4e+00);
pub const D3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATOR = @as(f32, 1);
pub const D3D12_FLOAT_TO_SRGB_OFFSET = @as(f32, 5.5e-02);
pub const D3D12_FLOAT_TO_SRGB_SCALE_1 = @as(f32, 1.292e+01);
pub const D3D12_FLOAT_TO_SRGB_SCALE_2 = @as(f32, 1.055e+00);
pub const D3D12_FLOAT_TO_SRGB_THRESHOLD = @as(f32, 3.1308e-03);
pub const D3D12_FTOI_INSTRUCTION_MAX_INPUT = @as(f32, 2.1474836e+09);
pub const D3D12_FTOI_INSTRUCTION_MIN_INPUT = @as(f32, -2.1474836e+09);
pub const D3D12_FTOU_INSTRUCTION_MAX_INPUT = @as(f32, 4.2949673e+09);
pub const D3D12_FTOU_INSTRUCTION_MIN_INPUT = @as(f32, 0);
pub const D3D12_GS_INPUT_INSTANCE_ID_READS_PER_INST = @as(u32, 2);
pub const D3D12_GS_INPUT_INSTANCE_ID_READ_PORTS = @as(u32, 1);
pub const D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_GS_INPUT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_GS_INPUT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_GS_INPUT_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_GS_INPUT_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_GS_INPUT_REGISTER_VERTICES = @as(u32, 32);
pub const D3D12_GS_MAX_INSTANCE_COUNT = @as(u32, 32);
pub const D3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES = @as(u32, 1024);
pub const D3D12_GS_OUTPUT_ELEMENTS = @as(u32, 32);
pub const D3D12_GS_OUTPUT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_GS_OUTPUT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_HS_CONTROL_POINT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_HS_CONTROL_POINT_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND = @as(u32, 4294967295);
pub const D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND = @as(u32, 4294967295);
pub const D3D12_HS_MAXTESSFACTOR_LOWER_BOUND = @as(f32, 1);
pub const D3D12_HS_MAXTESSFACTOR_UPPER_BOUND = @as(f32, 64);
pub const D3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = @as(u32, 3968);
pub const D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS = @as(u32, 128);
pub const D3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = @as(u32, 0);
pub const D3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGY = @as(u32, 0);
pub const D3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = @as(u32, 0);
pub const D3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = @as(u32, 1);
pub const D3D12_IA_INSTANCE_ID_BIT_COUNT = @as(u32, 32);
pub const D3D12_IA_INTEGER_ARITHMETIC_BIT_COUNT = @as(u32, 32);
pub const D3D12_IA_PATCH_MAX_CONTROL_POINT_COUNT = @as(u32, 32);
pub const D3D12_IA_PRIMITIVE_ID_BIT_COUNT = @as(u32, 32);
pub const D3D12_IA_VERTEX_ID_BIT_COUNT = @as(u32, 32);
pub const D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = @as(u32, 32);
pub const D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = @as(u32, 128);
pub const D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = @as(u32, 32);
pub const D3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = @as(u32, 4294967295);
pub const D3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDER = @as(u32, 4294967295);
pub const D3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = @as(u32, 4294967295);
pub const D3D12_KEEP_UNORDERED_ACCESS_VIEWS = @as(u32, 4294967295);
pub const D3D12_LINEAR_GAMMA = @as(f32, 1);
pub const D3D12_MAJOR_VERSION = @as(u32, 12);
pub const D3D12_MAX_BORDER_COLOR_COMPONENT = @as(f32, 1);
pub const D3D12_MAX_DEPTH = @as(f32, 1);
pub const D3D12_MAX_LIVE_STATIC_SAMPLERS = @as(u32, 2032);
pub const D3D12_MAX_MAXANISOTROPY = @as(u32, 16);
pub const D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT = @as(u32, 32);
pub const D3D12_MAX_POSITION_VALUE = @as(f32, 3.4028236e+34);
pub const D3D12_MAX_ROOT_COST = @as(u32, 64);
pub const D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1 = @as(u32, 1000000);
pub const D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2 = @as(u32, 1000000);
pub const D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE = @as(u32, 2048);
pub const D3D12_MAX_TEXTURE_DIMENSION_2_TO_EXP = @as(u32, 17);
pub const D3D12_MAX_VIEW_INSTANCE_COUNT = @as(u32, 4);
pub const D3D12_MINOR_VERSION = @as(u32, 0);
pub const D3D12_MIN_BORDER_COLOR_COMPONENT = @as(f32, 0);
pub const D3D12_MIN_DEPTH = @as(f32, 0);
pub const D3D12_MIN_MAXANISOTROPY = @as(u32, 0);
pub const D3D12_MIP_LOD_BIAS_MAX = @as(f32, 1.599e+01);
pub const D3D12_MIP_LOD_BIAS_MIN = @as(f32, -16);
pub const D3D12_MIP_LOD_FRACTIONAL_BIT_COUNT = @as(u32, 8);
pub const D3D12_MIP_LOD_RANGE_BIT_COUNT = @as(u32, 8);
pub const D3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTH = @as(f32, 1.4e+00);
pub const D3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = @as(u32, 0);
pub const D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_END = @as(u32, 4294967295);
pub const D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_START = @as(u32, 4294967288);
pub const D3D12_PACKED_TILE = @as(u32, 4294967295);
pub const D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT = @as(u32, 15);
pub const D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = @as(u32, 16);
pub const D3D12_PS_CS_UAV_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_PS_CS_UAV_REGISTER_COUNT = @as(u32, 8);
pub const D3D12_PS_CS_UAV_REGISTER_READS_PER_INST = @as(u32, 1);
pub const D3D12_PS_CS_UAV_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_PS_FRONTFACING_DEFAULT_VALUE = @as(u32, 4294967295);
pub const D3D12_PS_FRONTFACING_FALSE_VALUE = @as(u32, 0);
pub const D3D12_PS_FRONTFACING_TRUE_VALUE = @as(u32, 4294967295);
pub const D3D12_PS_INPUT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_PS_INPUT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_PS_INPUT_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_PS_INPUT_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT = @as(f32, 0);
pub const D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_PS_OUTPUT_DEPTH_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTS = @as(u32, 1);
pub const D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_PS_OUTPUT_MASK_REGISTER_COUNT = @as(u32, 1);
pub const D3D12_PS_OUTPUT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_PS_OUTPUT_REGISTER_COUNT = @as(u32, 8);
pub const D3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT = @as(f32, 5.0e-01);
pub const D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT = @as(u32, 16);
pub const D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT = @as(u32, 8);
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT = @as(u32, 256);
pub const D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT = @as(u32, 16);
pub const D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES = @as(u32, 32);
pub const D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH = @as(u32, 31);
pub const D3D12_RAYTRACING_MAX_GEOMETRIES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = @as(u32, 16777216);
pub const D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE = @as(u32, 16777216);
pub const D3D12_RAYTRACING_MAX_PRIMITIVES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = @as(u32, 536870912);
pub const D3D12_RAYTRACING_MAX_RAY_GENERATION_SHADER_THREADS = @as(u32, 1073741824);
pub const D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE = @as(u32, 4096);
pub const D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT = @as(u32, 32);
pub const D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT = @as(u32, 64);
pub const D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT = @as(u32, 16);
pub const D3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICE = @as(u32, 4096);
pub const D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = @as(u32, 27);
pub const D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = @as(u32, 4096);
pub const D3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE = @as(u32, 4096);
pub const D3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = @as(u32, 32);
pub const D3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = @as(u32, 32);
pub const D3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = @as(u32, 16384);
pub const D3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = @as(u32, 1024);
pub const D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = @as(u32, 4096);
pub const D3D12_REQ_MAXANISOTROPY = @as(u32, 16);
pub const D3D12_REQ_MIP_LEVELS = @as(u32, 15);
pub const D3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = @as(u32, 2048);
pub const D3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE = @as(u32, 4096);
pub const D3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = @as(u32, 16384);
pub const D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM = @as(u32, 128);
pub const D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM = @as(f32, 2.5e-01);
pub const D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM = @as(u32, 2048);
pub const D3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP = @as(u32, 20);
pub const D3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE = @as(u32, 4096);
pub const D3D12_REQ_SUBRESOURCES = @as(u32, 30720);
pub const D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = @as(u32, 2048);
pub const D3D12_REQ_TEXTURE1D_U_DIMENSION = @as(u32, 16384);
pub const D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = @as(u32, 2048);
pub const D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION = @as(u32, 16384);
pub const D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = @as(u32, 2048);
pub const D3D12_REQ_TEXTURECUBE_DIMENSION = @as(u32, 16384);
pub const D3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = @as(u32, 0);
pub const D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES = @as(u32, 4294967295);
pub const D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT = @as(u32, 2);
pub const D3D12_SDK_VERSION = @as(u32, 5);
pub const D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES = @as(u32, 32);
pub const D3D12_SHADER_MAJOR_VERSION = @as(u32, 5);
pub const D3D12_SHADER_MAX_INSTANCES = @as(u32, 65535);
pub const D3D12_SHADER_MAX_INTERFACES = @as(u32, 253);
pub const D3D12_SHADER_MAX_INTERFACE_CALL_SITES = @as(u32, 4096);
pub const D3D12_SHADER_MAX_TYPES = @as(u32, 65535);
pub const D3D12_SHADER_MINOR_VERSION = @as(u32, 1);
pub const D3D12_SHIFT_INSTRUCTION_PAD_VALUE = @as(u32, 0);
pub const D3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = @as(u32, 5);
pub const D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT = @as(u32, 8);
pub const D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = @as(u32, 65536);
pub const D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT = @as(u32, 4096);
pub const D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES = @as(u32, 2048);
pub const D3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = @as(u32, 512);
pub const D3D12_SO_BUFFER_SLOT_COUNT = @as(u32, 4);
pub const D3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAP = @as(u32, 4294967295);
pub const D3D12_SO_NO_RASTERIZED_STREAM = @as(u32, 4294967295);
pub const D3D12_SO_OUTPUT_COMPONENT_COUNT = @as(u32, 128);
pub const D3D12_SO_STREAM_COUNT = @as(u32, 4);
pub const D3D12_SPEC_DATE_DAY = @as(u32, 14);
pub const D3D12_SPEC_DATE_MONTH = @as(u32, 11);
pub const D3D12_SPEC_DATE_YEAR = @as(u32, 2014);
pub const D3D12_SPEC_VERSION = @as(f64, 1.16e+00);
pub const D3D12_SRGB_GAMMA = @as(f32, 2.2e+00);
pub const D3D12_SRGB_TO_FLOAT_DENOMINATOR_1 = @as(f32, 1.292e+01);
pub const D3D12_SRGB_TO_FLOAT_DENOMINATOR_2 = @as(f32, 1.055e+00);
pub const D3D12_SRGB_TO_FLOAT_EXPONENT = @as(f32, 2.4e+00);
pub const D3D12_SRGB_TO_FLOAT_OFFSET = @as(f32, 5.5e-02);
pub const D3D12_SRGB_TO_FLOAT_THRESHOLD = @as(f32, 4.045e-02);
pub const D3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULP = @as(f32, 5.0e-01);
pub const D3D12_STANDARD_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = @as(u32, 64);
pub const D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = @as(u32, 4);
pub const D3D12_STANDARD_PIXEL_COMPONENT_COUNT = @as(u32, 128);
pub const D3D12_STANDARD_PIXEL_ELEMENT_COUNT = @as(u32, 32);
pub const D3D12_STANDARD_VECTOR_SIZE = @as(u32, 4);
pub const D3D12_STANDARD_VERTEX_ELEMENT_COUNT = @as(u32, 32);
pub const D3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = @as(u32, 64);
pub const D3D12_SUBPIXEL_FRACTIONAL_BIT_COUNT = @as(u32, 8);
pub const D3D12_SUBTEXEL_FRACTIONAL_BIT_COUNT = @as(u32, 8);
pub const D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_END = @as(u32, 4294967295);
pub const D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_START = @as(u32, 4294967280);
pub const D3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR = @as(u32, 64);
pub const D3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR = @as(u32, 64);
pub const D3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR = @as(u32, 63);
pub const D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR = @as(u32, 64);
pub const D3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR = @as(u32, 2);
pub const D3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR = @as(u32, 1);
pub const D3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR = @as(u32, 1);
pub const D3D12_TEXEL_ADDRESS_RANGE_BIT_COUNT = @as(u32, 16);
pub const D3D12_TEXTURE_DATA_PITCH_ALIGNMENT = @as(u32, 256);
pub const D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT = @as(u32, 512);
pub const D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES = @as(u32, 65536);
pub const D3D12_TRACKED_WORKLOAD_MAX_INSTANCES = @as(u32, 32);
pub const D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT = @as(u32, 4096);
pub const D3D12_UAV_SLOT_COUNT = @as(u32, 64);
pub const D3D12_UNBOUND_MEMORY_ACCESS_RESULT = @as(u32, 0);
pub const D3D12_VIDEO_DECODE_MAX_ARGUMENTS = @as(u32, 10);
pub const D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS = @as(u32, 4);
pub const D3D12_VIDEO_DECODE_MIN_BITSTREAM_OFFSET_ALIGNMENT = @as(u32, 256);
pub const D3D12_VIDEO_DECODE_MIN_HISTOGRAM_OFFSET_ALIGNMENT = @as(u32, 256);
pub const D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN = @as(u32, 4294967295);
pub const D3D12_VIDEO_PROCESS_MAX_FILTERS = @as(u32, 32);
pub const D3D12_VIDEO_PROCESS_STEREO_VIEWS = @as(u32, 2);
pub const D3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = @as(u32, 15);
pub const D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = @as(u32, 16);
pub const D3D12_VIEWPORT_BOUNDS_MAX = @as(u32, 32767);
pub const D3D12_VIEWPORT_BOUNDS_MIN = @as(i32, -32768);
pub const D3D12_VS_INPUT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_VS_INPUT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_VS_INPUT_REGISTER_READS_PER_INST = @as(u32, 2);
pub const D3D12_VS_INPUT_REGISTER_READ_PORTS = @as(u32, 1);
pub const D3D12_VS_OUTPUT_REGISTER_COMPONENTS = @as(u32, 4);
pub const D3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = @as(u32, 32);
pub const D3D12_VS_OUTPUT_REGISTER_COUNT = @as(u32, 32);
pub const D3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = @as(u32, 10);
pub const D3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = @as(u32, 25);
pub const D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = @as(u32, 25);
pub const D3D12_SHADER_COMPONENT_MAPPING_MASK = @as(u32, 7);
pub const D3D12_SHADER_COMPONENT_MAPPING_SHIFT = @as(u32, 3);
pub const D3D12_FILTER_REDUCTION_TYPE_MASK = @as(u32, 3);
pub const D3D12_FILTER_REDUCTION_TYPE_SHIFT = @as(u32, 7);
pub const D3D12_FILTER_TYPE_MASK = @as(u32, 3);
pub const D3D12_MIN_FILTER_SHIFT = @as(u32, 4);
pub const D3D12_MAG_FILTER_SHIFT = @as(u32, 2);
pub const D3D12_MIP_FILTER_SHIFT = @as(u32, 0);
pub const D3D12_ANISOTROPIC_FILTERING_BIT = @as(u32, 64);
pub const LUID_DEFINED = @as(u32, 1);
pub const D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED = Guid.initString("62b0084e-c70e-4daa-a109-30ff8d5a0482");
pub const CLSID_D3D12Debug = Guid.initString("f2352aeb-dd84-49fe-b97b-a9dcfdcc1b4f");
pub const CLSID_D3D12Tools = Guid.initString("e38216b1-3c8c-4833-aa09-0a06b65d96c8");
pub const CLSID_D3D12DeviceRemovedExtendedData = Guid.initString("4a75bbc4-9ff4-4ad8-9f18-abae84dc5ff2");
pub const CLSID_D3D12SDKConfiguration = Guid.initString("7cda6aca-a03e-49c8-9458-0334d20e07ce");
pub const D3D12_SHADING_RATE_X_AXIS_SHIFT = @as(u32, 2);
pub const D3D12_SHADING_RATE_VALID_MASK = @as(u32, 3);
pub const WKPDID_D3DAutoDebugObjectNameW = Guid.initString("d4902e36-757a-4942-9594-b6769afa43cd");
pub const DXGI_DEBUG_D3D12 = Guid.initString("cf59a98c-a950-4326-91ef-9bbaa17bfd95");
pub const D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT = @as(u32, 1024);
pub const D3D_SHADER_REQUIRES_STENCIL_REF = @as(u32, 512);
pub const D3D_SHADER_REQUIRES_INNER_COVERAGE = @as(u32, 1024);
pub const D3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATS = @as(u32, 2048);
pub const D3D_SHADER_REQUIRES_ROVS = @as(u32, 4096);
pub const D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER = @as(u32, 8192);
pub const D3D_SHADER_REQUIRES_WAVE_OPS = @as(u32, 16384);
pub const D3D_SHADER_REQUIRES_INT64_OPS = @as(u32, 32768);
pub const D3D_SHADER_REQUIRES_VIEW_ID = @as(u32, 65536);
pub const D3D_SHADER_REQUIRES_BARYCENTRICS = @as(u32, 131072);
pub const D3D_SHADER_REQUIRES_NATIVE_16BIT_OPS = @as(u32, 262144);
pub const D3D_SHADER_REQUIRES_SHADING_RATE = @as(u32, 524288);
pub const D3D_SHADER_REQUIRES_RAYTRACING_TIER_1_1 = @as(u32, 1048576);
pub const D3D_SHADER_REQUIRES_SAMPLER_FEEDBACK = @as(u32, 2097152);
pub const D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_TYPED_RESOURCE = @as(u32, 4194304);
pub const D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_GROUP_SHARED = @as(u32, 8388608);
pub const D3D_SHADER_REQUIRES_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS = @as(u32, 16777216);
pub const D3D_SHADER_REQUIRES_RESOURCE_DESCRIPTOR_HEAP_INDEXING = @as(u32, 33554432);
pub const D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING = @as(u32, 67108864);
pub const D3D_SHADER_REQUIRES_WAVE_MMA = @as(u32, 134217728);
pub const D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE = @as(u32, 268435456);
pub const D3D12ExperimentalShaderModels = Guid.initString("76f5573e-f13a-40f5-b297-81ce9e18933f");
pub const D3D12TiledResourceTier4 = Guid.initString("c9c4725f-a81a-4f56-8c5b-c51039d694fb");
pub const D3D12MetaCommand = Guid.initString("c734c97e-8077-48c8-9fdc-d9d1dd31dd77");
//--------------------------------------------------------------------------------
// Section: Types (461)
//--------------------------------------------------------------------------------
pub const D3D12_COMMAND_LIST_TYPE = enum(i32) {
DIRECT = 0,
BUNDLE = 1,
COMPUTE = 2,
COPY = 3,
VIDEO_DECODE = 4,
VIDEO_PROCESS = 5,
VIDEO_ENCODE = 6,
};
pub const D3D12_COMMAND_LIST_TYPE_DIRECT = D3D12_COMMAND_LIST_TYPE.DIRECT;
pub const D3D12_COMMAND_LIST_TYPE_BUNDLE = D3D12_COMMAND_LIST_TYPE.BUNDLE;
pub const D3D12_COMMAND_LIST_TYPE_COMPUTE = D3D12_COMMAND_LIST_TYPE.COMPUTE;
pub const D3D12_COMMAND_LIST_TYPE_COPY = D3D12_COMMAND_LIST_TYPE.COPY;
pub const D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE = D3D12_COMMAND_LIST_TYPE.VIDEO_DECODE;
pub const D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS = D3D12_COMMAND_LIST_TYPE.VIDEO_PROCESS;
pub const D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE = D3D12_COMMAND_LIST_TYPE.VIDEO_ENCODE;
pub const D3D12_COMMAND_QUEUE_FLAGS = enum(u32) {
NONE = 0,
DISABLE_GPU_TIMEOUT = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
DISABLE_GPU_TIMEOUT: u1 = 0,
}) D3D12_COMMAND_QUEUE_FLAGS {
return @intToEnum(D3D12_COMMAND_QUEUE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_COMMAND_QUEUE_FLAGS.NONE) else 0)
| (if (o.DISABLE_GPU_TIMEOUT == 1) @enumToInt(D3D12_COMMAND_QUEUE_FLAGS.DISABLE_GPU_TIMEOUT) else 0)
);
}
};
pub const D3D12_COMMAND_QUEUE_FLAG_NONE = D3D12_COMMAND_QUEUE_FLAGS.NONE;
pub const D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = D3D12_COMMAND_QUEUE_FLAGS.DISABLE_GPU_TIMEOUT;
pub const D3D12_COMMAND_QUEUE_PRIORITY = enum(i32) {
NORMAL = 0,
HIGH = 100,
GLOBAL_REALTIME = 10000,
};
pub const D3D12_COMMAND_QUEUE_PRIORITY_NORMAL = D3D12_COMMAND_QUEUE_PRIORITY.NORMAL;
pub const D3D12_COMMAND_QUEUE_PRIORITY_HIGH = D3D12_COMMAND_QUEUE_PRIORITY.HIGH;
pub const D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME = D3D12_COMMAND_QUEUE_PRIORITY.GLOBAL_REALTIME;
pub const D3D12_COMMAND_QUEUE_DESC = extern struct {
Type: D3D12_COMMAND_LIST_TYPE,
Priority: i32,
Flags: D3D12_COMMAND_QUEUE_FLAGS,
NodeMask: u32,
};
pub const D3D12_PRIMITIVE_TOPOLOGY_TYPE = enum(i32) {
UNDEFINED = 0,
POINT = 1,
LINE = 2,
TRIANGLE = 3,
PATCH = 4,
};
pub const D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED = D3D12_PRIMITIVE_TOPOLOGY_TYPE.UNDEFINED;
pub const D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT = D3D12_PRIMITIVE_TOPOLOGY_TYPE.POINT;
pub const D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE = D3D12_PRIMITIVE_TOPOLOGY_TYPE.LINE;
pub const D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE = D3D12_PRIMITIVE_TOPOLOGY_TYPE.TRIANGLE;
pub const D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH = D3D12_PRIMITIVE_TOPOLOGY_TYPE.PATCH;
pub const D3D12_INPUT_CLASSIFICATION = enum(i32) {
VERTEX_DATA = 0,
INSTANCE_DATA = 1,
};
pub const D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA = D3D12_INPUT_CLASSIFICATION.VERTEX_DATA;
pub const D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA = D3D12_INPUT_CLASSIFICATION.INSTANCE_DATA;
pub const D3D12_INPUT_ELEMENT_DESC = extern struct {
SemanticName: ?[*:0]const u8,
SemanticIndex: u32,
Format: DXGI_FORMAT,
InputSlot: u32,
AlignedByteOffset: u32,
InputSlotClass: D3D12_INPUT_CLASSIFICATION,
InstanceDataStepRate: u32,
};
pub const D3D12_FILL_MODE = enum(i32) {
WIREFRAME = 2,
SOLID = 3,
};
pub const D3D12_FILL_MODE_WIREFRAME = D3D12_FILL_MODE.WIREFRAME;
pub const D3D12_FILL_MODE_SOLID = D3D12_FILL_MODE.SOLID;
pub const D3D12_CULL_MODE = enum(i32) {
NONE = 1,
FRONT = 2,
BACK = 3,
};
pub const D3D12_CULL_MODE_NONE = D3D12_CULL_MODE.NONE;
pub const D3D12_CULL_MODE_FRONT = D3D12_CULL_MODE.FRONT;
pub const D3D12_CULL_MODE_BACK = D3D12_CULL_MODE.BACK;
pub const D3D12_SO_DECLARATION_ENTRY = extern struct {
Stream: u32,
SemanticName: ?[*:0]const u8,
SemanticIndex: u32,
StartComponent: u8,
ComponentCount: u8,
OutputSlot: u8,
};
pub const D3D12_VIEWPORT = extern struct {
TopLeftX: f32,
TopLeftY: f32,
Width: f32,
Height: f32,
MinDepth: f32,
MaxDepth: f32,
};
pub const D3D12_BOX = extern struct {
left: u32,
top: u32,
front: u32,
right: u32,
bottom: u32,
back: u32,
};
pub const D3D12_COMPARISON_FUNC = enum(i32) {
NEVER = 1,
LESS = 2,
EQUAL = 3,
LESS_EQUAL = 4,
GREATER = 5,
NOT_EQUAL = 6,
GREATER_EQUAL = 7,
ALWAYS = 8,
};
pub const D3D12_COMPARISON_FUNC_NEVER = D3D12_COMPARISON_FUNC.NEVER;
pub const D3D12_COMPARISON_FUNC_LESS = D3D12_COMPARISON_FUNC.LESS;
pub const D3D12_COMPARISON_FUNC_EQUAL = D3D12_COMPARISON_FUNC.EQUAL;
pub const D3D12_COMPARISON_FUNC_LESS_EQUAL = D3D12_COMPARISON_FUNC.LESS_EQUAL;
pub const D3D12_COMPARISON_FUNC_GREATER = D3D12_COMPARISON_FUNC.GREATER;
pub const D3D12_COMPARISON_FUNC_NOT_EQUAL = D3D12_COMPARISON_FUNC.NOT_EQUAL;
pub const D3D12_COMPARISON_FUNC_GREATER_EQUAL = D3D12_COMPARISON_FUNC.GREATER_EQUAL;
pub const D3D12_COMPARISON_FUNC_ALWAYS = D3D12_COMPARISON_FUNC.ALWAYS;
pub const D3D12_DEPTH_WRITE_MASK = enum(i32) {
ZERO = 0,
ALL = 1,
};
pub const D3D12_DEPTH_WRITE_MASK_ZERO = D3D12_DEPTH_WRITE_MASK.ZERO;
pub const D3D12_DEPTH_WRITE_MASK_ALL = D3D12_DEPTH_WRITE_MASK.ALL;
pub const D3D12_STENCIL_OP = enum(i32) {
KEEP = 1,
ZERO = 2,
REPLACE = 3,
INCR_SAT = 4,
DECR_SAT = 5,
INVERT = 6,
INCR = 7,
DECR = 8,
};
pub const D3D12_STENCIL_OP_KEEP = D3D12_STENCIL_OP.KEEP;
pub const D3D12_STENCIL_OP_ZERO = D3D12_STENCIL_OP.ZERO;
pub const D3D12_STENCIL_OP_REPLACE = D3D12_STENCIL_OP.REPLACE;
pub const D3D12_STENCIL_OP_INCR_SAT = D3D12_STENCIL_OP.INCR_SAT;
pub const D3D12_STENCIL_OP_DECR_SAT = D3D12_STENCIL_OP.DECR_SAT;
pub const D3D12_STENCIL_OP_INVERT = D3D12_STENCIL_OP.INVERT;
pub const D3D12_STENCIL_OP_INCR = D3D12_STENCIL_OP.INCR;
pub const D3D12_STENCIL_OP_DECR = D3D12_STENCIL_OP.DECR;
pub const D3D12_DEPTH_STENCILOP_DESC = extern struct {
StencilFailOp: D3D12_STENCIL_OP,
StencilDepthFailOp: D3D12_STENCIL_OP,
StencilPassOp: D3D12_STENCIL_OP,
StencilFunc: D3D12_COMPARISON_FUNC,
};
pub const D3D12_DEPTH_STENCIL_DESC = extern struct {
DepthEnable: BOOL,
DepthWriteMask: D3D12_DEPTH_WRITE_MASK,
DepthFunc: D3D12_COMPARISON_FUNC,
StencilEnable: BOOL,
StencilReadMask: u8,
StencilWriteMask: u8,
FrontFace: D3D12_DEPTH_STENCILOP_DESC,
BackFace: D3D12_DEPTH_STENCILOP_DESC,
};
pub const D3D12_DEPTH_STENCIL_DESC1 = extern struct {
DepthEnable: BOOL,
DepthWriteMask: D3D12_DEPTH_WRITE_MASK,
DepthFunc: D3D12_COMPARISON_FUNC,
StencilEnable: BOOL,
StencilReadMask: u8,
StencilWriteMask: u8,
FrontFace: D3D12_DEPTH_STENCILOP_DESC,
BackFace: D3D12_DEPTH_STENCILOP_DESC,
DepthBoundsTestEnable: BOOL,
};
pub const D3D12_BLEND = enum(i32) {
ZERO = 1,
ONE = 2,
SRC_COLOR = 3,
INV_SRC_COLOR = 4,
SRC_ALPHA = 5,
INV_SRC_ALPHA = 6,
DEST_ALPHA = 7,
INV_DEST_ALPHA = 8,
DEST_COLOR = 9,
INV_DEST_COLOR = 10,
SRC_ALPHA_SAT = 11,
BLEND_FACTOR = 14,
INV_BLEND_FACTOR = 15,
SRC1_COLOR = 16,
INV_SRC1_COLOR = 17,
SRC1_ALPHA = 18,
INV_SRC1_ALPHA = 19,
};
pub const D3D12_BLEND_ZERO = D3D12_BLEND.ZERO;
pub const D3D12_BLEND_ONE = D3D12_BLEND.ONE;
pub const D3D12_BLEND_SRC_COLOR = D3D12_BLEND.SRC_COLOR;
pub const D3D12_BLEND_INV_SRC_COLOR = D3D12_BLEND.INV_SRC_COLOR;
pub const D3D12_BLEND_SRC_ALPHA = D3D12_BLEND.SRC_ALPHA;
pub const D3D12_BLEND_INV_SRC_ALPHA = D3D12_BLEND.INV_SRC_ALPHA;
pub const D3D12_BLEND_DEST_ALPHA = D3D12_BLEND.DEST_ALPHA;
pub const D3D12_BLEND_INV_DEST_ALPHA = D3D12_BLEND.INV_DEST_ALPHA;
pub const D3D12_BLEND_DEST_COLOR = D3D12_BLEND.DEST_COLOR;
pub const D3D12_BLEND_INV_DEST_COLOR = D3D12_BLEND.INV_DEST_COLOR;
pub const D3D12_BLEND_SRC_ALPHA_SAT = D3D12_BLEND.SRC_ALPHA_SAT;
pub const D3D12_BLEND_BLEND_FACTOR = D3D12_BLEND.BLEND_FACTOR;
pub const D3D12_BLEND_INV_BLEND_FACTOR = D3D12_BLEND.INV_BLEND_FACTOR;
pub const D3D12_BLEND_SRC1_COLOR = D3D12_BLEND.SRC1_COLOR;
pub const D3D12_BLEND_INV_SRC1_COLOR = D3D12_BLEND.INV_SRC1_COLOR;
pub const D3D12_BLEND_SRC1_ALPHA = D3D12_BLEND.SRC1_ALPHA;
pub const D3D12_BLEND_INV_SRC1_ALPHA = D3D12_BLEND.INV_SRC1_ALPHA;
pub const D3D12_BLEND_OP = enum(i32) {
ADD = 1,
SUBTRACT = 2,
REV_SUBTRACT = 3,
MIN = 4,
MAX = 5,
};
pub const D3D12_BLEND_OP_ADD = D3D12_BLEND_OP.ADD;
pub const D3D12_BLEND_OP_SUBTRACT = D3D12_BLEND_OP.SUBTRACT;
pub const D3D12_BLEND_OP_REV_SUBTRACT = D3D12_BLEND_OP.REV_SUBTRACT;
pub const D3D12_BLEND_OP_MIN = D3D12_BLEND_OP.MIN;
pub const D3D12_BLEND_OP_MAX = D3D12_BLEND_OP.MAX;
pub const D3D12_COLOR_WRITE_ENABLE = enum(i32) {
RED = 1,
GREEN = 2,
BLUE = 4,
ALPHA = 8,
ALL = 15,
};
pub const D3D12_COLOR_WRITE_ENABLE_RED = D3D12_COLOR_WRITE_ENABLE.RED;
pub const D3D12_COLOR_WRITE_ENABLE_GREEN = D3D12_COLOR_WRITE_ENABLE.GREEN;
pub const D3D12_COLOR_WRITE_ENABLE_BLUE = D3D12_COLOR_WRITE_ENABLE.BLUE;
pub const D3D12_COLOR_WRITE_ENABLE_ALPHA = D3D12_COLOR_WRITE_ENABLE.ALPHA;
pub const D3D12_COLOR_WRITE_ENABLE_ALL = D3D12_COLOR_WRITE_ENABLE.ALL;
pub const D3D12_LOGIC_OP = enum(i32) {
CLEAR = 0,
SET = 1,
COPY = 2,
COPY_INVERTED = 3,
NOOP = 4,
INVERT = 5,
AND = 6,
NAND = 7,
OR = 8,
NOR = 9,
XOR = 10,
EQUIV = 11,
AND_REVERSE = 12,
AND_INVERTED = 13,
OR_REVERSE = 14,
OR_INVERTED = 15,
};
pub const D3D12_LOGIC_OP_CLEAR = D3D12_LOGIC_OP.CLEAR;
pub const D3D12_LOGIC_OP_SET = D3D12_LOGIC_OP.SET;
pub const D3D12_LOGIC_OP_COPY = D3D12_LOGIC_OP.COPY;
pub const D3D12_LOGIC_OP_COPY_INVERTED = D3D12_LOGIC_OP.COPY_INVERTED;
pub const D3D12_LOGIC_OP_NOOP = D3D12_LOGIC_OP.NOOP;
pub const D3D12_LOGIC_OP_INVERT = D3D12_LOGIC_OP.INVERT;
pub const D3D12_LOGIC_OP_AND = D3D12_LOGIC_OP.AND;
pub const D3D12_LOGIC_OP_NAND = D3D12_LOGIC_OP.NAND;
pub const D3D12_LOGIC_OP_OR = D3D12_LOGIC_OP.OR;
pub const D3D12_LOGIC_OP_NOR = D3D12_LOGIC_OP.NOR;
pub const D3D12_LOGIC_OP_XOR = D3D12_LOGIC_OP.XOR;
pub const D3D12_LOGIC_OP_EQUIV = D3D12_LOGIC_OP.EQUIV;
pub const D3D12_LOGIC_OP_AND_REVERSE = D3D12_LOGIC_OP.AND_REVERSE;
pub const D3D12_LOGIC_OP_AND_INVERTED = D3D12_LOGIC_OP.AND_INVERTED;
pub const D3D12_LOGIC_OP_OR_REVERSE = D3D12_LOGIC_OP.OR_REVERSE;
pub const D3D12_LOGIC_OP_OR_INVERTED = D3D12_LOGIC_OP.OR_INVERTED;
pub const D3D12_RENDER_TARGET_BLEND_DESC = extern struct {
BlendEnable: BOOL,
LogicOpEnable: BOOL,
SrcBlend: D3D12_BLEND,
DestBlend: D3D12_BLEND,
BlendOp: D3D12_BLEND_OP,
SrcBlendAlpha: D3D12_BLEND,
DestBlendAlpha: D3D12_BLEND,
BlendOpAlpha: D3D12_BLEND_OP,
LogicOp: D3D12_LOGIC_OP,
RenderTargetWriteMask: u8,
};
pub const D3D12_BLEND_DESC = extern struct {
AlphaToCoverageEnable: BOOL,
IndependentBlendEnable: BOOL,
RenderTarget: [8]D3D12_RENDER_TARGET_BLEND_DESC,
};
pub const D3D12_CONSERVATIVE_RASTERIZATION_MODE = enum(i32) {
FF = 0,
N = 1,
};
pub const D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF = D3D12_CONSERVATIVE_RASTERIZATION_MODE.FF;
pub const D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON = D3D12_CONSERVATIVE_RASTERIZATION_MODE.N;
pub const D3D12_RASTERIZER_DESC = extern struct {
FillMode: D3D12_FILL_MODE,
CullMode: D3D12_CULL_MODE,
FrontCounterClockwise: BOOL,
DepthBias: i32,
DepthBiasClamp: f32,
SlopeScaledDepthBias: f32,
DepthClipEnable: BOOL,
MultisampleEnable: BOOL,
AntialiasedLineEnable: BOOL,
ForcedSampleCount: u32,
ConservativeRaster: D3D12_CONSERVATIVE_RASTERIZATION_MODE,
};
const IID_ID3D12Object_Value = Guid.initString("c4fec28f-7966-4e95-9f94-f431cb56c3b8");
pub const IID_ID3D12Object = &IID_ID3D12Object_Value;
pub const ID3D12Object = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetPrivateData: fn(
self: *const ID3D12Object,
guid: ?*const Guid,
pDataSize: ?*u32,
// TODO: what to do with BytesParamIndex 1?
pData: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPrivateData: fn(
self: *const ID3D12Object,
guid: ?*const Guid,
DataSize: u32,
// TODO: what to do with BytesParamIndex 1?
pData: ?*const anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPrivateDataInterface: fn(
self: *const ID3D12Object,
guid: ?*const Guid,
pData: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetName: fn(
self: *const ID3D12Object,
Name: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Object_GetPrivateData(self: *const T, guid: ?*const Guid, pDataSize: ?*u32, pData: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Object.VTable, self.vtable).GetPrivateData(@ptrCast(*const ID3D12Object, self), guid, pDataSize, pData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Object_SetPrivateData(self: *const T, guid: ?*const Guid, DataSize: u32, pData: ?*const anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Object.VTable, self.vtable).SetPrivateData(@ptrCast(*const ID3D12Object, self), guid, DataSize, pData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Object_SetPrivateDataInterface(self: *const T, guid: ?*const Guid, pData: ?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Object.VTable, self.vtable).SetPrivateDataInterface(@ptrCast(*const ID3D12Object, self), guid, pData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Object_SetName(self: *const T, Name: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Object.VTable, self.vtable).SetName(@ptrCast(*const ID3D12Object, self), Name);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DeviceChild_Value = Guid.initString("905db94b-a00c-4140-9df5-2b64ca9ea357");
pub const IID_ID3D12DeviceChild = &IID_ID3D12DeviceChild_Value;
pub const ID3D12DeviceChild = extern struct {
pub const VTable = extern struct {
base: ID3D12Object.VTable,
GetDevice: fn(
self: *const ID3D12DeviceChild,
riid: ?*const Guid,
ppvDevice: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Object.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceChild_GetDevice(self: *const T, riid: ?*const Guid, ppvDevice: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DeviceChild.VTable, self.vtable).GetDevice(@ptrCast(*const ID3D12DeviceChild, self), riid, ppvDevice);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12RootSignature_Value = Guid.initString("c54a6b66-72df-4ee8-8be5-a946a1429214");
pub const IID_ID3D12RootSignature = &IID_ID3D12RootSignature_Value;
pub const ID3D12RootSignature = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceChild.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceChild.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_SHADER_BYTECODE = extern struct {
pShaderBytecode: ?*const anyopaque,
BytecodeLength: usize,
};
pub const D3D12_STREAM_OUTPUT_DESC = extern struct {
pSODeclaration: ?*const D3D12_SO_DECLARATION_ENTRY,
NumEntries: u32,
pBufferStrides: ?*const u32,
NumStrides: u32,
RasterizedStream: u32,
};
pub const D3D12_INPUT_LAYOUT_DESC = extern struct {
pInputElementDescs: ?*const D3D12_INPUT_ELEMENT_DESC,
NumElements: u32,
};
pub const D3D12_INDEX_BUFFER_STRIP_CUT_VALUE = enum(i32) {
DISABLED = 0,
@"0xFFFF" = 1,
@"0xFFFFFFFF" = 2,
};
pub const D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE.DISABLED;
pub const D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE.@"0xFFFF";
pub const D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE.@"0xFFFFFFFF";
pub const D3D12_CACHED_PIPELINE_STATE = extern struct {
pCachedBlob: ?*const anyopaque,
CachedBlobSizeInBytes: usize,
};
pub const D3D12_PIPELINE_STATE_FLAGS = enum(u32) {
NONE = 0,
TOOL_DEBUG = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
TOOL_DEBUG: u1 = 0,
}) D3D12_PIPELINE_STATE_FLAGS {
return @intToEnum(D3D12_PIPELINE_STATE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_PIPELINE_STATE_FLAGS.NONE) else 0)
| (if (o.TOOL_DEBUG == 1) @enumToInt(D3D12_PIPELINE_STATE_FLAGS.TOOL_DEBUG) else 0)
);
}
};
pub const D3D12_PIPELINE_STATE_FLAG_NONE = D3D12_PIPELINE_STATE_FLAGS.NONE;
pub const D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG = D3D12_PIPELINE_STATE_FLAGS.TOOL_DEBUG;
pub const D3D12_GRAPHICS_PIPELINE_STATE_DESC = extern struct {
pRootSignature: ?*ID3D12RootSignature,
VS: D3D12_SHADER_BYTECODE,
PS: D3D12_SHADER_BYTECODE,
DS: D3D12_SHADER_BYTECODE,
HS: D3D12_SHADER_BYTECODE,
GS: D3D12_SHADER_BYTECODE,
StreamOutput: D3D12_STREAM_OUTPUT_DESC,
BlendState: D3D12_BLEND_DESC,
SampleMask: u32,
RasterizerState: D3D12_RASTERIZER_DESC,
DepthStencilState: D3D12_DEPTH_STENCIL_DESC,
InputLayout: D3D12_INPUT_LAYOUT_DESC,
IBStripCutValue: D3D12_INDEX_BUFFER_STRIP_CUT_VALUE,
PrimitiveTopologyType: D3D12_PRIMITIVE_TOPOLOGY_TYPE,
NumRenderTargets: u32,
RTVFormats: [8]DXGI_FORMAT,
DSVFormat: DXGI_FORMAT,
SampleDesc: DXGI_SAMPLE_DESC,
NodeMask: u32,
CachedPSO: D3D12_CACHED_PIPELINE_STATE,
Flags: D3D12_PIPELINE_STATE_FLAGS,
};
pub const D3D12_COMPUTE_PIPELINE_STATE_DESC = extern struct {
pRootSignature: ?*ID3D12RootSignature,
CS: D3D12_SHADER_BYTECODE,
NodeMask: u32,
CachedPSO: D3D12_CACHED_PIPELINE_STATE,
Flags: D3D12_PIPELINE_STATE_FLAGS,
};
pub const D3D12_RT_FORMAT_ARRAY = extern struct {
RTFormats: [8]DXGI_FORMAT,
NumRenderTargets: u32,
};
pub const D3D12_PIPELINE_STATE_STREAM_DESC = extern struct {
SizeInBytes: usize,
pPipelineStateSubobjectStream: ?*anyopaque,
};
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE = enum(i32) {
ROOT_SIGNATURE = 0,
VS = 1,
PS = 2,
DS = 3,
HS = 4,
GS = 5,
CS = 6,
STREAM_OUTPUT = 7,
BLEND = 8,
SAMPLE_MASK = 9,
RASTERIZER = 10,
DEPTH_STENCIL = 11,
INPUT_LAYOUT = 12,
IB_STRIP_CUT_VALUE = 13,
PRIMITIVE_TOPOLOGY = 14,
RENDER_TARGET_FORMATS = 15,
DEPTH_STENCIL_FORMAT = 16,
SAMPLE_DESC = 17,
NODE_MASK = 18,
CACHED_PSO = 19,
FLAGS = 20,
DEPTH_STENCIL1 = 21,
VIEW_INSTANCING = 22,
AS = 24,
MS = 25,
MAX_VALID = 26,
};
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.ROOT_SIGNATURE;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.VS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.PS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.DS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.HS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.GS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.CS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.STREAM_OUTPUT;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.BLEND;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.SAMPLE_MASK;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.RASTERIZER;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.DEPTH_STENCIL;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.INPUT_LAYOUT;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.IB_STRIP_CUT_VALUE;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.PRIMITIVE_TOPOLOGY;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.RENDER_TARGET_FORMATS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.DEPTH_STENCIL_FORMAT;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.SAMPLE_DESC;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.NODE_MASK;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.CACHED_PSO;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.FLAGS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.DEPTH_STENCIL1;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.VIEW_INSTANCING;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.AS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.MS;
pub const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID = D3D12_PIPELINE_STATE_SUBOBJECT_TYPE.MAX_VALID;
pub const D3D12_FEATURE = enum(i32) {
D3D12_OPTIONS = 0,
ARCHITECTURE = 1,
FEATURE_LEVELS = 2,
FORMAT_SUPPORT = 3,
MULTISAMPLE_QUALITY_LEVELS = 4,
FORMAT_INFO = 5,
GPU_VIRTUAL_ADDRESS_SUPPORT = 6,
SHADER_MODEL = 7,
D3D12_OPTIONS1 = 8,
PROTECTED_RESOURCE_SESSION_SUPPORT = 10,
ROOT_SIGNATURE = 12,
ARCHITECTURE1 = 16,
D3D12_OPTIONS2 = 18,
SHADER_CACHE = 19,
COMMAND_QUEUE_PRIORITY = 20,
D3D12_OPTIONS3 = 21,
EXISTING_HEAPS = 22,
D3D12_OPTIONS4 = 23,
SERIALIZATION = 24,
CROSS_NODE = 25,
D3D12_OPTIONS5 = 27,
DISPLAYABLE = 28,
D3D12_OPTIONS6 = 30,
QUERY_META_COMMAND = 31,
D3D12_OPTIONS7 = 32,
PROTECTED_RESOURCE_SESSION_TYPE_COUNT = 33,
PROTECTED_RESOURCE_SESSION_TYPES = 34,
D3D12_OPTIONS8 = 36,
D3D12_OPTIONS9 = 37,
D3D12_OPTIONS10 = 39,
D3D12_OPTIONS11 = 40,
};
pub const D3D12_FEATURE_D3D12_OPTIONS = D3D12_FEATURE.D3D12_OPTIONS;
pub const D3D12_FEATURE_ARCHITECTURE = D3D12_FEATURE.ARCHITECTURE;
pub const D3D12_FEATURE_FEATURE_LEVELS = D3D12_FEATURE.FEATURE_LEVELS;
pub const D3D12_FEATURE_FORMAT_SUPPORT = D3D12_FEATURE.FORMAT_SUPPORT;
pub const D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS = D3D12_FEATURE.MULTISAMPLE_QUALITY_LEVELS;
pub const D3D12_FEATURE_FORMAT_INFO = D3D12_FEATURE.FORMAT_INFO;
pub const D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = D3D12_FEATURE.GPU_VIRTUAL_ADDRESS_SUPPORT;
pub const D3D12_FEATURE_SHADER_MODEL = D3D12_FEATURE.SHADER_MODEL;
pub const D3D12_FEATURE_D3D12_OPTIONS1 = D3D12_FEATURE.D3D12_OPTIONS1;
pub const D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT = D3D12_FEATURE.PROTECTED_RESOURCE_SESSION_SUPPORT;
pub const D3D12_FEATURE_ROOT_SIGNATURE = D3D12_FEATURE.ROOT_SIGNATURE;
pub const D3D12_FEATURE_ARCHITECTURE1 = D3D12_FEATURE.ARCHITECTURE1;
pub const D3D12_FEATURE_D3D12_OPTIONS2 = D3D12_FEATURE.D3D12_OPTIONS2;
pub const D3D12_FEATURE_SHADER_CACHE = D3D12_FEATURE.SHADER_CACHE;
pub const D3D12_FEATURE_COMMAND_QUEUE_PRIORITY = D3D12_FEATURE.COMMAND_QUEUE_PRIORITY;
pub const D3D12_FEATURE_D3D12_OPTIONS3 = D3D12_FEATURE.D3D12_OPTIONS3;
pub const D3D12_FEATURE_EXISTING_HEAPS = D3D12_FEATURE.EXISTING_HEAPS;
pub const D3D12_FEATURE_D3D12_OPTIONS4 = D3D12_FEATURE.D3D12_OPTIONS4;
pub const D3D12_FEATURE_SERIALIZATION = D3D12_FEATURE.SERIALIZATION;
pub const D3D12_FEATURE_CROSS_NODE = D3D12_FEATURE.CROSS_NODE;
pub const D3D12_FEATURE_D3D12_OPTIONS5 = D3D12_FEATURE.D3D12_OPTIONS5;
pub const D3D12_FEATURE_DISPLAYABLE = D3D12_FEATURE.DISPLAYABLE;
pub const D3D12_FEATURE_D3D12_OPTIONS6 = D3D12_FEATURE.D3D12_OPTIONS6;
pub const D3D12_FEATURE_QUERY_META_COMMAND = D3D12_FEATURE.QUERY_META_COMMAND;
pub const D3D12_FEATURE_D3D12_OPTIONS7 = D3D12_FEATURE.D3D12_OPTIONS7;
pub const D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT = D3D12_FEATURE.PROTECTED_RESOURCE_SESSION_TYPE_COUNT;
pub const D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES = D3D12_FEATURE.PROTECTED_RESOURCE_SESSION_TYPES;
pub const D3D12_FEATURE_D3D12_OPTIONS8 = D3D12_FEATURE.D3D12_OPTIONS8;
pub const D3D12_FEATURE_D3D12_OPTIONS9 = D3D12_FEATURE.D3D12_OPTIONS9;
pub const D3D12_FEATURE_D3D12_OPTIONS10 = D3D12_FEATURE.D3D12_OPTIONS10;
pub const D3D12_FEATURE_D3D12_OPTIONS11 = D3D12_FEATURE.D3D12_OPTIONS11;
pub const D3D12_SHADER_MIN_PRECISION_SUPPORT = enum(u32) {
NONE = 0,
@"10_BIT" = 1,
@"16_BIT" = 2,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
@"10_BIT": u1 = 0,
@"16_BIT": u1 = 0,
}) D3D12_SHADER_MIN_PRECISION_SUPPORT {
return @intToEnum(D3D12_SHADER_MIN_PRECISION_SUPPORT,
(if (o.NONE == 1) @enumToInt(D3D12_SHADER_MIN_PRECISION_SUPPORT.NONE) else 0)
| (if (o.@"10_BIT" == 1) @enumToInt(D3D12_SHADER_MIN_PRECISION_SUPPORT.@"10_BIT") else 0)
| (if (o.@"16_BIT" == 1) @enumToInt(D3D12_SHADER_MIN_PRECISION_SUPPORT.@"16_BIT") else 0)
);
}
};
pub const D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE = D3D12_SHADER_MIN_PRECISION_SUPPORT.NONE;
pub const D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT = D3D12_SHADER_MIN_PRECISION_SUPPORT.@"10_BIT";
pub const D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = D3D12_SHADER_MIN_PRECISION_SUPPORT.@"16_BIT";
pub const D3D12_TILED_RESOURCES_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1" = 1,
@"2" = 2,
@"3" = 3,
@"4" = 4,
};
pub const D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED = D3D12_TILED_RESOURCES_TIER.NOT_SUPPORTED;
pub const D3D12_TILED_RESOURCES_TIER_1 = D3D12_TILED_RESOURCES_TIER.@"1";
pub const D3D12_TILED_RESOURCES_TIER_2 = D3D12_TILED_RESOURCES_TIER.@"2";
pub const D3D12_TILED_RESOURCES_TIER_3 = D3D12_TILED_RESOURCES_TIER.@"3";
pub const D3D12_TILED_RESOURCES_TIER_4 = D3D12_TILED_RESOURCES_TIER.@"4";
pub const D3D12_RESOURCE_BINDING_TIER = enum(i32) {
@"1" = 1,
@"2" = 2,
@"3" = 3,
};
pub const D3D12_RESOURCE_BINDING_TIER_1 = D3D12_RESOURCE_BINDING_TIER.@"1";
pub const D3D12_RESOURCE_BINDING_TIER_2 = D3D12_RESOURCE_BINDING_TIER.@"2";
pub const D3D12_RESOURCE_BINDING_TIER_3 = D3D12_RESOURCE_BINDING_TIER.@"3";
pub const D3D12_CONSERVATIVE_RASTERIZATION_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1" = 1,
@"2" = 2,
@"3" = 3,
};
pub const D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED = D3D12_CONSERVATIVE_RASTERIZATION_TIER.NOT_SUPPORTED;
pub const D3D12_CONSERVATIVE_RASTERIZATION_TIER_1 = D3D12_CONSERVATIVE_RASTERIZATION_TIER.@"1";
pub const D3D12_CONSERVATIVE_RASTERIZATION_TIER_2 = D3D12_CONSERVATIVE_RASTERIZATION_TIER.@"2";
pub const D3D12_CONSERVATIVE_RASTERIZATION_TIER_3 = D3D12_CONSERVATIVE_RASTERIZATION_TIER.@"3";
pub const D3D12_FORMAT_SUPPORT1 = enum(u32) {
NONE = 0,
BUFFER = 1,
IA_VERTEX_BUFFER = 2,
IA_INDEX_BUFFER = 4,
SO_BUFFER = 8,
TEXTURE1D = 16,
TEXTURE2D = 32,
TEXTURE3D = 64,
TEXTURECUBE = 128,
SHADER_LOAD = 256,
SHADER_SAMPLE = 512,
SHADER_SAMPLE_COMPARISON = 1024,
SHADER_SAMPLE_MONO_TEXT = 2048,
MIP = 4096,
RENDER_TARGET = 16384,
BLENDABLE = 32768,
DEPTH_STENCIL = 65536,
MULTISAMPLE_RESOLVE = 262144,
DISPLAY = 524288,
CAST_WITHIN_BIT_LAYOUT = 1048576,
MULTISAMPLE_RENDERTARGET = 2097152,
MULTISAMPLE_LOAD = 4194304,
SHADER_GATHER = 8388608,
BACK_BUFFER_CAST = 16777216,
TYPED_UNORDERED_ACCESS_VIEW = 33554432,
SHADER_GATHER_COMPARISON = 67108864,
DECODER_OUTPUT = 134217728,
VIDEO_PROCESSOR_OUTPUT = 268435456,
VIDEO_PROCESSOR_INPUT = 536870912,
VIDEO_ENCODER = 1073741824,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
BUFFER: u1 = 0,
IA_VERTEX_BUFFER: u1 = 0,
IA_INDEX_BUFFER: u1 = 0,
SO_BUFFER: u1 = 0,
TEXTURE1D: u1 = 0,
TEXTURE2D: u1 = 0,
TEXTURE3D: u1 = 0,
TEXTURECUBE: u1 = 0,
SHADER_LOAD: u1 = 0,
SHADER_SAMPLE: u1 = 0,
SHADER_SAMPLE_COMPARISON: u1 = 0,
SHADER_SAMPLE_MONO_TEXT: u1 = 0,
MIP: u1 = 0,
RENDER_TARGET: u1 = 0,
BLENDABLE: u1 = 0,
DEPTH_STENCIL: u1 = 0,
MULTISAMPLE_RESOLVE: u1 = 0,
DISPLAY: u1 = 0,
CAST_WITHIN_BIT_LAYOUT: u1 = 0,
MULTISAMPLE_RENDERTARGET: u1 = 0,
MULTISAMPLE_LOAD: u1 = 0,
SHADER_GATHER: u1 = 0,
BACK_BUFFER_CAST: u1 = 0,
TYPED_UNORDERED_ACCESS_VIEW: u1 = 0,
SHADER_GATHER_COMPARISON: u1 = 0,
DECODER_OUTPUT: u1 = 0,
VIDEO_PROCESSOR_OUTPUT: u1 = 0,
VIDEO_PROCESSOR_INPUT: u1 = 0,
VIDEO_ENCODER: u1 = 0,
}) D3D12_FORMAT_SUPPORT1 {
return @intToEnum(D3D12_FORMAT_SUPPORT1,
(if (o.NONE == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.NONE) else 0)
| (if (o.BUFFER == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.BUFFER) else 0)
| (if (o.IA_VERTEX_BUFFER == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.IA_VERTEX_BUFFER) else 0)
| (if (o.IA_INDEX_BUFFER == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.IA_INDEX_BUFFER) else 0)
| (if (o.SO_BUFFER == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.SO_BUFFER) else 0)
| (if (o.TEXTURE1D == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.TEXTURE1D) else 0)
| (if (o.TEXTURE2D == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.TEXTURE2D) else 0)
| (if (o.TEXTURE3D == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.TEXTURE3D) else 0)
| (if (o.TEXTURECUBE == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.TEXTURECUBE) else 0)
| (if (o.SHADER_LOAD == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.SHADER_LOAD) else 0)
| (if (o.SHADER_SAMPLE == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.SHADER_SAMPLE) else 0)
| (if (o.SHADER_SAMPLE_COMPARISON == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.SHADER_SAMPLE_COMPARISON) else 0)
| (if (o.SHADER_SAMPLE_MONO_TEXT == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.SHADER_SAMPLE_MONO_TEXT) else 0)
| (if (o.MIP == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.MIP) else 0)
| (if (o.RENDER_TARGET == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.RENDER_TARGET) else 0)
| (if (o.BLENDABLE == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.BLENDABLE) else 0)
| (if (o.DEPTH_STENCIL == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.DEPTH_STENCIL) else 0)
| (if (o.MULTISAMPLE_RESOLVE == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.MULTISAMPLE_RESOLVE) else 0)
| (if (o.DISPLAY == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.DISPLAY) else 0)
| (if (o.CAST_WITHIN_BIT_LAYOUT == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.CAST_WITHIN_BIT_LAYOUT) else 0)
| (if (o.MULTISAMPLE_RENDERTARGET == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.MULTISAMPLE_RENDERTARGET) else 0)
| (if (o.MULTISAMPLE_LOAD == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.MULTISAMPLE_LOAD) else 0)
| (if (o.SHADER_GATHER == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.SHADER_GATHER) else 0)
| (if (o.BACK_BUFFER_CAST == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.BACK_BUFFER_CAST) else 0)
| (if (o.TYPED_UNORDERED_ACCESS_VIEW == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.TYPED_UNORDERED_ACCESS_VIEW) else 0)
| (if (o.SHADER_GATHER_COMPARISON == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.SHADER_GATHER_COMPARISON) else 0)
| (if (o.DECODER_OUTPUT == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.DECODER_OUTPUT) else 0)
| (if (o.VIDEO_PROCESSOR_OUTPUT == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.VIDEO_PROCESSOR_OUTPUT) else 0)
| (if (o.VIDEO_PROCESSOR_INPUT == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.VIDEO_PROCESSOR_INPUT) else 0)
| (if (o.VIDEO_ENCODER == 1) @enumToInt(D3D12_FORMAT_SUPPORT1.VIDEO_ENCODER) else 0)
);
}
};
pub const D3D12_FORMAT_SUPPORT1_NONE = D3D12_FORMAT_SUPPORT1.NONE;
pub const D3D12_FORMAT_SUPPORT1_BUFFER = D3D12_FORMAT_SUPPORT1.BUFFER;
pub const D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER = D3D12_FORMAT_SUPPORT1.IA_VERTEX_BUFFER;
pub const D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER = D3D12_FORMAT_SUPPORT1.IA_INDEX_BUFFER;
pub const D3D12_FORMAT_SUPPORT1_SO_BUFFER = D3D12_FORMAT_SUPPORT1.SO_BUFFER;
pub const D3D12_FORMAT_SUPPORT1_TEXTURE1D = D3D12_FORMAT_SUPPORT1.TEXTURE1D;
pub const D3D12_FORMAT_SUPPORT1_TEXTURE2D = D3D12_FORMAT_SUPPORT1.TEXTURE2D;
pub const D3D12_FORMAT_SUPPORT1_TEXTURE3D = D3D12_FORMAT_SUPPORT1.TEXTURE3D;
pub const D3D12_FORMAT_SUPPORT1_TEXTURECUBE = D3D12_FORMAT_SUPPORT1.TEXTURECUBE;
pub const D3D12_FORMAT_SUPPORT1_SHADER_LOAD = D3D12_FORMAT_SUPPORT1.SHADER_LOAD;
pub const D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE = D3D12_FORMAT_SUPPORT1.SHADER_SAMPLE;
pub const D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON = D3D12_FORMAT_SUPPORT1.SHADER_SAMPLE_COMPARISON;
pub const D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_MONO_TEXT = D3D12_FORMAT_SUPPORT1.SHADER_SAMPLE_MONO_TEXT;
pub const D3D12_FORMAT_SUPPORT1_MIP = D3D12_FORMAT_SUPPORT1.MIP;
pub const D3D12_FORMAT_SUPPORT1_RENDER_TARGET = D3D12_FORMAT_SUPPORT1.RENDER_TARGET;
pub const D3D12_FORMAT_SUPPORT1_BLENDABLE = D3D12_FORMAT_SUPPORT1.BLENDABLE;
pub const D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL = D3D12_FORMAT_SUPPORT1.DEPTH_STENCIL;
pub const D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE = D3D12_FORMAT_SUPPORT1.MULTISAMPLE_RESOLVE;
pub const D3D12_FORMAT_SUPPORT1_DISPLAY = D3D12_FORMAT_SUPPORT1.DISPLAY;
pub const D3D12_FORMAT_SUPPORT1_CAST_WITHIN_BIT_LAYOUT = D3D12_FORMAT_SUPPORT1.CAST_WITHIN_BIT_LAYOUT;
pub const D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET = D3D12_FORMAT_SUPPORT1.MULTISAMPLE_RENDERTARGET;
pub const D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD = D3D12_FORMAT_SUPPORT1.MULTISAMPLE_LOAD;
pub const D3D12_FORMAT_SUPPORT1_SHADER_GATHER = D3D12_FORMAT_SUPPORT1.SHADER_GATHER;
pub const D3D12_FORMAT_SUPPORT1_BACK_BUFFER_CAST = D3D12_FORMAT_SUPPORT1.BACK_BUFFER_CAST;
pub const D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW = D3D12_FORMAT_SUPPORT1.TYPED_UNORDERED_ACCESS_VIEW;
pub const D3D12_FORMAT_SUPPORT1_SHADER_GATHER_COMPARISON = D3D12_FORMAT_SUPPORT1.SHADER_GATHER_COMPARISON;
pub const D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT = D3D12_FORMAT_SUPPORT1.DECODER_OUTPUT;
pub const D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_OUTPUT = D3D12_FORMAT_SUPPORT1.VIDEO_PROCESSOR_OUTPUT;
pub const D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT = D3D12_FORMAT_SUPPORT1.VIDEO_PROCESSOR_INPUT;
pub const D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER = D3D12_FORMAT_SUPPORT1.VIDEO_ENCODER;
pub const D3D12_FORMAT_SUPPORT2 = enum(u32) {
NONE = 0,
UAV_ATOMIC_ADD = 1,
UAV_ATOMIC_BITWISE_OPS = 2,
UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 4,
UAV_ATOMIC_EXCHANGE = 8,
UAV_ATOMIC_SIGNED_MIN_OR_MAX = 16,
UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = 32,
UAV_TYPED_LOAD = 64,
UAV_TYPED_STORE = 128,
OUTPUT_MERGER_LOGIC_OP = 256,
TILED = 512,
MULTIPLANE_OVERLAY = 16384,
SAMPLER_FEEDBACK = 32768,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
UAV_ATOMIC_ADD: u1 = 0,
UAV_ATOMIC_BITWISE_OPS: u1 = 0,
UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE: u1 = 0,
UAV_ATOMIC_EXCHANGE: u1 = 0,
UAV_ATOMIC_SIGNED_MIN_OR_MAX: u1 = 0,
UAV_ATOMIC_UNSIGNED_MIN_OR_MAX: u1 = 0,
UAV_TYPED_LOAD: u1 = 0,
UAV_TYPED_STORE: u1 = 0,
OUTPUT_MERGER_LOGIC_OP: u1 = 0,
TILED: u1 = 0,
MULTIPLANE_OVERLAY: u1 = 0,
SAMPLER_FEEDBACK: u1 = 0,
}) D3D12_FORMAT_SUPPORT2 {
return @intToEnum(D3D12_FORMAT_SUPPORT2,
(if (o.NONE == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.NONE) else 0)
| (if (o.UAV_ATOMIC_ADD == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_ADD) else 0)
| (if (o.UAV_ATOMIC_BITWISE_OPS == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_BITWISE_OPS) else 0)
| (if (o.UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE) else 0)
| (if (o.UAV_ATOMIC_EXCHANGE == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_EXCHANGE) else 0)
| (if (o.UAV_ATOMIC_SIGNED_MIN_OR_MAX == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_SIGNED_MIN_OR_MAX) else 0)
| (if (o.UAV_ATOMIC_UNSIGNED_MIN_OR_MAX == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_UNSIGNED_MIN_OR_MAX) else 0)
| (if (o.UAV_TYPED_LOAD == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.UAV_TYPED_LOAD) else 0)
| (if (o.UAV_TYPED_STORE == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.UAV_TYPED_STORE) else 0)
| (if (o.OUTPUT_MERGER_LOGIC_OP == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.OUTPUT_MERGER_LOGIC_OP) else 0)
| (if (o.TILED == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.TILED) else 0)
| (if (o.MULTIPLANE_OVERLAY == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.MULTIPLANE_OVERLAY) else 0)
| (if (o.SAMPLER_FEEDBACK == 1) @enumToInt(D3D12_FORMAT_SUPPORT2.SAMPLER_FEEDBACK) else 0)
);
}
};
pub const D3D12_FORMAT_SUPPORT2_NONE = D3D12_FORMAT_SUPPORT2.NONE;
pub const D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD = D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_ADD;
pub const D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS = D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_BITWISE_OPS;
pub const D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE;
pub const D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE = D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_EXCHANGE;
pub const D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX = D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_SIGNED_MIN_OR_MAX;
pub const D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = D3D12_FORMAT_SUPPORT2.UAV_ATOMIC_UNSIGNED_MIN_OR_MAX;
pub const D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD = D3D12_FORMAT_SUPPORT2.UAV_TYPED_LOAD;
pub const D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE = D3D12_FORMAT_SUPPORT2.UAV_TYPED_STORE;
pub const D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = D3D12_FORMAT_SUPPORT2.OUTPUT_MERGER_LOGIC_OP;
pub const D3D12_FORMAT_SUPPORT2_TILED = D3D12_FORMAT_SUPPORT2.TILED;
pub const D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = D3D12_FORMAT_SUPPORT2.MULTIPLANE_OVERLAY;
pub const D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK = D3D12_FORMAT_SUPPORT2.SAMPLER_FEEDBACK;
pub const D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS = enum(u32) {
NONE = 0,
TILED_RESOURCE = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
TILED_RESOURCE: u1 = 0,
}) D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS {
return @intToEnum(D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS.NONE) else 0)
| (if (o.TILED_RESOURCE == 1) @enumToInt(D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS.TILED_RESOURCE) else 0)
);
}
};
pub const D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE = D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS.NONE;
pub const D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS.TILED_RESOURCE;
pub const D3D12_CROSS_NODE_SHARING_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1_EMULATED" = 1,
@"1" = 2,
@"2" = 3,
@"3" = 4,
};
pub const D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED = D3D12_CROSS_NODE_SHARING_TIER.NOT_SUPPORTED;
pub const D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED = D3D12_CROSS_NODE_SHARING_TIER.@"1_EMULATED";
pub const D3D12_CROSS_NODE_SHARING_TIER_1 = D3D12_CROSS_NODE_SHARING_TIER.@"1";
pub const D3D12_CROSS_NODE_SHARING_TIER_2 = D3D12_CROSS_NODE_SHARING_TIER.@"2";
pub const D3D12_CROSS_NODE_SHARING_TIER_3 = D3D12_CROSS_NODE_SHARING_TIER.@"3";
pub const D3D12_RESOURCE_HEAP_TIER = enum(i32) {
@"1" = 1,
@"2" = 2,
};
pub const D3D12_RESOURCE_HEAP_TIER_1 = D3D12_RESOURCE_HEAP_TIER.@"1";
pub const D3D12_RESOURCE_HEAP_TIER_2 = D3D12_RESOURCE_HEAP_TIER.@"2";
pub const D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1" = 1,
@"2" = 2,
};
pub const D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER.NOT_SUPPORTED;
pub const D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1 = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER.@"1";
pub const D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2 = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER.@"2";
pub const D3D12_VIEW_INSTANCING_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1" = 1,
@"2" = 2,
@"3" = 3,
};
pub const D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED = D3D12_VIEW_INSTANCING_TIER.NOT_SUPPORTED;
pub const D3D12_VIEW_INSTANCING_TIER_1 = D3D12_VIEW_INSTANCING_TIER.@"1";
pub const D3D12_VIEW_INSTANCING_TIER_2 = D3D12_VIEW_INSTANCING_TIER.@"2";
pub const D3D12_VIEW_INSTANCING_TIER_3 = D3D12_VIEW_INSTANCING_TIER.@"3";
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS = extern struct {
DoublePrecisionFloatShaderOps: BOOL,
OutputMergerLogicOp: BOOL,
MinPrecisionSupport: D3D12_SHADER_MIN_PRECISION_SUPPORT,
TiledResourcesTier: D3D12_TILED_RESOURCES_TIER,
ResourceBindingTier: D3D12_RESOURCE_BINDING_TIER,
PSSpecifiedStencilRefSupported: BOOL,
TypedUAVLoadAdditionalFormats: BOOL,
ROVsSupported: BOOL,
ConservativeRasterizationTier: D3D12_CONSERVATIVE_RASTERIZATION_TIER,
MaxGPUVirtualAddressBitsPerResource: u32,
StandardSwizzle64KBSupported: BOOL,
CrossNodeSharingTier: D3D12_CROSS_NODE_SHARING_TIER,
CrossAdapterRowMajorTextureSupported: BOOL,
VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation: BOOL,
ResourceHeapTier: D3D12_RESOURCE_HEAP_TIER,
};
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS1 = extern struct {
WaveOps: BOOL,
WaveLaneCountMin: u32,
WaveLaneCountMax: u32,
TotalLaneCount: u32,
ExpandedComputeResourceStates: BOOL,
Int64ShaderOps: BOOL,
};
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS2 = extern struct {
DepthBoundsTestSupported: BOOL,
ProgrammableSamplePositionsTier: D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER,
};
pub const D3D_ROOT_SIGNATURE_VERSION = enum(i32) {
@"1" = 1,
// _0 = 1, this enum value conflicts with @"1"
_1 = 2,
};
pub const D3D_ROOT_SIGNATURE_VERSION_1 = D3D_ROOT_SIGNATURE_VERSION.@"1";
pub const D3D_ROOT_SIGNATURE_VERSION_1_0 = D3D_ROOT_SIGNATURE_VERSION.@"1";
pub const D3D_ROOT_SIGNATURE_VERSION_1_1 = D3D_ROOT_SIGNATURE_VERSION._1;
pub const D3D12_FEATURE_DATA_ROOT_SIGNATURE = extern struct {
HighestVersion: D3D_ROOT_SIGNATURE_VERSION,
};
pub const D3D12_FEATURE_DATA_ARCHITECTURE = extern struct {
NodeIndex: u32,
TileBasedRenderer: BOOL,
UMA: BOOL,
CacheCoherentUMA: BOOL,
};
pub const D3D12_FEATURE_DATA_ARCHITECTURE1 = extern struct {
NodeIndex: u32,
TileBasedRenderer: BOOL,
UMA: BOOL,
CacheCoherentUMA: BOOL,
IsolatedMMU: BOOL,
};
pub const D3D12_FEATURE_DATA_FEATURE_LEVELS = extern struct {
NumFeatureLevels: u32,
pFeatureLevelsRequested: ?*const D3D_FEATURE_LEVEL,
MaxSupportedFeatureLevel: D3D_FEATURE_LEVEL,
};
pub const D3D_SHADER_MODEL = enum(i32) {
@"5_1" = 81,
@"6_0" = 96,
@"6_1" = 97,
@"6_2" = 98,
@"6_3" = 99,
@"6_4" = 100,
@"6_5" = 101,
@"6_6" = 102,
@"6_7" = 103,
};
pub const D3D_SHADER_MODEL_5_1 = D3D_SHADER_MODEL.@"5_1";
pub const D3D_SHADER_MODEL_6_0 = D3D_SHADER_MODEL.@"6_0";
pub const D3D_SHADER_MODEL_6_1 = D3D_SHADER_MODEL.@"6_1";
pub const D3D_SHADER_MODEL_6_2 = D3D_SHADER_MODEL.@"6_2";
pub const D3D_SHADER_MODEL_6_3 = D3D_SHADER_MODEL.@"6_3";
pub const D3D_SHADER_MODEL_6_4 = D3D_SHADER_MODEL.@"6_4";
pub const D3D_SHADER_MODEL_6_5 = D3D_SHADER_MODEL.@"6_5";
pub const D3D_SHADER_MODEL_6_6 = D3D_SHADER_MODEL.@"6_6";
pub const D3D_SHADER_MODEL_6_7 = D3D_SHADER_MODEL.@"6_7";
pub const D3D12_FEATURE_DATA_SHADER_MODEL = extern struct {
HighestShaderModel: D3D_SHADER_MODEL,
};
pub const D3D12_FEATURE_DATA_FORMAT_SUPPORT = extern struct {
Format: DXGI_FORMAT,
Support1: D3D12_FORMAT_SUPPORT1,
Support2: D3D12_FORMAT_SUPPORT2,
};
pub const D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS = extern struct {
Format: DXGI_FORMAT,
SampleCount: u32,
Flags: D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS,
NumQualityLevels: u32,
};
pub const D3D12_FEATURE_DATA_FORMAT_INFO = extern struct {
Format: DXGI_FORMAT,
PlaneCount: u8,
};
pub const D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT = extern struct {
MaxGPUVirtualAddressBitsPerResource: u32,
MaxGPUVirtualAddressBitsPerProcess: u32,
};
pub const D3D12_SHADER_CACHE_SUPPORT_FLAGS = enum(u32) {
NONE = 0,
SINGLE_PSO = 1,
LIBRARY = 2,
AUTOMATIC_INPROC_CACHE = 4,
AUTOMATIC_DISK_CACHE = 8,
DRIVER_MANAGED_CACHE = 16,
SHADER_CONTROL_CLEAR = 32,
SHADER_SESSION_DELETE = 64,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
SINGLE_PSO: u1 = 0,
LIBRARY: u1 = 0,
AUTOMATIC_INPROC_CACHE: u1 = 0,
AUTOMATIC_DISK_CACHE: u1 = 0,
DRIVER_MANAGED_CACHE: u1 = 0,
SHADER_CONTROL_CLEAR: u1 = 0,
SHADER_SESSION_DELETE: u1 = 0,
}) D3D12_SHADER_CACHE_SUPPORT_FLAGS {
return @intToEnum(D3D12_SHADER_CACHE_SUPPORT_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_SHADER_CACHE_SUPPORT_FLAGS.NONE) else 0)
| (if (o.SINGLE_PSO == 1) @enumToInt(D3D12_SHADER_CACHE_SUPPORT_FLAGS.SINGLE_PSO) else 0)
| (if (o.LIBRARY == 1) @enumToInt(D3D12_SHADER_CACHE_SUPPORT_FLAGS.LIBRARY) else 0)
| (if (o.AUTOMATIC_INPROC_CACHE == 1) @enumToInt(D3D12_SHADER_CACHE_SUPPORT_FLAGS.AUTOMATIC_INPROC_CACHE) else 0)
| (if (o.AUTOMATIC_DISK_CACHE == 1) @enumToInt(D3D12_SHADER_CACHE_SUPPORT_FLAGS.AUTOMATIC_DISK_CACHE) else 0)
| (if (o.DRIVER_MANAGED_CACHE == 1) @enumToInt(D3D12_SHADER_CACHE_SUPPORT_FLAGS.DRIVER_MANAGED_CACHE) else 0)
| (if (o.SHADER_CONTROL_CLEAR == 1) @enumToInt(D3D12_SHADER_CACHE_SUPPORT_FLAGS.SHADER_CONTROL_CLEAR) else 0)
| (if (o.SHADER_SESSION_DELETE == 1) @enumToInt(D3D12_SHADER_CACHE_SUPPORT_FLAGS.SHADER_SESSION_DELETE) else 0)
);
}
};
pub const D3D12_SHADER_CACHE_SUPPORT_NONE = D3D12_SHADER_CACHE_SUPPORT_FLAGS.NONE;
pub const D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO = D3D12_SHADER_CACHE_SUPPORT_FLAGS.SINGLE_PSO;
pub const D3D12_SHADER_CACHE_SUPPORT_LIBRARY = D3D12_SHADER_CACHE_SUPPORT_FLAGS.LIBRARY;
pub const D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = D3D12_SHADER_CACHE_SUPPORT_FLAGS.AUTOMATIC_INPROC_CACHE;
pub const D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = D3D12_SHADER_CACHE_SUPPORT_FLAGS.AUTOMATIC_DISK_CACHE;
pub const D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE = D3D12_SHADER_CACHE_SUPPORT_FLAGS.DRIVER_MANAGED_CACHE;
pub const D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR = D3D12_SHADER_CACHE_SUPPORT_FLAGS.SHADER_CONTROL_CLEAR;
pub const D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE = D3D12_SHADER_CACHE_SUPPORT_FLAGS.SHADER_SESSION_DELETE;
pub const D3D12_FEATURE_DATA_SHADER_CACHE = extern struct {
SupportFlags: D3D12_SHADER_CACHE_SUPPORT_FLAGS,
};
pub const D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY = extern struct {
CommandListType: D3D12_COMMAND_LIST_TYPE,
Priority: u32,
PriorityForTypeIsSupported: BOOL,
};
pub const D3D12_COMMAND_LIST_SUPPORT_FLAGS = enum(u32) {
NONE = 0,
DIRECT = 1,
BUNDLE = 2,
COMPUTE = 4,
COPY = 8,
VIDEO_DECODE = 16,
VIDEO_PROCESS = 32,
VIDEO_ENCODE = 64,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
DIRECT: u1 = 0,
BUNDLE: u1 = 0,
COMPUTE: u1 = 0,
COPY: u1 = 0,
VIDEO_DECODE: u1 = 0,
VIDEO_PROCESS: u1 = 0,
VIDEO_ENCODE: u1 = 0,
}) D3D12_COMMAND_LIST_SUPPORT_FLAGS {
return @intToEnum(D3D12_COMMAND_LIST_SUPPORT_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_COMMAND_LIST_SUPPORT_FLAGS.NONE) else 0)
| (if (o.DIRECT == 1) @enumToInt(D3D12_COMMAND_LIST_SUPPORT_FLAGS.DIRECT) else 0)
| (if (o.BUNDLE == 1) @enumToInt(D3D12_COMMAND_LIST_SUPPORT_FLAGS.BUNDLE) else 0)
| (if (o.COMPUTE == 1) @enumToInt(D3D12_COMMAND_LIST_SUPPORT_FLAGS.COMPUTE) else 0)
| (if (o.COPY == 1) @enumToInt(D3D12_COMMAND_LIST_SUPPORT_FLAGS.COPY) else 0)
| (if (o.VIDEO_DECODE == 1) @enumToInt(D3D12_COMMAND_LIST_SUPPORT_FLAGS.VIDEO_DECODE) else 0)
| (if (o.VIDEO_PROCESS == 1) @enumToInt(D3D12_COMMAND_LIST_SUPPORT_FLAGS.VIDEO_PROCESS) else 0)
| (if (o.VIDEO_ENCODE == 1) @enumToInt(D3D12_COMMAND_LIST_SUPPORT_FLAGS.VIDEO_ENCODE) else 0)
);
}
};
pub const D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE = D3D12_COMMAND_LIST_SUPPORT_FLAGS.NONE;
pub const D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT = D3D12_COMMAND_LIST_SUPPORT_FLAGS.DIRECT;
pub const D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE = D3D12_COMMAND_LIST_SUPPORT_FLAGS.BUNDLE;
pub const D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE = D3D12_COMMAND_LIST_SUPPORT_FLAGS.COMPUTE;
pub const D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY = D3D12_COMMAND_LIST_SUPPORT_FLAGS.COPY;
pub const D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE = D3D12_COMMAND_LIST_SUPPORT_FLAGS.VIDEO_DECODE;
pub const D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS = D3D12_COMMAND_LIST_SUPPORT_FLAGS.VIDEO_PROCESS;
pub const D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE = D3D12_COMMAND_LIST_SUPPORT_FLAGS.VIDEO_ENCODE;
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS3 = extern struct {
CopyQueueTimestampQueriesSupported: BOOL,
CastingFullyTypedFormatSupported: BOOL,
WriteBufferImmediateSupportFlags: D3D12_COMMAND_LIST_SUPPORT_FLAGS,
ViewInstancingTier: D3D12_VIEW_INSTANCING_TIER,
BarycentricsSupported: BOOL,
};
pub const D3D12_FEATURE_DATA_EXISTING_HEAPS = extern struct {
Supported: BOOL,
};
pub const D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER = enum(i32) {
@"0" = 0,
@"1" = 1,
@"2" = 2,
};
pub const D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER.@"0";
pub const D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER.@"1";
pub const D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2 = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER.@"2";
pub const D3D12_FEATURE_DATA_DISPLAYABLE = extern struct {
DisplayableTexture: BOOL,
SharedResourceCompatibilityTier: D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER,
};
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS4 = extern struct {
MSAA64KBAlignedTextureSupported: BOOL,
SharedResourceCompatibilityTier: D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER,
Native16BitShaderOpsSupported: BOOL,
};
pub const D3D12_HEAP_SERIALIZATION_TIER = enum(i32) {
@"0" = 0,
@"10" = 10,
};
pub const D3D12_HEAP_SERIALIZATION_TIER_0 = D3D12_HEAP_SERIALIZATION_TIER.@"0";
pub const D3D12_HEAP_SERIALIZATION_TIER_10 = D3D12_HEAP_SERIALIZATION_TIER.@"10";
pub const D3D12_FEATURE_DATA_SERIALIZATION = extern struct {
NodeIndex: u32,
HeapSerializationTier: D3D12_HEAP_SERIALIZATION_TIER,
};
pub const D3D12_FEATURE_DATA_CROSS_NODE = extern struct {
SharingTier: D3D12_CROSS_NODE_SHARING_TIER,
AtomicShaderInstructions: BOOL,
};
pub const D3D12_RENDER_PASS_TIER = enum(i32) {
@"0" = 0,
@"1" = 1,
@"2" = 2,
};
pub const D3D12_RENDER_PASS_TIER_0 = D3D12_RENDER_PASS_TIER.@"0";
pub const D3D12_RENDER_PASS_TIER_1 = D3D12_RENDER_PASS_TIER.@"1";
pub const D3D12_RENDER_PASS_TIER_2 = D3D12_RENDER_PASS_TIER.@"2";
pub const D3D12_RAYTRACING_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1_0" = 10,
@"1_1" = 11,
};
pub const D3D12_RAYTRACING_TIER_NOT_SUPPORTED = D3D12_RAYTRACING_TIER.NOT_SUPPORTED;
pub const D3D12_RAYTRACING_TIER_1_0 = D3D12_RAYTRACING_TIER.@"1_0";
pub const D3D12_RAYTRACING_TIER_1_1 = D3D12_RAYTRACING_TIER.@"1_1";
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS5 = extern struct {
SRVOnlyTiledResourceTier3: BOOL,
RenderPassesTier: D3D12_RENDER_PASS_TIER,
RaytracingTier: D3D12_RAYTRACING_TIER,
};
pub const D3D12_VARIABLE_SHADING_RATE_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1" = 1,
@"2" = 2,
};
pub const D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED = D3D12_VARIABLE_SHADING_RATE_TIER.NOT_SUPPORTED;
pub const D3D12_VARIABLE_SHADING_RATE_TIER_1 = D3D12_VARIABLE_SHADING_RATE_TIER.@"1";
pub const D3D12_VARIABLE_SHADING_RATE_TIER_2 = D3D12_VARIABLE_SHADING_RATE_TIER.@"2";
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS6 = extern struct {
AdditionalShadingRatesSupported: BOOL,
PerPrimitiveShadingRateSupportedWithViewportIndexing: BOOL,
VariableShadingRateTier: D3D12_VARIABLE_SHADING_RATE_TIER,
ShadingRateImageTileSize: u32,
BackgroundProcessingSupported: BOOL,
};
pub const D3D12_MESH_SHADER_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1" = 10,
};
pub const D3D12_MESH_SHADER_TIER_NOT_SUPPORTED = D3D12_MESH_SHADER_TIER.NOT_SUPPORTED;
pub const D3D12_MESH_SHADER_TIER_1 = D3D12_MESH_SHADER_TIER.@"1";
pub const D3D12_SAMPLER_FEEDBACK_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"0_9" = 90,
@"1_0" = 100,
};
pub const D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED = D3D12_SAMPLER_FEEDBACK_TIER.NOT_SUPPORTED;
pub const D3D12_SAMPLER_FEEDBACK_TIER_0_9 = D3D12_SAMPLER_FEEDBACK_TIER.@"0_9";
pub const D3D12_SAMPLER_FEEDBACK_TIER_1_0 = D3D12_SAMPLER_FEEDBACK_TIER.@"1_0";
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS7 = extern struct {
MeshShaderTier: D3D12_MESH_SHADER_TIER,
SamplerFeedbackTier: D3D12_SAMPLER_FEEDBACK_TIER,
};
pub const D3D12_FEATURE_DATA_QUERY_META_COMMAND = extern struct {
CommandId: Guid,
NodeMask: u32,
pQueryInputData: ?*const anyopaque,
QueryInputDataSizeInBytes: usize,
pQueryOutputData: ?*anyopaque,
QueryOutputDataSizeInBytes: usize,
};
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS8 = extern struct {
UnalignedBlockTexturesSupported: BOOL,
};
pub const D3D12_WAVE_MMA_TIER = enum(i32) {
NOT_SUPPORTED = 0,
@"1_0" = 10,
};
pub const D3D12_WAVE_MMA_TIER_NOT_SUPPORTED = D3D12_WAVE_MMA_TIER.NOT_SUPPORTED;
pub const D3D12_WAVE_MMA_TIER_1_0 = D3D12_WAVE_MMA_TIER.@"1_0";
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS9 = extern struct {
MeshShaderPipelineStatsSupported: BOOL,
MeshShaderSupportsFullRangeRenderTargetArrayIndex: BOOL,
AtomicInt64OnTypedResourceSupported: BOOL,
AtomicInt64OnGroupSharedSupported: BOOL,
DerivativesInMeshAndAmplificationShadersSupported: BOOL,
WaveMMATier: D3D12_WAVE_MMA_TIER,
};
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS10 = extern struct {
VariableRateShadingSumCombinerSupported: BOOL,
MeshShaderPerPrimitiveShadingRateSupported: BOOL,
};
pub const D3D12_FEATURE_DATA_D3D12_OPTIONS11 = extern struct {
AtomicInt64OnDescriptorHeapResourceSupported: BOOL,
};
pub const D3D12_RESOURCE_ALLOCATION_INFO = extern struct {
SizeInBytes: u64,
Alignment: u64,
};
pub const D3D12_RESOURCE_ALLOCATION_INFO1 = extern struct {
Offset: u64,
Alignment: u64,
SizeInBytes: u64,
};
pub const D3D12_HEAP_TYPE = enum(i32) {
DEFAULT = 1,
UPLOAD = 2,
READBACK = 3,
CUSTOM = 4,
};
pub const D3D12_HEAP_TYPE_DEFAULT = D3D12_HEAP_TYPE.DEFAULT;
pub const D3D12_HEAP_TYPE_UPLOAD = D3D12_HEAP_TYPE.UPLOAD;
pub const D3D12_HEAP_TYPE_READBACK = D3D12_HEAP_TYPE.READBACK;
pub const D3D12_HEAP_TYPE_CUSTOM = D3D12_HEAP_TYPE.CUSTOM;
pub const D3D12_CPU_PAGE_PROPERTY = enum(i32) {
UNKNOWN = 0,
NOT_AVAILABLE = 1,
WRITE_COMBINE = 2,
WRITE_BACK = 3,
};
pub const D3D12_CPU_PAGE_PROPERTY_UNKNOWN = D3D12_CPU_PAGE_PROPERTY.UNKNOWN;
pub const D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE = D3D12_CPU_PAGE_PROPERTY.NOT_AVAILABLE;
pub const D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE = D3D12_CPU_PAGE_PROPERTY.WRITE_COMBINE;
pub const D3D12_CPU_PAGE_PROPERTY_WRITE_BACK = D3D12_CPU_PAGE_PROPERTY.WRITE_BACK;
pub const D3D12_MEMORY_POOL = enum(i32) {
UNKNOWN = 0,
L0 = 1,
L1 = 2,
};
pub const D3D12_MEMORY_POOL_UNKNOWN = D3D12_MEMORY_POOL.UNKNOWN;
pub const D3D12_MEMORY_POOL_L0 = D3D12_MEMORY_POOL.L0;
pub const D3D12_MEMORY_POOL_L1 = D3D12_MEMORY_POOL.L1;
pub const D3D12_HEAP_PROPERTIES = extern struct {
Type: D3D12_HEAP_TYPE,
CPUPageProperty: D3D12_CPU_PAGE_PROPERTY,
MemoryPoolPreference: D3D12_MEMORY_POOL,
CreationNodeMask: u32,
VisibleNodeMask: u32,
};
pub const D3D12_HEAP_FLAGS = enum(u32) {
NONE = 0,
SHARED = 1,
DENY_BUFFERS = 4,
ALLOW_DISPLAY = 8,
SHARED_CROSS_ADAPTER = 32,
DENY_RT_DS_TEXTURES = 64,
DENY_NON_RT_DS_TEXTURES = 128,
HARDWARE_PROTECTED = 256,
ALLOW_WRITE_WATCH = 512,
ALLOW_SHADER_ATOMICS = 1024,
CREATE_NOT_RESIDENT = 2048,
CREATE_NOT_ZEROED = 4096,
// ALLOW_ALL_BUFFERS_AND_TEXTURES = 0, this enum value conflicts with NONE
ALLOW_ONLY_BUFFERS = 192,
ALLOW_ONLY_NON_RT_DS_TEXTURES = 68,
ALLOW_ONLY_RT_DS_TEXTURES = 132,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
SHARED: u1 = 0,
DENY_BUFFERS: u1 = 0,
ALLOW_DISPLAY: u1 = 0,
SHARED_CROSS_ADAPTER: u1 = 0,
DENY_RT_DS_TEXTURES: u1 = 0,
DENY_NON_RT_DS_TEXTURES: u1 = 0,
HARDWARE_PROTECTED: u1 = 0,
ALLOW_WRITE_WATCH: u1 = 0,
ALLOW_SHADER_ATOMICS: u1 = 0,
CREATE_NOT_RESIDENT: u1 = 0,
CREATE_NOT_ZEROED: u1 = 0,
ALLOW_ONLY_BUFFERS: u1 = 0,
ALLOW_ONLY_NON_RT_DS_TEXTURES: u1 = 0,
ALLOW_ONLY_RT_DS_TEXTURES: u1 = 0,
}) D3D12_HEAP_FLAGS {
return @intToEnum(D3D12_HEAP_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_HEAP_FLAGS.NONE) else 0)
| (if (o.SHARED == 1) @enumToInt(D3D12_HEAP_FLAGS.SHARED) else 0)
| (if (o.DENY_BUFFERS == 1) @enumToInt(D3D12_HEAP_FLAGS.DENY_BUFFERS) else 0)
| (if (o.ALLOW_DISPLAY == 1) @enumToInt(D3D12_HEAP_FLAGS.ALLOW_DISPLAY) else 0)
| (if (o.SHARED_CROSS_ADAPTER == 1) @enumToInt(D3D12_HEAP_FLAGS.SHARED_CROSS_ADAPTER) else 0)
| (if (o.DENY_RT_DS_TEXTURES == 1) @enumToInt(D3D12_HEAP_FLAGS.DENY_RT_DS_TEXTURES) else 0)
| (if (o.DENY_NON_RT_DS_TEXTURES == 1) @enumToInt(D3D12_HEAP_FLAGS.DENY_NON_RT_DS_TEXTURES) else 0)
| (if (o.HARDWARE_PROTECTED == 1) @enumToInt(D3D12_HEAP_FLAGS.HARDWARE_PROTECTED) else 0)
| (if (o.ALLOW_WRITE_WATCH == 1) @enumToInt(D3D12_HEAP_FLAGS.ALLOW_WRITE_WATCH) else 0)
| (if (o.ALLOW_SHADER_ATOMICS == 1) @enumToInt(D3D12_HEAP_FLAGS.ALLOW_SHADER_ATOMICS) else 0)
| (if (o.CREATE_NOT_RESIDENT == 1) @enumToInt(D3D12_HEAP_FLAGS.CREATE_NOT_RESIDENT) else 0)
| (if (o.CREATE_NOT_ZEROED == 1) @enumToInt(D3D12_HEAP_FLAGS.CREATE_NOT_ZEROED) else 0)
| (if (o.ALLOW_ONLY_BUFFERS == 1) @enumToInt(D3D12_HEAP_FLAGS.ALLOW_ONLY_BUFFERS) else 0)
| (if (o.ALLOW_ONLY_NON_RT_DS_TEXTURES == 1) @enumToInt(D3D12_HEAP_FLAGS.ALLOW_ONLY_NON_RT_DS_TEXTURES) else 0)
| (if (o.ALLOW_ONLY_RT_DS_TEXTURES == 1) @enumToInt(D3D12_HEAP_FLAGS.ALLOW_ONLY_RT_DS_TEXTURES) else 0)
);
}
};
pub const D3D12_HEAP_FLAG_NONE = D3D12_HEAP_FLAGS.NONE;
pub const D3D12_HEAP_FLAG_SHARED = D3D12_HEAP_FLAGS.SHARED;
pub const D3D12_HEAP_FLAG_DENY_BUFFERS = D3D12_HEAP_FLAGS.DENY_BUFFERS;
pub const D3D12_HEAP_FLAG_ALLOW_DISPLAY = D3D12_HEAP_FLAGS.ALLOW_DISPLAY;
pub const D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = D3D12_HEAP_FLAGS.SHARED_CROSS_ADAPTER;
pub const D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = D3D12_HEAP_FLAGS.DENY_RT_DS_TEXTURES;
pub const D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = D3D12_HEAP_FLAGS.DENY_NON_RT_DS_TEXTURES;
pub const D3D12_HEAP_FLAG_HARDWARE_PROTECTED = D3D12_HEAP_FLAGS.HARDWARE_PROTECTED;
pub const D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH = D3D12_HEAP_FLAGS.ALLOW_WRITE_WATCH;
pub const D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = D3D12_HEAP_FLAGS.ALLOW_SHADER_ATOMICS;
pub const D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT = D3D12_HEAP_FLAGS.CREATE_NOT_RESIDENT;
pub const D3D12_HEAP_FLAG_CREATE_NOT_ZEROED = D3D12_HEAP_FLAGS.CREATE_NOT_ZEROED;
pub const D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = D3D12_HEAP_FLAGS.NONE;
pub const D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = D3D12_HEAP_FLAGS.ALLOW_ONLY_BUFFERS;
pub const D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = D3D12_HEAP_FLAGS.ALLOW_ONLY_NON_RT_DS_TEXTURES;
pub const D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = D3D12_HEAP_FLAGS.ALLOW_ONLY_RT_DS_TEXTURES;
pub const D3D12_HEAP_DESC = extern struct {
SizeInBytes: u64,
Properties: D3D12_HEAP_PROPERTIES,
Alignment: u64,
Flags: D3D12_HEAP_FLAGS,
};
pub const D3D12_RESOURCE_DIMENSION = enum(i32) {
UNKNOWN = 0,
BUFFER = 1,
TEXTURE1D = 2,
TEXTURE2D = 3,
TEXTURE3D = 4,
};
pub const D3D12_RESOURCE_DIMENSION_UNKNOWN = D3D12_RESOURCE_DIMENSION.UNKNOWN;
pub const D3D12_RESOURCE_DIMENSION_BUFFER = D3D12_RESOURCE_DIMENSION.BUFFER;
pub const D3D12_RESOURCE_DIMENSION_TEXTURE1D = D3D12_RESOURCE_DIMENSION.TEXTURE1D;
pub const D3D12_RESOURCE_DIMENSION_TEXTURE2D = D3D12_RESOURCE_DIMENSION.TEXTURE2D;
pub const D3D12_RESOURCE_DIMENSION_TEXTURE3D = D3D12_RESOURCE_DIMENSION.TEXTURE3D;
pub const D3D12_TEXTURE_LAYOUT = enum(i32) {
UNKNOWN = 0,
ROW_MAJOR = 1,
@"64KB_UNDEFINED_SWIZZLE" = 2,
@"64KB_STANDARD_SWIZZLE" = 3,
};
pub const D3D12_TEXTURE_LAYOUT_UNKNOWN = D3D12_TEXTURE_LAYOUT.UNKNOWN;
pub const D3D12_TEXTURE_LAYOUT_ROW_MAJOR = D3D12_TEXTURE_LAYOUT.ROW_MAJOR;
pub const D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE = D3D12_TEXTURE_LAYOUT.@"64KB_UNDEFINED_SWIZZLE";
pub const D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE = D3D12_TEXTURE_LAYOUT.@"64KB_STANDARD_SWIZZLE";
pub const D3D12_RESOURCE_FLAGS = enum(u32) {
NONE = 0,
ALLOW_RENDER_TARGET = 1,
ALLOW_DEPTH_STENCIL = 2,
ALLOW_UNORDERED_ACCESS = 4,
DENY_SHADER_RESOURCE = 8,
ALLOW_CROSS_ADAPTER = 16,
ALLOW_SIMULTANEOUS_ACCESS = 32,
VIDEO_DECODE_REFERENCE_ONLY = 64,
VIDEO_ENCODE_REFERENCE_ONLY = 128,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
ALLOW_RENDER_TARGET: u1 = 0,
ALLOW_DEPTH_STENCIL: u1 = 0,
ALLOW_UNORDERED_ACCESS: u1 = 0,
DENY_SHADER_RESOURCE: u1 = 0,
ALLOW_CROSS_ADAPTER: u1 = 0,
ALLOW_SIMULTANEOUS_ACCESS: u1 = 0,
VIDEO_DECODE_REFERENCE_ONLY: u1 = 0,
VIDEO_ENCODE_REFERENCE_ONLY: u1 = 0,
}) D3D12_RESOURCE_FLAGS {
return @intToEnum(D3D12_RESOURCE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RESOURCE_FLAGS.NONE) else 0)
| (if (o.ALLOW_RENDER_TARGET == 1) @enumToInt(D3D12_RESOURCE_FLAGS.ALLOW_RENDER_TARGET) else 0)
| (if (o.ALLOW_DEPTH_STENCIL == 1) @enumToInt(D3D12_RESOURCE_FLAGS.ALLOW_DEPTH_STENCIL) else 0)
| (if (o.ALLOW_UNORDERED_ACCESS == 1) @enumToInt(D3D12_RESOURCE_FLAGS.ALLOW_UNORDERED_ACCESS) else 0)
| (if (o.DENY_SHADER_RESOURCE == 1) @enumToInt(D3D12_RESOURCE_FLAGS.DENY_SHADER_RESOURCE) else 0)
| (if (o.ALLOW_CROSS_ADAPTER == 1) @enumToInt(D3D12_RESOURCE_FLAGS.ALLOW_CROSS_ADAPTER) else 0)
| (if (o.ALLOW_SIMULTANEOUS_ACCESS == 1) @enumToInt(D3D12_RESOURCE_FLAGS.ALLOW_SIMULTANEOUS_ACCESS) else 0)
| (if (o.VIDEO_DECODE_REFERENCE_ONLY == 1) @enumToInt(D3D12_RESOURCE_FLAGS.VIDEO_DECODE_REFERENCE_ONLY) else 0)
| (if (o.VIDEO_ENCODE_REFERENCE_ONLY == 1) @enumToInt(D3D12_RESOURCE_FLAGS.VIDEO_ENCODE_REFERENCE_ONLY) else 0)
);
}
};
pub const D3D12_RESOURCE_FLAG_NONE = D3D12_RESOURCE_FLAGS.NONE;
pub const D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET = D3D12_RESOURCE_FLAGS.ALLOW_RENDER_TARGET;
pub const D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL = D3D12_RESOURCE_FLAGS.ALLOW_DEPTH_STENCIL;
pub const D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS = D3D12_RESOURCE_FLAGS.ALLOW_UNORDERED_ACCESS;
pub const D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE = D3D12_RESOURCE_FLAGS.DENY_SHADER_RESOURCE;
pub const D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = D3D12_RESOURCE_FLAGS.ALLOW_CROSS_ADAPTER;
pub const D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = D3D12_RESOURCE_FLAGS.ALLOW_SIMULTANEOUS_ACCESS;
pub const D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = D3D12_RESOURCE_FLAGS.VIDEO_DECODE_REFERENCE_ONLY;
pub const D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY = D3D12_RESOURCE_FLAGS.VIDEO_ENCODE_REFERENCE_ONLY;
pub const D3D12_MIP_REGION = extern struct {
Width: u32,
Height: u32,
Depth: u32,
};
pub const D3D12_RESOURCE_DESC = extern struct {
Dimension: D3D12_RESOURCE_DIMENSION,
Alignment: u64,
Width: u64,
Height: u32,
DepthOrArraySize: u16,
MipLevels: u16,
Format: DXGI_FORMAT,
SampleDesc: DXGI_SAMPLE_DESC,
Layout: D3D12_TEXTURE_LAYOUT,
Flags: D3D12_RESOURCE_FLAGS,
};
pub const D3D12_RESOURCE_DESC1 = extern struct {
Dimension: D3D12_RESOURCE_DIMENSION,
Alignment: u64,
Width: u64,
Height: u32,
DepthOrArraySize: u16,
MipLevels: u16,
Format: DXGI_FORMAT,
SampleDesc: DXGI_SAMPLE_DESC,
Layout: D3D12_TEXTURE_LAYOUT,
Flags: D3D12_RESOURCE_FLAGS,
SamplerFeedbackMipRegion: D3D12_MIP_REGION,
};
pub const D3D12_DEPTH_STENCIL_VALUE = extern struct {
Depth: f32,
Stencil: u8,
};
pub const D3D12_CLEAR_VALUE = extern struct {
Format: DXGI_FORMAT,
Anonymous: extern union {
Color: [4]f32,
DepthStencil: D3D12_DEPTH_STENCIL_VALUE,
},
};
pub const D3D12_RANGE = extern struct {
Begin: usize,
End: usize,
};
pub const D3D12_RANGE_UINT64 = extern struct {
Begin: u64,
End: u64,
};
pub const D3D12_SUBRESOURCE_RANGE_UINT64 = extern struct {
Subresource: u32,
Range: D3D12_RANGE_UINT64,
};
pub const D3D12_SUBRESOURCE_INFO = extern struct {
Offset: u64,
RowPitch: u32,
DepthPitch: u32,
};
pub const D3D12_TILED_RESOURCE_COORDINATE = extern struct {
X: u32,
Y: u32,
Z: u32,
Subresource: u32,
};
pub const D3D12_TILE_REGION_SIZE = extern struct {
NumTiles: u32,
UseBox: BOOL,
Width: u32,
Height: u16,
Depth: u16,
};
pub const D3D12_TILE_RANGE_FLAGS = enum(i32) {
NONE = 0,
NULL = 1,
SKIP = 2,
REUSE_SINGLE_TILE = 4,
};
pub const D3D12_TILE_RANGE_FLAG_NONE = D3D12_TILE_RANGE_FLAGS.NONE;
pub const D3D12_TILE_RANGE_FLAG_NULL = D3D12_TILE_RANGE_FLAGS.NULL;
pub const D3D12_TILE_RANGE_FLAG_SKIP = D3D12_TILE_RANGE_FLAGS.SKIP;
pub const D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE = D3D12_TILE_RANGE_FLAGS.REUSE_SINGLE_TILE;
pub const D3D12_SUBRESOURCE_TILING = extern struct {
WidthInTiles: u32,
HeightInTiles: u16,
DepthInTiles: u16,
StartTileIndexInOverallResource: u32,
};
pub const D3D12_TILE_SHAPE = extern struct {
WidthInTexels: u32,
HeightInTexels: u32,
DepthInTexels: u32,
};
pub const D3D12_PACKED_MIP_INFO = extern struct {
NumStandardMips: u8,
NumPackedMips: u8,
NumTilesForPackedMips: u32,
StartTileIndexInOverallResource: u32,
};
pub const D3D12_TILE_MAPPING_FLAGS = enum(u32) {
NE = 0,
_HAZARD = 1,
_,
pub fn initFlags(o: struct {
NE: u1 = 0,
_HAZARD: u1 = 0,
}) D3D12_TILE_MAPPING_FLAGS {
return @intToEnum(D3D12_TILE_MAPPING_FLAGS,
(if (o.NE == 1) @enumToInt(D3D12_TILE_MAPPING_FLAGS.NE) else 0)
| (if (o._HAZARD == 1) @enumToInt(D3D12_TILE_MAPPING_FLAGS._HAZARD) else 0)
);
}
};
pub const D3D12_TILE_MAPPING_FLAG_NONE = D3D12_TILE_MAPPING_FLAGS.NE;
pub const D3D12_TILE_MAPPING_FLAG_NO_HAZARD = D3D12_TILE_MAPPING_FLAGS._HAZARD;
pub const D3D12_TILE_COPY_FLAGS = enum(u32) {
NONE = 0,
NO_HAZARD = 1,
LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 2,
SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 4,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
NO_HAZARD: u1 = 0,
LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE: u1 = 0,
SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER: u1 = 0,
}) D3D12_TILE_COPY_FLAGS {
return @intToEnum(D3D12_TILE_COPY_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_TILE_COPY_FLAGS.NONE) else 0)
| (if (o.NO_HAZARD == 1) @enumToInt(D3D12_TILE_COPY_FLAGS.NO_HAZARD) else 0)
| (if (o.LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE == 1) @enumToInt(D3D12_TILE_COPY_FLAGS.LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE) else 0)
| (if (o.SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER == 1) @enumToInt(D3D12_TILE_COPY_FLAGS.SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER) else 0)
);
}
};
pub const D3D12_TILE_COPY_FLAG_NONE = D3D12_TILE_COPY_FLAGS.NONE;
pub const D3D12_TILE_COPY_FLAG_NO_HAZARD = D3D12_TILE_COPY_FLAGS.NO_HAZARD;
pub const D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = D3D12_TILE_COPY_FLAGS.LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE;
pub const D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = D3D12_TILE_COPY_FLAGS.SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER;
pub const D3D12_RESOURCE_STATES = enum(u32) {
COMMON = 0,
VERTEX_AND_CONSTANT_BUFFER = 1,
INDEX_BUFFER = 2,
RENDER_TARGET = 4,
UNORDERED_ACCESS = 8,
DEPTH_WRITE = 16,
DEPTH_READ = 32,
NON_PIXEL_SHADER_RESOURCE = 64,
PIXEL_SHADER_RESOURCE = 128,
STREAM_OUT = 256,
INDIRECT_ARGUMENT = 512,
COPY_DEST = 1024,
COPY_SOURCE = 2048,
RESOLVE_DEST = 4096,
RESOLVE_SOURCE = 8192,
RAYTRACING_ACCELERATION_STRUCTURE = 4194304,
SHADING_RATE_SOURCE = 16777216,
GENERIC_READ = 2755,
ALL_SHADER_RESOURCE = 192,
// PRESENT = 0, this enum value conflicts with COMMON
// PREDICATION = 512, this enum value conflicts with INDIRECT_ARGUMENT
VIDEO_DECODE_READ = 65536,
VIDEO_DECODE_WRITE = 131072,
VIDEO_PROCESS_READ = 262144,
VIDEO_PROCESS_WRITE = 524288,
VIDEO_ENCODE_READ = 2097152,
VIDEO_ENCODE_WRITE = 8388608,
_,
pub fn initFlags(o: struct {
COMMON: u1 = 0,
VERTEX_AND_CONSTANT_BUFFER: u1 = 0,
INDEX_BUFFER: u1 = 0,
RENDER_TARGET: u1 = 0,
UNORDERED_ACCESS: u1 = 0,
DEPTH_WRITE: u1 = 0,
DEPTH_READ: u1 = 0,
NON_PIXEL_SHADER_RESOURCE: u1 = 0,
PIXEL_SHADER_RESOURCE: u1 = 0,
STREAM_OUT: u1 = 0,
INDIRECT_ARGUMENT: u1 = 0,
COPY_DEST: u1 = 0,
COPY_SOURCE: u1 = 0,
RESOLVE_DEST: u1 = 0,
RESOLVE_SOURCE: u1 = 0,
RAYTRACING_ACCELERATION_STRUCTURE: u1 = 0,
SHADING_RATE_SOURCE: u1 = 0,
GENERIC_READ: u1 = 0,
ALL_SHADER_RESOURCE: u1 = 0,
VIDEO_DECODE_READ: u1 = 0,
VIDEO_DECODE_WRITE: u1 = 0,
VIDEO_PROCESS_READ: u1 = 0,
VIDEO_PROCESS_WRITE: u1 = 0,
VIDEO_ENCODE_READ: u1 = 0,
VIDEO_ENCODE_WRITE: u1 = 0,
}) D3D12_RESOURCE_STATES {
return @intToEnum(D3D12_RESOURCE_STATES,
(if (o.COMMON == 1) @enumToInt(D3D12_RESOURCE_STATES.COMMON) else 0)
| (if (o.VERTEX_AND_CONSTANT_BUFFER == 1) @enumToInt(D3D12_RESOURCE_STATES.VERTEX_AND_CONSTANT_BUFFER) else 0)
| (if (o.INDEX_BUFFER == 1) @enumToInt(D3D12_RESOURCE_STATES.INDEX_BUFFER) else 0)
| (if (o.RENDER_TARGET == 1) @enumToInt(D3D12_RESOURCE_STATES.RENDER_TARGET) else 0)
| (if (o.UNORDERED_ACCESS == 1) @enumToInt(D3D12_RESOURCE_STATES.UNORDERED_ACCESS) else 0)
| (if (o.DEPTH_WRITE == 1) @enumToInt(D3D12_RESOURCE_STATES.DEPTH_WRITE) else 0)
| (if (o.DEPTH_READ == 1) @enumToInt(D3D12_RESOURCE_STATES.DEPTH_READ) else 0)
| (if (o.NON_PIXEL_SHADER_RESOURCE == 1) @enumToInt(D3D12_RESOURCE_STATES.NON_PIXEL_SHADER_RESOURCE) else 0)
| (if (o.PIXEL_SHADER_RESOURCE == 1) @enumToInt(D3D12_RESOURCE_STATES.PIXEL_SHADER_RESOURCE) else 0)
| (if (o.STREAM_OUT == 1) @enumToInt(D3D12_RESOURCE_STATES.STREAM_OUT) else 0)
| (if (o.INDIRECT_ARGUMENT == 1) @enumToInt(D3D12_RESOURCE_STATES.INDIRECT_ARGUMENT) else 0)
| (if (o.COPY_DEST == 1) @enumToInt(D3D12_RESOURCE_STATES.COPY_DEST) else 0)
| (if (o.COPY_SOURCE == 1) @enumToInt(D3D12_RESOURCE_STATES.COPY_SOURCE) else 0)
| (if (o.RESOLVE_DEST == 1) @enumToInt(D3D12_RESOURCE_STATES.RESOLVE_DEST) else 0)
| (if (o.RESOLVE_SOURCE == 1) @enumToInt(D3D12_RESOURCE_STATES.RESOLVE_SOURCE) else 0)
| (if (o.RAYTRACING_ACCELERATION_STRUCTURE == 1) @enumToInt(D3D12_RESOURCE_STATES.RAYTRACING_ACCELERATION_STRUCTURE) else 0)
| (if (o.SHADING_RATE_SOURCE == 1) @enumToInt(D3D12_RESOURCE_STATES.SHADING_RATE_SOURCE) else 0)
| (if (o.GENERIC_READ == 1) @enumToInt(D3D12_RESOURCE_STATES.GENERIC_READ) else 0)
| (if (o.ALL_SHADER_RESOURCE == 1) @enumToInt(D3D12_RESOURCE_STATES.ALL_SHADER_RESOURCE) else 0)
| (if (o.VIDEO_DECODE_READ == 1) @enumToInt(D3D12_RESOURCE_STATES.VIDEO_DECODE_READ) else 0)
| (if (o.VIDEO_DECODE_WRITE == 1) @enumToInt(D3D12_RESOURCE_STATES.VIDEO_DECODE_WRITE) else 0)
| (if (o.VIDEO_PROCESS_READ == 1) @enumToInt(D3D12_RESOURCE_STATES.VIDEO_PROCESS_READ) else 0)
| (if (o.VIDEO_PROCESS_WRITE == 1) @enumToInt(D3D12_RESOURCE_STATES.VIDEO_PROCESS_WRITE) else 0)
| (if (o.VIDEO_ENCODE_READ == 1) @enumToInt(D3D12_RESOURCE_STATES.VIDEO_ENCODE_READ) else 0)
| (if (o.VIDEO_ENCODE_WRITE == 1) @enumToInt(D3D12_RESOURCE_STATES.VIDEO_ENCODE_WRITE) else 0)
);
}
};
pub const D3D12_RESOURCE_STATE_COMMON = D3D12_RESOURCE_STATES.COMMON;
pub const D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER = D3D12_RESOURCE_STATES.VERTEX_AND_CONSTANT_BUFFER;
pub const D3D12_RESOURCE_STATE_INDEX_BUFFER = D3D12_RESOURCE_STATES.INDEX_BUFFER;
pub const D3D12_RESOURCE_STATE_RENDER_TARGET = D3D12_RESOURCE_STATES.RENDER_TARGET;
pub const D3D12_RESOURCE_STATE_UNORDERED_ACCESS = D3D12_RESOURCE_STATES.UNORDERED_ACCESS;
pub const D3D12_RESOURCE_STATE_DEPTH_WRITE = D3D12_RESOURCE_STATES.DEPTH_WRITE;
pub const D3D12_RESOURCE_STATE_DEPTH_READ = D3D12_RESOURCE_STATES.DEPTH_READ;
pub const D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE = D3D12_RESOURCE_STATES.NON_PIXEL_SHADER_RESOURCE;
pub const D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE = D3D12_RESOURCE_STATES.PIXEL_SHADER_RESOURCE;
pub const D3D12_RESOURCE_STATE_STREAM_OUT = D3D12_RESOURCE_STATES.STREAM_OUT;
pub const D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT = D3D12_RESOURCE_STATES.INDIRECT_ARGUMENT;
pub const D3D12_RESOURCE_STATE_COPY_DEST = D3D12_RESOURCE_STATES.COPY_DEST;
pub const D3D12_RESOURCE_STATE_COPY_SOURCE = D3D12_RESOURCE_STATES.COPY_SOURCE;
pub const D3D12_RESOURCE_STATE_RESOLVE_DEST = D3D12_RESOURCE_STATES.RESOLVE_DEST;
pub const D3D12_RESOURCE_STATE_RESOLVE_SOURCE = D3D12_RESOURCE_STATES.RESOLVE_SOURCE;
pub const D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = D3D12_RESOURCE_STATES.RAYTRACING_ACCELERATION_STRUCTURE;
pub const D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE = D3D12_RESOURCE_STATES.SHADING_RATE_SOURCE;
pub const D3D12_RESOURCE_STATE_GENERIC_READ = D3D12_RESOURCE_STATES.GENERIC_READ;
pub const D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE = D3D12_RESOURCE_STATES.ALL_SHADER_RESOURCE;
pub const D3D12_RESOURCE_STATE_PRESENT = D3D12_RESOURCE_STATES.COMMON;
pub const D3D12_RESOURCE_STATE_PREDICATION = D3D12_RESOURCE_STATES.INDIRECT_ARGUMENT;
pub const D3D12_RESOURCE_STATE_VIDEO_DECODE_READ = D3D12_RESOURCE_STATES.VIDEO_DECODE_READ;
pub const D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE = D3D12_RESOURCE_STATES.VIDEO_DECODE_WRITE;
pub const D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ = D3D12_RESOURCE_STATES.VIDEO_PROCESS_READ;
pub const D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE = D3D12_RESOURCE_STATES.VIDEO_PROCESS_WRITE;
pub const D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ = D3D12_RESOURCE_STATES.VIDEO_ENCODE_READ;
pub const D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE = D3D12_RESOURCE_STATES.VIDEO_ENCODE_WRITE;
pub const D3D12_RESOURCE_BARRIER_TYPE = enum(i32) {
TRANSITION = 0,
ALIASING = 1,
UAV = 2,
};
pub const D3D12_RESOURCE_BARRIER_TYPE_TRANSITION = D3D12_RESOURCE_BARRIER_TYPE.TRANSITION;
pub const D3D12_RESOURCE_BARRIER_TYPE_ALIASING = D3D12_RESOURCE_BARRIER_TYPE.ALIASING;
pub const D3D12_RESOURCE_BARRIER_TYPE_UAV = D3D12_RESOURCE_BARRIER_TYPE.UAV;
pub const D3D12_RESOURCE_TRANSITION_BARRIER = extern struct {
pResource: ?*ID3D12Resource,
Subresource: u32,
StateBefore: D3D12_RESOURCE_STATES,
StateAfter: D3D12_RESOURCE_STATES,
};
pub const D3D12_RESOURCE_ALIASING_BARRIER = extern struct {
pResourceBefore: ?*ID3D12Resource,
pResourceAfter: ?*ID3D12Resource,
};
pub const D3D12_RESOURCE_UAV_BARRIER = extern struct {
pResource: ?*ID3D12Resource,
};
pub const D3D12_RESOURCE_BARRIER_FLAGS = enum(u32) {
NONE = 0,
BEGIN_ONLY = 1,
END_ONLY = 2,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
BEGIN_ONLY: u1 = 0,
END_ONLY: u1 = 0,
}) D3D12_RESOURCE_BARRIER_FLAGS {
return @intToEnum(D3D12_RESOURCE_BARRIER_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RESOURCE_BARRIER_FLAGS.NONE) else 0)
| (if (o.BEGIN_ONLY == 1) @enumToInt(D3D12_RESOURCE_BARRIER_FLAGS.BEGIN_ONLY) else 0)
| (if (o.END_ONLY == 1) @enumToInt(D3D12_RESOURCE_BARRIER_FLAGS.END_ONLY) else 0)
);
}
};
pub const D3D12_RESOURCE_BARRIER_FLAG_NONE = D3D12_RESOURCE_BARRIER_FLAGS.NONE;
pub const D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY = D3D12_RESOURCE_BARRIER_FLAGS.BEGIN_ONLY;
pub const D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = D3D12_RESOURCE_BARRIER_FLAGS.END_ONLY;
pub const D3D12_RESOURCE_BARRIER = extern struct {
Type: D3D12_RESOURCE_BARRIER_TYPE,
Flags: D3D12_RESOURCE_BARRIER_FLAGS,
Anonymous: extern union {
Transition: D3D12_RESOURCE_TRANSITION_BARRIER,
Aliasing: D3D12_RESOURCE_ALIASING_BARRIER,
UAV: D3D12_RESOURCE_UAV_BARRIER,
},
};
pub const D3D12_SUBRESOURCE_FOOTPRINT = extern struct {
Format: DXGI_FORMAT,
Width: u32,
Height: u32,
Depth: u32,
RowPitch: u32,
};
pub const D3D12_PLACED_SUBRESOURCE_FOOTPRINT = extern struct {
Offset: u64,
Footprint: D3D12_SUBRESOURCE_FOOTPRINT,
};
pub const D3D12_TEXTURE_COPY_TYPE = enum(i32) {
SUBRESOURCE_INDEX = 0,
PLACED_FOOTPRINT = 1,
};
pub const D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX = D3D12_TEXTURE_COPY_TYPE.SUBRESOURCE_INDEX;
pub const D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT = D3D12_TEXTURE_COPY_TYPE.PLACED_FOOTPRINT;
pub const D3D12_TEXTURE_COPY_LOCATION = extern struct {
pResource: ?*ID3D12Resource,
Type: D3D12_TEXTURE_COPY_TYPE,
Anonymous: extern union {
PlacedFootprint: D3D12_PLACED_SUBRESOURCE_FOOTPRINT,
SubresourceIndex: u32,
},
};
pub const D3D12_RESOLVE_MODE = enum(i32) {
DECOMPRESS = 0,
MIN = 1,
MAX = 2,
AVERAGE = 3,
ENCODE_SAMPLER_FEEDBACK = 4,
DECODE_SAMPLER_FEEDBACK = 5,
};
pub const D3D12_RESOLVE_MODE_DECOMPRESS = D3D12_RESOLVE_MODE.DECOMPRESS;
pub const D3D12_RESOLVE_MODE_MIN = D3D12_RESOLVE_MODE.MIN;
pub const D3D12_RESOLVE_MODE_MAX = D3D12_RESOLVE_MODE.MAX;
pub const D3D12_RESOLVE_MODE_AVERAGE = D3D12_RESOLVE_MODE.AVERAGE;
pub const D3D12_RESOLVE_MODE_ENCODE_SAMPLER_FEEDBACK = D3D12_RESOLVE_MODE.ENCODE_SAMPLER_FEEDBACK;
pub const D3D12_RESOLVE_MODE_DECODE_SAMPLER_FEEDBACK = D3D12_RESOLVE_MODE.DECODE_SAMPLER_FEEDBACK;
pub const D3D12_SAMPLE_POSITION = extern struct {
X: i8,
Y: i8,
};
pub const D3D12_VIEW_INSTANCE_LOCATION = extern struct {
ViewportArrayIndex: u32,
RenderTargetArrayIndex: u32,
};
pub const D3D12_VIEW_INSTANCING_FLAGS = enum(u32) {
NONE = 0,
ENABLE_VIEW_INSTANCE_MASKING = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
ENABLE_VIEW_INSTANCE_MASKING: u1 = 0,
}) D3D12_VIEW_INSTANCING_FLAGS {
return @intToEnum(D3D12_VIEW_INSTANCING_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_VIEW_INSTANCING_FLAGS.NONE) else 0)
| (if (o.ENABLE_VIEW_INSTANCE_MASKING == 1) @enumToInt(D3D12_VIEW_INSTANCING_FLAGS.ENABLE_VIEW_INSTANCE_MASKING) else 0)
);
}
};
pub const D3D12_VIEW_INSTANCING_FLAG_NONE = D3D12_VIEW_INSTANCING_FLAGS.NONE;
pub const D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING = D3D12_VIEW_INSTANCING_FLAGS.ENABLE_VIEW_INSTANCE_MASKING;
pub const D3D12_VIEW_INSTANCING_DESC = extern struct {
ViewInstanceCount: u32,
pViewInstanceLocations: ?*const D3D12_VIEW_INSTANCE_LOCATION,
Flags: D3D12_VIEW_INSTANCING_FLAGS,
};
pub const D3D12_SHADER_COMPONENT_MAPPING = enum(i32) {
ROM_MEMORY_COMPONENT_0 = 0,
ROM_MEMORY_COMPONENT_1 = 1,
ROM_MEMORY_COMPONENT_2 = 2,
ROM_MEMORY_COMPONENT_3 = 3,
ORCE_VALUE_0 = 4,
ORCE_VALUE_1 = 5,
};
pub const D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0 = D3D12_SHADER_COMPONENT_MAPPING.ROM_MEMORY_COMPONENT_0;
pub const D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1 = D3D12_SHADER_COMPONENT_MAPPING.ROM_MEMORY_COMPONENT_1;
pub const D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2 = D3D12_SHADER_COMPONENT_MAPPING.ROM_MEMORY_COMPONENT_2;
pub const D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3 = D3D12_SHADER_COMPONENT_MAPPING.ROM_MEMORY_COMPONENT_3;
pub const D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0 = D3D12_SHADER_COMPONENT_MAPPING.ORCE_VALUE_0;
pub const D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1 = D3D12_SHADER_COMPONENT_MAPPING.ORCE_VALUE_1;
pub const D3D12_BUFFER_SRV_FLAGS = enum(u32) {
NONE = 0,
RAW = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
RAW: u1 = 0,
}) D3D12_BUFFER_SRV_FLAGS {
return @intToEnum(D3D12_BUFFER_SRV_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_BUFFER_SRV_FLAGS.NONE) else 0)
| (if (o.RAW == 1) @enumToInt(D3D12_BUFFER_SRV_FLAGS.RAW) else 0)
);
}
};
pub const D3D12_BUFFER_SRV_FLAG_NONE = D3D12_BUFFER_SRV_FLAGS.NONE;
pub const D3D12_BUFFER_SRV_FLAG_RAW = D3D12_BUFFER_SRV_FLAGS.RAW;
pub const D3D12_BUFFER_SRV = extern struct {
FirstElement: u64,
NumElements: u32,
StructureByteStride: u32,
Flags: D3D12_BUFFER_SRV_FLAGS,
};
pub const D3D12_TEX1D_SRV = extern struct {
MostDetailedMip: u32,
MipLevels: u32,
ResourceMinLODClamp: f32,
};
pub const D3D12_TEX1D_ARRAY_SRV = extern struct {
MostDetailedMip: u32,
MipLevels: u32,
FirstArraySlice: u32,
ArraySize: u32,
ResourceMinLODClamp: f32,
};
pub const D3D12_TEX2D_SRV = extern struct {
MostDetailedMip: u32,
MipLevels: u32,
PlaneSlice: u32,
ResourceMinLODClamp: f32,
};
pub const D3D12_TEX2D_ARRAY_SRV = extern struct {
MostDetailedMip: u32,
MipLevels: u32,
FirstArraySlice: u32,
ArraySize: u32,
PlaneSlice: u32,
ResourceMinLODClamp: f32,
};
pub const D3D12_TEX3D_SRV = extern struct {
MostDetailedMip: u32,
MipLevels: u32,
ResourceMinLODClamp: f32,
};
pub const D3D12_TEXCUBE_SRV = extern struct {
MostDetailedMip: u32,
MipLevels: u32,
ResourceMinLODClamp: f32,
};
pub const D3D12_TEXCUBE_ARRAY_SRV = extern struct {
MostDetailedMip: u32,
MipLevels: u32,
First2DArrayFace: u32,
NumCubes: u32,
ResourceMinLODClamp: f32,
};
pub const D3D12_TEX2DMS_SRV = extern struct {
UnusedField_NothingToDefine: u32,
};
pub const D3D12_TEX2DMS_ARRAY_SRV = extern struct {
FirstArraySlice: u32,
ArraySize: u32,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV = extern struct {
Location: u64,
};
pub const D3D12_SRV_DIMENSION = enum(i32) {
UNKNOWN = 0,
BUFFER = 1,
TEXTURE1D = 2,
TEXTURE1DARRAY = 3,
TEXTURE2D = 4,
TEXTURE2DARRAY = 5,
TEXTURE2DMS = 6,
TEXTURE2DMSARRAY = 7,
TEXTURE3D = 8,
TEXTURECUBE = 9,
TEXTURECUBEARRAY = 10,
RAYTRACING_ACCELERATION_STRUCTURE = 11,
};
pub const D3D12_SRV_DIMENSION_UNKNOWN = D3D12_SRV_DIMENSION.UNKNOWN;
pub const D3D12_SRV_DIMENSION_BUFFER = D3D12_SRV_DIMENSION.BUFFER;
pub const D3D12_SRV_DIMENSION_TEXTURE1D = D3D12_SRV_DIMENSION.TEXTURE1D;
pub const D3D12_SRV_DIMENSION_TEXTURE1DARRAY = D3D12_SRV_DIMENSION.TEXTURE1DARRAY;
pub const D3D12_SRV_DIMENSION_TEXTURE2D = D3D12_SRV_DIMENSION.TEXTURE2D;
pub const D3D12_SRV_DIMENSION_TEXTURE2DARRAY = D3D12_SRV_DIMENSION.TEXTURE2DARRAY;
pub const D3D12_SRV_DIMENSION_TEXTURE2DMS = D3D12_SRV_DIMENSION.TEXTURE2DMS;
pub const D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D12_SRV_DIMENSION.TEXTURE2DMSARRAY;
pub const D3D12_SRV_DIMENSION_TEXTURE3D = D3D12_SRV_DIMENSION.TEXTURE3D;
pub const D3D12_SRV_DIMENSION_TEXTURECUBE = D3D12_SRV_DIMENSION.TEXTURECUBE;
pub const D3D12_SRV_DIMENSION_TEXTURECUBEARRAY = D3D12_SRV_DIMENSION.TEXTURECUBEARRAY;
pub const D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE = D3D12_SRV_DIMENSION.RAYTRACING_ACCELERATION_STRUCTURE;
pub const D3D12_SHADER_RESOURCE_VIEW_DESC = extern struct {
Format: DXGI_FORMAT,
ViewDimension: D3D12_SRV_DIMENSION,
Shader4ComponentMapping: u32,
Anonymous: extern union {
Buffer: D3D12_BUFFER_SRV,
Texture1D: D3D12_TEX1D_SRV,
Texture1DArray: D3D12_TEX1D_ARRAY_SRV,
Texture2D: D3D12_TEX2D_SRV,
Texture2DArray: D3D12_TEX2D_ARRAY_SRV,
Texture2DMS: D3D12_TEX2DMS_SRV,
Texture2DMSArray: D3D12_TEX2DMS_ARRAY_SRV,
Texture3D: D3D12_TEX3D_SRV,
TextureCube: D3D12_TEXCUBE_SRV,
TextureCubeArray: D3D12_TEXCUBE_ARRAY_SRV,
RaytracingAccelerationStructure: D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV,
},
};
pub const D3D12_CONSTANT_BUFFER_VIEW_DESC = extern struct {
BufferLocation: u64,
SizeInBytes: u32,
};
pub const D3D12_FILTER = enum(i32) {
MIN_MAG_MIP_POINT = 0,
MIN_MAG_POINT_MIP_LINEAR = 1,
MIN_POINT_MAG_LINEAR_MIP_POINT = 4,
MIN_POINT_MAG_MIP_LINEAR = 5,
MIN_LINEAR_MAG_MIP_POINT = 16,
MIN_LINEAR_MAG_POINT_MIP_LINEAR = 17,
MIN_MAG_LINEAR_MIP_POINT = 20,
MIN_MAG_MIP_LINEAR = 21,
ANISOTROPIC = 85,
COMPARISON_MIN_MAG_MIP_POINT = 128,
COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 129,
COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 132,
COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 133,
COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 144,
COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 145,
COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 148,
COMPARISON_MIN_MAG_MIP_LINEAR = 149,
COMPARISON_ANISOTROPIC = 213,
MINIMUM_MIN_MAG_MIP_POINT = 256,
MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 257,
MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 260,
MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 261,
MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 272,
MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 273,
MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 276,
MINIMUM_MIN_MAG_MIP_LINEAR = 277,
MINIMUM_ANISOTROPIC = 341,
MAXIMUM_MIN_MAG_MIP_POINT = 384,
MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 385,
MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 388,
MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 389,
MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 400,
MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 401,
MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 404,
MAXIMUM_MIN_MAG_MIP_LINEAR = 405,
MAXIMUM_ANISOTROPIC = 469,
};
pub const D3D12_FILTER_MIN_MAG_MIP_POINT = D3D12_FILTER.MIN_MAG_MIP_POINT;
pub const D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR = D3D12_FILTER.MIN_MAG_POINT_MIP_LINEAR;
pub const D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = D3D12_FILTER.MIN_POINT_MAG_LINEAR_MIP_POINT;
pub const D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR = D3D12_FILTER.MIN_POINT_MAG_MIP_LINEAR;
pub const D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT = D3D12_FILTER.MIN_LINEAR_MAG_MIP_POINT;
pub const D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = D3D12_FILTER.MIN_LINEAR_MAG_POINT_MIP_LINEAR;
pub const D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT = D3D12_FILTER.MIN_MAG_LINEAR_MIP_POINT;
pub const D3D12_FILTER_MIN_MAG_MIP_LINEAR = D3D12_FILTER.MIN_MAG_MIP_LINEAR;
pub const D3D12_FILTER_ANISOTROPIC = D3D12_FILTER.ANISOTROPIC;
pub const D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT = D3D12_FILTER.COMPARISON_MIN_MAG_MIP_POINT;
pub const D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = D3D12_FILTER.COMPARISON_MIN_MAG_POINT_MIP_LINEAR;
pub const D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = D3D12_FILTER.COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT;
pub const D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = D3D12_FILTER.COMPARISON_MIN_POINT_MAG_MIP_LINEAR;
pub const D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = D3D12_FILTER.COMPARISON_MIN_LINEAR_MAG_MIP_POINT;
pub const D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = D3D12_FILTER.COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
pub const D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = D3D12_FILTER.COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
pub const D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = D3D12_FILTER.COMPARISON_MIN_MAG_MIP_LINEAR;
pub const D3D12_FILTER_COMPARISON_ANISOTROPIC = D3D12_FILTER.COMPARISON_ANISOTROPIC;
pub const D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT = D3D12_FILTER.MINIMUM_MIN_MAG_MIP_POINT;
pub const D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = D3D12_FILTER.MINIMUM_MIN_MAG_POINT_MIP_LINEAR;
pub const D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = D3D12_FILTER.MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT;
pub const D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = D3D12_FILTER.MINIMUM_MIN_POINT_MAG_MIP_LINEAR;
pub const D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = D3D12_FILTER.MINIMUM_MIN_LINEAR_MAG_MIP_POINT;
pub const D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = D3D12_FILTER.MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
pub const D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = D3D12_FILTER.MINIMUM_MIN_MAG_LINEAR_MIP_POINT;
pub const D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = D3D12_FILTER.MINIMUM_MIN_MAG_MIP_LINEAR;
pub const D3D12_FILTER_MINIMUM_ANISOTROPIC = D3D12_FILTER.MINIMUM_ANISOTROPIC;
pub const D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = D3D12_FILTER.MAXIMUM_MIN_MAG_MIP_POINT;
pub const D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = D3D12_FILTER.MAXIMUM_MIN_MAG_POINT_MIP_LINEAR;
pub const D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = D3D12_FILTER.MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT;
pub const D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = D3D12_FILTER.MAXIMUM_MIN_POINT_MAG_MIP_LINEAR;
pub const D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = D3D12_FILTER.MAXIMUM_MIN_LINEAR_MAG_MIP_POINT;
pub const D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = D3D12_FILTER.MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
pub const D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = D3D12_FILTER.MAXIMUM_MIN_MAG_LINEAR_MIP_POINT;
pub const D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = D3D12_FILTER.MAXIMUM_MIN_MAG_MIP_LINEAR;
pub const D3D12_FILTER_MAXIMUM_ANISOTROPIC = D3D12_FILTER.MAXIMUM_ANISOTROPIC;
pub const D3D12_FILTER_TYPE = enum(i32) {
POINT = 0,
LINEAR = 1,
};
pub const D3D12_FILTER_TYPE_POINT = D3D12_FILTER_TYPE.POINT;
pub const D3D12_FILTER_TYPE_LINEAR = D3D12_FILTER_TYPE.LINEAR;
pub const D3D12_FILTER_REDUCTION_TYPE = enum(i32) {
STANDARD = 0,
COMPARISON = 1,
MINIMUM = 2,
MAXIMUM = 3,
};
pub const D3D12_FILTER_REDUCTION_TYPE_STANDARD = D3D12_FILTER_REDUCTION_TYPE.STANDARD;
pub const D3D12_FILTER_REDUCTION_TYPE_COMPARISON = D3D12_FILTER_REDUCTION_TYPE.COMPARISON;
pub const D3D12_FILTER_REDUCTION_TYPE_MINIMUM = D3D12_FILTER_REDUCTION_TYPE.MINIMUM;
pub const D3D12_FILTER_REDUCTION_TYPE_MAXIMUM = D3D12_FILTER_REDUCTION_TYPE.MAXIMUM;
pub const D3D12_TEXTURE_ADDRESS_MODE = enum(i32) {
WRAP = 1,
MIRROR = 2,
CLAMP = 3,
BORDER = 4,
MIRROR_ONCE = 5,
};
pub const D3D12_TEXTURE_ADDRESS_MODE_WRAP = D3D12_TEXTURE_ADDRESS_MODE.WRAP;
pub const D3D12_TEXTURE_ADDRESS_MODE_MIRROR = D3D12_TEXTURE_ADDRESS_MODE.MIRROR;
pub const D3D12_TEXTURE_ADDRESS_MODE_CLAMP = D3D12_TEXTURE_ADDRESS_MODE.CLAMP;
pub const D3D12_TEXTURE_ADDRESS_MODE_BORDER = D3D12_TEXTURE_ADDRESS_MODE.BORDER;
pub const D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = D3D12_TEXTURE_ADDRESS_MODE.MIRROR_ONCE;
pub const D3D12_SAMPLER_DESC = extern struct {
Filter: D3D12_FILTER,
AddressU: D3D12_TEXTURE_ADDRESS_MODE,
AddressV: D3D12_TEXTURE_ADDRESS_MODE,
AddressW: D3D12_TEXTURE_ADDRESS_MODE,
MipLODBias: f32,
MaxAnisotropy: u32,
ComparisonFunc: D3D12_COMPARISON_FUNC,
BorderColor: [4]f32,
MinLOD: f32,
MaxLOD: f32,
};
pub const D3D12_BUFFER_UAV_FLAGS = enum(u32) {
NONE = 0,
RAW = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
RAW: u1 = 0,
}) D3D12_BUFFER_UAV_FLAGS {
return @intToEnum(D3D12_BUFFER_UAV_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_BUFFER_UAV_FLAGS.NONE) else 0)
| (if (o.RAW == 1) @enumToInt(D3D12_BUFFER_UAV_FLAGS.RAW) else 0)
);
}
};
pub const D3D12_BUFFER_UAV_FLAG_NONE = D3D12_BUFFER_UAV_FLAGS.NONE;
pub const D3D12_BUFFER_UAV_FLAG_RAW = D3D12_BUFFER_UAV_FLAGS.RAW;
pub const D3D12_BUFFER_UAV = extern struct {
FirstElement: u64,
NumElements: u32,
StructureByteStride: u32,
CounterOffsetInBytes: u64,
Flags: D3D12_BUFFER_UAV_FLAGS,
};
pub const D3D12_TEX1D_UAV = extern struct {
MipSlice: u32,
};
pub const D3D12_TEX1D_ARRAY_UAV = extern struct {
MipSlice: u32,
FirstArraySlice: u32,
ArraySize: u32,
};
pub const D3D12_TEX2D_UAV = extern struct {
MipSlice: u32,
PlaneSlice: u32,
};
pub const D3D12_TEX2D_ARRAY_UAV = extern struct {
MipSlice: u32,
FirstArraySlice: u32,
ArraySize: u32,
PlaneSlice: u32,
};
pub const D3D12_TEX3D_UAV = extern struct {
MipSlice: u32,
FirstWSlice: u32,
WSize: u32,
};
pub const D3D12_UAV_DIMENSION = enum(i32) {
UNKNOWN = 0,
BUFFER = 1,
TEXTURE1D = 2,
TEXTURE1DARRAY = 3,
TEXTURE2D = 4,
TEXTURE2DARRAY = 5,
TEXTURE3D = 8,
};
pub const D3D12_UAV_DIMENSION_UNKNOWN = D3D12_UAV_DIMENSION.UNKNOWN;
pub const D3D12_UAV_DIMENSION_BUFFER = D3D12_UAV_DIMENSION.BUFFER;
pub const D3D12_UAV_DIMENSION_TEXTURE1D = D3D12_UAV_DIMENSION.TEXTURE1D;
pub const D3D12_UAV_DIMENSION_TEXTURE1DARRAY = D3D12_UAV_DIMENSION.TEXTURE1DARRAY;
pub const D3D12_UAV_DIMENSION_TEXTURE2D = D3D12_UAV_DIMENSION.TEXTURE2D;
pub const D3D12_UAV_DIMENSION_TEXTURE2DARRAY = D3D12_UAV_DIMENSION.TEXTURE2DARRAY;
pub const D3D12_UAV_DIMENSION_TEXTURE3D = D3D12_UAV_DIMENSION.TEXTURE3D;
pub const D3D12_UNORDERED_ACCESS_VIEW_DESC = extern struct {
Format: DXGI_FORMAT,
ViewDimension: D3D12_UAV_DIMENSION,
Anonymous: extern union {
Buffer: D3D12_BUFFER_UAV,
Texture1D: D3D12_TEX1D_UAV,
Texture1DArray: D3D12_TEX1D_ARRAY_UAV,
Texture2D: D3D12_TEX2D_UAV,
Texture2DArray: D3D12_TEX2D_ARRAY_UAV,
Texture3D: D3D12_TEX3D_UAV,
},
};
pub const D3D12_BUFFER_RTV = extern struct {
FirstElement: u64,
NumElements: u32,
};
pub const D3D12_TEX1D_RTV = extern struct {
MipSlice: u32,
};
pub const D3D12_TEX1D_ARRAY_RTV = extern struct {
MipSlice: u32,
FirstArraySlice: u32,
ArraySize: u32,
};
pub const D3D12_TEX2D_RTV = extern struct {
MipSlice: u32,
PlaneSlice: u32,
};
pub const D3D12_TEX2DMS_RTV = extern struct {
UnusedField_NothingToDefine: u32,
};
pub const D3D12_TEX2D_ARRAY_RTV = extern struct {
MipSlice: u32,
FirstArraySlice: u32,
ArraySize: u32,
PlaneSlice: u32,
};
pub const D3D12_TEX2DMS_ARRAY_RTV = extern struct {
FirstArraySlice: u32,
ArraySize: u32,
};
pub const D3D12_TEX3D_RTV = extern struct {
MipSlice: u32,
FirstWSlice: u32,
WSize: u32,
};
pub const D3D12_RTV_DIMENSION = enum(i32) {
UNKNOWN = 0,
BUFFER = 1,
TEXTURE1D = 2,
TEXTURE1DARRAY = 3,
TEXTURE2D = 4,
TEXTURE2DARRAY = 5,
TEXTURE2DMS = 6,
TEXTURE2DMSARRAY = 7,
TEXTURE3D = 8,
};
pub const D3D12_RTV_DIMENSION_UNKNOWN = D3D12_RTV_DIMENSION.UNKNOWN;
pub const D3D12_RTV_DIMENSION_BUFFER = D3D12_RTV_DIMENSION.BUFFER;
pub const D3D12_RTV_DIMENSION_TEXTURE1D = D3D12_RTV_DIMENSION.TEXTURE1D;
pub const D3D12_RTV_DIMENSION_TEXTURE1DARRAY = D3D12_RTV_DIMENSION.TEXTURE1DARRAY;
pub const D3D12_RTV_DIMENSION_TEXTURE2D = D3D12_RTV_DIMENSION.TEXTURE2D;
pub const D3D12_RTV_DIMENSION_TEXTURE2DARRAY = D3D12_RTV_DIMENSION.TEXTURE2DARRAY;
pub const D3D12_RTV_DIMENSION_TEXTURE2DMS = D3D12_RTV_DIMENSION.TEXTURE2DMS;
pub const D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY = D3D12_RTV_DIMENSION.TEXTURE2DMSARRAY;
pub const D3D12_RTV_DIMENSION_TEXTURE3D = D3D12_RTV_DIMENSION.TEXTURE3D;
pub const D3D12_RENDER_TARGET_VIEW_DESC = extern struct {
Format: DXGI_FORMAT,
ViewDimension: D3D12_RTV_DIMENSION,
Anonymous: extern union {
Buffer: D3D12_BUFFER_RTV,
Texture1D: D3D12_TEX1D_RTV,
Texture1DArray: D3D12_TEX1D_ARRAY_RTV,
Texture2D: D3D12_TEX2D_RTV,
Texture2DArray: D3D12_TEX2D_ARRAY_RTV,
Texture2DMS: D3D12_TEX2DMS_RTV,
Texture2DMSArray: D3D12_TEX2DMS_ARRAY_RTV,
Texture3D: D3D12_TEX3D_RTV,
},
};
pub const D3D12_TEX1D_DSV = extern struct {
MipSlice: u32,
};
pub const D3D12_TEX1D_ARRAY_DSV = extern struct {
MipSlice: u32,
FirstArraySlice: u32,
ArraySize: u32,
};
pub const D3D12_TEX2D_DSV = extern struct {
MipSlice: u32,
};
pub const D3D12_TEX2D_ARRAY_DSV = extern struct {
MipSlice: u32,
FirstArraySlice: u32,
ArraySize: u32,
};
pub const D3D12_TEX2DMS_DSV = extern struct {
UnusedField_NothingToDefine: u32,
};
pub const D3D12_TEX2DMS_ARRAY_DSV = extern struct {
FirstArraySlice: u32,
ArraySize: u32,
};
pub const D3D12_DSV_FLAGS = enum(u32) {
NONE = 0,
READ_ONLY_DEPTH = 1,
READ_ONLY_STENCIL = 2,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
READ_ONLY_DEPTH: u1 = 0,
READ_ONLY_STENCIL: u1 = 0,
}) D3D12_DSV_FLAGS {
return @intToEnum(D3D12_DSV_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_DSV_FLAGS.NONE) else 0)
| (if (o.READ_ONLY_DEPTH == 1) @enumToInt(D3D12_DSV_FLAGS.READ_ONLY_DEPTH) else 0)
| (if (o.READ_ONLY_STENCIL == 1) @enumToInt(D3D12_DSV_FLAGS.READ_ONLY_STENCIL) else 0)
);
}
};
pub const D3D12_DSV_FLAG_NONE = D3D12_DSV_FLAGS.NONE;
pub const D3D12_DSV_FLAG_READ_ONLY_DEPTH = D3D12_DSV_FLAGS.READ_ONLY_DEPTH;
pub const D3D12_DSV_FLAG_READ_ONLY_STENCIL = D3D12_DSV_FLAGS.READ_ONLY_STENCIL;
pub const D3D12_DSV_DIMENSION = enum(i32) {
UNKNOWN = 0,
TEXTURE1D = 1,
TEXTURE1DARRAY = 2,
TEXTURE2D = 3,
TEXTURE2DARRAY = 4,
TEXTURE2DMS = 5,
TEXTURE2DMSARRAY = 6,
};
pub const D3D12_DSV_DIMENSION_UNKNOWN = D3D12_DSV_DIMENSION.UNKNOWN;
pub const D3D12_DSV_DIMENSION_TEXTURE1D = D3D12_DSV_DIMENSION.TEXTURE1D;
pub const D3D12_DSV_DIMENSION_TEXTURE1DARRAY = D3D12_DSV_DIMENSION.TEXTURE1DARRAY;
pub const D3D12_DSV_DIMENSION_TEXTURE2D = D3D12_DSV_DIMENSION.TEXTURE2D;
pub const D3D12_DSV_DIMENSION_TEXTURE2DARRAY = D3D12_DSV_DIMENSION.TEXTURE2DARRAY;
pub const D3D12_DSV_DIMENSION_TEXTURE2DMS = D3D12_DSV_DIMENSION.TEXTURE2DMS;
pub const D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY = D3D12_DSV_DIMENSION.TEXTURE2DMSARRAY;
pub const D3D12_DEPTH_STENCIL_VIEW_DESC = extern struct {
Format: DXGI_FORMAT,
ViewDimension: D3D12_DSV_DIMENSION,
Flags: D3D12_DSV_FLAGS,
Anonymous: extern union {
Texture1D: D3D12_TEX1D_DSV,
Texture1DArray: D3D12_TEX1D_ARRAY_DSV,
Texture2D: D3D12_TEX2D_DSV,
Texture2DArray: D3D12_TEX2D_ARRAY_DSV,
Texture2DMS: D3D12_TEX2DMS_DSV,
Texture2DMSArray: D3D12_TEX2DMS_ARRAY_DSV,
},
};
pub const D3D12_CLEAR_FLAGS = enum(u32) {
DEPTH = 1,
STENCIL = 2,
_,
pub fn initFlags(o: struct {
DEPTH: u1 = 0,
STENCIL: u1 = 0,
}) D3D12_CLEAR_FLAGS {
return @intToEnum(D3D12_CLEAR_FLAGS,
(if (o.DEPTH == 1) @enumToInt(D3D12_CLEAR_FLAGS.DEPTH) else 0)
| (if (o.STENCIL == 1) @enumToInt(D3D12_CLEAR_FLAGS.STENCIL) else 0)
);
}
};
pub const D3D12_CLEAR_FLAG_DEPTH = D3D12_CLEAR_FLAGS.DEPTH;
pub const D3D12_CLEAR_FLAG_STENCIL = D3D12_CLEAR_FLAGS.STENCIL;
pub const D3D12_FENCE_FLAGS = enum(u32) {
NONE = 0,
SHARED = 1,
SHARED_CROSS_ADAPTER = 2,
NON_MONITORED = 4,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
SHARED: u1 = 0,
SHARED_CROSS_ADAPTER: u1 = 0,
NON_MONITORED: u1 = 0,
}) D3D12_FENCE_FLAGS {
return @intToEnum(D3D12_FENCE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_FENCE_FLAGS.NONE) else 0)
| (if (o.SHARED == 1) @enumToInt(D3D12_FENCE_FLAGS.SHARED) else 0)
| (if (o.SHARED_CROSS_ADAPTER == 1) @enumToInt(D3D12_FENCE_FLAGS.SHARED_CROSS_ADAPTER) else 0)
| (if (o.NON_MONITORED == 1) @enumToInt(D3D12_FENCE_FLAGS.NON_MONITORED) else 0)
);
}
};
pub const D3D12_FENCE_FLAG_NONE = D3D12_FENCE_FLAGS.NONE;
pub const D3D12_FENCE_FLAG_SHARED = D3D12_FENCE_FLAGS.SHARED;
pub const D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = D3D12_FENCE_FLAGS.SHARED_CROSS_ADAPTER;
pub const D3D12_FENCE_FLAG_NON_MONITORED = D3D12_FENCE_FLAGS.NON_MONITORED;
pub const D3D12_DESCRIPTOR_HEAP_TYPE = enum(i32) {
CBV_SRV_UAV = 0,
SAMPLER = 1,
RTV = 2,
DSV = 3,
NUM_TYPES = 4,
};
pub const D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV = D3D12_DESCRIPTOR_HEAP_TYPE.CBV_SRV_UAV;
pub const D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER = D3D12_DESCRIPTOR_HEAP_TYPE.SAMPLER;
pub const D3D12_DESCRIPTOR_HEAP_TYPE_RTV = D3D12_DESCRIPTOR_HEAP_TYPE.RTV;
pub const D3D12_DESCRIPTOR_HEAP_TYPE_DSV = D3D12_DESCRIPTOR_HEAP_TYPE.DSV;
pub const D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES = D3D12_DESCRIPTOR_HEAP_TYPE.NUM_TYPES;
pub const D3D12_DESCRIPTOR_HEAP_FLAGS = enum(u32) {
NONE = 0,
SHADER_VISIBLE = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
SHADER_VISIBLE: u1 = 0,
}) D3D12_DESCRIPTOR_HEAP_FLAGS {
return @intToEnum(D3D12_DESCRIPTOR_HEAP_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_DESCRIPTOR_HEAP_FLAGS.NONE) else 0)
| (if (o.SHADER_VISIBLE == 1) @enumToInt(D3D12_DESCRIPTOR_HEAP_FLAGS.SHADER_VISIBLE) else 0)
);
}
};
pub const D3D12_DESCRIPTOR_HEAP_FLAG_NONE = D3D12_DESCRIPTOR_HEAP_FLAGS.NONE;
pub const D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = D3D12_DESCRIPTOR_HEAP_FLAGS.SHADER_VISIBLE;
pub const D3D12_DESCRIPTOR_HEAP_DESC = extern struct {
Type: D3D12_DESCRIPTOR_HEAP_TYPE,
NumDescriptors: u32,
Flags: D3D12_DESCRIPTOR_HEAP_FLAGS,
NodeMask: u32,
};
pub const D3D12_DESCRIPTOR_RANGE_TYPE = enum(i32) {
SRV = 0,
UAV = 1,
CBV = 2,
SAMPLER = 3,
};
pub const D3D12_DESCRIPTOR_RANGE_TYPE_SRV = D3D12_DESCRIPTOR_RANGE_TYPE.SRV;
pub const D3D12_DESCRIPTOR_RANGE_TYPE_UAV = D3D12_DESCRIPTOR_RANGE_TYPE.UAV;
pub const D3D12_DESCRIPTOR_RANGE_TYPE_CBV = D3D12_DESCRIPTOR_RANGE_TYPE.CBV;
pub const D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER = D3D12_DESCRIPTOR_RANGE_TYPE.SAMPLER;
pub const D3D12_DESCRIPTOR_RANGE = extern struct {
RangeType: D3D12_DESCRIPTOR_RANGE_TYPE,
NumDescriptors: u32,
BaseShaderRegister: u32,
RegisterSpace: u32,
OffsetInDescriptorsFromTableStart: u32,
};
pub const D3D12_ROOT_DESCRIPTOR_TABLE = extern struct {
NumDescriptorRanges: u32,
pDescriptorRanges: ?*const D3D12_DESCRIPTOR_RANGE,
};
pub const D3D12_ROOT_CONSTANTS = extern struct {
ShaderRegister: u32,
RegisterSpace: u32,
Num32BitValues: u32,
};
pub const D3D12_ROOT_DESCRIPTOR = extern struct {
ShaderRegister: u32,
RegisterSpace: u32,
};
pub const D3D12_SHADER_VISIBILITY = enum(i32) {
ALL = 0,
VERTEX = 1,
HULL = 2,
DOMAIN = 3,
GEOMETRY = 4,
PIXEL = 5,
AMPLIFICATION = 6,
MESH = 7,
};
pub const D3D12_SHADER_VISIBILITY_ALL = D3D12_SHADER_VISIBILITY.ALL;
pub const D3D12_SHADER_VISIBILITY_VERTEX = D3D12_SHADER_VISIBILITY.VERTEX;
pub const D3D12_SHADER_VISIBILITY_HULL = D3D12_SHADER_VISIBILITY.HULL;
pub const D3D12_SHADER_VISIBILITY_DOMAIN = D3D12_SHADER_VISIBILITY.DOMAIN;
pub const D3D12_SHADER_VISIBILITY_GEOMETRY = D3D12_SHADER_VISIBILITY.GEOMETRY;
pub const D3D12_SHADER_VISIBILITY_PIXEL = D3D12_SHADER_VISIBILITY.PIXEL;
pub const D3D12_SHADER_VISIBILITY_AMPLIFICATION = D3D12_SHADER_VISIBILITY.AMPLIFICATION;
pub const D3D12_SHADER_VISIBILITY_MESH = D3D12_SHADER_VISIBILITY.MESH;
pub const D3D12_ROOT_PARAMETER_TYPE = enum(i32) {
DESCRIPTOR_TABLE = 0,
@"32BIT_CONSTANTS" = 1,
CBV = 2,
SRV = 3,
UAV = 4,
};
pub const D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE = D3D12_ROOT_PARAMETER_TYPE.DESCRIPTOR_TABLE;
pub const D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS = D3D12_ROOT_PARAMETER_TYPE.@"32BIT_CONSTANTS";
pub const D3D12_ROOT_PARAMETER_TYPE_CBV = D3D12_ROOT_PARAMETER_TYPE.CBV;
pub const D3D12_ROOT_PARAMETER_TYPE_SRV = D3D12_ROOT_PARAMETER_TYPE.SRV;
pub const D3D12_ROOT_PARAMETER_TYPE_UAV = D3D12_ROOT_PARAMETER_TYPE.UAV;
pub const D3D12_ROOT_PARAMETER = extern struct {
ParameterType: D3D12_ROOT_PARAMETER_TYPE,
Anonymous: extern union {
DescriptorTable: D3D12_ROOT_DESCRIPTOR_TABLE,
Constants: D3D12_ROOT_CONSTANTS,
Descriptor: D3D12_ROOT_DESCRIPTOR,
},
ShaderVisibility: D3D12_SHADER_VISIBILITY,
};
pub const D3D12_ROOT_SIGNATURE_FLAGS = enum(u32) {
NONE = 0,
ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 1,
DENY_VERTEX_SHADER_ROOT_ACCESS = 2,
DENY_HULL_SHADER_ROOT_ACCESS = 4,
DENY_DOMAIN_SHADER_ROOT_ACCESS = 8,
DENY_GEOMETRY_SHADER_ROOT_ACCESS = 16,
DENY_PIXEL_SHADER_ROOT_ACCESS = 32,
ALLOW_STREAM_OUTPUT = 64,
LOCAL_ROOT_SIGNATURE = 128,
DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = 256,
DENY_MESH_SHADER_ROOT_ACCESS = 512,
CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED = 1024,
SAMPLER_HEAP_DIRECTLY_INDEXED = 2048,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT: u1 = 0,
DENY_VERTEX_SHADER_ROOT_ACCESS: u1 = 0,
DENY_HULL_SHADER_ROOT_ACCESS: u1 = 0,
DENY_DOMAIN_SHADER_ROOT_ACCESS: u1 = 0,
DENY_GEOMETRY_SHADER_ROOT_ACCESS: u1 = 0,
DENY_PIXEL_SHADER_ROOT_ACCESS: u1 = 0,
ALLOW_STREAM_OUTPUT: u1 = 0,
LOCAL_ROOT_SIGNATURE: u1 = 0,
DENY_AMPLIFICATION_SHADER_ROOT_ACCESS: u1 = 0,
DENY_MESH_SHADER_ROOT_ACCESS: u1 = 0,
CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED: u1 = 0,
SAMPLER_HEAP_DIRECTLY_INDEXED: u1 = 0,
}) D3D12_ROOT_SIGNATURE_FLAGS {
return @intToEnum(D3D12_ROOT_SIGNATURE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.NONE) else 0)
| (if (o.ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT) else 0)
| (if (o.DENY_VERTEX_SHADER_ROOT_ACCESS == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.DENY_VERTEX_SHADER_ROOT_ACCESS) else 0)
| (if (o.DENY_HULL_SHADER_ROOT_ACCESS == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.DENY_HULL_SHADER_ROOT_ACCESS) else 0)
| (if (o.DENY_DOMAIN_SHADER_ROOT_ACCESS == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.DENY_DOMAIN_SHADER_ROOT_ACCESS) else 0)
| (if (o.DENY_GEOMETRY_SHADER_ROOT_ACCESS == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.DENY_GEOMETRY_SHADER_ROOT_ACCESS) else 0)
| (if (o.DENY_PIXEL_SHADER_ROOT_ACCESS == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.DENY_PIXEL_SHADER_ROOT_ACCESS) else 0)
| (if (o.ALLOW_STREAM_OUTPUT == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.ALLOW_STREAM_OUTPUT) else 0)
| (if (o.LOCAL_ROOT_SIGNATURE == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.LOCAL_ROOT_SIGNATURE) else 0)
| (if (o.DENY_AMPLIFICATION_SHADER_ROOT_ACCESS == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.DENY_AMPLIFICATION_SHADER_ROOT_ACCESS) else 0)
| (if (o.DENY_MESH_SHADER_ROOT_ACCESS == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.DENY_MESH_SHADER_ROOT_ACCESS) else 0)
| (if (o.CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED) else 0)
| (if (o.SAMPLER_HEAP_DIRECTLY_INDEXED == 1) @enumToInt(D3D12_ROOT_SIGNATURE_FLAGS.SAMPLER_HEAP_DIRECTLY_INDEXED) else 0)
);
}
};
pub const D3D12_ROOT_SIGNATURE_FLAG_NONE = D3D12_ROOT_SIGNATURE_FLAGS.NONE;
pub const D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = D3D12_ROOT_SIGNATURE_FLAGS.ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
pub const D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS = D3D12_ROOT_SIGNATURE_FLAGS.DENY_VERTEX_SHADER_ROOT_ACCESS;
pub const D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS = D3D12_ROOT_SIGNATURE_FLAGS.DENY_HULL_SHADER_ROOT_ACCESS;
pub const D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS = D3D12_ROOT_SIGNATURE_FLAGS.DENY_DOMAIN_SHADER_ROOT_ACCESS;
pub const D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = D3D12_ROOT_SIGNATURE_FLAGS.DENY_GEOMETRY_SHADER_ROOT_ACCESS;
pub const D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = D3D12_ROOT_SIGNATURE_FLAGS.DENY_PIXEL_SHADER_ROOT_ACCESS;
pub const D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = D3D12_ROOT_SIGNATURE_FLAGS.ALLOW_STREAM_OUTPUT;
pub const D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE = D3D12_ROOT_SIGNATURE_FLAGS.LOCAL_ROOT_SIGNATURE;
pub const D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = D3D12_ROOT_SIGNATURE_FLAGS.DENY_AMPLIFICATION_SHADER_ROOT_ACCESS;
pub const D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS = D3D12_ROOT_SIGNATURE_FLAGS.DENY_MESH_SHADER_ROOT_ACCESS;
pub const D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED = D3D12_ROOT_SIGNATURE_FLAGS.CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED;
pub const D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED = D3D12_ROOT_SIGNATURE_FLAGS.SAMPLER_HEAP_DIRECTLY_INDEXED;
pub const D3D12_STATIC_BORDER_COLOR = enum(i32) {
TRANSPARENT_BLACK = 0,
OPAQUE_BLACK = 1,
OPAQUE_WHITE = 2,
};
pub const D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK = D3D12_STATIC_BORDER_COLOR.TRANSPARENT_BLACK;
pub const D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK = D3D12_STATIC_BORDER_COLOR.OPAQUE_BLACK;
pub const D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE = D3D12_STATIC_BORDER_COLOR.OPAQUE_WHITE;
pub const D3D12_STATIC_SAMPLER_DESC = extern struct {
Filter: D3D12_FILTER,
AddressU: D3D12_TEXTURE_ADDRESS_MODE,
AddressV: D3D12_TEXTURE_ADDRESS_MODE,
AddressW: D3D12_TEXTURE_ADDRESS_MODE,
MipLODBias: f32,
MaxAnisotropy: u32,
ComparisonFunc: D3D12_COMPARISON_FUNC,
BorderColor: D3D12_STATIC_BORDER_COLOR,
MinLOD: f32,
MaxLOD: f32,
ShaderRegister: u32,
RegisterSpace: u32,
ShaderVisibility: D3D12_SHADER_VISIBILITY,
};
pub const D3D12_ROOT_SIGNATURE_DESC = extern struct {
NumParameters: u32,
pParameters: ?*const D3D12_ROOT_PARAMETER,
NumStaticSamplers: u32,
pStaticSamplers: ?*const D3D12_STATIC_SAMPLER_DESC,
Flags: D3D12_ROOT_SIGNATURE_FLAGS,
};
pub const D3D12_DESCRIPTOR_RANGE_FLAGS = enum(u32) {
NONE = 0,
DESCRIPTORS_VOLATILE = 1,
DATA_VOLATILE = 2,
DATA_STATIC_WHILE_SET_AT_EXECUTE = 4,
DATA_STATIC = 8,
DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 65536,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
DESCRIPTORS_VOLATILE: u1 = 0,
DATA_VOLATILE: u1 = 0,
DATA_STATIC_WHILE_SET_AT_EXECUTE: u1 = 0,
DATA_STATIC: u1 = 0,
DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: u1 = 0,
}) D3D12_DESCRIPTOR_RANGE_FLAGS {
return @intToEnum(D3D12_DESCRIPTOR_RANGE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_DESCRIPTOR_RANGE_FLAGS.NONE) else 0)
| (if (o.DESCRIPTORS_VOLATILE == 1) @enumToInt(D3D12_DESCRIPTOR_RANGE_FLAGS.DESCRIPTORS_VOLATILE) else 0)
| (if (o.DATA_VOLATILE == 1) @enumToInt(D3D12_DESCRIPTOR_RANGE_FLAGS.DATA_VOLATILE) else 0)
| (if (o.DATA_STATIC_WHILE_SET_AT_EXECUTE == 1) @enumToInt(D3D12_DESCRIPTOR_RANGE_FLAGS.DATA_STATIC_WHILE_SET_AT_EXECUTE) else 0)
| (if (o.DATA_STATIC == 1) @enumToInt(D3D12_DESCRIPTOR_RANGE_FLAGS.DATA_STATIC) else 0)
| (if (o.DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS == 1) @enumToInt(D3D12_DESCRIPTOR_RANGE_FLAGS.DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS) else 0)
);
}
};
pub const D3D12_DESCRIPTOR_RANGE_FLAG_NONE = D3D12_DESCRIPTOR_RANGE_FLAGS.NONE;
pub const D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE = D3D12_DESCRIPTOR_RANGE_FLAGS.DESCRIPTORS_VOLATILE;
pub const D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE = D3D12_DESCRIPTOR_RANGE_FLAGS.DATA_VOLATILE;
pub const D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = D3D12_DESCRIPTOR_RANGE_FLAGS.DATA_STATIC_WHILE_SET_AT_EXECUTE;
pub const D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC = D3D12_DESCRIPTOR_RANGE_FLAGS.DATA_STATIC;
pub const D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = D3D12_DESCRIPTOR_RANGE_FLAGS.DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS;
pub const D3D12_DESCRIPTOR_RANGE1 = extern struct {
RangeType: D3D12_DESCRIPTOR_RANGE_TYPE,
NumDescriptors: u32,
BaseShaderRegister: u32,
RegisterSpace: u32,
Flags: D3D12_DESCRIPTOR_RANGE_FLAGS,
OffsetInDescriptorsFromTableStart: u32,
};
pub const D3D12_ROOT_DESCRIPTOR_TABLE1 = extern struct {
NumDescriptorRanges: u32,
pDescriptorRanges: ?*const D3D12_DESCRIPTOR_RANGE1,
};
pub const D3D12_ROOT_DESCRIPTOR_FLAGS = enum(u32) {
NONE = 0,
DATA_VOLATILE = 2,
DATA_STATIC_WHILE_SET_AT_EXECUTE = 4,
DATA_STATIC = 8,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
DATA_VOLATILE: u1 = 0,
DATA_STATIC_WHILE_SET_AT_EXECUTE: u1 = 0,
DATA_STATIC: u1 = 0,
}) D3D12_ROOT_DESCRIPTOR_FLAGS {
return @intToEnum(D3D12_ROOT_DESCRIPTOR_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_ROOT_DESCRIPTOR_FLAGS.NONE) else 0)
| (if (o.DATA_VOLATILE == 1) @enumToInt(D3D12_ROOT_DESCRIPTOR_FLAGS.DATA_VOLATILE) else 0)
| (if (o.DATA_STATIC_WHILE_SET_AT_EXECUTE == 1) @enumToInt(D3D12_ROOT_DESCRIPTOR_FLAGS.DATA_STATIC_WHILE_SET_AT_EXECUTE) else 0)
| (if (o.DATA_STATIC == 1) @enumToInt(D3D12_ROOT_DESCRIPTOR_FLAGS.DATA_STATIC) else 0)
);
}
};
pub const D3D12_ROOT_DESCRIPTOR_FLAG_NONE = D3D12_ROOT_DESCRIPTOR_FLAGS.NONE;
pub const D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE = D3D12_ROOT_DESCRIPTOR_FLAGS.DATA_VOLATILE;
pub const D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = D3D12_ROOT_DESCRIPTOR_FLAGS.DATA_STATIC_WHILE_SET_AT_EXECUTE;
pub const D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC = D3D12_ROOT_DESCRIPTOR_FLAGS.DATA_STATIC;
pub const D3D12_ROOT_DESCRIPTOR1 = extern struct {
ShaderRegister: u32,
RegisterSpace: u32,
Flags: D3D12_ROOT_DESCRIPTOR_FLAGS,
};
pub const D3D12_ROOT_PARAMETER1 = extern struct {
ParameterType: D3D12_ROOT_PARAMETER_TYPE,
Anonymous: extern union {
DescriptorTable: D3D12_ROOT_DESCRIPTOR_TABLE1,
Constants: D3D12_ROOT_CONSTANTS,
Descriptor: D3D12_ROOT_DESCRIPTOR1,
},
ShaderVisibility: D3D12_SHADER_VISIBILITY,
};
pub const D3D12_ROOT_SIGNATURE_DESC1 = extern struct {
NumParameters: u32,
pParameters: ?*const D3D12_ROOT_PARAMETER1,
NumStaticSamplers: u32,
pStaticSamplers: ?*const D3D12_STATIC_SAMPLER_DESC,
Flags: D3D12_ROOT_SIGNATURE_FLAGS,
};
pub const D3D12_VERSIONED_ROOT_SIGNATURE_DESC = extern struct {
Version: D3D_ROOT_SIGNATURE_VERSION,
Anonymous: extern union {
Desc_1_0: D3D12_ROOT_SIGNATURE_DESC,
Desc_1_1: D3D12_ROOT_SIGNATURE_DESC1,
},
};
const IID_ID3D12RootSignatureDeserializer_Value = Guid.initString("34ab647b-3cc8-46ac-841b-c0965645c046");
pub const IID_ID3D12RootSignatureDeserializer = &IID_ID3D12RootSignatureDeserializer_Value;
pub const ID3D12RootSignatureDeserializer = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetRootSignatureDesc: fn(
self: *const ID3D12RootSignatureDeserializer,
) callconv(@import("std").os.windows.WINAPI) ?*D3D12_ROOT_SIGNATURE_DESC,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12RootSignatureDeserializer_GetRootSignatureDesc(self: *const T) callconv(.Inline) ?*D3D12_ROOT_SIGNATURE_DESC {
return @ptrCast(*const ID3D12RootSignatureDeserializer.VTable, self.vtable).GetRootSignatureDesc(@ptrCast(*const ID3D12RootSignatureDeserializer, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12VersionedRootSignatureDeserializer_Value = Guid.initString("7f91ce67-090c-4bb7-b78e-ed8ff2e31da0");
pub const IID_ID3D12VersionedRootSignatureDeserializer = &IID_ID3D12VersionedRootSignatureDeserializer_Value;
pub const ID3D12VersionedRootSignatureDeserializer = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetRootSignatureDescAtVersion: fn(
self: *const ID3D12VersionedRootSignatureDeserializer,
convertToVersion: D3D_ROOT_SIGNATURE_VERSION,
ppDesc: ?*const ?*D3D12_VERSIONED_ROOT_SIGNATURE_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetUnconvertedRootSignatureDesc: fn(
self: *const ID3D12VersionedRootSignatureDeserializer,
) callconv(@import("std").os.windows.WINAPI) ?*D3D12_VERSIONED_ROOT_SIGNATURE_DESC,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12VersionedRootSignatureDeserializer_GetRootSignatureDescAtVersion(self: *const T, convertToVersion: D3D_ROOT_SIGNATURE_VERSION, ppDesc: ?*const ?*D3D12_VERSIONED_ROOT_SIGNATURE_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12VersionedRootSignatureDeserializer.VTable, self.vtable).GetRootSignatureDescAtVersion(@ptrCast(*const ID3D12VersionedRootSignatureDeserializer, self), convertToVersion, ppDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12VersionedRootSignatureDeserializer_GetUnconvertedRootSignatureDesc(self: *const T) callconv(.Inline) ?*D3D12_VERSIONED_ROOT_SIGNATURE_DESC {
return @ptrCast(*const ID3D12VersionedRootSignatureDeserializer.VTable, self.vtable).GetUnconvertedRootSignatureDesc(@ptrCast(*const ID3D12VersionedRootSignatureDeserializer, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const PFN_D3D12_SERIALIZE_ROOT_SIGNATURE = fn(
pRootSignature: ?*const D3D12_ROOT_SIGNATURE_DESC,
Version: D3D_ROOT_SIGNATURE_VERSION,
ppBlob: ?*?*ID3DBlob,
ppErrorBlob: ?*?*ID3DBlob,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER = fn(
// TODO: what to do with BytesParamIndex 1?
pSrcData: ?*const anyopaque,
SrcDataSizeInBytes: usize,
pRootSignatureDeserializerInterface: ?*const Guid,
ppRootSignatureDeserializer: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE = fn(
pRootSignature: ?*const D3D12_VERSIONED_ROOT_SIGNATURE_DESC,
ppBlob: ?*?*ID3DBlob,
ppErrorBlob: ?*?*ID3DBlob,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER = fn(
// TODO: what to do with BytesParamIndex 1?
pSrcData: ?*const anyopaque,
SrcDataSizeInBytes: usize,
pRootSignatureDeserializerInterface: ?*const Guid,
ppRootSignatureDeserializer: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const D3D12_CPU_DESCRIPTOR_HANDLE = extern struct {
ptr: usize,
};
pub const D3D12_GPU_DESCRIPTOR_HANDLE = extern struct {
ptr: u64,
};
pub const D3D12_DISCARD_REGION = extern struct {
NumRects: u32,
pRects: ?*const RECT,
FirstSubresource: u32,
NumSubresources: u32,
};
pub const D3D12_QUERY_HEAP_TYPE = enum(i32) {
OCCLUSION = 0,
TIMESTAMP = 1,
PIPELINE_STATISTICS = 2,
SO_STATISTICS = 3,
VIDEO_DECODE_STATISTICS = 4,
COPY_QUEUE_TIMESTAMP = 5,
PIPELINE_STATISTICS1 = 7,
};
pub const D3D12_QUERY_HEAP_TYPE_OCCLUSION = D3D12_QUERY_HEAP_TYPE.OCCLUSION;
pub const D3D12_QUERY_HEAP_TYPE_TIMESTAMP = D3D12_QUERY_HEAP_TYPE.TIMESTAMP;
pub const D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS = D3D12_QUERY_HEAP_TYPE.PIPELINE_STATISTICS;
pub const D3D12_QUERY_HEAP_TYPE_SO_STATISTICS = D3D12_QUERY_HEAP_TYPE.SO_STATISTICS;
pub const D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS = D3D12_QUERY_HEAP_TYPE.VIDEO_DECODE_STATISTICS;
pub const D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP = D3D12_QUERY_HEAP_TYPE.COPY_QUEUE_TIMESTAMP;
pub const D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS1 = D3D12_QUERY_HEAP_TYPE.PIPELINE_STATISTICS1;
pub const D3D12_QUERY_HEAP_DESC = extern struct {
Type: D3D12_QUERY_HEAP_TYPE,
Count: u32,
NodeMask: u32,
};
pub const D3D12_QUERY_TYPE = enum(i32) {
OCCLUSION = 0,
BINARY_OCCLUSION = 1,
TIMESTAMP = 2,
PIPELINE_STATISTICS = 3,
SO_STATISTICS_STREAM0 = 4,
SO_STATISTICS_STREAM1 = 5,
SO_STATISTICS_STREAM2 = 6,
SO_STATISTICS_STREAM3 = 7,
VIDEO_DECODE_STATISTICS = 8,
PIPELINE_STATISTICS1 = 10,
};
pub const D3D12_QUERY_TYPE_OCCLUSION = D3D12_QUERY_TYPE.OCCLUSION;
pub const D3D12_QUERY_TYPE_BINARY_OCCLUSION = D3D12_QUERY_TYPE.BINARY_OCCLUSION;
pub const D3D12_QUERY_TYPE_TIMESTAMP = D3D12_QUERY_TYPE.TIMESTAMP;
pub const D3D12_QUERY_TYPE_PIPELINE_STATISTICS = D3D12_QUERY_TYPE.PIPELINE_STATISTICS;
pub const D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0 = D3D12_QUERY_TYPE.SO_STATISTICS_STREAM0;
pub const D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 = D3D12_QUERY_TYPE.SO_STATISTICS_STREAM1;
pub const D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 = D3D12_QUERY_TYPE.SO_STATISTICS_STREAM2;
pub const D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 = D3D12_QUERY_TYPE.SO_STATISTICS_STREAM3;
pub const D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS = D3D12_QUERY_TYPE.VIDEO_DECODE_STATISTICS;
pub const D3D12_QUERY_TYPE_PIPELINE_STATISTICS1 = D3D12_QUERY_TYPE.PIPELINE_STATISTICS1;
pub const D3D12_PREDICATION_OP = enum(i32) {
EQUAL_ZERO = 0,
NOT_EQUAL_ZERO = 1,
};
pub const D3D12_PREDICATION_OP_EQUAL_ZERO = D3D12_PREDICATION_OP.EQUAL_ZERO;
pub const D3D12_PREDICATION_OP_NOT_EQUAL_ZERO = D3D12_PREDICATION_OP.NOT_EQUAL_ZERO;
pub const D3D12_QUERY_DATA_PIPELINE_STATISTICS = extern struct {
IAVertices: u64,
IAPrimitives: u64,
VSInvocations: u64,
GSInvocations: u64,
GSPrimitives: u64,
CInvocations: u64,
CPrimitives: u64,
PSInvocations: u64,
HSInvocations: u64,
DSInvocations: u64,
CSInvocations: u64,
};
pub const D3D12_QUERY_DATA_PIPELINE_STATISTICS1 = extern struct {
IAVertices: u64,
IAPrimitives: u64,
VSInvocations: u64,
GSInvocations: u64,
GSPrimitives: u64,
CInvocations: u64,
CPrimitives: u64,
PSInvocations: u64,
HSInvocations: u64,
DSInvocations: u64,
CSInvocations: u64,
ASInvocations: u64,
MSInvocations: u64,
MSPrimitives: u64,
};
pub const D3D12_QUERY_DATA_SO_STATISTICS = extern struct {
NumPrimitivesWritten: u64,
PrimitivesStorageNeeded: u64,
};
pub const D3D12_STREAM_OUTPUT_BUFFER_VIEW = extern struct {
BufferLocation: u64,
SizeInBytes: u64,
BufferFilledSizeLocation: u64,
};
pub const D3D12_DRAW_ARGUMENTS = extern struct {
VertexCountPerInstance: u32,
InstanceCount: u32,
StartVertexLocation: u32,
StartInstanceLocation: u32,
};
pub const D3D12_DRAW_INDEXED_ARGUMENTS = extern struct {
IndexCountPerInstance: u32,
InstanceCount: u32,
StartIndexLocation: u32,
BaseVertexLocation: i32,
StartInstanceLocation: u32,
};
pub const D3D12_DISPATCH_ARGUMENTS = extern struct {
ThreadGroupCountX: u32,
ThreadGroupCountY: u32,
ThreadGroupCountZ: u32,
};
pub const D3D12_VERTEX_BUFFER_VIEW = extern struct {
BufferLocation: u64,
SizeInBytes: u32,
StrideInBytes: u32,
};
pub const D3D12_INDEX_BUFFER_VIEW = extern struct {
BufferLocation: u64,
SizeInBytes: u32,
Format: DXGI_FORMAT,
};
pub const D3D12_INDIRECT_ARGUMENT_TYPE = enum(i32) {
DRAW = 0,
DRAW_INDEXED = 1,
DISPATCH = 2,
VERTEX_BUFFER_VIEW = 3,
INDEX_BUFFER_VIEW = 4,
CONSTANT = 5,
CONSTANT_BUFFER_VIEW = 6,
SHADER_RESOURCE_VIEW = 7,
UNORDERED_ACCESS_VIEW = 8,
DISPATCH_RAYS = 9,
DISPATCH_MESH = 10,
};
pub const D3D12_INDIRECT_ARGUMENT_TYPE_DRAW = D3D12_INDIRECT_ARGUMENT_TYPE.DRAW;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED = D3D12_INDIRECT_ARGUMENT_TYPE.DRAW_INDEXED;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH = D3D12_INDIRECT_ARGUMENT_TYPE.DISPATCH;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW = D3D12_INDIRECT_ARGUMENT_TYPE.VERTEX_BUFFER_VIEW;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW = D3D12_INDIRECT_ARGUMENT_TYPE.INDEX_BUFFER_VIEW;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT = D3D12_INDIRECT_ARGUMENT_TYPE.CONSTANT;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW = D3D12_INDIRECT_ARGUMENT_TYPE.CONSTANT_BUFFER_VIEW;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW = D3D12_INDIRECT_ARGUMENT_TYPE.SHADER_RESOURCE_VIEW;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW = D3D12_INDIRECT_ARGUMENT_TYPE.UNORDERED_ACCESS_VIEW;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS = D3D12_INDIRECT_ARGUMENT_TYPE.DISPATCH_RAYS;
pub const D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH = D3D12_INDIRECT_ARGUMENT_TYPE.DISPATCH_MESH;
pub const D3D12_INDIRECT_ARGUMENT_DESC = extern struct {
Type: D3D12_INDIRECT_ARGUMENT_TYPE,
Anonymous: extern union {
VertexBuffer: extern struct {
Slot: u32,
},
Constant: extern struct {
RootParameterIndex: u32,
DestOffsetIn32BitValues: u32,
Num32BitValuesToSet: u32,
},
ConstantBufferView: extern struct {
RootParameterIndex: u32,
},
ShaderResourceView: extern struct {
RootParameterIndex: u32,
},
UnorderedAccessView: extern struct {
RootParameterIndex: u32,
},
},
};
pub const D3D12_COMMAND_SIGNATURE_DESC = extern struct {
ByteStride: u32,
NumArgumentDescs: u32,
pArgumentDescs: ?*const D3D12_INDIRECT_ARGUMENT_DESC,
NodeMask: u32,
};
const IID_ID3D12Pageable_Value = Guid.initString("63ee58fb-1268-4835-86da-f008ce62f0d6");
pub const IID_ID3D12Pageable = &IID_ID3D12Pageable_Value;
pub const ID3D12Pageable = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceChild.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceChild.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Heap_Value = Guid.initString("6b3b2502-6e51-45b3-90ee-9884265e8df3");
pub const IID_ID3D12Heap = &IID_ID3D12Heap_Value;
pub const ID3D12Heap = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
GetDesc: fn(
self: *const ID3D12Heap,
) callconv(@import("std").os.windows.WINAPI) D3D12_HEAP_DESC,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Heap_GetDesc(self: *const T) callconv(.Inline) D3D12_HEAP_DESC {
return @ptrCast(*const ID3D12Heap.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12Heap, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Resource_Value = Guid.initString("696442be-a72e-4059-bc79-5b5c98040fad");
pub const IID_ID3D12Resource = &IID_ID3D12Resource_Value;
pub const ID3D12Resource = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
Map: fn(
self: *const ID3D12Resource,
Subresource: u32,
pReadRange: ?*const D3D12_RANGE,
ppData: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Unmap: fn(
self: *const ID3D12Resource,
Subresource: u32,
pWrittenRange: ?*const D3D12_RANGE,
) callconv(@import("std").os.windows.WINAPI) void,
GetDesc: fn(
self: *const ID3D12Resource,
) callconv(@import("std").os.windows.WINAPI) D3D12_RESOURCE_DESC,
GetGPUVirtualAddress: fn(
self: *const ID3D12Resource,
) callconv(@import("std").os.windows.WINAPI) u64,
WriteToSubresource: fn(
self: *const ID3D12Resource,
DstSubresource: u32,
pDstBox: ?*const D3D12_BOX,
pSrcData: ?*const anyopaque,
SrcRowPitch: u32,
SrcDepthPitch: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReadFromSubresource: fn(
self: *const ID3D12Resource,
pDstData: ?*anyopaque,
DstRowPitch: u32,
DstDepthPitch: u32,
SrcSubresource: u32,
pSrcBox: ?*const D3D12_BOX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetHeapProperties: fn(
self: *const ID3D12Resource,
pHeapProperties: ?*D3D12_HEAP_PROPERTIES,
pHeapFlags: ?*D3D12_HEAP_FLAGS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource_Map(self: *const T, Subresource: u32, pReadRange: ?*const D3D12_RANGE, ppData: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Resource.VTable, self.vtable).Map(@ptrCast(*const ID3D12Resource, self), Subresource, pReadRange, ppData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource_Unmap(self: *const T, Subresource: u32, pWrittenRange: ?*const D3D12_RANGE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Resource.VTable, self.vtable).Unmap(@ptrCast(*const ID3D12Resource, self), Subresource, pWrittenRange);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource_GetDesc(self: *const T) callconv(.Inline) D3D12_RESOURCE_DESC {
return @ptrCast(*const ID3D12Resource.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12Resource, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource_GetGPUVirtualAddress(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12Resource.VTable, self.vtable).GetGPUVirtualAddress(@ptrCast(*const ID3D12Resource, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource_WriteToSubresource(self: *const T, DstSubresource: u32, pDstBox: ?*const D3D12_BOX, pSrcData: ?*const anyopaque, SrcRowPitch: u32, SrcDepthPitch: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Resource.VTable, self.vtable).WriteToSubresource(@ptrCast(*const ID3D12Resource, self), DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource_ReadFromSubresource(self: *const T, pDstData: ?*anyopaque, DstRowPitch: u32, DstDepthPitch: u32, SrcSubresource: u32, pSrcBox: ?*const D3D12_BOX) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Resource.VTable, self.vtable).ReadFromSubresource(@ptrCast(*const ID3D12Resource, self), pDstData, DstRowPitch, DstDepthPitch, SrcSubresource, pSrcBox);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource_GetHeapProperties(self: *const T, pHeapProperties: ?*D3D12_HEAP_PROPERTIES, pHeapFlags: ?*D3D12_HEAP_FLAGS) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Resource.VTable, self.vtable).GetHeapProperties(@ptrCast(*const ID3D12Resource, self), pHeapProperties, pHeapFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12CommandAllocator_Value = Guid.initString("6102dee4-af59-4b09-b999-b44d73f09b24");
pub const IID_ID3D12CommandAllocator = &IID_ID3D12CommandAllocator_Value;
pub const ID3D12CommandAllocator = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
Reset: fn(
self: *const ID3D12CommandAllocator,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandAllocator_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12CommandAllocator.VTable, self.vtable).Reset(@ptrCast(*const ID3D12CommandAllocator, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Fence_Value = Guid.initString("0a753dcf-c4d8-4b91-adf6-be5a60d95a76");
pub const IID_ID3D12Fence = &IID_ID3D12Fence_Value;
pub const ID3D12Fence = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
GetCompletedValue: fn(
self: *const ID3D12Fence,
) callconv(@import("std").os.windows.WINAPI) u64,
SetEventOnCompletion: fn(
self: *const ID3D12Fence,
Value: u64,
hEvent: ?HANDLE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Signal: fn(
self: *const ID3D12Fence,
Value: u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Fence_GetCompletedValue(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12Fence.VTable, self.vtable).GetCompletedValue(@ptrCast(*const ID3D12Fence, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Fence_SetEventOnCompletion(self: *const T, Value: u64, hEvent: ?HANDLE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Fence.VTable, self.vtable).SetEventOnCompletion(@ptrCast(*const ID3D12Fence, self), Value, hEvent);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Fence_Signal(self: *const T, Value: u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Fence.VTable, self.vtable).Signal(@ptrCast(*const ID3D12Fence, self), Value);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Fence1_Value = Guid.initString("433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a");
pub const IID_ID3D12Fence1 = &IID_ID3D12Fence1_Value;
pub const ID3D12Fence1 = extern struct {
pub const VTable = extern struct {
base: ID3D12Fence.VTable,
GetCreationFlags: fn(
self: *const ID3D12Fence1,
) callconv(@import("std").os.windows.WINAPI) D3D12_FENCE_FLAGS,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Fence.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Fence1_GetCreationFlags(self: *const T) callconv(.Inline) D3D12_FENCE_FLAGS {
return @ptrCast(*const ID3D12Fence1.VTable, self.vtable).GetCreationFlags(@ptrCast(*const ID3D12Fence1, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12PipelineState_Value = Guid.initString("765a30f3-f624-4c6f-a828-ace948622445");
pub const IID_ID3D12PipelineState = &IID_ID3D12PipelineState_Value;
pub const ID3D12PipelineState = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
GetCachedBlob: fn(
self: *const ID3D12PipelineState,
ppBlob: ?*?*ID3DBlob,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12PipelineState_GetCachedBlob(self: *const T, ppBlob: ?*?*ID3DBlob) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12PipelineState.VTable, self.vtable).GetCachedBlob(@ptrCast(*const ID3D12PipelineState, self), ppBlob);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DescriptorHeap_Value = Guid.initString("8efb471d-616c-4f49-90f7-127bb763fa51");
pub const IID_ID3D12DescriptorHeap = &IID_ID3D12DescriptorHeap_Value;
pub const ID3D12DescriptorHeap = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
GetDesc: fn(
self: *const ID3D12DescriptorHeap,
) callconv(@import("std").os.windows.WINAPI) D3D12_DESCRIPTOR_HEAP_DESC,
GetCPUDescriptorHandleForHeapStart: fn(
self: *const ID3D12DescriptorHeap,
) callconv(@import("std").os.windows.WINAPI) D3D12_CPU_DESCRIPTOR_HANDLE,
GetGPUDescriptorHandleForHeapStart: fn(
self: *const ID3D12DescriptorHeap,
) callconv(@import("std").os.windows.WINAPI) D3D12_GPU_DESCRIPTOR_HANDLE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DescriptorHeap_GetDesc(self: *const T) callconv(.Inline) D3D12_DESCRIPTOR_HEAP_DESC {
return @ptrCast(*const ID3D12DescriptorHeap.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12DescriptorHeap, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(self: *const T) callconv(.Inline) D3D12_CPU_DESCRIPTOR_HANDLE {
return @ptrCast(*const ID3D12DescriptorHeap.VTable, self.vtable).GetCPUDescriptorHandleForHeapStart(@ptrCast(*const ID3D12DescriptorHeap, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(self: *const T) callconv(.Inline) D3D12_GPU_DESCRIPTOR_HANDLE {
return @ptrCast(*const ID3D12DescriptorHeap.VTable, self.vtable).GetGPUDescriptorHandleForHeapStart(@ptrCast(*const ID3D12DescriptorHeap, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12QueryHeap_Value = Guid.initString("0d9658ae-ed45-469e-a61d-970ec583cab4");
pub const IID_ID3D12QueryHeap = &IID_ID3D12QueryHeap_Value;
pub const ID3D12QueryHeap = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12CommandSignature_Value = Guid.initString("c36a797c-ec80-4f0a-8985-a7b2475082d1");
pub const IID_ID3D12CommandSignature = &IID_ID3D12CommandSignature_Value;
pub const ID3D12CommandSignature = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12CommandList_Value = Guid.initString("7116d91c-e7e4-47ce-b8c6-ec8168f437e5");
pub const IID_ID3D12CommandList = &IID_ID3D12CommandList_Value;
pub const ID3D12CommandList = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceChild.VTable,
GetType: fn(
self: *const ID3D12CommandList,
) callconv(@import("std").os.windows.WINAPI) D3D12_COMMAND_LIST_TYPE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceChild.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandList_GetType(self: *const T) callconv(.Inline) D3D12_COMMAND_LIST_TYPE {
return @ptrCast(*const ID3D12CommandList.VTable, self.vtable).GetType(@ptrCast(*const ID3D12CommandList, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12GraphicsCommandList_Value = Guid.initString("5b160d0f-ac1b-4185-8ba8-b3ae42a5a455");
pub const IID_ID3D12GraphicsCommandList = &IID_ID3D12GraphicsCommandList_Value;
pub const ID3D12GraphicsCommandList = extern struct {
pub const VTable = extern struct {
base: ID3D12CommandList.VTable,
Close: fn(
self: *const ID3D12GraphicsCommandList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const ID3D12GraphicsCommandList,
pAllocator: ?*ID3D12CommandAllocator,
pInitialState: ?*ID3D12PipelineState,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ClearState: fn(
self: *const ID3D12GraphicsCommandList,
pPipelineState: ?*ID3D12PipelineState,
) callconv(@import("std").os.windows.WINAPI) void,
DrawInstanced: fn(
self: *const ID3D12GraphicsCommandList,
VertexCountPerInstance: u32,
InstanceCount: u32,
StartVertexLocation: u32,
StartInstanceLocation: u32,
) callconv(@import("std").os.windows.WINAPI) void,
DrawIndexedInstanced: fn(
self: *const ID3D12GraphicsCommandList,
IndexCountPerInstance: u32,
InstanceCount: u32,
StartIndexLocation: u32,
BaseVertexLocation: i32,
StartInstanceLocation: u32,
) callconv(@import("std").os.windows.WINAPI) void,
Dispatch: fn(
self: *const ID3D12GraphicsCommandList,
ThreadGroupCountX: u32,
ThreadGroupCountY: u32,
ThreadGroupCountZ: u32,
) callconv(@import("std").os.windows.WINAPI) void,
CopyBufferRegion: fn(
self: *const ID3D12GraphicsCommandList,
pDstBuffer: ?*ID3D12Resource,
DstOffset: u64,
pSrcBuffer: ?*ID3D12Resource,
SrcOffset: u64,
NumBytes: u64,
) callconv(@import("std").os.windows.WINAPI) void,
CopyTextureRegion: fn(
self: *const ID3D12GraphicsCommandList,
pDst: ?*const D3D12_TEXTURE_COPY_LOCATION,
DstX: u32,
DstY: u32,
DstZ: u32,
pSrc: ?*const D3D12_TEXTURE_COPY_LOCATION,
pSrcBox: ?*const D3D12_BOX,
) callconv(@import("std").os.windows.WINAPI) void,
CopyResource: fn(
self: *const ID3D12GraphicsCommandList,
pDstResource: ?*ID3D12Resource,
pSrcResource: ?*ID3D12Resource,
) callconv(@import("std").os.windows.WINAPI) void,
CopyTiles: fn(
self: *const ID3D12GraphicsCommandList,
pTiledResource: ?*ID3D12Resource,
pTileRegionStartCoordinate: ?*const D3D12_TILED_RESOURCE_COORDINATE,
pTileRegionSize: ?*const D3D12_TILE_REGION_SIZE,
pBuffer: ?*ID3D12Resource,
BufferStartOffsetInBytes: u64,
Flags: D3D12_TILE_COPY_FLAGS,
) callconv(@import("std").os.windows.WINAPI) void,
ResolveSubresource: fn(
self: *const ID3D12GraphicsCommandList,
pDstResource: ?*ID3D12Resource,
DstSubresource: u32,
pSrcResource: ?*ID3D12Resource,
SrcSubresource: u32,
Format: DXGI_FORMAT,
) callconv(@import("std").os.windows.WINAPI) void,
IASetPrimitiveTopology: fn(
self: *const ID3D12GraphicsCommandList,
PrimitiveTopology: D3D_PRIMITIVE_TOPOLOGY,
) callconv(@import("std").os.windows.WINAPI) void,
RSSetViewports: fn(
self: *const ID3D12GraphicsCommandList,
NumViewports: u32,
pViewports: [*]const D3D12_VIEWPORT,
) callconv(@import("std").os.windows.WINAPI) void,
RSSetScissorRects: fn(
self: *const ID3D12GraphicsCommandList,
NumRects: u32,
pRects: [*]const RECT,
) callconv(@import("std").os.windows.WINAPI) void,
OMSetBlendFactor: fn(
self: *const ID3D12GraphicsCommandList,
BlendFactor: ?*[4]f32,
) callconv(@import("std").os.windows.WINAPI) void,
OMSetStencilRef: fn(
self: *const ID3D12GraphicsCommandList,
StencilRef: u32,
) callconv(@import("std").os.windows.WINAPI) void,
SetPipelineState: fn(
self: *const ID3D12GraphicsCommandList,
pPipelineState: ?*ID3D12PipelineState,
) callconv(@import("std").os.windows.WINAPI) void,
ResourceBarrier: fn(
self: *const ID3D12GraphicsCommandList,
NumBarriers: u32,
pBarriers: [*]const D3D12_RESOURCE_BARRIER,
) callconv(@import("std").os.windows.WINAPI) void,
ExecuteBundle: fn(
self: *const ID3D12GraphicsCommandList,
pCommandList: ?*ID3D12GraphicsCommandList,
) callconv(@import("std").os.windows.WINAPI) void,
SetDescriptorHeaps: fn(
self: *const ID3D12GraphicsCommandList,
NumDescriptorHeaps: u32,
ppDescriptorHeaps: [*]?*ID3D12DescriptorHeap,
) callconv(@import("std").os.windows.WINAPI) void,
SetComputeRootSignature: fn(
self: *const ID3D12GraphicsCommandList,
pRootSignature: ?*ID3D12RootSignature,
) callconv(@import("std").os.windows.WINAPI) void,
SetGraphicsRootSignature: fn(
self: *const ID3D12GraphicsCommandList,
pRootSignature: ?*ID3D12RootSignature,
) callconv(@import("std").os.windows.WINAPI) void,
SetComputeRootDescriptorTable: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
BaseDescriptor: D3D12_GPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
SetGraphicsRootDescriptorTable: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
BaseDescriptor: D3D12_GPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
SetComputeRoot32BitConstant: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
SrcData: u32,
DestOffsetIn32BitValues: u32,
) callconv(@import("std").os.windows.WINAPI) void,
SetGraphicsRoot32BitConstant: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
SrcData: u32,
DestOffsetIn32BitValues: u32,
) callconv(@import("std").os.windows.WINAPI) void,
SetComputeRoot32BitConstants: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
Num32BitValuesToSet: u32,
pSrcData: ?*const anyopaque,
DestOffsetIn32BitValues: u32,
) callconv(@import("std").os.windows.WINAPI) void,
SetGraphicsRoot32BitConstants: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
Num32BitValuesToSet: u32,
pSrcData: ?*const anyopaque,
DestOffsetIn32BitValues: u32,
) callconv(@import("std").os.windows.WINAPI) void,
SetComputeRootConstantBufferView: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
BufferLocation: u64,
) callconv(@import("std").os.windows.WINAPI) void,
SetGraphicsRootConstantBufferView: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
BufferLocation: u64,
) callconv(@import("std").os.windows.WINAPI) void,
SetComputeRootShaderResourceView: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
BufferLocation: u64,
) callconv(@import("std").os.windows.WINAPI) void,
SetGraphicsRootShaderResourceView: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
BufferLocation: u64,
) callconv(@import("std").os.windows.WINAPI) void,
SetComputeRootUnorderedAccessView: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
BufferLocation: u64,
) callconv(@import("std").os.windows.WINAPI) void,
SetGraphicsRootUnorderedAccessView: fn(
self: *const ID3D12GraphicsCommandList,
RootParameterIndex: u32,
BufferLocation: u64,
) callconv(@import("std").os.windows.WINAPI) void,
IASetIndexBuffer: fn(
self: *const ID3D12GraphicsCommandList,
pView: ?*const D3D12_INDEX_BUFFER_VIEW,
) callconv(@import("std").os.windows.WINAPI) void,
IASetVertexBuffers: fn(
self: *const ID3D12GraphicsCommandList,
StartSlot: u32,
NumViews: u32,
pViews: ?[*]const D3D12_VERTEX_BUFFER_VIEW,
) callconv(@import("std").os.windows.WINAPI) void,
SOSetTargets: fn(
self: *const ID3D12GraphicsCommandList,
StartSlot: u32,
NumViews: u32,
pViews: ?[*]const D3D12_STREAM_OUTPUT_BUFFER_VIEW,
) callconv(@import("std").os.windows.WINAPI) void,
OMSetRenderTargets: fn(
self: *const ID3D12GraphicsCommandList,
NumRenderTargetDescriptors: u32,
pRenderTargetDescriptors: ?*const D3D12_CPU_DESCRIPTOR_HANDLE,
RTsSingleHandleToDescriptorRange: BOOL,
pDepthStencilDescriptor: ?*const D3D12_CPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
ClearDepthStencilView: fn(
self: *const ID3D12GraphicsCommandList,
DepthStencilView: D3D12_CPU_DESCRIPTOR_HANDLE,
ClearFlags: D3D12_CLEAR_FLAGS,
Depth: f32,
Stencil: u8,
NumRects: u32,
pRects: [*]const RECT,
) callconv(@import("std").os.windows.WINAPI) void,
ClearRenderTargetView: fn(
self: *const ID3D12GraphicsCommandList,
RenderTargetView: D3D12_CPU_DESCRIPTOR_HANDLE,
ColorRGBA: ?*const f32,
NumRects: u32,
pRects: [*]const RECT,
) callconv(@import("std").os.windows.WINAPI) void,
ClearUnorderedAccessViewUint: fn(
self: *const ID3D12GraphicsCommandList,
ViewGPUHandleInCurrentHeap: D3D12_GPU_DESCRIPTOR_HANDLE,
ViewCPUHandle: D3D12_CPU_DESCRIPTOR_HANDLE,
pResource: ?*ID3D12Resource,
Values: ?*const u32,
NumRects: u32,
pRects: [*]const RECT,
) callconv(@import("std").os.windows.WINAPI) void,
ClearUnorderedAccessViewFloat: fn(
self: *const ID3D12GraphicsCommandList,
ViewGPUHandleInCurrentHeap: D3D12_GPU_DESCRIPTOR_HANDLE,
ViewCPUHandle: D3D12_CPU_DESCRIPTOR_HANDLE,
pResource: ?*ID3D12Resource,
Values: ?*const f32,
NumRects: u32,
pRects: [*]const RECT,
) callconv(@import("std").os.windows.WINAPI) void,
DiscardResource: fn(
self: *const ID3D12GraphicsCommandList,
pResource: ?*ID3D12Resource,
pRegion: ?*const D3D12_DISCARD_REGION,
) callconv(@import("std").os.windows.WINAPI) void,
BeginQuery: fn(
self: *const ID3D12GraphicsCommandList,
pQueryHeap: ?*ID3D12QueryHeap,
Type: D3D12_QUERY_TYPE,
Index: u32,
) callconv(@import("std").os.windows.WINAPI) void,
EndQuery: fn(
self: *const ID3D12GraphicsCommandList,
pQueryHeap: ?*ID3D12QueryHeap,
Type: D3D12_QUERY_TYPE,
Index: u32,
) callconv(@import("std").os.windows.WINAPI) void,
ResolveQueryData: fn(
self: *const ID3D12GraphicsCommandList,
pQueryHeap: ?*ID3D12QueryHeap,
Type: D3D12_QUERY_TYPE,
StartIndex: u32,
NumQueries: u32,
pDestinationBuffer: ?*ID3D12Resource,
AlignedDestinationBufferOffset: u64,
) callconv(@import("std").os.windows.WINAPI) void,
SetPredication: fn(
self: *const ID3D12GraphicsCommandList,
pBuffer: ?*ID3D12Resource,
AlignedBufferOffset: u64,
Operation: D3D12_PREDICATION_OP,
) callconv(@import("std").os.windows.WINAPI) void,
SetMarker: fn(
self: *const ID3D12GraphicsCommandList,
Metadata: u32,
// TODO: what to do with BytesParamIndex 2?
pData: ?*const anyopaque,
Size: u32,
) callconv(@import("std").os.windows.WINAPI) void,
BeginEvent: fn(
self: *const ID3D12GraphicsCommandList,
Metadata: u32,
// TODO: what to do with BytesParamIndex 2?
pData: ?*const anyopaque,
Size: u32,
) callconv(@import("std").os.windows.WINAPI) void,
EndEvent: fn(
self: *const ID3D12GraphicsCommandList,
) callconv(@import("std").os.windows.WINAPI) void,
ExecuteIndirect: fn(
self: *const ID3D12GraphicsCommandList,
pCommandSignature: ?*ID3D12CommandSignature,
MaxCommandCount: u32,
pArgumentBuffer: ?*ID3D12Resource,
ArgumentBufferOffset: u64,
pCountBuffer: ?*ID3D12Resource,
CountBufferOffset: u64,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12CommandList.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).Close(@ptrCast(*const ID3D12GraphicsCommandList, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_Reset(self: *const T, pAllocator: ?*ID3D12CommandAllocator, pInitialState: ?*ID3D12PipelineState) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).Reset(@ptrCast(*const ID3D12GraphicsCommandList, self), pAllocator, pInitialState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ClearState(self: *const T, pPipelineState: ?*ID3D12PipelineState) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ClearState(@ptrCast(*const ID3D12GraphicsCommandList, self), pPipelineState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_DrawInstanced(self: *const T, VertexCountPerInstance: u32, InstanceCount: u32, StartVertexLocation: u32, StartInstanceLocation: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).DrawInstanced(@ptrCast(*const ID3D12GraphicsCommandList, self), VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_DrawIndexedInstanced(self: *const T, IndexCountPerInstance: u32, InstanceCount: u32, StartIndexLocation: u32, BaseVertexLocation: i32, StartInstanceLocation: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).DrawIndexedInstanced(@ptrCast(*const ID3D12GraphicsCommandList, self), IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_Dispatch(self: *const T, ThreadGroupCountX: u32, ThreadGroupCountY: u32, ThreadGroupCountZ: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).Dispatch(@ptrCast(*const ID3D12GraphicsCommandList, self), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_CopyBufferRegion(self: *const T, pDstBuffer: ?*ID3D12Resource, DstOffset: u64, pSrcBuffer: ?*ID3D12Resource, SrcOffset: u64, NumBytes: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).CopyBufferRegion(@ptrCast(*const ID3D12GraphicsCommandList, self), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_CopyTextureRegion(self: *const T, pDst: ?*const D3D12_TEXTURE_COPY_LOCATION, DstX: u32, DstY: u32, DstZ: u32, pSrc: ?*const D3D12_TEXTURE_COPY_LOCATION, pSrcBox: ?*const D3D12_BOX) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).CopyTextureRegion(@ptrCast(*const ID3D12GraphicsCommandList, self), pDst, DstX, DstY, DstZ, pSrc, pSrcBox);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_CopyResource(self: *const T, pDstResource: ?*ID3D12Resource, pSrcResource: ?*ID3D12Resource) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).CopyResource(@ptrCast(*const ID3D12GraphicsCommandList, self), pDstResource, pSrcResource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_CopyTiles(self: *const T, pTiledResource: ?*ID3D12Resource, pTileRegionStartCoordinate: ?*const D3D12_TILED_RESOURCE_COORDINATE, pTileRegionSize: ?*const D3D12_TILE_REGION_SIZE, pBuffer: ?*ID3D12Resource, BufferStartOffsetInBytes: u64, Flags: D3D12_TILE_COPY_FLAGS) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).CopyTiles(@ptrCast(*const ID3D12GraphicsCommandList, self), pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ResolveSubresource(self: *const T, pDstResource: ?*ID3D12Resource, DstSubresource: u32, pSrcResource: ?*ID3D12Resource, SrcSubresource: u32, Format: DXGI_FORMAT) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ResolveSubresource(@ptrCast(*const ID3D12GraphicsCommandList, self), pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_IASetPrimitiveTopology(self: *const T, PrimitiveTopology: D3D_PRIMITIVE_TOPOLOGY) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).IASetPrimitiveTopology(@ptrCast(*const ID3D12GraphicsCommandList, self), PrimitiveTopology);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_RSSetViewports(self: *const T, NumViewports: u32, pViewports: [*]const D3D12_VIEWPORT) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).RSSetViewports(@ptrCast(*const ID3D12GraphicsCommandList, self), NumViewports, pViewports);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_RSSetScissorRects(self: *const T, NumRects: u32, pRects: [*]const RECT) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).RSSetScissorRects(@ptrCast(*const ID3D12GraphicsCommandList, self), NumRects, pRects);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_OMSetBlendFactor(self: *const T, BlendFactor: ?*[4]f32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).OMSetBlendFactor(@ptrCast(*const ID3D12GraphicsCommandList, self), BlendFactor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_OMSetStencilRef(self: *const T, StencilRef: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).OMSetStencilRef(@ptrCast(*const ID3D12GraphicsCommandList, self), StencilRef);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetPipelineState(self: *const T, pPipelineState: ?*ID3D12PipelineState) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetPipelineState(@ptrCast(*const ID3D12GraphicsCommandList, self), pPipelineState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ResourceBarrier(self: *const T, NumBarriers: u32, pBarriers: [*]const D3D12_RESOURCE_BARRIER) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ResourceBarrier(@ptrCast(*const ID3D12GraphicsCommandList, self), NumBarriers, pBarriers);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ExecuteBundle(self: *const T, pCommandList: ?*ID3D12GraphicsCommandList) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ExecuteBundle(@ptrCast(*const ID3D12GraphicsCommandList, self), pCommandList);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetDescriptorHeaps(self: *const T, NumDescriptorHeaps: u32, ppDescriptorHeaps: [*]?*ID3D12DescriptorHeap) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetDescriptorHeaps(@ptrCast(*const ID3D12GraphicsCommandList, self), NumDescriptorHeaps, ppDescriptorHeaps);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetComputeRootSignature(self: *const T, pRootSignature: ?*ID3D12RootSignature) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetComputeRootSignature(@ptrCast(*const ID3D12GraphicsCommandList, self), pRootSignature);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetGraphicsRootSignature(self: *const T, pRootSignature: ?*ID3D12RootSignature) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetGraphicsRootSignature(@ptrCast(*const ID3D12GraphicsCommandList, self), pRootSignature);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(self: *const T, RootParameterIndex: u32, BaseDescriptor: D3D12_GPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetComputeRootDescriptorTable(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, BaseDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(self: *const T, RootParameterIndex: u32, BaseDescriptor: D3D12_GPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetGraphicsRootDescriptorTable(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, BaseDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetComputeRoot32BitConstant(self: *const T, RootParameterIndex: u32, SrcData: u32, DestOffsetIn32BitValues: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetComputeRoot32BitConstant(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, SrcData, DestOffsetIn32BitValues);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstant(self: *const T, RootParameterIndex: u32, SrcData: u32, DestOffsetIn32BitValues: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetGraphicsRoot32BitConstant(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, SrcData, DestOffsetIn32BitValues);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetComputeRoot32BitConstants(self: *const T, RootParameterIndex: u32, Num32BitValuesToSet: u32, pSrcData: ?*const anyopaque, DestOffsetIn32BitValues: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetComputeRoot32BitConstants(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstants(self: *const T, RootParameterIndex: u32, Num32BitValuesToSet: u32, pSrcData: ?*const anyopaque, DestOffsetIn32BitValues: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetGraphicsRoot32BitConstants(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, Num32BitValuesToSet, pSrcData, DestOffsetIn32BitValues);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetComputeRootConstantBufferView(self: *const T, RootParameterIndex: u32, BufferLocation: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetComputeRootConstantBufferView(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, BufferLocation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetGraphicsRootConstantBufferView(self: *const T, RootParameterIndex: u32, BufferLocation: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetGraphicsRootConstantBufferView(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, BufferLocation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetComputeRootShaderResourceView(self: *const T, RootParameterIndex: u32, BufferLocation: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetComputeRootShaderResourceView(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, BufferLocation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetGraphicsRootShaderResourceView(self: *const T, RootParameterIndex: u32, BufferLocation: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetGraphicsRootShaderResourceView(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, BufferLocation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetComputeRootUnorderedAccessView(self: *const T, RootParameterIndex: u32, BufferLocation: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetComputeRootUnorderedAccessView(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, BufferLocation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetGraphicsRootUnorderedAccessView(self: *const T, RootParameterIndex: u32, BufferLocation: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetGraphicsRootUnorderedAccessView(@ptrCast(*const ID3D12GraphicsCommandList, self), RootParameterIndex, BufferLocation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_IASetIndexBuffer(self: *const T, pView: ?*const D3D12_INDEX_BUFFER_VIEW) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).IASetIndexBuffer(@ptrCast(*const ID3D12GraphicsCommandList, self), pView);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_IASetVertexBuffers(self: *const T, StartSlot: u32, NumViews: u32, pViews: ?[*]const D3D12_VERTEX_BUFFER_VIEW) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).IASetVertexBuffers(@ptrCast(*const ID3D12GraphicsCommandList, self), StartSlot, NumViews, pViews);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SOSetTargets(self: *const T, StartSlot: u32, NumViews: u32, pViews: ?[*]const D3D12_STREAM_OUTPUT_BUFFER_VIEW) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SOSetTargets(@ptrCast(*const ID3D12GraphicsCommandList, self), StartSlot, NumViews, pViews);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_OMSetRenderTargets(self: *const T, NumRenderTargetDescriptors: u32, pRenderTargetDescriptors: ?*const D3D12_CPU_DESCRIPTOR_HANDLE, RTsSingleHandleToDescriptorRange: BOOL, pDepthStencilDescriptor: ?*const D3D12_CPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).OMSetRenderTargets(@ptrCast(*const ID3D12GraphicsCommandList, self), NumRenderTargetDescriptors, pRenderTargetDescriptors, RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ClearDepthStencilView(self: *const T, DepthStencilView: D3D12_CPU_DESCRIPTOR_HANDLE, ClearFlags: D3D12_CLEAR_FLAGS, Depth: f32, Stencil: u8, NumRects: u32, pRects: [*]const RECT) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ClearDepthStencilView(@ptrCast(*const ID3D12GraphicsCommandList, self), DepthStencilView, ClearFlags, Depth, Stencil, NumRects, pRects);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ClearRenderTargetView(self: *const T, RenderTargetView: D3D12_CPU_DESCRIPTOR_HANDLE, ColorRGBA: ?*const f32, NumRects: u32, pRects: [*]const RECT) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ClearRenderTargetView(@ptrCast(*const ID3D12GraphicsCommandList, self), RenderTargetView, ColorRGBA, NumRects, pRects);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ClearUnorderedAccessViewUint(self: *const T, ViewGPUHandleInCurrentHeap: D3D12_GPU_DESCRIPTOR_HANDLE, ViewCPUHandle: D3D12_CPU_DESCRIPTOR_HANDLE, pResource: ?*ID3D12Resource, Values: ?*const u32, NumRects: u32, pRects: [*]const RECT) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ClearUnorderedAccessViewUint(@ptrCast(*const ID3D12GraphicsCommandList, self), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ClearUnorderedAccessViewFloat(self: *const T, ViewGPUHandleInCurrentHeap: D3D12_GPU_DESCRIPTOR_HANDLE, ViewCPUHandle: D3D12_CPU_DESCRIPTOR_HANDLE, pResource: ?*ID3D12Resource, Values: ?*const f32, NumRects: u32, pRects: [*]const RECT) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ClearUnorderedAccessViewFloat(@ptrCast(*const ID3D12GraphicsCommandList, self), ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource, Values, NumRects, pRects);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_DiscardResource(self: *const T, pResource: ?*ID3D12Resource, pRegion: ?*const D3D12_DISCARD_REGION) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).DiscardResource(@ptrCast(*const ID3D12GraphicsCommandList, self), pResource, pRegion);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_BeginQuery(self: *const T, pQueryHeap: ?*ID3D12QueryHeap, Type: D3D12_QUERY_TYPE, Index: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).BeginQuery(@ptrCast(*const ID3D12GraphicsCommandList, self), pQueryHeap, Type, Index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_EndQuery(self: *const T, pQueryHeap: ?*ID3D12QueryHeap, Type: D3D12_QUERY_TYPE, Index: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).EndQuery(@ptrCast(*const ID3D12GraphicsCommandList, self), pQueryHeap, Type, Index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ResolveQueryData(self: *const T, pQueryHeap: ?*ID3D12QueryHeap, Type: D3D12_QUERY_TYPE, StartIndex: u32, NumQueries: u32, pDestinationBuffer: ?*ID3D12Resource, AlignedDestinationBufferOffset: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ResolveQueryData(@ptrCast(*const ID3D12GraphicsCommandList, self), pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer, AlignedDestinationBufferOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetPredication(self: *const T, pBuffer: ?*ID3D12Resource, AlignedBufferOffset: u64, Operation: D3D12_PREDICATION_OP) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetPredication(@ptrCast(*const ID3D12GraphicsCommandList, self), pBuffer, AlignedBufferOffset, Operation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_SetMarker(self: *const T, Metadata: u32, pData: ?*const anyopaque, Size: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).SetMarker(@ptrCast(*const ID3D12GraphicsCommandList, self), Metadata, pData, Size);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_BeginEvent(self: *const T, Metadata: u32, pData: ?*const anyopaque, Size: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).BeginEvent(@ptrCast(*const ID3D12GraphicsCommandList, self), Metadata, pData, Size);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_EndEvent(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).EndEvent(@ptrCast(*const ID3D12GraphicsCommandList, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList_ExecuteIndirect(self: *const T, pCommandSignature: ?*ID3D12CommandSignature, MaxCommandCount: u32, pArgumentBuffer: ?*ID3D12Resource, ArgumentBufferOffset: u64, pCountBuffer: ?*ID3D12Resource, CountBufferOffset: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList.VTable, self.vtable).ExecuteIndirect(@ptrCast(*const ID3D12GraphicsCommandList, self), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12GraphicsCommandList1_Value = Guid.initString("553103fb-1fe7-4557-bb38-946d7d0e7ca7");
pub const IID_ID3D12GraphicsCommandList1 = &IID_ID3D12GraphicsCommandList1_Value;
pub const ID3D12GraphicsCommandList1 = extern struct {
pub const VTable = extern struct {
base: ID3D12GraphicsCommandList.VTable,
AtomicCopyBufferUINT: fn(
self: *const ID3D12GraphicsCommandList1,
pDstBuffer: ?*ID3D12Resource,
DstOffset: u64,
pSrcBuffer: ?*ID3D12Resource,
SrcOffset: u64,
Dependencies: u32,
ppDependentResources: [*]?*ID3D12Resource,
pDependentSubresourceRanges: [*]const D3D12_SUBRESOURCE_RANGE_UINT64,
) callconv(@import("std").os.windows.WINAPI) void,
AtomicCopyBufferUINT64: fn(
self: *const ID3D12GraphicsCommandList1,
pDstBuffer: ?*ID3D12Resource,
DstOffset: u64,
pSrcBuffer: ?*ID3D12Resource,
SrcOffset: u64,
Dependencies: u32,
ppDependentResources: [*]?*ID3D12Resource,
pDependentSubresourceRanges: [*]const D3D12_SUBRESOURCE_RANGE_UINT64,
) callconv(@import("std").os.windows.WINAPI) void,
OMSetDepthBounds: fn(
self: *const ID3D12GraphicsCommandList1,
Min: f32,
Max: f32,
) callconv(@import("std").os.windows.WINAPI) void,
SetSamplePositions: fn(
self: *const ID3D12GraphicsCommandList1,
NumSamplesPerPixel: u32,
NumPixels: u32,
pSamplePositions: ?*D3D12_SAMPLE_POSITION,
) callconv(@import("std").os.windows.WINAPI) void,
ResolveSubresourceRegion: fn(
self: *const ID3D12GraphicsCommandList1,
pDstResource: ?*ID3D12Resource,
DstSubresource: u32,
DstX: u32,
DstY: u32,
pSrcResource: ?*ID3D12Resource,
SrcSubresource: u32,
pSrcRect: ?*RECT,
Format: DXGI_FORMAT,
ResolveMode: D3D12_RESOLVE_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetViewInstanceMask: fn(
self: *const ID3D12GraphicsCommandList1,
Mask: u32,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12GraphicsCommandList.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList1_AtomicCopyBufferUINT(self: *const T, pDstBuffer: ?*ID3D12Resource, DstOffset: u64, pSrcBuffer: ?*ID3D12Resource, SrcOffset: u64, Dependencies: u32, ppDependentResources: [*]?*ID3D12Resource, pDependentSubresourceRanges: [*]const D3D12_SUBRESOURCE_RANGE_UINT64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList1.VTable, self.vtable).AtomicCopyBufferUINT(@ptrCast(*const ID3D12GraphicsCommandList1, self), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList1_AtomicCopyBufferUINT64(self: *const T, pDstBuffer: ?*ID3D12Resource, DstOffset: u64, pSrcBuffer: ?*ID3D12Resource, SrcOffset: u64, Dependencies: u32, ppDependentResources: [*]?*ID3D12Resource, pDependentSubresourceRanges: [*]const D3D12_SUBRESOURCE_RANGE_UINT64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList1.VTable, self.vtable).AtomicCopyBufferUINT64(@ptrCast(*const ID3D12GraphicsCommandList1, self), pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, Dependencies, ppDependentResources, pDependentSubresourceRanges);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList1_OMSetDepthBounds(self: *const T, Min: f32, Max: f32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList1.VTable, self.vtable).OMSetDepthBounds(@ptrCast(*const ID3D12GraphicsCommandList1, self), Min, Max);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList1_SetSamplePositions(self: *const T, NumSamplesPerPixel: u32, NumPixels: u32, pSamplePositions: ?*D3D12_SAMPLE_POSITION) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList1.VTable, self.vtable).SetSamplePositions(@ptrCast(*const ID3D12GraphicsCommandList1, self), NumSamplesPerPixel, NumPixels, pSamplePositions);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList1_ResolveSubresourceRegion(self: *const T, pDstResource: ?*ID3D12Resource, DstSubresource: u32, DstX: u32, DstY: u32, pSrcResource: ?*ID3D12Resource, SrcSubresource: u32, pSrcRect: ?*RECT, Format: DXGI_FORMAT, ResolveMode: D3D12_RESOLVE_MODE) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList1.VTable, self.vtable).ResolveSubresourceRegion(@ptrCast(*const ID3D12GraphicsCommandList1, self), pDstResource, DstSubresource, DstX, DstY, pSrcResource, SrcSubresource, pSrcRect, Format, ResolveMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList1_SetViewInstanceMask(self: *const T, Mask: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList1.VTable, self.vtable).SetViewInstanceMask(@ptrCast(*const ID3D12GraphicsCommandList1, self), Mask);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER = extern struct {
Dest: u64,
Value: u32,
};
pub const D3D12_WRITEBUFFERIMMEDIATE_MODE = enum(i32) {
DEFAULT = 0,
MARKER_IN = 1,
MARKER_OUT = 2,
};
pub const D3D12_WRITEBUFFERIMMEDIATE_MODE_DEFAULT = D3D12_WRITEBUFFERIMMEDIATE_MODE.DEFAULT;
pub const D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_IN = D3D12_WRITEBUFFERIMMEDIATE_MODE.MARKER_IN;
pub const D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_OUT = D3D12_WRITEBUFFERIMMEDIATE_MODE.MARKER_OUT;
const IID_ID3D12GraphicsCommandList2_Value = Guid.initString("38c3e585-ff17-412c-9150-4fc6f9d72a28");
pub const IID_ID3D12GraphicsCommandList2 = &IID_ID3D12GraphicsCommandList2_Value;
pub const ID3D12GraphicsCommandList2 = extern struct {
pub const VTable = extern struct {
base: ID3D12GraphicsCommandList1.VTable,
WriteBufferImmediate: fn(
self: *const ID3D12GraphicsCommandList2,
Count: u32,
pParams: [*]const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER,
pModes: ?[*]const D3D12_WRITEBUFFERIMMEDIATE_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12GraphicsCommandList1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList2_WriteBufferImmediate(self: *const T, Count: u32, pParams: [*]const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pModes: ?[*]const D3D12_WRITEBUFFERIMMEDIATE_MODE) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList2.VTable, self.vtable).WriteBufferImmediate(@ptrCast(*const ID3D12GraphicsCommandList2, self), Count, pParams, pModes);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12CommandQueue_Value = Guid.initString("0ec870a6-5d7e-4c22-8cfc-5baae07616ed");
pub const IID_ID3D12CommandQueue = &IID_ID3D12CommandQueue_Value;
pub const ID3D12CommandQueue = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
UpdateTileMappings: fn(
self: *const ID3D12CommandQueue,
pResource: ?*ID3D12Resource,
NumResourceRegions: u32,
pResourceRegionStartCoordinates: ?[*]const D3D12_TILED_RESOURCE_COORDINATE,
pResourceRegionSizes: ?[*]const D3D12_TILE_REGION_SIZE,
pHeap: ?*ID3D12Heap,
NumRanges: u32,
pRangeFlags: ?[*]const D3D12_TILE_RANGE_FLAGS,
pHeapRangeStartOffsets: ?[*]const u32,
pRangeTileCounts: ?[*]const u32,
Flags: D3D12_TILE_MAPPING_FLAGS,
) callconv(@import("std").os.windows.WINAPI) void,
CopyTileMappings: fn(
self: *const ID3D12CommandQueue,
pDstResource: ?*ID3D12Resource,
pDstRegionStartCoordinate: ?*const D3D12_TILED_RESOURCE_COORDINATE,
pSrcResource: ?*ID3D12Resource,
pSrcRegionStartCoordinate: ?*const D3D12_TILED_RESOURCE_COORDINATE,
pRegionSize: ?*const D3D12_TILE_REGION_SIZE,
Flags: D3D12_TILE_MAPPING_FLAGS,
) callconv(@import("std").os.windows.WINAPI) void,
ExecuteCommandLists: fn(
self: *const ID3D12CommandQueue,
NumCommandLists: u32,
ppCommandLists: [*]?*ID3D12CommandList,
) callconv(@import("std").os.windows.WINAPI) void,
SetMarker: fn(
self: *const ID3D12CommandQueue,
Metadata: u32,
// TODO: what to do with BytesParamIndex 2?
pData: ?*const anyopaque,
Size: u32,
) callconv(@import("std").os.windows.WINAPI) void,
BeginEvent: fn(
self: *const ID3D12CommandQueue,
Metadata: u32,
// TODO: what to do with BytesParamIndex 2?
pData: ?*const anyopaque,
Size: u32,
) callconv(@import("std").os.windows.WINAPI) void,
EndEvent: fn(
self: *const ID3D12CommandQueue,
) callconv(@import("std").os.windows.WINAPI) void,
Signal: fn(
self: *const ID3D12CommandQueue,
pFence: ?*ID3D12Fence,
Value: u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Wait: fn(
self: *const ID3D12CommandQueue,
pFence: ?*ID3D12Fence,
Value: u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTimestampFrequency: fn(
self: *const ID3D12CommandQueue,
pFrequency: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetClockCalibration: fn(
self: *const ID3D12CommandQueue,
pGpuTimestamp: ?*u64,
pCpuTimestamp: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDesc: fn(
self: *const ID3D12CommandQueue,
) callconv(@import("std").os.windows.WINAPI) D3D12_COMMAND_QUEUE_DESC,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_UpdateTileMappings(self: *const T, pResource: ?*ID3D12Resource, NumResourceRegions: u32, pResourceRegionStartCoordinates: ?[*]const D3D12_TILED_RESOURCE_COORDINATE, pResourceRegionSizes: ?[*]const D3D12_TILE_REGION_SIZE, pHeap: ?*ID3D12Heap, NumRanges: u32, pRangeFlags: ?[*]const D3D12_TILE_RANGE_FLAGS, pHeapRangeStartOffsets: ?[*]const u32, pRangeTileCounts: ?[*]const u32, Flags: D3D12_TILE_MAPPING_FLAGS) callconv(.Inline) void {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).UpdateTileMappings(@ptrCast(*const ID3D12CommandQueue, self), pResource, NumResourceRegions, pResourceRegionStartCoordinates, pResourceRegionSizes, pHeap, NumRanges, pRangeFlags, pHeapRangeStartOffsets, pRangeTileCounts, Flags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_CopyTileMappings(self: *const T, pDstResource: ?*ID3D12Resource, pDstRegionStartCoordinate: ?*const D3D12_TILED_RESOURCE_COORDINATE, pSrcResource: ?*ID3D12Resource, pSrcRegionStartCoordinate: ?*const D3D12_TILED_RESOURCE_COORDINATE, pRegionSize: ?*const D3D12_TILE_REGION_SIZE, Flags: D3D12_TILE_MAPPING_FLAGS) callconv(.Inline) void {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).CopyTileMappings(@ptrCast(*const ID3D12CommandQueue, self), pDstResource, pDstRegionStartCoordinate, pSrcResource, pSrcRegionStartCoordinate, pRegionSize, Flags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_ExecuteCommandLists(self: *const T, NumCommandLists: u32, ppCommandLists: [*]?*ID3D12CommandList) callconv(.Inline) void {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).ExecuteCommandLists(@ptrCast(*const ID3D12CommandQueue, self), NumCommandLists, ppCommandLists);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_SetMarker(self: *const T, Metadata: u32, pData: ?*const anyopaque, Size: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).SetMarker(@ptrCast(*const ID3D12CommandQueue, self), Metadata, pData, Size);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_BeginEvent(self: *const T, Metadata: u32, pData: ?*const anyopaque, Size: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).BeginEvent(@ptrCast(*const ID3D12CommandQueue, self), Metadata, pData, Size);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_EndEvent(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).EndEvent(@ptrCast(*const ID3D12CommandQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_Signal(self: *const T, pFence: ?*ID3D12Fence, Value: u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).Signal(@ptrCast(*const ID3D12CommandQueue, self), pFence, Value);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_Wait(self: *const T, pFence: ?*ID3D12Fence, Value: u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).Wait(@ptrCast(*const ID3D12CommandQueue, self), pFence, Value);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_GetTimestampFrequency(self: *const T, pFrequency: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).GetTimestampFrequency(@ptrCast(*const ID3D12CommandQueue, self), pFrequency);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_GetClockCalibration(self: *const T, pGpuTimestamp: ?*u64, pCpuTimestamp: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).GetClockCalibration(@ptrCast(*const ID3D12CommandQueue, self), pGpuTimestamp, pCpuTimestamp);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12CommandQueue_GetDesc(self: *const T) callconv(.Inline) D3D12_COMMAND_QUEUE_DESC {
return @ptrCast(*const ID3D12CommandQueue.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12CommandQueue, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Device_Value = Guid.initString("189819f1-1db6-4b57-be54-1821339b85f7");
pub const IID_ID3D12Device = &IID_ID3D12Device_Value;
pub const ID3D12Device = extern struct {
pub const VTable = extern struct {
base: ID3D12Object.VTable,
GetNodeCount: fn(
self: *const ID3D12Device,
) callconv(@import("std").os.windows.WINAPI) u32,
CreateCommandQueue: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_COMMAND_QUEUE_DESC,
riid: ?*const Guid,
ppCommandQueue: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateCommandAllocator: fn(
self: *const ID3D12Device,
type: D3D12_COMMAND_LIST_TYPE,
riid: ?*const Guid,
ppCommandAllocator: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateGraphicsPipelineState: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_GRAPHICS_PIPELINE_STATE_DESC,
riid: ?*const Guid,
ppPipelineState: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateComputePipelineState: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_COMPUTE_PIPELINE_STATE_DESC,
riid: ?*const Guid,
ppPipelineState: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateCommandList: fn(
self: *const ID3D12Device,
nodeMask: u32,
type: D3D12_COMMAND_LIST_TYPE,
pCommandAllocator: ?*ID3D12CommandAllocator,
pInitialState: ?*ID3D12PipelineState,
riid: ?*const Guid,
ppCommandList: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CheckFeatureSupport: fn(
self: *const ID3D12Device,
Feature: D3D12_FEATURE,
// TODO: what to do with BytesParamIndex 2?
pFeatureSupportData: ?*anyopaque,
FeatureSupportDataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateDescriptorHeap: fn(
self: *const ID3D12Device,
pDescriptorHeapDesc: ?*const D3D12_DESCRIPTOR_HEAP_DESC,
riid: ?*const Guid,
ppvHeap: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDescriptorHandleIncrementSize: fn(
self: *const ID3D12Device,
DescriptorHeapType: D3D12_DESCRIPTOR_HEAP_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32,
CreateRootSignature: fn(
self: *const ID3D12Device,
nodeMask: u32,
pBlobWithRootSignature: [*]const u8,
blobLengthInBytes: usize,
riid: ?*const Guid,
ppvRootSignature: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateConstantBufferView: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_CONSTANT_BUFFER_VIEW_DESC,
DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
CreateShaderResourceView: fn(
self: *const ID3D12Device,
pResource: ?*ID3D12Resource,
pDesc: ?*const D3D12_SHADER_RESOURCE_VIEW_DESC,
DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
CreateUnorderedAccessView: fn(
self: *const ID3D12Device,
pResource: ?*ID3D12Resource,
pCounterResource: ?*ID3D12Resource,
pDesc: ?*const D3D12_UNORDERED_ACCESS_VIEW_DESC,
DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
CreateRenderTargetView: fn(
self: *const ID3D12Device,
pResource: ?*ID3D12Resource,
pDesc: ?*const D3D12_RENDER_TARGET_VIEW_DESC,
DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
CreateDepthStencilView: fn(
self: *const ID3D12Device,
pResource: ?*ID3D12Resource,
pDesc: ?*const D3D12_DEPTH_STENCIL_VIEW_DESC,
DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
CreateSampler: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_SAMPLER_DESC,
DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
CopyDescriptors: fn(
self: *const ID3D12Device,
NumDestDescriptorRanges: u32,
pDestDescriptorRangeStarts: [*]const D3D12_CPU_DESCRIPTOR_HANDLE,
pDestDescriptorRangeSizes: ?[*]const u32,
NumSrcDescriptorRanges: u32,
pSrcDescriptorRangeStarts: [*]const D3D12_CPU_DESCRIPTOR_HANDLE,
pSrcDescriptorRangeSizes: ?[*]const u32,
DescriptorHeapsType: D3D12_DESCRIPTOR_HEAP_TYPE,
) callconv(@import("std").os.windows.WINAPI) void,
CopyDescriptorsSimple: fn(
self: *const ID3D12Device,
NumDescriptors: u32,
DestDescriptorRangeStart: D3D12_CPU_DESCRIPTOR_HANDLE,
SrcDescriptorRangeStart: D3D12_CPU_DESCRIPTOR_HANDLE,
DescriptorHeapsType: D3D12_DESCRIPTOR_HEAP_TYPE,
) callconv(@import("std").os.windows.WINAPI) void,
GetResourceAllocationInfo: fn(
self: *const ID3D12Device,
visibleMask: u32,
numResourceDescs: u32,
pResourceDescs: [*]const D3D12_RESOURCE_DESC,
) callconv(@import("std").os.windows.WINAPI) D3D12_RESOURCE_ALLOCATION_INFO,
GetCustomHeapProperties: fn(
self: *const ID3D12Device,
nodeMask: u32,
heapType: D3D12_HEAP_TYPE,
) callconv(@import("std").os.windows.WINAPI) D3D12_HEAP_PROPERTIES,
CreateCommittedResource: fn(
self: *const ID3D12Device,
pHeapProperties: ?*const D3D12_HEAP_PROPERTIES,
HeapFlags: D3D12_HEAP_FLAGS,
pDesc: ?*const D3D12_RESOURCE_DESC,
InitialResourceState: D3D12_RESOURCE_STATES,
pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE,
riidResource: ?*const Guid,
ppvResource: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateHeap: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_HEAP_DESC,
riid: ?*const Guid,
ppvHeap: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreatePlacedResource: fn(
self: *const ID3D12Device,
pHeap: ?*ID3D12Heap,
HeapOffset: u64,
pDesc: ?*const D3D12_RESOURCE_DESC,
InitialState: D3D12_RESOURCE_STATES,
pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE,
riid: ?*const Guid,
ppvResource: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateReservedResource: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_RESOURCE_DESC,
InitialState: D3D12_RESOURCE_STATES,
pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE,
riid: ?*const Guid,
ppvResource: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateSharedHandle: fn(
self: *const ID3D12Device,
pObject: ?*ID3D12DeviceChild,
pAttributes: ?*const SECURITY_ATTRIBUTES,
Access: u32,
Name: ?[*:0]const u16,
pHandle: ?*?HANDLE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenSharedHandle: fn(
self: *const ID3D12Device,
NTHandle: ?HANDLE,
riid: ?*const Guid,
ppvObj: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenSharedHandleByName: fn(
self: *const ID3D12Device,
Name: ?[*:0]const u16,
Access: u32,
pNTHandle: ?*?HANDLE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
MakeResident: fn(
self: *const ID3D12Device,
NumObjects: u32,
ppObjects: [*]?*ID3D12Pageable,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Evict: fn(
self: *const ID3D12Device,
NumObjects: u32,
ppObjects: [*]?*ID3D12Pageable,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateFence: fn(
self: *const ID3D12Device,
InitialValue: u64,
Flags: D3D12_FENCE_FLAGS,
riid: ?*const Guid,
ppFence: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDeviceRemovedReason: fn(
self: *const ID3D12Device,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCopyableFootprints: fn(
self: *const ID3D12Device,
pResourceDesc: ?*const D3D12_RESOURCE_DESC,
FirstSubresource: u32,
NumSubresources: u32,
BaseOffset: u64,
pLayouts: ?[*]D3D12_PLACED_SUBRESOURCE_FOOTPRINT,
pNumRows: ?[*]u32,
pRowSizeInBytes: ?[*]u64,
pTotalBytes: ?*u64,
) callconv(@import("std").os.windows.WINAPI) void,
CreateQueryHeap: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_QUERY_HEAP_DESC,
riid: ?*const Guid,
ppvHeap: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetStablePowerState: fn(
self: *const ID3D12Device,
Enable: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateCommandSignature: fn(
self: *const ID3D12Device,
pDesc: ?*const D3D12_COMMAND_SIGNATURE_DESC,
pRootSignature: ?*ID3D12RootSignature,
riid: ?*const Guid,
ppvCommandSignature: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetResourceTiling: fn(
self: *const ID3D12Device,
pTiledResource: ?*ID3D12Resource,
pNumTilesForEntireResource: ?*u32,
pPackedMipDesc: ?*D3D12_PACKED_MIP_INFO,
pStandardTileShapeForNonPackedMips: ?*D3D12_TILE_SHAPE,
pNumSubresourceTilings: ?*u32,
FirstSubresourceTilingToGet: u32,
pSubresourceTilingsForNonPackedMips: [*]D3D12_SUBRESOURCE_TILING,
) callconv(@import("std").os.windows.WINAPI) void,
GetAdapterLuid: fn(
self: *const ID3D12Device,
) callconv(@import("std").os.windows.WINAPI) LUID,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Object.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_GetNodeCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).GetNodeCount(@ptrCast(*const ID3D12Device, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateCommandQueue(self: *const T, pDesc: ?*const D3D12_COMMAND_QUEUE_DESC, riid: ?*const Guid, ppCommandQueue: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateCommandQueue(@ptrCast(*const ID3D12Device, self), pDesc, riid, ppCommandQueue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateCommandAllocator(self: *const T, type_: D3D12_COMMAND_LIST_TYPE, riid: ?*const Guid, ppCommandAllocator: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateCommandAllocator(@ptrCast(*const ID3D12Device, self), type_, riid, ppCommandAllocator);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateGraphicsPipelineState(self: *const T, pDesc: ?*const D3D12_GRAPHICS_PIPELINE_STATE_DESC, riid: ?*const Guid, ppPipelineState: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateGraphicsPipelineState(@ptrCast(*const ID3D12Device, self), pDesc, riid, ppPipelineState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateComputePipelineState(self: *const T, pDesc: ?*const D3D12_COMPUTE_PIPELINE_STATE_DESC, riid: ?*const Guid, ppPipelineState: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateComputePipelineState(@ptrCast(*const ID3D12Device, self), pDesc, riid, ppPipelineState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateCommandList(self: *const T, nodeMask: u32, type_: D3D12_COMMAND_LIST_TYPE, pCommandAllocator: ?*ID3D12CommandAllocator, pInitialState: ?*ID3D12PipelineState, riid: ?*const Guid, ppCommandList: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateCommandList(@ptrCast(*const ID3D12Device, self), nodeMask, type_, pCommandAllocator, pInitialState, riid, ppCommandList);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CheckFeatureSupport(self: *const T, Feature: D3D12_FEATURE, pFeatureSupportData: ?*anyopaque, FeatureSupportDataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CheckFeatureSupport(@ptrCast(*const ID3D12Device, self), Feature, pFeatureSupportData, FeatureSupportDataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateDescriptorHeap(self: *const T, pDescriptorHeapDesc: ?*const D3D12_DESCRIPTOR_HEAP_DESC, riid: ?*const Guid, ppvHeap: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateDescriptorHeap(@ptrCast(*const ID3D12Device, self), pDescriptorHeapDesc, riid, ppvHeap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_GetDescriptorHandleIncrementSize(self: *const T, DescriptorHeapType: D3D12_DESCRIPTOR_HEAP_TYPE) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).GetDescriptorHandleIncrementSize(@ptrCast(*const ID3D12Device, self), DescriptorHeapType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateRootSignature(self: *const T, nodeMask: u32, pBlobWithRootSignature: [*]const u8, blobLengthInBytes: usize, riid: ?*const Guid, ppvRootSignature: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateRootSignature(@ptrCast(*const ID3D12Device, self), nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateConstantBufferView(self: *const T, pDesc: ?*const D3D12_CONSTANT_BUFFER_VIEW_DESC, DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateConstantBufferView(@ptrCast(*const ID3D12Device, self), pDesc, DestDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateShaderResourceView(self: *const T, pResource: ?*ID3D12Resource, pDesc: ?*const D3D12_SHADER_RESOURCE_VIEW_DESC, DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateShaderResourceView(@ptrCast(*const ID3D12Device, self), pResource, pDesc, DestDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateUnorderedAccessView(self: *const T, pResource: ?*ID3D12Resource, pCounterResource: ?*ID3D12Resource, pDesc: ?*const D3D12_UNORDERED_ACCESS_VIEW_DESC, DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateUnorderedAccessView(@ptrCast(*const ID3D12Device, self), pResource, pCounterResource, pDesc, DestDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateRenderTargetView(self: *const T, pResource: ?*ID3D12Resource, pDesc: ?*const D3D12_RENDER_TARGET_VIEW_DESC, DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateRenderTargetView(@ptrCast(*const ID3D12Device, self), pResource, pDesc, DestDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateDepthStencilView(self: *const T, pResource: ?*ID3D12Resource, pDesc: ?*const D3D12_DEPTH_STENCIL_VIEW_DESC, DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateDepthStencilView(@ptrCast(*const ID3D12Device, self), pResource, pDesc, DestDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateSampler(self: *const T, pDesc: ?*const D3D12_SAMPLER_DESC, DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateSampler(@ptrCast(*const ID3D12Device, self), pDesc, DestDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CopyDescriptors(self: *const T, NumDestDescriptorRanges: u32, pDestDescriptorRangeStarts: [*]const D3D12_CPU_DESCRIPTOR_HANDLE, pDestDescriptorRangeSizes: ?[*]const u32, NumSrcDescriptorRanges: u32, pSrcDescriptorRangeStarts: [*]const D3D12_CPU_DESCRIPTOR_HANDLE, pSrcDescriptorRangeSizes: ?[*]const u32, DescriptorHeapsType: D3D12_DESCRIPTOR_HEAP_TYPE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CopyDescriptors(@ptrCast(*const ID3D12Device, self), NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CopyDescriptorsSimple(self: *const T, NumDescriptors: u32, DestDescriptorRangeStart: D3D12_CPU_DESCRIPTOR_HANDLE, SrcDescriptorRangeStart: D3D12_CPU_DESCRIPTOR_HANDLE, DescriptorHeapsType: D3D12_DESCRIPTOR_HEAP_TYPE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CopyDescriptorsSimple(@ptrCast(*const ID3D12Device, self), NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_GetResourceAllocationInfo(self: *const T, visibleMask: u32, numResourceDescs: u32, pResourceDescs: [*]const D3D12_RESOURCE_DESC) callconv(.Inline) D3D12_RESOURCE_ALLOCATION_INFO {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).GetResourceAllocationInfo(@ptrCast(*const ID3D12Device, self), visibleMask, numResourceDescs, pResourceDescs);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_GetCustomHeapProperties(self: *const T, nodeMask: u32, heapType: D3D12_HEAP_TYPE) callconv(.Inline) D3D12_HEAP_PROPERTIES {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).GetCustomHeapProperties(@ptrCast(*const ID3D12Device, self), nodeMask, heapType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateCommittedResource(self: *const T, pHeapProperties: ?*const D3D12_HEAP_PROPERTIES, HeapFlags: D3D12_HEAP_FLAGS, pDesc: ?*const D3D12_RESOURCE_DESC, InitialResourceState: D3D12_RESOURCE_STATES, pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE, riidResource: ?*const Guid, ppvResource: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateCommittedResource(@ptrCast(*const ID3D12Device, self), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateHeap(self: *const T, pDesc: ?*const D3D12_HEAP_DESC, riid: ?*const Guid, ppvHeap: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateHeap(@ptrCast(*const ID3D12Device, self), pDesc, riid, ppvHeap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreatePlacedResource(self: *const T, pHeap: ?*ID3D12Heap, HeapOffset: u64, pDesc: ?*const D3D12_RESOURCE_DESC, InitialState: D3D12_RESOURCE_STATES, pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE, riid: ?*const Guid, ppvResource: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreatePlacedResource(@ptrCast(*const ID3D12Device, self), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateReservedResource(self: *const T, pDesc: ?*const D3D12_RESOURCE_DESC, InitialState: D3D12_RESOURCE_STATES, pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE, riid: ?*const Guid, ppvResource: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateReservedResource(@ptrCast(*const ID3D12Device, self), pDesc, InitialState, pOptimizedClearValue, riid, ppvResource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateSharedHandle(self: *const T, pObject: ?*ID3D12DeviceChild, pAttributes: ?*const SECURITY_ATTRIBUTES, Access: u32, Name: ?[*:0]const u16, pHandle: ?*?HANDLE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateSharedHandle(@ptrCast(*const ID3D12Device, self), pObject, pAttributes, Access, Name, pHandle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_OpenSharedHandle(self: *const T, NTHandle: ?HANDLE, riid: ?*const Guid, ppvObj: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).OpenSharedHandle(@ptrCast(*const ID3D12Device, self), NTHandle, riid, ppvObj);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_OpenSharedHandleByName(self: *const T, Name: ?[*:0]const u16, Access: u32, pNTHandle: ?*?HANDLE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).OpenSharedHandleByName(@ptrCast(*const ID3D12Device, self), Name, Access, pNTHandle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_MakeResident(self: *const T, NumObjects: u32, ppObjects: [*]?*ID3D12Pageable) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).MakeResident(@ptrCast(*const ID3D12Device, self), NumObjects, ppObjects);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_Evict(self: *const T, NumObjects: u32, ppObjects: [*]?*ID3D12Pageable) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).Evict(@ptrCast(*const ID3D12Device, self), NumObjects, ppObjects);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateFence(self: *const T, InitialValue: u64, Flags: D3D12_FENCE_FLAGS, riid: ?*const Guid, ppFence: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateFence(@ptrCast(*const ID3D12Device, self), InitialValue, Flags, riid, ppFence);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_GetDeviceRemovedReason(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).GetDeviceRemovedReason(@ptrCast(*const ID3D12Device, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_GetCopyableFootprints(self: *const T, pResourceDesc: ?*const D3D12_RESOURCE_DESC, FirstSubresource: u32, NumSubresources: u32, BaseOffset: u64, pLayouts: ?[*]D3D12_PLACED_SUBRESOURCE_FOOTPRINT, pNumRows: ?[*]u32, pRowSizeInBytes: ?[*]u64, pTotalBytes: ?*u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).GetCopyableFootprints(@ptrCast(*const ID3D12Device, self), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateQueryHeap(self: *const T, pDesc: ?*const D3D12_QUERY_HEAP_DESC, riid: ?*const Guid, ppvHeap: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateQueryHeap(@ptrCast(*const ID3D12Device, self), pDesc, riid, ppvHeap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_SetStablePowerState(self: *const T, Enable: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).SetStablePowerState(@ptrCast(*const ID3D12Device, self), Enable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_CreateCommandSignature(self: *const T, pDesc: ?*const D3D12_COMMAND_SIGNATURE_DESC, pRootSignature: ?*ID3D12RootSignature, riid: ?*const Guid, ppvCommandSignature: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).CreateCommandSignature(@ptrCast(*const ID3D12Device, self), pDesc, pRootSignature, riid, ppvCommandSignature);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_GetResourceTiling(self: *const T, pTiledResource: ?*ID3D12Resource, pNumTilesForEntireResource: ?*u32, pPackedMipDesc: ?*D3D12_PACKED_MIP_INFO, pStandardTileShapeForNonPackedMips: ?*D3D12_TILE_SHAPE, pNumSubresourceTilings: ?*u32, FirstSubresourceTilingToGet: u32, pSubresourceTilingsForNonPackedMips: [*]D3D12_SUBRESOURCE_TILING) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).GetResourceTiling(@ptrCast(*const ID3D12Device, self), pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device_GetAdapterLuid(self: *const T) callconv(.Inline) LUID {
return @ptrCast(*const ID3D12Device.VTable, self.vtable).GetAdapterLuid(@ptrCast(*const ID3D12Device, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12PipelineLibrary_Value = Guid.initString("c64226a8-9201-46af-b4cc-53fb9ff7414f");
pub const IID_ID3D12PipelineLibrary = &IID_ID3D12PipelineLibrary_Value;
pub const ID3D12PipelineLibrary = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceChild.VTable,
StorePipeline: fn(
self: *const ID3D12PipelineLibrary,
pName: ?[*:0]const u16,
pPipeline: ?*ID3D12PipelineState,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LoadGraphicsPipeline: fn(
self: *const ID3D12PipelineLibrary,
pName: ?[*:0]const u16,
pDesc: ?*const D3D12_GRAPHICS_PIPELINE_STATE_DESC,
riid: ?*const Guid,
ppPipelineState: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LoadComputePipeline: fn(
self: *const ID3D12PipelineLibrary,
pName: ?[*:0]const u16,
pDesc: ?*const D3D12_COMPUTE_PIPELINE_STATE_DESC,
riid: ?*const Guid,
ppPipelineState: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSerializedSize: fn(
self: *const ID3D12PipelineLibrary,
) callconv(@import("std").os.windows.WINAPI) usize,
Serialize: fn(
self: *const ID3D12PipelineLibrary,
pData: [*]u8,
DataSizeInBytes: usize,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceChild.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12PipelineLibrary_StorePipeline(self: *const T, pName: ?[*:0]const u16, pPipeline: ?*ID3D12PipelineState) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12PipelineLibrary.VTable, self.vtable).StorePipeline(@ptrCast(*const ID3D12PipelineLibrary, self), pName, pPipeline);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12PipelineLibrary_LoadGraphicsPipeline(self: *const T, pName: ?[*:0]const u16, pDesc: ?*const D3D12_GRAPHICS_PIPELINE_STATE_DESC, riid: ?*const Guid, ppPipelineState: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12PipelineLibrary.VTable, self.vtable).LoadGraphicsPipeline(@ptrCast(*const ID3D12PipelineLibrary, self), pName, pDesc, riid, ppPipelineState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12PipelineLibrary_LoadComputePipeline(self: *const T, pName: ?[*:0]const u16, pDesc: ?*const D3D12_COMPUTE_PIPELINE_STATE_DESC, riid: ?*const Guid, ppPipelineState: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12PipelineLibrary.VTable, self.vtable).LoadComputePipeline(@ptrCast(*const ID3D12PipelineLibrary, self), pName, pDesc, riid, ppPipelineState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12PipelineLibrary_GetSerializedSize(self: *const T) callconv(.Inline) usize {
return @ptrCast(*const ID3D12PipelineLibrary.VTable, self.vtable).GetSerializedSize(@ptrCast(*const ID3D12PipelineLibrary, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12PipelineLibrary_Serialize(self: *const T, pData: [*]u8, DataSizeInBytes: usize) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12PipelineLibrary.VTable, self.vtable).Serialize(@ptrCast(*const ID3D12PipelineLibrary, self), pData, DataSizeInBytes);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12PipelineLibrary1_Value = Guid.initString("80eabf42-2568-4e5e-bd82-c37f86961dc3");
pub const IID_ID3D12PipelineLibrary1 = &IID_ID3D12PipelineLibrary1_Value;
pub const ID3D12PipelineLibrary1 = extern struct {
pub const VTable = extern struct {
base: ID3D12PipelineLibrary.VTable,
LoadPipeline: fn(
self: *const ID3D12PipelineLibrary1,
pName: ?[*:0]const u16,
pDesc: ?*const D3D12_PIPELINE_STATE_STREAM_DESC,
riid: ?*const Guid,
ppPipelineState: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12PipelineLibrary.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12PipelineLibrary1_LoadPipeline(self: *const T, pName: ?[*:0]const u16, pDesc: ?*const D3D12_PIPELINE_STATE_STREAM_DESC, riid: ?*const Guid, ppPipelineState: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12PipelineLibrary1.VTable, self.vtable).LoadPipeline(@ptrCast(*const ID3D12PipelineLibrary1, self), pName, pDesc, riid, ppPipelineState);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_MULTIPLE_FENCE_WAIT_FLAGS = enum(u32) {
NONE = 0,
ANY = 1,
// ALL = 0, this enum value conflicts with NONE
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
ANY: u1 = 0,
}) D3D12_MULTIPLE_FENCE_WAIT_FLAGS {
return @intToEnum(D3D12_MULTIPLE_FENCE_WAIT_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_MULTIPLE_FENCE_WAIT_FLAGS.NONE) else 0)
| (if (o.ANY == 1) @enumToInt(D3D12_MULTIPLE_FENCE_WAIT_FLAGS.ANY) else 0)
);
}
};
pub const D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE = D3D12_MULTIPLE_FENCE_WAIT_FLAGS.NONE;
pub const D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY = D3D12_MULTIPLE_FENCE_WAIT_FLAGS.ANY;
pub const D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL = D3D12_MULTIPLE_FENCE_WAIT_FLAGS.NONE;
pub const D3D12_RESIDENCY_PRIORITY = enum(i32) {
MINIMUM = 671088640,
LOW = 1342177280,
NORMAL = 2013265920,
HIGH = -1610547200,
MAXIMUM = -939524096,
};
pub const D3D12_RESIDENCY_PRIORITY_MINIMUM = D3D12_RESIDENCY_PRIORITY.MINIMUM;
pub const D3D12_RESIDENCY_PRIORITY_LOW = D3D12_RESIDENCY_PRIORITY.LOW;
pub const D3D12_RESIDENCY_PRIORITY_NORMAL = D3D12_RESIDENCY_PRIORITY.NORMAL;
pub const D3D12_RESIDENCY_PRIORITY_HIGH = D3D12_RESIDENCY_PRIORITY.HIGH;
pub const D3D12_RESIDENCY_PRIORITY_MAXIMUM = D3D12_RESIDENCY_PRIORITY.MAXIMUM;
const IID_ID3D12Device1_Value = Guid.initString("77acce80-638e-4e65-8895-c1f23386863e");
pub const IID_ID3D12Device1 = &IID_ID3D12Device1_Value;
pub const ID3D12Device1 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device.VTable,
CreatePipelineLibrary: fn(
self: *const ID3D12Device1,
pLibraryBlob: [*]const u8,
BlobLength: usize,
riid: ?*const Guid,
ppPipelineLibrary: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetEventOnMultipleFenceCompletion: fn(
self: *const ID3D12Device1,
ppFences: [*]?*ID3D12Fence,
pFenceValues: [*]const u64,
NumFences: u32,
Flags: D3D12_MULTIPLE_FENCE_WAIT_FLAGS,
hEvent: ?HANDLE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetResidencyPriority: fn(
self: *const ID3D12Device1,
NumObjects: u32,
ppObjects: [*]?*ID3D12Pageable,
pPriorities: [*]const D3D12_RESIDENCY_PRIORITY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device1_CreatePipelineLibrary(self: *const T, pLibraryBlob: [*]const u8, BlobLength: usize, riid: ?*const Guid, ppPipelineLibrary: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device1.VTable, self.vtable).CreatePipelineLibrary(@ptrCast(*const ID3D12Device1, self), pLibraryBlob, BlobLength, riid, ppPipelineLibrary);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device1_SetEventOnMultipleFenceCompletion(self: *const T, ppFences: [*]?*ID3D12Fence, pFenceValues: [*]const u64, NumFences: u32, Flags: D3D12_MULTIPLE_FENCE_WAIT_FLAGS, hEvent: ?HANDLE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device1.VTable, self.vtable).SetEventOnMultipleFenceCompletion(@ptrCast(*const ID3D12Device1, self), ppFences, pFenceValues, NumFences, Flags, hEvent);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device1_SetResidencyPriority(self: *const T, NumObjects: u32, ppObjects: [*]?*ID3D12Pageable, pPriorities: [*]const D3D12_RESIDENCY_PRIORITY) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device1.VTable, self.vtable).SetResidencyPriority(@ptrCast(*const ID3D12Device1, self), NumObjects, ppObjects, pPriorities);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Device2_Value = Guid.initString("30baa41e-b15b-475c-a0bb-1af5c5b64328");
pub const IID_ID3D12Device2 = &IID_ID3D12Device2_Value;
pub const ID3D12Device2 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device1.VTable,
CreatePipelineState: fn(
self: *const ID3D12Device2,
pDesc: ?*const D3D12_PIPELINE_STATE_STREAM_DESC,
riid: ?*const Guid,
ppPipelineState: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device2_CreatePipelineState(self: *const T, pDesc: ?*const D3D12_PIPELINE_STATE_STREAM_DESC, riid: ?*const Guid, ppPipelineState: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device2.VTable, self.vtable).CreatePipelineState(@ptrCast(*const ID3D12Device2, self), pDesc, riid, ppPipelineState);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_RESIDENCY_FLAGS = enum(u32) {
NONE = 0,
DENY_OVERBUDGET = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
DENY_OVERBUDGET: u1 = 0,
}) D3D12_RESIDENCY_FLAGS {
return @intToEnum(D3D12_RESIDENCY_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RESIDENCY_FLAGS.NONE) else 0)
| (if (o.DENY_OVERBUDGET == 1) @enumToInt(D3D12_RESIDENCY_FLAGS.DENY_OVERBUDGET) else 0)
);
}
};
pub const D3D12_RESIDENCY_FLAG_NONE = D3D12_RESIDENCY_FLAGS.NONE;
pub const D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = D3D12_RESIDENCY_FLAGS.DENY_OVERBUDGET;
const IID_ID3D12Device3_Value = Guid.initString("81dadc15-2bad-4392-93c5-101345c4aa98");
pub const IID_ID3D12Device3 = &IID_ID3D12Device3_Value;
pub const ID3D12Device3 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device2.VTable,
OpenExistingHeapFromAddress: fn(
self: *const ID3D12Device3,
pAddress: ?*const anyopaque,
riid: ?*const Guid,
ppvHeap: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenExistingHeapFromFileMapping: fn(
self: *const ID3D12Device3,
hFileMapping: ?HANDLE,
riid: ?*const Guid,
ppvHeap: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnqueueMakeResident: fn(
self: *const ID3D12Device3,
Flags: D3D12_RESIDENCY_FLAGS,
NumObjects: u32,
ppObjects: [*]?*ID3D12Pageable,
pFenceToSignal: ?*ID3D12Fence,
FenceValueToSignal: u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device3_OpenExistingHeapFromAddress(self: *const T, pAddress: ?*const anyopaque, riid: ?*const Guid, ppvHeap: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device3.VTable, self.vtable).OpenExistingHeapFromAddress(@ptrCast(*const ID3D12Device3, self), pAddress, riid, ppvHeap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device3_OpenExistingHeapFromFileMapping(self: *const T, hFileMapping: ?HANDLE, riid: ?*const Guid, ppvHeap: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device3.VTable, self.vtable).OpenExistingHeapFromFileMapping(@ptrCast(*const ID3D12Device3, self), hFileMapping, riid, ppvHeap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device3_EnqueueMakeResident(self: *const T, Flags: D3D12_RESIDENCY_FLAGS, NumObjects: u32, ppObjects: [*]?*ID3D12Pageable, pFenceToSignal: ?*ID3D12Fence, FenceValueToSignal: u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device3.VTable, self.vtable).EnqueueMakeResident(@ptrCast(*const ID3D12Device3, self), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_COMMAND_LIST_FLAGS = enum(u32) {
E = 0,
_,
pub fn initFlags(o: struct {
E: u1 = 0,
}) D3D12_COMMAND_LIST_FLAGS {
return @intToEnum(D3D12_COMMAND_LIST_FLAGS,
(if (o.E == 1) @enumToInt(D3D12_COMMAND_LIST_FLAGS.E) else 0)
);
}
};
pub const D3D12_COMMAND_LIST_FLAG_NONE = D3D12_COMMAND_LIST_FLAGS.E;
pub const D3D12_COMMAND_POOL_FLAGS = enum(u32) {
E = 0,
_,
pub fn initFlags(o: struct {
E: u1 = 0,
}) D3D12_COMMAND_POOL_FLAGS {
return @intToEnum(D3D12_COMMAND_POOL_FLAGS,
(if (o.E == 1) @enumToInt(D3D12_COMMAND_POOL_FLAGS.E) else 0)
);
}
};
pub const D3D12_COMMAND_POOL_FLAG_NONE = D3D12_COMMAND_POOL_FLAGS.E;
pub const D3D12_COMMAND_RECORDER_FLAGS = enum(u32) {
E = 0,
_,
pub fn initFlags(o: struct {
E: u1 = 0,
}) D3D12_COMMAND_RECORDER_FLAGS {
return @intToEnum(D3D12_COMMAND_RECORDER_FLAGS,
(if (o.E == 1) @enumToInt(D3D12_COMMAND_RECORDER_FLAGS.E) else 0)
);
}
};
pub const D3D12_COMMAND_RECORDER_FLAG_NONE = D3D12_COMMAND_RECORDER_FLAGS.E;
pub const D3D12_PROTECTED_SESSION_STATUS = enum(i32) {
OK = 0,
INVALID = 1,
};
pub const D3D12_PROTECTED_SESSION_STATUS_OK = D3D12_PROTECTED_SESSION_STATUS.OK;
pub const D3D12_PROTECTED_SESSION_STATUS_INVALID = D3D12_PROTECTED_SESSION_STATUS.INVALID;
const IID_ID3D12ProtectedSession_Value = Guid.initString("a1533d18-0ac1-4084-85b9-89a96116806b");
pub const IID_ID3D12ProtectedSession = &IID_ID3D12ProtectedSession_Value;
pub const ID3D12ProtectedSession = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceChild.VTable,
GetStatusFence: fn(
self: *const ID3D12ProtectedSession,
riid: ?*const Guid,
ppFence: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSessionStatus: fn(
self: *const ID3D12ProtectedSession,
) callconv(@import("std").os.windows.WINAPI) D3D12_PROTECTED_SESSION_STATUS,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceChild.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ProtectedSession_GetStatusFence(self: *const T, riid: ?*const Guid, ppFence: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ProtectedSession.VTable, self.vtable).GetStatusFence(@ptrCast(*const ID3D12ProtectedSession, self), riid, ppFence);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ProtectedSession_GetSessionStatus(self: *const T) callconv(.Inline) D3D12_PROTECTED_SESSION_STATUS {
return @ptrCast(*const ID3D12ProtectedSession.VTable, self.vtable).GetSessionStatus(@ptrCast(*const ID3D12ProtectedSession, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS = enum(u32) {
NONE = 0,
SUPPORTED = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
SUPPORTED: u1 = 0,
}) D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS {
return @intToEnum(D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS.NONE) else 0)
| (if (o.SUPPORTED == 1) @enumToInt(D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS.SUPPORTED) else 0)
);
}
};
pub const D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE = D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS.NONE;
pub const D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS.SUPPORTED;
pub const D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT = extern struct {
NodeIndex: u32,
Support: D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS,
};
pub const D3D12_PROTECTED_RESOURCE_SESSION_FLAGS = enum(u32) {
E = 0,
_,
pub fn initFlags(o: struct {
E: u1 = 0,
}) D3D12_PROTECTED_RESOURCE_SESSION_FLAGS {
return @intToEnum(D3D12_PROTECTED_RESOURCE_SESSION_FLAGS,
(if (o.E == 1) @enumToInt(D3D12_PROTECTED_RESOURCE_SESSION_FLAGS.E) else 0)
);
}
};
pub const D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = D3D12_PROTECTED_RESOURCE_SESSION_FLAGS.E;
pub const D3D12_PROTECTED_RESOURCE_SESSION_DESC = extern struct {
NodeMask: u32,
Flags: D3D12_PROTECTED_RESOURCE_SESSION_FLAGS,
};
const IID_ID3D12ProtectedResourceSession_Value = Guid.initString("6cd696f4-f289-40cc-8091-5a6c0a099c3d");
pub const IID_ID3D12ProtectedResourceSession = &IID_ID3D12ProtectedResourceSession_Value;
pub const ID3D12ProtectedResourceSession = extern struct {
pub const VTable = extern struct {
base: ID3D12ProtectedSession.VTable,
GetDesc: fn(
self: *const ID3D12ProtectedResourceSession,
) callconv(@import("std").os.windows.WINAPI) D3D12_PROTECTED_RESOURCE_SESSION_DESC,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12ProtectedSession.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ProtectedResourceSession_GetDesc(self: *const T) callconv(.Inline) D3D12_PROTECTED_RESOURCE_SESSION_DESC {
return @ptrCast(*const ID3D12ProtectedResourceSession.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12ProtectedResourceSession, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Device4_Value = Guid.initString("e865df17-a9ee-46f9-a463-3098315aa2e5");
pub const IID_ID3D12Device4 = &IID_ID3D12Device4_Value;
pub const ID3D12Device4 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device3.VTable,
CreateCommandList1: fn(
self: *const ID3D12Device4,
nodeMask: u32,
type: D3D12_COMMAND_LIST_TYPE,
flags: D3D12_COMMAND_LIST_FLAGS,
riid: ?*const Guid,
ppCommandList: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateProtectedResourceSession: fn(
self: *const ID3D12Device4,
pDesc: ?*const D3D12_PROTECTED_RESOURCE_SESSION_DESC,
riid: ?*const Guid,
ppSession: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateCommittedResource1: fn(
self: *const ID3D12Device4,
pHeapProperties: ?*const D3D12_HEAP_PROPERTIES,
HeapFlags: D3D12_HEAP_FLAGS,
pDesc: ?*const D3D12_RESOURCE_DESC,
InitialResourceState: D3D12_RESOURCE_STATES,
pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE,
pProtectedSession: ?*ID3D12ProtectedResourceSession,
riidResource: ?*const Guid,
ppvResource: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateHeap1: fn(
self: *const ID3D12Device4,
pDesc: ?*const D3D12_HEAP_DESC,
pProtectedSession: ?*ID3D12ProtectedResourceSession,
riid: ?*const Guid,
ppvHeap: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateReservedResource1: fn(
self: *const ID3D12Device4,
pDesc: ?*const D3D12_RESOURCE_DESC,
InitialState: D3D12_RESOURCE_STATES,
pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE,
pProtectedSession: ?*ID3D12ProtectedResourceSession,
riid: ?*const Guid,
ppvResource: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetResourceAllocationInfo1: fn(
self: *const ID3D12Device4,
visibleMask: u32,
numResourceDescs: u32,
pResourceDescs: [*]const D3D12_RESOURCE_DESC,
pResourceAllocationInfo1: ?[*]D3D12_RESOURCE_ALLOCATION_INFO1,
) callconv(@import("std").os.windows.WINAPI) D3D12_RESOURCE_ALLOCATION_INFO,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device4_CreateCommandList1(self: *const T, nodeMask: u32, type_: D3D12_COMMAND_LIST_TYPE, flags: D3D12_COMMAND_LIST_FLAGS, riid: ?*const Guid, ppCommandList: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device4.VTable, self.vtable).CreateCommandList1(@ptrCast(*const ID3D12Device4, self), nodeMask, type_, flags, riid, ppCommandList);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device4_CreateProtectedResourceSession(self: *const T, pDesc: ?*const D3D12_PROTECTED_RESOURCE_SESSION_DESC, riid: ?*const Guid, ppSession: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device4.VTable, self.vtable).CreateProtectedResourceSession(@ptrCast(*const ID3D12Device4, self), pDesc, riid, ppSession);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device4_CreateCommittedResource1(self: *const T, pHeapProperties: ?*const D3D12_HEAP_PROPERTIES, HeapFlags: D3D12_HEAP_FLAGS, pDesc: ?*const D3D12_RESOURCE_DESC, InitialResourceState: D3D12_RESOURCE_STATES, pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE, pProtectedSession: ?*ID3D12ProtectedResourceSession, riidResource: ?*const Guid, ppvResource: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device4.VTable, self.vtable).CreateCommittedResource1(@ptrCast(*const ID3D12Device4, self), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device4_CreateHeap1(self: *const T, pDesc: ?*const D3D12_HEAP_DESC, pProtectedSession: ?*ID3D12ProtectedResourceSession, riid: ?*const Guid, ppvHeap: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device4.VTable, self.vtable).CreateHeap1(@ptrCast(*const ID3D12Device4, self), pDesc, pProtectedSession, riid, ppvHeap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device4_CreateReservedResource1(self: *const T, pDesc: ?*const D3D12_RESOURCE_DESC, InitialState: D3D12_RESOURCE_STATES, pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE, pProtectedSession: ?*ID3D12ProtectedResourceSession, riid: ?*const Guid, ppvResource: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device4.VTable, self.vtable).CreateReservedResource1(@ptrCast(*const ID3D12Device4, self), pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device4_GetResourceAllocationInfo1(self: *const T, visibleMask: u32, numResourceDescs: u32, pResourceDescs: [*]const D3D12_RESOURCE_DESC, pResourceAllocationInfo1: ?[*]D3D12_RESOURCE_ALLOCATION_INFO1) callconv(.Inline) D3D12_RESOURCE_ALLOCATION_INFO {
return @ptrCast(*const ID3D12Device4.VTable, self.vtable).GetResourceAllocationInfo1(@ptrCast(*const ID3D12Device4, self), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_LIFETIME_STATE = enum(i32) {
IN_USE = 0,
NOT_IN_USE = 1,
};
pub const D3D12_LIFETIME_STATE_IN_USE = D3D12_LIFETIME_STATE.IN_USE;
pub const D3D12_LIFETIME_STATE_NOT_IN_USE = D3D12_LIFETIME_STATE.NOT_IN_USE;
const IID_ID3D12LifetimeOwner_Value = Guid.initString("e667af9f-cd56-4f46-83ce-032e595d70a8");
pub const IID_ID3D12LifetimeOwner = &IID_ID3D12LifetimeOwner_Value;
pub const ID3D12LifetimeOwner = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
LifetimeStateUpdated: fn(
self: *const ID3D12LifetimeOwner,
NewState: D3D12_LIFETIME_STATE,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12LifetimeOwner_LifetimeStateUpdated(self: *const T, NewState: D3D12_LIFETIME_STATE) callconv(.Inline) void {
return @ptrCast(*const ID3D12LifetimeOwner.VTable, self.vtable).LifetimeStateUpdated(@ptrCast(*const ID3D12LifetimeOwner, self), NewState);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12SwapChainAssistant_Value = Guid.initString("f1df64b6-57fd-49cd-8807-c0eb88b45c8f");
pub const IID_ID3D12SwapChainAssistant = &IID_ID3D12SwapChainAssistant_Value;
pub const ID3D12SwapChainAssistant = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetLUID: fn(
self: *const ID3D12SwapChainAssistant,
) callconv(@import("std").os.windows.WINAPI) LUID,
GetSwapChainObject: fn(
self: *const ID3D12SwapChainAssistant,
riid: ?*const Guid,
ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCurrentResourceAndCommandQueue: fn(
self: *const ID3D12SwapChainAssistant,
riidResource: ?*const Guid,
ppvResource: ?*?*anyopaque,
riidQueue: ?*const Guid,
ppvQueue: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InsertImplicitSync: fn(
self: *const ID3D12SwapChainAssistant,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SwapChainAssistant_GetLUID(self: *const T) callconv(.Inline) LUID {
return @ptrCast(*const ID3D12SwapChainAssistant.VTable, self.vtable).GetLUID(@ptrCast(*const ID3D12SwapChainAssistant, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SwapChainAssistant_GetSwapChainObject(self: *const T, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12SwapChainAssistant.VTable, self.vtable).GetSwapChainObject(@ptrCast(*const ID3D12SwapChainAssistant, self), riid, ppv);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SwapChainAssistant_GetCurrentResourceAndCommandQueue(self: *const T, riidResource: ?*const Guid, ppvResource: ?*?*anyopaque, riidQueue: ?*const Guid, ppvQueue: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12SwapChainAssistant.VTable, self.vtable).GetCurrentResourceAndCommandQueue(@ptrCast(*const ID3D12SwapChainAssistant, self), riidResource, ppvResource, riidQueue, ppvQueue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SwapChainAssistant_InsertImplicitSync(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12SwapChainAssistant.VTable, self.vtable).InsertImplicitSync(@ptrCast(*const ID3D12SwapChainAssistant, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12LifetimeTracker_Value = Guid.initString("3fd03d36-4eb1-424a-a582-494ecb8ba813");
pub const IID_ID3D12LifetimeTracker = &IID_ID3D12LifetimeTracker_Value;
pub const ID3D12LifetimeTracker = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceChild.VTable,
DestroyOwnedObject: fn(
self: *const ID3D12LifetimeTracker,
pObject: ?*ID3D12DeviceChild,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceChild.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12LifetimeTracker_DestroyOwnedObject(self: *const T, pObject: ?*ID3D12DeviceChild) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12LifetimeTracker.VTable, self.vtable).DestroyOwnedObject(@ptrCast(*const ID3D12LifetimeTracker, self), pObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_META_COMMAND_PARAMETER_TYPE = enum(i32) {
FLOAT = 0,
UINT64 = 1,
GPU_VIRTUAL_ADDRESS = 2,
CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 3,
GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 4,
};
pub const D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT = D3D12_META_COMMAND_PARAMETER_TYPE.FLOAT;
pub const D3D12_META_COMMAND_PARAMETER_TYPE_UINT64 = D3D12_META_COMMAND_PARAMETER_TYPE.UINT64;
pub const D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS = D3D12_META_COMMAND_PARAMETER_TYPE.GPU_VIRTUAL_ADDRESS;
pub const D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = D3D12_META_COMMAND_PARAMETER_TYPE.CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV;
pub const D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = D3D12_META_COMMAND_PARAMETER_TYPE.GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV;
pub const D3D12_META_COMMAND_PARAMETER_FLAGS = enum(u32) {
INPUT = 1,
OUTPUT = 2,
_,
pub fn initFlags(o: struct {
INPUT: u1 = 0,
OUTPUT: u1 = 0,
}) D3D12_META_COMMAND_PARAMETER_FLAGS {
return @intToEnum(D3D12_META_COMMAND_PARAMETER_FLAGS,
(if (o.INPUT == 1) @enumToInt(D3D12_META_COMMAND_PARAMETER_FLAGS.INPUT) else 0)
| (if (o.OUTPUT == 1) @enumToInt(D3D12_META_COMMAND_PARAMETER_FLAGS.OUTPUT) else 0)
);
}
};
pub const D3D12_META_COMMAND_PARAMETER_FLAG_INPUT = D3D12_META_COMMAND_PARAMETER_FLAGS.INPUT;
pub const D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = D3D12_META_COMMAND_PARAMETER_FLAGS.OUTPUT;
pub const D3D12_META_COMMAND_PARAMETER_STAGE = enum(i32) {
CREATION = 0,
INITIALIZATION = 1,
EXECUTION = 2,
};
pub const D3D12_META_COMMAND_PARAMETER_STAGE_CREATION = D3D12_META_COMMAND_PARAMETER_STAGE.CREATION;
pub const D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION = D3D12_META_COMMAND_PARAMETER_STAGE.INITIALIZATION;
pub const D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION = D3D12_META_COMMAND_PARAMETER_STAGE.EXECUTION;
pub const D3D12_META_COMMAND_PARAMETER_DESC = extern struct {
Name: ?[*:0]const u16,
Type: D3D12_META_COMMAND_PARAMETER_TYPE,
Flags: D3D12_META_COMMAND_PARAMETER_FLAGS,
RequiredResourceState: D3D12_RESOURCE_STATES,
StructureOffset: u32,
};
pub const D3D12_GRAPHICS_STATES = enum(u32) {
NONE = 0,
IA_VERTEX_BUFFERS = 1,
IA_INDEX_BUFFER = 2,
IA_PRIMITIVE_TOPOLOGY = 4,
DESCRIPTOR_HEAP = 8,
GRAPHICS_ROOT_SIGNATURE = 16,
COMPUTE_ROOT_SIGNATURE = 32,
RS_VIEWPORTS = 64,
RS_SCISSOR_RECTS = 128,
PREDICATION = 256,
OM_RENDER_TARGETS = 512,
OM_STENCIL_REF = 1024,
OM_BLEND_FACTOR = 2048,
PIPELINE_STATE = 4096,
SO_TARGETS = 8192,
OM_DEPTH_BOUNDS = 16384,
SAMPLE_POSITIONS = 32768,
VIEW_INSTANCE_MASK = 65536,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
IA_VERTEX_BUFFERS: u1 = 0,
IA_INDEX_BUFFER: u1 = 0,
IA_PRIMITIVE_TOPOLOGY: u1 = 0,
DESCRIPTOR_HEAP: u1 = 0,
GRAPHICS_ROOT_SIGNATURE: u1 = 0,
COMPUTE_ROOT_SIGNATURE: u1 = 0,
RS_VIEWPORTS: u1 = 0,
RS_SCISSOR_RECTS: u1 = 0,
PREDICATION: u1 = 0,
OM_RENDER_TARGETS: u1 = 0,
OM_STENCIL_REF: u1 = 0,
OM_BLEND_FACTOR: u1 = 0,
PIPELINE_STATE: u1 = 0,
SO_TARGETS: u1 = 0,
OM_DEPTH_BOUNDS: u1 = 0,
SAMPLE_POSITIONS: u1 = 0,
VIEW_INSTANCE_MASK: u1 = 0,
}) D3D12_GRAPHICS_STATES {
return @intToEnum(D3D12_GRAPHICS_STATES,
(if (o.NONE == 1) @enumToInt(D3D12_GRAPHICS_STATES.NONE) else 0)
| (if (o.IA_VERTEX_BUFFERS == 1) @enumToInt(D3D12_GRAPHICS_STATES.IA_VERTEX_BUFFERS) else 0)
| (if (o.IA_INDEX_BUFFER == 1) @enumToInt(D3D12_GRAPHICS_STATES.IA_INDEX_BUFFER) else 0)
| (if (o.IA_PRIMITIVE_TOPOLOGY == 1) @enumToInt(D3D12_GRAPHICS_STATES.IA_PRIMITIVE_TOPOLOGY) else 0)
| (if (o.DESCRIPTOR_HEAP == 1) @enumToInt(D3D12_GRAPHICS_STATES.DESCRIPTOR_HEAP) else 0)
| (if (o.GRAPHICS_ROOT_SIGNATURE == 1) @enumToInt(D3D12_GRAPHICS_STATES.GRAPHICS_ROOT_SIGNATURE) else 0)
| (if (o.COMPUTE_ROOT_SIGNATURE == 1) @enumToInt(D3D12_GRAPHICS_STATES.COMPUTE_ROOT_SIGNATURE) else 0)
| (if (o.RS_VIEWPORTS == 1) @enumToInt(D3D12_GRAPHICS_STATES.RS_VIEWPORTS) else 0)
| (if (o.RS_SCISSOR_RECTS == 1) @enumToInt(D3D12_GRAPHICS_STATES.RS_SCISSOR_RECTS) else 0)
| (if (o.PREDICATION == 1) @enumToInt(D3D12_GRAPHICS_STATES.PREDICATION) else 0)
| (if (o.OM_RENDER_TARGETS == 1) @enumToInt(D3D12_GRAPHICS_STATES.OM_RENDER_TARGETS) else 0)
| (if (o.OM_STENCIL_REF == 1) @enumToInt(D3D12_GRAPHICS_STATES.OM_STENCIL_REF) else 0)
| (if (o.OM_BLEND_FACTOR == 1) @enumToInt(D3D12_GRAPHICS_STATES.OM_BLEND_FACTOR) else 0)
| (if (o.PIPELINE_STATE == 1) @enumToInt(D3D12_GRAPHICS_STATES.PIPELINE_STATE) else 0)
| (if (o.SO_TARGETS == 1) @enumToInt(D3D12_GRAPHICS_STATES.SO_TARGETS) else 0)
| (if (o.OM_DEPTH_BOUNDS == 1) @enumToInt(D3D12_GRAPHICS_STATES.OM_DEPTH_BOUNDS) else 0)
| (if (o.SAMPLE_POSITIONS == 1) @enumToInt(D3D12_GRAPHICS_STATES.SAMPLE_POSITIONS) else 0)
| (if (o.VIEW_INSTANCE_MASK == 1) @enumToInt(D3D12_GRAPHICS_STATES.VIEW_INSTANCE_MASK) else 0)
);
}
};
pub const D3D12_GRAPHICS_STATE_NONE = D3D12_GRAPHICS_STATES.NONE;
pub const D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS = D3D12_GRAPHICS_STATES.IA_VERTEX_BUFFERS;
pub const D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER = D3D12_GRAPHICS_STATES.IA_INDEX_BUFFER;
pub const D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = D3D12_GRAPHICS_STATES.IA_PRIMITIVE_TOPOLOGY;
pub const D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP = D3D12_GRAPHICS_STATES.DESCRIPTOR_HEAP;
pub const D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = D3D12_GRAPHICS_STATES.GRAPHICS_ROOT_SIGNATURE;
pub const D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = D3D12_GRAPHICS_STATES.COMPUTE_ROOT_SIGNATURE;
pub const D3D12_GRAPHICS_STATE_RS_VIEWPORTS = D3D12_GRAPHICS_STATES.RS_VIEWPORTS;
pub const D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS = D3D12_GRAPHICS_STATES.RS_SCISSOR_RECTS;
pub const D3D12_GRAPHICS_STATE_PREDICATION = D3D12_GRAPHICS_STATES.PREDICATION;
pub const D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS = D3D12_GRAPHICS_STATES.OM_RENDER_TARGETS;
pub const D3D12_GRAPHICS_STATE_OM_STENCIL_REF = D3D12_GRAPHICS_STATES.OM_STENCIL_REF;
pub const D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR = D3D12_GRAPHICS_STATES.OM_BLEND_FACTOR;
pub const D3D12_GRAPHICS_STATE_PIPELINE_STATE = D3D12_GRAPHICS_STATES.PIPELINE_STATE;
pub const D3D12_GRAPHICS_STATE_SO_TARGETS = D3D12_GRAPHICS_STATES.SO_TARGETS;
pub const D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS = D3D12_GRAPHICS_STATES.OM_DEPTH_BOUNDS;
pub const D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS = D3D12_GRAPHICS_STATES.SAMPLE_POSITIONS;
pub const D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = D3D12_GRAPHICS_STATES.VIEW_INSTANCE_MASK;
pub const D3D12_META_COMMAND_DESC = extern struct {
Id: Guid,
Name: ?[*:0]const u16,
InitializationDirtyState: D3D12_GRAPHICS_STATES,
ExecutionDirtyState: D3D12_GRAPHICS_STATES,
};
const IID_ID3D12StateObject_Value = Guid.initString("47016943-fca8-4594-93ea-af258b55346d");
pub const IID_ID3D12StateObject = &IID_ID3D12StateObject_Value;
pub const ID3D12StateObject = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12StateObjectProperties_Value = Guid.initString("de5fa827-9bf9-4f26-89ff-d7f56fde3860");
pub const IID_ID3D12StateObjectProperties = &IID_ID3D12StateObjectProperties_Value;
pub const ID3D12StateObjectProperties = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetShaderIdentifier: fn(
self: *const ID3D12StateObjectProperties,
pExportName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque,
GetShaderStackSize: fn(
self: *const ID3D12StateObjectProperties,
pExportName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) u64,
GetPipelineStackSize: fn(
self: *const ID3D12StateObjectProperties,
) callconv(@import("std").os.windows.WINAPI) u64,
SetPipelineStackSize: fn(
self: *const ID3D12StateObjectProperties,
PipelineStackSizeInBytes: u64,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12StateObjectProperties_GetShaderIdentifier(self: *const T, pExportName: ?[*:0]const u16) callconv(.Inline) ?*anyopaque {
return @ptrCast(*const ID3D12StateObjectProperties.VTable, self.vtable).GetShaderIdentifier(@ptrCast(*const ID3D12StateObjectProperties, self), pExportName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12StateObjectProperties_GetShaderStackSize(self: *const T, pExportName: ?[*:0]const u16) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12StateObjectProperties.VTable, self.vtable).GetShaderStackSize(@ptrCast(*const ID3D12StateObjectProperties, self), pExportName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12StateObjectProperties_GetPipelineStackSize(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12StateObjectProperties.VTable, self.vtable).GetPipelineStackSize(@ptrCast(*const ID3D12StateObjectProperties, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12StateObjectProperties_SetPipelineStackSize(self: *const T, PipelineStackSizeInBytes: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12StateObjectProperties.VTable, self.vtable).SetPipelineStackSize(@ptrCast(*const ID3D12StateObjectProperties, self), PipelineStackSizeInBytes);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_STATE_SUBOBJECT_TYPE = enum(i32) {
STATE_OBJECT_CONFIG = 0,
GLOBAL_ROOT_SIGNATURE = 1,
LOCAL_ROOT_SIGNATURE = 2,
NODE_MASK = 3,
DXIL_LIBRARY = 5,
EXISTING_COLLECTION = 6,
SUBOBJECT_TO_EXPORTS_ASSOCIATION = 7,
DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 8,
RAYTRACING_SHADER_CONFIG = 9,
RAYTRACING_PIPELINE_CONFIG = 10,
HIT_GROUP = 11,
RAYTRACING_PIPELINE_CONFIG1 = 12,
MAX_VALID = 13,
};
pub const D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = D3D12_STATE_SUBOBJECT_TYPE.STATE_OBJECT_CONFIG;
pub const D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = D3D12_STATE_SUBOBJECT_TYPE.GLOBAL_ROOT_SIGNATURE;
pub const D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = D3D12_STATE_SUBOBJECT_TYPE.LOCAL_ROOT_SIGNATURE;
pub const D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = D3D12_STATE_SUBOBJECT_TYPE.NODE_MASK;
pub const D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = D3D12_STATE_SUBOBJECT_TYPE.DXIL_LIBRARY;
pub const D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = D3D12_STATE_SUBOBJECT_TYPE.EXISTING_COLLECTION;
pub const D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = D3D12_STATE_SUBOBJECT_TYPE.SUBOBJECT_TO_EXPORTS_ASSOCIATION;
pub const D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = D3D12_STATE_SUBOBJECT_TYPE.DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
pub const D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = D3D12_STATE_SUBOBJECT_TYPE.RAYTRACING_SHADER_CONFIG;
pub const D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = D3D12_STATE_SUBOBJECT_TYPE.RAYTRACING_PIPELINE_CONFIG;
pub const D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = D3D12_STATE_SUBOBJECT_TYPE.HIT_GROUP;
pub const D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 = D3D12_STATE_SUBOBJECT_TYPE.RAYTRACING_PIPELINE_CONFIG1;
pub const D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = D3D12_STATE_SUBOBJECT_TYPE.MAX_VALID;
pub const D3D12_STATE_SUBOBJECT = extern struct {
Type: D3D12_STATE_SUBOBJECT_TYPE,
pDesc: ?*const anyopaque,
};
pub const D3D12_STATE_OBJECT_FLAGS = enum(u32) {
NONE = 0,
ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 1,
ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 2,
ALLOW_STATE_OBJECT_ADDITIONS = 4,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS: u1 = 0,
ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS: u1 = 0,
ALLOW_STATE_OBJECT_ADDITIONS: u1 = 0,
}) D3D12_STATE_OBJECT_FLAGS {
return @intToEnum(D3D12_STATE_OBJECT_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_STATE_OBJECT_FLAGS.NONE) else 0)
| (if (o.ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS == 1) @enumToInt(D3D12_STATE_OBJECT_FLAGS.ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS) else 0)
| (if (o.ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS == 1) @enumToInt(D3D12_STATE_OBJECT_FLAGS.ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS) else 0)
| (if (o.ALLOW_STATE_OBJECT_ADDITIONS == 1) @enumToInt(D3D12_STATE_OBJECT_FLAGS.ALLOW_STATE_OBJECT_ADDITIONS) else 0)
);
}
};
pub const D3D12_STATE_OBJECT_FLAG_NONE = D3D12_STATE_OBJECT_FLAGS.NONE;
pub const D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = D3D12_STATE_OBJECT_FLAGS.ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS;
pub const D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = D3D12_STATE_OBJECT_FLAGS.ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS;
pub const D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = D3D12_STATE_OBJECT_FLAGS.ALLOW_STATE_OBJECT_ADDITIONS;
pub const D3D12_STATE_OBJECT_CONFIG = extern struct {
Flags: D3D12_STATE_OBJECT_FLAGS,
};
pub const D3D12_GLOBAL_ROOT_SIGNATURE = extern struct {
pGlobalRootSignature: ?*ID3D12RootSignature,
};
pub const D3D12_LOCAL_ROOT_SIGNATURE = extern struct {
pLocalRootSignature: ?*ID3D12RootSignature,
};
pub const D3D12_NODE_MASK = extern struct {
NodeMask: u32,
};
pub const D3D12_EXPORT_FLAGS = enum(u32) {
E = 0,
_,
pub fn initFlags(o: struct {
E: u1 = 0,
}) D3D12_EXPORT_FLAGS {
return @intToEnum(D3D12_EXPORT_FLAGS,
(if (o.E == 1) @enumToInt(D3D12_EXPORT_FLAGS.E) else 0)
);
}
};
pub const D3D12_EXPORT_FLAG_NONE = D3D12_EXPORT_FLAGS.E;
pub const D3D12_EXPORT_DESC = extern struct {
Name: ?[*:0]const u16,
ExportToRename: ?[*:0]const u16,
Flags: D3D12_EXPORT_FLAGS,
};
pub const D3D12_DXIL_LIBRARY_DESC = extern struct {
DXILLibrary: D3D12_SHADER_BYTECODE,
NumExports: u32,
pExports: ?*D3D12_EXPORT_DESC,
};
pub const D3D12_EXISTING_COLLECTION_DESC = extern struct {
pExistingCollection: ?*ID3D12StateObject,
NumExports: u32,
pExports: ?*D3D12_EXPORT_DESC,
};
pub const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION = extern struct {
pSubobjectToAssociate: ?*const D3D12_STATE_SUBOBJECT,
NumExports: u32,
pExports: ?*?PWSTR,
};
pub const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = extern struct {
SubobjectToAssociate: ?[*:0]const u16,
NumExports: u32,
pExports: ?*?PWSTR,
};
pub const D3D12_HIT_GROUP_TYPE = enum(i32) {
TRIANGLES = 0,
PROCEDURAL_PRIMITIVE = 1,
};
pub const D3D12_HIT_GROUP_TYPE_TRIANGLES = D3D12_HIT_GROUP_TYPE.TRIANGLES;
pub const D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = D3D12_HIT_GROUP_TYPE.PROCEDURAL_PRIMITIVE;
pub const D3D12_HIT_GROUP_DESC = extern struct {
HitGroupExport: ?[*:0]const u16,
Type: D3D12_HIT_GROUP_TYPE,
AnyHitShaderImport: ?[*:0]const u16,
ClosestHitShaderImport: ?[*:0]const u16,
IntersectionShaderImport: ?[*:0]const u16,
};
pub const D3D12_RAYTRACING_SHADER_CONFIG = extern struct {
MaxPayloadSizeInBytes: u32,
MaxAttributeSizeInBytes: u32,
};
pub const D3D12_RAYTRACING_PIPELINE_CONFIG = extern struct {
MaxTraceRecursionDepth: u32,
};
pub const D3D12_RAYTRACING_PIPELINE_FLAGS = enum(u32) {
NONE = 0,
SKIP_TRIANGLES = 256,
SKIP_PROCEDURAL_PRIMITIVES = 512,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
SKIP_TRIANGLES: u1 = 0,
SKIP_PROCEDURAL_PRIMITIVES: u1 = 0,
}) D3D12_RAYTRACING_PIPELINE_FLAGS {
return @intToEnum(D3D12_RAYTRACING_PIPELINE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RAYTRACING_PIPELINE_FLAGS.NONE) else 0)
| (if (o.SKIP_TRIANGLES == 1) @enumToInt(D3D12_RAYTRACING_PIPELINE_FLAGS.SKIP_TRIANGLES) else 0)
| (if (o.SKIP_PROCEDURAL_PRIMITIVES == 1) @enumToInt(D3D12_RAYTRACING_PIPELINE_FLAGS.SKIP_PROCEDURAL_PRIMITIVES) else 0)
);
}
};
pub const D3D12_RAYTRACING_PIPELINE_FLAG_NONE = D3D12_RAYTRACING_PIPELINE_FLAGS.NONE;
pub const D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = D3D12_RAYTRACING_PIPELINE_FLAGS.SKIP_TRIANGLES;
pub const D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = D3D12_RAYTRACING_PIPELINE_FLAGS.SKIP_PROCEDURAL_PRIMITIVES;
pub const D3D12_RAYTRACING_PIPELINE_CONFIG1 = extern struct {
MaxTraceRecursionDepth: u32,
Flags: D3D12_RAYTRACING_PIPELINE_FLAGS,
};
pub const D3D12_STATE_OBJECT_TYPE = enum(i32) {
COLLECTION = 0,
RAYTRACING_PIPELINE = 3,
};
pub const D3D12_STATE_OBJECT_TYPE_COLLECTION = D3D12_STATE_OBJECT_TYPE.COLLECTION;
pub const D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = D3D12_STATE_OBJECT_TYPE.RAYTRACING_PIPELINE;
pub const D3D12_STATE_OBJECT_DESC = extern struct {
Type: D3D12_STATE_OBJECT_TYPE,
NumSubobjects: u32,
pSubobjects: ?*const D3D12_STATE_SUBOBJECT,
};
pub const D3D12_RAYTRACING_GEOMETRY_FLAGS = enum(u32) {
NONE = 0,
OPAQUE = 1,
NO_DUPLICATE_ANYHIT_INVOCATION = 2,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
OPAQUE: u1 = 0,
NO_DUPLICATE_ANYHIT_INVOCATION: u1 = 0,
}) D3D12_RAYTRACING_GEOMETRY_FLAGS {
return @intToEnum(D3D12_RAYTRACING_GEOMETRY_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RAYTRACING_GEOMETRY_FLAGS.NONE) else 0)
| (if (o.OPAQUE == 1) @enumToInt(D3D12_RAYTRACING_GEOMETRY_FLAGS.OPAQUE) else 0)
| (if (o.NO_DUPLICATE_ANYHIT_INVOCATION == 1) @enumToInt(D3D12_RAYTRACING_GEOMETRY_FLAGS.NO_DUPLICATE_ANYHIT_INVOCATION) else 0)
);
}
};
pub const D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = D3D12_RAYTRACING_GEOMETRY_FLAGS.NONE;
pub const D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = D3D12_RAYTRACING_GEOMETRY_FLAGS.OPAQUE;
pub const D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = D3D12_RAYTRACING_GEOMETRY_FLAGS.NO_DUPLICATE_ANYHIT_INVOCATION;
pub const D3D12_RAYTRACING_GEOMETRY_TYPE = enum(i32) {
TRIANGLES = 0,
PROCEDURAL_PRIMITIVE_AABBS = 1,
};
pub const D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = D3D12_RAYTRACING_GEOMETRY_TYPE.TRIANGLES;
pub const D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = D3D12_RAYTRACING_GEOMETRY_TYPE.PROCEDURAL_PRIMITIVE_AABBS;
pub const D3D12_RAYTRACING_INSTANCE_FLAGS = enum(u32) {
NONE = 0,
TRIANGLE_CULL_DISABLE = 1,
TRIANGLE_FRONT_COUNTERCLOCKWISE = 2,
FORCE_OPAQUE = 4,
FORCE_NON_OPAQUE = 8,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
TRIANGLE_CULL_DISABLE: u1 = 0,
TRIANGLE_FRONT_COUNTERCLOCKWISE: u1 = 0,
FORCE_OPAQUE: u1 = 0,
FORCE_NON_OPAQUE: u1 = 0,
}) D3D12_RAYTRACING_INSTANCE_FLAGS {
return @intToEnum(D3D12_RAYTRACING_INSTANCE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RAYTRACING_INSTANCE_FLAGS.NONE) else 0)
| (if (o.TRIANGLE_CULL_DISABLE == 1) @enumToInt(D3D12_RAYTRACING_INSTANCE_FLAGS.TRIANGLE_CULL_DISABLE) else 0)
| (if (o.TRIANGLE_FRONT_COUNTERCLOCKWISE == 1) @enumToInt(D3D12_RAYTRACING_INSTANCE_FLAGS.TRIANGLE_FRONT_COUNTERCLOCKWISE) else 0)
| (if (o.FORCE_OPAQUE == 1) @enumToInt(D3D12_RAYTRACING_INSTANCE_FLAGS.FORCE_OPAQUE) else 0)
| (if (o.FORCE_NON_OPAQUE == 1) @enumToInt(D3D12_RAYTRACING_INSTANCE_FLAGS.FORCE_NON_OPAQUE) else 0)
);
}
};
pub const D3D12_RAYTRACING_INSTANCE_FLAG_NONE = D3D12_RAYTRACING_INSTANCE_FLAGS.NONE;
pub const D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = D3D12_RAYTRACING_INSTANCE_FLAGS.TRIANGLE_CULL_DISABLE;
pub const D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = D3D12_RAYTRACING_INSTANCE_FLAGS.TRIANGLE_FRONT_COUNTERCLOCKWISE;
pub const D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = D3D12_RAYTRACING_INSTANCE_FLAGS.FORCE_OPAQUE;
pub const D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = D3D12_RAYTRACING_INSTANCE_FLAGS.FORCE_NON_OPAQUE;
pub const D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE = extern struct {
StartAddress: u64,
StrideInBytes: u64,
};
pub const D3D12_GPU_VIRTUAL_ADDRESS_RANGE = extern struct {
StartAddress: u64,
SizeInBytes: u64,
};
pub const D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE = extern struct {
StartAddress: u64,
SizeInBytes: u64,
StrideInBytes: u64,
};
pub const D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC = extern struct {
Transform3x4: u64,
IndexFormat: DXGI_FORMAT,
VertexFormat: DXGI_FORMAT,
IndexCount: u32,
VertexCount: u32,
IndexBuffer: u64,
VertexBuffer: D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE,
};
pub const D3D12_RAYTRACING_AABB = extern struct {
MinX: f32,
MinY: f32,
MinZ: f32,
MaxX: f32,
MaxY: f32,
MaxZ: f32,
};
pub const D3D12_RAYTRACING_GEOMETRY_AABBS_DESC = extern struct {
AABBCount: u64,
AABBs: D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS = enum(u32) {
NONE = 0,
ALLOW_UPDATE = 1,
ALLOW_COMPACTION = 2,
PREFER_FAST_TRACE = 4,
PREFER_FAST_BUILD = 8,
MINIMIZE_MEMORY = 16,
PERFORM_UPDATE = 32,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
ALLOW_UPDATE: u1 = 0,
ALLOW_COMPACTION: u1 = 0,
PREFER_FAST_TRACE: u1 = 0,
PREFER_FAST_BUILD: u1 = 0,
MINIMIZE_MEMORY: u1 = 0,
PERFORM_UPDATE: u1 = 0,
}) D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS {
return @intToEnum(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.NONE) else 0)
| (if (o.ALLOW_UPDATE == 1) @enumToInt(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.ALLOW_UPDATE) else 0)
| (if (o.ALLOW_COMPACTION == 1) @enumToInt(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.ALLOW_COMPACTION) else 0)
| (if (o.PREFER_FAST_TRACE == 1) @enumToInt(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.PREFER_FAST_TRACE) else 0)
| (if (o.PREFER_FAST_BUILD == 1) @enumToInt(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.PREFER_FAST_BUILD) else 0)
| (if (o.MINIMIZE_MEMORY == 1) @enumToInt(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.MINIMIZE_MEMORY) else 0)
| (if (o.PERFORM_UPDATE == 1) @enumToInt(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.PERFORM_UPDATE) else 0)
);
}
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.NONE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.ALLOW_UPDATE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.ALLOW_COMPACTION;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.PREFER_FAST_TRACE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.PREFER_FAST_BUILD;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.MINIMIZE_MEMORY;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.PERFORM_UPDATE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE = enum(i32) {
CLONE = 0,
COMPACT = 1,
VISUALIZATION_DECODE_FOR_TOOLS = 2,
SERIALIZE = 3,
DESERIALIZE = 4,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE.CLONE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE.COMPACT;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE.VISUALIZATION_DECODE_FOR_TOOLS;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE.SERIALIZE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE.DESERIALIZE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE = enum(i32) {
TOP_LEVEL = 0,
BOTTOM_LEVEL = 1,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE.TOP_LEVEL;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE.BOTTOM_LEVEL;
pub const D3D12_ELEMENTS_LAYOUT = enum(i32) {
Y = 0,
_OF_POINTERS = 1,
};
pub const D3D12_ELEMENTS_LAYOUT_ARRAY = D3D12_ELEMENTS_LAYOUT.Y;
pub const D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = D3D12_ELEMENTS_LAYOUT._OF_POINTERS;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE = enum(i32) {
COMPACTED_SIZE = 0,
TOOLS_VISUALIZATION = 1,
SERIALIZATION = 2,
CURRENT_SIZE = 3,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE.COMPACTED_SIZE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE.TOOLS_VISUALIZATION;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE.SERIALIZATION;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE.CURRENT_SIZE;
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC = extern struct {
DestBuffer: u64,
InfoType: D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC = extern struct {
CompactedSizeInBytes: u64,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC = extern struct {
DecodedSizeInBytes: u64,
};
pub const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER = extern struct {
Type: D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE,
NumDescs: u32,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC = extern struct {
SerializedSizeInBytes: u64,
NumBottomLevelAccelerationStructurePointers: u64,
};
pub const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER = extern struct {
DriverOpaqueGUID: Guid,
DriverOpaqueVersioningData: [16]u8,
};
pub const D3D12_SERIALIZED_DATA_TYPE = enum(i32) {
E = 0,
};
pub const D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = D3D12_SERIALIZED_DATA_TYPE.E;
pub const D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS = enum(i32) {
COMPATIBLE_WITH_DEVICE = 0,
UNSUPPORTED_TYPE = 1,
UNRECOGNIZED = 2,
INCOMPATIBLE_VERSION = 3,
INCOMPATIBLE_TYPE = 4,
};
pub const D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS.COMPATIBLE_WITH_DEVICE;
pub const D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS.UNSUPPORTED_TYPE;
pub const D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS.UNRECOGNIZED;
pub const D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS.INCOMPATIBLE_VERSION;
pub const D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS.INCOMPATIBLE_TYPE;
pub const D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER = extern struct {
DriverMatchingIdentifier: D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER,
SerializedSizeInBytesIncludingHeader: u64,
DeserializedSizeInBytes: u64,
NumBottomLevelAccelerationStructurePointersAfterHeader: u64,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC = extern struct {
CurrentSizeInBytes: u64,
};
pub const D3D12_RAYTRACING_INSTANCE_DESC = extern struct {
Transform: [12]f32,
_bitfield1: u32,
_bitfield2: u32,
AccelerationStructure: u64,
};
pub const D3D12_RAYTRACING_GEOMETRY_DESC = extern struct {
Type: D3D12_RAYTRACING_GEOMETRY_TYPE,
Flags: D3D12_RAYTRACING_GEOMETRY_FLAGS,
Anonymous: extern union {
Triangles: D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC,
AABBs: D3D12_RAYTRACING_GEOMETRY_AABBS_DESC,
},
};
pub const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS = extern struct {
Type: D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE,
Flags: D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS,
NumDescs: u32,
DescsLayout: D3D12_ELEMENTS_LAYOUT,
Anonymous: extern union {
InstanceDescs: u64,
pGeometryDescs: ?*const D3D12_RAYTRACING_GEOMETRY_DESC,
ppGeometryDescs: ?*const ?*D3D12_RAYTRACING_GEOMETRY_DESC,
},
};
pub const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC = extern struct {
DestAccelerationStructureData: u64,
Inputs: D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS,
SourceAccelerationStructureData: u64,
ScratchAccelerationStructureData: u64,
};
pub const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO = extern struct {
ResultDataMaxSizeInBytes: u64,
ScratchDataSizeInBytes: u64,
UpdateScratchDataSizeInBytes: u64,
};
pub const D3D12_RAY_FLAGS = enum(u32) {
NONE = 0,
FORCE_OPAQUE = 1,
FORCE_NON_OPAQUE = 2,
ACCEPT_FIRST_HIT_AND_END_SEARCH = 4,
SKIP_CLOSEST_HIT_SHADER = 8,
CULL_BACK_FACING_TRIANGLES = 16,
CULL_FRONT_FACING_TRIANGLES = 32,
CULL_OPAQUE = 64,
CULL_NON_OPAQUE = 128,
SKIP_TRIANGLES = 256,
SKIP_PROCEDURAL_PRIMITIVES = 512,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
FORCE_OPAQUE: u1 = 0,
FORCE_NON_OPAQUE: u1 = 0,
ACCEPT_FIRST_HIT_AND_END_SEARCH: u1 = 0,
SKIP_CLOSEST_HIT_SHADER: u1 = 0,
CULL_BACK_FACING_TRIANGLES: u1 = 0,
CULL_FRONT_FACING_TRIANGLES: u1 = 0,
CULL_OPAQUE: u1 = 0,
CULL_NON_OPAQUE: u1 = 0,
SKIP_TRIANGLES: u1 = 0,
SKIP_PROCEDURAL_PRIMITIVES: u1 = 0,
}) D3D12_RAY_FLAGS {
return @intToEnum(D3D12_RAY_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RAY_FLAGS.NONE) else 0)
| (if (o.FORCE_OPAQUE == 1) @enumToInt(D3D12_RAY_FLAGS.FORCE_OPAQUE) else 0)
| (if (o.FORCE_NON_OPAQUE == 1) @enumToInt(D3D12_RAY_FLAGS.FORCE_NON_OPAQUE) else 0)
| (if (o.ACCEPT_FIRST_HIT_AND_END_SEARCH == 1) @enumToInt(D3D12_RAY_FLAGS.ACCEPT_FIRST_HIT_AND_END_SEARCH) else 0)
| (if (o.SKIP_CLOSEST_HIT_SHADER == 1) @enumToInt(D3D12_RAY_FLAGS.SKIP_CLOSEST_HIT_SHADER) else 0)
| (if (o.CULL_BACK_FACING_TRIANGLES == 1) @enumToInt(D3D12_RAY_FLAGS.CULL_BACK_FACING_TRIANGLES) else 0)
| (if (o.CULL_FRONT_FACING_TRIANGLES == 1) @enumToInt(D3D12_RAY_FLAGS.CULL_FRONT_FACING_TRIANGLES) else 0)
| (if (o.CULL_OPAQUE == 1) @enumToInt(D3D12_RAY_FLAGS.CULL_OPAQUE) else 0)
| (if (o.CULL_NON_OPAQUE == 1) @enumToInt(D3D12_RAY_FLAGS.CULL_NON_OPAQUE) else 0)
| (if (o.SKIP_TRIANGLES == 1) @enumToInt(D3D12_RAY_FLAGS.SKIP_TRIANGLES) else 0)
| (if (o.SKIP_PROCEDURAL_PRIMITIVES == 1) @enumToInt(D3D12_RAY_FLAGS.SKIP_PROCEDURAL_PRIMITIVES) else 0)
);
}
};
pub const D3D12_RAY_FLAG_NONE = D3D12_RAY_FLAGS.NONE;
pub const D3D12_RAY_FLAG_FORCE_OPAQUE = D3D12_RAY_FLAGS.FORCE_OPAQUE;
pub const D3D12_RAY_FLAG_FORCE_NON_OPAQUE = D3D12_RAY_FLAGS.FORCE_NON_OPAQUE;
pub const D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = D3D12_RAY_FLAGS.ACCEPT_FIRST_HIT_AND_END_SEARCH;
pub const D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = D3D12_RAY_FLAGS.SKIP_CLOSEST_HIT_SHADER;
pub const D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = D3D12_RAY_FLAGS.CULL_BACK_FACING_TRIANGLES;
pub const D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = D3D12_RAY_FLAGS.CULL_FRONT_FACING_TRIANGLES;
pub const D3D12_RAY_FLAG_CULL_OPAQUE = D3D12_RAY_FLAGS.CULL_OPAQUE;
pub const D3D12_RAY_FLAG_CULL_NON_OPAQUE = D3D12_RAY_FLAGS.CULL_NON_OPAQUE;
pub const D3D12_RAY_FLAG_SKIP_TRIANGLES = D3D12_RAY_FLAGS.SKIP_TRIANGLES;
pub const D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = D3D12_RAY_FLAGS.SKIP_PROCEDURAL_PRIMITIVES;
pub const D3D12_HIT_KIND = enum(i32) {
FRONT_FACE = 254,
BACK_FACE = 255,
};
pub const D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = D3D12_HIT_KIND.FRONT_FACE;
pub const D3D12_HIT_KIND_TRIANGLE_BACK_FACE = D3D12_HIT_KIND.BACK_FACE;
// TODO: this type is limited to platform 'windows10.0.17763'
const IID_ID3D12Device5_Value = Guid.initString("8b4f173b-2fea-4b80-8f58-4307191ab95d");
pub const IID_ID3D12Device5 = &IID_ID3D12Device5_Value;
pub const ID3D12Device5 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device4.VTable,
CreateLifetimeTracker: fn(
self: *const ID3D12Device5,
pOwner: ?*ID3D12LifetimeOwner,
riid: ?*const Guid,
ppvTracker: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveDevice: fn(
self: *const ID3D12Device5,
) callconv(@import("std").os.windows.WINAPI) void,
EnumerateMetaCommands: fn(
self: *const ID3D12Device5,
pNumMetaCommands: ?*u32,
pDescs: ?[*]D3D12_META_COMMAND_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumerateMetaCommandParameters: fn(
self: *const ID3D12Device5,
CommandId: ?*const Guid,
Stage: D3D12_META_COMMAND_PARAMETER_STAGE,
pTotalStructureSizeInBytes: ?*u32,
pParameterCount: ?*u32,
pParameterDescs: ?[*]D3D12_META_COMMAND_PARAMETER_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateMetaCommand: fn(
self: *const ID3D12Device5,
CommandId: ?*const Guid,
NodeMask: u32,
// TODO: what to do with BytesParamIndex 3?
pCreationParametersData: ?*const anyopaque,
CreationParametersDataSizeInBytes: usize,
riid: ?*const Guid,
ppMetaCommand: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStateObject: fn(
self: *const ID3D12Device5,
pDesc: ?*const D3D12_STATE_OBJECT_DESC,
riid: ?*const Guid,
ppStateObject: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRaytracingAccelerationStructurePrebuildInfo: fn(
self: *const ID3D12Device5,
pDesc: ?*const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS,
pInfo: ?*D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO,
) callconv(@import("std").os.windows.WINAPI) void,
CheckDriverMatchingIdentifier: fn(
self: *const ID3D12Device5,
SerializedDataType: D3D12_SERIALIZED_DATA_TYPE,
pIdentifierToCheck: ?*const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER,
) callconv(@import("std").os.windows.WINAPI) D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device4.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device5_CreateLifetimeTracker(self: *const T, pOwner: ?*ID3D12LifetimeOwner, riid: ?*const Guid, ppvTracker: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device5.VTable, self.vtable).CreateLifetimeTracker(@ptrCast(*const ID3D12Device5, self), pOwner, riid, ppvTracker);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device5_RemoveDevice(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device5.VTable, self.vtable).RemoveDevice(@ptrCast(*const ID3D12Device5, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device5_EnumerateMetaCommands(self: *const T, pNumMetaCommands: ?*u32, pDescs: ?[*]D3D12_META_COMMAND_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device5.VTable, self.vtable).EnumerateMetaCommands(@ptrCast(*const ID3D12Device5, self), pNumMetaCommands, pDescs);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device5_EnumerateMetaCommandParameters(self: *const T, CommandId: ?*const Guid, Stage: D3D12_META_COMMAND_PARAMETER_STAGE, pTotalStructureSizeInBytes: ?*u32, pParameterCount: ?*u32, pParameterDescs: ?[*]D3D12_META_COMMAND_PARAMETER_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device5.VTable, self.vtable).EnumerateMetaCommandParameters(@ptrCast(*const ID3D12Device5, self), CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device5_CreateMetaCommand(self: *const T, CommandId: ?*const Guid, NodeMask: u32, pCreationParametersData: ?*const anyopaque, CreationParametersDataSizeInBytes: usize, riid: ?*const Guid, ppMetaCommand: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device5.VTable, self.vtable).CreateMetaCommand(@ptrCast(*const ID3D12Device5, self), CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device5_CreateStateObject(self: *const T, pDesc: ?*const D3D12_STATE_OBJECT_DESC, riid: ?*const Guid, ppStateObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device5.VTable, self.vtable).CreateStateObject(@ptrCast(*const ID3D12Device5, self), pDesc, riid, ppStateObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device5_GetRaytracingAccelerationStructurePrebuildInfo(self: *const T, pDesc: ?*const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS, pInfo: ?*D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device5.VTable, self.vtable).GetRaytracingAccelerationStructurePrebuildInfo(@ptrCast(*const ID3D12Device5, self), pDesc, pInfo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device5_CheckDriverMatchingIdentifier(self: *const T, SerializedDataType: D3D12_SERIALIZED_DATA_TYPE, pIdentifierToCheck: ?*const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER) callconv(.Inline) D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS {
return @ptrCast(*const ID3D12Device5.VTable, self.vtable).CheckDriverMatchingIdentifier(@ptrCast(*const ID3D12Device5, self), SerializedDataType, pIdentifierToCheck);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_AUTO_BREADCRUMB_OP = enum(i32) {
SETMARKER = 0,
BEGINEVENT = 1,
ENDEVENT = 2,
DRAWINSTANCED = 3,
DRAWINDEXEDINSTANCED = 4,
EXECUTEINDIRECT = 5,
DISPATCH = 6,
COPYBUFFERREGION = 7,
COPYTEXTUREREGION = 8,
COPYRESOURCE = 9,
COPYTILES = 10,
RESOLVESUBRESOURCE = 11,
CLEARRENDERTARGETVIEW = 12,
CLEARUNORDEREDACCESSVIEW = 13,
CLEARDEPTHSTENCILVIEW = 14,
RESOURCEBARRIER = 15,
EXECUTEBUNDLE = 16,
PRESENT = 17,
RESOLVEQUERYDATA = 18,
BEGINSUBMISSION = 19,
ENDSUBMISSION = 20,
DECODEFRAME = 21,
PROCESSFRAMES = 22,
ATOMICCOPYBUFFERUINT = 23,
ATOMICCOPYBUFFERUINT64 = 24,
RESOLVESUBRESOURCEREGION = 25,
WRITEBUFFERIMMEDIATE = 26,
DECODEFRAME1 = 27,
SETPROTECTEDRESOURCESESSION = 28,
DECODEFRAME2 = 29,
PROCESSFRAMES1 = 30,
BUILDRAYTRACINGACCELERATIONSTRUCTURE = 31,
EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 32,
COPYRAYTRACINGACCELERATIONSTRUCTURE = 33,
DISPATCHRAYS = 34,
INITIALIZEMETACOMMAND = 35,
EXECUTEMETACOMMAND = 36,
ESTIMATEMOTION = 37,
RESOLVEMOTIONVECTORHEAP = 38,
SETPIPELINESTATE1 = 39,
INITIALIZEEXTENSIONCOMMAND = 40,
EXECUTEEXTENSIONCOMMAND = 41,
DISPATCHMESH = 42,
ENCODEFRAME = 43,
RESOLVEENCODEROUTPUTMETADATA = 44,
};
pub const D3D12_AUTO_BREADCRUMB_OP_SETMARKER = D3D12_AUTO_BREADCRUMB_OP.SETMARKER;
pub const D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = D3D12_AUTO_BREADCRUMB_OP.BEGINEVENT;
pub const D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = D3D12_AUTO_BREADCRUMB_OP.ENDEVENT;
pub const D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = D3D12_AUTO_BREADCRUMB_OP.DRAWINSTANCED;
pub const D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = D3D12_AUTO_BREADCRUMB_OP.DRAWINDEXEDINSTANCED;
pub const D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = D3D12_AUTO_BREADCRUMB_OP.EXECUTEINDIRECT;
pub const D3D12_AUTO_BREADCRUMB_OP_DISPATCH = D3D12_AUTO_BREADCRUMB_OP.DISPATCH;
pub const D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = D3D12_AUTO_BREADCRUMB_OP.COPYBUFFERREGION;
pub const D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = D3D12_AUTO_BREADCRUMB_OP.COPYTEXTUREREGION;
pub const D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = D3D12_AUTO_BREADCRUMB_OP.COPYRESOURCE;
pub const D3D12_AUTO_BREADCRUMB_OP_COPYTILES = D3D12_AUTO_BREADCRUMB_OP.COPYTILES;
pub const D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = D3D12_AUTO_BREADCRUMB_OP.RESOLVESUBRESOURCE;
pub const D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = D3D12_AUTO_BREADCRUMB_OP.CLEARRENDERTARGETVIEW;
pub const D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = D3D12_AUTO_BREADCRUMB_OP.CLEARUNORDEREDACCESSVIEW;
pub const D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = D3D12_AUTO_BREADCRUMB_OP.CLEARDEPTHSTENCILVIEW;
pub const D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = D3D12_AUTO_BREADCRUMB_OP.RESOURCEBARRIER;
pub const D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = D3D12_AUTO_BREADCRUMB_OP.EXECUTEBUNDLE;
pub const D3D12_AUTO_BREADCRUMB_OP_PRESENT = D3D12_AUTO_BREADCRUMB_OP.PRESENT;
pub const D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = D3D12_AUTO_BREADCRUMB_OP.RESOLVEQUERYDATA;
pub const D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = D3D12_AUTO_BREADCRUMB_OP.BEGINSUBMISSION;
pub const D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = D3D12_AUTO_BREADCRUMB_OP.ENDSUBMISSION;
pub const D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = D3D12_AUTO_BREADCRUMB_OP.DECODEFRAME;
pub const D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = D3D12_AUTO_BREADCRUMB_OP.PROCESSFRAMES;
pub const D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = D3D12_AUTO_BREADCRUMB_OP.ATOMICCOPYBUFFERUINT;
pub const D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = D3D12_AUTO_BREADCRUMB_OP.ATOMICCOPYBUFFERUINT64;
pub const D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = D3D12_AUTO_BREADCRUMB_OP.RESOLVESUBRESOURCEREGION;
pub const D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = D3D12_AUTO_BREADCRUMB_OP.WRITEBUFFERIMMEDIATE;
pub const D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = D3D12_AUTO_BREADCRUMB_OP.DECODEFRAME1;
pub const D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = D3D12_AUTO_BREADCRUMB_OP.SETPROTECTEDRESOURCESESSION;
pub const D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = D3D12_AUTO_BREADCRUMB_OP.DECODEFRAME2;
pub const D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = D3D12_AUTO_BREADCRUMB_OP.PROCESSFRAMES1;
pub const D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = D3D12_AUTO_BREADCRUMB_OP.BUILDRAYTRACINGACCELERATIONSTRUCTURE;
pub const D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = D3D12_AUTO_BREADCRUMB_OP.EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO;
pub const D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = D3D12_AUTO_BREADCRUMB_OP.COPYRAYTRACINGACCELERATIONSTRUCTURE;
pub const D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = D3D12_AUTO_BREADCRUMB_OP.DISPATCHRAYS;
pub const D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = D3D12_AUTO_BREADCRUMB_OP.INITIALIZEMETACOMMAND;
pub const D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = D3D12_AUTO_BREADCRUMB_OP.EXECUTEMETACOMMAND;
pub const D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = D3D12_AUTO_BREADCRUMB_OP.ESTIMATEMOTION;
pub const D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = D3D12_AUTO_BREADCRUMB_OP.RESOLVEMOTIONVECTORHEAP;
pub const D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = D3D12_AUTO_BREADCRUMB_OP.SETPIPELINESTATE1;
pub const D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = D3D12_AUTO_BREADCRUMB_OP.INITIALIZEEXTENSIONCOMMAND;
pub const D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = D3D12_AUTO_BREADCRUMB_OP.EXECUTEEXTENSIONCOMMAND;
pub const D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH = D3D12_AUTO_BREADCRUMB_OP.DISPATCHMESH;
pub const D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME = D3D12_AUTO_BREADCRUMB_OP.ENCODEFRAME;
pub const D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA = D3D12_AUTO_BREADCRUMB_OP.RESOLVEENCODEROUTPUTMETADATA;
pub const D3D12_AUTO_BREADCRUMB_NODE = extern struct {
pCommandListDebugNameA: ?*const u8,
pCommandListDebugNameW: ?[*:0]const u16,
pCommandQueueDebugNameA: ?*const u8,
pCommandQueueDebugNameW: ?[*:0]const u16,
pCommandList: ?*ID3D12GraphicsCommandList,
pCommandQueue: ?*ID3D12CommandQueue,
BreadcrumbCount: u32,
pLastBreadcrumbValue: ?*const u32,
pCommandHistory: ?*const D3D12_AUTO_BREADCRUMB_OP,
pNext: ?*const D3D12_AUTO_BREADCRUMB_NODE,
};
pub const D3D12_DRED_BREADCRUMB_CONTEXT = extern struct {
BreadcrumbIndex: u32,
pContextString: ?[*:0]const u16,
};
pub const D3D12_AUTO_BREADCRUMB_NODE1 = extern struct {
pCommandListDebugNameA: ?*const u8,
pCommandListDebugNameW: ?[*:0]const u16,
pCommandQueueDebugNameA: ?*const u8,
pCommandQueueDebugNameW: ?[*:0]const u16,
pCommandList: ?*ID3D12GraphicsCommandList,
pCommandQueue: ?*ID3D12CommandQueue,
BreadcrumbCount: u32,
pLastBreadcrumbValue: ?*const u32,
pCommandHistory: ?*const D3D12_AUTO_BREADCRUMB_OP,
pNext: ?*const D3D12_AUTO_BREADCRUMB_NODE1,
BreadcrumbContextsCount: u32,
pBreadcrumbContexts: ?*D3D12_DRED_BREADCRUMB_CONTEXT,
};
pub const D3D12_DRED_VERSION = enum(i32) {
@"0" = 1,
@"1" = 2,
@"2" = 3,
@"3" = 4,
};
pub const D3D12_DRED_VERSION_1_0 = D3D12_DRED_VERSION.@"0";
pub const D3D12_DRED_VERSION_1_1 = D3D12_DRED_VERSION.@"1";
pub const D3D12_DRED_VERSION_1_2 = D3D12_DRED_VERSION.@"2";
pub const D3D12_DRED_VERSION_1_3 = D3D12_DRED_VERSION.@"3";
pub const D3D12_DRED_FLAGS = enum(u32) {
NONE = 0,
FORCE_ENABLE = 1,
DISABLE_AUTOBREADCRUMBS = 2,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
FORCE_ENABLE: u1 = 0,
DISABLE_AUTOBREADCRUMBS: u1 = 0,
}) D3D12_DRED_FLAGS {
return @intToEnum(D3D12_DRED_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_DRED_FLAGS.NONE) else 0)
| (if (o.FORCE_ENABLE == 1) @enumToInt(D3D12_DRED_FLAGS.FORCE_ENABLE) else 0)
| (if (o.DISABLE_AUTOBREADCRUMBS == 1) @enumToInt(D3D12_DRED_FLAGS.DISABLE_AUTOBREADCRUMBS) else 0)
);
}
};
pub const D3D12_DRED_FLAG_NONE = D3D12_DRED_FLAGS.NONE;
pub const D3D12_DRED_FLAG_FORCE_ENABLE = D3D12_DRED_FLAGS.FORCE_ENABLE;
pub const D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = D3D12_DRED_FLAGS.DISABLE_AUTOBREADCRUMBS;
pub const D3D12_DRED_ENABLEMENT = enum(i32) {
SYSTEM_CONTROLLED = 0,
FORCED_OFF = 1,
FORCED_ON = 2,
};
pub const D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = D3D12_DRED_ENABLEMENT.SYSTEM_CONTROLLED;
pub const D3D12_DRED_ENABLEMENT_FORCED_OFF = D3D12_DRED_ENABLEMENT.FORCED_OFF;
pub const D3D12_DRED_ENABLEMENT_FORCED_ON = D3D12_DRED_ENABLEMENT.FORCED_ON;
pub const D3D12_DEVICE_REMOVED_EXTENDED_DATA = extern struct {
Flags: D3D12_DRED_FLAGS,
pHeadAutoBreadcrumbNode: ?*D3D12_AUTO_BREADCRUMB_NODE,
};
pub const D3D12_DRED_ALLOCATION_TYPE = enum(i32) {
COMMAND_QUEUE = 19,
COMMAND_ALLOCATOR = 20,
PIPELINE_STATE = 21,
COMMAND_LIST = 22,
FENCE = 23,
DESCRIPTOR_HEAP = 24,
HEAP = 25,
QUERY_HEAP = 27,
COMMAND_SIGNATURE = 28,
PIPELINE_LIBRARY = 29,
VIDEO_DECODER = 30,
VIDEO_PROCESSOR = 32,
RESOURCE = 34,
PASS = 35,
CRYPTOSESSION = 36,
CRYPTOSESSIONPOLICY = 37,
PROTECTEDRESOURCESESSION = 38,
VIDEO_DECODER_HEAP = 39,
COMMAND_POOL = 40,
COMMAND_RECORDER = 41,
STATE_OBJECT = 42,
METACOMMAND = 43,
SCHEDULINGGROUP = 44,
VIDEO_MOTION_ESTIMATOR = 45,
VIDEO_MOTION_VECTOR_HEAP = 46,
VIDEO_EXTENSION_COMMAND = 47,
VIDEO_ENCODER = 48,
VIDEO_ENCODER_HEAP = 49,
INVALID = -1,
};
pub const D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = D3D12_DRED_ALLOCATION_TYPE.COMMAND_QUEUE;
pub const D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = D3D12_DRED_ALLOCATION_TYPE.COMMAND_ALLOCATOR;
pub const D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = D3D12_DRED_ALLOCATION_TYPE.PIPELINE_STATE;
pub const D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = D3D12_DRED_ALLOCATION_TYPE.COMMAND_LIST;
pub const D3D12_DRED_ALLOCATION_TYPE_FENCE = D3D12_DRED_ALLOCATION_TYPE.FENCE;
pub const D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = D3D12_DRED_ALLOCATION_TYPE.DESCRIPTOR_HEAP;
pub const D3D12_DRED_ALLOCATION_TYPE_HEAP = D3D12_DRED_ALLOCATION_TYPE.HEAP;
pub const D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = D3D12_DRED_ALLOCATION_TYPE.QUERY_HEAP;
pub const D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = D3D12_DRED_ALLOCATION_TYPE.COMMAND_SIGNATURE;
pub const D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = D3D12_DRED_ALLOCATION_TYPE.PIPELINE_LIBRARY;
pub const D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = D3D12_DRED_ALLOCATION_TYPE.VIDEO_DECODER;
pub const D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = D3D12_DRED_ALLOCATION_TYPE.VIDEO_PROCESSOR;
pub const D3D12_DRED_ALLOCATION_TYPE_RESOURCE = D3D12_DRED_ALLOCATION_TYPE.RESOURCE;
pub const D3D12_DRED_ALLOCATION_TYPE_PASS = D3D12_DRED_ALLOCATION_TYPE.PASS;
pub const D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = D3D12_DRED_ALLOCATION_TYPE.CRYPTOSESSION;
pub const D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = D3D12_DRED_ALLOCATION_TYPE.CRYPTOSESSIONPOLICY;
pub const D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = D3D12_DRED_ALLOCATION_TYPE.PROTECTEDRESOURCESESSION;
pub const D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = D3D12_DRED_ALLOCATION_TYPE.VIDEO_DECODER_HEAP;
pub const D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = D3D12_DRED_ALLOCATION_TYPE.COMMAND_POOL;
pub const D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = D3D12_DRED_ALLOCATION_TYPE.COMMAND_RECORDER;
pub const D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = D3D12_DRED_ALLOCATION_TYPE.STATE_OBJECT;
pub const D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = D3D12_DRED_ALLOCATION_TYPE.METACOMMAND;
pub const D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = D3D12_DRED_ALLOCATION_TYPE.SCHEDULINGGROUP;
pub const D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = D3D12_DRED_ALLOCATION_TYPE.VIDEO_MOTION_ESTIMATOR;
pub const D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = D3D12_DRED_ALLOCATION_TYPE.VIDEO_MOTION_VECTOR_HEAP;
pub const D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = D3D12_DRED_ALLOCATION_TYPE.VIDEO_EXTENSION_COMMAND;
pub const D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER = D3D12_DRED_ALLOCATION_TYPE.VIDEO_ENCODER;
pub const D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP = D3D12_DRED_ALLOCATION_TYPE.VIDEO_ENCODER_HEAP;
pub const D3D12_DRED_ALLOCATION_TYPE_INVALID = D3D12_DRED_ALLOCATION_TYPE.INVALID;
pub const D3D12_DRED_ALLOCATION_NODE = extern struct {
ObjectNameA: ?*const u8,
ObjectNameW: ?[*:0]const u16,
AllocationType: D3D12_DRED_ALLOCATION_TYPE,
pNext: ?*const D3D12_DRED_ALLOCATION_NODE,
};
pub const D3D12_DRED_ALLOCATION_NODE1 = extern struct {
ObjectNameA: ?*const u8,
ObjectNameW: ?[*:0]const u16,
AllocationType: D3D12_DRED_ALLOCATION_TYPE,
pNext: ?*const D3D12_DRED_ALLOCATION_NODE1,
pObject: ?*IUnknown,
};
pub const D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT = extern struct {
pHeadAutoBreadcrumbNode: ?*const D3D12_AUTO_BREADCRUMB_NODE,
};
pub const D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 = extern struct {
pHeadAutoBreadcrumbNode: ?*const D3D12_AUTO_BREADCRUMB_NODE1,
};
pub const D3D12_DRED_PAGE_FAULT_OUTPUT = extern struct {
PageFaultVA: u64,
pHeadExistingAllocationNode: ?*const D3D12_DRED_ALLOCATION_NODE,
pHeadRecentFreedAllocationNode: ?*const D3D12_DRED_ALLOCATION_NODE,
};
pub const D3D12_DRED_PAGE_FAULT_OUTPUT1 = extern struct {
PageFaultVA: u64,
pHeadExistingAllocationNode: ?*const D3D12_DRED_ALLOCATION_NODE1,
pHeadRecentFreedAllocationNode: ?*const D3D12_DRED_ALLOCATION_NODE1,
};
pub const D3D12_DRED_PAGE_FAULT_FLAGS = enum(u32) {
E = 0,
_,
pub fn initFlags(o: struct {
E: u1 = 0,
}) D3D12_DRED_PAGE_FAULT_FLAGS {
return @intToEnum(D3D12_DRED_PAGE_FAULT_FLAGS,
(if (o.E == 1) @enumToInt(D3D12_DRED_PAGE_FAULT_FLAGS.E) else 0)
);
}
};
pub const D3D12_DRED_PAGE_FAULT_FLAGS_NONE = D3D12_DRED_PAGE_FAULT_FLAGS.E;
pub const D3D12_DRED_DEVICE_STATE = enum(i32) {
UNKNOWN = 0,
HUNG = 3,
FAULT = 6,
PAGEFAULT = 7,
};
pub const D3D12_DRED_DEVICE_STATE_UNKNOWN = D3D12_DRED_DEVICE_STATE.UNKNOWN;
pub const D3D12_DRED_DEVICE_STATE_HUNG = D3D12_DRED_DEVICE_STATE.HUNG;
pub const D3D12_DRED_DEVICE_STATE_FAULT = D3D12_DRED_DEVICE_STATE.FAULT;
pub const D3D12_DRED_DEVICE_STATE_PAGEFAULT = D3D12_DRED_DEVICE_STATE.PAGEFAULT;
pub const D3D12_DRED_PAGE_FAULT_OUTPUT2 = extern struct {
PageFaultVA: u64,
pHeadExistingAllocationNode: ?*const D3D12_DRED_ALLOCATION_NODE1,
pHeadRecentFreedAllocationNode: ?*const D3D12_DRED_ALLOCATION_NODE1,
PageFaultFlags: D3D12_DRED_PAGE_FAULT_FLAGS,
};
pub const D3D12_DEVICE_REMOVED_EXTENDED_DATA1 = extern struct {
DeviceRemovedReason: HRESULT,
AutoBreadcrumbsOutput: D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT,
PageFaultOutput: D3D12_DRED_PAGE_FAULT_OUTPUT,
};
pub const D3D12_DEVICE_REMOVED_EXTENDED_DATA2 = extern struct {
DeviceRemovedReason: HRESULT,
AutoBreadcrumbsOutput: D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1,
PageFaultOutput: D3D12_DRED_PAGE_FAULT_OUTPUT1,
};
pub const D3D12_DEVICE_REMOVED_EXTENDED_DATA3 = extern struct {
DeviceRemovedReason: HRESULT,
AutoBreadcrumbsOutput: D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1,
PageFaultOutput: D3D12_DRED_PAGE_FAULT_OUTPUT2,
DeviceState: D3D12_DRED_DEVICE_STATE,
};
pub const D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA = extern struct {
Version: D3D12_DRED_VERSION,
Anonymous: extern union {
Dred_1_0: D3D12_DEVICE_REMOVED_EXTENDED_DATA,
Dred_1_1: D3D12_DEVICE_REMOVED_EXTENDED_DATA1,
Dred_1_2: D3D12_DEVICE_REMOVED_EXTENDED_DATA2,
Dred_1_3: D3D12_DEVICE_REMOVED_EXTENDED_DATA3,
},
};
const IID_ID3D12DeviceRemovedExtendedDataSettings_Value = Guid.initString("82bc481c-6b9b-4030-aedb-7ee3d1df1e63");
pub const IID_ID3D12DeviceRemovedExtendedDataSettings = &IID_ID3D12DeviceRemovedExtendedDataSettings_Value;
pub const ID3D12DeviceRemovedExtendedDataSettings = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetAutoBreadcrumbsEnablement: fn(
self: *const ID3D12DeviceRemovedExtendedDataSettings,
Enablement: D3D12_DRED_ENABLEMENT,
) callconv(@import("std").os.windows.WINAPI) void,
SetPageFaultEnablement: fn(
self: *const ID3D12DeviceRemovedExtendedDataSettings,
Enablement: D3D12_DRED_ENABLEMENT,
) callconv(@import("std").os.windows.WINAPI) void,
SetWatsonDumpEnablement: fn(
self: *const ID3D12DeviceRemovedExtendedDataSettings,
Enablement: D3D12_DRED_ENABLEMENT,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedDataSettings_SetAutoBreadcrumbsEnablement(self: *const T, Enablement: D3D12_DRED_ENABLEMENT) callconv(.Inline) void {
return @ptrCast(*const ID3D12DeviceRemovedExtendedDataSettings.VTable, self.vtable).SetAutoBreadcrumbsEnablement(@ptrCast(*const ID3D12DeviceRemovedExtendedDataSettings, self), Enablement);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedDataSettings_SetPageFaultEnablement(self: *const T, Enablement: D3D12_DRED_ENABLEMENT) callconv(.Inline) void {
return @ptrCast(*const ID3D12DeviceRemovedExtendedDataSettings.VTable, self.vtable).SetPageFaultEnablement(@ptrCast(*const ID3D12DeviceRemovedExtendedDataSettings, self), Enablement);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedDataSettings_SetWatsonDumpEnablement(self: *const T, Enablement: D3D12_DRED_ENABLEMENT) callconv(.Inline) void {
return @ptrCast(*const ID3D12DeviceRemovedExtendedDataSettings.VTable, self.vtable).SetWatsonDumpEnablement(@ptrCast(*const ID3D12DeviceRemovedExtendedDataSettings, self), Enablement);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DeviceRemovedExtendedDataSettings1_Value = Guid.initString("dbd5ae51-3317-4f0a-adf9-1d7cedcaae0b");
pub const IID_ID3D12DeviceRemovedExtendedDataSettings1 = &IID_ID3D12DeviceRemovedExtendedDataSettings1_Value;
pub const ID3D12DeviceRemovedExtendedDataSettings1 = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceRemovedExtendedDataSettings.VTable,
SetBreadcrumbContextEnablement: fn(
self: *const ID3D12DeviceRemovedExtendedDataSettings1,
Enablement: D3D12_DRED_ENABLEMENT,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceRemovedExtendedDataSettings.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedDataSettings1_SetBreadcrumbContextEnablement(self: *const T, Enablement: D3D12_DRED_ENABLEMENT) callconv(.Inline) void {
return @ptrCast(*const ID3D12DeviceRemovedExtendedDataSettings1.VTable, self.vtable).SetBreadcrumbContextEnablement(@ptrCast(*const ID3D12DeviceRemovedExtendedDataSettings1, self), Enablement);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DeviceRemovedExtendedData_Value = Guid.initString("98931d33-5ae8-4791-aa3c-1a73a2934e71");
pub const IID_ID3D12DeviceRemovedExtendedData = &IID_ID3D12DeviceRemovedExtendedData_Value;
pub const ID3D12DeviceRemovedExtendedData = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetAutoBreadcrumbsOutput: fn(
self: *const ID3D12DeviceRemovedExtendedData,
pOutput: ?*D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPageFaultAllocationOutput: fn(
self: *const ID3D12DeviceRemovedExtendedData,
pOutput: ?*D3D12_DRED_PAGE_FAULT_OUTPUT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedData_GetAutoBreadcrumbsOutput(self: *const T, pOutput: ?*D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DeviceRemovedExtendedData.VTable, self.vtable).GetAutoBreadcrumbsOutput(@ptrCast(*const ID3D12DeviceRemovedExtendedData, self), pOutput);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedData_GetPageFaultAllocationOutput(self: *const T, pOutput: ?*D3D12_DRED_PAGE_FAULT_OUTPUT) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DeviceRemovedExtendedData.VTable, self.vtable).GetPageFaultAllocationOutput(@ptrCast(*const ID3D12DeviceRemovedExtendedData, self), pOutput);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DeviceRemovedExtendedData1_Value = Guid.initString("9727a022-cf1d-4dda-9eba-effa653fc506");
pub const IID_ID3D12DeviceRemovedExtendedData1 = &IID_ID3D12DeviceRemovedExtendedData1_Value;
pub const ID3D12DeviceRemovedExtendedData1 = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceRemovedExtendedData.VTable,
GetAutoBreadcrumbsOutput1: fn(
self: *const ID3D12DeviceRemovedExtendedData1,
pOutput: ?*D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPageFaultAllocationOutput1: fn(
self: *const ID3D12DeviceRemovedExtendedData1,
pOutput: ?*D3D12_DRED_PAGE_FAULT_OUTPUT1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceRemovedExtendedData.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedData1_GetAutoBreadcrumbsOutput1(self: *const T, pOutput: ?*D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DeviceRemovedExtendedData1.VTable, self.vtable).GetAutoBreadcrumbsOutput1(@ptrCast(*const ID3D12DeviceRemovedExtendedData1, self), pOutput);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedData1_GetPageFaultAllocationOutput1(self: *const T, pOutput: ?*D3D12_DRED_PAGE_FAULT_OUTPUT1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DeviceRemovedExtendedData1.VTable, self.vtable).GetPageFaultAllocationOutput1(@ptrCast(*const ID3D12DeviceRemovedExtendedData1, self), pOutput);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DeviceRemovedExtendedData2_Value = Guid.initString("67fc5816-e4ca-4915-bf18-42541272da54");
pub const IID_ID3D12DeviceRemovedExtendedData2 = &IID_ID3D12DeviceRemovedExtendedData2_Value;
pub const ID3D12DeviceRemovedExtendedData2 = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceRemovedExtendedData1.VTable,
GetPageFaultAllocationOutput2: fn(
self: *const ID3D12DeviceRemovedExtendedData2,
pOutput: ?*D3D12_DRED_PAGE_FAULT_OUTPUT2,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDeviceState: fn(
self: *const ID3D12DeviceRemovedExtendedData2,
) callconv(@import("std").os.windows.WINAPI) D3D12_DRED_DEVICE_STATE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceRemovedExtendedData1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput2(self: *const T, pOutput: ?*D3D12_DRED_PAGE_FAULT_OUTPUT2) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DeviceRemovedExtendedData2.VTable, self.vtable).GetPageFaultAllocationOutput2(@ptrCast(*const ID3D12DeviceRemovedExtendedData2, self), pOutput);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DeviceRemovedExtendedData2_GetDeviceState(self: *const T) callconv(.Inline) D3D12_DRED_DEVICE_STATE {
return @ptrCast(*const ID3D12DeviceRemovedExtendedData2.VTable, self.vtable).GetDeviceState(@ptrCast(*const ID3D12DeviceRemovedExtendedData2, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_BACKGROUND_PROCESSING_MODE = enum(i32) {
ALLOWED = 0,
ALLOW_INTRUSIVE_MEASUREMENTS = 1,
DISABLE_BACKGROUND_WORK = 2,
DISABLE_PROFILING_BY_SYSTEM = 3,
};
pub const D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = D3D12_BACKGROUND_PROCESSING_MODE.ALLOWED;
pub const D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = D3D12_BACKGROUND_PROCESSING_MODE.ALLOW_INTRUSIVE_MEASUREMENTS;
pub const D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = D3D12_BACKGROUND_PROCESSING_MODE.DISABLE_BACKGROUND_WORK;
pub const D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = D3D12_BACKGROUND_PROCESSING_MODE.DISABLE_PROFILING_BY_SYSTEM;
pub const D3D12_MEASUREMENTS_ACTION = enum(i32) {
KEEP_ALL = 0,
COMMIT_RESULTS = 1,
COMMIT_RESULTS_HIGH_PRIORITY = 2,
DISCARD_PREVIOUS = 3,
};
pub const D3D12_MEASUREMENTS_ACTION_KEEP_ALL = D3D12_MEASUREMENTS_ACTION.KEEP_ALL;
pub const D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = D3D12_MEASUREMENTS_ACTION.COMMIT_RESULTS;
pub const D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = D3D12_MEASUREMENTS_ACTION.COMMIT_RESULTS_HIGH_PRIORITY;
pub const D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = D3D12_MEASUREMENTS_ACTION.DISCARD_PREVIOUS;
const IID_ID3D12Device6_Value = Guid.initString("c70b221b-40e4-4a17-89af-025a0727a6dc");
pub const IID_ID3D12Device6 = &IID_ID3D12Device6_Value;
pub const ID3D12Device6 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device5.VTable,
SetBackgroundProcessingMode: fn(
self: *const ID3D12Device6,
Mode: D3D12_BACKGROUND_PROCESSING_MODE,
MeasurementsAction: D3D12_MEASUREMENTS_ACTION,
hEventToSignalUponCompletion: ?HANDLE,
pbFurtherMeasurementsDesired: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device5.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device6_SetBackgroundProcessingMode(self: *const T, Mode: D3D12_BACKGROUND_PROCESSING_MODE, MeasurementsAction: D3D12_MEASUREMENTS_ACTION, hEventToSignalUponCompletion: ?HANDLE, pbFurtherMeasurementsDesired: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device6.VTable, self.vtable).SetBackgroundProcessingMode(@ptrCast(*const ID3D12Device6, self), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT = extern struct {
NodeIndex: u32,
Count: u32,
};
pub const D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES = extern struct {
NodeIndex: u32,
Count: u32,
pTypes: ?*Guid,
};
pub const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 = extern struct {
NodeMask: u32,
Flags: D3D12_PROTECTED_RESOURCE_SESSION_FLAGS,
ProtectionType: Guid,
};
const IID_ID3D12ProtectedResourceSession1_Value = Guid.initString("d6f12dd6-76fb-406e-8961-4296eefc0409");
pub const IID_ID3D12ProtectedResourceSession1 = &IID_ID3D12ProtectedResourceSession1_Value;
pub const ID3D12ProtectedResourceSession1 = extern struct {
pub const VTable = extern struct {
base: ID3D12ProtectedResourceSession.VTable,
GetDesc1: fn(
self: *const ID3D12ProtectedResourceSession1,
) callconv(@import("std").os.windows.WINAPI) D3D12_PROTECTED_RESOURCE_SESSION_DESC1,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12ProtectedResourceSession.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ProtectedResourceSession1_GetDesc1(self: *const T) callconv(.Inline) D3D12_PROTECTED_RESOURCE_SESSION_DESC1 {
return @ptrCast(*const ID3D12ProtectedResourceSession1.VTable, self.vtable).GetDesc1(@ptrCast(*const ID3D12ProtectedResourceSession1, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Device7_Value = Guid.initString("5c014b53-68a1-4b9b-8bd1-dd6046b9358b");
pub const IID_ID3D12Device7 = &IID_ID3D12Device7_Value;
pub const ID3D12Device7 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device6.VTable,
AddToStateObject: fn(
self: *const ID3D12Device7,
pAddition: ?*const D3D12_STATE_OBJECT_DESC,
pStateObjectToGrowFrom: ?*ID3D12StateObject,
riid: ?*const Guid,
ppNewStateObject: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateProtectedResourceSession1: fn(
self: *const ID3D12Device7,
pDesc: ?*const D3D12_PROTECTED_RESOURCE_SESSION_DESC1,
riid: ?*const Guid,
ppSession: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device6.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device7_AddToStateObject(self: *const T, pAddition: ?*const D3D12_STATE_OBJECT_DESC, pStateObjectToGrowFrom: ?*ID3D12StateObject, riid: ?*const Guid, ppNewStateObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device7.VTable, self.vtable).AddToStateObject(@ptrCast(*const ID3D12Device7, self), pAddition, pStateObjectToGrowFrom, riid, ppNewStateObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device7_CreateProtectedResourceSession1(self: *const T, pDesc: ?*const D3D12_PROTECTED_RESOURCE_SESSION_DESC1, riid: ?*const Guid, ppSession: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device7.VTable, self.vtable).CreateProtectedResourceSession1(@ptrCast(*const ID3D12Device7, self), pDesc, riid, ppSession);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Device8_Value = Guid.initString("9218e6bb-f944-4f7e-a75c-b1b2c7b701f3");
pub const IID_ID3D12Device8 = &IID_ID3D12Device8_Value;
pub const ID3D12Device8 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device7.VTable,
GetResourceAllocationInfo2: fn(
self: *const ID3D12Device8,
visibleMask: u32,
numResourceDescs: u32,
pResourceDescs: [*]const D3D12_RESOURCE_DESC1,
pResourceAllocationInfo1: ?[*]D3D12_RESOURCE_ALLOCATION_INFO1,
) callconv(@import("std").os.windows.WINAPI) D3D12_RESOURCE_ALLOCATION_INFO,
CreateCommittedResource2: fn(
self: *const ID3D12Device8,
pHeapProperties: ?*const D3D12_HEAP_PROPERTIES,
HeapFlags: D3D12_HEAP_FLAGS,
pDesc: ?*const D3D12_RESOURCE_DESC1,
InitialResourceState: D3D12_RESOURCE_STATES,
pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE,
pProtectedSession: ?*ID3D12ProtectedResourceSession,
riidResource: ?*const Guid,
ppvResource: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreatePlacedResource1: fn(
self: *const ID3D12Device8,
pHeap: ?*ID3D12Heap,
HeapOffset: u64,
pDesc: ?*const D3D12_RESOURCE_DESC1,
InitialState: D3D12_RESOURCE_STATES,
pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE,
riid: ?*const Guid,
ppvResource: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateSamplerFeedbackUnorderedAccessView: fn(
self: *const ID3D12Device8,
pTargetedResource: ?*ID3D12Resource,
pFeedbackResource: ?*ID3D12Resource,
DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) void,
GetCopyableFootprints1: fn(
self: *const ID3D12Device8,
pResourceDesc: ?*const D3D12_RESOURCE_DESC1,
FirstSubresource: u32,
NumSubresources: u32,
BaseOffset: u64,
pLayouts: ?[*]D3D12_PLACED_SUBRESOURCE_FOOTPRINT,
pNumRows: ?[*]u32,
pRowSizeInBytes: ?[*]u64,
pTotalBytes: ?*u64,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device7.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device8_GetResourceAllocationInfo2(self: *const T, visibleMask: u32, numResourceDescs: u32, pResourceDescs: [*]const D3D12_RESOURCE_DESC1, pResourceAllocationInfo1: ?[*]D3D12_RESOURCE_ALLOCATION_INFO1) callconv(.Inline) D3D12_RESOURCE_ALLOCATION_INFO {
return @ptrCast(*const ID3D12Device8.VTable, self.vtable).GetResourceAllocationInfo2(@ptrCast(*const ID3D12Device8, self), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device8_CreateCommittedResource2(self: *const T, pHeapProperties: ?*const D3D12_HEAP_PROPERTIES, HeapFlags: D3D12_HEAP_FLAGS, pDesc: ?*const D3D12_RESOURCE_DESC1, InitialResourceState: D3D12_RESOURCE_STATES, pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE, pProtectedSession: ?*ID3D12ProtectedResourceSession, riidResource: ?*const Guid, ppvResource: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device8.VTable, self.vtable).CreateCommittedResource2(@ptrCast(*const ID3D12Device8, self), pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device8_CreatePlacedResource1(self: *const T, pHeap: ?*ID3D12Heap, HeapOffset: u64, pDesc: ?*const D3D12_RESOURCE_DESC1, InitialState: D3D12_RESOURCE_STATES, pOptimizedClearValue: ?*const D3D12_CLEAR_VALUE, riid: ?*const Guid, ppvResource: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device8.VTable, self.vtable).CreatePlacedResource1(@ptrCast(*const ID3D12Device8, self), pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device8_CreateSamplerFeedbackUnorderedAccessView(self: *const T, pTargetedResource: ?*ID3D12Resource, pFeedbackResource: ?*ID3D12Resource, DestDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device8.VTable, self.vtable).CreateSamplerFeedbackUnorderedAccessView(@ptrCast(*const ID3D12Device8, self), pTargetedResource, pFeedbackResource, DestDescriptor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device8_GetCopyableFootprints1(self: *const T, pResourceDesc: ?*const D3D12_RESOURCE_DESC1, FirstSubresource: u32, NumSubresources: u32, BaseOffset: u64, pLayouts: ?[*]D3D12_PLACED_SUBRESOURCE_FOOTPRINT, pNumRows: ?[*]u32, pRowSizeInBytes: ?[*]u64, pTotalBytes: ?*u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12Device8.VTable, self.vtable).GetCopyableFootprints1(@ptrCast(*const ID3D12Device8, self), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Resource1_Value = Guid.initString("9d5e227a-4430-4161-88b3-3eca6bb16e19");
pub const IID_ID3D12Resource1 = &IID_ID3D12Resource1_Value;
pub const ID3D12Resource1 = extern struct {
pub const VTable = extern struct {
base: ID3D12Resource.VTable,
GetProtectedResourceSession: fn(
self: *const ID3D12Resource1,
riid: ?*const Guid,
ppProtectedSession: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource1_GetProtectedResourceSession(self: *const T, riid: ?*const Guid, ppProtectedSession: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Resource1.VTable, self.vtable).GetProtectedResourceSession(@ptrCast(*const ID3D12Resource1, self), riid, ppProtectedSession);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Resource2_Value = Guid.initString("be36ec3b-ea85-4aeb-a45a-e9d76404a495");
pub const IID_ID3D12Resource2 = &IID_ID3D12Resource2_Value;
pub const ID3D12Resource2 = extern struct {
pub const VTable = extern struct {
base: ID3D12Resource1.VTable,
GetDesc1: fn(
self: *const ID3D12Resource2,
) callconv(@import("std").os.windows.WINAPI) D3D12_RESOURCE_DESC1,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Resource1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Resource2_GetDesc1(self: *const T) callconv(.Inline) D3D12_RESOURCE_DESC1 {
return @ptrCast(*const ID3D12Resource2.VTable, self.vtable).GetDesc1(@ptrCast(*const ID3D12Resource2, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Heap1_Value = Guid.initString("572f7389-2168-49e3-9693-d6df5871bf6d");
pub const IID_ID3D12Heap1 = &IID_ID3D12Heap1_Value;
pub const ID3D12Heap1 = extern struct {
pub const VTable = extern struct {
base: ID3D12Heap.VTable,
GetProtectedResourceSession: fn(
self: *const ID3D12Heap1,
riid: ?*const Guid,
ppProtectedSession: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Heap.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Heap1_GetProtectedResourceSession(self: *const T, riid: ?*const Guid, ppProtectedSession: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Heap1.VTable, self.vtable).GetProtectedResourceSession(@ptrCast(*const ID3D12Heap1, self), riid, ppProtectedSession);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12GraphicsCommandList3_Value = Guid.initString("6fda83a7-b84c-4e38-9ac8-c7bd22016b3d");
pub const IID_ID3D12GraphicsCommandList3 = &IID_ID3D12GraphicsCommandList3_Value;
pub const ID3D12GraphicsCommandList3 = extern struct {
pub const VTable = extern struct {
base: ID3D12GraphicsCommandList2.VTable,
SetProtectedResourceSession: fn(
self: *const ID3D12GraphicsCommandList3,
pProtectedResourceSession: ?*ID3D12ProtectedResourceSession,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12GraphicsCommandList2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList3_SetProtectedResourceSession(self: *const T, pProtectedResourceSession: ?*ID3D12ProtectedResourceSession) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList3.VTable, self.vtable).SetProtectedResourceSession(@ptrCast(*const ID3D12GraphicsCommandList3, self), pProtectedResourceSession);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE = enum(i32) {
DISCARD = 0,
PRESERVE = 1,
CLEAR = 2,
NO_ACCESS = 3,
};
pub const D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE.DISCARD;
pub const D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE.PRESERVE;
pub const D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE.CLEAR;
pub const D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE.NO_ACCESS;
pub const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS = extern struct {
ClearValue: D3D12_CLEAR_VALUE,
};
pub const D3D12_RENDER_PASS_BEGINNING_ACCESS = extern struct {
Type: D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE,
Anonymous: extern union {
Clear: D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS,
},
};
pub const D3D12_RENDER_PASS_ENDING_ACCESS_TYPE = enum(i32) {
DISCARD = 0,
PRESERVE = 1,
RESOLVE = 2,
NO_ACCESS = 3,
};
pub const D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE.DISCARD;
pub const D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE.PRESERVE;
pub const D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE.RESOLVE;
pub const D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE.NO_ACCESS;
pub const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS = extern struct {
SrcSubresource: u32,
DstSubresource: u32,
DstX: u32,
DstY: u32,
SrcRect: RECT,
};
pub const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS = extern struct {
pSrcResource: ?*ID3D12Resource,
pDstResource: ?*ID3D12Resource,
SubresourceCount: u32,
pSubresourceParameters: ?*const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS,
Format: DXGI_FORMAT,
ResolveMode: D3D12_RESOLVE_MODE,
PreserveResolveSource: BOOL,
};
pub const D3D12_RENDER_PASS_ENDING_ACCESS = extern struct {
Type: D3D12_RENDER_PASS_ENDING_ACCESS_TYPE,
Anonymous: extern union {
Resolve: D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS,
},
};
pub const D3D12_RENDER_PASS_RENDER_TARGET_DESC = extern struct {
cpuDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
BeginningAccess: D3D12_RENDER_PASS_BEGINNING_ACCESS,
EndingAccess: D3D12_RENDER_PASS_ENDING_ACCESS,
};
pub const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC = extern struct {
cpuDescriptor: D3D12_CPU_DESCRIPTOR_HANDLE,
DepthBeginningAccess: D3D12_RENDER_PASS_BEGINNING_ACCESS,
StencilBeginningAccess: D3D12_RENDER_PASS_BEGINNING_ACCESS,
DepthEndingAccess: D3D12_RENDER_PASS_ENDING_ACCESS,
StencilEndingAccess: D3D12_RENDER_PASS_ENDING_ACCESS,
};
pub const D3D12_RENDER_PASS_FLAGS = enum(u32) {
NONE = 0,
ALLOW_UAV_WRITES = 1,
SUSPENDING_PASS = 2,
RESUMING_PASS = 4,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
ALLOW_UAV_WRITES: u1 = 0,
SUSPENDING_PASS: u1 = 0,
RESUMING_PASS: u1 = 0,
}) D3D12_RENDER_PASS_FLAGS {
return @intToEnum(D3D12_RENDER_PASS_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_RENDER_PASS_FLAGS.NONE) else 0)
| (if (o.ALLOW_UAV_WRITES == 1) @enumToInt(D3D12_RENDER_PASS_FLAGS.ALLOW_UAV_WRITES) else 0)
| (if (o.SUSPENDING_PASS == 1) @enumToInt(D3D12_RENDER_PASS_FLAGS.SUSPENDING_PASS) else 0)
| (if (o.RESUMING_PASS == 1) @enumToInt(D3D12_RENDER_PASS_FLAGS.RESUMING_PASS) else 0)
);
}
};
pub const D3D12_RENDER_PASS_FLAG_NONE = D3D12_RENDER_PASS_FLAGS.NONE;
pub const D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = D3D12_RENDER_PASS_FLAGS.ALLOW_UAV_WRITES;
pub const D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = D3D12_RENDER_PASS_FLAGS.SUSPENDING_PASS;
pub const D3D12_RENDER_PASS_FLAG_RESUMING_PASS = D3D12_RENDER_PASS_FLAGS.RESUMING_PASS;
const IID_ID3D12MetaCommand_Value = Guid.initString("dbb84c27-36ce-4fc9-b801-f048c46ac570");
pub const IID_ID3D12MetaCommand = &IID_ID3D12MetaCommand_Value;
pub const ID3D12MetaCommand = extern struct {
pub const VTable = extern struct {
base: ID3D12Pageable.VTable,
GetRequiredParameterResourceSize: fn(
self: *const ID3D12MetaCommand,
Stage: D3D12_META_COMMAND_PARAMETER_STAGE,
ParameterIndex: u32,
) callconv(@import("std").os.windows.WINAPI) u64,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Pageable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12MetaCommand_GetRequiredParameterResourceSize(self: *const T, Stage: D3D12_META_COMMAND_PARAMETER_STAGE, ParameterIndex: u32) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12MetaCommand.VTable, self.vtable).GetRequiredParameterResourceSize(@ptrCast(*const ID3D12MetaCommand, self), Stage, ParameterIndex);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_DISPATCH_RAYS_DESC = extern struct {
RayGenerationShaderRecord: D3D12_GPU_VIRTUAL_ADDRESS_RANGE,
MissShaderTable: D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
HitGroupTable: D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
CallableShaderTable: D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
Width: u32,
Height: u32,
Depth: u32,
};
const IID_ID3D12GraphicsCommandList4_Value = Guid.initString("8754318e-d3a9-4541-98cf-645b50dc4874");
pub const IID_ID3D12GraphicsCommandList4 = &IID_ID3D12GraphicsCommandList4_Value;
pub const ID3D12GraphicsCommandList4 = extern struct {
pub const VTable = extern struct {
base: ID3D12GraphicsCommandList3.VTable,
BeginRenderPass: fn(
self: *const ID3D12GraphicsCommandList4,
NumRenderTargets: u32,
pRenderTargets: ?[*]const D3D12_RENDER_PASS_RENDER_TARGET_DESC,
pDepthStencil: ?*const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC,
Flags: D3D12_RENDER_PASS_FLAGS,
) callconv(@import("std").os.windows.WINAPI) void,
EndRenderPass: fn(
self: *const ID3D12GraphicsCommandList4,
) callconv(@import("std").os.windows.WINAPI) void,
InitializeMetaCommand: fn(
self: *const ID3D12GraphicsCommandList4,
pMetaCommand: ?*ID3D12MetaCommand,
// TODO: what to do with BytesParamIndex 2?
pInitializationParametersData: ?*const anyopaque,
InitializationParametersDataSizeInBytes: usize,
) callconv(@import("std").os.windows.WINAPI) void,
ExecuteMetaCommand: fn(
self: *const ID3D12GraphicsCommandList4,
pMetaCommand: ?*ID3D12MetaCommand,
// TODO: what to do with BytesParamIndex 2?
pExecutionParametersData: ?*const anyopaque,
ExecutionParametersDataSizeInBytes: usize,
) callconv(@import("std").os.windows.WINAPI) void,
BuildRaytracingAccelerationStructure: fn(
self: *const ID3D12GraphicsCommandList4,
pDesc: ?*const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC,
NumPostbuildInfoDescs: u32,
pPostbuildInfoDescs: ?[*]const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC,
) callconv(@import("std").os.windows.WINAPI) void,
EmitRaytracingAccelerationStructurePostbuildInfo: fn(
self: *const ID3D12GraphicsCommandList4,
pDesc: ?*const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC,
NumSourceAccelerationStructures: u32,
pSourceAccelerationStructureData: [*]const u64,
) callconv(@import("std").os.windows.WINAPI) void,
CopyRaytracingAccelerationStructure: fn(
self: *const ID3D12GraphicsCommandList4,
DestAccelerationStructureData: u64,
SourceAccelerationStructureData: u64,
Mode: D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetPipelineState1: fn(
self: *const ID3D12GraphicsCommandList4,
pStateObject: ?*ID3D12StateObject,
) callconv(@import("std").os.windows.WINAPI) void,
DispatchRays: fn(
self: *const ID3D12GraphicsCommandList4,
pDesc: ?*const D3D12_DISPATCH_RAYS_DESC,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12GraphicsCommandList3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_BeginRenderPass(self: *const T, NumRenderTargets: u32, pRenderTargets: ?[*]const D3D12_RENDER_PASS_RENDER_TARGET_DESC, pDepthStencil: ?*const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC, Flags: D3D12_RENDER_PASS_FLAGS) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).BeginRenderPass(@ptrCast(*const ID3D12GraphicsCommandList4, self), NumRenderTargets, pRenderTargets, pDepthStencil, Flags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_EndRenderPass(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).EndRenderPass(@ptrCast(*const ID3D12GraphicsCommandList4, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_InitializeMetaCommand(self: *const T, pMetaCommand: ?*ID3D12MetaCommand, pInitializationParametersData: ?*const anyopaque, InitializationParametersDataSizeInBytes: usize) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).InitializeMetaCommand(@ptrCast(*const ID3D12GraphicsCommandList4, self), pMetaCommand, pInitializationParametersData, InitializationParametersDataSizeInBytes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_ExecuteMetaCommand(self: *const T, pMetaCommand: ?*ID3D12MetaCommand, pExecutionParametersData: ?*const anyopaque, ExecutionParametersDataSizeInBytes: usize) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).ExecuteMetaCommand(@ptrCast(*const ID3D12GraphicsCommandList4, self), pMetaCommand, pExecutionParametersData, ExecutionParametersDataSizeInBytes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_BuildRaytracingAccelerationStructure(self: *const T, pDesc: ?*const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC, NumPostbuildInfoDescs: u32, pPostbuildInfoDescs: ?[*]const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).BuildRaytracingAccelerationStructure(@ptrCast(*const ID3D12GraphicsCommandList4, self), pDesc, NumPostbuildInfoDescs, pPostbuildInfoDescs);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_EmitRaytracingAccelerationStructurePostbuildInfo(self: *const T, pDesc: ?*const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC, NumSourceAccelerationStructures: u32, pSourceAccelerationStructureData: [*]const u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).EmitRaytracingAccelerationStructurePostbuildInfo(@ptrCast(*const ID3D12GraphicsCommandList4, self), pDesc, NumSourceAccelerationStructures, pSourceAccelerationStructureData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_CopyRaytracingAccelerationStructure(self: *const T, DestAccelerationStructureData: u64, SourceAccelerationStructureData: u64, Mode: D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).CopyRaytracingAccelerationStructure(@ptrCast(*const ID3D12GraphicsCommandList4, self), DestAccelerationStructureData, SourceAccelerationStructureData, Mode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_SetPipelineState1(self: *const T, pStateObject: ?*ID3D12StateObject) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).SetPipelineState1(@ptrCast(*const ID3D12GraphicsCommandList4, self), pStateObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList4_DispatchRays(self: *const T, pDesc: ?*const D3D12_DISPATCH_RAYS_DESC) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList4.VTable, self.vtable).DispatchRays(@ptrCast(*const ID3D12GraphicsCommandList4, self), pDesc);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_SHADER_CACHE_MODE = enum(i32) {
MEMORY = 0,
DISK = 1,
};
pub const D3D12_SHADER_CACHE_MODE_MEMORY = D3D12_SHADER_CACHE_MODE.MEMORY;
pub const D3D12_SHADER_CACHE_MODE_DISK = D3D12_SHADER_CACHE_MODE.DISK;
pub const D3D12_SHADER_CACHE_FLAGS = enum(u32) {
NONE = 0,
DRIVER_VERSIONED = 1,
USE_WORKING_DIR = 2,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
DRIVER_VERSIONED: u1 = 0,
USE_WORKING_DIR: u1 = 0,
}) D3D12_SHADER_CACHE_FLAGS {
return @intToEnum(D3D12_SHADER_CACHE_FLAGS,
(if (o.NONE == 1) @enumToInt(D3D12_SHADER_CACHE_FLAGS.NONE) else 0)
| (if (o.DRIVER_VERSIONED == 1) @enumToInt(D3D12_SHADER_CACHE_FLAGS.DRIVER_VERSIONED) else 0)
| (if (o.USE_WORKING_DIR == 1) @enumToInt(D3D12_SHADER_CACHE_FLAGS.USE_WORKING_DIR) else 0)
);
}
};
pub const D3D12_SHADER_CACHE_FLAG_NONE = D3D12_SHADER_CACHE_FLAGS.NONE;
pub const D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED = D3D12_SHADER_CACHE_FLAGS.DRIVER_VERSIONED;
pub const D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR = D3D12_SHADER_CACHE_FLAGS.USE_WORKING_DIR;
pub const D3D12_SHADER_CACHE_SESSION_DESC = extern struct {
Identifier: Guid,
Mode: D3D12_SHADER_CACHE_MODE,
Flags: D3D12_SHADER_CACHE_FLAGS,
MaximumInMemoryCacheSizeBytes: u32,
MaximumInMemoryCacheEntries: u32,
MaximumValueFileSizeBytes: u32,
Version: u64,
};
const IID_ID3D12ShaderCacheSession_Value = Guid.initString("28e2495d-0f64-4ae4-a6ec-129255dc49a8");
pub const IID_ID3D12ShaderCacheSession = &IID_ID3D12ShaderCacheSession_Value;
pub const ID3D12ShaderCacheSession = extern struct {
pub const VTable = extern struct {
base: ID3D12DeviceChild.VTable,
FindValue: fn(
self: *const ID3D12ShaderCacheSession,
// TODO: what to do with BytesParamIndex 1?
pKey: ?*const anyopaque,
KeySize: u32,
// TODO: what to do with BytesParamIndex 3?
pValue: ?*anyopaque,
pValueSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
StoreValue: fn(
self: *const ID3D12ShaderCacheSession,
// TODO: what to do with BytesParamIndex 1?
pKey: ?*const anyopaque,
KeySize: u32,
// TODO: what to do with BytesParamIndex 3?
pValue: ?*const anyopaque,
ValueSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetDeleteOnDestroy: fn(
self: *const ID3D12ShaderCacheSession,
) callconv(@import("std").os.windows.WINAPI) void,
GetDesc: fn(
self: *const ID3D12ShaderCacheSession,
) callconv(@import("std").os.windows.WINAPI) D3D12_SHADER_CACHE_SESSION_DESC,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DeviceChild.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderCacheSession_FindValue(self: *const T, pKey: ?*const anyopaque, KeySize: u32, pValue: ?*anyopaque, pValueSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderCacheSession.VTable, self.vtable).FindValue(@ptrCast(*const ID3D12ShaderCacheSession, self), pKey, KeySize, pValue, pValueSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderCacheSession_StoreValue(self: *const T, pKey: ?*const anyopaque, KeySize: u32, pValue: ?*const anyopaque, ValueSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderCacheSession.VTable, self.vtable).StoreValue(@ptrCast(*const ID3D12ShaderCacheSession, self), pKey, KeySize, pValue, ValueSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderCacheSession_SetDeleteOnDestroy(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12ShaderCacheSession.VTable, self.vtable).SetDeleteOnDestroy(@ptrCast(*const ID3D12ShaderCacheSession, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderCacheSession_GetDesc(self: *const T) callconv(.Inline) D3D12_SHADER_CACHE_SESSION_DESC {
return @ptrCast(*const ID3D12ShaderCacheSession.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12ShaderCacheSession, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_SHADER_CACHE_KIND_FLAGS = enum(u32) {
IMPLICIT_D3D_CACHE_FOR_DRIVER = 1,
IMPLICIT_D3D_CONVERSIONS = 2,
IMPLICIT_DRIVER_MANAGED = 4,
APPLICATION_MANAGED = 8,
_,
pub fn initFlags(o: struct {
IMPLICIT_D3D_CACHE_FOR_DRIVER: u1 = 0,
IMPLICIT_D3D_CONVERSIONS: u1 = 0,
IMPLICIT_DRIVER_MANAGED: u1 = 0,
APPLICATION_MANAGED: u1 = 0,
}) D3D12_SHADER_CACHE_KIND_FLAGS {
return @intToEnum(D3D12_SHADER_CACHE_KIND_FLAGS,
(if (o.IMPLICIT_D3D_CACHE_FOR_DRIVER == 1) @enumToInt(D3D12_SHADER_CACHE_KIND_FLAGS.IMPLICIT_D3D_CACHE_FOR_DRIVER) else 0)
| (if (o.IMPLICIT_D3D_CONVERSIONS == 1) @enumToInt(D3D12_SHADER_CACHE_KIND_FLAGS.IMPLICIT_D3D_CONVERSIONS) else 0)
| (if (o.IMPLICIT_DRIVER_MANAGED == 1) @enumToInt(D3D12_SHADER_CACHE_KIND_FLAGS.IMPLICIT_DRIVER_MANAGED) else 0)
| (if (o.APPLICATION_MANAGED == 1) @enumToInt(D3D12_SHADER_CACHE_KIND_FLAGS.APPLICATION_MANAGED) else 0)
);
}
};
pub const D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = D3D12_SHADER_CACHE_KIND_FLAGS.IMPLICIT_D3D_CACHE_FOR_DRIVER;
pub const D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = D3D12_SHADER_CACHE_KIND_FLAGS.IMPLICIT_D3D_CONVERSIONS;
pub const D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = D3D12_SHADER_CACHE_KIND_FLAGS.IMPLICIT_DRIVER_MANAGED;
pub const D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = D3D12_SHADER_CACHE_KIND_FLAGS.APPLICATION_MANAGED;
pub const D3D12_SHADER_CACHE_CONTROL_FLAGS = enum(u32) {
DISABLE = 1,
ENABLE = 2,
CLEAR = 4,
_,
pub fn initFlags(o: struct {
DISABLE: u1 = 0,
ENABLE: u1 = 0,
CLEAR: u1 = 0,
}) D3D12_SHADER_CACHE_CONTROL_FLAGS {
return @intToEnum(D3D12_SHADER_CACHE_CONTROL_FLAGS,
(if (o.DISABLE == 1) @enumToInt(D3D12_SHADER_CACHE_CONTROL_FLAGS.DISABLE) else 0)
| (if (o.ENABLE == 1) @enumToInt(D3D12_SHADER_CACHE_CONTROL_FLAGS.ENABLE) else 0)
| (if (o.CLEAR == 1) @enumToInt(D3D12_SHADER_CACHE_CONTROL_FLAGS.CLEAR) else 0)
);
}
};
pub const D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = D3D12_SHADER_CACHE_CONTROL_FLAGS.DISABLE;
pub const D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = D3D12_SHADER_CACHE_CONTROL_FLAGS.ENABLE;
pub const D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = D3D12_SHADER_CACHE_CONTROL_FLAGS.CLEAR;
const IID_ID3D12Device9_Value = Guid.initString("4c80e962-f032-4f60-bc9e-ebc2cfa1d83c");
pub const IID_ID3D12Device9 = &IID_ID3D12Device9_Value;
pub const ID3D12Device9 = extern struct {
pub const VTable = extern struct {
base: ID3D12Device8.VTable,
CreateShaderCacheSession: fn(
self: *const ID3D12Device9,
pDesc: ?*const D3D12_SHADER_CACHE_SESSION_DESC,
riid: ?*const Guid,
ppvSession: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ShaderCacheControl: fn(
self: *const ID3D12Device9,
Kinds: D3D12_SHADER_CACHE_KIND_FLAGS,
Control: D3D12_SHADER_CACHE_CONTROL_FLAGS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateCommandQueue1: fn(
self: *const ID3D12Device9,
pDesc: ?*const D3D12_COMMAND_QUEUE_DESC,
CreatorID: ?*const Guid,
riid: ?*const Guid,
ppCommandQueue: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Device8.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device9_CreateShaderCacheSession(self: *const T, pDesc: ?*const D3D12_SHADER_CACHE_SESSION_DESC, riid: ?*const Guid, ppvSession: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device9.VTable, self.vtable).CreateShaderCacheSession(@ptrCast(*const ID3D12Device9, self), pDesc, riid, ppvSession);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device9_ShaderCacheControl(self: *const T, Kinds: D3D12_SHADER_CACHE_KIND_FLAGS, Control: D3D12_SHADER_CACHE_CONTROL_FLAGS) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device9.VTable, self.vtable).ShaderCacheControl(@ptrCast(*const ID3D12Device9, self), Kinds, Control);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Device9_CreateCommandQueue1(self: *const T, pDesc: ?*const D3D12_COMMAND_QUEUE_DESC, CreatorID: ?*const Guid, riid: ?*const Guid, ppCommandQueue: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12Device9.VTable, self.vtable).CreateCommandQueue1(@ptrCast(*const ID3D12Device9, self), pDesc, CreatorID, riid, ppCommandQueue);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Tools_Value = Guid.initString("7071e1f0-e84b-4b33-974f-12fa49de65c5");
pub const IID_ID3D12Tools = &IID_ID3D12Tools_Value;
pub const ID3D12Tools = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
EnableShaderInstrumentation: fn(
self: *const ID3D12Tools,
bEnable: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
ShaderInstrumentationEnabled: fn(
self: *const ID3D12Tools,
) callconv(@import("std").os.windows.WINAPI) BOOL,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Tools_EnableShaderInstrumentation(self: *const T, bEnable: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID3D12Tools.VTable, self.vtable).EnableShaderInstrumentation(@ptrCast(*const ID3D12Tools, self), bEnable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Tools_ShaderInstrumentationEnabled(self: *const T) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12Tools.VTable, self.vtable).ShaderInstrumentationEnabled(@ptrCast(*const ID3D12Tools, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_SUBRESOURCE_DATA = extern struct {
pData: ?*const anyopaque,
RowPitch: isize,
SlicePitch: isize,
};
pub const D3D12_MEMCPY_DEST = extern struct {
pData: ?*anyopaque,
RowPitch: usize,
SlicePitch: usize,
};
const IID_ID3D12Debug_Value = Guid.initString("344488b7-6846-474b-b989-f027448245e0");
pub const IID_ID3D12Debug = &IID_ID3D12Debug_Value;
pub const ID3D12Debug = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
EnableDebugLayer: fn(
self: *const ID3D12Debug,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug_EnableDebugLayer(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug.VTable, self.vtable).EnableDebugLayer(@ptrCast(*const ID3D12Debug, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_GPU_BASED_VALIDATION_FLAGS = enum(i32) {
NONE = 0,
DISABLE_STATE_TRACKING = 1,
};
pub const D3D12_GPU_BASED_VALIDATION_FLAGS_NONE = D3D12_GPU_BASED_VALIDATION_FLAGS.NONE;
pub const D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING = D3D12_GPU_BASED_VALIDATION_FLAGS.DISABLE_STATE_TRACKING;
const IID_ID3D12Debug1_Value = Guid.initString("affaa4ca-63fe-4d8e-b8ad-159000af4304");
pub const IID_ID3D12Debug1 = &IID_ID3D12Debug1_Value;
pub const ID3D12Debug1 = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
EnableDebugLayer: fn(
self: *const ID3D12Debug1,
) callconv(@import("std").os.windows.WINAPI) void,
SetEnableGPUBasedValidation: fn(
self: *const ID3D12Debug1,
Enable: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
SetEnableSynchronizedCommandQueueValidation: fn(
self: *const ID3D12Debug1,
Enable: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug1_EnableDebugLayer(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug1.VTable, self.vtable).EnableDebugLayer(@ptrCast(*const ID3D12Debug1, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug1_SetEnableGPUBasedValidation(self: *const T, Enable: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug1.VTable, self.vtable).SetEnableGPUBasedValidation(@ptrCast(*const ID3D12Debug1, self), Enable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug1_SetEnableSynchronizedCommandQueueValidation(self: *const T, Enable: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug1.VTable, self.vtable).SetEnableSynchronizedCommandQueueValidation(@ptrCast(*const ID3D12Debug1, self), Enable);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Debug2_Value = Guid.initString("93a665c4-a3b2-4e5d-b692-a26ae14e3374");
pub const IID_ID3D12Debug2 = &IID_ID3D12Debug2_Value;
pub const ID3D12Debug2 = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetGPUBasedValidationFlags: fn(
self: *const ID3D12Debug2,
Flags: D3D12_GPU_BASED_VALIDATION_FLAGS,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug2_SetGPUBasedValidationFlags(self: *const T, Flags: D3D12_GPU_BASED_VALIDATION_FLAGS) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug2.VTable, self.vtable).SetGPUBasedValidationFlags(@ptrCast(*const ID3D12Debug2, self), Flags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Debug3_Value = Guid.initString("5cf4e58f-f671-4ff1-a542-3686e3d153d1");
pub const IID_ID3D12Debug3 = &IID_ID3D12Debug3_Value;
pub const ID3D12Debug3 = extern struct {
pub const VTable = extern struct {
base: ID3D12Debug.VTable,
SetEnableGPUBasedValidation: fn(
self: *const ID3D12Debug3,
Enable: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
SetEnableSynchronizedCommandQueueValidation: fn(
self: *const ID3D12Debug3,
Enable: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
SetGPUBasedValidationFlags: fn(
self: *const ID3D12Debug3,
Flags: D3D12_GPU_BASED_VALIDATION_FLAGS,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Debug.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug3_SetEnableGPUBasedValidation(self: *const T, Enable: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug3.VTable, self.vtable).SetEnableGPUBasedValidation(@ptrCast(*const ID3D12Debug3, self), Enable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug3_SetEnableSynchronizedCommandQueueValidation(self: *const T, Enable: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug3.VTable, self.vtable).SetEnableSynchronizedCommandQueueValidation(@ptrCast(*const ID3D12Debug3, self), Enable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug3_SetGPUBasedValidationFlags(self: *const T, Flags: D3D12_GPU_BASED_VALIDATION_FLAGS) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug3.VTable, self.vtable).SetGPUBasedValidationFlags(@ptrCast(*const ID3D12Debug3, self), Flags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Debug4_Value = Guid.initString("014b816e-9ec5-4a2f-a845-ffbe441ce13a");
pub const IID_ID3D12Debug4 = &IID_ID3D12Debug4_Value;
pub const ID3D12Debug4 = extern struct {
pub const VTable = extern struct {
base: ID3D12Debug3.VTable,
DisableDebugLayer: fn(
self: *const ID3D12Debug4,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Debug3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug4_DisableDebugLayer(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug4.VTable, self.vtable).DisableDebugLayer(@ptrCast(*const ID3D12Debug4, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12Debug5_Value = Guid.initString("548d6b12-09fa-40e0-9069-5dcd589a52c9");
pub const IID_ID3D12Debug5 = &IID_ID3D12Debug5_Value;
pub const ID3D12Debug5 = extern struct {
pub const VTable = extern struct {
base: ID3D12Debug4.VTable,
SetEnableAutoName: fn(
self: *const ID3D12Debug5,
Enable: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12Debug4.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12Debug5_SetEnableAutoName(self: *const T, Enable: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID3D12Debug5.VTable, self.vtable).SetEnableAutoName(@ptrCast(*const ID3D12Debug5, self), Enable);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_RLDO_FLAGS = enum(i32) {
NONE = 0,
SUMMARY = 1,
DETAIL = 2,
IGNORE_INTERNAL = 4,
};
pub const D3D12_RLDO_NONE = D3D12_RLDO_FLAGS.NONE;
pub const D3D12_RLDO_SUMMARY = D3D12_RLDO_FLAGS.SUMMARY;
pub const D3D12_RLDO_DETAIL = D3D12_RLDO_FLAGS.DETAIL;
pub const D3D12_RLDO_IGNORE_INTERNAL = D3D12_RLDO_FLAGS.IGNORE_INTERNAL;
pub const D3D12_DEBUG_DEVICE_PARAMETER_TYPE = enum(i32) {
FEATURE_FLAGS = 0,
GPU_BASED_VALIDATION_SETTINGS = 1,
GPU_SLOWDOWN_PERFORMANCE_FACTOR = 2,
};
pub const D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS = D3D12_DEBUG_DEVICE_PARAMETER_TYPE.FEATURE_FLAGS;
pub const D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = D3D12_DEBUG_DEVICE_PARAMETER_TYPE.GPU_BASED_VALIDATION_SETTINGS;
pub const D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR = D3D12_DEBUG_DEVICE_PARAMETER_TYPE.GPU_SLOWDOWN_PERFORMANCE_FACTOR;
pub const D3D12_DEBUG_FEATURE = enum(i32) {
NONE = 0,
ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS = 1,
CONSERVATIVE_RESOURCE_STATE_TRACKING = 2,
DISABLE_VIRTUALIZED_BUNDLES_VALIDATION = 4,
EMULATE_WINDOWS7 = 8,
};
pub const D3D12_DEBUG_FEATURE_NONE = D3D12_DEBUG_FEATURE.NONE;
pub const D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS = D3D12_DEBUG_FEATURE.ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS;
pub const D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING = D3D12_DEBUG_FEATURE.CONSERVATIVE_RESOURCE_STATE_TRACKING;
pub const D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION = D3D12_DEBUG_FEATURE.DISABLE_VIRTUALIZED_BUNDLES_VALIDATION;
pub const D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7 = D3D12_DEBUG_FEATURE.EMULATE_WINDOWS7;
pub const D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE = enum(i32) {
D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE = 0,
D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY = 1,
D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION = 2,
D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION = 3,
NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES = 4,
};
pub const D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE = D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE.D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE;
pub const D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY = D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE.D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY;
pub const D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION = D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE.D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION;
pub const D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION = D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE.D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION;
pub const NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES = D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE.NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES;
pub const D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS = enum(i32) {
_NONE = 0,
_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS = 1,
_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = 2,
_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS = 4,
S_VALID_MASK = 7,
};
pub const D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE = D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS._NONE;
pub const D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS = D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS._FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS;
pub const D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS._FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS;
pub const D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS = D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS._FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS;
pub const D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK = D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS.S_VALID_MASK;
pub const D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS = extern struct {
MaxMessagesPerCommandList: u32,
DefaultShaderPatchMode: D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE,
PipelineStateCreateFlags: D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS,
};
pub const D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR = extern struct {
SlowdownFactor: f32,
};
const IID_ID3D12DebugDevice1_Value = Guid.initString("a9b71770-d099-4a65-a698-3dee10020f88");
pub const IID_ID3D12DebugDevice1 = &IID_ID3D12DebugDevice1_Value;
pub const ID3D12DebugDevice1 = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetDebugParameter: fn(
self: *const ID3D12DebugDevice1,
Type: D3D12_DEBUG_DEVICE_PARAMETER_TYPE,
// TODO: what to do with BytesParamIndex 2?
pData: ?*const anyopaque,
DataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDebugParameter: fn(
self: *const ID3D12DebugDevice1,
Type: D3D12_DEBUG_DEVICE_PARAMETER_TYPE,
// TODO: what to do with BytesParamIndex 2?
pData: ?*anyopaque,
DataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReportLiveDeviceObjects: fn(
self: *const ID3D12DebugDevice1,
Flags: D3D12_RLDO_FLAGS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugDevice1_SetDebugParameter(self: *const T, Type: D3D12_DEBUG_DEVICE_PARAMETER_TYPE, pData: ?*const anyopaque, DataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugDevice1.VTable, self.vtable).SetDebugParameter(@ptrCast(*const ID3D12DebugDevice1, self), Type, pData, DataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugDevice1_GetDebugParameter(self: *const T, Type: D3D12_DEBUG_DEVICE_PARAMETER_TYPE, pData: ?*anyopaque, DataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugDevice1.VTable, self.vtable).GetDebugParameter(@ptrCast(*const ID3D12DebugDevice1, self), Type, pData, DataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugDevice1_ReportLiveDeviceObjects(self: *const T, Flags: D3D12_RLDO_FLAGS) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugDevice1.VTable, self.vtable).ReportLiveDeviceObjects(@ptrCast(*const ID3D12DebugDevice1, self), Flags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DebugDevice_Value = Guid.initString("3febd6dd-4973-4787-8194-e45f9e28923e");
pub const IID_ID3D12DebugDevice = &IID_ID3D12DebugDevice_Value;
pub const ID3D12DebugDevice = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetFeatureMask: fn(
self: *const ID3D12DebugDevice,
Mask: D3D12_DEBUG_FEATURE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFeatureMask: fn(
self: *const ID3D12DebugDevice,
) callconv(@import("std").os.windows.WINAPI) D3D12_DEBUG_FEATURE,
ReportLiveDeviceObjects: fn(
self: *const ID3D12DebugDevice,
Flags: D3D12_RLDO_FLAGS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugDevice_SetFeatureMask(self: *const T, Mask: D3D12_DEBUG_FEATURE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugDevice.VTable, self.vtable).SetFeatureMask(@ptrCast(*const ID3D12DebugDevice, self), Mask);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugDevice_GetFeatureMask(self: *const T) callconv(.Inline) D3D12_DEBUG_FEATURE {
return @ptrCast(*const ID3D12DebugDevice.VTable, self.vtable).GetFeatureMask(@ptrCast(*const ID3D12DebugDevice, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugDevice_ReportLiveDeviceObjects(self: *const T, Flags: D3D12_RLDO_FLAGS) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugDevice.VTable, self.vtable).ReportLiveDeviceObjects(@ptrCast(*const ID3D12DebugDevice, self), Flags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DebugDevice2_Value = Guid.initString("60eccbc1-378d-4df1-894c-f8ac5ce4d7dd");
pub const IID_ID3D12DebugDevice2 = &IID_ID3D12DebugDevice2_Value;
pub const ID3D12DebugDevice2 = extern struct {
pub const VTable = extern struct {
base: ID3D12DebugDevice.VTable,
SetDebugParameter: fn(
self: *const ID3D12DebugDevice2,
Type: D3D12_DEBUG_DEVICE_PARAMETER_TYPE,
// TODO: what to do with BytesParamIndex 2?
pData: ?*const anyopaque,
DataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDebugParameter: fn(
self: *const ID3D12DebugDevice2,
Type: D3D12_DEBUG_DEVICE_PARAMETER_TYPE,
// TODO: what to do with BytesParamIndex 2?
pData: ?*anyopaque,
DataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DebugDevice.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugDevice2_SetDebugParameter(self: *const T, Type: D3D12_DEBUG_DEVICE_PARAMETER_TYPE, pData: ?*const anyopaque, DataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugDevice2.VTable, self.vtable).SetDebugParameter(@ptrCast(*const ID3D12DebugDevice2, self), Type, pData, DataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugDevice2_GetDebugParameter(self: *const T, Type: D3D12_DEBUG_DEVICE_PARAMETER_TYPE, pData: ?*anyopaque, DataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugDevice2.VTable, self.vtable).GetDebugParameter(@ptrCast(*const ID3D12DebugDevice2, self), Type, pData, DataSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DebugCommandQueue_Value = Guid.initString("09e0bf36-54ac-484f-8847-4baeeab6053a");
pub const IID_ID3D12DebugCommandQueue = &IID_ID3D12DebugCommandQueue_Value;
pub const ID3D12DebugCommandQueue = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AssertResourceState: fn(
self: *const ID3D12DebugCommandQueue,
pResource: ?*ID3D12Resource,
Subresource: u32,
State: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandQueue_AssertResourceState(self: *const T, pResource: ?*ID3D12Resource, Subresource: u32, State: u32) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12DebugCommandQueue.VTable, self.vtable).AssertResourceState(@ptrCast(*const ID3D12DebugCommandQueue, self), pResource, Subresource, State);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE = enum(i32) {
S = 0,
};
pub const D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE.S;
pub const D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS = extern struct {
ShaderPatchMode: D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE,
};
const IID_ID3D12DebugCommandList1_Value = Guid.initString("102ca951-311b-4b01-b11f-ecb83e061b37");
pub const IID_ID3D12DebugCommandList1 = &IID_ID3D12DebugCommandList1_Value;
pub const ID3D12DebugCommandList1 = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AssertResourceState: fn(
self: *const ID3D12DebugCommandList1,
pResource: ?*ID3D12Resource,
Subresource: u32,
State: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL,
SetDebugParameter: fn(
self: *const ID3D12DebugCommandList1,
Type: D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE,
// TODO: what to do with BytesParamIndex 2?
pData: ?*const anyopaque,
DataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDebugParameter: fn(
self: *const ID3D12DebugCommandList1,
Type: D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE,
// TODO: what to do with BytesParamIndex 2?
pData: ?*anyopaque,
DataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandList1_AssertResourceState(self: *const T, pResource: ?*ID3D12Resource, Subresource: u32, State: u32) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12DebugCommandList1.VTable, self.vtable).AssertResourceState(@ptrCast(*const ID3D12DebugCommandList1, self), pResource, Subresource, State);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandList1_SetDebugParameter(self: *const T, Type: D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE, pData: ?*const anyopaque, DataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugCommandList1.VTable, self.vtable).SetDebugParameter(@ptrCast(*const ID3D12DebugCommandList1, self), Type, pData, DataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandList1_GetDebugParameter(self: *const T, Type: D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE, pData: ?*anyopaque, DataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugCommandList1.VTable, self.vtable).GetDebugParameter(@ptrCast(*const ID3D12DebugCommandList1, self), Type, pData, DataSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DebugCommandList_Value = Guid.initString("09e0bf36-54ac-484f-8847-4baeeab6053f");
pub const IID_ID3D12DebugCommandList = &IID_ID3D12DebugCommandList_Value;
pub const ID3D12DebugCommandList = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AssertResourceState: fn(
self: *const ID3D12DebugCommandList,
pResource: ?*ID3D12Resource,
Subresource: u32,
State: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL,
SetFeatureMask: fn(
self: *const ID3D12DebugCommandList,
Mask: D3D12_DEBUG_FEATURE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFeatureMask: fn(
self: *const ID3D12DebugCommandList,
) callconv(@import("std").os.windows.WINAPI) D3D12_DEBUG_FEATURE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandList_AssertResourceState(self: *const T, pResource: ?*ID3D12Resource, Subresource: u32, State: u32) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12DebugCommandList.VTable, self.vtable).AssertResourceState(@ptrCast(*const ID3D12DebugCommandList, self), pResource, Subresource, State);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandList_SetFeatureMask(self: *const T, Mask: D3D12_DEBUG_FEATURE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugCommandList.VTable, self.vtable).SetFeatureMask(@ptrCast(*const ID3D12DebugCommandList, self), Mask);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandList_GetFeatureMask(self: *const T) callconv(.Inline) D3D12_DEBUG_FEATURE {
return @ptrCast(*const ID3D12DebugCommandList.VTable, self.vtable).GetFeatureMask(@ptrCast(*const ID3D12DebugCommandList, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12DebugCommandList2_Value = Guid.initString("aeb575cf-4e06-48be-ba3b-c450fc96652e");
pub const IID_ID3D12DebugCommandList2 = &IID_ID3D12DebugCommandList2_Value;
pub const ID3D12DebugCommandList2 = extern struct {
pub const VTable = extern struct {
base: ID3D12DebugCommandList.VTable,
SetDebugParameter: fn(
self: *const ID3D12DebugCommandList2,
Type: D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE,
// TODO: what to do with BytesParamIndex 2?
pData: ?*const anyopaque,
DataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDebugParameter: fn(
self: *const ID3D12DebugCommandList2,
Type: D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE,
// TODO: what to do with BytesParamIndex 2?
pData: ?*anyopaque,
DataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12DebugCommandList.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandList2_SetDebugParameter(self: *const T, Type: D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE, pData: ?*const anyopaque, DataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugCommandList2.VTable, self.vtable).SetDebugParameter(@ptrCast(*const ID3D12DebugCommandList2, self), Type, pData, DataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12DebugCommandList2_GetDebugParameter(self: *const T, Type: D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE, pData: ?*anyopaque, DataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12DebugCommandList2.VTable, self.vtable).GetDebugParameter(@ptrCast(*const ID3D12DebugCommandList2, self), Type, pData, DataSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12SharingContract_Value = Guid.initString("0adf7d52-929c-4e61-addb-ffed30de66ef");
pub const IID_ID3D12SharingContract = &IID_ID3D12SharingContract_Value;
pub const ID3D12SharingContract = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Present: fn(
self: *const ID3D12SharingContract,
pResource: ?*ID3D12Resource,
Subresource: u32,
window: ?HWND,
) callconv(@import("std").os.windows.WINAPI) void,
SharedFenceSignal: fn(
self: *const ID3D12SharingContract,
pFence: ?*ID3D12Fence,
FenceValue: u64,
) callconv(@import("std").os.windows.WINAPI) void,
BeginCapturableWork: fn(
self: *const ID3D12SharingContract,
guid: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) void,
EndCapturableWork: fn(
self: *const ID3D12SharingContract,
guid: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SharingContract_Present(self: *const T, pResource: ?*ID3D12Resource, Subresource: u32, window: ?HWND) callconv(.Inline) void {
return @ptrCast(*const ID3D12SharingContract.VTable, self.vtable).Present(@ptrCast(*const ID3D12SharingContract, self), pResource, Subresource, window);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SharingContract_SharedFenceSignal(self: *const T, pFence: ?*ID3D12Fence, FenceValue: u64) callconv(.Inline) void {
return @ptrCast(*const ID3D12SharingContract.VTable, self.vtable).SharedFenceSignal(@ptrCast(*const ID3D12SharingContract, self), pFence, FenceValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SharingContract_BeginCapturableWork(self: *const T, guid: ?*const Guid) callconv(.Inline) void {
return @ptrCast(*const ID3D12SharingContract.VTable, self.vtable).BeginCapturableWork(@ptrCast(*const ID3D12SharingContract, self), guid);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SharingContract_EndCapturableWork(self: *const T, guid: ?*const Guid) callconv(.Inline) void {
return @ptrCast(*const ID3D12SharingContract.VTable, self.vtable).EndCapturableWork(@ptrCast(*const ID3D12SharingContract, self), guid);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_MESSAGE_CATEGORY = enum(i32) {
APPLICATION_DEFINED = 0,
MISCELLANEOUS = 1,
INITIALIZATION = 2,
CLEANUP = 3,
COMPILATION = 4,
STATE_CREATION = 5,
STATE_SETTING = 6,
STATE_GETTING = 7,
RESOURCE_MANIPULATION = 8,
EXECUTION = 9,
SHADER = 10,
};
pub const D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED = D3D12_MESSAGE_CATEGORY.APPLICATION_DEFINED;
pub const D3D12_MESSAGE_CATEGORY_MISCELLANEOUS = D3D12_MESSAGE_CATEGORY.MISCELLANEOUS;
pub const D3D12_MESSAGE_CATEGORY_INITIALIZATION = D3D12_MESSAGE_CATEGORY.INITIALIZATION;
pub const D3D12_MESSAGE_CATEGORY_CLEANUP = D3D12_MESSAGE_CATEGORY.CLEANUP;
pub const D3D12_MESSAGE_CATEGORY_COMPILATION = D3D12_MESSAGE_CATEGORY.COMPILATION;
pub const D3D12_MESSAGE_CATEGORY_STATE_CREATION = D3D12_MESSAGE_CATEGORY.STATE_CREATION;
pub const D3D12_MESSAGE_CATEGORY_STATE_SETTING = D3D12_MESSAGE_CATEGORY.STATE_SETTING;
pub const D3D12_MESSAGE_CATEGORY_STATE_GETTING = D3D12_MESSAGE_CATEGORY.STATE_GETTING;
pub const D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION = D3D12_MESSAGE_CATEGORY.RESOURCE_MANIPULATION;
pub const D3D12_MESSAGE_CATEGORY_EXECUTION = D3D12_MESSAGE_CATEGORY.EXECUTION;
pub const D3D12_MESSAGE_CATEGORY_SHADER = D3D12_MESSAGE_CATEGORY.SHADER;
pub const D3D12_MESSAGE_SEVERITY = enum(i32) {
CORRUPTION = 0,
ERROR = 1,
WARNING = 2,
INFO = 3,
MESSAGE = 4,
};
pub const D3D12_MESSAGE_SEVERITY_CORRUPTION = D3D12_MESSAGE_SEVERITY.CORRUPTION;
pub const D3D12_MESSAGE_SEVERITY_ERROR = D3D12_MESSAGE_SEVERITY.ERROR;
pub const D3D12_MESSAGE_SEVERITY_WARNING = D3D12_MESSAGE_SEVERITY.WARNING;
pub const D3D12_MESSAGE_SEVERITY_INFO = D3D12_MESSAGE_SEVERITY.INFO;
pub const D3D12_MESSAGE_SEVERITY_MESSAGE = D3D12_MESSAGE_SEVERITY.MESSAGE;
pub const D3D12_MESSAGE_ID = enum(i32) {
UNKNOWN = 0,
STRING_FROM_APPLICATION = 1,
CORRUPTED_THIS = 2,
CORRUPTED_PARAMETER1 = 3,
CORRUPTED_PARAMETER2 = 4,
CORRUPTED_PARAMETER3 = 5,
CORRUPTED_PARAMETER4 = 6,
CORRUPTED_PARAMETER5 = 7,
CORRUPTED_PARAMETER6 = 8,
CORRUPTED_PARAMETER7 = 9,
CORRUPTED_PARAMETER8 = 10,
CORRUPTED_PARAMETER9 = 11,
CORRUPTED_PARAMETER10 = 12,
CORRUPTED_PARAMETER11 = 13,
CORRUPTED_PARAMETER12 = 14,
CORRUPTED_PARAMETER13 = 15,
CORRUPTED_PARAMETER14 = 16,
CORRUPTED_PARAMETER15 = 17,
CORRUPTED_MULTITHREADING = 18,
MESSAGE_REPORTING_OUTOFMEMORY = 19,
GETPRIVATEDATA_MOREDATA = 20,
SETPRIVATEDATA_INVALIDFREEDATA = 21,
SETPRIVATEDATA_CHANGINGPARAMS = 24,
SETPRIVATEDATA_OUTOFMEMORY = 25,
CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT = 26,
CREATESHADERRESOURCEVIEW_INVALIDDESC = 27,
CREATESHADERRESOURCEVIEW_INVALIDFORMAT = 28,
CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE = 29,
CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE = 30,
CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS = 31,
CREATESHADERRESOURCEVIEW_INVALIDRESOURCE = 32,
CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT = 35,
CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT = 36,
CREATERENDERTARGETVIEW_INVALIDDESC = 37,
CREATERENDERTARGETVIEW_INVALIDFORMAT = 38,
CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE = 39,
CREATERENDERTARGETVIEW_INVALIDPLANESLICE = 40,
CREATERENDERTARGETVIEW_INVALIDDIMENSIONS = 41,
CREATERENDERTARGETVIEW_INVALIDRESOURCE = 42,
CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT = 45,
CREATEDEPTHSTENCILVIEW_INVALIDDESC = 46,
CREATEDEPTHSTENCILVIEW_INVALIDFORMAT = 47,
CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS = 48,
CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE = 49,
CREATEINPUTLAYOUT_OUTOFMEMORY = 52,
CREATEINPUTLAYOUT_TOOMANYELEMENTS = 53,
CREATEINPUTLAYOUT_INVALIDFORMAT = 54,
CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT = 55,
CREATEINPUTLAYOUT_INVALIDSLOT = 56,
CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS = 57,
CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH = 58,
CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE = 59,
CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE = 60,
CREATEINPUTLAYOUT_INVALIDALIGNMENT = 61,
CREATEINPUTLAYOUT_DUPLICATESEMANTIC = 62,
CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE = 63,
CREATEINPUTLAYOUT_NULLSEMANTIC = 64,
CREATEINPUTLAYOUT_MISSINGELEMENT = 65,
CREATEVERTEXSHADER_OUTOFMEMORY = 66,
CREATEVERTEXSHADER_INVALIDSHADERBYTECODE = 67,
CREATEVERTEXSHADER_INVALIDSHADERTYPE = 68,
CREATEGEOMETRYSHADER_OUTOFMEMORY = 69,
CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE = 70,
CREATEGEOMETRYSHADER_INVALIDSHADERTYPE = 71,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY = 72,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE = 73,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE = 74,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES = 75,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED = 76,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED = 79,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT = 80,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT = 81,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT = 82,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT = 83,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION = 84,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT = 85,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE = 86,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC = 87,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH = 88,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS = 89,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX = 90,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE = 91,
CREATEPIXELSHADER_OUTOFMEMORY = 92,
CREATEPIXELSHADER_INVALIDSHADERBYTECODE = 93,
CREATEPIXELSHADER_INVALIDSHADERTYPE = 94,
CREATERASTERIZERSTATE_INVALIDFILLMODE = 95,
CREATERASTERIZERSTATE_INVALIDCULLMODE = 96,
CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP = 97,
CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS = 98,
CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK = 100,
CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC = 101,
CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP = 102,
CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP = 103,
CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP = 104,
CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC = 105,
CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP = 106,
CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP = 107,
CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP = 108,
CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC = 109,
CREATEBLENDSTATE_INVALIDSRCBLEND = 111,
CREATEBLENDSTATE_INVALIDDESTBLEND = 112,
CREATEBLENDSTATE_INVALIDBLENDOP = 113,
CREATEBLENDSTATE_INVALIDSRCBLENDALPHA = 114,
CREATEBLENDSTATE_INVALIDDESTBLENDALPHA = 115,
CREATEBLENDSTATE_INVALIDBLENDOPALPHA = 116,
CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK = 117,
CLEARDEPTHSTENCILVIEW_INVALID = 135,
COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET = 200,
COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH = 201,
COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET = 202,
COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL = 209,
COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL = 210,
COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET = 211,
COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID = 212,
COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL = 213,
COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY = 219,
COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED = 221,
COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED = 222,
DEVICE_REMOVAL_PROCESS_AT_FAULT = 232,
DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT = 233,
DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT = 234,
CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC = 239,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC = 240,
CREATEINPUTLAYOUT_TYPE_MISMATCH = 245,
CREATEINPUTLAYOUT_EMPTY_LAYOUT = 253,
LIVE_OBJECT_SUMMARY = 255,
LIVE_DEVICE = 274,
LIVE_SWAPCHAIN = 275,
CREATEDEPTHSTENCILVIEW_INVALIDFLAGS = 276,
CREATEVERTEXSHADER_INVALIDCLASSLINKAGE = 277,
CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE = 278,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER = 280,
CREATEPIXELSHADER_INVALIDCLASSLINKAGE = 283,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM = 284,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES = 285,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES = 286,
CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES = 287,
CREATEHULLSHADER_OUTOFMEMORY = 289,
CREATEHULLSHADER_INVALIDSHADERBYTECODE = 290,
CREATEHULLSHADER_INVALIDSHADERTYPE = 291,
CREATEHULLSHADER_INVALIDCLASSLINKAGE = 292,
CREATEDOMAINSHADER_OUTOFMEMORY = 294,
CREATEDOMAINSHADER_INVALIDSHADERBYTECODE = 295,
CREATEDOMAINSHADER_INVALIDSHADERTYPE = 296,
CREATEDOMAINSHADER_INVALIDCLASSLINKAGE = 297,
RESOURCE_UNMAP_NOTMAPPED = 310,
DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE = 318,
CREATECOMPUTESHADER_OUTOFMEMORY = 321,
CREATECOMPUTESHADER_INVALIDSHADERBYTECODE = 322,
CREATECOMPUTESHADER_INVALIDCLASSLINKAGE = 323,
DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 331,
DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 332,
DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 333,
DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 334,
DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED = 335,
DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED = 336,
DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED = 337,
CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE = 340,
CREATEUNORDEREDACCESSVIEW_INVALIDDESC = 341,
CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT = 342,
CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE = 343,
CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE = 344,
CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS = 345,
CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT = 346,
CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS = 354,
CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT = 401,
CREATEBLENDSTATE_INVALIDLOGICOPS = 403,
DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 410,
DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 412,
DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 414,
DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 416,
DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED = 418,
DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 420,
DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED = 422,
DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED = 425,
DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED = 426,
DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED = 427,
DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED = 428,
DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED = 429,
DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED = 430,
DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED = 431,
DEVICE_CLEARVIEW_INVALIDSOURCERECT = 447,
DEVICE_CLEARVIEW_EMPTYRECT = 448,
UPDATETILEMAPPINGS_INVALID_PARAMETER = 493,
COPYTILEMAPPINGS_INVALID_PARAMETER = 494,
CREATEDEVICE_INVALIDARGS = 506,
CREATEDEVICE_WARNING = 507,
RESOURCE_BARRIER_INVALID_TYPE = 519,
RESOURCE_BARRIER_NULL_POINTER = 520,
RESOURCE_BARRIER_INVALID_SUBRESOURCE = 521,
RESOURCE_BARRIER_RESERVED_BITS = 522,
RESOURCE_BARRIER_MISSING_BIND_FLAGS = 523,
RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS = 524,
RESOURCE_BARRIER_MATCHING_STATES = 525,
RESOURCE_BARRIER_INVALID_COMBINATION = 526,
RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH = 527,
RESOURCE_BARRIER_INVALID_RESOURCE = 528,
RESOURCE_BARRIER_SAMPLE_COUNT = 529,
RESOURCE_BARRIER_INVALID_FLAGS = 530,
RESOURCE_BARRIER_INVALID_COMBINED_FLAGS = 531,
RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT = 532,
RESOURCE_BARRIER_INVALID_SPLIT_BARRIER = 533,
RESOURCE_BARRIER_UNMATCHED_END = 534,
RESOURCE_BARRIER_UNMATCHED_BEGIN = 535,
RESOURCE_BARRIER_INVALID_FLAG = 536,
RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE = 537,
INVALID_SUBRESOURCE_STATE = 538,
COMMAND_ALLOCATOR_CONTENTION = 540,
COMMAND_ALLOCATOR_RESET = 541,
COMMAND_ALLOCATOR_RESET_BUNDLE = 542,
COMMAND_ALLOCATOR_CANNOT_RESET = 543,
COMMAND_LIST_OPEN = 544,
INVALID_BUNDLE_API = 546,
COMMAND_LIST_CLOSED = 547,
WRONG_COMMAND_ALLOCATOR_TYPE = 549,
COMMAND_ALLOCATOR_SYNC = 552,
COMMAND_LIST_SYNC = 553,
SET_DESCRIPTOR_HEAP_INVALID = 554,
CREATE_COMMANDQUEUE = 557,
CREATE_COMMANDALLOCATOR = 558,
CREATE_PIPELINESTATE = 559,
CREATE_COMMANDLIST12 = 560,
CREATE_RESOURCE = 562,
CREATE_DESCRIPTORHEAP = 563,
CREATE_ROOTSIGNATURE = 564,
CREATE_LIBRARY = 565,
CREATE_HEAP = 566,
CREATE_MONITOREDFENCE = 567,
CREATE_QUERYHEAP = 568,
CREATE_COMMANDSIGNATURE = 569,
LIVE_COMMANDQUEUE = 570,
LIVE_COMMANDALLOCATOR = 571,
LIVE_PIPELINESTATE = 572,
LIVE_COMMANDLIST12 = 573,
LIVE_RESOURCE = 575,
LIVE_DESCRIPTORHEAP = 576,
LIVE_ROOTSIGNATURE = 577,
LIVE_LIBRARY = 578,
LIVE_HEAP = 579,
LIVE_MONITOREDFENCE = 580,
LIVE_QUERYHEAP = 581,
LIVE_COMMANDSIGNATURE = 582,
DESTROY_COMMANDQUEUE = 583,
DESTROY_COMMANDALLOCATOR = 584,
DESTROY_PIPELINESTATE = 585,
DESTROY_COMMANDLIST12 = 586,
DESTROY_RESOURCE = 588,
DESTROY_DESCRIPTORHEAP = 589,
DESTROY_ROOTSIGNATURE = 590,
DESTROY_LIBRARY = 591,
DESTROY_HEAP = 592,
DESTROY_MONITOREDFENCE = 593,
DESTROY_QUERYHEAP = 594,
DESTROY_COMMANDSIGNATURE = 595,
CREATERESOURCE_INVALIDDIMENSIONS = 597,
CREATERESOURCE_INVALIDMISCFLAGS = 599,
CREATERESOURCE_INVALIDARG_RETURN = 602,
CREATERESOURCE_OUTOFMEMORY_RETURN = 603,
CREATERESOURCE_INVALIDDESC = 604,
POSSIBLY_INVALID_SUBRESOURCE_STATE = 607,
INVALID_USE_OF_NON_RESIDENT_RESOURCE = 608,
POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE = 609,
BUNDLE_PIPELINE_STATE_MISMATCH = 610,
PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE = 611,
RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE = 613,
RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = 614,
DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE = 615,
DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = 616,
CREATESHADER_INVALIDBYTECODE = 622,
CREATEHEAP_NULLDESC = 623,
CREATEHEAP_INVALIDSIZE = 624,
CREATEHEAP_UNRECOGNIZEDHEAPTYPE = 625,
CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = 626,
CREATEHEAP_UNRECOGNIZEDMEMORYPOOL = 627,
CREATEHEAP_INVALIDPROPERTIES = 628,
CREATEHEAP_INVALIDALIGNMENT = 629,
CREATEHEAP_UNRECOGNIZEDMISCFLAGS = 630,
CREATEHEAP_INVALIDMISCFLAGS = 631,
CREATEHEAP_INVALIDARG_RETURN = 632,
CREATEHEAP_OUTOFMEMORY_RETURN = 633,
CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES = 634,
CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE = 635,
CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = 636,
CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL = 637,
CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES = 638,
CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS = 639,
CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS = 640,
CREATERESOURCEANDHEAP_INVALIDARG_RETURN = 641,
CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN = 642,
GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE = 643,
GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE = 644,
CREATE_DESCRIPTOR_HEAP_INVALID_DESC = 645,
INVALID_DESCRIPTOR_HANDLE = 646,
CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE = 647,
CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE = 649,
CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC = 650,
CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE = 652,
COPY_DESCRIPTORS_INVALID_RANGES = 653,
COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR = 654,
CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN = 655,
CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT = 656,
CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET = 657,
CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET = 658,
CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH = 659,
CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX = 660,
CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE = 661,
CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK = 662,
CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE = 663,
CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS = 664,
CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION = 665,
CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND = 666,
CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH = 667,
CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH = 668,
CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH = 669,
CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH = 670,
CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN = 671,
CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT = 672,
CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY = 673,
CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE = 674,
CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 = 675,
CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING = 676,
CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH = 677,
CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS = 678,
CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET = 679,
CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET = 680,
CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH = 681,
CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT = 682,
CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS = 683,
CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES = 684,
CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC = 685,
CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH = 686,
CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH = 687,
CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH = 688,
CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH = 689,
CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH = 690,
CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE = 691,
EXECUTE_BUNDLE_OPEN_BUNDLE = 692,
EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH = 693,
EXECUTE_BUNDLE_TYPE = 694,
DRAW_EMPTY_SCISSOR_RECTANGLE = 695,
CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND = 696,
CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED = 697,
CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION = 698,
CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE = 699,
CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES = 700,
CREATERESOURCEANDHEAP_NULLHEAP = 701,
GETRESOURCEALLOCATIONINFO_INVALIDRDESCS = 702,
MAKERESIDENT_NULLOBJECTARRAY = 703,
EVICT_NULLOBJECTARRAY = 705,
SET_DESCRIPTOR_TABLE_INVALID = 708,
SET_ROOT_CONSTANT_INVALID = 709,
SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID = 710,
SET_ROOT_SHADER_RESOURCE_VIEW_INVALID = 711,
SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID = 712,
SET_VERTEX_BUFFERS_INVALID_DESC = 713,
SET_INDEX_BUFFER_INVALID_DESC = 715,
SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC = 717,
CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY = 718,
CREATERESOURCE_UNRECOGNIZEDLAYOUT = 719,
CREATERESOURCE_INVALIDDIMENSIONALITY = 720,
CREATERESOURCE_INVALIDALIGNMENT = 721,
CREATERESOURCE_INVALIDMIPLEVELS = 722,
CREATERESOURCE_INVALIDSAMPLEDESC = 723,
CREATERESOURCE_INVALIDLAYOUT = 724,
SET_INDEX_BUFFER_INVALID = 725,
SET_VERTEX_BUFFERS_INVALID = 726,
SET_STREAM_OUTPUT_BUFFERS_INVALID = 727,
SET_RENDER_TARGETS_INVALID = 728,
CREATEQUERY_HEAP_INVALID_PARAMETERS = 729,
BEGIN_END_QUERY_INVALID_PARAMETERS = 731,
CLOSE_COMMAND_LIST_OPEN_QUERY = 732,
RESOLVE_QUERY_DATA_INVALID_PARAMETERS = 733,
SET_PREDICATION_INVALID_PARAMETERS = 734,
TIMESTAMPS_NOT_SUPPORTED = 735,
CREATERESOURCE_UNRECOGNIZEDFORMAT = 737,
CREATERESOURCE_INVALIDFORMAT = 738,
GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE = 739,
GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET = 740,
// GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE = 739, this enum value conflicts with GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE
// GETCOPYABLELAYOUT_INVALIDBASEOFFSET = 740, this enum value conflicts with GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET
RESOURCE_BARRIER_INVALID_HEAP = 741,
CREATE_SAMPLER_INVALID = 742,
CREATECOMMANDSIGNATURE_INVALID = 743,
EXECUTE_INDIRECT_INVALID_PARAMETERS = 744,
GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION = 745,
CREATERESOURCE_INVALIDCLEARVALUE = 815,
CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT = 816,
CREATERESOURCE_INVALIDCLEARVALUEFORMAT = 817,
CREATERESOURCE_CLEARVALUEDENORMFLUSH = 818,
CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE = 820,
CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE = 821,
MAP_INVALIDHEAP = 822,
UNMAP_INVALIDHEAP = 823,
MAP_INVALIDRESOURCE = 824,
UNMAP_INVALIDRESOURCE = 825,
MAP_INVALIDSUBRESOURCE = 826,
UNMAP_INVALIDSUBRESOURCE = 827,
MAP_INVALIDRANGE = 828,
UNMAP_INVALIDRANGE = 829,
MAP_INVALIDDATAPOINTER = 832,
MAP_INVALIDARG_RETURN = 833,
MAP_OUTOFMEMORY_RETURN = 834,
EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED = 835,
EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH = 836,
EXECUTECOMMANDLISTS_OPENCOMMANDLIST = 837,
EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST = 838,
COPYBUFFERREGION_NULLDST = 839,
COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION = 840,
COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS = 841,
COPYBUFFERREGION_NULLSRC = 842,
COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION = 843,
COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS = 844,
COPYBUFFERREGION_INVALIDCOPYFLAGS = 845,
COPYTEXTUREREGION_NULLDST = 846,
COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE = 847,
COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION = 848,
COPYTEXTUREREGION_INVALIDDSTRESOURCE = 849,
COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE = 850,
COPYTEXTUREREGION_INVALIDDSTOFFSET = 851,
COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT = 852,
COPYTEXTUREREGION_INVALIDDSTFORMAT = 853,
COPYTEXTUREREGION_INVALIDDSTDIMENSIONS = 854,
COPYTEXTUREREGION_INVALIDDSTROWPITCH = 855,
COPYTEXTUREREGION_INVALIDDSTPLACEMENT = 856,
COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT = 857,
COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS = 858,
COPYTEXTUREREGION_NULLSRC = 859,
COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE = 860,
COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION = 861,
COPYTEXTUREREGION_INVALIDSRCRESOURCE = 862,
COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE = 863,
COPYTEXTUREREGION_INVALIDSRCOFFSET = 864,
COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT = 865,
COPYTEXTUREREGION_INVALIDSRCFORMAT = 866,
COPYTEXTUREREGION_INVALIDSRCDIMENSIONS = 867,
COPYTEXTUREREGION_INVALIDSRCROWPITCH = 868,
COPYTEXTUREREGION_INVALIDSRCPLACEMENT = 869,
COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT = 870,
COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS = 871,
COPYTEXTUREREGION_INVALIDDSTCOORDINATES = 872,
COPYTEXTUREREGION_INVALIDSRCBOX = 873,
COPYTEXTUREREGION_FORMATMISMATCH = 874,
COPYTEXTUREREGION_EMPTYBOX = 875,
COPYTEXTUREREGION_INVALIDCOPYFLAGS = 876,
RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX = 877,
RESOLVESUBRESOURCE_INVALID_FORMAT = 878,
RESOLVESUBRESOURCE_RESOURCE_MISMATCH = 879,
RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT = 880,
CREATECOMPUTEPIPELINESTATE_INVALID_SHADER = 881,
CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH = 882,
CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE = 883,
CREATEPIPELINESTATE_INVALIDCACHEDBLOB = 884,
CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH = 885,
CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH = 886,
CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH = 887,
CREATEPIPELINESTATE_CACHEDBLOBIGNORED = 888,
WRITETOSUBRESOURCE_INVALIDHEAP = 889,
WRITETOSUBRESOURCE_INVALIDRESOURCE = 890,
WRITETOSUBRESOURCE_INVALIDBOX = 891,
WRITETOSUBRESOURCE_INVALIDSUBRESOURCE = 892,
WRITETOSUBRESOURCE_EMPTYBOX = 893,
READFROMSUBRESOURCE_INVALIDHEAP = 894,
READFROMSUBRESOURCE_INVALIDRESOURCE = 895,
READFROMSUBRESOURCE_INVALIDBOX = 896,
READFROMSUBRESOURCE_INVALIDSUBRESOURCE = 897,
READFROMSUBRESOURCE_EMPTYBOX = 898,
TOO_MANY_NODES_SPECIFIED = 899,
INVALID_NODE_INDEX = 900,
GETHEAPPROPERTIES_INVALIDRESOURCE = 901,
NODE_MASK_MISMATCH = 902,
COMMAND_LIST_OUTOFMEMORY = 903,
COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES = 904,
COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES = 905,
COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES = 906,
EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE = 907,
COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS = 908,
CREATE_QUEUE_INVALID_TYPE = 909,
CREATE_QUEUE_INVALID_FLAGS = 910,
CREATESHAREDRESOURCE_INVALIDFLAGS = 911,
CREATESHAREDRESOURCE_INVALIDFORMAT = 912,
CREATESHAREDHEAP_INVALIDFLAGS = 913,
REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES = 914,
REFLECTSHAREDPROPERTIES_INVALIDSIZE = 915,
REFLECTSHAREDPROPERTIES_INVALIDOBJECT = 916,
KEYEDMUTEX_INVALIDOBJECT = 917,
KEYEDMUTEX_INVALIDKEY = 918,
KEYEDMUTEX_WRONGSTATE = 919,
CREATE_QUEUE_INVALID_PRIORITY = 920,
OBJECT_DELETED_WHILE_STILL_IN_USE = 921,
CREATEPIPELINESTATE_INVALID_FLAGS = 922,
HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE = 923,
COMMAND_LIST_DRAW_RENDER_TARGET_DELETED = 924,
CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT = 925,
HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS = 926,
EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED = 927,
UNMAP_RANGE_NOT_EMPTY = 929,
MAP_INVALID_NULLRANGE = 930,
UNMAP_INVALID_NULLRANGE = 931,
NO_GRAPHICS_API_SUPPORT = 932,
NO_COMPUTE_API_SUPPORT = 933,
RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED = 934,
GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED = 935,
GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS = 936,
GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS = 937,
GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED = 938,
GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH = 939,
GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH = 940,
GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH = 941,
GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE = 942,
COPYRESOURCE_NULLDST = 943,
COPYRESOURCE_INVALIDDSTRESOURCE = 944,
COPYRESOURCE_NULLSRC = 945,
COPYRESOURCE_INVALIDSRCRESOURCE = 946,
RESOLVESUBRESOURCE_NULLDST = 947,
RESOLVESUBRESOURCE_INVALIDDSTRESOURCE = 948,
RESOLVESUBRESOURCE_NULLSRC = 949,
RESOLVESUBRESOURCE_INVALIDSRCRESOURCE = 950,
PIPELINE_STATE_TYPE_MISMATCH = 951,
COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET = 952,
COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH = 953,
RESOURCE_BARRIER_ZERO_BARRIERS = 954,
BEGIN_END_EVENT_MISMATCH = 955,
RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH = 956,
RESOURCE_BARRIER_MISMATCHING_BEGIN_END = 957,
GPU_BASED_VALIDATION_INVALID_RESOURCE = 958,
USE_OF_ZERO_REFCOUNT_OBJECT = 959,
OBJECT_EVICTED_WHILE_STILL_IN_USE = 960,
GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS = 961,
CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB = 962,
CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH = 963,
CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH = 964,
CREATEPIPELINELIBRARY_UNSUPPORTED = 965,
CREATE_PIPELINELIBRARY = 966,
LIVE_PIPELINELIBRARY = 967,
DESTROY_PIPELINELIBRARY = 968,
STOREPIPELINE_NONAME = 969,
STOREPIPELINE_DUPLICATENAME = 970,
LOADPIPELINE_NAMENOTFOUND = 971,
LOADPIPELINE_INVALIDDESC = 972,
PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY = 973,
CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH = 974,
SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS = 975,
CREATE_QUEUE_VIDEO_NOT_SUPPORTED = 976,
CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED = 977,
CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED = 978,
CREATE_VIDEODECODECOMMANDLIST = 979,
CREATE_VIDEODECODER = 980,
CREATE_VIDEODECODESTREAM = 981,
LIVE_VIDEODECODECOMMANDLIST = 982,
LIVE_VIDEODECODER = 983,
LIVE_VIDEODECODESTREAM = 984,
DESTROY_VIDEODECODECOMMANDLIST = 985,
DESTROY_VIDEODECODER = 986,
DESTROY_VIDEODECODESTREAM = 987,
DECODE_FRAME_INVALID_PARAMETERS = 988,
DEPRECATED_API = 989,
RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE = 990,
COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET = 991,
COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET = 992,
COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET = 993,
COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET = 994,
DISCARD_INVALID_SUBRESOURCE_RANGE = 995,
DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS = 996,
DISCARD_NO_RECTS_FOR_NON_TEXTURE2D = 997,
COPY_ON_SAME_SUBRESOURCE = 998,
SETRESIDENCYPRIORITY_INVALID_PAGEABLE = 999,
GPU_BASED_VALIDATION_UNSUPPORTED = 1000,
STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE = 1001,
DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE = 1002,
DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE = 1003,
EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET = 1004,
GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS = 1005,
GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH = 1006,
CREATE_FENCE_INVALID_FLAGS = 1007,
RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS = 1008,
SETRESIDENCYPRIORITY_INVALID_PRIORITY = 1009,
CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS = 1013,
BEGIN_EVENT = 1014,
END_EVENT = 1015,
CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS = 1016,
CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED = 1017,
CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT = 1018,
CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT = 1019,
CREATEPIPELINESTATE_ZERO_SIZE_STREAM = 1020,
CREATEPIPELINESTATE_INVALID_STREAM = 1021,
CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE = 1022,
COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH = 1023,
CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME = 1024,
CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME = 1025,
ATOMICCOPYBUFFER_INVALID_ARCHITECTURE = 1026,
ATOMICCOPYBUFFER_NULL_DST = 1027,
ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION = 1028,
ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS = 1029,
ATOMICCOPYBUFFER_NULL_SRC = 1030,
ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION = 1031,
ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS = 1032,
ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT = 1033,
ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES = 1034,
ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES = 1035,
ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE = 1036,
ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE = 1037,
ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS = 1038,
ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS = 1039,
ATOMICCOPYBUFFER_ZERO_DEPENDENCIES = 1040,
DEVICE_CREATE_SHARED_HANDLE_INVALIDARG = 1041,
DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE = 1042,
SETDEPTHBOUNDS_INVALIDARGS = 1043,
GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE = 1044,
COMMAND_LIST_PIPELINE_STATE_NOT_SET = 1045,
CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH = 1046,
OBJECT_ACCESSED_WHILE_STILL_IN_USE = 1047,
PROGRAMMABLE_MSAA_UNSUPPORTED = 1048,
SETSAMPLEPOSITIONS_INVALIDARGS = 1049,
RESOLVESUBRESOURCEREGION_INVALID_RECT = 1050,
CREATE_VIDEODECODECOMMANDQUEUE = 1051,
CREATE_VIDEOPROCESSCOMMANDLIST = 1052,
CREATE_VIDEOPROCESSCOMMANDQUEUE = 1053,
LIVE_VIDEODECODECOMMANDQUEUE = 1054,
LIVE_VIDEOPROCESSCOMMANDLIST = 1055,
LIVE_VIDEOPROCESSCOMMANDQUEUE = 1056,
DESTROY_VIDEODECODECOMMANDQUEUE = 1057,
DESTROY_VIDEOPROCESSCOMMANDLIST = 1058,
DESTROY_VIDEOPROCESSCOMMANDQUEUE = 1059,
CREATE_VIDEOPROCESSOR = 1060,
CREATE_VIDEOPROCESSSTREAM = 1061,
LIVE_VIDEOPROCESSOR = 1062,
LIVE_VIDEOPROCESSSTREAM = 1063,
DESTROY_VIDEOPROCESSOR = 1064,
DESTROY_VIDEOPROCESSSTREAM = 1065,
PROCESS_FRAME_INVALID_PARAMETERS = 1066,
COPY_INVALIDLAYOUT = 1067,
CREATE_CRYPTO_SESSION = 1068,
CREATE_CRYPTO_SESSION_POLICY = 1069,
CREATE_PROTECTED_RESOURCE_SESSION = 1070,
LIVE_CRYPTO_SESSION = 1071,
LIVE_CRYPTO_SESSION_POLICY = 1072,
LIVE_PROTECTED_RESOURCE_SESSION = 1073,
DESTROY_CRYPTO_SESSION = 1074,
DESTROY_CRYPTO_SESSION_POLICY = 1075,
DESTROY_PROTECTED_RESOURCE_SESSION = 1076,
PROTECTED_RESOURCE_SESSION_UNSUPPORTED = 1077,
FENCE_INVALIDOPERATION = 1078,
CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED = 1079,
SAMPLEPOSITIONS_MISMATCH_DEFERRED = 1080,
SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE = 1081,
SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR = 1082,
CREATE_VIDEODECODERHEAP = 1083,
LIVE_VIDEODECODERHEAP = 1084,
DESTROY_VIDEODECODERHEAP = 1085,
OPENEXISTINGHEAP_INVALIDARG_RETURN = 1086,
OPENEXISTINGHEAP_OUTOFMEMORY_RETURN = 1087,
OPENEXISTINGHEAP_INVALIDADDRESS = 1088,
OPENEXISTINGHEAP_INVALIDHANDLE = 1089,
WRITEBUFFERIMMEDIATE_INVALID_DEST = 1090,
WRITEBUFFERIMMEDIATE_INVALID_MODE = 1091,
WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT = 1092,
WRITEBUFFERIMMEDIATE_NOT_SUPPORTED = 1093,
SETVIEWINSTANCEMASK_INVALIDARGS = 1094,
VIEW_INSTANCING_UNSUPPORTED = 1095,
VIEW_INSTANCING_INVALIDARGS = 1096,
COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = 1097,
COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = 1098,
CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE = 1099,
CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED = 1100,
VIDEO_DECODE_SUPPORT_INVALID_INPUT = 1101,
CREATE_VIDEO_DECODER_UNSUPPORTED = 1102,
CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR = 1103,
CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED = 1104,
CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR = 1105,
NO_VIDEO_API_SUPPORT = 1106,
VIDEO_PROCESS_SUPPORT_INVALID_INPUT = 1107,
CREATE_VIDEO_PROCESSOR_CAPS_FAILURE = 1108,
VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT = 1109,
VIDEO_DECODE_FRAME_INVALID_ARGUMENT = 1110,
ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS = 1111,
OPENEXISTINGHEAP_UNSUPPORTED = 1112,
VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT = 1113,
VIDEO_DECODE_SUPPORT_UNSUPPORTED = 1114,
CREATE_COMMANDRECORDER = 1115,
LIVE_COMMANDRECORDER = 1116,
DESTROY_COMMANDRECORDER = 1117,
CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED = 1118,
CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS = 1119,
CREATE_COMMAND_RECORDER_INVALID_FLAGS = 1120,
CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS = 1121,
CREATE_COMMANDPOOL = 1122,
LIVE_COMMANDPOOL = 1123,
DESTROY_COMMANDPOOL = 1124,
CREATE_COMMAND_POOL_INVALID_FLAGS = 1125,
CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED = 1126,
COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH = 1127,
COMMAND_RECORDER_CONTENTION = 1128,
COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST = 1129,
COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST = 1130,
CANNOT_EXECUTE_EMPTY_COMMAND_LIST = 1131,
CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS = 1132,
CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET = 1133,
CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING = 1134,
COMMAND_POOL_SYNC = 1135,
EVICT_UNDERFLOW = 1136,
CREATE_META_COMMAND = 1137,
LIVE_META_COMMAND = 1138,
DESTROY_META_COMMAND = 1139,
COPYBUFFERREGION_INVALID_DST_RESOURCE = 1140,
COPYBUFFERREGION_INVALID_SRC_RESOURCE = 1141,
ATOMICCOPYBUFFER_INVALID_DST_RESOURCE = 1142,
ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE = 1143,
CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER = 1144,
CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC = 1145,
CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED = 1146,
CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION = 1147,
CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS = 1148,
CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET = 1149,
CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION = 1150,
CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS = 1151,
CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN = 1152,
CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER = 1153,
UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES = 1154,
CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE = 1155,
CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS = 1156,
COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED = 1157,
BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = 1158,
EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID = 1159,
COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = 1160,
DISPATCH_RAYS_INVALID = 1161,
GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID = 1162,
CREATE_LIFETIMETRACKER = 1163,
LIVE_LIFETIMETRACKER = 1164,
DESTROY_LIFETIMETRACKER = 1165,
DESTROYOWNEDOBJECT_OBJECTNOTOWNED = 1166,
CREATE_TRACKEDWORKLOAD = 1167,
LIVE_TRACKEDWORKLOAD = 1168,
DESTROY_TRACKEDWORKLOAD = 1169,
RENDER_PASS_ERROR = 1170,
META_COMMAND_ID_INVALID = 1171,
META_COMMAND_UNSUPPORTED_PARAMS = 1172,
META_COMMAND_FAILED_ENUMERATION = 1173,
META_COMMAND_PARAMETER_SIZE_MISMATCH = 1174,
UNINITIALIZED_META_COMMAND = 1175,
META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS = 1176,
CREATE_VIDEOENCODECOMMANDLIST = 1177,
LIVE_VIDEOENCODECOMMANDLIST = 1178,
DESTROY_VIDEOENCODECOMMANDLIST = 1179,
CREATE_VIDEOENCODECOMMANDQUEUE = 1180,
LIVE_VIDEOENCODECOMMANDQUEUE = 1181,
DESTROY_VIDEOENCODECOMMANDQUEUE = 1182,
CREATE_VIDEOMOTIONESTIMATOR = 1183,
LIVE_VIDEOMOTIONESTIMATOR = 1184,
DESTROY_VIDEOMOTIONESTIMATOR = 1185,
CREATE_VIDEOMOTIONVECTORHEAP = 1186,
LIVE_VIDEOMOTIONVECTORHEAP = 1187,
DESTROY_VIDEOMOTIONVECTORHEAP = 1188,
MULTIPLE_TRACKED_WORKLOADS = 1189,
MULTIPLE_TRACKED_WORKLOAD_PAIRS = 1190,
OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR = 1191,
CANNOT_ADD_TRACKED_WORKLOAD = 1192,
INCOMPLETE_TRACKED_WORKLOAD_PAIR = 1193,
CREATE_STATE_OBJECT_ERROR = 1194,
GET_SHADER_IDENTIFIER_ERROR = 1195,
GET_SHADER_STACK_SIZE_ERROR = 1196,
GET_PIPELINE_STACK_SIZE_ERROR = 1197,
SET_PIPELINE_STACK_SIZE_ERROR = 1198,
GET_SHADER_IDENTIFIER_SIZE_INVALID = 1199,
CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID = 1200,
CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE = 1201,
RENDER_PASS_INVALID_RESOURCE_BARRIER = 1202,
RENDER_PASS_DISALLOWED_API_CALLED = 1203,
RENDER_PASS_CANNOT_NEST_RENDER_PASSES = 1204,
RENDER_PASS_CANNOT_END_WITHOUT_BEGIN = 1205,
RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST = 1206,
RENDER_PASS_GPU_WORK_WHILE_SUSPENDED = 1207,
RENDER_PASS_MISMATCHING_SUSPEND_RESUME = 1208,
RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS = 1209,
RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS = 1210,
TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH = 1211,
TRACKED_WORKLOAD_NOT_SUPPORTED = 1212,
RENDER_PASS_MISMATCHING_NO_ACCESS = 1213,
RENDER_PASS_UNSUPPORTED_RESOLVE = 1214,
CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR = 1215,
WINDOWS7_FENCE_OUTOFORDER_SIGNAL = 1216,
WINDOWS7_FENCE_OUTOFORDER_WAIT = 1217,
VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT = 1218,
VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = 1219,
ESTIMATE_MOTION_INVALID_ARGUMENT = 1220,
RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = 1221,
GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE = 1222,
SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT = 1223,
CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL = 1224,
CREATE_VIDEOEXTENSIONCOMMAND = 1225,
LIVE_VIDEOEXTENSIONCOMMAND = 1226,
DESTROY_VIDEOEXTENSIONCOMMAND = 1227,
INVALID_VIDEO_EXTENSION_COMMAND_ID = 1228,
VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT = 1229,
CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY = 1230,
VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR = 1231,
GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = 1232,
RSSETSHADING_RATE_INVALID_SHADING_RATE = 1233,
RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP = 1234,
RSSETSHADING_RATE_INVALID_COMBINER = 1235,
RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2 = 1236,
RSSETSHADINGRATE_REQUIRES_TIER_1 = 1237,
SHADING_RATE_IMAGE_INCORRECT_FORMAT = 1238,
SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE = 1239,
SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL = 1240,
SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT = 1241,
SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY = 1242,
NON_RETAIL_SHADER_MODEL_WONT_VALIDATE = 1243,
CREATEGRAPHICSPIPELINESTATE_AS_ROOT_SIGNATURE_MISMATCH = 1244,
CREATEGRAPHICSPIPELINESTATE_MS_ROOT_SIGNATURE_MISMATCH = 1245,
ADD_TO_STATE_OBJECT_ERROR = 1246,
CREATE_PROTECTED_RESOURCE_SESSION_INVALID_ARGUMENT = 1247,
CREATEGRAPHICSPIPELINESTATE_MS_PSO_DESC_MISMATCH = 1248,
CREATEPIPELINESTATE_MS_INCOMPLETE_TYPE = 1249,
CREATEGRAPHICSPIPELINESTATE_AS_NOT_MS_MISMATCH = 1250,
CREATEGRAPHICSPIPELINESTATE_MS_NOT_PS_MISMATCH = 1251,
NONZERO_SAMPLER_FEEDBACK_MIP_REGION_WITH_INCOMPATIBLE_FORMAT = 1252,
CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_SHADER_MISMATCH = 1253,
EMPTY_DISPATCH = 1254,
RESOURCE_FORMAT_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY = 1255,
SAMPLER_FEEDBACK_MAP_INVALID_MIP_REGION = 1256,
SAMPLER_FEEDBACK_MAP_INVALID_DIMENSION = 1257,
SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_COUNT = 1258,
SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_QUALITY = 1259,
SAMPLER_FEEDBACK_MAP_INVALID_LAYOUT = 1260,
SAMPLER_FEEDBACK_MAP_REQUIRES_UNORDERED_ACCESS_FLAG = 1261,
SAMPLER_FEEDBACK_CREATE_UAV_NULL_ARGUMENTS = 1262,
SAMPLER_FEEDBACK_UAV_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY = 1263,
SAMPLER_FEEDBACK_CREATE_UAV_REQUIRES_FEEDBACK_MAP_FORMAT = 1264,
CREATEMESHSHADER_INVALIDSHADERBYTECODE = 1265,
CREATEMESHSHADER_OUTOFMEMORY = 1266,
CREATEMESHSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE = 1267,
RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_INVALID_FORMAT = 1268,
RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_INVALID_MIP_LEVEL_COUNT = 1269,
RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_ARRAY_SIZE_MISMATCH = 1270,
SAMPLER_FEEDBACK_CREATE_UAV_MISMATCHING_TARGETED_RESOURCE = 1271,
CREATEMESHSHADER_OUTPUTEXCEEDSMAXSIZE = 1272,
CREATEMESHSHADER_GROUPSHAREDEXCEEDSMAXSIZE = 1273,
VERTEX_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = 1274,
MESH_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = 1275,
CREATEMESHSHADER_MISMATCHEDASMSPAYLOADSIZE = 1276,
CREATE_ROOT_SIGNATURE_UNBOUNDED_STATIC_DESCRIPTORS = 1277,
CREATEAMPLIFICATIONSHADER_INVALIDSHADERBYTECODE = 1278,
CREATEAMPLIFICATIONSHADER_OUTOFMEMORY = 1279,
CREATE_SHADERCACHESESSION = 1280,
LIVE_SHADERCACHESESSION = 1281,
DESTROY_SHADERCACHESESSION = 1282,
CREATESHADERCACHESESSION_INVALIDARGS = 1283,
CREATESHADERCACHESESSION_DISABLED = 1284,
CREATESHADERCACHESESSION_ALREADYOPEN = 1285,
SHADERCACHECONTROL_DEVELOPERMODE = 1286,
SHADERCACHECONTROL_INVALIDFLAGS = 1287,
SHADERCACHECONTROL_STATEALREADYSET = 1288,
SHADERCACHECONTROL_IGNOREDFLAG = 1289,
SHADERCACHESESSION_STOREVALUE_ALREADYPRESENT = 1290,
SHADERCACHESESSION_STOREVALUE_HASHCOLLISION = 1291,
SHADERCACHESESSION_STOREVALUE_CACHEFULL = 1292,
SHADERCACHESESSION_FINDVALUE_NOTFOUND = 1293,
SHADERCACHESESSION_CORRUPT = 1294,
SHADERCACHESESSION_DISABLED = 1295,
OVERSIZED_DISPATCH = 1296,
CREATE_VIDEOENCODER = 1297,
LIVE_VIDEOENCODER = 1298,
DESTROY_VIDEOENCODER = 1299,
CREATE_VIDEOENCODERHEAP = 1300,
LIVE_VIDEOENCODERHEAP = 1301,
DESTROY_VIDEOENCODERHEAP = 1302,
COPYTEXTUREREGION_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG = 1303,
COPYRESOURCE_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG = 1304,
ENCODE_FRAME_INVALID_PARAMETERS = 1305,
ENCODE_FRAME_UNSUPPORTED_PARAMETERS = 1306,
RESOLVE_ENCODER_OUTPUT_METADATA_INVALID_PARAMETERS = 1307,
RESOLVE_ENCODER_OUTPUT_METADATA_UNSUPPORTED_PARAMETERS = 1308,
CREATE_VIDEO_ENCODER_INVALID_PARAMETERS = 1309,
CREATE_VIDEO_ENCODER_UNSUPPORTED_PARAMETERS = 1310,
CREATE_VIDEO_ENCODER_HEAP_INVALID_PARAMETERS = 1311,
CREATE_VIDEO_ENCODER_HEAP_UNSUPPORTED_PARAMETERS = 1312,
CREATECOMMANDLIST_NULL_COMMANDALLOCATOR = 1313,
CLEAR_UNORDERED_ACCESS_VIEW_INVALID_DESCRIPTOR_HANDLE = 1314,
DESCRIPTOR_HEAP_NOT_SHADER_VISIBLE = 1315,
CREATEBLENDSTATE_BLENDOP_WARNING = 1316,
CREATEBLENDSTATE_BLENDOPALPHA_WARNING = 1317,
WRITE_COMBINE_PERFORMANCE_WARNING = 1318,
RESOLVE_QUERY_INVALID_QUERY_STATE = 1319,
SETPRIVATEDATA_NO_ACCESS = 1320,
COMMAND_LIST_STATIC_DESCRIPTOR_SAMPLER_MODE_MISMATCH = 1321,
GETCOPYABLEFOOTPRINTS_UNSUPPORTED_BUFFER_WIDTH = 1322,
CREATEMESHSHADER_TOPOLOGY_MISMATCH = 1323,
VRS_SUM_COMBINER_REQUIRES_CAPABILITY = 1324,
SETTING_SHADING_RATE_FROM_MS_REQUIRES_CAPABILITY = 1325,
SHADERCACHESESSION_SHADERCACHEDELETE_NOTSUPPORTED = 1326,
SHADERCACHECONTROL_SHADERCACHECLEAR_NOTSUPPORTED = 1327,
D3D12_MESSAGES_END = 1328,
};
pub const D3D12_MESSAGE_ID_UNKNOWN = D3D12_MESSAGE_ID.UNKNOWN;
pub const D3D12_MESSAGE_ID_STRING_FROM_APPLICATION = D3D12_MESSAGE_ID.STRING_FROM_APPLICATION;
pub const D3D12_MESSAGE_ID_CORRUPTED_THIS = D3D12_MESSAGE_ID.CORRUPTED_THIS;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER1;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER2;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER3;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER4;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER5;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER6;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER7;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER8;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER9;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER10;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER11;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER12;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER13;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER14;
pub const D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15 = D3D12_MESSAGE_ID.CORRUPTED_PARAMETER15;
pub const D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING = D3D12_MESSAGE_ID.CORRUPTED_MULTITHREADING;
pub const D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY = D3D12_MESSAGE_ID.MESSAGE_REPORTING_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA = D3D12_MESSAGE_ID.GETPRIVATEDATA_MOREDATA;
pub const D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA = D3D12_MESSAGE_ID.SETPRIVATEDATA_INVALIDFREEDATA;
pub const D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS = D3D12_MESSAGE_ID.SETPRIVATEDATA_CHANGINGPARAMS;
pub const D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY = D3D12_MESSAGE_ID.SETPRIVATEDATA_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT = D3D12_MESSAGE_ID.CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT;
pub const D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC = D3D12_MESSAGE_ID.CREATESHADERRESOURCEVIEW_INVALIDDESC;
pub const D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT = D3D12_MESSAGE_ID.CREATESHADERRESOURCEVIEW_INVALIDFORMAT;
pub const D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE = D3D12_MESSAGE_ID.CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE;
pub const D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE = D3D12_MESSAGE_ID.CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE;
pub const D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS = D3D12_MESSAGE_ID.CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS;
pub const D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE = D3D12_MESSAGE_ID.CREATESHADERRESOURCEVIEW_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT = D3D12_MESSAGE_ID.CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT;
pub const D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT = D3D12_MESSAGE_ID.CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT;
pub const D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC = D3D12_MESSAGE_ID.CREATERENDERTARGETVIEW_INVALIDDESC;
pub const D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT = D3D12_MESSAGE_ID.CREATERENDERTARGETVIEW_INVALIDFORMAT;
pub const D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE = D3D12_MESSAGE_ID.CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE;
pub const D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE = D3D12_MESSAGE_ID.CREATERENDERTARGETVIEW_INVALIDPLANESLICE;
pub const D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS = D3D12_MESSAGE_ID.CREATERENDERTARGETVIEW_INVALIDDIMENSIONS;
pub const D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE = D3D12_MESSAGE_ID.CREATERENDERTARGETVIEW_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILVIEW_INVALIDDESC;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILVIEW_INVALIDFORMAT;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_TOOMANYELEMENTS;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_INVALIDFORMAT;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_INVALIDSLOT;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_INVALIDALIGNMENT;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_DUPLICATESEMANTIC;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_NULLSEMANTIC;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_MISSINGELEMENT;
pub const D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEVERTEXSHADER_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATEVERTEXSHADER_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE = D3D12_MESSAGE_ID.CREATEVERTEXSHADER_INVALIDSHADERTYPE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADER_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADER_INVALIDSHADERTYPE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE;
pub const D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEPIXELSHADER_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATEPIXELSHADER_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE = D3D12_MESSAGE_ID.CREATEPIXELSHADER_INVALIDSHADERTYPE;
pub const D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE = D3D12_MESSAGE_ID.CREATERASTERIZERSTATE_INVALIDFILLMODE;
pub const D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE = D3D12_MESSAGE_ID.CREATERASTERIZERSTATE_INVALIDCULLMODE;
pub const D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP = D3D12_MESSAGE_ID.CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP;
pub const D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS = D3D12_MESSAGE_ID.CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND = D3D12_MESSAGE_ID.CREATEBLENDSTATE_INVALIDSRCBLEND;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND = D3D12_MESSAGE_ID.CREATEBLENDSTATE_INVALIDDESTBLEND;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP = D3D12_MESSAGE_ID.CREATEBLENDSTATE_INVALIDBLENDOP;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA = D3D12_MESSAGE_ID.CREATEBLENDSTATE_INVALIDSRCBLENDALPHA;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA = D3D12_MESSAGE_ID.CREATEBLENDSTATE_INVALIDDESTBLENDALPHA;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA = D3D12_MESSAGE_ID.CREATEBLENDSTATE_INVALIDBLENDOPALPHA;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK = D3D12_MESSAGE_ID.CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK;
pub const D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID = D3D12_MESSAGE_ID.CLEARDEPTHSTENCILVIEW_INVALID;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED;
pub const D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT = D3D12_MESSAGE_ID.DEVICE_REMOVAL_PROCESS_AT_FAULT;
pub const D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT = D3D12_MESSAGE_ID.DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT;
pub const D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT = D3D12_MESSAGE_ID.DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_TYPE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT = D3D12_MESSAGE_ID.CREATEINPUTLAYOUT_EMPTY_LAYOUT;
pub const D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY = D3D12_MESSAGE_ID.LIVE_OBJECT_SUMMARY;
pub const D3D12_MESSAGE_ID_LIVE_DEVICE = D3D12_MESSAGE_ID.LIVE_DEVICE;
pub const D3D12_MESSAGE_ID_LIVE_SWAPCHAIN = D3D12_MESSAGE_ID.LIVE_SWAPCHAIN;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILVIEW_INVALIDFLAGS;
pub const D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE = D3D12_MESSAGE_ID.CREATEVERTEXSHADER_INVALIDCLASSLINKAGE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER;
pub const D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE = D3D12_MESSAGE_ID.CREATEPIXELSHADER_INVALIDCLASSLINKAGE;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES;
pub const D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES = D3D12_MESSAGE_ID.CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES;
pub const D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEHULLSHADER_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATEHULLSHADER_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE = D3D12_MESSAGE_ID.CREATEHULLSHADER_INVALIDSHADERTYPE;
pub const D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE = D3D12_MESSAGE_ID.CREATEHULLSHADER_INVALIDCLASSLINKAGE;
pub const D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEDOMAINSHADER_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATEDOMAINSHADER_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE = D3D12_MESSAGE_ID.CREATEDOMAINSHADER_INVALIDSHADERTYPE;
pub const D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE = D3D12_MESSAGE_ID.CREATEDOMAINSHADER_INVALIDCLASSLINKAGE;
pub const D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED = D3D12_MESSAGE_ID.RESOURCE_UNMAP_NOTMAPPED;
pub const D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE = D3D12_MESSAGE_ID.DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE;
pub const D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATECOMPUTESHADER_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATECOMPUTESHADER_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE = D3D12_MESSAGE_ID.CREATECOMPUTESHADER_INVALIDCLASSLINKAGE;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE = D3D12_MESSAGE_ID.CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC = D3D12_MESSAGE_ID.CREATEUNORDEREDACCESSVIEW_INVALIDDESC;
pub const D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT = D3D12_MESSAGE_ID.CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT;
pub const D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE = D3D12_MESSAGE_ID.CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE;
pub const D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE = D3D12_MESSAGE_ID.CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE;
pub const D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS = D3D12_MESSAGE_ID.CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS;
pub const D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT = D3D12_MESSAGE_ID.CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT;
pub const D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS = D3D12_MESSAGE_ID.CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS;
pub const D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT = D3D12_MESSAGE_ID.CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS = D3D12_MESSAGE_ID.CREATEBLENDSTATE_INVALIDLOGICOPS;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED = D3D12_MESSAGE_ID.DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED;
pub const D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT = D3D12_MESSAGE_ID.DEVICE_CLEARVIEW_INVALIDSOURCERECT;
pub const D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT = D3D12_MESSAGE_ID.DEVICE_CLEARVIEW_EMPTYRECT;
pub const D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER = D3D12_MESSAGE_ID.UPDATETILEMAPPINGS_INVALID_PARAMETER;
pub const D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER = D3D12_MESSAGE_ID.COPYTILEMAPPINGS_INVALID_PARAMETER;
pub const D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS = D3D12_MESSAGE_ID.CREATEDEVICE_INVALIDARGS;
pub const D3D12_MESSAGE_ID_CREATEDEVICE_WARNING = D3D12_MESSAGE_ID.CREATEDEVICE_WARNING;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_TYPE;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER = D3D12_MESSAGE_ID.RESOURCE_BARRIER_NULL_POINTER;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_SUBRESOURCE;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS = D3D12_MESSAGE_ID.RESOURCE_BARRIER_RESERVED_BITS;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS = D3D12_MESSAGE_ID.RESOURCE_BARRIER_MISSING_BIND_FLAGS;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS = D3D12_MESSAGE_ID.RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES = D3D12_MESSAGE_ID.RESOURCE_BARRIER_MATCHING_STATES;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_COMBINATION;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH = D3D12_MESSAGE_ID.RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_RESOURCE;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT = D3D12_MESSAGE_ID.RESOURCE_BARRIER_SAMPLE_COUNT;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_FLAGS;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_COMBINED_FLAGS;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_SPLIT_BARRIER;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END = D3D12_MESSAGE_ID.RESOURCE_BARRIER_UNMATCHED_END;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN = D3D12_MESSAGE_ID.RESOURCE_BARRIER_UNMATCHED_BEGIN;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_FLAG;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE;
pub const D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE = D3D12_MESSAGE_ID.INVALID_SUBRESOURCE_STATE;
pub const D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION = D3D12_MESSAGE_ID.COMMAND_ALLOCATOR_CONTENTION;
pub const D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET = D3D12_MESSAGE_ID.COMMAND_ALLOCATOR_RESET;
pub const D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE = D3D12_MESSAGE_ID.COMMAND_ALLOCATOR_RESET_BUNDLE;
pub const D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET = D3D12_MESSAGE_ID.COMMAND_ALLOCATOR_CANNOT_RESET;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_OPEN = D3D12_MESSAGE_ID.COMMAND_LIST_OPEN;
pub const D3D12_MESSAGE_ID_INVALID_BUNDLE_API = D3D12_MESSAGE_ID.INVALID_BUNDLE_API;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED = D3D12_MESSAGE_ID.COMMAND_LIST_CLOSED;
pub const D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE = D3D12_MESSAGE_ID.WRONG_COMMAND_ALLOCATOR_TYPE;
pub const D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC = D3D12_MESSAGE_ID.COMMAND_ALLOCATOR_SYNC;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_SYNC = D3D12_MESSAGE_ID.COMMAND_LIST_SYNC;
pub const D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID = D3D12_MESSAGE_ID.SET_DESCRIPTOR_HEAP_INVALID;
pub const D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE = D3D12_MESSAGE_ID.CREATE_COMMANDQUEUE;
pub const D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR = D3D12_MESSAGE_ID.CREATE_COMMANDALLOCATOR;
pub const D3D12_MESSAGE_ID_CREATE_PIPELINESTATE = D3D12_MESSAGE_ID.CREATE_PIPELINESTATE;
pub const D3D12_MESSAGE_ID_CREATE_COMMANDLIST12 = D3D12_MESSAGE_ID.CREATE_COMMANDLIST12;
pub const D3D12_MESSAGE_ID_CREATE_RESOURCE = D3D12_MESSAGE_ID.CREATE_RESOURCE;
pub const D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP = D3D12_MESSAGE_ID.CREATE_DESCRIPTORHEAP;
pub const D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE = D3D12_MESSAGE_ID.CREATE_ROOTSIGNATURE;
pub const D3D12_MESSAGE_ID_CREATE_LIBRARY = D3D12_MESSAGE_ID.CREATE_LIBRARY;
pub const D3D12_MESSAGE_ID_CREATE_HEAP = D3D12_MESSAGE_ID.CREATE_HEAP;
pub const D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE = D3D12_MESSAGE_ID.CREATE_MONITOREDFENCE;
pub const D3D12_MESSAGE_ID_CREATE_QUERYHEAP = D3D12_MESSAGE_ID.CREATE_QUERYHEAP;
pub const D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE = D3D12_MESSAGE_ID.CREATE_COMMANDSIGNATURE;
pub const D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE = D3D12_MESSAGE_ID.LIVE_COMMANDQUEUE;
pub const D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR = D3D12_MESSAGE_ID.LIVE_COMMANDALLOCATOR;
pub const D3D12_MESSAGE_ID_LIVE_PIPELINESTATE = D3D12_MESSAGE_ID.LIVE_PIPELINESTATE;
pub const D3D12_MESSAGE_ID_LIVE_COMMANDLIST12 = D3D12_MESSAGE_ID.LIVE_COMMANDLIST12;
pub const D3D12_MESSAGE_ID_LIVE_RESOURCE = D3D12_MESSAGE_ID.LIVE_RESOURCE;
pub const D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP = D3D12_MESSAGE_ID.LIVE_DESCRIPTORHEAP;
pub const D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE = D3D12_MESSAGE_ID.LIVE_ROOTSIGNATURE;
pub const D3D12_MESSAGE_ID_LIVE_LIBRARY = D3D12_MESSAGE_ID.LIVE_LIBRARY;
pub const D3D12_MESSAGE_ID_LIVE_HEAP = D3D12_MESSAGE_ID.LIVE_HEAP;
pub const D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE = D3D12_MESSAGE_ID.LIVE_MONITOREDFENCE;
pub const D3D12_MESSAGE_ID_LIVE_QUERYHEAP = D3D12_MESSAGE_ID.LIVE_QUERYHEAP;
pub const D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE = D3D12_MESSAGE_ID.LIVE_COMMANDSIGNATURE;
pub const D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE = D3D12_MESSAGE_ID.DESTROY_COMMANDQUEUE;
pub const D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR = D3D12_MESSAGE_ID.DESTROY_COMMANDALLOCATOR;
pub const D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE = D3D12_MESSAGE_ID.DESTROY_PIPELINESTATE;
pub const D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12 = D3D12_MESSAGE_ID.DESTROY_COMMANDLIST12;
pub const D3D12_MESSAGE_ID_DESTROY_RESOURCE = D3D12_MESSAGE_ID.DESTROY_RESOURCE;
pub const D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP = D3D12_MESSAGE_ID.DESTROY_DESCRIPTORHEAP;
pub const D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE = D3D12_MESSAGE_ID.DESTROY_ROOTSIGNATURE;
pub const D3D12_MESSAGE_ID_DESTROY_LIBRARY = D3D12_MESSAGE_ID.DESTROY_LIBRARY;
pub const D3D12_MESSAGE_ID_DESTROY_HEAP = D3D12_MESSAGE_ID.DESTROY_HEAP;
pub const D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE = D3D12_MESSAGE_ID.DESTROY_MONITOREDFENCE;
pub const D3D12_MESSAGE_ID_DESTROY_QUERYHEAP = D3D12_MESSAGE_ID.DESTROY_QUERYHEAP;
pub const D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE = D3D12_MESSAGE_ID.DESTROY_COMMANDSIGNATURE;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDDIMENSIONS;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDMISCFLAGS;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDARG_RETURN;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN = D3D12_MESSAGE_ID.CREATERESOURCE_OUTOFMEMORY_RETURN;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDDESC;
pub const D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE = D3D12_MESSAGE_ID.POSSIBLY_INVALID_SUBRESOURCE_STATE;
pub const D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE = D3D12_MESSAGE_ID.INVALID_USE_OF_NON_RESIDENT_RESOURCE;
pub const D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE = D3D12_MESSAGE_ID.POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE;
pub const D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH = D3D12_MESSAGE_ID.BUNDLE_PIPELINE_STATE_MISMATCH;
pub const D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE = D3D12_MESSAGE_ID.PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE;
pub const D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE = D3D12_MESSAGE_ID.RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE;
pub const D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = D3D12_MESSAGE_ID.RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE;
pub const D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE = D3D12_MESSAGE_ID.DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE;
pub const D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = D3D12_MESSAGE_ID.DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE;
pub const D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE = D3D12_MESSAGE_ID.CREATESHADER_INVALIDBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC = D3D12_MESSAGE_ID.CREATEHEAP_NULLDESC;
pub const D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE = D3D12_MESSAGE_ID.CREATEHEAP_INVALIDSIZE;
pub const D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE = D3D12_MESSAGE_ID.CREATEHEAP_UNRECOGNIZEDHEAPTYPE;
pub const D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = D3D12_MESSAGE_ID.CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES;
pub const D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL = D3D12_MESSAGE_ID.CREATEHEAP_UNRECOGNIZEDMEMORYPOOL;
pub const D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES = D3D12_MESSAGE_ID.CREATEHEAP_INVALIDPROPERTIES;
pub const D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT = D3D12_MESSAGE_ID.CREATEHEAP_INVALIDALIGNMENT;
pub const D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS = D3D12_MESSAGE_ID.CREATEHEAP_UNRECOGNIZEDMISCFLAGS;
pub const D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS = D3D12_MESSAGE_ID.CREATEHEAP_INVALIDMISCFLAGS;
pub const D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN = D3D12_MESSAGE_ID.CREATEHEAP_INVALIDARG_RETURN;
pub const D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN = D3D12_MESSAGE_ID.CREATEHEAP_OUTOFMEMORY_RETURN;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_INVALIDARG_RETURN;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN;
pub const D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE = D3D12_MESSAGE_ID.GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE;
pub const D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE = D3D12_MESSAGE_ID.GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE;
pub const D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC = D3D12_MESSAGE_ID.CREATE_DESCRIPTOR_HEAP_INVALID_DESC;
pub const D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE = D3D12_MESSAGE_ID.INVALID_DESCRIPTOR_HANDLE;
pub const D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE = D3D12_MESSAGE_ID.CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE;
pub const D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE = D3D12_MESSAGE_ID.CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE;
pub const D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC = D3D12_MESSAGE_ID.CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC;
pub const D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE = D3D12_MESSAGE_ID.CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE;
pub const D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES = D3D12_MESSAGE_ID.COPY_DESCRIPTORS_INVALID_RANGES;
pub const D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR = D3D12_MESSAGE_ID.COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE;
pub const D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE = D3D12_MESSAGE_ID.EXECUTE_BUNDLE_OPEN_BUNDLE;
pub const D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH = D3D12_MESSAGE_ID.EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH;
pub const D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE = D3D12_MESSAGE_ID.EXECUTE_BUNDLE_TYPE;
pub const D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE = D3D12_MESSAGE_ID.DRAW_EMPTY_SCISSOR_RECTANGLE;
pub const D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND = D3D12_MESSAGE_ID.CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND;
pub const D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED = D3D12_MESSAGE_ID.CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED;
pub const D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION = D3D12_MESSAGE_ID.CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION;
pub const D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE = D3D12_MESSAGE_ID.CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES;
pub const D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP = D3D12_MESSAGE_ID.CREATERESOURCEANDHEAP_NULLHEAP;
pub const D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS = D3D12_MESSAGE_ID.GETRESOURCEALLOCATIONINFO_INVALIDRDESCS;
pub const D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY = D3D12_MESSAGE_ID.MAKERESIDENT_NULLOBJECTARRAY;
pub const D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY = D3D12_MESSAGE_ID.EVICT_NULLOBJECTARRAY;
pub const D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID = D3D12_MESSAGE_ID.SET_DESCRIPTOR_TABLE_INVALID;
pub const D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID = D3D12_MESSAGE_ID.SET_ROOT_CONSTANT_INVALID;
pub const D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID = D3D12_MESSAGE_ID.SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID;
pub const D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID = D3D12_MESSAGE_ID.SET_ROOT_SHADER_RESOURCE_VIEW_INVALID;
pub const D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID = D3D12_MESSAGE_ID.SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID;
pub const D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC = D3D12_MESSAGE_ID.SET_VERTEX_BUFFERS_INVALID_DESC;
pub const D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC = D3D12_MESSAGE_ID.SET_INDEX_BUFFER_INVALID_DESC;
pub const D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC = D3D12_MESSAGE_ID.SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY = D3D12_MESSAGE_ID.CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT = D3D12_MESSAGE_ID.CREATERESOURCE_UNRECOGNIZEDLAYOUT;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDDIMENSIONALITY;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDALIGNMENT;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDMIPLEVELS;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDSAMPLEDESC;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDLAYOUT;
pub const D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID = D3D12_MESSAGE_ID.SET_INDEX_BUFFER_INVALID;
pub const D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID = D3D12_MESSAGE_ID.SET_VERTEX_BUFFERS_INVALID;
pub const D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID = D3D12_MESSAGE_ID.SET_STREAM_OUTPUT_BUFFERS_INVALID;
pub const D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID = D3D12_MESSAGE_ID.SET_RENDER_TARGETS_INVALID;
pub const D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS = D3D12_MESSAGE_ID.CREATEQUERY_HEAP_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS = D3D12_MESSAGE_ID.BEGIN_END_QUERY_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY = D3D12_MESSAGE_ID.CLOSE_COMMAND_LIST_OPEN_QUERY;
pub const D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS = D3D12_MESSAGE_ID.RESOLVE_QUERY_DATA_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS = D3D12_MESSAGE_ID.SET_PREDICATION_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED = D3D12_MESSAGE_ID.TIMESTAMPS_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT = D3D12_MESSAGE_ID.CREATERESOURCE_UNRECOGNIZEDFORMAT;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDFORMAT;
pub const D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE = D3D12_MESSAGE_ID.GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE;
pub const D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET = D3D12_MESSAGE_ID.GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET;
pub const D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE = D3D12_MESSAGE_ID.GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE;
pub const D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET = D3D12_MESSAGE_ID.GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP = D3D12_MESSAGE_ID.RESOURCE_BARRIER_INVALID_HEAP;
pub const D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID = D3D12_MESSAGE_ID.CREATE_SAMPLER_INVALID;
pub const D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID = D3D12_MESSAGE_ID.CREATECOMMANDSIGNATURE_INVALID;
pub const D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS = D3D12_MESSAGE_ID.EXECUTE_INDIRECT_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION = D3D12_MESSAGE_ID.GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDCLEARVALUE;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT = D3D12_MESSAGE_ID.CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT = D3D12_MESSAGE_ID.CREATERESOURCE_INVALIDCLEARVALUEFORMAT;
pub const D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH = D3D12_MESSAGE_ID.CREATERESOURCE_CLEARVALUEDENORMFLUSH;
pub const D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE = D3D12_MESSAGE_ID.CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE;
pub const D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE = D3D12_MESSAGE_ID.CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE;
pub const D3D12_MESSAGE_ID_MAP_INVALIDHEAP = D3D12_MESSAGE_ID.MAP_INVALIDHEAP;
pub const D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP = D3D12_MESSAGE_ID.UNMAP_INVALIDHEAP;
pub const D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE = D3D12_MESSAGE_ID.MAP_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE = D3D12_MESSAGE_ID.UNMAP_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE = D3D12_MESSAGE_ID.MAP_INVALIDSUBRESOURCE;
pub const D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE = D3D12_MESSAGE_ID.UNMAP_INVALIDSUBRESOURCE;
pub const D3D12_MESSAGE_ID_MAP_INVALIDRANGE = D3D12_MESSAGE_ID.MAP_INVALIDRANGE;
pub const D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE = D3D12_MESSAGE_ID.UNMAP_INVALIDRANGE;
pub const D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER = D3D12_MESSAGE_ID.MAP_INVALIDDATAPOINTER;
pub const D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN = D3D12_MESSAGE_ID.MAP_INVALIDARG_RETURN;
pub const D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN = D3D12_MESSAGE_ID.MAP_OUTOFMEMORY_RETURN;
pub const D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED = D3D12_MESSAGE_ID.EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED;
pub const D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH = D3D12_MESSAGE_ID.EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH;
pub const D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST = D3D12_MESSAGE_ID.EXECUTECOMMANDLISTS_OPENCOMMANDLIST;
pub const D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST = D3D12_MESSAGE_ID.EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST = D3D12_MESSAGE_ID.COPYBUFFERREGION_NULLDST;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION = D3D12_MESSAGE_ID.COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS = D3D12_MESSAGE_ID.COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC = D3D12_MESSAGE_ID.COPYBUFFERREGION_NULLSRC;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION = D3D12_MESSAGE_ID.COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS = D3D12_MESSAGE_ID.COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS = D3D12_MESSAGE_ID.COPYBUFFERREGION_INVALIDCOPYFLAGS;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST = D3D12_MESSAGE_ID.COPYTEXTUREREGION_NULLDST;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE = D3D12_MESSAGE_ID.COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTRESOURCE;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTOFFSET;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT = D3D12_MESSAGE_ID.COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTFORMAT;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTDIMENSIONS;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTROWPITCH;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTPLACEMENT;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS = D3D12_MESSAGE_ID.COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC = D3D12_MESSAGE_ID.COPYTEXTUREREGION_NULLSRC;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE = D3D12_MESSAGE_ID.COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCRESOURCE;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCOFFSET;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT = D3D12_MESSAGE_ID.COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCFORMAT;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCDIMENSIONS;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCROWPITCH;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCPLACEMENT;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS = D3D12_MESSAGE_ID.COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDDSTCOORDINATES;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDSRCBOX;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH = D3D12_MESSAGE_ID.COPYTEXTUREREGION_FORMATMISMATCH;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX = D3D12_MESSAGE_ID.COPYTEXTUREREGION_EMPTYBOX;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS = D3D12_MESSAGE_ID.COPYTEXTUREREGION_INVALIDCOPYFLAGS;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_INVALID_FORMAT;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_RESOURCE_MISMATCH;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT;
pub const D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER = D3D12_MESSAGE_ID.CREATECOMPUTEPIPELINESTATE_INVALID_SHADER;
pub const D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE = D3D12_MESSAGE_ID.CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_INVALIDCACHEDBLOB;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_CACHEDBLOBIGNORED;
pub const D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP = D3D12_MESSAGE_ID.WRITETOSUBRESOURCE_INVALIDHEAP;
pub const D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE = D3D12_MESSAGE_ID.WRITETOSUBRESOURCE_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX = D3D12_MESSAGE_ID.WRITETOSUBRESOURCE_INVALIDBOX;
pub const D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE = D3D12_MESSAGE_ID.WRITETOSUBRESOURCE_INVALIDSUBRESOURCE;
pub const D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX = D3D12_MESSAGE_ID.WRITETOSUBRESOURCE_EMPTYBOX;
pub const D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP = D3D12_MESSAGE_ID.READFROMSUBRESOURCE_INVALIDHEAP;
pub const D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE = D3D12_MESSAGE_ID.READFROMSUBRESOURCE_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX = D3D12_MESSAGE_ID.READFROMSUBRESOURCE_INVALIDBOX;
pub const D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE = D3D12_MESSAGE_ID.READFROMSUBRESOURCE_INVALIDSUBRESOURCE;
pub const D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX = D3D12_MESSAGE_ID.READFROMSUBRESOURCE_EMPTYBOX;
pub const D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED = D3D12_MESSAGE_ID.TOO_MANY_NODES_SPECIFIED;
pub const D3D12_MESSAGE_ID_INVALID_NODE_INDEX = D3D12_MESSAGE_ID.INVALID_NODE_INDEX;
pub const D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE = D3D12_MESSAGE_ID.GETHEAPPROPERTIES_INVALIDRESOURCE;
pub const D3D12_MESSAGE_ID_NODE_MASK_MISMATCH = D3D12_MESSAGE_ID.NODE_MASK_MISMATCH;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY = D3D12_MESSAGE_ID.COMMAND_LIST_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES = D3D12_MESSAGE_ID.COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES = D3D12_MESSAGE_ID.COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES;
pub const D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES = D3D12_MESSAGE_ID.COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES;
pub const D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE = D3D12_MESSAGE_ID.EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS = D3D12_MESSAGE_ID.COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS;
pub const D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE = D3D12_MESSAGE_ID.CREATE_QUEUE_INVALID_TYPE;
pub const D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS = D3D12_MESSAGE_ID.CREATE_QUEUE_INVALID_FLAGS;
pub const D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS = D3D12_MESSAGE_ID.CREATESHAREDRESOURCE_INVALIDFLAGS;
pub const D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT = D3D12_MESSAGE_ID.CREATESHAREDRESOURCE_INVALIDFORMAT;
pub const D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS = D3D12_MESSAGE_ID.CREATESHAREDHEAP_INVALIDFLAGS;
pub const D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES = D3D12_MESSAGE_ID.REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES;
pub const D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE = D3D12_MESSAGE_ID.REFLECTSHAREDPROPERTIES_INVALIDSIZE;
pub const D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT = D3D12_MESSAGE_ID.REFLECTSHAREDPROPERTIES_INVALIDOBJECT;
pub const D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT = D3D12_MESSAGE_ID.KEYEDMUTEX_INVALIDOBJECT;
pub const D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY = D3D12_MESSAGE_ID.KEYEDMUTEX_INVALIDKEY;
pub const D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE = D3D12_MESSAGE_ID.KEYEDMUTEX_WRONGSTATE;
pub const D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY = D3D12_MESSAGE_ID.CREATE_QUEUE_INVALID_PRIORITY;
pub const D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE = D3D12_MESSAGE_ID.OBJECT_DELETED_WHILE_STILL_IN_USE;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_INVALID_FLAGS;
pub const D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE = D3D12_MESSAGE_ID.HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED = D3D12_MESSAGE_ID.COMMAND_LIST_DRAW_RENDER_TARGET_DELETED;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT;
pub const D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS = D3D12_MESSAGE_ID.HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS;
pub const D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED = D3D12_MESSAGE_ID.EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED;
pub const D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY = D3D12_MESSAGE_ID.UNMAP_RANGE_NOT_EMPTY;
pub const D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE = D3D12_MESSAGE_ID.MAP_INVALID_NULLRANGE;
pub const D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE = D3D12_MESSAGE_ID.UNMAP_INVALID_NULLRANGE;
pub const D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT = D3D12_MESSAGE_ID.NO_GRAPHICS_API_SUPPORT;
pub const D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT = D3D12_MESSAGE_ID.NO_COMPUTE_API_SUPPORT;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE;
pub const D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST = D3D12_MESSAGE_ID.COPYRESOURCE_NULLDST;
pub const D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE = D3D12_MESSAGE_ID.COPYRESOURCE_INVALIDDSTRESOURCE;
pub const D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC = D3D12_MESSAGE_ID.COPYRESOURCE_NULLSRC;
pub const D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE = D3D12_MESSAGE_ID.COPYRESOURCE_INVALIDSRCRESOURCE;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_NULLDST;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_INVALIDDSTRESOURCE;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_NULLSRC;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_INVALIDSRCRESOURCE;
pub const D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH = D3D12_MESSAGE_ID.PIPELINE_STATE_TYPE_MISMATCH;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS = D3D12_MESSAGE_ID.RESOURCE_BARRIER_ZERO_BARRIERS;
pub const D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH = D3D12_MESSAGE_ID.BEGIN_END_EVENT_MISMATCH;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH = D3D12_MESSAGE_ID.RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END = D3D12_MESSAGE_ID.RESOURCE_BARRIER_MISMATCHING_BEGIN_END;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_INVALID_RESOURCE;
pub const D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT = D3D12_MESSAGE_ID.USE_OF_ZERO_REFCOUNT_OBJECT;
pub const D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE = D3D12_MESSAGE_ID.OBJECT_EVICTED_WHILE_STILL_IN_USE;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS;
pub const D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB = D3D12_MESSAGE_ID.CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB;
pub const D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH = D3D12_MESSAGE_ID.CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH;
pub const D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH = D3D12_MESSAGE_ID.CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH;
pub const D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED = D3D12_MESSAGE_ID.CREATEPIPELINELIBRARY_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY = D3D12_MESSAGE_ID.CREATE_PIPELINELIBRARY;
pub const D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY = D3D12_MESSAGE_ID.LIVE_PIPELINELIBRARY;
pub const D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY = D3D12_MESSAGE_ID.DESTROY_PIPELINELIBRARY;
pub const D3D12_MESSAGE_ID_STOREPIPELINE_NONAME = D3D12_MESSAGE_ID.STOREPIPELINE_NONAME;
pub const D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME = D3D12_MESSAGE_ID.STOREPIPELINE_DUPLICATENAME;
pub const D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND = D3D12_MESSAGE_ID.LOADPIPELINE_NAMENOTFOUND;
pub const D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC = D3D12_MESSAGE_ID.LOADPIPELINE_INVALIDDESC;
pub const D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY = D3D12_MESSAGE_ID.PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH;
pub const D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS = D3D12_MESSAGE_ID.SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS;
pub const D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED = D3D12_MESSAGE_ID.CREATE_QUEUE_VIDEO_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED = D3D12_MESSAGE_ID.CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED = D3D12_MESSAGE_ID.CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST = D3D12_MESSAGE_ID.CREATE_VIDEODECODECOMMANDLIST;
pub const D3D12_MESSAGE_ID_CREATE_VIDEODECODER = D3D12_MESSAGE_ID.CREATE_VIDEODECODER;
pub const D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM = D3D12_MESSAGE_ID.CREATE_VIDEODECODESTREAM;
pub const D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST = D3D12_MESSAGE_ID.LIVE_VIDEODECODECOMMANDLIST;
pub const D3D12_MESSAGE_ID_LIVE_VIDEODECODER = D3D12_MESSAGE_ID.LIVE_VIDEODECODER;
pub const D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM = D3D12_MESSAGE_ID.LIVE_VIDEODECODESTREAM;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST = D3D12_MESSAGE_ID.DESTROY_VIDEODECODECOMMANDLIST;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEODECODER = D3D12_MESSAGE_ID.DESTROY_VIDEODECODER;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM = D3D12_MESSAGE_ID.DESTROY_VIDEODECODESTREAM;
pub const D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS = D3D12_MESSAGE_ID.DECODE_FRAME_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_DEPRECATED_API = D3D12_MESSAGE_ID.DEPRECATED_API;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE = D3D12_MESSAGE_ID.RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET;
pub const D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE = D3D12_MESSAGE_ID.DISCARD_INVALID_SUBRESOURCE_RANGE;
pub const D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS = D3D12_MESSAGE_ID.DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS;
pub const D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D = D3D12_MESSAGE_ID.DISCARD_NO_RECTS_FOR_NON_TEXTURE2D;
pub const D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE = D3D12_MESSAGE_ID.COPY_ON_SAME_SUBRESOURCE;
pub const D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE = D3D12_MESSAGE_ID.SETRESIDENCYPRIORITY_INVALID_PAGEABLE;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE = D3D12_MESSAGE_ID.STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE;
pub const D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE = D3D12_MESSAGE_ID.DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE;
pub const D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE = D3D12_MESSAGE_ID.DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE;
pub const D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET = D3D12_MESSAGE_ID.EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS = D3D12_MESSAGE_ID.CREATE_FENCE_INVALID_FLAGS;
pub const D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS = D3D12_MESSAGE_ID.RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS;
pub const D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY = D3D12_MESSAGE_ID.SETRESIDENCYPRIORITY_INVALID_PRIORITY;
pub const D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS = D3D12_MESSAGE_ID.CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS;
pub const D3D12_MESSAGE_ID_BEGIN_EVENT = D3D12_MESSAGE_ID.BEGIN_EVENT;
pub const D3D12_MESSAGE_ID_END_EVENT = D3D12_MESSAGE_ID.END_EVENT;
pub const D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS = D3D12_MESSAGE_ID.CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS;
pub const D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED = D3D12_MESSAGE_ID.CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_ZERO_SIZE_STREAM;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_INVALID_STREAM;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH = D3D12_MESSAGE_ID.COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME = D3D12_MESSAGE_ID.CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME = D3D12_MESSAGE_ID.CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_INVALID_ARCHITECTURE;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_NULL_DST;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_NULL_SRC;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_ZERO_DEPENDENCIES;
pub const D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG = D3D12_MESSAGE_ID.DEVICE_CREATE_SHARED_HANDLE_INVALIDARG;
pub const D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE = D3D12_MESSAGE_ID.DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE;
pub const D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS = D3D12_MESSAGE_ID.SETDEPTHBOUNDS_INVALIDARGS;
pub const D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE = D3D12_MESSAGE_ID.GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET = D3D12_MESSAGE_ID.COMMAND_LIST_PIPELINE_STATE_NOT_SET;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH;
pub const D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE = D3D12_MESSAGE_ID.OBJECT_ACCESSED_WHILE_STILL_IN_USE;
pub const D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED = D3D12_MESSAGE_ID.PROGRAMMABLE_MSAA_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS = D3D12_MESSAGE_ID.SETSAMPLEPOSITIONS_INVALIDARGS;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT = D3D12_MESSAGE_ID.RESOLVESUBRESOURCEREGION_INVALID_RECT;
pub const D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE = D3D12_MESSAGE_ID.CREATE_VIDEODECODECOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST = D3D12_MESSAGE_ID.CREATE_VIDEOPROCESSCOMMANDLIST;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE = D3D12_MESSAGE_ID.CREATE_VIDEOPROCESSCOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE = D3D12_MESSAGE_ID.LIVE_VIDEODECODECOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST = D3D12_MESSAGE_ID.LIVE_VIDEOPROCESSCOMMANDLIST;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE = D3D12_MESSAGE_ID.LIVE_VIDEOPROCESSCOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE = D3D12_MESSAGE_ID.DESTROY_VIDEODECODECOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST = D3D12_MESSAGE_ID.DESTROY_VIDEOPROCESSCOMMANDLIST;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE = D3D12_MESSAGE_ID.DESTROY_VIDEOPROCESSCOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR = D3D12_MESSAGE_ID.CREATE_VIDEOPROCESSOR;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM = D3D12_MESSAGE_ID.CREATE_VIDEOPROCESSSTREAM;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR = D3D12_MESSAGE_ID.LIVE_VIDEOPROCESSOR;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM = D3D12_MESSAGE_ID.LIVE_VIDEOPROCESSSTREAM;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR = D3D12_MESSAGE_ID.DESTROY_VIDEOPROCESSOR;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM = D3D12_MESSAGE_ID.DESTROY_VIDEOPROCESSSTREAM;
pub const D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS = D3D12_MESSAGE_ID.PROCESS_FRAME_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT = D3D12_MESSAGE_ID.COPY_INVALIDLAYOUT;
pub const D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION = D3D12_MESSAGE_ID.CREATE_CRYPTO_SESSION;
pub const D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION_POLICY = D3D12_MESSAGE_ID.CREATE_CRYPTO_SESSION_POLICY;
pub const D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION = D3D12_MESSAGE_ID.CREATE_PROTECTED_RESOURCE_SESSION;
pub const D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION = D3D12_MESSAGE_ID.LIVE_CRYPTO_SESSION;
pub const D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION_POLICY = D3D12_MESSAGE_ID.LIVE_CRYPTO_SESSION_POLICY;
pub const D3D12_MESSAGE_ID_LIVE_PROTECTED_RESOURCE_SESSION = D3D12_MESSAGE_ID.LIVE_PROTECTED_RESOURCE_SESSION;
pub const D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION = D3D12_MESSAGE_ID.DESTROY_CRYPTO_SESSION;
pub const D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION_POLICY = D3D12_MESSAGE_ID.DESTROY_CRYPTO_SESSION_POLICY;
pub const D3D12_MESSAGE_ID_DESTROY_PROTECTED_RESOURCE_SESSION = D3D12_MESSAGE_ID.DESTROY_PROTECTED_RESOURCE_SESSION;
pub const D3D12_MESSAGE_ID_PROTECTED_RESOURCE_SESSION_UNSUPPORTED = D3D12_MESSAGE_ID.PROTECTED_RESOURCE_SESSION_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_FENCE_INVALIDOPERATION = D3D12_MESSAGE_ID.FENCE_INVALIDOPERATION;
pub const D3D12_MESSAGE_ID_CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED = D3D12_MESSAGE_ID.CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_DEFERRED = D3D12_MESSAGE_ID.SAMPLEPOSITIONS_MISMATCH_DEFERRED;
pub const D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE = D3D12_MESSAGE_ID.SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE;
pub const D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR = D3D12_MESSAGE_ID.SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR;
pub const D3D12_MESSAGE_ID_CREATE_VIDEODECODERHEAP = D3D12_MESSAGE_ID.CREATE_VIDEODECODERHEAP;
pub const D3D12_MESSAGE_ID_LIVE_VIDEODECODERHEAP = D3D12_MESSAGE_ID.LIVE_VIDEODECODERHEAP;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEODECODERHEAP = D3D12_MESSAGE_ID.DESTROY_VIDEODECODERHEAP;
pub const D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDARG_RETURN = D3D12_MESSAGE_ID.OPENEXISTINGHEAP_INVALIDARG_RETURN;
pub const D3D12_MESSAGE_ID_OPENEXISTINGHEAP_OUTOFMEMORY_RETURN = D3D12_MESSAGE_ID.OPENEXISTINGHEAP_OUTOFMEMORY_RETURN;
pub const D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDADDRESS = D3D12_MESSAGE_ID.OPENEXISTINGHEAP_INVALIDADDRESS;
pub const D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDHANDLE = D3D12_MESSAGE_ID.OPENEXISTINGHEAP_INVALIDHANDLE;
pub const D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_DEST = D3D12_MESSAGE_ID.WRITEBUFFERIMMEDIATE_INVALID_DEST;
pub const D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_MODE = D3D12_MESSAGE_ID.WRITEBUFFERIMMEDIATE_INVALID_MODE;
pub const D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT = D3D12_MESSAGE_ID.WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT;
pub const D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_NOT_SUPPORTED = D3D12_MESSAGE_ID.WRITEBUFFERIMMEDIATE_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_SETVIEWINSTANCEMASK_INVALIDARGS = D3D12_MESSAGE_ID.SETVIEWINSTANCEMASK_INVALIDARGS;
pub const D3D12_MESSAGE_ID_VIEW_INSTANCING_UNSUPPORTED = D3D12_MESSAGE_ID.VIEW_INSTANCING_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_VIEW_INSTANCING_INVALIDARGS = D3D12_MESSAGE_ID.VIEW_INSTANCING_INVALIDARGS;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = D3D12_MESSAGE_ID.COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG;
pub const D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = D3D12_MESSAGE_ID.COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG;
pub const D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE = D3D12_MESSAGE_ID.CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE;
pub const D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED = D3D12_MESSAGE_ID.CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_INVALID_INPUT = D3D12_MESSAGE_ID.VIDEO_DECODE_SUPPORT_INVALID_INPUT;
pub const D3D12_MESSAGE_ID_CREATE_VIDEO_DECODER_UNSUPPORTED = D3D12_MESSAGE_ID.CREATE_VIDEO_DECODER_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR;
pub const D3D12_MESSAGE_ID_NO_VIDEO_API_SUPPORT = D3D12_MESSAGE_ID.NO_VIDEO_API_SUPPORT;
pub const D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_INVALID_INPUT = D3D12_MESSAGE_ID.VIDEO_PROCESS_SUPPORT_INVALID_INPUT;
pub const D3D12_MESSAGE_ID_CREATE_VIDEO_PROCESSOR_CAPS_FAILURE = D3D12_MESSAGE_ID.CREATE_VIDEO_PROCESSOR_CAPS_FAILURE;
pub const D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT = D3D12_MESSAGE_ID.VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT;
pub const D3D12_MESSAGE_ID_VIDEO_DECODE_FRAME_INVALID_ARGUMENT = D3D12_MESSAGE_ID.VIDEO_DECODE_FRAME_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS = D3D12_MESSAGE_ID.ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS;
pub const D3D12_MESSAGE_ID_OPENEXISTINGHEAP_UNSUPPORTED = D3D12_MESSAGE_ID.OPENEXISTINGHEAP_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT = D3D12_MESSAGE_ID.VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_UNSUPPORTED = D3D12_MESSAGE_ID.VIDEO_DECODE_SUPPORT_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_CREATE_COMMANDRECORDER = D3D12_MESSAGE_ID.CREATE_COMMANDRECORDER;
pub const D3D12_MESSAGE_ID_LIVE_COMMANDRECORDER = D3D12_MESSAGE_ID.LIVE_COMMANDRECORDER;
pub const D3D12_MESSAGE_ID_DESTROY_COMMANDRECORDER = D3D12_MESSAGE_ID.DESTROY_COMMANDRECORDER;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED = D3D12_MESSAGE_ID.CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS = D3D12_MESSAGE_ID.CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_FLAGS = D3D12_MESSAGE_ID.CREATE_COMMAND_RECORDER_INVALID_FLAGS;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS = D3D12_MESSAGE_ID.CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS;
pub const D3D12_MESSAGE_ID_CREATE_COMMANDPOOL = D3D12_MESSAGE_ID.CREATE_COMMANDPOOL;
pub const D3D12_MESSAGE_ID_LIVE_COMMANDPOOL = D3D12_MESSAGE_ID.LIVE_COMMANDPOOL;
pub const D3D12_MESSAGE_ID_DESTROY_COMMANDPOOL = D3D12_MESSAGE_ID.DESTROY_COMMANDPOOL;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_POOL_INVALID_FLAGS = D3D12_MESSAGE_ID.CREATE_COMMAND_POOL_INVALID_FLAGS;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED = D3D12_MESSAGE_ID.CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH = D3D12_MESSAGE_ID.COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH;
pub const D3D12_MESSAGE_ID_COMMAND_RECORDER_CONTENTION = D3D12_MESSAGE_ID.COMMAND_RECORDER_CONTENTION;
pub const D3D12_MESSAGE_ID_COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST = D3D12_MESSAGE_ID.COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST;
pub const D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST = D3D12_MESSAGE_ID.COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST;
pub const D3D12_MESSAGE_ID_CANNOT_EXECUTE_EMPTY_COMMAND_LIST = D3D12_MESSAGE_ID.CANNOT_EXECUTE_EMPTY_COMMAND_LIST;
pub const D3D12_MESSAGE_ID_CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS = D3D12_MESSAGE_ID.CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS;
pub const D3D12_MESSAGE_ID_CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET = D3D12_MESSAGE_ID.CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET;
pub const D3D12_MESSAGE_ID_CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING = D3D12_MESSAGE_ID.CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING;
pub const D3D12_MESSAGE_ID_COMMAND_POOL_SYNC = D3D12_MESSAGE_ID.COMMAND_POOL_SYNC;
pub const D3D12_MESSAGE_ID_EVICT_UNDERFLOW = D3D12_MESSAGE_ID.EVICT_UNDERFLOW;
pub const D3D12_MESSAGE_ID_CREATE_META_COMMAND = D3D12_MESSAGE_ID.CREATE_META_COMMAND;
pub const D3D12_MESSAGE_ID_LIVE_META_COMMAND = D3D12_MESSAGE_ID.LIVE_META_COMMAND;
pub const D3D12_MESSAGE_ID_DESTROY_META_COMMAND = D3D12_MESSAGE_ID.DESTROY_META_COMMAND;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_DST_RESOURCE = D3D12_MESSAGE_ID.COPYBUFFERREGION_INVALID_DST_RESOURCE;
pub const D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_SRC_RESOURCE = D3D12_MESSAGE_ID.COPYBUFFERREGION_INVALID_SRC_RESOURCE;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_INVALID_DST_RESOURCE;
pub const D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE = D3D12_MESSAGE_ID.ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS;
pub const D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN = D3D12_MESSAGE_ID.CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN;
pub const D3D12_MESSAGE_ID_CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER = D3D12_MESSAGE_ID.CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER;
pub const D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES = D3D12_MESSAGE_ID.UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE = D3D12_MESSAGE_ID.CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE;
pub const D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS = D3D12_MESSAGE_ID.CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS;
pub const D3D12_MESSAGE_ID_COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED = D3D12_MESSAGE_ID.COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED;
pub const D3D12_MESSAGE_ID_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = D3D12_MESSAGE_ID.BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID;
pub const D3D12_MESSAGE_ID_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID = D3D12_MESSAGE_ID.EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID;
pub const D3D12_MESSAGE_ID_COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = D3D12_MESSAGE_ID.COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID;
pub const D3D12_MESSAGE_ID_DISPATCH_RAYS_INVALID = D3D12_MESSAGE_ID.DISPATCH_RAYS_INVALID;
pub const D3D12_MESSAGE_ID_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID = D3D12_MESSAGE_ID.GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID;
pub const D3D12_MESSAGE_ID_CREATE_LIFETIMETRACKER = D3D12_MESSAGE_ID.CREATE_LIFETIMETRACKER;
pub const D3D12_MESSAGE_ID_LIVE_LIFETIMETRACKER = D3D12_MESSAGE_ID.LIVE_LIFETIMETRACKER;
pub const D3D12_MESSAGE_ID_DESTROY_LIFETIMETRACKER = D3D12_MESSAGE_ID.DESTROY_LIFETIMETRACKER;
pub const D3D12_MESSAGE_ID_DESTROYOWNEDOBJECT_OBJECTNOTOWNED = D3D12_MESSAGE_ID.DESTROYOWNEDOBJECT_OBJECTNOTOWNED;
pub const D3D12_MESSAGE_ID_CREATE_TRACKEDWORKLOAD = D3D12_MESSAGE_ID.CREATE_TRACKEDWORKLOAD;
pub const D3D12_MESSAGE_ID_LIVE_TRACKEDWORKLOAD = D3D12_MESSAGE_ID.LIVE_TRACKEDWORKLOAD;
pub const D3D12_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD = D3D12_MESSAGE_ID.DESTROY_TRACKEDWORKLOAD;
pub const D3D12_MESSAGE_ID_RENDER_PASS_ERROR = D3D12_MESSAGE_ID.RENDER_PASS_ERROR;
pub const D3D12_MESSAGE_ID_META_COMMAND_ID_INVALID = D3D12_MESSAGE_ID.META_COMMAND_ID_INVALID;
pub const D3D12_MESSAGE_ID_META_COMMAND_UNSUPPORTED_PARAMS = D3D12_MESSAGE_ID.META_COMMAND_UNSUPPORTED_PARAMS;
pub const D3D12_MESSAGE_ID_META_COMMAND_FAILED_ENUMERATION = D3D12_MESSAGE_ID.META_COMMAND_FAILED_ENUMERATION;
pub const D3D12_MESSAGE_ID_META_COMMAND_PARAMETER_SIZE_MISMATCH = D3D12_MESSAGE_ID.META_COMMAND_PARAMETER_SIZE_MISMATCH;
pub const D3D12_MESSAGE_ID_UNINITIALIZED_META_COMMAND = D3D12_MESSAGE_ID.UNINITIALIZED_META_COMMAND;
pub const D3D12_MESSAGE_ID_META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS = D3D12_MESSAGE_ID.META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDLIST = D3D12_MESSAGE_ID.CREATE_VIDEOENCODECOMMANDLIST;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDLIST = D3D12_MESSAGE_ID.LIVE_VIDEOENCODECOMMANDLIST;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDLIST = D3D12_MESSAGE_ID.DESTROY_VIDEOENCODECOMMANDLIST;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDQUEUE = D3D12_MESSAGE_ID.CREATE_VIDEOENCODECOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDQUEUE = D3D12_MESSAGE_ID.LIVE_VIDEOENCODECOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDQUEUE = D3D12_MESSAGE_ID.DESTROY_VIDEOENCODECOMMANDQUEUE;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONESTIMATOR = D3D12_MESSAGE_ID.CREATE_VIDEOMOTIONESTIMATOR;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONESTIMATOR = D3D12_MESSAGE_ID.LIVE_VIDEOMOTIONESTIMATOR;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONESTIMATOR = D3D12_MESSAGE_ID.DESTROY_VIDEOMOTIONESTIMATOR;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONVECTORHEAP = D3D12_MESSAGE_ID.CREATE_VIDEOMOTIONVECTORHEAP;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONVECTORHEAP = D3D12_MESSAGE_ID.LIVE_VIDEOMOTIONVECTORHEAP;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONVECTORHEAP = D3D12_MESSAGE_ID.DESTROY_VIDEOMOTIONVECTORHEAP;
pub const D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS = D3D12_MESSAGE_ID.MULTIPLE_TRACKED_WORKLOADS;
pub const D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS = D3D12_MESSAGE_ID.MULTIPLE_TRACKED_WORKLOAD_PAIRS;
pub const D3D12_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR = D3D12_MESSAGE_ID.OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR;
pub const D3D12_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD = D3D12_MESSAGE_ID.CANNOT_ADD_TRACKED_WORKLOAD;
pub const D3D12_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR = D3D12_MESSAGE_ID.INCOMPLETE_TRACKED_WORKLOAD_PAIR;
pub const D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_ERROR = D3D12_MESSAGE_ID.CREATE_STATE_OBJECT_ERROR;
pub const D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_ERROR = D3D12_MESSAGE_ID.GET_SHADER_IDENTIFIER_ERROR;
pub const D3D12_MESSAGE_ID_GET_SHADER_STACK_SIZE_ERROR = D3D12_MESSAGE_ID.GET_SHADER_STACK_SIZE_ERROR;
pub const D3D12_MESSAGE_ID_GET_PIPELINE_STACK_SIZE_ERROR = D3D12_MESSAGE_ID.GET_PIPELINE_STACK_SIZE_ERROR;
pub const D3D12_MESSAGE_ID_SET_PIPELINE_STACK_SIZE_ERROR = D3D12_MESSAGE_ID.SET_PIPELINE_STACK_SIZE_ERROR;
pub const D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_SIZE_INVALID = D3D12_MESSAGE_ID.GET_SHADER_IDENTIFIER_SIZE_INVALID;
pub const D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID = D3D12_MESSAGE_ID.CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID;
pub const D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE = D3D12_MESSAGE_ID.CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE;
pub const D3D12_MESSAGE_ID_RENDER_PASS_INVALID_RESOURCE_BARRIER = D3D12_MESSAGE_ID.RENDER_PASS_INVALID_RESOURCE_BARRIER;
pub const D3D12_MESSAGE_ID_RENDER_PASS_DISALLOWED_API_CALLED = D3D12_MESSAGE_ID.RENDER_PASS_DISALLOWED_API_CALLED;
pub const D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_NEST_RENDER_PASSES = D3D12_MESSAGE_ID.RENDER_PASS_CANNOT_NEST_RENDER_PASSES;
pub const D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_END_WITHOUT_BEGIN = D3D12_MESSAGE_ID.RENDER_PASS_CANNOT_END_WITHOUT_BEGIN;
pub const D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST = D3D12_MESSAGE_ID.RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST;
pub const D3D12_MESSAGE_ID_RENDER_PASS_GPU_WORK_WHILE_SUSPENDED = D3D12_MESSAGE_ID.RENDER_PASS_GPU_WORK_WHILE_SUSPENDED;
pub const D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_SUSPEND_RESUME = D3D12_MESSAGE_ID.RENDER_PASS_MISMATCHING_SUSPEND_RESUME;
pub const D3D12_MESSAGE_ID_RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS = D3D12_MESSAGE_ID.RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS;
pub const D3D12_MESSAGE_ID_RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS = D3D12_MESSAGE_ID.RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS;
pub const D3D12_MESSAGE_ID_TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH = D3D12_MESSAGE_ID.TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH;
pub const D3D12_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED = D3D12_MESSAGE_ID.TRACKED_WORKLOAD_NOT_SUPPORTED;
pub const D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_NO_ACCESS = D3D12_MESSAGE_ID.RENDER_PASS_MISMATCHING_NO_ACCESS;
pub const D3D12_MESSAGE_ID_RENDER_PASS_UNSUPPORTED_RESOLVE = D3D12_MESSAGE_ID.RENDER_PASS_UNSUPPORTED_RESOLVE;
pub const D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR = D3D12_MESSAGE_ID.CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR;
pub const D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_SIGNAL = D3D12_MESSAGE_ID.WINDOWS7_FENCE_OUTOFORDER_SIGNAL;
pub const D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_WAIT = D3D12_MESSAGE_ID.WINDOWS7_FENCE_OUTOFORDER_WAIT;
pub const D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT = D3D12_MESSAGE_ID.VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = D3D12_MESSAGE_ID.VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_ESTIMATE_MOTION_INVALID_ARGUMENT = D3D12_MESSAGE_ID.ESTIMATE_MOTION_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = D3D12_MESSAGE_ID.RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE = D3D12_MESSAGE_ID.GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE;
pub const D3D12_MESSAGE_ID_SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT = D3D12_MESSAGE_ID.SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL = D3D12_MESSAGE_ID.CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOEXTENSIONCOMMAND = D3D12_MESSAGE_ID.CREATE_VIDEOEXTENSIONCOMMAND;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOEXTENSIONCOMMAND = D3D12_MESSAGE_ID.LIVE_VIDEOEXTENSIONCOMMAND;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOEXTENSIONCOMMAND = D3D12_MESSAGE_ID.DESTROY_VIDEOEXTENSIONCOMMAND;
pub const D3D12_MESSAGE_ID_INVALID_VIDEO_EXTENSION_COMMAND_ID = D3D12_MESSAGE_ID.INVALID_VIDEO_EXTENSION_COMMAND_ID;
pub const D3D12_MESSAGE_ID_VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT = D3D12_MESSAGE_ID.VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY = D3D12_MESSAGE_ID.CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY;
pub const D3D12_MESSAGE_ID_VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR = D3D12_MESSAGE_ID.VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR;
pub const D3D12_MESSAGE_ID_GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = D3D12_MESSAGE_ID.GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE;
pub const D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_SHADING_RATE = D3D12_MESSAGE_ID.RSSETSHADING_RATE_INVALID_SHADING_RATE;
pub const D3D12_MESSAGE_ID_RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP = D3D12_MESSAGE_ID.RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP;
pub const D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_COMBINER = D3D12_MESSAGE_ID.RSSETSHADING_RATE_INVALID_COMBINER;
pub const D3D12_MESSAGE_ID_RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2 = D3D12_MESSAGE_ID.RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2;
pub const D3D12_MESSAGE_ID_RSSETSHADINGRATE_REQUIRES_TIER_1 = D3D12_MESSAGE_ID.RSSETSHADINGRATE_REQUIRES_TIER_1;
pub const D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_FORMAT = D3D12_MESSAGE_ID.SHADING_RATE_IMAGE_INCORRECT_FORMAT;
pub const D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE = D3D12_MESSAGE_ID.SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE;
pub const D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL = D3D12_MESSAGE_ID.SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL;
pub const D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT = D3D12_MESSAGE_ID.SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT;
pub const D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY = D3D12_MESSAGE_ID.SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY;
pub const D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE = D3D12_MESSAGE_ID.NON_RETAIL_SHADER_MODEL_WONT_VALIDATE;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_AS_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_ROOT_SIGNATURE_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_MS_ROOT_SIGNATURE_MISMATCH;
pub const D3D12_MESSAGE_ID_ADD_TO_STATE_OBJECT_ERROR = D3D12_MESSAGE_ID.ADD_TO_STATE_OBJECT_ERROR;
pub const D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION_INVALID_ARGUMENT = D3D12_MESSAGE_ID.CREATE_PROTECTED_RESOURCE_SESSION_INVALID_ARGUMENT;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_PSO_DESC_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_MS_PSO_DESC_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEPIPELINESTATE_MS_INCOMPLETE_TYPE = D3D12_MESSAGE_ID.CREATEPIPELINESTATE_MS_INCOMPLETE_TYPE;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_NOT_MS_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_AS_NOT_MS_MISMATCH;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_NOT_PS_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_MS_NOT_PS_MISMATCH;
pub const D3D12_MESSAGE_ID_NONZERO_SAMPLER_FEEDBACK_MIP_REGION_WITH_INCOMPATIBLE_FORMAT = D3D12_MESSAGE_ID.NONZERO_SAMPLER_FEEDBACK_MIP_REGION_WITH_INCOMPATIBLE_FORMAT;
pub const D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_SHADER_MISMATCH = D3D12_MESSAGE_ID.CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_SHADER_MISMATCH;
pub const D3D12_MESSAGE_ID_EMPTY_DISPATCH = D3D12_MESSAGE_ID.EMPTY_DISPATCH;
pub const D3D12_MESSAGE_ID_RESOURCE_FORMAT_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY = D3D12_MESSAGE_ID.RESOURCE_FORMAT_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_MIP_REGION = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_MAP_INVALID_MIP_REGION;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_DIMENSION = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_MAP_INVALID_DIMENSION;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_COUNT = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_COUNT;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_QUALITY = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_QUALITY;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_LAYOUT = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_MAP_INVALID_LAYOUT;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_REQUIRES_UNORDERED_ACCESS_FLAG = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_MAP_REQUIRES_UNORDERED_ACCESS_FLAG;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_NULL_ARGUMENTS = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_CREATE_UAV_NULL_ARGUMENTS;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_UAV_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_UAV_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_REQUIRES_FEEDBACK_MAP_FORMAT = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_CREATE_UAV_REQUIRES_FEEDBACK_MAP_FORMAT;
pub const D3D12_MESSAGE_ID_CREATEMESHSHADER_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATEMESHSHADER_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEMESHSHADER_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATEMESHSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE = D3D12_MESSAGE_ID.CREATEMESHSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_INVALID_FORMAT = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_INVALID_FORMAT;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_INVALID_MIP_LEVEL_COUNT = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_INVALID_MIP_LEVEL_COUNT;
pub const D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_ARRAY_SIZE_MISMATCH = D3D12_MESSAGE_ID.RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_ARRAY_SIZE_MISMATCH;
pub const D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_MISMATCHING_TARGETED_RESOURCE = D3D12_MESSAGE_ID.SAMPLER_FEEDBACK_CREATE_UAV_MISMATCHING_TARGETED_RESOURCE;
pub const D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTPUTEXCEEDSMAXSIZE = D3D12_MESSAGE_ID.CREATEMESHSHADER_OUTPUTEXCEEDSMAXSIZE;
pub const D3D12_MESSAGE_ID_CREATEMESHSHADER_GROUPSHAREDEXCEEDSMAXSIZE = D3D12_MESSAGE_ID.CREATEMESHSHADER_GROUPSHAREDEXCEEDSMAXSIZE;
pub const D3D12_MESSAGE_ID_VERTEX_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = D3D12_MESSAGE_ID.VERTEX_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE;
pub const D3D12_MESSAGE_ID_MESH_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = D3D12_MESSAGE_ID.MESH_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE;
pub const D3D12_MESSAGE_ID_CREATEMESHSHADER_MISMATCHEDASMSPAYLOADSIZE = D3D12_MESSAGE_ID.CREATEMESHSHADER_MISMATCHEDASMSPAYLOADSIZE;
pub const D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_UNBOUNDED_STATIC_DESCRIPTORS = D3D12_MESSAGE_ID.CREATE_ROOT_SIGNATURE_UNBOUNDED_STATIC_DESCRIPTORS;
pub const D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_INVALIDSHADERBYTECODE = D3D12_MESSAGE_ID.CREATEAMPLIFICATIONSHADER_INVALIDSHADERBYTECODE;
pub const D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_OUTOFMEMORY = D3D12_MESSAGE_ID.CREATEAMPLIFICATIONSHADER_OUTOFMEMORY;
pub const D3D12_MESSAGE_ID_CREATE_SHADERCACHESESSION = D3D12_MESSAGE_ID.CREATE_SHADERCACHESESSION;
pub const D3D12_MESSAGE_ID_LIVE_SHADERCACHESESSION = D3D12_MESSAGE_ID.LIVE_SHADERCACHESESSION;
pub const D3D12_MESSAGE_ID_DESTROY_SHADERCACHESESSION = D3D12_MESSAGE_ID.DESTROY_SHADERCACHESESSION;
pub const D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_INVALIDARGS = D3D12_MESSAGE_ID.CREATESHADERCACHESESSION_INVALIDARGS;
pub const D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_DISABLED = D3D12_MESSAGE_ID.CREATESHADERCACHESESSION_DISABLED;
pub const D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_ALREADYOPEN = D3D12_MESSAGE_ID.CREATESHADERCACHESESSION_ALREADYOPEN;
pub const D3D12_MESSAGE_ID_SHADERCACHECONTROL_DEVELOPERMODE = D3D12_MESSAGE_ID.SHADERCACHECONTROL_DEVELOPERMODE;
pub const D3D12_MESSAGE_ID_SHADERCACHECONTROL_INVALIDFLAGS = D3D12_MESSAGE_ID.SHADERCACHECONTROL_INVALIDFLAGS;
pub const D3D12_MESSAGE_ID_SHADERCACHECONTROL_STATEALREADYSET = D3D12_MESSAGE_ID.SHADERCACHECONTROL_STATEALREADYSET;
pub const D3D12_MESSAGE_ID_SHADERCACHECONTROL_IGNOREDFLAG = D3D12_MESSAGE_ID.SHADERCACHECONTROL_IGNOREDFLAG;
pub const D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_ALREADYPRESENT = D3D12_MESSAGE_ID.SHADERCACHESESSION_STOREVALUE_ALREADYPRESENT;
pub const D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_HASHCOLLISION = D3D12_MESSAGE_ID.SHADERCACHESESSION_STOREVALUE_HASHCOLLISION;
pub const D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_CACHEFULL = D3D12_MESSAGE_ID.SHADERCACHESESSION_STOREVALUE_CACHEFULL;
pub const D3D12_MESSAGE_ID_SHADERCACHESESSION_FINDVALUE_NOTFOUND = D3D12_MESSAGE_ID.SHADERCACHESESSION_FINDVALUE_NOTFOUND;
pub const D3D12_MESSAGE_ID_SHADERCACHESESSION_CORRUPT = D3D12_MESSAGE_ID.SHADERCACHESESSION_CORRUPT;
pub const D3D12_MESSAGE_ID_SHADERCACHESESSION_DISABLED = D3D12_MESSAGE_ID.SHADERCACHESESSION_DISABLED;
pub const D3D12_MESSAGE_ID_OVERSIZED_DISPATCH = D3D12_MESSAGE_ID.OVERSIZED_DISPATCH;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOENCODER = D3D12_MESSAGE_ID.CREATE_VIDEOENCODER;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOENCODER = D3D12_MESSAGE_ID.LIVE_VIDEOENCODER;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOENCODER = D3D12_MESSAGE_ID.DESTROY_VIDEOENCODER;
pub const D3D12_MESSAGE_ID_CREATE_VIDEOENCODERHEAP = D3D12_MESSAGE_ID.CREATE_VIDEOENCODERHEAP;
pub const D3D12_MESSAGE_ID_LIVE_VIDEOENCODERHEAP = D3D12_MESSAGE_ID.LIVE_VIDEOENCODERHEAP;
pub const D3D12_MESSAGE_ID_DESTROY_VIDEOENCODERHEAP = D3D12_MESSAGE_ID.DESTROY_VIDEOENCODERHEAP;
pub const D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG = D3D12_MESSAGE_ID.COPYTEXTUREREGION_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG;
pub const D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG = D3D12_MESSAGE_ID.COPYRESOURCE_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG;
pub const D3D12_MESSAGE_ID_ENCODE_FRAME_INVALID_PARAMETERS = D3D12_MESSAGE_ID.ENCODE_FRAME_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_ENCODE_FRAME_UNSUPPORTED_PARAMETERS = D3D12_MESSAGE_ID.ENCODE_FRAME_UNSUPPORTED_PARAMETERS;
pub const D3D12_MESSAGE_ID_RESOLVE_ENCODER_OUTPUT_METADATA_INVALID_PARAMETERS = D3D12_MESSAGE_ID.RESOLVE_ENCODER_OUTPUT_METADATA_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_RESOLVE_ENCODER_OUTPUT_METADATA_UNSUPPORTED_PARAMETERS = D3D12_MESSAGE_ID.RESOLVE_ENCODER_OUTPUT_METADATA_UNSUPPORTED_PARAMETERS;
pub const D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_INVALID_PARAMETERS = D3D12_MESSAGE_ID.CREATE_VIDEO_ENCODER_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_UNSUPPORTED_PARAMETERS = D3D12_MESSAGE_ID.CREATE_VIDEO_ENCODER_UNSUPPORTED_PARAMETERS;
pub const D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_HEAP_INVALID_PARAMETERS = D3D12_MESSAGE_ID.CREATE_VIDEO_ENCODER_HEAP_INVALID_PARAMETERS;
pub const D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_HEAP_UNSUPPORTED_PARAMETERS = D3D12_MESSAGE_ID.CREATE_VIDEO_ENCODER_HEAP_UNSUPPORTED_PARAMETERS;
pub const D3D12_MESSAGE_ID_CREATECOMMANDLIST_NULL_COMMANDALLOCATOR = D3D12_MESSAGE_ID.CREATECOMMANDLIST_NULL_COMMANDALLOCATOR;
pub const D3D12_MESSAGE_ID_CLEAR_UNORDERED_ACCESS_VIEW_INVALID_DESCRIPTOR_HANDLE = D3D12_MESSAGE_ID.CLEAR_UNORDERED_ACCESS_VIEW_INVALID_DESCRIPTOR_HANDLE;
pub const D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SHADER_VISIBLE = D3D12_MESSAGE_ID.DESCRIPTOR_HEAP_NOT_SHADER_VISIBLE;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_BLENDOP_WARNING = D3D12_MESSAGE_ID.CREATEBLENDSTATE_BLENDOP_WARNING;
pub const D3D12_MESSAGE_ID_CREATEBLENDSTATE_BLENDOPALPHA_WARNING = D3D12_MESSAGE_ID.CREATEBLENDSTATE_BLENDOPALPHA_WARNING;
pub const D3D12_MESSAGE_ID_WRITE_COMBINE_PERFORMANCE_WARNING = D3D12_MESSAGE_ID.WRITE_COMBINE_PERFORMANCE_WARNING;
pub const D3D12_MESSAGE_ID_RESOLVE_QUERY_INVALID_QUERY_STATE = D3D12_MESSAGE_ID.RESOLVE_QUERY_INVALID_QUERY_STATE;
pub const D3D12_MESSAGE_ID_SETPRIVATEDATA_NO_ACCESS = D3D12_MESSAGE_ID.SETPRIVATEDATA_NO_ACCESS;
pub const D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_SAMPLER_MODE_MISMATCH = D3D12_MESSAGE_ID.COMMAND_LIST_STATIC_DESCRIPTOR_SAMPLER_MODE_MISMATCH;
pub const D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_UNSUPPORTED_BUFFER_WIDTH = D3D12_MESSAGE_ID.GETCOPYABLEFOOTPRINTS_UNSUPPORTED_BUFFER_WIDTH;
pub const D3D12_MESSAGE_ID_CREATEMESHSHADER_TOPOLOGY_MISMATCH = D3D12_MESSAGE_ID.CREATEMESHSHADER_TOPOLOGY_MISMATCH;
pub const D3D12_MESSAGE_ID_VRS_SUM_COMBINER_REQUIRES_CAPABILITY = D3D12_MESSAGE_ID.VRS_SUM_COMBINER_REQUIRES_CAPABILITY;
pub const D3D12_MESSAGE_ID_SETTING_SHADING_RATE_FROM_MS_REQUIRES_CAPABILITY = D3D12_MESSAGE_ID.SETTING_SHADING_RATE_FROM_MS_REQUIRES_CAPABILITY;
pub const D3D12_MESSAGE_ID_SHADERCACHESESSION_SHADERCACHEDELETE_NOTSUPPORTED = D3D12_MESSAGE_ID.SHADERCACHESESSION_SHADERCACHEDELETE_NOTSUPPORTED;
pub const D3D12_MESSAGE_ID_SHADERCACHECONTROL_SHADERCACHECLEAR_NOTSUPPORTED = D3D12_MESSAGE_ID.SHADERCACHECONTROL_SHADERCACHECLEAR_NOTSUPPORTED;
pub const D3D12_MESSAGE_ID_D3D12_MESSAGES_END = D3D12_MESSAGE_ID.D3D12_MESSAGES_END;
pub const D3D12_MESSAGE = extern struct {
Category: D3D12_MESSAGE_CATEGORY,
Severity: D3D12_MESSAGE_SEVERITY,
ID: D3D12_MESSAGE_ID,
pDescription: ?*const u8,
DescriptionByteLength: usize,
};
pub const D3D12_INFO_QUEUE_FILTER_DESC = extern struct {
NumCategories: u32,
pCategoryList: ?*D3D12_MESSAGE_CATEGORY,
NumSeverities: u32,
pSeverityList: ?*D3D12_MESSAGE_SEVERITY,
NumIDs: u32,
pIDList: ?*D3D12_MESSAGE_ID,
};
pub const D3D12_INFO_QUEUE_FILTER = extern struct {
AllowList: D3D12_INFO_QUEUE_FILTER_DESC,
DenyList: D3D12_INFO_QUEUE_FILTER_DESC,
};
const IID_ID3D12InfoQueue_Value = Guid.initString("0742a90b-c387-483f-b946-30a7e4e61458");
pub const IID_ID3D12InfoQueue = &IID_ID3D12InfoQueue_Value;
pub const ID3D12InfoQueue = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetMessageCountLimit: fn(
self: *const ID3D12InfoQueue,
MessageCountLimit: u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ClearStoredMessages: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) void,
GetMessage: fn(
self: *const ID3D12InfoQueue,
MessageIndex: u64,
// TODO: what to do with BytesParamIndex 2?
pMessage: ?*D3D12_MESSAGE,
pMessageByteLength: ?*usize,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNumMessagesAllowedByStorageFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) u64,
GetNumMessagesDeniedByStorageFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) u64,
GetNumStoredMessages: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) u64,
GetNumStoredMessagesAllowedByRetrievalFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) u64,
GetNumMessagesDiscardedByMessageCountLimit: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) u64,
GetMessageCountLimit: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) u64,
AddStorageFilterEntries: fn(
self: *const ID3D12InfoQueue,
pFilter: ?*D3D12_INFO_QUEUE_FILTER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStorageFilter: fn(
self: *const ID3D12InfoQueue,
// TODO: what to do with BytesParamIndex 1?
pFilter: ?*D3D12_INFO_QUEUE_FILTER,
pFilterByteLength: ?*usize,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ClearStorageFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) void,
PushEmptyStorageFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PushCopyOfStorageFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PushStorageFilter: fn(
self: *const ID3D12InfoQueue,
pFilter: ?*D3D12_INFO_QUEUE_FILTER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PopStorageFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) void,
GetStorageFilterStackSize: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) u32,
AddRetrievalFilterEntries: fn(
self: *const ID3D12InfoQueue,
pFilter: ?*D3D12_INFO_QUEUE_FILTER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRetrievalFilter: fn(
self: *const ID3D12InfoQueue,
// TODO: what to do with BytesParamIndex 1?
pFilter: ?*D3D12_INFO_QUEUE_FILTER,
pFilterByteLength: ?*usize,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ClearRetrievalFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) void,
PushEmptyRetrievalFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PushCopyOfRetrievalFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PushRetrievalFilter: fn(
self: *const ID3D12InfoQueue,
pFilter: ?*D3D12_INFO_QUEUE_FILTER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PopRetrievalFilter: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) void,
GetRetrievalFilterStackSize: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) u32,
AddMessage: fn(
self: *const ID3D12InfoQueue,
Category: D3D12_MESSAGE_CATEGORY,
Severity: D3D12_MESSAGE_SEVERITY,
ID: D3D12_MESSAGE_ID,
pDescription: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddApplicationMessage: fn(
self: *const ID3D12InfoQueue,
Severity: D3D12_MESSAGE_SEVERITY,
pDescription: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetBreakOnCategory: fn(
self: *const ID3D12InfoQueue,
Category: D3D12_MESSAGE_CATEGORY,
bEnable: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetBreakOnSeverity: fn(
self: *const ID3D12InfoQueue,
Severity: D3D12_MESSAGE_SEVERITY,
bEnable: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetBreakOnID: fn(
self: *const ID3D12InfoQueue,
ID: D3D12_MESSAGE_ID,
bEnable: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetBreakOnCategory: fn(
self: *const ID3D12InfoQueue,
Category: D3D12_MESSAGE_CATEGORY,
) callconv(@import("std").os.windows.WINAPI) BOOL,
GetBreakOnSeverity: fn(
self: *const ID3D12InfoQueue,
Severity: D3D12_MESSAGE_SEVERITY,
) callconv(@import("std").os.windows.WINAPI) BOOL,
GetBreakOnID: fn(
self: *const ID3D12InfoQueue,
ID: D3D12_MESSAGE_ID,
) callconv(@import("std").os.windows.WINAPI) BOOL,
SetMuteDebugOutput: fn(
self: *const ID3D12InfoQueue,
bMute: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
GetMuteDebugOutput: fn(
self: *const ID3D12InfoQueue,
) callconv(@import("std").os.windows.WINAPI) BOOL,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_SetMessageCountLimit(self: *const T, MessageCountLimit: u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).SetMessageCountLimit(@ptrCast(*const ID3D12InfoQueue, self), MessageCountLimit);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_ClearStoredMessages(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).ClearStoredMessages(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetMessage(self: *const T, MessageIndex: u64, pMessage: ?*D3D12_MESSAGE, pMessageByteLength: ?*usize) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetMessage(@ptrCast(*const ID3D12InfoQueue, self), MessageIndex, pMessage, pMessageByteLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetNumMessagesAllowedByStorageFilter(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetNumMessagesAllowedByStorageFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetNumMessagesDeniedByStorageFilter(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetNumMessagesDeniedByStorageFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetNumStoredMessages(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetNumStoredMessages(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetNumStoredMessagesAllowedByRetrievalFilter(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetNumStoredMessagesAllowedByRetrievalFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetNumMessagesDiscardedByMessageCountLimit(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetNumMessagesDiscardedByMessageCountLimit(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetMessageCountLimit(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetMessageCountLimit(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_AddStorageFilterEntries(self: *const T, pFilter: ?*D3D12_INFO_QUEUE_FILTER) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).AddStorageFilterEntries(@ptrCast(*const ID3D12InfoQueue, self), pFilter);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetStorageFilter(self: *const T, pFilter: ?*D3D12_INFO_QUEUE_FILTER, pFilterByteLength: ?*usize) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetStorageFilter(@ptrCast(*const ID3D12InfoQueue, self), pFilter, pFilterByteLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_ClearStorageFilter(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).ClearStorageFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_PushEmptyStorageFilter(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).PushEmptyStorageFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_PushCopyOfStorageFilter(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).PushCopyOfStorageFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_PushStorageFilter(self: *const T, pFilter: ?*D3D12_INFO_QUEUE_FILTER) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).PushStorageFilter(@ptrCast(*const ID3D12InfoQueue, self), pFilter);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_PopStorageFilter(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).PopStorageFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetStorageFilterStackSize(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetStorageFilterStackSize(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_AddRetrievalFilterEntries(self: *const T, pFilter: ?*D3D12_INFO_QUEUE_FILTER) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).AddRetrievalFilterEntries(@ptrCast(*const ID3D12InfoQueue, self), pFilter);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetRetrievalFilter(self: *const T, pFilter: ?*D3D12_INFO_QUEUE_FILTER, pFilterByteLength: ?*usize) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetRetrievalFilter(@ptrCast(*const ID3D12InfoQueue, self), pFilter, pFilterByteLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_ClearRetrievalFilter(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).ClearRetrievalFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_PushEmptyRetrievalFilter(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).PushEmptyRetrievalFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_PushCopyOfRetrievalFilter(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).PushCopyOfRetrievalFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_PushRetrievalFilter(self: *const T, pFilter: ?*D3D12_INFO_QUEUE_FILTER) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).PushRetrievalFilter(@ptrCast(*const ID3D12InfoQueue, self), pFilter);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_PopRetrievalFilter(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).PopRetrievalFilter(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetRetrievalFilterStackSize(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetRetrievalFilterStackSize(@ptrCast(*const ID3D12InfoQueue, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_AddMessage(self: *const T, Category: D3D12_MESSAGE_CATEGORY, Severity: D3D12_MESSAGE_SEVERITY, ID: D3D12_MESSAGE_ID, pDescription: ?[*:0]const u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).AddMessage(@ptrCast(*const ID3D12InfoQueue, self), Category, Severity, ID, pDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_AddApplicationMessage(self: *const T, Severity: D3D12_MESSAGE_SEVERITY, pDescription: ?[*:0]const u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).AddApplicationMessage(@ptrCast(*const ID3D12InfoQueue, self), Severity, pDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_SetBreakOnCategory(self: *const T, Category: D3D12_MESSAGE_CATEGORY, bEnable: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).SetBreakOnCategory(@ptrCast(*const ID3D12InfoQueue, self), Category, bEnable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_SetBreakOnSeverity(self: *const T, Severity: D3D12_MESSAGE_SEVERITY, bEnable: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).SetBreakOnSeverity(@ptrCast(*const ID3D12InfoQueue, self), Severity, bEnable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_SetBreakOnID(self: *const T, ID: D3D12_MESSAGE_ID, bEnable: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).SetBreakOnID(@ptrCast(*const ID3D12InfoQueue, self), ID, bEnable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetBreakOnCategory(self: *const T, Category: D3D12_MESSAGE_CATEGORY) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetBreakOnCategory(@ptrCast(*const ID3D12InfoQueue, self), Category);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetBreakOnSeverity(self: *const T, Severity: D3D12_MESSAGE_SEVERITY) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetBreakOnSeverity(@ptrCast(*const ID3D12InfoQueue, self), Severity);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetBreakOnID(self: *const T, ID: D3D12_MESSAGE_ID) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetBreakOnID(@ptrCast(*const ID3D12InfoQueue, self), ID);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_SetMuteDebugOutput(self: *const T, bMute: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).SetMuteDebugOutput(@ptrCast(*const ID3D12InfoQueue, self), bMute);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue_GetMuteDebugOutput(self: *const T) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12InfoQueue.VTable, self.vtable).GetMuteDebugOutput(@ptrCast(*const ID3D12InfoQueue, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_MESSAGE_CALLBACK_FLAGS = enum(i32) {
FLAG_NONE = 0,
IGNORE_FILTERS = 1,
};
pub const D3D12_MESSAGE_CALLBACK_FLAG_NONE = D3D12_MESSAGE_CALLBACK_FLAGS.FLAG_NONE;
pub const D3D12_MESSAGE_CALLBACK_IGNORE_FILTERS = D3D12_MESSAGE_CALLBACK_FLAGS.IGNORE_FILTERS;
pub const D3D12MessageFunc = fn(
Category: D3D12_MESSAGE_CATEGORY,
Severity: D3D12_MESSAGE_SEVERITY,
ID: D3D12_MESSAGE_ID,
pDescription: ?[*:0]const u8,
pContext: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;
const IID_ID3D12InfoQueue1_Value = Guid.initString("2852dd88-b484-4c0c-b6b1-67168500e600");
pub const IID_ID3D12InfoQueue1 = &IID_ID3D12InfoQueue1_Value;
pub const ID3D12InfoQueue1 = extern struct {
pub const VTable = extern struct {
base: ID3D12InfoQueue.VTable,
RegisterMessageCallback: fn(
self: *const ID3D12InfoQueue1,
CallbackFunc: ?D3D12MessageFunc,
CallbackFilterFlags: D3D12_MESSAGE_CALLBACK_FLAGS,
pContext: ?*anyopaque,
pCallbackCookie: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterMessageCallback: fn(
self: *const ID3D12InfoQueue1,
CallbackCookie: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12InfoQueue.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue1_RegisterMessageCallback(self: *const T, CallbackFunc: ?D3D12MessageFunc, CallbackFilterFlags: D3D12_MESSAGE_CALLBACK_FLAGS, pContext: ?*anyopaque, pCallbackCookie: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue1.VTable, self.vtable).RegisterMessageCallback(@ptrCast(*const ID3D12InfoQueue1, self), CallbackFunc, CallbackFilterFlags, pContext, pCallbackCookie);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12InfoQueue1_UnregisterMessageCallback(self: *const T, CallbackCookie: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12InfoQueue1.VTable, self.vtable).UnregisterMessageCallback(@ptrCast(*const ID3D12InfoQueue1, self), CallbackCookie);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const PFN_D3D12_CREATE_DEVICE = fn(
param0: ?*IUnknown,
param1: D3D_FEATURE_LEVEL,
param2: ?*const Guid,
param3: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PFN_D3D12_GET_DEBUG_INTERFACE = fn(
param0: ?*const Guid,
param1: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PFN_D3D12_GET_INTERFACE = fn(
param0: ?*const Guid,
param1: ?*const Guid,
param2: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
const IID_ID3D12SDKConfiguration_Value = Guid.initString("e9eb5314-33aa-42b2-a718-d77f58b1f1c7");
pub const IID_ID3D12SDKConfiguration = &IID_ID3D12SDKConfiguration_Value;
pub const ID3D12SDKConfiguration = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetSDKVersion: fn(
self: *const ID3D12SDKConfiguration,
SDKVersion: u32,
SDKPath: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12SDKConfiguration_SetSDKVersion(self: *const T, SDKVersion: u32, SDKPath: ?[*:0]const u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12SDKConfiguration.VTable, self.vtable).SetSDKVersion(@ptrCast(*const ID3D12SDKConfiguration, self), SDKVersion, SDKPath);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_AXIS_SHADING_RATE = enum(i32) {
@"1X" = 0,
@"2X" = 1,
@"4X" = 2,
};
pub const D3D12_AXIS_SHADING_RATE_1X = D3D12_AXIS_SHADING_RATE.@"1X";
pub const D3D12_AXIS_SHADING_RATE_2X = D3D12_AXIS_SHADING_RATE.@"2X";
pub const D3D12_AXIS_SHADING_RATE_4X = D3D12_AXIS_SHADING_RATE.@"4X";
pub const D3D12_SHADING_RATE = enum(i32) {
@"1X1" = 0,
@"1X2" = 1,
@"2X1" = 4,
@"2X2" = 5,
@"2X4" = 6,
@"4X2" = 9,
@"4X4" = 10,
};
pub const D3D12_SHADING_RATE_1X1 = D3D12_SHADING_RATE.@"1X1";
pub const D3D12_SHADING_RATE_1X2 = D3D12_SHADING_RATE.@"1X2";
pub const D3D12_SHADING_RATE_2X1 = D3D12_SHADING_RATE.@"2X1";
pub const D3D12_SHADING_RATE_2X2 = D3D12_SHADING_RATE.@"2X2";
pub const D3D12_SHADING_RATE_2X4 = D3D12_SHADING_RATE.@"2X4";
pub const D3D12_SHADING_RATE_4X2 = D3D12_SHADING_RATE.@"4X2";
pub const D3D12_SHADING_RATE_4X4 = D3D12_SHADING_RATE.@"4X4";
pub const D3D12_SHADING_RATE_COMBINER = enum(i32) {
PASSTHROUGH = 0,
OVERRIDE = 1,
MIN = 2,
MAX = 3,
SUM = 4,
};
pub const D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = D3D12_SHADING_RATE_COMBINER.PASSTHROUGH;
pub const D3D12_SHADING_RATE_COMBINER_OVERRIDE = D3D12_SHADING_RATE_COMBINER.OVERRIDE;
pub const D3D12_SHADING_RATE_COMBINER_MIN = D3D12_SHADING_RATE_COMBINER.MIN;
pub const D3D12_SHADING_RATE_COMBINER_MAX = D3D12_SHADING_RATE_COMBINER.MAX;
pub const D3D12_SHADING_RATE_COMBINER_SUM = D3D12_SHADING_RATE_COMBINER.SUM;
const IID_ID3D12GraphicsCommandList5_Value = Guid.initString("55050859-4024-474c-87f5-6472eaee44ea");
pub const IID_ID3D12GraphicsCommandList5 = &IID_ID3D12GraphicsCommandList5_Value;
pub const ID3D12GraphicsCommandList5 = extern struct {
pub const VTable = extern struct {
base: ID3D12GraphicsCommandList4.VTable,
RSSetShadingRate: fn(
self: *const ID3D12GraphicsCommandList5,
baseShadingRate: D3D12_SHADING_RATE,
combiners: ?*const D3D12_SHADING_RATE_COMBINER,
) callconv(@import("std").os.windows.WINAPI) void,
RSSetShadingRateImage: fn(
self: *const ID3D12GraphicsCommandList5,
shadingRateImage: ?*ID3D12Resource,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12GraphicsCommandList4.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList5_RSSetShadingRate(self: *const T, baseShadingRate: D3D12_SHADING_RATE, combiners: ?*const D3D12_SHADING_RATE_COMBINER) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList5.VTable, self.vtable).RSSetShadingRate(@ptrCast(*const ID3D12GraphicsCommandList5, self), baseShadingRate, combiners);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList5_RSSetShadingRateImage(self: *const T, shadingRateImage: ?*ID3D12Resource) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList5.VTable, self.vtable).RSSetShadingRateImage(@ptrCast(*const ID3D12GraphicsCommandList5, self), shadingRateImage);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_DISPATCH_MESH_ARGUMENTS = extern struct {
ThreadGroupCountX: u32,
ThreadGroupCountY: u32,
ThreadGroupCountZ: u32,
};
const IID_ID3D12GraphicsCommandList6_Value = Guid.initString("c3827890-e548-4cfa-96cf-5689a9370f80");
pub const IID_ID3D12GraphicsCommandList6 = &IID_ID3D12GraphicsCommandList6_Value;
pub const ID3D12GraphicsCommandList6 = extern struct {
pub const VTable = extern struct {
base: ID3D12GraphicsCommandList5.VTable,
DispatchMesh: fn(
self: *const ID3D12GraphicsCommandList6,
ThreadGroupCountX: u32,
ThreadGroupCountY: u32,
ThreadGroupCountZ: u32,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID3D12GraphicsCommandList5.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12GraphicsCommandList6_DispatchMesh(self: *const T, ThreadGroupCountX: u32, ThreadGroupCountY: u32, ThreadGroupCountZ: u32) callconv(.Inline) void {
return @ptrCast(*const ID3D12GraphicsCommandList6.VTable, self.vtable).DispatchMesh(@ptrCast(*const ID3D12GraphicsCommandList6, self), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D3D12_SHADER_VERSION_TYPE = enum(i32) {
PIXEL_SHADER = 0,
VERTEX_SHADER = 1,
GEOMETRY_SHADER = 2,
HULL_SHADER = 3,
DOMAIN_SHADER = 4,
COMPUTE_SHADER = 5,
RESERVED0 = 65520,
};
pub const D3D12_SHVER_PIXEL_SHADER = D3D12_SHADER_VERSION_TYPE.PIXEL_SHADER;
pub const D3D12_SHVER_VERTEX_SHADER = D3D12_SHADER_VERSION_TYPE.VERTEX_SHADER;
pub const D3D12_SHVER_GEOMETRY_SHADER = D3D12_SHADER_VERSION_TYPE.GEOMETRY_SHADER;
pub const D3D12_SHVER_HULL_SHADER = D3D12_SHADER_VERSION_TYPE.HULL_SHADER;
pub const D3D12_SHVER_DOMAIN_SHADER = D3D12_SHADER_VERSION_TYPE.DOMAIN_SHADER;
pub const D3D12_SHVER_COMPUTE_SHADER = D3D12_SHADER_VERSION_TYPE.COMPUTE_SHADER;
pub const D3D12_SHVER_RESERVED0 = D3D12_SHADER_VERSION_TYPE.RESERVED0;
pub const D3D12_SIGNATURE_PARAMETER_DESC = extern struct {
SemanticName: ?[*:0]const u8,
SemanticIndex: u32,
Register: u32,
SystemValueType: D3D_NAME,
ComponentType: D3D_REGISTER_COMPONENT_TYPE,
Mask: u8,
ReadWriteMask: u8,
Stream: u32,
MinPrecision: D3D_MIN_PRECISION,
};
pub const D3D12_SHADER_BUFFER_DESC = extern struct {
Name: ?[*:0]const u8,
Type: D3D_CBUFFER_TYPE,
Variables: u32,
Size: u32,
uFlags: u32,
};
pub const D3D12_SHADER_VARIABLE_DESC = extern struct {
Name: ?[*:0]const u8,
StartOffset: u32,
Size: u32,
uFlags: u32,
DefaultValue: ?*anyopaque,
StartTexture: u32,
TextureSize: u32,
StartSampler: u32,
SamplerSize: u32,
};
pub const D3D12_SHADER_TYPE_DESC = extern struct {
Class: D3D_SHADER_VARIABLE_CLASS,
Type: D3D_SHADER_VARIABLE_TYPE,
Rows: u32,
Columns: u32,
Elements: u32,
Members: u32,
Offset: u32,
Name: ?[*:0]const u8,
};
pub const D3D12_SHADER_DESC = extern struct {
Version: u32,
Creator: ?[*:0]const u8,
Flags: u32,
ConstantBuffers: u32,
BoundResources: u32,
InputParameters: u32,
OutputParameters: u32,
InstructionCount: u32,
TempRegisterCount: u32,
TempArrayCount: u32,
DefCount: u32,
DclCount: u32,
TextureNormalInstructions: u32,
TextureLoadInstructions: u32,
TextureCompInstructions: u32,
TextureBiasInstructions: u32,
TextureGradientInstructions: u32,
FloatInstructionCount: u32,
IntInstructionCount: u32,
UintInstructionCount: u32,
StaticFlowControlCount: u32,
DynamicFlowControlCount: u32,
MacroInstructionCount: u32,
ArrayInstructionCount: u32,
CutInstructionCount: u32,
EmitInstructionCount: u32,
GSOutputTopology: D3D_PRIMITIVE_TOPOLOGY,
GSMaxOutputVertexCount: u32,
InputPrimitive: D3D_PRIMITIVE,
PatchConstantParameters: u32,
cGSInstanceCount: u32,
cControlPoints: u32,
HSOutputPrimitive: D3D_TESSELLATOR_OUTPUT_PRIMITIVE,
HSPartitioning: D3D_TESSELLATOR_PARTITIONING,
TessellatorDomain: D3D_TESSELLATOR_DOMAIN,
cBarrierInstructions: u32,
cInterlockedInstructions: u32,
cTextureStoreInstructions: u32,
};
pub const D3D12_SHADER_INPUT_BIND_DESC = extern struct {
Name: ?[*:0]const u8,
Type: D3D_SHADER_INPUT_TYPE,
BindPoint: u32,
BindCount: u32,
uFlags: u32,
ReturnType: D3D_RESOURCE_RETURN_TYPE,
Dimension: D3D_SRV_DIMENSION,
NumSamples: u32,
Space: u32,
uID: u32,
};
pub const D3D12_LIBRARY_DESC = extern struct {
Creator: ?[*:0]const u8,
Flags: u32,
FunctionCount: u32,
};
pub const D3D12_FUNCTION_DESC = extern struct {
Version: u32,
Creator: ?[*:0]const u8,
Flags: u32,
ConstantBuffers: u32,
BoundResources: u32,
InstructionCount: u32,
TempRegisterCount: u32,
TempArrayCount: u32,
DefCount: u32,
DclCount: u32,
TextureNormalInstructions: u32,
TextureLoadInstructions: u32,
TextureCompInstructions: u32,
TextureBiasInstructions: u32,
TextureGradientInstructions: u32,
FloatInstructionCount: u32,
IntInstructionCount: u32,
UintInstructionCount: u32,
StaticFlowControlCount: u32,
DynamicFlowControlCount: u32,
MacroInstructionCount: u32,
ArrayInstructionCount: u32,
MovInstructionCount: u32,
MovcInstructionCount: u32,
ConversionInstructionCount: u32,
BitwiseInstructionCount: u32,
MinFeatureLevel: D3D_FEATURE_LEVEL,
RequiredFeatureFlags: u64,
Name: ?[*:0]const u8,
FunctionParameterCount: i32,
HasReturn: BOOL,
Has10Level9VertexShader: BOOL,
Has10Level9PixelShader: BOOL,
};
pub const D3D12_PARAMETER_DESC = extern struct {
Name: ?[*:0]const u8,
SemanticName: ?[*:0]const u8,
Type: D3D_SHADER_VARIABLE_TYPE,
Class: D3D_SHADER_VARIABLE_CLASS,
Rows: u32,
Columns: u32,
InterpolationMode: D3D_INTERPOLATION_MODE,
Flags: D3D_PARAMETER_FLAGS,
FirstInRegister: u32,
FirstInComponent: u32,
FirstOutRegister: u32,
FirstOutComponent: u32,
};
const IID_ID3D12ShaderReflectionType_Value = Guid.initString("e913c351-783d-48ca-a1d1-4f306284ad56");
pub const IID_ID3D12ShaderReflectionType = &IID_ID3D12ShaderReflectionType_Value;
pub const ID3D12ShaderReflectionType = extern struct {
pub const VTable = extern struct {
GetDesc: fn(
self: *const ID3D12ShaderReflectionType,
pDesc: ?*D3D12_SHADER_TYPE_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMemberTypeByIndex: fn(
self: *const ID3D12ShaderReflectionType,
Index: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionType,
GetMemberTypeByName: fn(
self: *const ID3D12ShaderReflectionType,
Name: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionType,
GetMemberTypeName: fn(
self: *const ID3D12ShaderReflectionType,
Index: u32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR,
IsEqual: fn(
self: *const ID3D12ShaderReflectionType,
pType: ?*ID3D12ShaderReflectionType,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSubType: fn(
self: *const ID3D12ShaderReflectionType,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionType,
GetBaseClass: fn(
self: *const ID3D12ShaderReflectionType,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionType,
GetNumInterfaces: fn(
self: *const ID3D12ShaderReflectionType,
) callconv(@import("std").os.windows.WINAPI) u32,
GetInterfaceByIndex: fn(
self: *const ID3D12ShaderReflectionType,
uIndex: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionType,
IsOfType: fn(
self: *const ID3D12ShaderReflectionType,
pType: ?*ID3D12ShaderReflectionType,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ImplementsInterface: fn(
self: *const ID3D12ShaderReflectionType,
pBase: ?*ID3D12ShaderReflectionType,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_GetDesc(self: *const T, pDesc: ?*D3D12_SHADER_TYPE_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12ShaderReflectionType, self), pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_GetMemberTypeByIndex(self: *const T, Index: u32) callconv(.Inline) ?*ID3D12ShaderReflectionType {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).GetMemberTypeByIndex(@ptrCast(*const ID3D12ShaderReflectionType, self), Index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_GetMemberTypeByName(self: *const T, Name: ?[*:0]const u8) callconv(.Inline) ?*ID3D12ShaderReflectionType {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).GetMemberTypeByName(@ptrCast(*const ID3D12ShaderReflectionType, self), Name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_GetMemberTypeName(self: *const T, Index: u32) callconv(.Inline) ?PSTR {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).GetMemberTypeName(@ptrCast(*const ID3D12ShaderReflectionType, self), Index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_IsEqual(self: *const T, pType: ?*ID3D12ShaderReflectionType) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).IsEqual(@ptrCast(*const ID3D12ShaderReflectionType, self), pType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_GetSubType(self: *const T) callconv(.Inline) ?*ID3D12ShaderReflectionType {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).GetSubType(@ptrCast(*const ID3D12ShaderReflectionType, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_GetBaseClass(self: *const T) callconv(.Inline) ?*ID3D12ShaderReflectionType {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).GetBaseClass(@ptrCast(*const ID3D12ShaderReflectionType, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_GetNumInterfaces(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).GetNumInterfaces(@ptrCast(*const ID3D12ShaderReflectionType, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_GetInterfaceByIndex(self: *const T, uIndex: u32) callconv(.Inline) ?*ID3D12ShaderReflectionType {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).GetInterfaceByIndex(@ptrCast(*const ID3D12ShaderReflectionType, self), uIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_IsOfType(self: *const T, pType: ?*ID3D12ShaderReflectionType) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).IsOfType(@ptrCast(*const ID3D12ShaderReflectionType, self), pType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionType_ImplementsInterface(self: *const T, pBase: ?*ID3D12ShaderReflectionType) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflectionType.VTable, self.vtable).ImplementsInterface(@ptrCast(*const ID3D12ShaderReflectionType, self), pBase);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12ShaderReflectionVariable_Value = Guid.initString("8337a8a6-a216-444a-b2f4-314733a73aea");
pub const IID_ID3D12ShaderReflectionVariable = &IID_ID3D12ShaderReflectionVariable_Value;
pub const ID3D12ShaderReflectionVariable = extern struct {
pub const VTable = extern struct {
GetDesc: fn(
self: *const ID3D12ShaderReflectionVariable,
pDesc: ?*D3D12_SHADER_VARIABLE_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetType: fn(
self: *const ID3D12ShaderReflectionVariable,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionType,
GetBuffer: fn(
self: *const ID3D12ShaderReflectionVariable,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionConstantBuffer,
GetInterfaceSlot: fn(
self: *const ID3D12ShaderReflectionVariable,
uArrayIndex: u32,
) callconv(@import("std").os.windows.WINAPI) u32,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionVariable_GetDesc(self: *const T, pDesc: ?*D3D12_SHADER_VARIABLE_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflectionVariable.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12ShaderReflectionVariable, self), pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionVariable_GetType(self: *const T) callconv(.Inline) ?*ID3D12ShaderReflectionType {
return @ptrCast(*const ID3D12ShaderReflectionVariable.VTable, self.vtable).GetType(@ptrCast(*const ID3D12ShaderReflectionVariable, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionVariable_GetBuffer(self: *const T) callconv(.Inline) ?*ID3D12ShaderReflectionConstantBuffer {
return @ptrCast(*const ID3D12ShaderReflectionVariable.VTable, self.vtable).GetBuffer(@ptrCast(*const ID3D12ShaderReflectionVariable, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionVariable_GetInterfaceSlot(self: *const T, uArrayIndex: u32) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12ShaderReflectionVariable.VTable, self.vtable).GetInterfaceSlot(@ptrCast(*const ID3D12ShaderReflectionVariable, self), uArrayIndex);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12ShaderReflectionConstantBuffer_Value = Guid.initString("c59598b4-48b3-4869-b9b1-b1618b14a8b7");
pub const IID_ID3D12ShaderReflectionConstantBuffer = &IID_ID3D12ShaderReflectionConstantBuffer_Value;
pub const ID3D12ShaderReflectionConstantBuffer = extern struct {
pub const VTable = extern struct {
GetDesc: fn(
self: *const ID3D12ShaderReflectionConstantBuffer,
pDesc: ?*D3D12_SHADER_BUFFER_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetVariableByIndex: fn(
self: *const ID3D12ShaderReflectionConstantBuffer,
Index: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionVariable,
GetVariableByName: fn(
self: *const ID3D12ShaderReflectionConstantBuffer,
Name: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionVariable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionConstantBuffer_GetDesc(self: *const T, pDesc: ?*D3D12_SHADER_BUFFER_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflectionConstantBuffer.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12ShaderReflectionConstantBuffer, self), pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionConstantBuffer_GetVariableByIndex(self: *const T, Index: u32) callconv(.Inline) ?*ID3D12ShaderReflectionVariable {
return @ptrCast(*const ID3D12ShaderReflectionConstantBuffer.VTable, self.vtable).GetVariableByIndex(@ptrCast(*const ID3D12ShaderReflectionConstantBuffer, self), Index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflectionConstantBuffer_GetVariableByName(self: *const T, Name: ?[*:0]const u8) callconv(.Inline) ?*ID3D12ShaderReflectionVariable {
return @ptrCast(*const ID3D12ShaderReflectionConstantBuffer.VTable, self.vtable).GetVariableByName(@ptrCast(*const ID3D12ShaderReflectionConstantBuffer, self), Name);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12ShaderReflection_Value = Guid.initString("5a58797d-a72c-478d-8ba2-efc6b0efe88e");
pub const IID_ID3D12ShaderReflection = &IID_ID3D12ShaderReflection_Value;
pub const ID3D12ShaderReflection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDesc: fn(
self: *const ID3D12ShaderReflection,
pDesc: ?*D3D12_SHADER_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConstantBufferByIndex: fn(
self: *const ID3D12ShaderReflection,
Index: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionConstantBuffer,
GetConstantBufferByName: fn(
self: *const ID3D12ShaderReflection,
Name: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionConstantBuffer,
GetResourceBindingDesc: fn(
self: *const ID3D12ShaderReflection,
ResourceIndex: u32,
pDesc: ?*D3D12_SHADER_INPUT_BIND_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInputParameterDesc: fn(
self: *const ID3D12ShaderReflection,
ParameterIndex: u32,
pDesc: ?*D3D12_SIGNATURE_PARAMETER_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetOutputParameterDesc: fn(
self: *const ID3D12ShaderReflection,
ParameterIndex: u32,
pDesc: ?*D3D12_SIGNATURE_PARAMETER_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPatchConstantParameterDesc: fn(
self: *const ID3D12ShaderReflection,
ParameterIndex: u32,
pDesc: ?*D3D12_SIGNATURE_PARAMETER_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetVariableByName: fn(
self: *const ID3D12ShaderReflection,
Name: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionVariable,
GetResourceBindingDescByName: fn(
self: *const ID3D12ShaderReflection,
Name: ?[*:0]const u8,
pDesc: ?*D3D12_SHADER_INPUT_BIND_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMovInstructionCount: fn(
self: *const ID3D12ShaderReflection,
) callconv(@import("std").os.windows.WINAPI) u32,
GetMovcInstructionCount: fn(
self: *const ID3D12ShaderReflection,
) callconv(@import("std").os.windows.WINAPI) u32,
GetConversionInstructionCount: fn(
self: *const ID3D12ShaderReflection,
) callconv(@import("std").os.windows.WINAPI) u32,
GetBitwiseInstructionCount: fn(
self: *const ID3D12ShaderReflection,
) callconv(@import("std").os.windows.WINAPI) u32,
GetGSInputPrimitive: fn(
self: *const ID3D12ShaderReflection,
) callconv(@import("std").os.windows.WINAPI) D3D_PRIMITIVE,
IsSampleFrequencyShader: fn(
self: *const ID3D12ShaderReflection,
) callconv(@import("std").os.windows.WINAPI) BOOL,
GetNumInterfaceSlots: fn(
self: *const ID3D12ShaderReflection,
) callconv(@import("std").os.windows.WINAPI) u32,
GetMinFeatureLevel: fn(
self: *const ID3D12ShaderReflection,
pLevel: ?*D3D_FEATURE_LEVEL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetThreadGroupSize: fn(
self: *const ID3D12ShaderReflection,
pSizeX: ?*u32,
pSizeY: ?*u32,
pSizeZ: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32,
GetRequiresFlags: fn(
self: *const ID3D12ShaderReflection,
) callconv(@import("std").os.windows.WINAPI) u64,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetDesc(self: *const T, pDesc: ?*D3D12_SHADER_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12ShaderReflection, self), pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetConstantBufferByIndex(self: *const T, Index: u32) callconv(.Inline) ?*ID3D12ShaderReflectionConstantBuffer {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetConstantBufferByIndex(@ptrCast(*const ID3D12ShaderReflection, self), Index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetConstantBufferByName(self: *const T, Name: ?[*:0]const u8) callconv(.Inline) ?*ID3D12ShaderReflectionConstantBuffer {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetConstantBufferByName(@ptrCast(*const ID3D12ShaderReflection, self), Name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetResourceBindingDesc(self: *const T, ResourceIndex: u32, pDesc: ?*D3D12_SHADER_INPUT_BIND_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetResourceBindingDesc(@ptrCast(*const ID3D12ShaderReflection, self), ResourceIndex, pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetInputParameterDesc(self: *const T, ParameterIndex: u32, pDesc: ?*D3D12_SIGNATURE_PARAMETER_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetInputParameterDesc(@ptrCast(*const ID3D12ShaderReflection, self), ParameterIndex, pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetOutputParameterDesc(self: *const T, ParameterIndex: u32, pDesc: ?*D3D12_SIGNATURE_PARAMETER_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetOutputParameterDesc(@ptrCast(*const ID3D12ShaderReflection, self), ParameterIndex, pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetPatchConstantParameterDesc(self: *const T, ParameterIndex: u32, pDesc: ?*D3D12_SIGNATURE_PARAMETER_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetPatchConstantParameterDesc(@ptrCast(*const ID3D12ShaderReflection, self), ParameterIndex, pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetVariableByName(self: *const T, Name: ?[*:0]const u8) callconv(.Inline) ?*ID3D12ShaderReflectionVariable {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetVariableByName(@ptrCast(*const ID3D12ShaderReflection, self), Name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetResourceBindingDescByName(self: *const T, Name: ?[*:0]const u8, pDesc: ?*D3D12_SHADER_INPUT_BIND_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetResourceBindingDescByName(@ptrCast(*const ID3D12ShaderReflection, self), Name, pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetMovInstructionCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetMovInstructionCount(@ptrCast(*const ID3D12ShaderReflection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetMovcInstructionCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetMovcInstructionCount(@ptrCast(*const ID3D12ShaderReflection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetConversionInstructionCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetConversionInstructionCount(@ptrCast(*const ID3D12ShaderReflection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetBitwiseInstructionCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetBitwiseInstructionCount(@ptrCast(*const ID3D12ShaderReflection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetGSInputPrimitive(self: *const T) callconv(.Inline) D3D_PRIMITIVE {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetGSInputPrimitive(@ptrCast(*const ID3D12ShaderReflection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_IsSampleFrequencyShader(self: *const T) callconv(.Inline) BOOL {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).IsSampleFrequencyShader(@ptrCast(*const ID3D12ShaderReflection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetNumInterfaceSlots(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetNumInterfaceSlots(@ptrCast(*const ID3D12ShaderReflection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetMinFeatureLevel(self: *const T, pLevel: ?*D3D_FEATURE_LEVEL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetMinFeatureLevel(@ptrCast(*const ID3D12ShaderReflection, self), pLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetThreadGroupSize(self: *const T, pSizeX: ?*u32, pSizeY: ?*u32, pSizeZ: ?*u32) callconv(.Inline) u32 {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetThreadGroupSize(@ptrCast(*const ID3D12ShaderReflection, self), pSizeX, pSizeY, pSizeZ);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12ShaderReflection_GetRequiresFlags(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID3D12ShaderReflection.VTable, self.vtable).GetRequiresFlags(@ptrCast(*const ID3D12ShaderReflection, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12LibraryReflection_Value = Guid.initString("8e349d19-54db-4a56-9dc9-119d87bdb804");
pub const IID_ID3D12LibraryReflection = &IID_ID3D12LibraryReflection_Value;
pub const ID3D12LibraryReflection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDesc: fn(
self: *const ID3D12LibraryReflection,
pDesc: ?*D3D12_LIBRARY_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFunctionByIndex: fn(
self: *const ID3D12LibraryReflection,
FunctionIndex: i32,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12FunctionReflection,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12LibraryReflection_GetDesc(self: *const T, pDesc: ?*D3D12_LIBRARY_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12LibraryReflection.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12LibraryReflection, self), pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12LibraryReflection_GetFunctionByIndex(self: *const T, FunctionIndex: i32) callconv(.Inline) ?*ID3D12FunctionReflection {
return @ptrCast(*const ID3D12LibraryReflection.VTable, self.vtable).GetFunctionByIndex(@ptrCast(*const ID3D12LibraryReflection, self), FunctionIndex);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12FunctionReflection_Value = Guid.initString("1108795c-2772-4ba9-b2a8-d464dc7e2799");
pub const IID_ID3D12FunctionReflection = &IID_ID3D12FunctionReflection_Value;
pub const ID3D12FunctionReflection = extern struct {
pub const VTable = extern struct {
GetDesc: fn(
self: *const ID3D12FunctionReflection,
pDesc: ?*D3D12_FUNCTION_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConstantBufferByIndex: fn(
self: *const ID3D12FunctionReflection,
BufferIndex: u32,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionConstantBuffer,
GetConstantBufferByName: fn(
self: *const ID3D12FunctionReflection,
Name: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionConstantBuffer,
GetResourceBindingDesc: fn(
self: *const ID3D12FunctionReflection,
ResourceIndex: u32,
pDesc: ?*D3D12_SHADER_INPUT_BIND_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetVariableByName: fn(
self: *const ID3D12FunctionReflection,
Name: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12ShaderReflectionVariable,
GetResourceBindingDescByName: fn(
self: *const ID3D12FunctionReflection,
Name: ?[*:0]const u8,
pDesc: ?*D3D12_SHADER_INPUT_BIND_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFunctionParameter: fn(
self: *const ID3D12FunctionReflection,
ParameterIndex: i32,
) callconv(@import("std").os.windows.WINAPI) ?*ID3D12FunctionParameterReflection,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12FunctionReflection_GetDesc(self: *const T, pDesc: ?*D3D12_FUNCTION_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12FunctionReflection.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12FunctionReflection, self), pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12FunctionReflection_GetConstantBufferByIndex(self: *const T, BufferIndex: u32) callconv(.Inline) ?*ID3D12ShaderReflectionConstantBuffer {
return @ptrCast(*const ID3D12FunctionReflection.VTable, self.vtable).GetConstantBufferByIndex(@ptrCast(*const ID3D12FunctionReflection, self), BufferIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12FunctionReflection_GetConstantBufferByName(self: *const T, Name: ?[*:0]const u8) callconv(.Inline) ?*ID3D12ShaderReflectionConstantBuffer {
return @ptrCast(*const ID3D12FunctionReflection.VTable, self.vtable).GetConstantBufferByName(@ptrCast(*const ID3D12FunctionReflection, self), Name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12FunctionReflection_GetResourceBindingDesc(self: *const T, ResourceIndex: u32, pDesc: ?*D3D12_SHADER_INPUT_BIND_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12FunctionReflection.VTable, self.vtable).GetResourceBindingDesc(@ptrCast(*const ID3D12FunctionReflection, self), ResourceIndex, pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12FunctionReflection_GetVariableByName(self: *const T, Name: ?[*:0]const u8) callconv(.Inline) ?*ID3D12ShaderReflectionVariable {
return @ptrCast(*const ID3D12FunctionReflection.VTable, self.vtable).GetVariableByName(@ptrCast(*const ID3D12FunctionReflection, self), Name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12FunctionReflection_GetResourceBindingDescByName(self: *const T, Name: ?[*:0]const u8, pDesc: ?*D3D12_SHADER_INPUT_BIND_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12FunctionReflection.VTable, self.vtable).GetResourceBindingDescByName(@ptrCast(*const ID3D12FunctionReflection, self), Name, pDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12FunctionReflection_GetFunctionParameter(self: *const T, ParameterIndex: i32) callconv(.Inline) ?*ID3D12FunctionParameterReflection {
return @ptrCast(*const ID3D12FunctionReflection.VTable, self.vtable).GetFunctionParameter(@ptrCast(*const ID3D12FunctionReflection, self), ParameterIndex);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID3D12FunctionParameterReflection_Value = Guid.initString("ec25f42d-7006-4f2b-b33e-02cc3375733f");
pub const IID_ID3D12FunctionParameterReflection = &IID_ID3D12FunctionParameterReflection_Value;
pub const ID3D12FunctionParameterReflection = extern struct {
pub const VTable = extern struct {
GetDesc: fn(
self: *const ID3D12FunctionParameterReflection,
pDesc: ?*D3D12_PARAMETER_DESC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID3D12FunctionParameterReflection_GetDesc(self: *const T, pDesc: ?*D3D12_PARAMETER_DESC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID3D12FunctionParameterReflection.VTable, self.vtable).GetDesc(@ptrCast(*const ID3D12FunctionParameterReflection, self), pDesc);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (8)
//--------------------------------------------------------------------------------
pub extern "d3d12" fn D3D12SerializeRootSignature(
pRootSignature: ?*const D3D12_ROOT_SIGNATURE_DESC,
Version: D3D_ROOT_SIGNATURE_VERSION,
ppBlob: ?*?*ID3DBlob,
ppErrorBlob: ?*?*ID3DBlob,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d3d12" fn D3D12CreateRootSignatureDeserializer(
// TODO: what to do with BytesParamIndex 1?
pSrcData: ?*const anyopaque,
SrcDataSizeInBytes: usize,
pRootSignatureDeserializerInterface: ?*const Guid,
ppRootSignatureDeserializer: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d3d12" fn D3D12SerializeVersionedRootSignature(
pRootSignature: ?*const D3D12_VERSIONED_ROOT_SIGNATURE_DESC,
ppBlob: ?*?*ID3DBlob,
ppErrorBlob: ?*?*ID3DBlob,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d3d12" fn D3D12CreateVersionedRootSignatureDeserializer(
// TODO: what to do with BytesParamIndex 1?
pSrcData: ?*const anyopaque,
SrcDataSizeInBytes: usize,
pRootSignatureDeserializerInterface: ?*const Guid,
ppRootSignatureDeserializer: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d3d12" fn D3D12CreateDevice(
pAdapter: ?*IUnknown,
MinimumFeatureLevel: D3D_FEATURE_LEVEL,
riid: ?*const Guid,
ppDevice: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d3d12" fn D3D12GetDebugInterface(
riid: ?*const Guid,
ppvDebug: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d3d12" fn D3D12EnableExperimentalFeatures(
NumFeatures: u32,
pIIDs: [*]const Guid,
pConfigurationStructs: ?[*]u8,
pConfigurationStructSizes: ?[*]u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d3d12" fn D3D12GetInterface(
rclsid: ?*const Guid,
riid: ?*const Guid,
ppvDebug: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (31)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const D3D_CBUFFER_TYPE = @import("../graphics/direct3d.zig").D3D_CBUFFER_TYPE;
const D3D_FEATURE_LEVEL = @import("../graphics/direct3d.zig").D3D_FEATURE_LEVEL;
const D3D_INTERPOLATION_MODE = @import("../graphics/direct3d.zig").D3D_INTERPOLATION_MODE;
const D3D_MIN_PRECISION = @import("../graphics/direct3d.zig").D3D_MIN_PRECISION;
const D3D_NAME = @import("../graphics/direct3d.zig").D3D_NAME;
const D3D_PARAMETER_FLAGS = @import("../graphics/direct3d.zig").D3D_PARAMETER_FLAGS;
const D3D_PRIMITIVE = @import("../graphics/direct3d.zig").D3D_PRIMITIVE;
const D3D_PRIMITIVE_TOPOLOGY = @import("../graphics/direct3d.zig").D3D_PRIMITIVE_TOPOLOGY;
const D3D_REGISTER_COMPONENT_TYPE = @import("../graphics/direct3d.zig").D3D_REGISTER_COMPONENT_TYPE;
const D3D_RESOURCE_RETURN_TYPE = @import("../graphics/direct3d.zig").D3D_RESOURCE_RETURN_TYPE;
const D3D_SHADER_INPUT_TYPE = @import("../graphics/direct3d.zig").D3D_SHADER_INPUT_TYPE;
const D3D_SHADER_VARIABLE_CLASS = @import("../graphics/direct3d.zig").D3D_SHADER_VARIABLE_CLASS;
const D3D_SHADER_VARIABLE_TYPE = @import("../graphics/direct3d.zig").D3D_SHADER_VARIABLE_TYPE;
const D3D_SRV_DIMENSION = @import("../graphics/direct3d.zig").D3D_SRV_DIMENSION;
const D3D_TESSELLATOR_DOMAIN = @import("../graphics/direct3d.zig").D3D_TESSELLATOR_DOMAIN;
const D3D_TESSELLATOR_OUTPUT_PRIMITIVE = @import("../graphics/direct3d.zig").D3D_TESSELLATOR_OUTPUT_PRIMITIVE;
const D3D_TESSELLATOR_PARTITIONING = @import("../graphics/direct3d.zig").D3D_TESSELLATOR_PARTITIONING;
const DXGI_FORMAT = @import("../graphics/dxgi/common.zig").DXGI_FORMAT;
const DXGI_SAMPLE_DESC = @import("../graphics/dxgi/common.zig").DXGI_SAMPLE_DESC;
const HANDLE = @import("../foundation.zig").HANDLE;
const HRESULT = @import("../foundation.zig").HRESULT;
const HWND = @import("../foundation.zig").HWND;
const ID3DBlob = @import("../graphics/direct3d.zig").ID3DBlob;
const IUnknown = @import("../system/com.zig").IUnknown;
const LUID = @import("../foundation.zig").LUID;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;
const RECT = @import("../foundation.zig").RECT;
const SECURITY_ATTRIBUTES = @import("../security.zig").SECURITY_ATTRIBUTES;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "PFN_D3D12_SERIALIZE_ROOT_SIGNATURE")) { _ = PFN_D3D12_SERIALIZE_ROOT_SIGNATURE; }
if (@hasDecl(@This(), "PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER")) { _ = PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER; }
if (@hasDecl(@This(), "PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE")) { _ = PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE; }
if (@hasDecl(@This(), "PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER")) { _ = PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER; }
if (@hasDecl(@This(), "D3D12MessageFunc")) { _ = D3D12MessageFunc; }
if (@hasDecl(@This(), "PFN_D3D12_CREATE_DEVICE")) { _ = PFN_D3D12_CREATE_DEVICE; }
if (@hasDecl(@This(), "PFN_D3D12_GET_DEBUG_INTERFACE")) { _ = PFN_D3D12_GET_DEBUG_INTERFACE; }
if (@hasDecl(@This(), "PFN_D3D12_GET_INTERFACE")) { _ = PFN_D3D12_GET_INTERFACE; }
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/graphics/direct3d12.zig |
const std = @import("std");
const assert = std.debug.assert;
const fs = std.fs;
const linux = std.os.linux;
const log = std.log.scoped(.journal);
const mem = std.mem;
const Allocator = mem.Allocator;
const os = std.os;
usingnamespace @import("tigerbeetle.zig");
usingnamespace @import("state.zig");
pub const Journal = struct {
allocator: *Allocator,
state: *State,
file: fs.File,
hash_chain_root: u128,
prev_hash_chain_root: u128,
headers: []JournalHeader align(config.sector_size),
entries: u64,
offset: u64,
pub fn init(allocator: *Allocator, state: *State) !Journal {
const path = "journal";
const file = try Journal.open(path);
errdefer file.close();
var headers = try allocator.allocAdvanced(
JournalHeader,
config.sector_size,
config.journal_entries_max,
.exact,
);
errdefer allocator.free(headers);
mem.set(u8, mem.sliceAsBytes(headers), 0);
var self = Journal{
.allocator = allocator,
.state = state,
.file = file,
.hash_chain_root = 0,
.prev_hash_chain_root = 0,
.headers = headers,
.entries = 0,
.offset = @sizeOf(JournalHeader) * headers.len,
};
assert(@mod(self.offset, config.sector_size) == 0);
assert(@mod(@ptrToInt(&headers[0]), config.sector_size) == 0);
log.debug("fd={}", .{self.file.handle});
try self.recover();
return self;
}
pub fn deinit(self: *Journal) void {
self.file.close();
}
/// Append a batch of events to the journal:
/// - The journal will overwrite the 64-byte header in place at the front of the buffer.
/// - The journal will also write the 64-byte EOF entry to the last sector of the buffer.
/// - `size` may be less than a sector multiple, but the remainder must already be zero padded.
/// - The buffer pointer address must be aligned to `config.sector_size` for direct I/O.
/// - The buffer length must similarly be a multiple of `config.sector_size`.
pub fn append(self: *Journal, command: Command, size: u32, buffer: []u8) !void {
assert(command != .eof);
assert(command != .ack);
assert(@sizeOf(JournalHeader) == @sizeOf(NetworkHeader));
assert(size >= @sizeOf(JournalHeader));
assert(buffer.len == Journal.append_size(size));
assert(buffer.len >= size + config.sector_size);
assert(buffer.len < size + config.sector_size + config.sector_size);
assert(@mod(@ptrToInt(buffer.ptr), config.sector_size) == 0);
assert(@mod(buffer.len, config.sector_size) == 0);
// TODO Snapshot before the journal file can overflow in entries or size.
// TODO Wrap around the journal file when appending and parsing.
if (self.entries + 2 > config.journal_entries_max) @panic("journal entries full");
if (self.offset + buffer.len > config.journal_size_max) @panic("journal size full");
// Write the entry header to the front of the buffer:
var entry = mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]);
entry.* = .{
.prev_checksum_meta = self.hash_chain_root,
.offset = self.offset,
.command = command,
.size = size,
};
// Zero padding is not included in the checksum since it is not material except to prevent
// buffer bleeds, which we assert against in Debug mode:
entry.set_checksum_data(buffer[@sizeOf(JournalHeader)..entry.size]);
entry.set_checksum_meta();
if (std.builtin.mode == .Debug) {
// Assert that the sector padding is already zeroed:
var sum_of_sector_padding_bytes: u32 = 0;
for (buffer[entry.size..]) |byte| sum_of_sector_padding_bytes += byte;
assert(sum_of_sector_padding_bytes == 0);
}
// Write the EOF entry to the last sector of the buffer:
const entry_sector_size = Journal.sector_ceil(entry.size);
assert(entry_sector_size == buffer.len - config.sector_size);
const eof = mem.bytesAsValue(
JournalHeader,
buffer[entry_sector_size..][0..@sizeOf(JournalHeader)],
);
eof.* = .{
.prev_checksum_meta = entry.checksum_meta,
.offset = entry.offset + entry_sector_size,
.command = .eof,
.size = @sizeOf(JournalHeader),
};
eof.set_checksum_data(buffer[entry_sector_size..][@sizeOf(JournalHeader)..eof.size]);
eof.set_checksum_meta();
// Write the request entry and EOF entry to the tail of the journal:
log.debug("appending: {}", .{entry});
log.debug("appending: {}", .{eof});
// Write the request entry and EOF entry headers to the head of the journal:
assert(self.headers[self.entries].command == .eof);
assert(self.headers[self.entries].prev_checksum_meta == entry.prev_checksum_meta);
self.headers[self.entries + 0] = entry.*;
self.headers[self.entries + 1] = eof.*;
var headers_offset = Journal.sector_floor(self.entries * @sizeOf(JournalHeader));
var headers_length = Journal.sector_ceil((self.entries + 2) * @sizeOf(JournalHeader));
const headers = mem.sliceAsBytes(self.headers)[headers_offset..headers_length];
// TODO Track exponentially weighted moving average (EWMA) of write latencies.
// TODO Warn when the short term EWMA of these latencies exceeds the long term EWMA.
// This will enable operators to monitor/replace slow hardware if it remains slow.
// TODO Do the same for network replication.
// Re-order these writes according to where the last write took place for better locality:
// e.g. If the disk previously wrote the headers last then write them first this time.
if (config.journal_disk_scheduler == .elevator and @mod(self.entries, 2) == 0) {
self.write(headers, headers_offset);
self.write(buffer, self.offset);
} else {
self.write(buffer, self.offset);
self.write(headers, headers_offset);
}
// Update journal state:
self.hash_chain_root = entry.checksum_meta;
self.prev_hash_chain_root = entry.prev_checksum_meta;
self.entries += 1;
self.offset += buffer.len - config.sector_size;
assert(self.entries < config.journal_entries_max);
assert(self.offset < config.journal_size_max);
}
fn sector_floor(offset: u64) u64 {
const sectors = std.math.divFloor(u64, offset, config.sector_size) catch unreachable;
return sectors * config.sector_size;
}
fn sector_ceil(offset: u64) u64 {
const sectors = std.math.divCeil(u64, offset, config.sector_size) catch unreachable;
return sectors * config.sector_size;
}
/// Returns the sector multiple size of a batch, plus a sector for the EOF entry.
pub fn append_size(request_size: u64) u64 {
assert(request_size > 0);
const sector_multiple = Journal.sector_ceil(request_size);
assert(sector_multiple >= request_size);
assert(sector_multiple < request_size + config.sector_size);
// Now add another sector for the EOF entry:
return sector_multiple + config.sector_size;
}
/// Detects whether the underlying file system for a given directory fd supports Direct I/O.
/// Not all Linux file systems support `O_DIRECT`, e.g. a shared macOS volume.
pub fn fs_supports_direct_io(dir_fd: os.fd_t) !bool {
if (!@hasDecl(os, "O_DIRECT")) return false;
const path = "fs_supports_direct_io";
const dir = fs.Dir{ .fd = dir_fd };
const fd = try os.openatZ(dir_fd, path, os.O_CLOEXEC | os.O_CREAT | os.O_TRUNC, 0o666);
defer os.close(fd);
defer dir.deleteFile(path) catch {};
while (true) {
const res = os.system.openat(dir_fd, path, os.O_CLOEXEC | os.O_RDONLY | os.O_DIRECT, 0);
switch (linux.getErrno(res)) {
0 => {
os.close(@intCast(os.fd_t, res));
return true;
},
linux.EINTR => continue,
linux.EINVAL => return false,
else => |err| return os.unexpectedErrno(err),
}
}
}
fn read(self: *Journal, buffer: []u8, offset: u64) void {
log.debug("read(buffer.len={} offset={})", .{ buffer.len, offset });
assert(buffer.len > 0);
assert(offset + buffer.len <= config.journal_size_max);
// Ensure that the read is aligned correctly for Direct I/O:
// If this is not the case, the underlying read syscall will return EINVAL.
assert(@mod(@ptrToInt(buffer.ptr), config.sector_size) == 0);
assert(@mod(buffer.len, config.sector_size) == 0);
assert(@mod(offset, config.sector_size) == 0);
if (self.file.preadAll(buffer, offset)) |bytes_read| {
if (bytes_read != buffer.len) {
log.debug("short read: bytes_read={} buffer_len={}", .{ bytes_read, buffer.len });
@panic("fs corruption: journal file size truncated");
}
} else |err| {
if (err == error.InputOutput) {
// The disk was unable to read some sectors (an internal crc or hardware failure):
if (buffer.len > config.sector_size) {
log.warn("latent sector error, subdividing read...", .{});
// Subdivide the read into sectors to read around the faulty sector(s):
// This is considerably slower than doing a bulk read.
// By now we might also have experienced the disk's read timeout (in seconds).
var position = offset;
const length = offset + buffer.len;
while (position < length) : (position += config.sector_size) {
self.read(buffer[position..][0..config.sector_size], position);
}
} else {
// Zero any remaining sectors that cannot be read:
// We treat these EIO errors the same as a checksum failure.
log.warn("latent sector error at offset {}, zeroing sector...", .{offset});
mem.set(u8, buffer, 0);
}
} else {
log.emerg("impossible read: err={}", .{err});
@panic("impossible read");
}
}
}
fn write(self: *Journal, buffer: []const u8, offset: u64) void {
log.debug("write(buffer.len={} offset={})", .{ buffer.len, offset });
assert(buffer.len > 0);
assert(offset + buffer.len <= config.journal_size_max);
assert(@mod(@ptrToInt(buffer.ptr), config.sector_size) == 0);
assert(@mod(buffer.len, config.sector_size) == 0);
assert(@mod(offset, config.sector_size) == 0);
self.file.pwriteAll(buffer, offset) catch |err| switch (err) {
error.InputOutput => @panic("latent sector error: no spare sectors to reallocate"),
else => {
log.emerg("write: error={} buffer.len={} offset={}", .{ err, buffer.len, offset });
@panic("unrecoverable disk error");
},
};
}
pub fn recover(self: *Journal) !void {
assert(self.hash_chain_root == 0);
assert(self.prev_hash_chain_root == 0);
assert(self.entries == 0);
assert(self.offset == config.journal_entries_max * @sizeOf(JournalHeader));
var buffer = try self.allocator.allocAdvanced(
u8,
config.sector_size,
config.request_size_max,
.exact,
);
defer self.allocator.free(buffer);
assert(@mod(@ptrToInt(buffer.ptr), config.sector_size) == 0);
assert(@mod(buffer.len, config.sector_size) == 0);
assert(@mod(config.journal_size_max, buffer.len) == 0);
assert(buffer.len > @sizeOf(JournalHeader));
const state_output = try self.allocator.alloc(u8, config.message_size_max);
defer self.allocator.free(state_output);
// Read entry headers from the head of the journal:
self.read(mem.sliceAsBytes(self.headers), 0);
// Read entry headers and entry data from the body of the journal:
while (self.offset < config.journal_size_max) {
self.read(buffer[0..], self.offset);
var offset: u64 = 0;
while (offset < buffer.len) {
if (offset + @sizeOf(JournalHeader) > buffer.len) break;
// TODO Repair headers at the head of the journal in memory.
// TODO Repair headers at the head of the journal on disk.
const d = &self.headers[self.entries];
const e = mem.bytesAsValue(
JournalHeader,
buffer[offset..][0..@sizeOf(JournalHeader)],
);
log.debug("d = {}", .{d});
log.debug("e = {}", .{e});
if (!d.valid_checksum_meta()) @panic("corrupt header");
if (d.prev_checksum_meta != self.hash_chain_root) @panic("misdirected");
if (d.offset != self.offset) @panic("bad offset");
if (self.entries > 0) {
const p = self.headers[self.entries - 1];
assert(d.prev_checksum_meta == p.checksum_meta);
assert(d.offset == p.offset + Journal.sector_ceil(p.size));
}
if (!e.valid_checksum_meta()) @panic("corrupt header");
if (e.prev_checksum_meta != self.hash_chain_root) @panic("misdirected");
if (e.offset != self.offset) @panic("bad offset");
if (e.checksum_meta != d.checksum_meta) @panic("different headers");
assert(e.command == d.command);
assert(e.size == d.size);
// Re-read the entry into the buffer, but starting from the beginning of the buffer:
if (offset + e.size > buffer.len) {
// Assert that the buffer is sufficient for the entry to avoid an infinite loop:
assert(buffer.len >= e.size);
break;
}
const entry_data = buffer[offset..][@sizeOf(JournalHeader)..e.size];
if (!e.valid_checksum_data(entry_data)) @panic("corrupt entry data");
if (e.command == .eof) {
assert(e.size == @sizeOf(JournalHeader));
log.info("hash_chain_root={} prev_hash_chain_root={}", .{
self.hash_chain_root,
self.prev_hash_chain_root,
});
log.info("entries={}/{} ({}%) offset={}/{} ({}%)", .{
self.entries,
config.journal_entries_max,
@divFloor(self.entries * 100, config.journal_entries_max),
self.offset,
config.journal_size_max,
@divFloor(self.offset * 100, config.journal_size_max),
});
// We exclude the EOF entry from self.entries and from self.offset:
// This means the offset is ready for the next append, which overwrites the EOF.
return;
}
_ = self.state.apply(e.command, entry_data, state_output[0..]);
self.hash_chain_root = e.checksum_meta;
self.prev_hash_chain_root = e.prev_checksum_meta;
self.entries += 1;
self.offset += Journal.sector_ceil(e.size);
offset += Journal.sector_ceil(e.size);
// We have not yet encountered the EOF entry, so there must be free space remaining:
assert(self.entries < config.journal_entries_max);
assert(self.offset < config.journal_size_max);
}
}
assert(self.offset == config.journal_size_max);
@panic("eof entry not found");
}
/// Creates an empty journal file:
/// - Calls fallocate() to allocate contiguous disk sectors (if possible).
/// - Zeroes the entire file to force allocation and improve performance (e.g. on EBS volumes).
/// - Writes an EOF entry.
fn create(path: []const u8) !fs.File {
log.info("creating {}...", .{path});
const file = try Journal.openat(std.fs.cwd().fd, path, true);
// Ask the file system to allocate contiguous sectors for the file (if possible):
// Some file systems will not support fallocate(), that's fine, but could mean more seeks.
log.debug("pre-allocating {Bi}...", .{config.journal_size_max});
Journal.fallocate(file.handle, 0, 0, config.journal_size_max) catch |err| switch (err) {
error.OperationNotSupported => {
log.notice("file system does not support fallocate()", .{});
},
else => return err,
};
// Dynamically allocate a buffer to zero the file:
// This is done only at cluster initialization and not in the critical path.
// TODO Use allocator passed to Journal.init() once we have support for cluster init.
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
var allocator = &arena.allocator;
var buffer = try allocator.allocAdvanced(
u8,
config.sector_size,
config.request_size_max,
.exact,
);
defer allocator.free(buffer);
mem.set(u8, buffer[0..], 0);
// Write zeroes to the disk to improve performance:
// These zeroes have no semantic meaning from a journal recovery point of view.
// We use zeroes because we have to use something and we don't want a buffer bleed.
log.debug("zeroing {Bi}...", .{config.journal_size_max});
assert(@mod(config.journal_size_max, buffer.len) == 0);
var zeroing_progress: u64 = 0;
var zeroing_offset: u64 = 0;
while (zeroing_offset < config.journal_size_max) {
assert(@mod(@ptrToInt(buffer.ptr), config.sector_size) == 0);
assert(@mod(buffer.len, config.sector_size) == 0);
assert(@mod(zeroing_offset, config.sector_size) == 0);
try file.pwriteAll(buffer, zeroing_offset);
zeroing_offset += buffer.len;
const zeroing_percent: u64 = @divTrunc(zeroing_offset * 100, config.journal_size_max);
if (zeroing_percent - zeroing_progress >= 20 or zeroing_percent == 100) {
log.debug("zeroing... {}%", .{zeroing_percent});
zeroing_progress = zeroing_percent;
}
}
assert(zeroing_offset == config.journal_size_max);
// Write the EOF entry to the head of the journal, and to the body of the journal:
const eof_head_offset = 0;
const eof_body_offset = config.journal_entries_max * @sizeOf(JournalHeader);
assert(@mod(eof_body_offset, config.sector_size) == 0);
const eof = mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]);
eof.* = .{
.prev_checksum_meta = 0, // TODO Use unique initialization state.
.offset = eof_body_offset,
.command = .eof,
.size = @sizeOf(JournalHeader),
};
eof.set_checksum_data(buffer[0..0]);
eof.set_checksum_meta();
log.debug("write(buffer.len={} offset={}): {}", .{
config.sector_size,
eof_body_offset,
eof,
});
try file.pwriteAll(buffer[0..config.sector_size], eof_body_offset);
log.debug("write(buffer.len={} offset={}): {}", .{
config.sector_size,
eof_head_offset,
eof,
});
try file.pwriteAll(buffer[0..config.sector_size], eof_head_offset);
// TODO Open parent directory to fsync the directory inode (and recurse for all ancestors).
return file;
}
/// Pending https://github.com/ziglang/zig/pull/6895
fn fallocate(fd: os.fd_t, mode: i32, offset: u64, len: u64) !void {
switch (linux.getErrno(Journal.fallocate_syscall(fd, mode, offset, len))) {
0 => {},
linux.EBADF => return error.FileDescriptorInvalid,
linux.EFBIG => return error.FileTooBig,
linux.EINVAL => return error.ArgumentsInvalid,
linux.EIO => return error.InputOutput,
linux.ENODEV => return error.NoDevice,
linux.ENOSPC => return error.NoSpaceLeft,
linux.ENOSYS => return error.SystemOutdated,
linux.EOPNOTSUPP => return error.OperationNotSupported,
linux.EPERM => return error.PermissionDenied,
linux.ESPIPE => return error.Unseekable,
linux.ETXTBSY => return error.FileBusy,
else => |errno| return os.unexpectedErrno(errno),
}
}
fn fallocate_syscall(fd: os.fd_t, mode: i32, offset: u64, len: u64) usize {
if (@sizeOf(usize) == 4) {
return linux.syscall6(
.fallocate,
@bitCast(usize, @as(isize, fd)),
@bitCast(usize, @as(isize, mode)),
@truncate(usize, offset),
@truncate(usize, offset >> 32),
@truncate(usize, len),
@truncate(usize, len >> 32),
);
} else {
return linux.syscall4(
.fallocate,
@bitCast(usize, @as(isize, fd)),
@bitCast(usize, @as(isize, mode)),
offset,
len,
);
}
}
/// Opens an existing journal file.
fn open(path: []const u8) !fs.File {
// TODO Figure out absolute path to journal file regardless of the server's cwd.
log.debug("opening {}...", .{path});
return Journal.openat(std.fs.cwd().fd, path, false) catch |err| switch (err) {
error.FileNotFound => return try Journal.create(path),
else => return err,
};
}
/// Opens or creates a journal file:
/// - For reading and writing.
/// - For Direct I/O (if possible in development mode, but required in production mode).
/// - Obtains an advisory exclusive lock to the file descriptor.
fn openat(dir_fd: os.fd_t, path: []const u8, creating: bool) !fs.File {
var flags: u32 = os.O_CLOEXEC | os.O_RDWR | os.O_DSYNC;
var mode: fs.File.Mode = 0;
if (@hasDecl(os, "O_LARGEFILE")) flags |= os.O_LARGEFILE;
if (config.direct_io) {
const direct_io_supported = try Journal.fs_supports_direct_io(dir_fd);
if (direct_io_supported) {
flags |= os.O_DIRECT;
} else if (config.deployment_environment == .development) {
log.warn("file system does not support direct i/o", .{});
} else {
@panic("file system does not support direct i/o");
}
}
if (creating) {
flags |= os.O_CREAT;
flags |= os.O_EXCL;
mode = 0o666;
}
// This is critical since we rely on O_DSYNC to fsync():
assert((flags & os.O_DSYNC) > 0);
const path_c = try os.toPosixPath(path);
const fd = try os.openatZ(dir_fd, &path_c, flags, mode);
errdefer os.close(fd);
try os.flock(fd, os.LOCK_EX);
return fs.File{
.handle = fd,
.capable_io_mode = .blocking,
.intended_io_mode = .blocking,
};
}
};
const testing = std.testing;
test "append_size()" {
const sector_size: u64 = config.sector_size;
testing.expectEqual(sector_size * 2, Journal.append_size(1));
testing.expectEqual(sector_size * 2, Journal.append_size(sector_size - 1));
testing.expectEqual(sector_size * 2, Journal.append_size(sector_size));
testing.expectEqual(sector_size * 3, Journal.append_size(sector_size + 1));
} | src/journal.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
const Tile = struct {
dist: u16,
tag: u8,
fn tile2char(t: @This()) u8 {
if (t.tag == 0) {
return '.';
} else if (t.tag == 1) {
return '#';
} else if (t.dist == 0) {
return 'A' + (t.tag - 2);
} else {
return 'a' + (t.tag - 2);
}
}
};
const Vec2 = tools.Vec2;
const Map = tools.Map(Tile, 2000, 2000, true);
fn abs(x: i32) u32 {
return if (x >= 0) @intCast(u32, x) else @intCast(u32, -x);
}
pub fn run(input: []const u8, allocator: std.mem.Allocator) ![2][]const u8 {
const map = try allocator.create(Map);
defer allocator.destroy(map);
map.default_tile = Tile{ .tag = 0, .dist = 0 };
map.bbox = tools.BBox.empty;
map.fill(Tile{ .tag = 0, .dist = 0 }, null);
const coordList = try allocator.alloc(Vec2, 1000);
defer allocator.free(coordList);
var coordCount: usize = 0;
{
var tag: u8 = 2;
var it = std.mem.tokenize(u8, input, "\n\r");
while (it.next()) |line| {
const fields = tools.match_pattern("{}, {}", line) orelse unreachable;
const pos = Vec2{ .x = @intCast(i32, fields[0].imm), .y = @intCast(i32, fields[1].imm) };
coordList[coordCount] = pos;
coordCount += 1;
map.set(pos, Tile{ .tag = tag, .dist = 0 });
tag += 1;
}
map.bbox.min = map.bbox.min.add(Vec2{ .x = -2, .y = -2 });
map.bbox.max = map.bbox.max.add(Vec2{ .x = 2, .y = 2 });
//var buf: [50000]u8 = undefined;
//std.debug.print("amp=\n{}\n", .{map.printToBuf(null, null, Tile.tile2char, &buf)});
}
// update distance map
{
var changed = true;
while (changed) {
changed = false;
var it = map.iter(null);
while (it.nextEx()) |tn| {
var d: u16 = 65534;
var tag: u8 = 0;
for (tn.neib) |neib| {
if (neib) |n| {
if (n.tag != 0) {
if (n.dist + 1 < d) {
d = n.dist + 1;
tag = n.tag;
} else if (n.dist + 1 == d and tag != n.tag) {
tag = 1; // equidistant
}
}
}
}
if (tag != 0 and tn.t.dist > d or (tn.t.dist == d and tn.t.tag != tag) or tn.t.tag == 0) {
tn.t.tag = tag;
tn.t.dist = d;
changed = true;
}
}
}
//var buf: [50000]u8 = undefined;
//std.debug.print("amp=\n{}\n", .{map.printToBuf(null, null, Tile.tile2char, &buf)});
}
// part1
//var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
//defer arena.deinit();
const ans1 = ans: {
// bon je pense que tout ce qui est sur le bord exterieur va se propager à l'infini (en ligne droite ça sera toujours plus court)
var infiniteTags = [_]bool{false} ** 100;
{
var x = map.bbox.min.x;
while (x <= map.bbox.max.x) : (x += 1) {
infiniteTags[map.at(Vec2{ .x = x, .y = map.bbox.min.y }).tag] = true;
infiniteTags[map.at(Vec2{ .x = x, .y = map.bbox.max.y }).tag] = true;
}
var y = map.bbox.min.y;
while (y <= map.bbox.max.y) : (y += 1) {
infiniteTags[map.at(Vec2{ .x = map.bbox.min.x, .y = y }).tag] = true;
infiniteTags[map.at(Vec2{ .x = map.bbox.max.x, .y = y }).tag] = true;
}
}
var counts = [_]u32{0} ** 100;
var bestCount: u32 = 0;
var bestTag: u8 = 0;
var it = map.iter(null);
while (it.next()) |t| {
if (t.tag > 1 and !infiniteTags[t.tag]) {
counts[t.tag] += 1;
if (counts[t.tag] > bestCount) {
bestCount = counts[t.tag];
bestTag = t.tag;
}
}
}
break :ans bestCount;
};
// part2
const ans2 = ans: {
const coords = coordList[0..coordCount];
var count: u32 = 0;
var y = map.bbox.min.y;
while (y <= map.bbox.max.y) : (y += 1) {
var x = map.bbox.min.x;
while (x <= map.bbox.max.x) : (x += 1) {
var d: u32 = 0;
for (coords) |c| {
d += abs(c.x - x) + abs(c.y - y);
}
if (d < 10000) count += 1;
}
}
break :ans count;
};
return [_][]const u8{
try std.fmt.allocPrint(allocator, "{}", .{ans1}),
try std.fmt.allocPrint(allocator, "{}", .{ans2}),
};
}
pub const main = tools.defaultMain("2018/input_day06.txt", run); | 2018/day06.zig |
const std = @import("std");
const assert = std.debug.assert;
const builtin = @import("builtin");
const c = @cImport({
@cInclude("stdio.h");
@cInclude("string.h");
@cInclude("unistd.h");
@cInclude("time.h");
@cInclude("errno.h");
@cInclude("stdintfix.h"); // NB: Required as zig is unable to process some macros
@cInclude("SDL2/SDL.h");
@cInclude("SDL2/SDL_syswm.h");
@cInclude("GL/gl.h");
@cInclude("GL/glx.h");
@cInclude("GL/glext.h");
@cInclude("bgfx/c99/bgfx.h");
});
fn sdlSetWindow(window: *c.SDL_Window) !void {
var wmi: c.SDL_SysWMinfo = undefined;
wmi.version.major = c.SDL_MAJOR_VERSION;
wmi.version.minor = c.SDL_MINOR_VERSION;
wmi.version.patch = c.SDL_PATCHLEVEL;
if (c.SDL_GetWindowWMInfo(window, &wmi) == c.SDL_FALSE) {
return error.SdlFailedInit;
}
var pd: c.bgfx_platform_data_t = .{
.ndt = null,
.nwh = null,
.context = null,
.backBuffer = null,
.backBufferDS = null,
};
switch (builtin.os.tag) {
.linux, .freebsd => {
pd.ndt = wmi.info.x11.display;
pd.nwh = @intToPtr(*anyopaque, wmi.info.x11.window);
},
.macos => {
pd.nwh = @ptrCast(*anyopaque, wmi.info.cocoa.window);
},
.windows => {
pd.nwh = wmi.info.win.window;
},
else => {},
}
c.bgfx_set_platform_data(&pd);
}
pub fn main() !void {
_ = c.SDL_Init(0);
defer c.SDL_Quit();
const window = c.SDL_CreateWindow(
"bgfx",
c.SDL_WINDOWPOS_UNDEFINED,
c.SDL_WINDOWPOS_UNDEFINED,
800,
600,
c.SDL_WINDOW_SHOWN | c.SDL_WINDOW_RESIZABLE,
).?;
defer c.SDL_DestroyWindow(window);
try sdlSetWindow(window);
var init: c.bgfx_init_t = undefined;
c.bgfx_init_ctor(&init);
init.type = c.BGFX_RENDERER_TYPE_COUNT; // Automatically choose a renderer.
init.resolution.width = 800;
init.resolution.height = 600;
init.resolution.reset = c.BGFX_RESET_VSYNC;
assert(c.bgfx_init(&init));
defer c.bgfx_shutdown();
var width: u16 = 800;
var height: u16 = 600;
c.bgfx_set_debug(c.BGFX_DEBUG_TEXT);
c.bgfx_set_view_clear(0, c.BGFX_CLEAR_COLOR | c.BGFX_CLEAR_DEPTH, 0x443355FF, 1.0, 0);
c.bgfx_set_view_rect(0, 0, 0, width, height);
var should_exit = false;
var frame_number: u64 = 0;
gameloop: while (true) {
var event: c.SDL_Event = undefined;
while (c.SDL_PollEvent(&event) == 1) {
switch (event.type) {
c.SDL_QUIT => should_exit = true,
c.SDL_WINDOWEVENT => {
const wev = &event.window;
switch (wev.event) {
c.SDL_WINDOWEVENT_RESIZED => {
width = @intCast(u16, wev.data1);
height = @intCast(u16, wev.data2);
c.bgfx_reset(width, height, 0, 0);
c.bgfx_set_view_rect(0, 0, 0, width, height);
},
c.SDL_WINDOWEVENT_CLOSE => should_exit = true,
else => {},
}
},
else => {},
}
}
if (should_exit) break :gameloop;
c.bgfx_touch(0);
c.bgfx_dbg_text_clear(0, false);
c.bgfx_dbg_text_printf(0, 1, 0x4f, "Frame#:%d", frame_number);
frame_number = c.bgfx_frame(false);
}
} | src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const common = @import("common.zig");
const toml = @import("toml.zig");
const string = []const u8;
const Allocator = std.mem.Allocator;
const Kilo = 1024;
const Mega = Kilo * 1024;
const Giga = Mega * 1024;
const RST = "\x1B[0m";
const BLK = "\x1B[0;30m";
const RED = "\x1B[0;31m";
const GRN = "\x1B[0;32m";
const YEL = "\x1B[0;33m";
const BLU = "\x1B[0;34m";
const MAG = "\x1B[0;35m";
const CYN = "\x1B[0;36m";
const WHT = "\x1B[0;37m";
const BBLK = "\x1B[1;30m";
const BRED = "\x1B[1;31m";
const BGRN = "\x1B[1;32m";
const BYEL = "\x1B[1;33m";
const BBLU = "\x1B[1;34m";
const BMAG = "\x1B[1;35m";
const BCYN = "\x1B[1;36m";
const BWHT = "\x1B[1;37m";
const Test_Suite = struct {
const Self = @This();
const Tests_List = std.ArrayList(Test);
path: string,
continue_on_fail: bool = false,
line_endings_strict: bool = false,
tests: Tests_List,
pub fn init(_allocator: std.mem.Allocator, path: string) !Self {
return Self{
.path = path,
.tests = Tests_List.init(_allocator),
};
}
pub fn deinit(self: *Test_Suite) void {
self.tests.deinit();
}
pub fn format(value: *const Self, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = options;
_ = fmt;
try writer.print("Test_Suite{{{s}, {}, {s}}}", .{ value.path, value.continue_on_fail, value.tests.items });
}
};
const Test = struct {
const Self = @This();
name: string,
input: string,
output: string,
output_err: string,
exit_code: i64,
pub fn format(value: *const Self, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = options;
_ = fmt;
try writer.print("Test{{{s}}}", .{value.name});
}
};
fn tomlToSuite(allocator: Allocator, table: *toml.Table) !Test_Suite {
var path_val = table.items.get("path") orelse {
common.ewriteln("Missing key 'path' required", .{});
return error.Missing_Required_Key;
};
if (path_val != .String) {
common.ewriteln("Expected String for 'path' got {s}", .{@tagName(path_val)});
return error.Wrong_Value_Type;
}
var res = try Test_Suite.init(allocator, path_val.String);
if (table.items.get("continue_on_fail")) |cof| {
if (cof != .Bool) {
common.ewriteln("Expected Boolean for 'continue_on_fail' got {s}", .{@tagName(cof)});
return error.Wrong_Value_Type;
}
res.continue_on_fail = cof.Bool;
}
if (table.items.get("line_endings_strict")) |cof| {
if (cof != .Bool) {
common.ewriteln("Expected Boolean for 'line_endings_strict' got {s}", .{@tagName(cof)});
return error.Wrong_Value_Type;
}
res.line_endings_strict = cof.Bool;
}
var iterator = table.items.valueIterator();
while (iterator.next()) |val| {
if (val.* != .Table) continue;
var raw_test = val.Table;
var t: Test = undefined;
inline for (@typeInfo(Test).Struct.fields) |field| {
if (comptime std.mem.eql(u8, field.name, "name")) {
t.name = raw_test.name;
} else {
var field_value = raw_test.items.get(field.name) orelse {
common.ewriteln("Missing required key '" ++ field.name ++ "' on test {s}", .{raw_test.name});
return error.Missing_Required_Key;
};
const required_field_type = comptime switch (field.field_type) {
string => toml.Value.String,
i64 => toml.Value.Integer,
else => @compileError("Implement!"),
};
if (required_field_type != field_value) {
common.ewriteln("Expected " ++ @tagName(required_field_type) ++ " for '" ++ field.name ++ "' on {s} got {s}", .{ raw_test.name, @tagName(field_value) });
return error.Wrong_Value_Type;
}
@field(t, field.name) = @field(field_value, @tagName(required_field_type));
}
}
try res.tests.append(t);
}
return res;
}
/// Calculates the absolute path of the executable relative to the
/// directory of the tests.toml file. Returns if the path of the
/// executable is already absolute.
fn fixExePath(allocator: Allocator, suite: *Test_Suite) !void {
if (std.fs.path.isAbsolute(suite.path)) {
return;
}
suite.path = try std.fs.cwd().realpathAlloc(allocator, suite.path);
}
fn runSuite(allocator: Allocator, suite: *Test_Suite) !void {
_ = suite;
for (suite.tests.items) |t| {
common.write("{s}", .{t.name});
var i: usize = (70 - t.name.len);
while (i != 0) : (i -= 1) {
common.write(".", .{});
}
var result = try runTest(allocator, suite.path, t);
defer {
allocator.free(result.stderr);
allocator.free(result.stdout);
}
if (result.term != .Exited) {
common.writeln(BRED ++ "FAIL" ++ RST, .{});
common.writeln(" > Program did not exit correctly (exit code could not be attained)", .{});
return;
}
var fail = false;
if (result.term.Exited != t.exit_code) {
fail = true;
common.writeln(BRED ++ "FAIL" ++ RST, .{});
printDifference("exit code", t.exit_code, result.term.Exited);
}
if (!compareStrings(suite.line_endings_strict, result.stdout, t.output)) {
if (!fail) {
common.writeln(BRED ++ "FAIL" ++ RST, .{});
}
fail = true;
printDifference("output", t.output, result.stdout);
}
if (!compareStrings(suite.line_endings_strict, result.stderr, t.output_err)) {
if (!fail) {
common.writeln(BRED ++ "FAIL" ++ RST, .{});
}
fail = true;
printDifference("output_err", t.output_err, result.stderr);
}
if (!fail) {
common.writeln(BGRN ++ "OK" ++ RST, .{});
} else if (!suite.continue_on_fail) {
break;
}
}
}
/// Compares the two strings. If strict is enabled it ignores differences in line-endings.
/// Returns true if equal.
fn compareStrings(strict: bool, expected: string, actuall: string) bool {
if (strict) {
return std.mem.eql(u8, expected, actuall);
} else {
// Check ignoring line-endings
var i : u64 = 0;
while (i < expected.len) : (i += 1) {
if (i >= actuall.len) return false;
if (expected[i] == actuall[i]) {
// Ignored
} else if (expected[i] == '\r' and actuall[i] == '\n') {
if ( (i + 1 < expected.len) and expected[i + 1] == '\n' ) {
i += 1;
} else {
return false; // expected \r got \n
}
} else if (expected[i] == '\n' and actuall[i] == '\r') {
if ( (i + 1 < actuall.len) and actuall[i + 1] == '\n' ) {
i += 1;
} else {
return false; // expected \n got \r
}
}
}
return true;
}
}
fn printDifference(comptime name: string, expected: anytype, got: @TypeOf(expected)) void {
const format = switch (@TypeOf(expected)) {
string => "s",
else => "",
};
common.writeln(" > " ++ name ++ " differs:", .{});
common.writeln(" Expected: " ++ GRN ++ "{" ++ format ++ "}" ++ RST, .{expected});
common.writeln(" Got : " ++ RED ++ "{" ++ format ++ "}" ++ RST, .{got});
}
/// switch the cwd to the dir of the path
fn setCwd(allocator: Allocator, path: string) !void {
var config_path = try std.fs.realpathAlloc(allocator, path);
defer allocator.free(config_path);
var dir_path = std.fs.path.dirname(config_path) orelse &([_]u8{std.fs.path.delimiter});
var dir = try std.fs.openDirAbsolute(dir_path, .{});
defer dir.close();
try dir.setAsCwd();
}
fn runTest(allocator: Allocator, path: string, t: Test) !std.ChildProcess.ExecResult {
var argv = std.ArrayList([]const u8).init(allocator);
defer argv.deinit();
try argv.append(path);
var start: usize = 0;
for (t.input) |c, i| {
if (c == ' ') {
try argv.append(t.input[start..i]);
start = i + 1;
}
}
if (start != t.input.len) {
try argv.append(t.input[start..]);
}
return std.ChildProcess.exec(.{ .allocator = allocator, .argv = argv.items });
}
pub fn main() void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
var allocator = arena.allocator();
const args = std.process.argsAlloc(allocator) catch {
common.ewriteln("Unable to get process arguments", .{});
return;
};
defer std.process.argsFree(allocator, args);
mainProc(allocator, args);
}
/// Used to easily test for leaking memory
fn mainProc(allocator: Allocator, args: []const []const u8) void {
if (args.len < 2) {
common.ewriteln("No path to tests.toml provided.", .{});
return;
}
var file_content = std.fs.cwd().readFileAlloc(allocator, args[1], 100 * Mega) catch |err| {
common.ewriteln("Unable to read tests.toml file.", .{});
common.ewriteln(" Hint: {s}", .{@errorName(err)});
return;
};
defer allocator.free(file_content);
setCwd(allocator, args[1]) catch |err| {
common.ewriteln("Unable to switch current working directory.", .{});
common.ewriteln(" Hint: {s}", .{@errorName(err)});
};
var parser = toml.Parser.init(allocator, file_content);
var table = parser.parse() catch |err| {
common.ewriteln("Error while parsing tests.toml file.", .{});
common.ewriteln(" Hint: {s}", .{@errorName(err)});
return;
};
defer table.deinit();
var suite = tomlToSuite(allocator, &table) catch return;
defer suite.deinit();
fixExePath(allocator, &suite) catch |err| {
common.ewriteHint("Unable to resolve executable path.", err, .{});
};
common.writeln("Running Tests [{s}]", .{args[1]});
runSuite(allocator, &suite) catch |err| {
common.ewriteHint("Error while running tests.", err, .{});
};
}
test "Memory leak test" {
mainProc(std.testing.allocator, &.{ "", "/Users/bc/source/test_runner/test/tests.toml.example" });
} | src/main.zig |
const std = @import("std");
const io = std.io;
const map = std.HashMap;
const os = std.os;
const Tokenizer = @import("tokenizer.zig");
const warn = std.debug.warn;
const Buffer = std.Buffer;
const allocator = std.heap.c_allocator;
const Vec = std.ArrayList;
const util = @import("stringUtil.zig");
const c_str = std.cstr;
const maxSize = 100;
const ParserInfo = struct {
row: i32,
col: i32,
err: error,
};
const ParserErrors = error {
MissingToken,
};
pub fn printTree(key: &const Key)void {
switch (*key) {
Key.Null => warn("Null\n"),
Key.Int => warn("Int: {}\n", key.Int),
Key.Map => {
warn("Map {}: {{\n", key.Map.size);
var it = key.Map.iterator();
while (true) {
var entry = it.next();
if (entry) |value| {
warn("Key: {}, ", value.key);
printKey(&value.value);
} else {
break;
}
}
warn("}}\n");
},
Key.Array => {
warn("Array: [\n");
for (key.Array.items) |entry, i| {
if (i >= key.Array.len) break;
printKey(entry);
}
warn("]\n");
},
Key.Float => warn("Float: {}\n", key.Float),
Key.Bool => warn("Bool: {}\n", key.Bool),
Key.String => warn("String: {}\n", key.String),
else => {
warn("Invalid type\n");
},
}
}
const KeyMap = map([]u8, Key, util.hash_string, util.eql_string);
const KeyArray = Vec(Key);
fn last(self: &Vec(&Key)) &Key {
return self.items[self.len - 1];
}
pub const Key = union(enum) {
Map: KeyMap,
Int: i32,
Float: f32,
Bool: bool,
String: []u8,
Array: KeyArray,
Null,
Error: error,
};
pub fn parseFile(file: &os.File) Key {
var stream = io.FileInStream.init(file);
var tokenizer = Tokenizer.Tokenizer.init(&stream);
var buf = Buffer.initNull(std.heap.c_allocator);
defer buf.deinit();
tokenizer.readTillDeliminators(&buf, 100) catch |err| switch(err) {
error.EndOfStream => {
return Key.Null;
},
else => return Key { .Error = err },
};
var topKey : Key = undefined;
var firstByte = buf.toOwnedSlice()[0];
var arrayDepth: i32 = 0;
var mapDepth: i32 = 0;
var depth = Vec(&Key).init(allocator);
if (firstByte == '[') {
// Array
topKey = Key { .Array = KeyArray.init(allocator) };
arrayDepth += 1;
} else if (firstByte == '{') {
// Object
topKey = Key { .Map = KeyMap.init(allocator) };
mapDepth += 1;
} else {
return Key { .Error = error.InvalidCharacter };
}
var currentIndex : ?[]u8 = null;
depth.append(&topKey) catch |err| {
return Key { .Error = err };
};
while (true) {
tokenizer.readTillDeliminators(&buf, 100) catch |err| switch(err) {
error.EndOfStream => {
break;
},
else => return Key { .Error = err },
};
var slice = buf.toOwnedSlice();
//warn("Slice: {}", slice);
switch (slice[0]) {
'[' => {
arrayDepth += 1;
if (*last(&depth) == Key.Map and currentIndex != null) {
_ = last(&depth).Map.put(?? currentIndex, Key { .Array = KeyArray.init(allocator) }) catch |err| {
return Key { .Error = err };
};
depth.append(&(?? last(&depth).Map.get(?? currentIndex)).value) catch |err| {
return Key { .Error = err };
};
} else if (*last(&depth) == Key.Array) {
last(&depth).Array.append(Key { .Array = KeyArray.init(allocator) } ) catch |err| {
return Key { .Error = err };
};
const depthLast = *last(&depth);
depth.append(&depthLast.Array.items[depthLast.Array.len - 1]) catch |err| {
return Key { .Error = err };
};
} else {
return Key { .Error = error.NoKey };
}
currentIndex = null;
},
']' => {
arrayDepth -= 1;
_ = depth.pop();
},
',' => {
currentIndex = null;
continue;
},
'{' => {
mapDepth += 1;
if (*last(&depth) == Key.Map and currentIndex != null) {
_ = last(&depth).Map.put(?? currentIndex, Key { .Map = KeyMap.init(allocator) }) catch |err| {
return Key { .Error = err };
};
depth.append(&(?? last(&depth).Map.get(?? currentIndex)).value) catch |err| {
return Key { .Error = err };
};
} else if (*last(&depth) == Key.Array) {
last(&depth).Array.append(Key { .Map = KeyMap.init(allocator) } ) catch |err| {
return Key { .Error = err };
};
const depthLast = *last(&depth);
depth.append(&depthLast.Array.items[depthLast.Array.len - 1]) catch |err| {
return Key { .Error = err };
};
} else {
return Key { .Error = error.NoKey };
}
currentIndex = null;
},
'}' => {
mapDepth -= 1;
_ = depth.pop();
},
'"' => {
// Assignment
if (currentIndex == null) {
currentIndex = slice[1..slice.len - 1];
tokenizer.readTillDeliminators(&buf, 100) catch |err| switch(err) {
error.EndOfStream => {
return Key { .Error = error.MissingAssignment };
},
else => return Key { .Error = err },
};
slice = buf.toOwnedSlice();
if (slice[0] != ':') {
return Key { .Error = error.InvalidCharacter };
}
} else {
// Its a string assignment
if (*last(&depth) == Key.Map and currentIndex != null) {
_ = last(&depth).Map.put(?? currentIndex, Key { .String = slice[1..slice.len - 1] }) catch |err| {
return Key { .Error = err };
};
} else if (*last(&depth) == Key.Array) {
last(&depth).Array.append(Key { .String = slice[1..slice.len - 1] }) catch |err| {
return Key { .Error = err };
};
} else {
return Key { .Error = error.NoKey };
}
currentIndex = null;
}
},
else => {
var key : Key = undefined;
if (util.isLetter(slice[0])) {
// Check if boolean
if (util.eql_string_const("false", slice)) {
key = Key { .Bool = false };
} else if (util.eql_string_const("true", slice)) {
key = Key { .Bool = true };
} else if (util.eql_string_const("null", slice)) {
key = Key.Null;
} else {
return Key { .Error = error.InvalidCharacter };
}
} else if (util.isNumber(slice[0]) or slice[0] == '-' or slice[0] == '.' or slice[0] == '+') {
// Could be int or float
var dotLocation : ?usize = null;
var eLocation : ?usize = null;
var sign : i32 = 1;
// Cut signs out of slice after handling it
if (slice[0] == '-') {
sign = -1;
slice = slice[1..];
}
else if (slice[0] == '+') {
sign = 1;
slice = slice[1..];
}
for (slice) |char, i| {
if (char == '.') {
if (dotLocation != null) return Key { .Error = error.TwoDots };
dotLocation = i;
}
if (char == 'e' or char == 'E') {
if (eLocation != null) return Key { .Error = error.TwoEs };
eLocation = i;
}
}
var digitValue : i32 = 0;
if (dotLocation == null or ??dotLocation > 0) {
var endLocation : usize = undefined;
if (dotLocation) |loc| {
endLocation = loc;
} else if (eLocation) |loc| {
endLocation = loc;
} else {
endLocation = slice.len;
}
digitValue = util.atoi(slice[0..endLocation]) catch |err| {
return Key { .Error = error.InvalidCharacter };
};
}
if (dotLocation != null or eLocation != null) {
// Read digits after dot
var fractionDigits : i32 = 0;
var endLocation : usize = if (eLocation == null) slice.len else ??eLocation;
var digitCount : usize = 0;
if (dotLocation) |location| {
digitCount = endLocation - location;
fractionDigits = util.atoi(slice[location+1..endLocation]) catch |err| {
return Key { .Error = error.InvalidCharacter };
};
}
var float = (f32)(fractionDigits);
while (digitCount > 0) {
float /= 10;
digitCount -= 1;
}
digitCount = 0;
float += (f32)(digitValue);
digitValue = 0;
if (eLocation) |e| {
var exponentSign : f32 = undefined;
if (slice[e + 1] == '-') {
exponentSign = 0.1;
} else {
exponentSign = 10.0;
}
var loc = e;
if (slice[e + 1] == '-' or slice[e + 1] == '+') {
loc += 2;
} else {
loc += 1;
}
digitValue = util.atoi(slice[loc..]) catch |err| {
return Key { .Error = error.InvalidCharacter };
};
while (digitValue > 0) {
float *= exponentSign;
digitValue -= 1;
}
}
key = Key { .Float = float * (f32)(sign) };
} else {
key = Key { .Int = digitValue * sign };
}
} else {
return Key { .Error = error.InvalidCharacter };
}
if (*last(&depth) == Key.Map and currentIndex != null) {
_ = last(&depth).Map.put(?? currentIndex, key) catch |err| {
return Key { .Error = err };
};
} else if (*last(&depth) == Key.Array) {
last(&depth).Array.append(key) catch |err| {
return Key { .Error = err };
};
} else {
return Key { .Error = error.NoKey };
}
currentIndex = null;
},
}
}
return topKey;
} | src/parser.zig |
const std = @import("std");
const testing = std.testing;
const builtin = std.builtin;
pub inline fn hasBehaviour(comptime Type: type, comptime Behaviour: type) bool {
return doHasBehaviour(Type, Behaviour);
}
fn doHasBehaviour(comptime Type: type, comptime Behaviour: type) bool {
const type_info = @typeInfo(Type);
const behaviour_info = @typeInfo(Behaviour);
return switch (behaviour_info) {
// If `Behaviour` is simply `type`, accept any type.
.Type => true,
// If the behaviour is a primitive, expected that type to also be the
// same primitive.
.Bool,
.ComptimeInt,
.ComptimeFloat => Type == Behaviour,
// Except integers and floats, which also accept their compile time
// variants.
.Int => Type == Behaviour or Type == comptime_int,
.Float => Type == Behaviour or Type == comptime_int or Type == comptime_float,
// If the behaviour is a function, then the type must be the same.
.Fn => Type == Behaviour,
// If `Behaviour` is an enum, ensure that the subset of the specified
// fields are supported only.
.Enum => |behaviour_enum_info| enum_blk: {
if (type_info == .Enum) {
const type_enum_info = type_info.Enum;
inline for (behaviour_enum_info.fields) |behaviour_field| {
comptime var missing = true;
inline for (type_enum_info.fields) |type_field| {
if (comptime std.mem.eql(u8, behaviour_field.name, type_field.name)) {
missing = false;
}
}
if (missing) {
break :enum_blk false;
}
}
break :enum_blk true;
}
break :enum_blk false;
},
// Errors basically have the same behaviour as enums. If the behaviour
// is a subset of the error set, everything's good.
.ErrorSet => |behaviour_error_info| error_blk: {
if (type_info == .Error) {
const type_error_info = type_info.Error;
inline for (behaviour_error_info.?) |behaviour_error| {
comptime var missing = true;
inline for (type_error_info.?) |type_error| {
if (comptime std.mem.eql(u8, behaviour_error.name, type_error.name)) {
missing = false;
}
}
if (missing) {
break :error_blk false;
}
}
break :error_blk true;
}
break :error_blk false;
},
//
.Struct => |behaviour_struct_info| struct_blk: {
if (behaviour_struct_info.is_tuple) {
inline for (behaviour_struct_info.fields) |behaviour_field| {
if (!hasBehaviour(Type, behaviour_field.field_type)) {
break :struct_blk false;
}
}
}
inline for (behaviour_struct_info.decls) |behaviour_decl_info| {
switch (behaviour_decl_info.data) {
.Type, .Var => |behaviour_decl_type| {
// If the type does not have a declaration, it is not valid.
if (!@hasDecl(Type, behaviour_decl_info.name)) {
break :struct_blk false;
}
const type_decl_info = std.meta.declarationInfo(Type, behaviour_decl_info.name);
const type_decl_type = switch (type_decl_info.data) {
.Type, .Var => |t| t,
.Fn => |f| f.fn_type,
};
if (!doHasBehaviour(type_decl_type, behaviour_decl_type)) {
break :struct_blk false;
}
},
// Ignore function declarations.
.Fn => {},
}
}
break :struct_blk true;
},
// .Pointer => |type_pointer_info|
// if (behaviour_info.Pointer) |behaviour_pointer_info| {
// else
else => @compileError(@typeName(Behaviour) ++ " is not a supported behaviour"),
};
}
pub fn behaviour(comptime Type: type, comptime Behaviour: type) type {
doBehaviour(Type, Behaviour, @typeName(Type));
return Type;
}
fn doBehaviour(comptime Type: type, comptime Behaviour: type, comptime type_path: []const u8) void {
const type_info = @typeInfo(Type);
const behaviour_info = @typeInfo(Behaviour);
switch (behaviour_info) {
// If `Behaviour` is simply `type`, accept any type.
.Type => return,
// If the behaviour is a primitive, expected that type to also be the
// same primitive.
.Bool,
.ComptimeInt,
.ComptimeFloat => if (Type != Behaviour) {
@compileError("`" ++ @typeName(Type) ++ "` is not compatible with `" ++ @typeName(Behaviour) ++ "` in `" ++ type_path ++ "`");
},
// Except integers and floats, which also accept their compile time
// variants.
.Int => if (Type != Behaviour and Type != comptime_int) {
@compileError("`" ++ @typeName(Type) ++ "` is not compatible with `" ++ @typeName(Behaviour) ++ "` in `" ++ type_path ++ "`");
},
.Float => if (Type != Behaviour and Type != comptime_int and Type != comptime_float) {
@compileError("`" ++ @typeName(Type) ++ "` is not compatible with `" ++ @typeName(Behaviour) ++ "` in `" ++ type_path ++ "`");
},
// If the behaviour is a function, then the type must be the same.
.Fn => if (Type != Behaviour) {
if (comptime std.mem.eql(u8, type_path, @typeName(Type))) {
@compileError("`" ++ @typeName(Type) ++ "` is not compatible with `" ++ @typeName(Behaviour) ++ "`");
} else {
@compileError("`" ++ @typeName(Type) ++ "` is not compatible with `" ++ @typeName(Behaviour) ++ "` in `" ++ type_path ++ "`");
}
},
// If `Behaviour` is an enum, ensure that the subset of the specified
// fields are supported only.
.Enum => |behaviour_enum_info| enum_blk: {
if (type_info == .Enum) {
const type_enum_info = type_info.Enum;
inline for (behaviour_enum_info.fields) |behaviour_field| {
comptime var missing = true;
inline for (type_enum_info.fields) |type_field| {
if (comptime std.mem.eql(u8, behaviour_field.name, type_field.name)) {
missing = false;
}
}
if (missing) {
@compileError("Missing enum field `" ++ behaviour_field.name ++ "` in `" ++ type_path ++ "`");
}
}
break :enum_blk;
}
@compileError("Expected an enum in `" ++ type_path ++ "`");
},
// Errors basically have the same behaviour as enums. If the behaviour
// is a subset of the error set, everything's good.
.ErrorSet => |behaviour_error_info| error_blk: {
if (type_info == .Error) {
const type_error_info = type_info.Error;
inline for (behaviour_error_info.?) |behaviour_error| {
comptime var missing = true;
inline for (type_error_info.?) |type_error| {
if (comptime std.mem.eql(u8, behaviour_error.name, type_error.name)) {
missing = false;
}
}
if (missing) {
@compileError("Expected an error `" ++ behaviour_field.name ++ "` in `" ++ type_path ++ "`");
}
}
break :error_blk;
}
@compileError("Expected an error set in `" ++ type_path ++ "`");
},
//
.Struct => |behaviour_struct_info| {
if (behaviour_struct_info.is_tuple) {
inline for (behaviour_struct_info.fields) |behaviour_field| {
doBehaviour(Type, behaviour_field.field_type, type_path);
}
}
inline for (behaviour_struct_info.decls) |behaviour_decl_info| {
switch (behaviour_decl_info.data) {
.Type, .Var => |behaviour_decl_type| {
// If the type does not have a declaration, it is not valid.
if (!@hasDecl(Type, behaviour_decl_info.name)) {
@compileError("Missing a `" ++ behaviour_decl_info.name ++ "` declaration in `" ++ type_path ++ "`");
}
const type_decl_info = std.meta.declarationInfo(Type, behaviour_decl_info.name);
const type_decl_type = switch (type_decl_info.data) {
.Type, .Var => |t| t,
.Fn => |f| f.fn_type,
};
doBehaviour(type_decl_type, behaviour_decl_type, type_path ++ "." ++ behaviour_decl_info.name);
},
// Ignore function declarations.
.Fn => {},
}
}
},
// .Pointer => |type_pointer_info|
// if (behaviour_info.Pointer) |behaviour_pointer_info| {
// else
else => @compileError(@typeName(Behaviour) ++ " is not a supported behaviour"),
}
}
test "hasBehaviour/2 type" {
const S = struct { a: bool, b: usize };
const E = enum { a, b, c, d, e, f, g };
testing.expect(hasBehaviour(u64, type));
testing.expect(hasBehaviour(S, type));
testing.expect(hasBehaviour(bool, type));
testing.expect(hasBehaviour([]const u8, type));
testing.expect(hasBehaviour(E, type));
testing.expect(hasBehaviour(struct{}, type));
testing.expect(hasBehaviour(enum{ foo }, type));
}
test "hasBehaviour/2 scalars" {
const S = struct { a: bool, b: usize };
const E = enum { a, b };
testing.expect(hasBehaviour(u8, u8));
testing.expect(hasBehaviour(comptime_float, comptime_float));
}
test "hasBehaviour/2 errors" {
const E = enum { a, b, c, d, e, f, g };
const SubE = enum { b, d, g };
testing.expect(hasBehaviour(E, SubE));
testing.expect(hasBehaviour(E, enum{ f }));
testing.expect(hasBehaviour(SubE, enum{ g }));
testing.expect(hasBehaviour(enum{ foo }, enum{ foo }));
testing.expect(!hasBehaviour(struct {}, SubE));
testing.expect(!hasBehaviour(u32, SubE));
testing.expect(!hasBehaviour(enum { bar }, enum { baz }));
}
test "hasBehaviour/2 structs" {
const S = struct {
foo: usize,
bar: bool,
fn foo(u: u32) void {}
fn bar() []const u8 { return ""; }
fn baz(a: bool, b: bool) bool { return false; }
};
const S2 = struct {
pub const S1 = S;
pub const V = 3;
};
testing.expect(hasBehaviour(S, struct {}));
testing.expect(hasBehaviour(S, struct { pub const foo = fn(u32) void; }));
testing.expect(hasBehaviour(S, @TypeOf(.{ struct { pub const foo = fn(u32) void; } })));
testing.expect(hasBehaviour(S2, @TypeOf(.{
struct {
pub const S1 = @TypeOf(.{
struct {
pub const baz = fn(bool, bool) bool;
pub const V = u32;
}
});
}
})));
}
pub fn Indexable(comptime Self: type) type {
return struct {
pub const Index = type;
pub const Result = type;
pub const at = fn(Self, Self.Index) Self.Result;
};
}
const IndexableTest = struct {
pub const Index = u32;
pub const Result = u32;
pub fn at(self: @This(), index: u32) Result {
return index;
}
};
comptime {
behaviour(IndexableTest, Indexable(IndexableTest));
} | src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const builtin = @import("builtin");
const log_ = @import("Log.zig");
const fatalErrorLog_ = log_.fatalErrorLog;
const errLog_ = log_.errLog;
const dbgLog_ = log_.dbgLog;
const ArrayList = std.ArrayList;
const c_allocator = std.heap.c_allocator;
const page_allocator = std.heap.page_allocator;
const ObjectPool_ = @import("ObjectPool.zig");
const ObjectPool = ObjectPool_.ObjectPool;
const Queue = @import("Queue.zig").Queue;
const printStatistics = @import("Statistics.zig").printStatistics;
const config = @import("Config.zig").config;
pub fn fatalErrorLog(comptime s: []const u8, args: var) void {
fatalErrorLog_("TCP: " ++ s, args);
}
pub fn dbgLog(comptime s: []const u8, args: var) void {
dbgLog_("TCP: " ++ s, args);
}
pub fn errLog(comptime s: []const u8, args: var) void {
errLog_("TCP: " ++ s, args);
}
const SOCKET_BACKLOG = 4096;
const QUEUE_DEPTH = 32768;
const READ_BUFFER_SIZE = 2 * 1024;
const NUM_READ_BUFFERS = 8192;
pub const WRITE_BUFFER_SIZE = 32 * 1024;
// const MAX_CONNECTIONS = 15000;
threadlocal var bytes_recieved_total: usize = 0;
threadlocal var bytes_sent_total: usize = 0;
threadlocal var connections_counter: u32 = 0;
threadlocal var peak_connections: u32 = 0;
threadlocal var events_pending: u32 = 0;
pub fn bytesRecievedTotal() usize {
return bytes_recieved_total;
}
pub fn bytesSentTotal() usize {
return bytes_sent_total;
}
pub fn numConnections() u32 {
return connections_counter;
}
pub fn peakConnections() u32 {
return peak_connections;
}
pub fn numPendingEvents() u32 {
return events_pending;
}
threadlocal var io_uring_events_being_submitted: u32 = 0;
usingnamespace std.c;
const uring = @cImport({
@cInclude("netinet/in.h");
@cInclude("arpa/inet.h");
@cInclude("liburing.h");
});
const ListenSocket = struct {
fd: c_int,
port: u16,
fn queueAccept(self: *ListenSocket) !void {
events_pending += 1;
errdefer events_pending -= 1;
var sqe: [*c]uring.io_uring_sqe = uring.io_uring_get_sqe(&ring);
io_uring_events_being_submitted += 1;
var conn = try connection_pool.alloc();
conn.* = Connection{ .server_socket = self };
var address_length: c_int = @sizeOf(uring.sockaddr_in);
uring.io_uring_prep_accept(sqe, self.fd, @ptrCast([*c]uring.sockaddr, &conn.client_addr), @ptrCast([*c]c_uint, &address_length), 0);
var event = try uring_event_pool.alloc();
errdefer uring_event_pool.free(event);
event.* = URingEventData{
.op_type = .Accept,
.conn = conn,
.io = undefined, // not used
.meta_data = undefined, // not used
.connection = undefined,
};
// Accept events are always submitted, even when the queue is full
uring.io_uring_sqe_set_data(sqe, @ptrCast(*c_void, event));
}
};
pub threadlocal var write_buffer_pool: ObjectPool([WRITE_BUFFER_SIZE]u8, 256, writeBuffersOnAlloc) = undefined;
threadlocal var write_buffer_pool_alloc_done = false;
fn writeBuffersOnAlloc(e: []([WRITE_BUFFER_SIZE]u8)) ObjectPool_.OnAllocErrors!void {
// TODO: System call hangs if events are pending
if (write_buffer_pool_alloc_done) {
errLog("Write buffer pool full", .{});
return error.OnAllocError;
}
write_buffer_pool_alloc_done = true;
// var vecs: [256]uring.iovec = undefined;
// for (vecs) |*v, i| {
// v.*.iov_base = &e[i];
// v.*.iov_len = WRITE_BUFFER_SIZE;
// }
var vec = uring.iovec{
.iov_base = &e[0],
.iov_len = WRITE_BUFFER_SIZE * 256,
};
const ret = uring.io_uring_register_buffers(&ring, &vec, 1);
if (ret != 0) {
fatalErrorLog("io_uring_register_buffers error: {}", .{ret});
return error.OnAllocError;
}
}
threadlocal var server_sockets: ArrayList(ListenSocket) = undefined;
threadlocal var read_buffers: []u8 = undefined;
threadlocal var ring: uring.io_uring = undefined;
threadlocal var cqe: [*c]uring.io_uring_cqe = undefined;
threadlocal var events_backlog: Queue(*URingEventData) = undefined;
// Returns true if there is space in the event submission queue
// Returns false if the event was added to the backlog
fn incrementPendingEventCounter(event: *URingEventData) !bool {
if (events_pending >= QUEUE_DEPTH) {
dbgLog("IO Uring Queue full. Event type = {}", .{event.*.op_type});
try events_backlog.enqueue(event);
return false;
} else {
events_pending += 1;
return true;
}
}
threadlocal var uring_event_pool: ObjectPool(URingEventData, 256, null) = undefined;
pub fn eventPoolSize() usize {
return uring_event_pool.size();
}
const URingEventData = struct {
const OpType = enum {
BufferRegister, // All other fields ignored for this op type
Accept, Read, Write, Close
};
op_type: OpType,
conn: *Connection,
io: []const u8, // for writes
meta_data: u64, // custom data for writes. Not used for reads as reads are not started by the app-level code
connection: *Connection,
fn submit(self: *URingEventData) !void {
switch (self.op_type) {
.Read => {
var sqe: *uring.io_uring_sqe = uring.io_uring_get_sqe(&ring);
io_uring_events_being_submitted += 1;
uring.io_uring_prep_recv(sqe, self.connection.client_socket, null, READ_BUFFER_SIZE, 0);
sqe_set_buf_group(@ptrToInt(sqe), 1);
sqe_set_flags(@ptrToInt(sqe), uring.IOSQE_BUFFER_SELECT);
uring.io_uring_sqe_set_data(sqe, @ptrCast(*c_void, self));
self.connection.state = Connection.State.Reading;
},
.Write => {
var sqe: *uring.io_uring_sqe = uring.io_uring_get_sqe(&ring);
io_uring_events_being_submitted += 1;
uring.io_uring_prep_write_fixed(sqe, self.connection.client_socket, self.io.ptr, @intCast(c_uint, self.io.len), 0, 0);
sqe_set_flags(@ptrToInt(sqe), uring.IOSQE_IO_LINK); // force commands to be in order
uring.io_uring_sqe_set_data(sqe, @ptrCast(*c_void, self));
self.connection.state = Connection.State.Reading;
self.connection.write_in_progress = true;
},
.Close => {
var sqe: *uring.io_uring_sqe = uring.io_uring_get_sqe(&ring);
io_uring_events_being_submitted += 1;
uring.io_uring_prep_close(sqe, self.connection.client_socket);
sqe_set_flags(@ptrToInt(sqe), uring.IOSQE_IO_LINK); // force commands to be in order
uring.io_uring_sqe_set_data(sqe, @ptrCast(*c_void, self));
self.connection.state = Connection.State.Closing;
},
else => {},
}
}
};
// Return non-null if connection should be denied
pub const callback_new_connection = fn (port: u16, conn: usize, ip: u128) ?usize;
pub const callback_data_received = fn (port: u16, user_data: usize, conn: usize, data: []const u8) void;
// data is the slice that was passed to sendData()
pub const callback_write_complete = fn (port: u16, user_data: usize, conn: usize, data: []const u8, meta_data: u64) void;
pub const callback_connection_lost = fn (port: u16, user_data: usize, conn: usize) void;
threadlocal var cb_new_connection: callback_new_connection = undefined;
threadlocal var cb_data_recieved: callback_data_received = undefined;
threadlocal var cb_connection_lost: callback_connection_lost = undefined;
threadlocal var cb_write_complete: ?callback_write_complete = null;
threadlocal var connection_pool: ObjectPool(Connection, 4096, null) = undefined;
pub fn connectionPoolSize() usize {
return connection_pool.size();
}
const Connection = struct {
const State = enum {
Accepting, Reading, Closing
};
state: State = State.Accepting,
write_in_progress: bool = false,
server_socket: *ListenSocket,
user_data: ?usize = null,
// Only valid if state == Reading
client_socket: c_int = undefined,
client_addr: sockaddr_in6 = undefined,
last_read_time: u64 = 0,
fn accept(self: *Connection, fd: c_int) !void {
self.client_socket = fd;
const user_data = cb_new_connection(self.server_socket.port, @ptrToInt(self), @bitCast(u128, self.client_addr.addr));
if (user_data == null) {
return error.ConnectionRefused;
}
self.state = Connection.State.Reading;
self.user_data = user_data;
connections_counter += 1;
peak_connections = std.math.max(peak_connections, connections_counter);
}
fn queueRead(self: *Connection) !void {
if (self.state != .Reading) {
return;
}
if (self.user_data == null) {
assert(false);
return error.MissingUserData;
}
var event = try uring_event_pool.alloc();
errdefer uring_event_pool.free(event);
event.* = URingEventData{
.op_type = .Read,
.conn = self,
.io = undefined,
.meta_data = 0,
.connection = self,
};
if (try incrementPendingEventCounter(event)) {
errdefer events_pending -= 1;
try event.submit();
}
}
fn readCompleteOrFailed(self: *Connection) !void {
const buffer_id = cqe.*.flags >> 16;
assert(self.user_data != null);
if (cqe.*.res <= 0 or (cqe.*.flags & uring.IORING_CQE_F_BUFFER) == 0 or buffer_id > NUM_READ_BUFFERS or self.state != .Reading or self.user_data == null) {
try reregisterBuffer(buffer_id); // Function will ignore any invalid IDs
try self.queueClose();
return;
}
self.last_read_time = std.time.milliTimestamp();
const bytesRead = @intCast(u32, cqe.*.res);
const buffer_idx = buffer_id - 1;
const buffer = read_buffers[buffer_idx * READ_BUFFER_SIZE .. (buffer_idx + 1) * READ_BUFFER_SIZE];
cb_data_recieved(self.server_socket.port, self.user_data.?, @ptrToInt(self), buffer[0..bytesRead]);
try reregisterBuffer(buffer_id);
try self.queueRead();
}
// N.B. Because it is possible for writes to only partially complete, only one write
// may be queued per connection at once. This prevents parts of the data from being skipped.
// N.B. Data must be a subslice of a buffer from write_buffer_pool
fn queueWrite(self: *Connection, data: []const u8, meta_data: u64) !void {
if (self.state != .Reading) {
return error.InvalidState;
}
if (self.user_data == null) {
assert(false);
return error.MissingUserData;
}
if (self.write_in_progress) {
assert(false);
return error.WriteAlreadyQueued;
}
var event = try uring_event_pool.alloc();
errdefer uring_event_pool.free(event);
event.* = URingEventData{
.op_type = .Write,
.conn = self,
.io = data,
.meta_data = meta_data,
.connection = self,
};
if (try incrementPendingEventCounter(event)) {
errdefer events_pending -= 1;
try event.submit();
}
}
fn writeComplete(self: *Connection, event: *URingEventData, bytes_written: u32) void {
self.write_in_progress = false;
if (self.state != .Reading) {
return;
}
if (self.user_data == null) {
assert(false);
return;
}
if (cb_write_complete != null) {
cb_write_complete.?(self.server_socket.port, self.user_data.?, @ptrToInt(self), event.io[0..bytes_written], event.meta_data);
}
}
fn queueClose(self: *Connection) !void {
if (self.state == .Closing) {
return;
}
self.state = .Closing;
var event = try uring_event_pool.alloc();
errdefer uring_event_pool.free(event);
event.* = URingEventData{
.op_type = .Close,
.conn = self,
.io = undefined,
.meta_data = undefined, // not used
.connection = self,
};
if (try incrementPendingEventCounter(event)) {
errdefer events_pending -= 1;
try event.submit();
}
}
pub fn closed(self: *Connection) void {
if (connections_counter > 0) {
connections_counter -= 1;
}
if (self.state != .Accepting and self.user_data != null) {
cb_connection_lost(self.server_socket.port, self.user_data.?, @ptrToInt(self));
}
self.user_data = null;
}
pub fn closeIfIdle(self: *Connection) !void {
if (events_pending > QUEUE_DEPTH - 5) {
return error.GenericCallbackError;
}
if (self.write_in_progress) {
return;
}
if (std.time.milliTimestamp() - self.last_read_time < 10 * 1000) {
return;
}
// Idle, close.
self.queueClose() catch {
return error.GenericCallbackError;
};
}
};
var one_time_init_done = false;
pub fn oneTimeInit() !void {
if (one_time_init_done) {
return;
}
one_time_init_done = true;
// By default if the TCP connection is closed and we try to write to it
// the server will crash.
// This stops that. The write command will fail and the connection will
// be closed gracefully.
var sig_action = std.mem.zeroes(Sigaction);
sig_action.sigaction = SIG_IGN;
const e = sigaction(SIGPIPE, &sig_action, null);
}
pub const SocketInitInfo = struct {
port: u16
};
// Blocks indefinitely
pub fn start(
socket_setup_info: []const SocketInitInfo,
cb_new_connection_: callback_new_connection,
cb_data_recieved_: callback_data_received,
cb_connection_lost_: callback_connection_lost,
cb_write_complete_: ?callback_write_complete,
) !void {
cb_new_connection = cb_new_connection_;
cb_data_recieved = cb_data_recieved_;
cb_connection_lost = cb_connection_lost_;
cb_write_complete = cb_write_complete_;
if (uring.io_uring_queue_init(QUEUE_DEPTH, &ring, 0) < 0) {
return error.IoUringQueueInitError;
}
connection_pool = ObjectPool(Connection, 4096, null).init(c_allocator, c_allocator);
uring_event_pool = ObjectPool(URingEventData, 256, null).init(c_allocator, c_allocator);
write_buffer_pool = ObjectPool([WRITE_BUFFER_SIZE]u8, 256, writeBuffersOnAlloc).init(c_allocator, page_allocator);
events_backlog = try Queue(*URingEventData).init(c_allocator, 256);
try createListenSockets(socket_setup_info);
try createBuffers();
write_buffer_pool.free(try write_buffer_pool.alloc());
try startListening();
}
fn createBuffers() !void {
var event = try uring_event_pool.alloc();
errdefer uring_event_pool.free(event);
event.* = URingEventData{
.op_type = .BufferRegister,
.conn = undefined,
.io = undefined,
.meta_data = undefined,
.connection = undefined,
};
events_pending += 1;
errdefer events_pending -= 1;
read_buffers = try c_allocator.alloc(u8, NUM_READ_BUFFERS * READ_BUFFER_SIZE);
var sqe: *uring.io_uring_sqe = uring.io_uring_get_sqe(&ring);
io_uring_events_being_submitted += 1;
// Group 1, IDs start at 1
uring.io_uring_prep_provide_buffers(sqe, @ptrCast(*c_void, read_buffers), READ_BUFFER_SIZE, NUM_READ_BUFFERS, 1, 1);
uring.io_uring_sqe_set_data(sqe, @ptrCast(*c_void, event));
}
fn reregisterBuffer(id: u32) !void {
if (id == 0 or id > NUM_READ_BUFFERS) {
return;
}
const idx = id - 1;
// TODO pass event as null
var event = try uring_event_pool.alloc();
errdefer uring_event_pool.free(event);
event.* = URingEventData{
.op_type = .BufferRegister,
.conn = undefined,
.io = undefined,
.meta_data = undefined,
.connection = undefined,
};
events_pending += 1;
errdefer events_pending -= 1;
var sqe: *uring.io_uring_sqe = uring.io_uring_get_sqe(&ring);
io_uring_events_being_submitted += 1;
// Group 1
uring.io_uring_prep_provide_buffers(sqe, @ptrCast(*c_void, read_buffers[idx * READ_BUFFER_SIZE .. (idx + 1) * READ_BUFFER_SIZE]), READ_BUFFER_SIZE, 1, 1, @intCast(c_int, id));
uring.io_uring_sqe_set_data(sqe, @ptrCast(*c_void, event));
}
// Convert from host byte order to network byte order
// Also works in reverse
// Does nothing on big endian CPUs
fn hton(comptime T: type, x: T) T {
if (builtin.endian == builtin.Endian.Little) {
return @byteSwap(T, x);
}
return x;
}
const ntoh = hton;
// Creates socket that listens for incoming connections
fn createListenSockets(socket_setup_info: []const SocketInitInfo) !void {
server_sockets = ArrayList(ListenSocket).init(c_allocator);
for (socket_setup_info) |info| {
const server_socket = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
if (server_socket == -1) {
fatalErrorLog("Error creating listening socket (socket())", .{});
return error.SocketError;
}
errdefer _ = close(server_socket);
// Allow multiple sockets to be bound to the same port
// So multiple threads can use different listening sockets on the same port
var c_int_1: c_int = 1;
const setsockopt_err = setsockopt(server_socket, SOL_SOCKET, SO_REUSEPORT, &c_int_1, @sizeOf(c_int));
if (setsockopt_err != 0) {
fatalErrorLog("Error setting SO_REUSEPORT", .{});
return error.SocketError;
}
var addr = std.mem.zeroes(sockaddr_in6);
addr.family = AF_INET6;
addr.addr = uring.in6addr_any.__in6_u.__u6_addr8; // TODO remove
addr.port = hton(u16, info.port);
if (bind(server_socket, @ptrCast(*sockaddr, &addr), @sizeOf(sockaddr_in6)) < 0) {
fatalErrorLog("Error binding socket: {}", .{getErrno(-1)});
return error.SocketError;
}
if (listen(server_socket, SOCKET_BACKLOG) < 0) {
fatalErrorLog("Error setting socket to listen", .{});
return error.SocketError;
}
try server_sockets.append(ListenSocket{
.fd = server_socket,
.port = info.port,
});
}
}
extern fn io_uring_cqe_seen__(usize, usize) void;
extern fn io_uring_wait_cqe__(usize, usize) c_int;
extern fn sqe_set_buf_group(usize, u32) void;
extern fn sqe_set_flags(usize, u8) void;
threadlocal var time_last_killed_idle_connections: u64 = 0;
threadlocal var time_last_outputted_statistics: u64 = 0;
// Blocks indefinitely
fn startListening() !void {
for (server_sockets.items) |*s| {
try s.queueAccept();
}
while (true) {
while (io_uring_events_being_submitted > 0) {
const x = uring.io_uring_submit(&ring);
if (x < 0) {
return error.IoUringError;
}
if (x != io_uring_events_being_submitted) {
dbgLog("io_uring_submit submitted fewer than expected", .{});
}
if (x == 0) {
io_uring_events_being_submitted = 0;
break;
}
io_uring_events_being_submitted -= @intCast(u32, x);
}
if (config().enable_statistics and
std.time.milliTimestamp() - time_last_outputted_statistics > 5 * 1000)
{
time_last_outputted_statistics = std.time.milliTimestamp();
printStatistics();
}
if (events_pending > (QUEUE_DEPTH / 10) * 9 and std.time.milliTimestamp() - time_last_killed_idle_connections > 2 * 60 * 1000) {
// Thread reaching max capacity.
connection_pool.forEach(Connection.closeIfIdle) catch {};
time_last_killed_idle_connections = std.time.milliTimestamp();
}
while (events_pending < QUEUE_DEPTH - 5 and events_backlog.size > 0) {
const e = events_backlog.dequeue() catch unreachable;
dbgLog("Submitting event from backlog. Event type = {}", .{e.*.op_type});
e.submit() catch {
if (e.op_type != .BufferRegister and e.op_type != .Accept and e.op_type != .Close) {
e.connection.queueClose() catch {};
}
};
// Do not free the event. It will be freed when it completes.
}
const ret = io_uring_wait_cqe__(@ptrToInt(&ring), @ptrToInt(&cqe));
events_pending -= 1;
if (ret < 0) {
fatalErrorLog("io_uring_wait_cqe returned < 0", .{});
return error.URingError;
}
const event = @intToPtr(*URingEventData, cqe.*.user_data);
const conn = event.conn;
dbgLog("async event complete: {}. events_pending is {}", .{ event.op_type, events_pending });
if (event.op_type == URingEventData.OpType.Accept) {
// Get socket ready to accept next connection
conn.server_socket.queueAccept() catch |e| {
fatalErrorLog("Error queueing accept on socket: {}", .{e});
return e;
};
if (cqe.*.res >= 0) {
// New connection
var err = false;
conn.accept(cqe.*.res) catch |e| {
errLog("Accept error: {}", .{e});
err = true;
conn.queueClose() catch {};
};
if (!err) {
conn.queueRead() catch |e| {
errLog("Initial read error: {}", .{e});
conn.queueClose() catch {};
};
}
} else {
dbgLog("Error accepting connection. Server may be overloaded", .{});
connection_pool.free(event.conn);
}
} else if (event.op_type == URingEventData.OpType.Read) {
if (cqe.*.res <= 0) {
// Socket closed or error
if (cqe.*.res == -ENOBUFS) {
errLog("Out of read buffer space (ENOBUFS)!", .{});
// TODO: Allocate more read buffers
} else if (cqe.*.res == 0) {
dbgLog("Connection closed", .{});
} else if (cqe.*.res != -ECONNRESET) {
errLog("Read failed with error: {}", .{cqe.*.res});
}
conn.readCompleteOrFailed() catch |e| {
errLog("readCompleteOrFailed() failed with error: {}", .{e});
};
conn.queueClose() catch {};
} else {
bytes_recieved_total += @intCast(usize, cqe.*.res);
conn.readCompleteOrFailed() catch |e| {
errLog("readCompleteOrFailed() failed with error: {}", .{e});
conn.queueClose() catch {};
};
}
} else if (event.op_type == URingEventData.OpType.Write) {
if (cqe.*.res <= 0) {
if (cqe.*.res < 0 and cqe.*.res != -ECONNRESET) {
errLog("Write error. cqe.*.res = {}", .{cqe.*.res});
}
// Socket closed
conn.queueClose() catch {};
} else {
bytes_sent_total += @intCast(usize, cqe.*.res);
if (cqe.*.res < event.io.len) {
dbgLog("Incomplete write. cqe.*.res = {}, event.io.len = {}", .{ cqe.*.res, event.io.len });
}
conn.writeComplete(event, @intCast(u32, std.math.min(@intCast(usize, cqe.*.res), event.io.len)));
if (cqe.*.res < event.io.len) {
conn.queueWrite(event.io[@intCast(usize, cqe.*.res)..], event.meta_data) catch |e| {
conn.queueClose() catch {};
};
}
}
} else if (event.op_type == URingEventData.OpType.Close) {
conn.closed();
connection_pool.free(conn);
}
uring_event_pool.free(event);
// uring.io_uring_cqe_seen(&ring, cqe);
io_uring_cqe_seen__(@ptrToInt(&ring), @ptrToInt(cqe));
}
}
// If this function returns an error then the connection is lost and socketFd is invalid
pub fn sendData(conn_: usize, data: []const u8, meta_data: u64) !void {
const conn = @intToPtr(*Connection, conn_);
conn.queueWrite(data, meta_data) catch |e| {
conn.queueClose() catch {};
return e;
};
}
pub fn closeSocket(conn_: usize) void {
dbgLog("Server closing TCP socket", .{});
const conn = @intToPtr(*Connection, conn_);
conn.queueClose() catch {};
}
pub fn ipToString(ip: u128, out: []u8) !void {
const err = uring.inet_ntop(AF_INET6, &ip, out.ptr, @intCast(c_uint, out.len));
if (err == null) {
return error.GenericError;
}
} | src/TCPServer.zig |
const std = @import("std");
const v = @import("vector_types.zig");
extern fn @"llvm.x86.pclmulqdq"(v.i64x2, v.i64x2, i8) v.i64x2;
pub inline fn carrylessMul(a: v.u64x2, b: v.u64x2) v.u64x2 {
return @bitCast(
v.u64x2,
@"llvm.x86.pclmulqdq"(@bitCast(v.i64x2, a), @bitCast(v.i64x2, b), 0),
);
}
test "pclmulqdq" {
const a = 0b10100010;
const b = 0b10010110;
const expected = @as(u64, 0b101100011101100);
const av: v.u64x2 = .{ a, 0 };
const bv: v.u64x2 = .{ b, 0 };
const r = carrylessMul(av, bv);
try std.testing.expectEqual(expected, r[0]);
}
extern fn @"llvm.x86.avx2.pshuf.b"(a: v.u8x32, b: v.u8x32) v.u8x32;
pub inline fn shuffleEpi8(a: v.u8x32, b: v.u8x32) v.u8x32 {
return @"llvm.x86.avx2.pshuf.b"(a, b);
}
extern fn @"llvm.x86.ssse3.pshuf.b.128"(a: v.u8x16, b: v.u8x16) v.u8x16;
pub inline fn shuffleEpi32(a: v.u8x16, b: v.u8x16) v.u8x16 {
return @"llvm.x86.ssse3.pshuf.b.128"(a, b);
}
test "pshufb" {
const x = shuffleEpi8(("a" ** 32).*, ("b" ** 32).*);
_ = x;
// std.debug.print("x {s}\n", .{@as([32]u8, x)});
}
extern fn @"llvm.x86.vpalignr"(v.i64x2, v.i64x2, i8) v.i64x2;
pub inline fn vpalignr(a: v.i64x2, b: v.i64x2, c: i8) v.i64x2 {
return @"llvm.x86.vpalignr"(a, b, c);
}
extern fn @"llvm.x86.avx2.pmovmskb"(v.u8x32) u32;
pub inline fn _mm256_movemask_epi8(a: v.u8x32) u32 {
return @"llvm.x86.avx2.pmovmskb"(a);
}
extern fn @"llvm.x86.ssse3.pmadd.ub.sw.128"(v.u8x16, v.u8x16) v.u16x8;
pub inline fn _mm_maddubs_epi16(a: v.u8x16, b: v.u8x16) v.u16x8 {
return @"llvm.x86.ssse3.pmadd.ub.sw.128"(a, b);
}
extern fn @"llvm.x86.sse2.pmadd.wd"(v.u16x8, v.u16x8) v.u32x4;
pub inline fn _mm_madd_epi16(a: v.u16x8, b: v.u16x8) v.u32x4 {
return @"llvm.x86.sse2.pmadd.wd"(a, b);
}
extern fn @"llvm.x86.sse41.packusdw"(a: v.u32x4, b: v.u32x4) v.u16x8;
pub inline fn _mm_packus_epi32(a: v.u32x4, b: v.u32x4) v.u16x8 {
return @"llvm.x86.sse41.packusdw"(a, b);
}
// extern fn @"llvm.x86.sse2.mov.dqu"(v.u8x16, v.u8x16, [*]u8) void;
// pub inline fn _mm256_storeu_si256(a: [*]u8, b: v.u8x32) void {
// const chunk: [32]u8 = b;
// @"llvm.x86.sse2.mov.dqu"(chunk[0..16].*, chunk[16..32].*, a);
// } | src/llvm_intrinsics.zig |
const builtin = @import("builtin");
const std = @import("std");
const Builder = std.build.Builder;
const Step = std.build.Step;
const Crc32WithPoly = std.hash.crc.Crc32WithPoly;
const Polynomial = std.hash.crc.Polynomial;
const ElfHeader = std.elf.Header;
const uf2 = @import("build/uf2.zig");
const UF2 = uf2.UF2;
const FILE_DELIM = switch (builtin.os.tag) {
.windows => "\\",
else => "/", // Are we sure about that?
};
const FlashKind = enum {
W25Q080,
};
pub fn build(b: *Builder) void {
const output_name = "rp2040_zig";
const elf_name = output_name ++ ".elf";
const uf2_name = output_name ++ ".uf2";
const flash_kind = b.option(FlashKind, "flash-kind", "The flash memory kind to boot from") orelse FlashKind.W25Q080;
const is_release_small_boot2 = b.option(bool, "release-small-ipl", "Use space-optimized version of the IPL");
const mode = b.standardReleaseOptions();
const rp2040_ras = std.build.Pkg{
.name = "rp2040_ras",
.path = std.build.FileSource{
.path = "rp2040_ras/rp2040_ras.zig",
},
};
const boot2_source = switch (flash_kind) {
.W25Q080 => "src/ipl/w25q080.zig",
};
const boot2 = b.addObject("boot2", boot2_source);
if (is_release_small_boot2 orelse false) {
boot2.setBuildMode(.ReleaseSmall);
} else {
boot2.setBuildMode(mode);
}
const app = b.addObject("app", "src/runtime.zig");
app.setBuildMode(mode);
const elf = b.addExecutable(elf_name, null);
elf.setBuildMode(mode);
elf.setOutputDir(switch (mode) {
.Debug => "Binary/Debug",
.ReleaseSafe => "Binary/ReleaseSafe",
.ReleaseFast => "Binary/ReleaseFast",
.ReleaseSmall => "Binary/ReleaseSmall",
});
// Set the target to thumbv6m-freestanding-eabi
const target = std.zig.CrossTarget{
.os_tag = .freestanding,
.cpu_arch = .thumb,
.cpu_model = .{
.explicit = &std.Target.arm.cpu.cortex_m0plus,
},
.abi = .eabi,
};
boot2.setTarget(target);
app.setTarget(target);
elf.setTarget(target);
boot2.addPackage(rp2040_ras);
app.addPackage(rp2040_ras);
// Use the custom linker script to build a baremetal program
elf.setLinkerScriptPath(std.build.FileSource{
.path = "src/linker.ld",
});
elf.addObject(boot2);
elf.addObject(app);
var write_checksum = b.allocator.create(WriteChecksumStep) catch unreachable;
write_checksum.* = WriteChecksumStep.init(
b,
"checksum",
elf.getOutputSource(),
);
write_checksum.step.dependOn(&elf.step);
var generate_uf2 = b.allocator.create(GenerateUF2Step) catch unreachable;
const uf2_output_path = std.mem.concat(b.allocator, u8, &[_][]const u8{
elf.output_dir orelse unreachable,
FILE_DELIM,
uf2_name,
}) catch unreachable;
generate_uf2.* = GenerateUF2Step.init(
b,
"uf2",
elf.getOutputSource(),
uf2_output_path,
);
generate_uf2.step.dependOn(&write_checksum.step);
b.default_step.dependOn(&generate_uf2.step);
}
const WriteChecksumStepError = error{
InvalidExecutableSize,
IPLSectionNotFound,
};
const WriteChecksumStep = struct {
step: Step,
elf_file_source: std.build.FileSource,
builder: *std.build.Builder,
pub fn init(
builder: *std.build.Builder,
name: []const u8,
elf_file_source: std.build.FileSource,
) WriteChecksumStep {
return .{
.step = Step.init(.custom, name, builder.allocator, write_checksum),
.elf_file_source = elf_file_source,
.builder = builder,
};
}
fn write_checksum(step: *Step) !void {
const self = @fieldParentPtr(WriteChecksumStep, "step", step);
const elf_filename = self.elf_file_source.getPath(self.builder);
const elf_file = try std.fs.cwd().openFile(elf_filename, .{
.read = true,
.write = true,
});
defer elf_file.close();
const reader = elf_file.reader();
const writer = elf_file.writer();
const elf_header = try ElfHeader.read(elf_file);
var found_file_offset: ?u32 = null;
var prog_header_it = elf_header.program_header_iterator(elf_file);
while (try prog_header_it.next()) |header| {
const file_offset = header.p_offset;
const section_size = header.p_filesz;
const target_address = header.p_paddr;
if (section_size == 256 and target_address == 0x10000000) {
found_file_offset = @intCast(u32, file_offset);
}
}
const ipl_file_offset = found_file_offset orelse return WriteChecksumStepError.IPLSectionNotFound;
var boot2_binary: [252]u8 = undefined;
try elf_file.seekTo(ipl_file_offset);
const length = try reader.readAll(boot2_binary[0..]);
if (length != 252) return WriteChecksumStepError.InvalidExecutableSize;
// Polynomial: 0x04C11DB7 (0xEDB88320 when reversed)
// Initial value: 0xFFFFFFFF (same as the Zig's implementation)
// Input/result reflection: no (yes for the Zig's implementation)
// Final XOR value: 0x00000000 (0xFFFFFFFF for the Zig's implementation)
// We need to bitReverse both the input bytes and the result.
// Also, the result should be inverted.
for (boot2_binary) |b, i| {
boot2_binary[i] = @bitReverse(u8, b);
}
const Crc32RaspberryPi = Crc32WithPoly(@intToEnum(Polynomial, 0xEDB88320));
const checksum = ~@bitReverse(u32, Crc32RaspberryPi.hash(boot2_binary[0..]));
var checksum_buf: [4]u8 = undefined;
std.mem.writeIntLittle(u32, &checksum_buf, checksum);
try elf_file.seekTo(ipl_file_offset + 252);
try writer.writeAll(checksum_buf[0..]);
}
};
const GenerateUF2Step = struct {
step: Step,
elf_file_source: std.build.FileSource,
uf2_filename: []const u8,
builder: *std.build.Builder,
pub fn init(
builder: *std.build.Builder,
name: []const u8,
elf_file_source: std.build.FileSource,
uf2_filename: []const u8,
) GenerateUF2Step {
return .{
.step = Step.init(.custom, name, builder.allocator, generate_uf2),
.elf_file_source = elf_file_source,
.uf2_filename = uf2_filename,
.builder = builder,
};
}
fn generate_uf2(step: *Step) !void {
const self = @fieldParentPtr(GenerateUF2Step, "step", step);
const elf_filename = self.elf_file_source.getPath(self.builder);
const elf_file = try std.fs.cwd().openFile(
elf_filename,
.{
.read = true,
},
);
defer elf_file.close();
const uf2_file = try std.fs.cwd().createFile(
self.uf2_filename,
.{
.truncate = true,
},
);
defer uf2_file.close();
const reader = elf_file.reader();
const writer = uf2_file.writer();
var uf2_writer = UF2.init(&self.builder.allocator, 0x10000000, .{ .family_id = 0xe48bff56 });
defer uf2_writer.deinit();
const elf_header = try ElfHeader.read(elf_file);
var prog_header_it = elf_header.program_header_iterator(elf_file);
while (try prog_header_it.next()) |header| {
if (header.p_filesz == 0) continue;
const file_offset = header.p_offset;
const section_size = header.p_filesz;
const target_address = header.p_paddr;
try elf_file.seekTo(file_offset);
var read_len: usize = 0;
while (read_len < section_size) {
var buf: [256]u8 = undefined;
const bytes = try reader.readAll(buf[0..]);
const chunk_len = if (read_len + bytes > section_size) section_size - read_len else bytes;
try uf2_writer.addData(buf[0..chunk_len], @intCast(u32, target_address + read_len));
read_len += bytes;
}
}
try uf2_writer.write(&writer);
}
}; | build.zig |
const bake = @import("src/bake.zig");
const cfg = @import("src/cfg.zig");
const minify = @import("src/minify.zig");
const std = @import("std");
// package for "baking" resources into runtime-ready format
pub fn getBakePkg(
builder: *std.build.Builder,
options: Options,
name: []const u8,
dest_dir: []const u8,
comptime recipe: Recipe,
) std.build.Pkg {
const baker = Baker(recipe).init(builder, options, name, dest_dir) catch unreachable;
return baker.getPkg();
}
// cross platform graphics based on webgpu
pub fn getGfxPkg() std.build.Pkg {
return std.build.Pkg{
.name = "cc_gfx",
.path = .{ .path = "src/gfx.zig" },
};
}
// cross platform math (exports zmath)
pub fn getMathPkg(builder: *std.build.Builder) std.build.Pkg {
const ext_dir = getExtDir(builder) catch unreachable;
const zmath_clone = GitClone.init(
builder,
ext_dir,
"https://github.com/michal-z/zig-gamedev.git",
"6e0a0ba9a9d4d087215928345208094ae9806ab3",
false,
) catch unreachable;
const zmath_path = std.fs.path.join(
builder.allocator,
&.{ ext_dir, "zig-gamedev", "libs", "zmath", "src", "zmath.zig" },
) catch unreachable;
const zmath_gen = builder.allocator.create(std.build.GeneratedFile) catch unreachable;
zmath_gen.* = .{
.step = &zmath_clone.step,
.path = zmath_path,
};
const dependencies = builder.allocator.alloc(std.build.Pkg, 1) catch unreachable;
dependencies[0] = .{
.name = "zmath",
.path = .{ .generated = zmath_gen },
};
return std.build.Pkg{
.name = "cc_math",
.path = .{ .path = "src/math.zig" },
.dependencies = dependencies,
};
}
// cross platform memory allocation
pub fn getMemPkg() std.build.Pkg {
return std.build.Pkg{
.name = "cc_mem",
.path = .{ .path = "src/mem.zig" },
};
}
// cross platform file system resources
pub fn getResPkg() std.build.Pkg {
return std.build.Pkg{
.name = "cc_res",
.path = .{ .path = "src/res.zig" },
};
}
// cross platform timing and profiling
pub fn getTimePkg() std.build.Pkg {
return std.build.Pkg{
.name = "cc_time",
.path = .{ .path = "src/time.zig" },
};
}
// user interface
pub fn getUiPkg(builder: *std.build.Builder) std.build.Pkg {
return std.build.Pkg{
.name = "cc_ui",
.path = .{ .path = "src/ui.zig" },
.dependencies = &.{getMathPkg(builder)},
};
}
// gfx implementation for user interface
pub fn getUiGfxPkg() std.build.Pkg {
return std.build.Pkg{
.name = "cc_ui_gfx",
.path = .{ .path = "src/ui_gfx.zig" },
};
}
// res implementation for user interface
pub fn getUiResPkg(builder: *std.build.Builder, options: Options) std.build.Pkg {
const recipe = Recipe{
.dir = "src",
.items = &.{
.{ .bake_type = bake.Shader, .path = "ui_vert.wgsl", .embed = true },
.{ .bake_type = bake.Shader, .path = "ui_frag.wgsl", .embed = true },
},
};
const dependencies = builder.allocator.alloc(std.build.Pkg, 1) catch unreachable;
dependencies[0] = getBakePkg(builder, options, "cc_ui_res", ".", recipe);
return std.build.Pkg{
.name = "cc_ui_res",
.path = .{ .path = "src/ui_res.zig" },
.dependencies = dependencies,
};
}
// cross platform windowing
pub fn getWndPkg() std.build.Pkg {
return std.build.Pkg{
.name = "cc_wnd",
.path = .{ .path = "src/wnd.zig" },
};
}
// helper package for wnd and gfx interop
pub fn getWndGfxPkg() std.build.Pkg {
return std.build.Pkg{
.name = "cc_wnd_gfx",
.path = .{ .path = "src/wnd_gfx.zig" },
};
}
pub const RecipeItem = struct {
bake_type: type,
path: []const u8,
embed: bool,
};
pub const Recipe = struct {
dir: []const u8,
items: []const RecipeItem,
};
pub const Options = struct {
platform: cfg.Platform = .web,
opt_level: cfg.OptLevel = .dbg,
bake_level: ?cfg.OptLevel = null,
log_level: std.log.Level = .debug,
log_enabled: bool = true,
pub fn init(builder: *std.build.Builder) Options {
const platform = builder.option(
cfg.Platform,
"p",
"platform",
) orelse .web;
const opt_level = builder.option(
cfg.OptLevel,
"opt",
"optimization level",
) orelse .dbg;
const bake_level = builder.option(
cfg.OptLevel,
"bake",
"when specified, resources will be baked before compiling",
);
const log_level = builder.option(
std.log.Level,
"log",
"log level",
) orelse switch (opt_level) {
.dbg => std.log.Level.debug,
.rel => std.log.Level.err,
};
const log_enabled = builder.option(
bool,
"log_enabled",
"set to false to disable logging",
) orelse true;
return Options{
.platform = platform,
.opt_level = opt_level,
.bake_level = bake_level,
.log_level = log_level,
.log_enabled = log_enabled,
};
}
};
const Example = enum {
tri,
cube,
ui,
};
pub fn build(builder: *std.build.Builder) !void {
const ex = builder.option(Example, "ex", "example project") orelse .tri;
switch (ex) {
.tri => try buildTri(builder),
.cube => try buildCube(builder),
.ui => try buildUi(builder),
}
}
fn buildTri(builder: *std.build.Builder) !void {
const options = Options.init(builder);
const dest_dir = try getDestDir(builder, options, "tri");
const recipe = Recipe{
.dir = "ex/tri",
.items = &.{
.{ .bake_type = bake.Shader, .path = "tri_vert.wgsl", .embed = true },
.{ .bake_type = bake.Shader, .path = "tri_frag.wgsl", .embed = true },
},
};
const tri_pkg = std.build.Pkg{
.name = "tri",
.path = .{ .path = "ex/tri/tri.zig" },
.dependencies = &.{
getBakePkg(builder, options, "tri", dest_dir, recipe),
getGfxPkg(),
getResPkg(),
getWndPkg(),
getWndGfxPkg(),
},
};
_ = try initMainLibExe(builder, options, tri_pkg);
}
fn buildCube(builder: *std.build.Builder) !void {
const options = Options.init(builder);
const dest_dir = try getDestDir(builder, options, "cube");
const recipe = Recipe{
.dir = "ex/cube",
.items = &.{
.{ .bake_type = bake.Shader, .path = "cube_vert.wgsl", .embed = true },
.{ .bake_type = bake.Shader, .path = "cube_frag.wgsl", .embed = true },
},
};
const cube_pkg = std.build.Pkg{
.name = "cube",
.path = .{ .path = "ex/cube/cube.zig" },
.dependencies = &.{
getBakePkg(builder, options, "cube", dest_dir, recipe),
getGfxPkg(),
getMathPkg(builder),
getResPkg(),
getTimePkg(),
getWndPkg(),
getWndGfxPkg(),
},
};
_ = try initMainLibExe(builder, options, cube_pkg);
}
fn buildUi(builder: *std.build.Builder) !void {
const options = Options.init(builder);
const ui_pkg = std.build.Pkg{
.name = "ui",
.path = .{ .path = "ex/ui/ui.zig" },
.dependencies = &.{
getGfxPkg(),
getMemPkg(),
getUiPkg(builder),
getUiGfxPkg(),
getUiResPkg(builder, options),
getWndPkg(),
getWndGfxPkg(),
},
};
_ = try initMainLibExe(builder, options, ui_pkg);
}
pub fn initMainLibExe(
builder: *std.build.Builder,
options: Options,
pkg: std.build.Pkg,
) !*std.build.LibExeObjStep {
const app_name = pkg.name;
var app_pkg = builder.dupePkg(pkg);
app_pkg.name = "app";
const build_options = builder.addOptions();
build_options.addOption(bool, "log_enabled", options.log_enabled);
build_options.addOption(std.log.Level, "log_level", options.log_level);
const dest_dir = try getDestDir(builder, options, app_name);
const main_lib_exe = switch (options.platform) {
.web => try initWebLibExe(builder, app_name),
.win => return error.NotYetImplemented,
};
main_lib_exe.setBuildMode(switch (options.opt_level) {
.dbg => .Debug,
.rel => .ReleaseFast,
});
main_lib_exe.override_dest_dir = .{ .custom = dest_dir };
main_lib_exe.addPackage(build_options.getPackage("build_options"));
main_lib_exe.addPackage(app_pkg);
main_lib_exe.install();
try installPlatformFiles(builder, options, app_name, dest_dir);
return main_lib_exe;
}
fn initWebLibExe(builder: *std.build.Builder, name: []const u8) !*std.build.LibExeObjStep {
const main_lib_exe = builder.addSharedLibrary(name, "src/main.zig", .unversioned);
const target = try std.zig.CrossTarget.parse(.{ .arch_os_abi = "wasm32-freestanding" });
main_lib_exe.setTarget(target);
return main_lib_exe;
}
pub fn installPlatformFiles(
builder: *std.build.Builder,
options: Options,
name: []const u8,
dest_dir: []const u8,
) !void {
switch (options.platform) {
.web => try installWebFiles(builder, options, name, dest_dir),
.win => return error.NotYetImplemented,
}
}
fn installWebFiles(
builder: *std.build.Builder,
options: Options,
name: []const u8,
dest_dir: []const u8,
) !void {
const gen_web_files = try GenerateWebFiles.init(builder, options, name);
const install_html_path = try std.fs.path.join(
builder.allocator,
&.{ dest_dir, "index.html" },
);
defer builder.allocator.free(install_html_path);
const install_js_path = try std.fs.path.join(
builder.allocator,
&.{ dest_dir, "cupcake.js" },
);
defer builder.allocator.free(install_js_path);
const install_html = builder.addInstallFile(
.{ .generated = &gen_web_files.html_file },
install_html_path,
);
const install_js = builder.addInstallFile(
.{ .generated = &gen_web_files.js_file },
install_js_path,
);
if (options.bake_level != null) {
install_html.step.dependOn(&gen_web_files.step);
install_js.step.dependOn(&gen_web_files.step);
}
const install_step = builder.getInstallStep();
install_step.dependOn(&install_html.step);
install_step.dependOn(&install_js.step);
}
fn getCacheDir(builder: *std.build.Builder) ![]u8 {
return try std.fs.path.join(
builder.allocator,
&.{ builder.build_root, builder.cache_root, "cupcake" },
);
}
fn getBakeCacheDir(builder: *std.build.Builder, options: Options, name: []const u8) ![]u8 {
return try std.fs.path.join(
builder.allocator,
&.{ try getCacheDir(builder), "bake", name, @tagName(options.platform) },
);
}
fn getDestDir(builder: *std.build.Builder, options: Options, name: []const u8) ![]u8 {
return try std.fs.path.join(
builder.allocator,
&.{ name, @tagName(options.platform) },
);
}
fn getExtDir(builder: *std.build.Builder) ![]u8 {
return try std.fs.path.join(
builder.allocator,
&.{ try getCacheDir(builder), "ext" },
);
}
// takes in a path, returns a valid version of that path for embedding in a source file
fn getPathString(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
var path_string = std.ArrayList(u8).init(allocator);
for (path) |char| {
if (std.fs.path.isSep(char)) {
try path_string.appendSlice("/");
} else {
try path_string.append(char);
}
}
return path_string.toOwnedSlice();
}
// todo: add mechanism for user to add bake types
pub fn Baker(comptime recipe: Recipe) type {
return struct {
const Self = @This();
const bake_dependencies = [_]std.build.Pkg{.{
.name = "bake",
.path = .{ .path = "src/bake.zig" },
}};
builder: *std.build.Builder,
platform: cfg.Platform,
bake_level: ?cfg.OptLevel,
cache_dir: []const u8,
install_step: std.build.Step,
list_step: std.build.Step,
list_file: std.build.GeneratedFile,
pkg_step: std.build.Step,
pkg_file: std.build.GeneratedFile,
pub fn init(
builder: *std.build.Builder,
options: Options,
name: []const u8,
dest_dir: []const u8,
) !*Self {
const cache_dir = try getBakeCacheDir(builder, options, name);
var self = try builder.allocator.create(Self);
self.* = .{
.builder = builder,
.platform = options.platform,
.bake_level = options.bake_level,
.cache_dir = cache_dir,
.install_step = std.build.Step.initNoOp(.custom, "install", builder.allocator),
.list_step = std.build.Step.init(.custom, "list", builder.allocator, makeList),
.list_file = .{ .step = &self.list_step },
.pkg_step = std.build.Step.init(.custom, "pkg", builder.allocator, makePkg),
.pkg_file = .{
.step = &self.pkg_step,
.path = try std.fs.path.join(
builder.allocator,
&.{ cache_dir, "bake_pkg.zig" },
),
},
};
if (options.bake_level != null) {
try std.fs.cwd().makePath(self.cache_dir);
const bake_exe = builder.addExecutable("bake", "src/bake.zig");
bake_exe.setBuildMode(.ReleaseSafe);
bake_exe.addPackage(.{
.name = "bake_list",
.path = .{ .generated = &self.list_file },
.dependencies = &bake_dependencies,
});
self.pkg_step.dependOn(&bake_exe.run().step);
self.install_step.dependOn(&self.pkg_step);
}
inline for (recipe.items) |item| {
if (item.embed) {
continue;
}
const var_name = comptime bake.getVarName(item.path, item.bake_type);
const item_path = try std.fs.path.join(
builder.allocator,
&.{ self.cache_dir, var_name },
);
defer builder.allocator.free(item_path);
const install_path = try std.fs.path.join(
builder.allocator,
&.{ dest_dir, var_name },
);
defer builder.allocator.free(install_path);
const install_gen = try builder.allocator.create(std.build.GeneratedFile);
install_gen.* = .{
.step = &self.pkg_step,
.path = try builder.allocator.dupe(u8, item_path),
};
const install_item = builder.addInstallFile(
.{ .generated = install_gen },
install_path,
);
install_item.step.dependOn(&self.install_step);
builder.getInstallStep().dependOn(&install_item.step);
}
return self;
}
pub fn getPkg(self: Self) std.build.Pkg {
const pkg_src = if (self.bake_level == null) block: {
break :block std.build.FileSource{ .path = self.pkg_file.getPath() };
} else block: {
break :block std.build.FileSource{ .generated = &self.pkg_file };
};
return std.build.Pkg{
.name = "cc_bake",
.path = pkg_src,
.dependencies = &bake_dependencies,
};
}
fn makeList(step: *std.build.Step) !void {
const self = @fieldParentPtr(Self, "list_step", step);
var list_file_contents = std.ArrayList(u8).init(self.builder.allocator);
defer list_file_contents.deinit();
const root_dir = try std.fs.path.join(
self.builder.allocator,
&.{ self.builder.build_root, recipe.dir },
);
const writer = list_file_contents.writer();
try writer.print("pub const bake = @import(\"bake\");\n", .{});
try writer.print(
"pub const in_dir = \"{s}\";\n",
.{try getPathString(self.builder.allocator, root_dir)},
);
try writer.print(
"pub const out_dir = \"{s}\";\n",
.{try getPathString(self.builder.allocator, self.cache_dir)},
);
try writer.print("pub const platform = .{s};\n", .{@tagName(self.platform)});
try writer.print("pub const opt_level = .{s};\n", .{@tagName(self.bake_level.?)});
inline for (recipe.items) |item| {
try writer.print(
"pub const @\"{s}\": type = bake.{s};\n",
.{ try getPathString(self.builder.allocator, item.path), item.bake_type },
);
}
const list_path = try std.fs.path.join(
self.builder.allocator,
&.{ self.cache_dir, "bake_list.zig" },
);
try std.fs.cwd().writeFile(list_path, list_file_contents.items);
self.list_file.path = list_path;
}
fn makePkg(step: *std.build.Step) !void {
const self = @fieldParentPtr(Self, "pkg_step", step);
var pkg_file_contents = std.ArrayList(u8).init(self.builder.allocator);
defer pkg_file_contents.deinit();
var cache_dir = try std.fs.cwd().openDir(self.cache_dir, .{});
defer cache_dir.close();
const writer = pkg_file_contents.writer();
try writer.print("pub const bake = @import(\"bake\");\n", .{});
inline for (recipe.items) |item| {
const var_name = comptime bake.getVarName(item.path, item.bake_type);
try writer.print("pub const {s} = .{{ ", .{var_name});
try writer.print(".Type = bake.{s}, ", .{item.bake_type});
if (item.embed) {
try writer.print(".data = .{{ .embed = @embedFile(\"{s}\") }}", .{var_name});
} else {
const item_file = try cache_dir.openFile(var_name, .{});
defer item_file.close();
const item_file_stat = try item_file.stat();
try writer.print(
".data = .{{ .file = .{{ .path = \"{s}\", .size = {} }} }}",
.{ var_name, item_file_stat.size },
);
}
try writer.print("}};\n", .{});
}
try std.fs.cwd().writeFile(self.pkg_file.getPath(), pkg_file_contents.items);
}
};
}
const GenerateWebFiles = struct {
builder: *std.build.Builder,
step: std.build.Step,
cache_dir: []const u8,
name: []const u8,
bake_level: ?cfg.OptLevel,
html_file: std.build.GeneratedFile,
js_file: std.build.GeneratedFile,
pub fn init(
builder: *std.build.Builder,
options: Options,
name: []const u8,
) !*GenerateWebFiles {
const cache_dir = try getBakeCacheDir(builder, options, name);
try std.fs.cwd().makePath(cache_dir);
const html_file_path = try std.fs.path.join(
builder.allocator,
&.{ cache_dir, "index.html" },
);
const js_file_path = try std.fs.path.join(
builder.allocator,
&.{ cache_dir, "cupcake.js" },
);
var gen_web_files = try builder.allocator.create(GenerateWebFiles);
gen_web_files.* = .{
.builder = builder,
.step = std.build.Step.init(.custom, "gen web files", builder.allocator, make),
.cache_dir = cache_dir,
.name = name,
.bake_level = options.bake_level,
.html_file = .{ .step = &gen_web_files.step, .path = html_file_path },
.js_file = .{ .step = &gen_web_files.step, .path = js_file_path },
};
return gen_web_files;
}
fn make(step: *std.build.Step) !void {
const gen_web_files = @fieldParentPtr(GenerateWebFiles, "step", step);
try gen_web_files.makeHtmlFile();
try gen_web_files.makeJsFile();
}
fn makeHtmlFile(gen_web_files: *GenerateWebFiles) !void {
const html_file = try std.fs.cwd().createFile(
gen_web_files.html_file.getPath(),
.{ .truncate = true },
);
defer html_file.close();
const html_fmt =
\\<!DOCTYPE html>
\\<html>
\\ <head>
\\ <meta charset="utf-8">
\\ <style>
\\ canvas {{
\\ border: 1px solid;
\\ display: block;
\\ margin: 0px auto 0px auto;
\\ }}
\\ </style>
\\ </head>
\\ <body>
\\ <script src="cupcake.js"></script>
\\ <script>
\\ ccRun("{s}.wasm");
\\ </script>
\\ </body>
\\</html>
;
try std.fmt.format(html_file.writer(), html_fmt, .{gen_web_files.name});
}
fn makeJsFile(gen_web_files: *GenerateWebFiles) !void {
// intentional ordering to prevent dependency issues
const js_srcs: []const []const u8 = &.{
"utils.js",
"main_web.js",
"time_web.js",
"res_web.js",
"wnd_web.js",
"gfx_webgpu.js",
};
const js_src_path = try std.fs.path.join(
gen_web_files.builder.allocator,
&.{ gen_web_files.builder.build_root, "src" },
);
defer gen_web_files.builder.allocator.free(js_src_path);
var js_src_dir = try std.fs.cwd().openDir(js_src_path, .{});
defer js_src_dir.close();
var js_file_contents = std.ArrayList(u8).init(gen_web_files.builder.allocator);
defer js_file_contents.deinit();
for (js_srcs) |js_src| {
const js_src_file = try js_src_dir.openFile(js_src, .{});
defer js_src_file.close();
const js_src_file_stat = try js_src_file.stat();
const js_src_bytes = try js_src_file.readToEndAlloc(
gen_web_files.builder.allocator,
js_src_file_stat.size,
);
defer gen_web_files.builder.allocator.free(js_src_bytes);
try js_file_contents.appendSlice(js_src_bytes[0..]);
try js_file_contents.appendSlice("\n");
}
if (gen_web_files.bake_level.? == .dbg) {
try std.fs.cwd().writeFile(gen_web_files.js_file.getPath(), js_file_contents.items);
} else {
const js_src_bytes_min = try minify.js(
js_file_contents.items,
gen_web_files.builder.allocator,
gen_web_files.bake_level.?,
);
defer gen_web_files.builder.allocator.free(js_src_bytes_min);
try std.fs.cwd().writeFile(gen_web_files.js_file.getPath(), js_src_bytes_min);
}
}
};
const GitClone = struct {
step: std.build.Step,
pub fn init(
builder: *std.build.Builder,
dir: []const u8,
repo: []const u8,
commit: []const u8,
recursive: bool,
) !*GitClone {
const git_clone = try builder.allocator.create(GitClone);
git_clone.* = .{
.step = std.build.Step.initNoOp(.custom, "git pull", builder.allocator),
};
const repo_name = std.fs.path.basename(repo);
if (!std.mem.endsWith(u8, repo_name, ".git")) {
return error.InvalidRepoName;
}
const repo_path = try std.fs.path.join(
builder.allocator,
&.{ dir, repo_name[0 .. repo_name.len - 4] },
);
defer builder.allocator.free(repo_path);
var repo_exists = true;
var repo_dir: ?std.fs.Dir = std.fs.cwd().openDir(repo_path, .{}) catch |e| block: {
switch (e) {
error.FileNotFound => {
repo_exists = false;
break :block null;
},
else => return e,
}
};
// todo: check if commit is same as well
if (repo_exists) {
repo_dir.?.close();
return git_clone;
}
try std.fs.cwd().makePath(dir);
var clone_args = std.ArrayList([]const u8).init(builder.allocator);
defer clone_args.deinit();
try clone_args.append("git");
try clone_args.append("clone");
if (recursive) {
try clone_args.append("--recurse-submodules");
try clone_args.append("-j8");
}
try clone_args.append(try builder.allocator.dupe(u8, repo));
const clone = builder.addSystemCommand(clone_args.items);
clone.cwd = try builder.allocator.dupe(u8, dir);
var checkout_args = std.ArrayList([]const u8).init(builder.allocator);
defer checkout_args.deinit();
try checkout_args.append("git");
try checkout_args.append("checkout");
if (recursive) {
try checkout_args.append("--recurse-submodules");
}
try checkout_args.append(try builder.allocator.dupe(u8, commit));
try checkout_args.append(".");
const checkout = builder.addSystemCommand(checkout_args.items);
checkout.cwd = try builder.allocator.dupe(u8, repo_path);
checkout.step.dependOn(&clone.step);
git_clone.step.dependOn(&checkout.step);
return git_clone;
}
}; | build.zig |
const std = @import("../std.zig");
const CpuFeature = std.Target.Cpu.Feature;
const CpuModel = std.Target.Cpu.Model;
pub const Feature = enum {
@"32bit",
@"8msecext",
a76,
aclass,
acquire_release,
aes,
avoid_movs_shop,
avoid_partial_cpsr,
bf16,
cde,
cdecp0,
cdecp1,
cdecp2,
cdecp3,
cdecp4,
cdecp5,
cdecp6,
cdecp7,
cheap_predicable_cpsr,
crc,
crypto,
d32,
db,
dfb,
disable_postra_scheduler,
dont_widen_vmovs,
dotprod,
dsp,
execute_only,
expand_fp_mlx,
exynos,
fp16,
fp16fml,
fp64,
fp_armv8,
fp_armv8d16,
fp_armv8d16sp,
fp_armv8sp,
fpao,
fpregs,
fpregs16,
fpregs64,
fullfp16,
fuse_aes,
fuse_literals,
has_v4t,
has_v5t,
has_v5te,
has_v6,
has_v6k,
has_v6m,
has_v6t2,
has_v7,
has_v7clrex,
has_v8_1a,
has_v8_1m_main,
has_v8_2a,
has_v8_3a,
has_v8_4a,
has_v8_5a,
has_v8_6a,
has_v8,
has_v8m,
has_v8m_main,
hwdiv,
hwdiv_arm,
i8mm,
iwmmxt,
iwmmxt2,
lob,
long_calls,
loop_align,
m3,
mclass,
mp,
muxed_units,
mve,
mve_fp,
mve1beat,
mve2beat,
mve4beat,
nacl_trap,
neon,
neon_fpmovs,
neonfp,
no_branch_predictor,
no_movt,
no_neg_immediates,
noarm,
nonpipelined_vfp,
perfmon,
prefer_ishst,
prefer_vmovsr,
prof_unpr,
r4,
ras,
rclass,
read_tp_hard,
reserve_r9,
ret_addr_stack,
sb,
sha2,
slow_fp_brcc,
slow_load_D_subreg,
slow_odd_reg,
slow_vdup32,
slow_vgetlni32,
slowfpvfmx,
slowfpvmlx,
soft_float,
splat_vfp_neon,
strict_align,
swift,
thumb2,
thumb_mode,
trustzone,
use_misched,
v2,
v2a,
v3,
v3m,
v4,
v4t,
v5t,
v5te,
v5tej,
v6,
v6j,
v6k,
v6kz,
v6m,
v6sm,
v6t2,
v7a,
v7em,
v7k,
v7m,
v7r,
v7s,
v7ve,
v8a,
v8m,
v8m_main,
v8r,
v8_1a,
v8_1m_main,
v8_2a,
v8_3a,
v8_4a,
v8_5a,
v8_6a,
vfp2,
vfp2sp,
vfp3,
vfp3d16,
vfp3d16sp,
vfp3sp,
vfp4,
vfp4d16,
vfp4d16sp,
vfp4sp,
virtualization,
vldn_align,
vmlx_forwarding,
vmlx_hazards,
wide_stride_vfp,
xscale,
zcz,
};
pub usingnamespace CpuFeature.feature_set_fns(Feature);
pub const all_features = blk: {
@setEvalBranchQuota(10000);
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= CpuFeature.Set.needed_bit_count);
var result: [len]CpuFeature = undefined;
result[@enumToInt(Feature.@"32bit")] = .{
.llvm_name = "32bit",
.description = "Prefer 32-bit Thumb instrs",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.@"8msecext")] = .{
.llvm_name = "8msecext",
.description = "Enable support for ARMv8-M Security Extensions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.a76)] = .{
.llvm_name = "a76",
.description = "Cortex-A76 ARM processors",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.aclass)] = .{
.llvm_name = "aclass",
.description = "Is application profile ('A' series)",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.acquire_release)] = .{
.llvm_name = "acquire-release",
.description = "Has v8 acquire/release (lda/ldaex etc) instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.aes)] = .{
.llvm_name = "aes",
.description = "Enable AES support",
.dependencies = featureSet(&[_]Feature{
.neon,
}),
};
result[@enumToInt(Feature.avoid_movs_shop)] = .{
.llvm_name = "avoid-movs-shop",
.description = "Avoid movs instructions with shifter operand",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.avoid_partial_cpsr)] = .{
.llvm_name = "avoid-partial-cpsr",
.description = "Avoid CPSR partial update for OOO execution",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.bf16)] = .{
.llvm_name = "bf16",
.description = "Enable support for BFloat16 instructions",
.dependencies = featureSet(&[_]Feature{
.neon,
}),
};
result[@enumToInt(Feature.cde)] = .{
.llvm_name = "cde",
.description = "Support CDE instructions",
.dependencies = featureSet(&[_]Feature{
.v8m_main,
}),
};
result[@enumToInt(Feature.cdecp0)] = .{
.llvm_name = "cdecp0",
.description = "Coprocessor 0 ISA is CDEv1",
.dependencies = featureSet(&[_]Feature{
.cde,
}),
};
result[@enumToInt(Feature.cdecp1)] = .{
.llvm_name = "cdecp1",
.description = "Coprocessor 1 ISA is CDEv1",
.dependencies = featureSet(&[_]Feature{
.cde,
}),
};
result[@enumToInt(Feature.cdecp2)] = .{
.llvm_name = "cdecp2",
.description = "Coprocessor 2 ISA is CDEv1",
.dependencies = featureSet(&[_]Feature{
.cde,
}),
};
result[@enumToInt(Feature.cdecp3)] = .{
.llvm_name = "cdecp3",
.description = "Coprocessor 3 ISA is CDEv1",
.dependencies = featureSet(&[_]Feature{
.cde,
}),
};
result[@enumToInt(Feature.cdecp4)] = .{
.llvm_name = "cdecp4",
.description = "Coprocessor 4 ISA is CDEv1",
.dependencies = featureSet(&[_]Feature{
.cde,
}),
};
result[@enumToInt(Feature.cdecp5)] = .{
.llvm_name = "cdecp5",
.description = "Coprocessor 5 ISA is CDEv1",
.dependencies = featureSet(&[_]Feature{
.cde,
}),
};
result[@enumToInt(Feature.cdecp6)] = .{
.llvm_name = "cdecp6",
.description = "Coprocessor 6 ISA is CDEv1",
.dependencies = featureSet(&[_]Feature{
.cde,
}),
};
result[@enumToInt(Feature.cdecp7)] = .{
.llvm_name = "cdecp7",
.description = "Coprocessor 7 ISA is CDEv1",
.dependencies = featureSet(&[_]Feature{
.cde,
}),
};
result[@enumToInt(Feature.cheap_predicable_cpsr)] = .{
.llvm_name = "cheap-predicable-cpsr",
.description = "Disable +1 predication cost for instructions updating CPSR",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.crc)] = .{
.llvm_name = "crc",
.description = "Enable support for CRC instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.crypto)] = .{
.llvm_name = "crypto",
.description = "Enable support for Cryptography extensions",
.dependencies = featureSet(&[_]Feature{
.aes,
.neon,
.sha2,
}),
};
result[@enumToInt(Feature.d32)] = .{
.llvm_name = "d32",
.description = "Extend FP to 32 double registers",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.db)] = .{
.llvm_name = "db",
.description = "Has data barrier (dmb/dsb) instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dfb)] = .{
.llvm_name = "dfb",
.description = "Has full data barrier (dfb) instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.disable_postra_scheduler)] = .{
.llvm_name = "disable-postra-scheduler",
.description = "Don't schedule again after register allocation",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dont_widen_vmovs)] = .{
.llvm_name = "dont-widen-vmovs",
.description = "Don't widen VMOVS to VMOVD",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dotprod)] = .{
.llvm_name = "dotprod",
.description = "Enable support for dot product instructions",
.dependencies = featureSet(&[_]Feature{
.neon,
}),
};
result[@enumToInt(Feature.dsp)] = .{
.llvm_name = "dsp",
.description = "Supports DSP instructions in ARM and/or Thumb2",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.execute_only)] = .{
.llvm_name = "execute-only",
.description = "Enable the generation of execute only code.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.expand_fp_mlx)] = .{
.llvm_name = "expand-fp-mlx",
.description = "Expand VFP/NEON MLA/MLS instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.exynos)] = .{
.llvm_name = "exynos",
.description = "Samsung Exynos processors",
.dependencies = featureSet(&[_]Feature{
.crc,
.crypto,
.expand_fp_mlx,
.fuse_aes,
.fuse_literals,
.hwdiv,
.hwdiv_arm,
.prof_unpr,
.ret_addr_stack,
.slow_fp_brcc,
.slow_vdup32,
.slow_vgetlni32,
.slowfpvfmx,
.slowfpvmlx,
.splat_vfp_neon,
.wide_stride_vfp,
.zcz,
}),
};
result[@enumToInt(Feature.fp16)] = .{
.llvm_name = "fp16",
.description = "Enable half-precision floating point",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fp16fml)] = .{
.llvm_name = "fp16fml",
.description = "Enable full half-precision floating point fml instructions",
.dependencies = featureSet(&[_]Feature{
.fullfp16,
}),
};
result[@enumToInt(Feature.fp64)] = .{
.llvm_name = "fp64",
.description = "Floating point unit supports double precision",
.dependencies = featureSet(&[_]Feature{
.fpregs64,
}),
};
result[@enumToInt(Feature.fp_armv8)] = .{
.llvm_name = "fp-armv8",
.description = "Enable ARMv8 FP",
.dependencies = featureSet(&[_]Feature{
.fp_armv8d16,
.fp_armv8sp,
.vfp4,
}),
};
result[@enumToInt(Feature.fp_armv8d16)] = .{
.llvm_name = "fp-armv8d16",
.description = "Enable ARMv8 FP with only 16 d-registers",
.dependencies = featureSet(&[_]Feature{
.fp_armv8d16sp,
.fp64,
.vfp4d16,
}),
};
result[@enumToInt(Feature.fp_armv8d16sp)] = .{
.llvm_name = "fp-armv8d16sp",
.description = "Enable ARMv8 FP with only 16 d-registers and no double precision",
.dependencies = featureSet(&[_]Feature{
.vfp4d16sp,
}),
};
result[@enumToInt(Feature.fp_armv8sp)] = .{
.llvm_name = "fp-armv8sp",
.description = "Enable ARMv8 FP with no double precision",
.dependencies = featureSet(&[_]Feature{
.d32,
.fp_armv8d16sp,
.vfp4sp,
}),
};
result[@enumToInt(Feature.fpao)] = .{
.llvm_name = "fpao",
.description = "Enable fast computation of positive address offsets",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fpregs)] = .{
.llvm_name = "fpregs",
.description = "Enable FP registers",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fpregs16)] = .{
.llvm_name = "fpregs16",
.description = "Enable 16-bit FP registers",
.dependencies = featureSet(&[_]Feature{
.fpregs,
}),
};
result[@enumToInt(Feature.fpregs64)] = .{
.llvm_name = "fpregs64",
.description = "Enable 64-bit FP registers",
.dependencies = featureSet(&[_]Feature{
.fpregs,
}),
};
result[@enumToInt(Feature.fullfp16)] = .{
.llvm_name = "fullfp16",
.description = "Enable full half-precision floating point",
.dependencies = featureSet(&[_]Feature{
.fp_armv8d16sp,
.fpregs16,
}),
};
result[@enumToInt(Feature.fuse_aes)] = .{
.llvm_name = "fuse-aes",
.description = "CPU fuses AES crypto operations",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fuse_literals)] = .{
.llvm_name = "fuse-literals",
.description = "CPU fuses literal generation operations",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.has_v4t)] = .{
.llvm_name = "v4t",
.description = "Support ARM v4T instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.has_v5t)] = .{
.llvm_name = "v5t",
.description = "Support ARM v5T instructions",
.dependencies = featureSet(&[_]Feature{
.has_v4t,
}),
};
result[@enumToInt(Feature.has_v5te)] = .{
.llvm_name = "v5te",
.description = "Support ARM v5TE, v5TEj, and v5TExp instructions",
.dependencies = featureSet(&[_]Feature{
.has_v5t,
}),
};
result[@enumToInt(Feature.has_v6)] = .{
.llvm_name = "v6",
.description = "Support ARM v6 instructions",
.dependencies = featureSet(&[_]Feature{
.has_v5te,
}),
};
result[@enumToInt(Feature.has_v6k)] = .{
.llvm_name = "v6k",
.description = "Support ARM v6k instructions",
.dependencies = featureSet(&[_]Feature{
.has_v6,
}),
};
result[@enumToInt(Feature.has_v6m)] = .{
.llvm_name = "v6m",
.description = "Support ARM v6M instructions",
.dependencies = featureSet(&[_]Feature{
.has_v6,
}),
};
result[@enumToInt(Feature.has_v6t2)] = .{
.llvm_name = "v6t2",
.description = "Support ARM v6t2 instructions",
.dependencies = featureSet(&[_]Feature{
.thumb2,
.has_v6k,
.has_v8m,
}),
};
result[@enumToInt(Feature.has_v7)] = .{
.llvm_name = "v7",
.description = "Support ARM v7 instructions",
.dependencies = featureSet(&[_]Feature{
.perfmon,
.has_v6t2,
.has_v7clrex,
}),
};
result[@enumToInt(Feature.has_v7clrex)] = .{
.llvm_name = "v7clrex",
.description = "Has v7 clrex instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.has_v8)] = .{
.llvm_name = "v8",
.description = "Support ARM v8 instructions",
.dependencies = featureSet(&[_]Feature{
.acquire_release,
.has_v7,
}),
};
result[@enumToInt(Feature.has_v8_1a)] = .{
.llvm_name = "v8.1a",
.description = "Support ARM v8.1a instructions",
.dependencies = featureSet(&[_]Feature{
.has_v8,
}),
};
result[@enumToInt(Feature.has_v8_1m_main)] = .{
.llvm_name = "v8.1m.main",
.description = "Support ARM v8-1M Mainline instructions",
.dependencies = featureSet(&[_]Feature{
.has_v8m_main,
}),
};
result[@enumToInt(Feature.has_v8_2a)] = .{
.llvm_name = "v8.2a",
.description = "Support ARM v8.2a instructions",
.dependencies = featureSet(&[_]Feature{
.has_v8_1a,
}),
};
result[@enumToInt(Feature.has_v8_3a)] = .{
.llvm_name = "v8.3a",
.description = "Support ARM v8.3a instructions",
.dependencies = featureSet(&[_]Feature{
.has_v8_2a,
}),
};
result[@enumToInt(Feature.has_v8_4a)] = .{
.llvm_name = "v8.4a",
.description = "Support ARM v8.4a instructions",
.dependencies = featureSet(&[_]Feature{
.dotprod,
.has_v8_3a,
}),
};
result[@enumToInt(Feature.has_v8_5a)] = .{
.llvm_name = "v8.5a",
.description = "Support ARM v8.5a instructions",
.dependencies = featureSet(&[_]Feature{
.sb,
.has_v8_4a,
}),
};
result[@enumToInt(Feature.has_v8_6a)] = .{
.llvm_name = "v8.6a",
.description = "Support ARM v8.6a instructions",
.dependencies = featureSet(&[_]Feature{
.bf16,
.i8mm,
.has_v8_5a,
}),
};
result[@enumToInt(Feature.has_v8m)] = .{
.llvm_name = "v8m",
.description = "Support ARM v8M Baseline instructions",
.dependencies = featureSet(&[_]Feature{
.has_v6m,
}),
};
result[@enumToInt(Feature.has_v8m_main)] = .{
.llvm_name = "v8m.main",
.description = "Support ARM v8M Mainline instructions",
.dependencies = featureSet(&[_]Feature{
.has_v7,
}),
};
result[@enumToInt(Feature.hwdiv)] = .{
.llvm_name = "hwdiv",
.description = "Enable divide instructions in Thumb",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hwdiv_arm)] = .{
.llvm_name = "hwdiv-arm",
.description = "Enable divide instructions in ARM mode",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.i8mm)] = .{
.llvm_name = "i8mm",
.description = "Enable Matrix Multiply Int8 Extension",
.dependencies = featureSet(&[_]Feature{
.neon,
}),
};
result[@enumToInt(Feature.iwmmxt)] = .{
.llvm_name = "iwmmxt",
.description = "ARMv5te architecture",
.dependencies = featureSet(&[_]Feature{
.has_v5te,
}),
};
result[@enumToInt(Feature.iwmmxt2)] = .{
.llvm_name = "iwmmxt2",
.description = "ARMv5te architecture",
.dependencies = featureSet(&[_]Feature{
.has_v5te,
}),
};
result[@enumToInt(Feature.lob)] = .{
.llvm_name = "lob",
.description = "Enable Low Overhead Branch extensions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.long_calls)] = .{
.llvm_name = "long-calls",
.description = "Generate calls via indirect call instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.loop_align)] = .{
.llvm_name = "loop-align",
.description = "Prefer 32-bit alignment for loops",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.m3)] = .{
.llvm_name = "m3",
.description = "Cortex-M3 ARM processors",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mclass)] = .{
.llvm_name = "mclass",
.description = "Is microcontroller profile ('M' series)",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mp)] = .{
.llvm_name = "mp",
.description = "Supports Multiprocessing extension",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.muxed_units)] = .{
.llvm_name = "muxed-units",
.description = "Has muxed AGU and NEON/FPU",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mve)] = .{
.llvm_name = "mve",
.description = "Support M-Class Vector Extension with integer ops",
.dependencies = featureSet(&[_]Feature{
.dsp,
.fpregs16,
.fpregs64,
.has_v8_1m_main,
}),
};
result[@enumToInt(Feature.mve_fp)] = .{
.llvm_name = "mve.fp",
.description = "Support M-Class Vector Extension with integer and floating ops",
.dependencies = featureSet(&[_]Feature{
.fp_armv8d16sp,
.fullfp16,
.mve,
}),
};
result[@enumToInt(Feature.mve1beat)] = .{
.llvm_name = "mve1beat",
.description = "Model MVE instructions as a 1 beat per tick architecture",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mve2beat)] = .{
.llvm_name = "mve2beat",
.description = "Model MVE instructions as a 2 beats per tick architecture",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mve4beat)] = .{
.llvm_name = "mve4beat",
.description = "Model MVE instructions as a 4 beats per tick architecture",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.nacl_trap)] = .{
.llvm_name = "nacl-trap",
.description = "NaCl trap",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.neon)] = .{
.llvm_name = "neon",
.description = "Enable NEON instructions",
.dependencies = featureSet(&[_]Feature{
.vfp3,
}),
};
result[@enumToInt(Feature.neon_fpmovs)] = .{
.llvm_name = "neon-fpmovs",
.description = "Convert VMOVSR, VMOVRS, VMOVS to NEON",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.neonfp)] = .{
.llvm_name = "neonfp",
.description = "Use NEON for single precision FP",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.no_branch_predictor)] = .{
.llvm_name = "no-branch-predictor",
.description = "Has no branch predictor",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.no_movt)] = .{
.llvm_name = "no-movt",
.description = "Don't use movt/movw pairs for 32-bit imms",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.no_neg_immediates)] = .{
.llvm_name = "no-neg-immediates",
.description = "Convert immediates and instructions to their negated or complemented equivalent when the immediate does not fit in the encoding.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.noarm)] = .{
.llvm_name = "noarm",
.description = "Does not support ARM mode execution",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.nonpipelined_vfp)] = .{
.llvm_name = "nonpipelined-vfp",
.description = "VFP instructions are not pipelined",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.perfmon)] = .{
.llvm_name = "perfmon",
.description = "Enable support for Performance Monitor extensions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.prefer_ishst)] = .{
.llvm_name = "prefer-ishst",
.description = "Prefer ISHST barriers",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.prefer_vmovsr)] = .{
.llvm_name = "prefer-vmovsr",
.description = "Prefer VMOVSR",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.prof_unpr)] = .{
.llvm_name = "prof-unpr",
.description = "Is profitable to unpredicate",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.r4)] = .{
.llvm_name = "r4",
.description = "Cortex-R4 ARM processors",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ras)] = .{
.llvm_name = "ras",
.description = "Enable Reliability, Availability and Serviceability extensions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.rclass)] = .{
.llvm_name = "rclass",
.description = "Is realtime profile ('R' series)",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.read_tp_hard)] = .{
.llvm_name = "read-tp-hard",
.description = "Reading thread pointer from register",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.reserve_r9)] = .{
.llvm_name = "reserve-r9",
.description = "Reserve R9, making it unavailable as GPR",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ret_addr_stack)] = .{
.llvm_name = "ret-addr-stack",
.description = "Has return address stack",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sb)] = .{
.llvm_name = "sb",
.description = "Enable v8.5a Speculation Barrier",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sha2)] = .{
.llvm_name = "sha2",
.description = "Enable SHA1 and SHA256 support",
.dependencies = featureSet(&[_]Feature{
.neon,
}),
};
result[@enumToInt(Feature.slow_fp_brcc)] = .{
.llvm_name = "slow-fp-brcc",
.description = "FP compare + branch is slow",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.slow_load_D_subreg)] = .{
.llvm_name = "slow-load-D-subreg",
.description = "Loading into D subregs is slow",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.slow_odd_reg)] = .{
.llvm_name = "slow-odd-reg",
.description = "VLDM/VSTM starting with an odd register is slow",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.slow_vdup32)] = .{
.llvm_name = "slow-vdup32",
.description = "Has slow VDUP32 - prefer VMOV",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.slow_vgetlni32)] = .{
.llvm_name = "slow-vgetlni32",
.description = "Has slow VGETLNi32 - prefer VMOV",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.slowfpvfmx)] = .{
.llvm_name = "slowfpvfmx",
.description = "Disable VFP / NEON FMA instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.slowfpvmlx)] = .{
.llvm_name = "slowfpvmlx",
.description = "Disable VFP / NEON MAC instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.soft_float)] = .{
.llvm_name = "soft-float",
.description = "Use software floating point features.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.splat_vfp_neon)] = .{
.llvm_name = "splat-vfp-neon",
.description = "Splat register from VFP to NEON",
.dependencies = featureSet(&[_]Feature{
.dont_widen_vmovs,
}),
};
result[@enumToInt(Feature.strict_align)] = .{
.llvm_name = "strict-align",
.description = "Disallow all unaligned memory access",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.swift)] = .{
.llvm_name = "swift",
.description = "Swift ARM processors",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.thumb2)] = .{
.llvm_name = "thumb2",
.description = "Enable Thumb2 instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.thumb_mode)] = .{
.llvm_name = "thumb-mode",
.description = "Thumb mode",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.trustzone)] = .{
.llvm_name = "trustzone",
.description = "Enable support for TrustZone security extensions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.use_misched)] = .{
.llvm_name = "use-misched",
.description = "Use the MachineScheduler",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.v2)] = .{
.llvm_name = "armv2",
.description = "ARMv2 architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
}),
};
result[@enumToInt(Feature.v2a)] = .{
.llvm_name = "armv2a",
.description = "ARMv2a architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
}),
};
result[@enumToInt(Feature.v3)] = .{
.llvm_name = "armv3",
.description = "ARMv3 architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
}),
};
result[@enumToInt(Feature.v3m)] = .{
.llvm_name = "armv3m",
.description = "ARMv3m architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
}),
};
result[@enumToInt(Feature.v4)] = .{
.llvm_name = "armv4",
.description = "ARMv4 architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
}),
};
result[@enumToInt(Feature.v4t)] = .{
.llvm_name = "armv4t",
.description = "ARMv4t architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
.has_v4t,
}),
};
result[@enumToInt(Feature.v5t)] = .{
.llvm_name = "armv5t",
.description = "ARMv5t architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
.has_v5t,
}),
};
result[@enumToInt(Feature.v5te)] = .{
.llvm_name = "armv5te",
.description = "ARMv5te architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
.has_v5te,
}),
};
result[@enumToInt(Feature.v5tej)] = .{
.llvm_name = "armv5tej",
.description = "ARMv5tej architecture",
.dependencies = featureSet(&[_]Feature{
.strict_align,
.has_v5te,
}),
};
result[@enumToInt(Feature.v6)] = .{
.llvm_name = "armv6",
.description = "ARMv6 architecture",
.dependencies = featureSet(&[_]Feature{
.dsp,
.has_v6,
}),
};
result[@enumToInt(Feature.v6m)] = .{
.llvm_name = "armv6-m",
.description = "ARMv6m architecture",
.dependencies = featureSet(&[_]Feature{
.db,
.mclass,
.noarm,
.strict_align,
.thumb_mode,
.has_v6m,
}),
};
result[@enumToInt(Feature.v6j)] = .{
.llvm_name = "armv6j",
.description = "ARMv7a architecture",
.dependencies = featureSet(&[_]Feature{
.v6,
}),
};
result[@enumToInt(Feature.v6k)] = .{
.llvm_name = "armv6k",
.description = "ARMv6k architecture",
.dependencies = featureSet(&[_]Feature{
.has_v6k,
}),
};
result[@enumToInt(Feature.v6kz)] = .{
.llvm_name = "armv6kz",
.description = "ARMv6kz architecture",
.dependencies = featureSet(&[_]Feature{
.trustzone,
.has_v6k,
}),
};
result[@enumToInt(Feature.v6sm)] = .{
.llvm_name = "armv6s-m",
.description = "ARMv6sm architecture",
.dependencies = featureSet(&[_]Feature{
.db,
.mclass,
.noarm,
.strict_align,
.thumb_mode,
.has_v6m,
}),
};
result[@enumToInt(Feature.v6t2)] = .{
.llvm_name = "armv6t2",
.description = "ARMv6t2 architecture",
.dependencies = featureSet(&[_]Feature{
.dsp,
.has_v6t2,
}),
};
result[@enumToInt(Feature.v7a)] = .{
.llvm_name = "armv7-a",
.description = "ARMv7a architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.db,
.dsp,
.neon,
.has_v7,
}),
};
result[@enumToInt(Feature.v7m)] = .{
.llvm_name = "armv7-m",
.description = "ARMv7m architecture",
.dependencies = featureSet(&[_]Feature{
.db,
.hwdiv,
.mclass,
.noarm,
.thumb_mode,
.thumb2,
.has_v7,
}),
};
result[@enumToInt(Feature.v7r)] = .{
.llvm_name = "armv7-r",
.description = "ARMv7r architecture",
.dependencies = featureSet(&[_]Feature{
.db,
.dsp,
.hwdiv,
.rclass,
.has_v7,
}),
};
result[@enumToInt(Feature.v7em)] = .{
.llvm_name = "armv7e-m",
.description = "ARMv7em architecture",
.dependencies = featureSet(&[_]Feature{
.db,
.dsp,
.hwdiv,
.mclass,
.noarm,
.thumb_mode,
.thumb2,
.has_v7,
}),
};
result[@enumToInt(Feature.v7k)] = .{
.llvm_name = "armv7k",
.description = "ARMv7a architecture",
.dependencies = featureSet(&[_]Feature{
.v7a,
}),
};
result[@enumToInt(Feature.v7s)] = .{
.llvm_name = "armv7s",
.description = "ARMv7a architecture",
.dependencies = featureSet(&[_]Feature{
.v7a,
}),
};
result[@enumToInt(Feature.v7ve)] = .{
.llvm_name = "armv7ve",
.description = "ARMv7ve architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.db,
.dsp,
.mp,
.neon,
.trustzone,
.has_v7,
.virtualization,
}),
};
result[@enumToInt(Feature.v8a)] = .{
.llvm_name = "armv8-a",
.description = "ARMv8a architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.crc,
.crypto,
.db,
.dsp,
.fp_armv8,
.mp,
.neon,
.trustzone,
.has_v8,
.virtualization,
}),
};
result[@enumToInt(Feature.v8m)] = .{
.llvm_name = "armv8-m.base",
.description = "ARMv8mBaseline architecture",
.dependencies = featureSet(&[_]Feature{
.@"8msecext",
.acquire_release,
.db,
.hwdiv,
.mclass,
.noarm,
.strict_align,
.thumb_mode,
.has_v7clrex,
.has_v8m,
}),
};
result[@enumToInt(Feature.v8m_main)] = .{
.llvm_name = "armv8-m.main",
.description = "ARMv8mMainline architecture",
.dependencies = featureSet(&[_]Feature{
.@"8msecext",
.acquire_release,
.db,
.hwdiv,
.mclass,
.noarm,
.thumb_mode,
.has_v8m_main,
}),
};
result[@enumToInt(Feature.v8r)] = .{
.llvm_name = "armv8-r",
.description = "ARMv8r architecture",
.dependencies = featureSet(&[_]Feature{
.crc,
.db,
.dfb,
.dsp,
.fp_armv8,
.mp,
.neon,
.rclass,
.has_v8,
.virtualization,
}),
};
result[@enumToInt(Feature.v8_1a)] = .{
.llvm_name = "armv8.1-a",
.description = "ARMv81a architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.crc,
.crypto,
.db,
.dsp,
.fp_armv8,
.mp,
.neon,
.trustzone,
.has_v8_1a,
.virtualization,
}),
};
result[@enumToInt(Feature.v8_1m_main)] = .{
.llvm_name = "armv8.1-m.main",
.description = "ARMv81mMainline architecture",
.dependencies = featureSet(&[_]Feature{
.@"8msecext",
.acquire_release,
.db,
.hwdiv,
.lob,
.mclass,
.noarm,
.ras,
.thumb_mode,
.has_v8_1m_main,
}),
};
result[@enumToInt(Feature.v8_2a)] = .{
.llvm_name = "armv8.2-a",
.description = "ARMv82a architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.crc,
.crypto,
.db,
.dsp,
.fp_armv8,
.mp,
.neon,
.ras,
.trustzone,
.has_v8_2a,
.virtualization,
}),
};
result[@enumToInt(Feature.v8_3a)] = .{
.llvm_name = "armv8.3-a",
.description = "ARMv83a architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.crc,
.crypto,
.db,
.dsp,
.fp_armv8,
.mp,
.neon,
.ras,
.trustzone,
.has_v8_3a,
.virtualization,
}),
};
result[@enumToInt(Feature.v8_4a)] = .{
.llvm_name = "armv8.4-a",
.description = "ARMv84a architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.crc,
.crypto,
.db,
.dotprod,
.dsp,
.fp_armv8,
.mp,
.neon,
.ras,
.trustzone,
.has_v8_4a,
.virtualization,
}),
};
result[@enumToInt(Feature.v8_5a)] = .{
.llvm_name = "armv8.5-a",
.description = "ARMv85a architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.crc,
.crypto,
.db,
.dotprod,
.dsp,
.fp_armv8,
.mp,
.neon,
.ras,
.trustzone,
.has_v8_5a,
.virtualization,
}),
};
result[@enumToInt(Feature.v8_6a)] = .{
.llvm_name = "armv8.6-a",
.description = "ARMv86a architecture",
.dependencies = featureSet(&[_]Feature{
.aclass,
.crc,
.crypto,
.db,
.dotprod,
.dsp,
.fp_armv8,
.mp,
.neon,
.ras,
.trustzone,
.has_v8_6a,
.virtualization,
}),
};
result[@enumToInt(Feature.vfp2)] = .{
.llvm_name = "vfp2",
.description = "Enable VFP2 instructions",
.dependencies = featureSet(&[_]Feature{
.fp64,
.vfp2sp,
}),
};
result[@enumToInt(Feature.vfp2sp)] = .{
.llvm_name = "vfp2sp",
.description = "Enable VFP2 instructions with no double precision",
.dependencies = featureSet(&[_]Feature{
.fpregs,
}),
};
result[@enumToInt(Feature.vfp3)] = .{
.llvm_name = "vfp3",
.description = "Enable VFP3 instructions",
.dependencies = featureSet(&[_]Feature{
.vfp3d16,
.vfp3sp,
}),
};
result[@enumToInt(Feature.vfp3d16)] = .{
.llvm_name = "vfp3d16",
.description = "Enable VFP3 instructions with only 16 d-registers",
.dependencies = featureSet(&[_]Feature{
.fp64,
.vfp2,
.vfp3d16sp,
}),
};
result[@enumToInt(Feature.vfp3d16sp)] = .{
.llvm_name = "vfp3d16sp",
.description = "Enable VFP3 instructions with only 16 d-registers and no double precision",
.dependencies = featureSet(&[_]Feature{
.vfp2sp,
}),
};
result[@enumToInt(Feature.vfp3sp)] = .{
.llvm_name = "vfp3sp",
.description = "Enable VFP3 instructions with no double precision",
.dependencies = featureSet(&[_]Feature{
.d32,
.vfp3d16sp,
}),
};
result[@enumToInt(Feature.vfp4)] = .{
.llvm_name = "vfp4",
.description = "Enable VFP4 instructions",
.dependencies = featureSet(&[_]Feature{
.fp16,
.vfp3,
.vfp4d16,
.vfp4sp,
}),
};
result[@enumToInt(Feature.vfp4d16)] = .{
.llvm_name = "vfp4d16",
.description = "Enable VFP4 instructions with only 16 d-registers",
.dependencies = featureSet(&[_]Feature{
.fp16,
.fp64,
.vfp3d16,
.vfp4d16sp,
}),
};
result[@enumToInt(Feature.vfp4d16sp)] = .{
.llvm_name = "vfp4d16sp",
.description = "Enable VFP4 instructions with only 16 d-registers and no double precision",
.dependencies = featureSet(&[_]Feature{
.fp16,
.vfp3d16sp,
}),
};
result[@enumToInt(Feature.vfp4sp)] = .{
.llvm_name = "vfp4sp",
.description = "Enable VFP4 instructions with no double precision",
.dependencies = featureSet(&[_]Feature{
.d32,
.fp16,
.vfp3sp,
.vfp4d16sp,
}),
};
result[@enumToInt(Feature.virtualization)] = .{
.llvm_name = "virtualization",
.description = "Supports Virtualization extension",
.dependencies = featureSet(&[_]Feature{
.hwdiv,
.hwdiv_arm,
}),
};
result[@enumToInt(Feature.vldn_align)] = .{
.llvm_name = "vldn-align",
.description = "Check for VLDn unaligned access",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vmlx_forwarding)] = .{
.llvm_name = "vmlx-forwarding",
.description = "Has multiplier accumulator forwarding",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vmlx_hazards)] = .{
.llvm_name = "vmlx-hazards",
.description = "Has VMLx hazards",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.wide_stride_vfp)] = .{
.llvm_name = "wide-stride-vfp",
.description = "Use a wide stride when allocating VFP registers",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.xscale)] = .{
.llvm_name = "xscale",
.description = "ARMv5te architecture",
.dependencies = featureSet(&[_]Feature{
.has_v5te,
}),
};
result[@enumToInt(Feature.zcz)] = .{
.llvm_name = "zcz",
.description = "Has zero-cycle zeroing instructions",
.dependencies = featureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
}
break :blk result;
};
pub const cpu = struct {
pub const arm1020e = CpuModel{
.name = "arm1020e",
.llvm_name = "arm1020e",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const arm1020t = CpuModel{
.name = "arm1020t",
.llvm_name = "arm1020t",
.features = featureSet(&[_]Feature{
.v5t,
}),
};
pub const arm1022e = CpuModel{
.name = "arm1022e",
.llvm_name = "arm1022e",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const arm10e = CpuModel{
.name = "arm10e",
.llvm_name = "arm10e",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const arm10tdmi = CpuModel{
.name = "arm10tdmi",
.llvm_name = "arm10tdmi",
.features = featureSet(&[_]Feature{
.v5t,
}),
};
pub const arm1136j_s = CpuModel{
.name = "arm1136j_s",
.llvm_name = "arm1136j-s",
.features = featureSet(&[_]Feature{
.v6,
}),
};
pub const arm1136jf_s = CpuModel{
.name = "arm1136jf_s",
.llvm_name = "arm1136jf-s",
.features = featureSet(&[_]Feature{
.v6,
.slowfpvmlx,
.vfp2,
}),
};
pub const arm1156t2_s = CpuModel{
.name = "arm1156t2_s",
.llvm_name = "arm1156t2-s",
.features = featureSet(&[_]Feature{
.v6t2,
}),
};
pub const arm1156t2f_s = CpuModel{
.name = "arm1156t2f_s",
.llvm_name = "arm1156t2f-s",
.features = featureSet(&[_]Feature{
.v6t2,
.slowfpvmlx,
.vfp2,
}),
};
pub const arm1176j_s = CpuModel{
.name = "arm1176j_s",
.llvm_name = "arm1176j-s",
.features = featureSet(&[_]Feature{
.v6kz,
}),
};
pub const arm1176jz_s = CpuModel{
.name = "arm1176jz_s",
.llvm_name = "arm1176jz-s",
.features = featureSet(&[_]Feature{
.v6kz,
}),
};
pub const arm1176jzf_s = CpuModel{
.name = "arm1176jzf_s",
.llvm_name = "arm1176jzf-s",
.features = featureSet(&[_]Feature{
.v6kz,
.slowfpvmlx,
.vfp2,
}),
};
pub const arm710t = CpuModel{
.name = "arm710t",
.llvm_name = "arm710t",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm720t = CpuModel{
.name = "arm720t",
.llvm_name = "arm720t",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm7tdmi = CpuModel{
.name = "arm7tdmi",
.llvm_name = "arm7tdmi",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm7tdmi_s = CpuModel{
.name = "arm7tdmi_s",
.llvm_name = "arm7tdmi-s",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm8 = CpuModel{
.name = "arm8",
.llvm_name = "arm8",
.features = featureSet(&[_]Feature{
.v4,
}),
};
pub const arm810 = CpuModel{
.name = "arm810",
.llvm_name = "arm810",
.features = featureSet(&[_]Feature{
.v4,
}),
};
pub const arm9 = CpuModel{
.name = "arm9",
.llvm_name = "arm9",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm920 = CpuModel{
.name = "arm920",
.llvm_name = "arm920",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm920t = CpuModel{
.name = "arm920t",
.llvm_name = "arm920t",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm922t = CpuModel{
.name = "arm922t",
.llvm_name = "arm922t",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm926ej_s = CpuModel{
.name = "arm926ej_s",
.llvm_name = "arm926ej-s",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const arm940t = CpuModel{
.name = "arm940t",
.llvm_name = "arm940t",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const arm946e_s = CpuModel{
.name = "arm946e_s",
.llvm_name = "arm946e-s",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const arm966e_s = CpuModel{
.name = "arm966e_s",
.llvm_name = "arm966e-s",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const arm968e_s = CpuModel{
.name = "arm968e_s",
.llvm_name = "arm968e-s",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const arm9e = CpuModel{
.name = "arm9e",
.llvm_name = "arm9e",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const arm9tdmi = CpuModel{
.name = "arm9tdmi",
.llvm_name = "arm9tdmi",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const baseline = CpuModel{
.name = "baseline",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{
.v7a,
}),
};
pub const cortex_a12 = CpuModel{
.name = "cortex_a12",
.llvm_name = "cortex-a12",
.features = featureSet(&[_]Feature{
.v7a,
.avoid_partial_cpsr,
.mp,
.ret_addr_stack,
.trustzone,
.vfp4,
.virtualization,
.vmlx_forwarding,
}),
};
pub const cortex_a15 = CpuModel{
.name = "cortex_a15",
.llvm_name = "cortex-a15",
.features = featureSet(&[_]Feature{
.v7a,
.avoid_partial_cpsr,
.dont_widen_vmovs,
.mp,
.muxed_units,
.ret_addr_stack,
.splat_vfp_neon,
.trustzone,
.vfp4,
.virtualization,
.vldn_align,
}),
};
pub const cortex_a17 = CpuModel{
.name = "cortex_a17",
.llvm_name = "cortex-a17",
.features = featureSet(&[_]Feature{
.v7a,
.avoid_partial_cpsr,
.mp,
.ret_addr_stack,
.trustzone,
.vfp4,
.virtualization,
.vmlx_forwarding,
}),
};
pub const cortex_a32 = CpuModel{
.name = "cortex_a32",
.llvm_name = "cortex-a32",
.features = featureSet(&[_]Feature{
.crc,
.crypto,
.hwdiv,
.hwdiv_arm,
.v8a,
}),
};
pub const cortex_a35 = CpuModel{
.name = "cortex_a35",
.llvm_name = "cortex-a35",
.features = featureSet(&[_]Feature{
.crc,
.crypto,
.hwdiv,
.hwdiv_arm,
.v8a,
}),
};
pub const cortex_a5 = CpuModel{
.name = "cortex_a5",
.llvm_name = "cortex-a5",
.features = featureSet(&[_]Feature{
.v7a,
.mp,
.ret_addr_stack,
.slow_fp_brcc,
.slowfpvfmx,
.slowfpvmlx,
.trustzone,
.vfp4,
.vmlx_forwarding,
}),
};
pub const cortex_a53 = CpuModel{
.name = "cortex_a53",
.llvm_name = "cortex-a53",
.features = featureSet(&[_]Feature{
.v8a,
.crc,
.crypto,
.fpao,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a55 = CpuModel{
.name = "cortex_a55",
.llvm_name = "cortex-a55",
.features = featureSet(&[_]Feature{
.v8_2a,
.dotprod,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a57 = CpuModel{
.name = "cortex_a57",
.llvm_name = "cortex-a57",
.features = featureSet(&[_]Feature{
.v8a,
.avoid_partial_cpsr,
.cheap_predicable_cpsr,
.crc,
.crypto,
.fpao,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a7 = CpuModel{
.name = "cortex_a7",
.llvm_name = "cortex-a7",
.features = featureSet(&[_]Feature{
.v7a,
.mp,
.ret_addr_stack,
.slow_fp_brcc,
.slowfpvfmx,
.slowfpvmlx,
.trustzone,
.vfp4,
.virtualization,
.vmlx_forwarding,
.vmlx_hazards,
}),
};
pub const cortex_a72 = CpuModel{
.name = "cortex_a72",
.llvm_name = "cortex-a72",
.features = featureSet(&[_]Feature{
.v8a,
.crc,
.crypto,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a73 = CpuModel{
.name = "cortex_a73",
.llvm_name = "cortex-a73",
.features = featureSet(&[_]Feature{
.v8a,
.crc,
.crypto,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a75 = CpuModel{
.name = "cortex_a75",
.llvm_name = "cortex-a75",
.features = featureSet(&[_]Feature{
.v8_2a,
.dotprod,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a76 = CpuModel{
.name = "cortex_a76",
.llvm_name = "cortex-a76",
.features = featureSet(&[_]Feature{
.a76,
.v8_2a,
.crc,
.crypto,
.dotprod,
.fullfp16,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a76ae = CpuModel{
.name = "cortex_a76ae",
.llvm_name = "cortex-a76ae",
.features = featureSet(&[_]Feature{
.a76,
.v8_2a,
.crc,
.crypto,
.dotprod,
.fullfp16,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a77 = CpuModel{
.name = "cortex_a77",
.llvm_name = "cortex-a77",
.features = featureSet(&[_]Feature{
.v8_2a,
.crc,
.crypto,
.dotprod,
.fullfp16,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a78 = CpuModel{
.name = "cortex_a78",
.llvm_name = "cortex-a78",
.features = featureSet(&[_]Feature{
.v8_2a,
.crc,
.crypto,
.dotprod,
.fullfp16,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cortex_a8 = CpuModel{
.name = "cortex_a8",
.llvm_name = "cortex-a8",
.features = featureSet(&[_]Feature{
.v7a,
.nonpipelined_vfp,
.ret_addr_stack,
.slow_fp_brcc,
.slowfpvfmx,
.slowfpvmlx,
.trustzone,
.vmlx_forwarding,
.vmlx_hazards,
}),
};
pub const cortex_a9 = CpuModel{
.name = "cortex_a9",
.llvm_name = "cortex-a9",
.features = featureSet(&[_]Feature{
.v7a,
.avoid_partial_cpsr,
.expand_fp_mlx,
.fp16,
.mp,
.muxed_units,
.neon_fpmovs,
.prefer_vmovsr,
.ret_addr_stack,
.trustzone,
.vldn_align,
.vmlx_forwarding,
.vmlx_hazards,
}),
};
pub const cortex_m0 = CpuModel{
.name = "cortex_m0",
.llvm_name = "cortex-m0",
.features = featureSet(&[_]Feature{
.v6m,
}),
};
pub const cortex_m0plus = CpuModel{
.name = "cortex_m0plus",
.llvm_name = "cortex-m0plus",
.features = featureSet(&[_]Feature{
.v6m,
}),
};
pub const cortex_m1 = CpuModel{
.name = "cortex_m1",
.llvm_name = "cortex-m1",
.features = featureSet(&[_]Feature{
.v6m,
}),
};
pub const cortex_m23 = CpuModel{
.name = "cortex_m23",
.llvm_name = "cortex-m23",
.features = featureSet(&[_]Feature{
.v8m,
.no_movt,
}),
};
pub const cortex_m3 = CpuModel{
.name = "cortex_m3",
.llvm_name = "cortex-m3",
.features = featureSet(&[_]Feature{
.v7m,
.loop_align,
.m3,
.no_branch_predictor,
.use_misched,
}),
};
pub const cortex_m33 = CpuModel{
.name = "cortex_m33",
.llvm_name = "cortex-m33",
.features = featureSet(&[_]Feature{
.v8m_main,
.dsp,
.fp_armv8d16sp,
.loop_align,
.no_branch_predictor,
.slowfpvfmx,
.slowfpvmlx,
.use_misched,
}),
};
pub const cortex_m35p = CpuModel{
.name = "cortex_m35p",
.llvm_name = "cortex-m35p",
.features = featureSet(&[_]Feature{
.v8m_main,
.dsp,
.fp_armv8d16sp,
.loop_align,
.no_branch_predictor,
.slowfpvfmx,
.slowfpvmlx,
.use_misched,
}),
};
pub const cortex_m4 = CpuModel{
.name = "cortex_m4",
.llvm_name = "cortex-m4",
.features = featureSet(&[_]Feature{
.v7em,
.loop_align,
.no_branch_predictor,
.slowfpvfmx,
.slowfpvmlx,
.use_misched,
.vfp4d16sp,
}),
};
pub const cortex_m55 = CpuModel{
.name = "cortex_m55",
.llvm_name = "cortex-m55",
.features = featureSet(&[_]Feature{
.v8_1m_main,
.dsp,
.fp_armv8d16,
.loop_align,
.mve_fp,
.no_branch_predictor,
.slowfpvmlx,
.use_misched,
}),
};
pub const cortex_m7 = CpuModel{
.name = "cortex_m7",
.llvm_name = "cortex-m7",
.features = featureSet(&[_]Feature{
.v7em,
.fp_armv8d16,
}),
};
pub const cortex_r4 = CpuModel{
.name = "cortex_r4",
.llvm_name = "cortex-r4",
.features = featureSet(&[_]Feature{
.v7r,
.avoid_partial_cpsr,
.r4,
.ret_addr_stack,
}),
};
pub const cortex_r4f = CpuModel{
.name = "cortex_r4f",
.llvm_name = "cortex-r4f",
.features = featureSet(&[_]Feature{
.v7r,
.avoid_partial_cpsr,
.r4,
.ret_addr_stack,
.slow_fp_brcc,
.slowfpvfmx,
.slowfpvmlx,
.vfp3d16,
}),
};
pub const cortex_r5 = CpuModel{
.name = "cortex_r5",
.llvm_name = "cortex-r5",
.features = featureSet(&[_]Feature{
.v7r,
.avoid_partial_cpsr,
.hwdiv_arm,
.ret_addr_stack,
.slow_fp_brcc,
.slowfpvfmx,
.slowfpvmlx,
.vfp3d16,
}),
};
pub const cortex_r52 = CpuModel{
.name = "cortex_r52",
.llvm_name = "cortex-r52",
.features = featureSet(&[_]Feature{
.v8r,
.fpao,
.use_misched,
}),
};
pub const cortex_r7 = CpuModel{
.name = "cortex_r7",
.llvm_name = "cortex-r7",
.features = featureSet(&[_]Feature{
.v7r,
.avoid_partial_cpsr,
.fp16,
.hwdiv_arm,
.mp,
.ret_addr_stack,
.slow_fp_brcc,
.slowfpvfmx,
.slowfpvmlx,
.vfp3d16,
}),
};
pub const cortex_r8 = CpuModel{
.name = "cortex_r8",
.llvm_name = "cortex-r8",
.features = featureSet(&[_]Feature{
.v7r,
.avoid_partial_cpsr,
.fp16,
.hwdiv_arm,
.mp,
.ret_addr_stack,
.slow_fp_brcc,
.slowfpvfmx,
.slowfpvmlx,
.vfp3d16,
}),
};
pub const cortex_x1 = CpuModel{
.name = "cortex_x1",
.llvm_name = "cortex-x1",
.features = featureSet(&[_]Feature{
.v8_2a,
.crc,
.crypto,
.dotprod,
.fullfp16,
.hwdiv,
.hwdiv_arm,
}),
};
pub const cyclone = CpuModel{
.name = "cyclone",
.llvm_name = "cyclone",
.features = featureSet(&[_]Feature{
.v8a,
.avoid_movs_shop,
.avoid_partial_cpsr,
.crypto,
.disable_postra_scheduler,
.hwdiv,
.hwdiv_arm,
.mp,
.neonfp,
.ret_addr_stack,
.slowfpvfmx,
.slowfpvmlx,
.swift,
.use_misched,
.vfp4,
.zcz,
}),
};
pub const ep9312 = CpuModel{
.name = "ep9312",
.llvm_name = "ep9312",
.features = featureSet(&[_]Feature{
.v4t,
}),
};
pub const exynos_m1 = CpuModel{
.name = "exynos_m1",
.llvm_name = null,
.features = featureSet(&[_]Feature{
.v8a,
.exynos,
}),
};
pub const exynos_m2 = CpuModel{
.name = "exynos_m2",
.llvm_name = null,
.features = featureSet(&[_]Feature{
.v8a,
.exynos,
}),
};
pub const exynos_m3 = CpuModel{
.name = "exynos_m3",
.llvm_name = "exynos-m3",
.features = featureSet(&[_]Feature{
.v8_2a,
.exynos,
}),
};
pub const exynos_m4 = CpuModel{
.name = "exynos_m4",
.llvm_name = "exynos-m4",
.features = featureSet(&[_]Feature{
.v8_2a,
.dotprod,
.exynos,
.fullfp16,
}),
};
pub const exynos_m5 = CpuModel{
.name = "exynos_m5",
.llvm_name = "exynos-m5",
.features = featureSet(&[_]Feature{
.dotprod,
.exynos,
.fullfp16,
.v8_2a,
}),
};
pub const generic = CpuModel{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{}),
};
pub const iwmmxt = CpuModel{
.name = "iwmmxt",
.llvm_name = "iwmmxt",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
pub const krait = CpuModel{
.name = "krait",
.llvm_name = "krait",
.features = featureSet(&[_]Feature{
.avoid_partial_cpsr,
.fp16,
.hwdiv,
.hwdiv_arm,
.muxed_units,
.ret_addr_stack,
.v7a,
.vfp4,
.vldn_align,
.vmlx_forwarding,
}),
};
pub const kryo = CpuModel{
.name = "kryo",
.llvm_name = "kryo",
.features = featureSet(&[_]Feature{
.crc,
.crypto,
.hwdiv,
.hwdiv_arm,
.v8a,
}),
};
pub const mpcore = CpuModel{
.name = "mpcore",
.llvm_name = "mpcore",
.features = featureSet(&[_]Feature{
.v6k,
.slowfpvmlx,
.vfp2,
}),
};
pub const mpcorenovfp = CpuModel{
.name = "mpcorenovfp",
.llvm_name = "mpcorenovfp",
.features = featureSet(&[_]Feature{
.v6k,
}),
};
pub const neoverse_n1 = CpuModel{
.name = "neoverse_n1",
.llvm_name = "neoverse-n1",
.features = featureSet(&[_]Feature{
.v8_2a,
.crc,
.crypto,
.dotprod,
.hwdiv,
.hwdiv_arm,
}),
};
pub const sc000 = CpuModel{
.name = "sc000",
.llvm_name = "sc000",
.features = featureSet(&[_]Feature{
.v6m,
}),
};
pub const sc300 = CpuModel{
.name = "sc300",
.llvm_name = "sc300",
.features = featureSet(&[_]Feature{
.v7m,
.m3,
.no_branch_predictor,
.use_misched,
}),
};
pub const strongarm = CpuModel{
.name = "strongarm",
.llvm_name = "strongarm",
.features = featureSet(&[_]Feature{
.v4,
}),
};
pub const strongarm110 = CpuModel{
.name = "strongarm110",
.llvm_name = "strongarm110",
.features = featureSet(&[_]Feature{
.v4,
}),
};
pub const strongarm1100 = CpuModel{
.name = "strongarm1100",
.llvm_name = "strongarm1100",
.features = featureSet(&[_]Feature{
.v4,
}),
};
pub const strongarm1110 = CpuModel{
.name = "strongarm1110",
.llvm_name = "strongarm1110",
.features = featureSet(&[_]Feature{
.v4,
}),
};
pub const swift = CpuModel{
.name = "swift",
.llvm_name = "swift",
.features = featureSet(&[_]Feature{
.v7a,
.avoid_movs_shop,
.avoid_partial_cpsr,
.disable_postra_scheduler,
.hwdiv,
.hwdiv_arm,
.mp,
.neonfp,
.prefer_ishst,
.prof_unpr,
.ret_addr_stack,
.slow_load_D_subreg,
.slow_odd_reg,
.slow_vdup32,
.slow_vgetlni32,
.slowfpvfmx,
.slowfpvmlx,
.swift,
.use_misched,
.vfp4,
.vmlx_hazards,
.wide_stride_vfp,
}),
};
pub const xscale = CpuModel{
.name = "xscale",
.llvm_name = "xscale",
.features = featureSet(&[_]Feature{
.v5te,
}),
};
}; | lib/std/target/arm.zig |
const std = @import("std");
const log = std.log.scoped(.gpa);
const math = std.math;
const assert = std.debug.assert;
const mem = std.mem;
const Allocator = std.mem.Allocator;
const page_size = std.mem.page_size;
const StackTrace = std.builtin.StackTrace;
/// Integer type for pointing to slots in a small allocation
const SlotIndex = std.meta.Int(.unsigned, math.log2(page_size) + 1);
const sys_can_stack_trace = switch (std.Target.current.cpu.arch) {
// Observed to go into an infinite loop.
// TODO: Make this work.
.mips,
.mipsel,
=> false,
// `@returnAddress()` in LLVM 10 gives
// "Non-Emscripten WebAssembly hasn't implemented __builtin_return_address".
.wasm32,
.wasm64,
=> std.Target.current.os.tag == .emscripten,
else => true,
};
const default_test_stack_trace_frames: usize = if (std.builtin.is_test) 8 else 4;
const default_sys_stack_trace_frames: usize = if (sys_can_stack_trace) default_test_stack_trace_frames else 0;
const default_stack_trace_frames: usize = switch (std.builtin.mode) {
.Debug => default_sys_stack_trace_frames,
else => 0,
};
pub const Config = struct {
/// Number of stack frames to capture.
stack_trace_frames: usize = default_stack_trace_frames,
/// If true, the allocator will have two fields:
/// * `total_requested_bytes` which tracks the total allocated bytes of memory requested.
/// * `requested_memory_limit` which causes allocations to return `error.OutOfMemory`
/// when the `total_requested_bytes` exceeds this limit.
/// If false, these fields will be `void`.
enable_memory_limit: bool = false,
/// Whether to enable safety checks.
safety: bool = std.debug.runtime_safety,
/// Whether the allocator may be used simultaneously from multiple threads.
thread_safe: bool = !std.builtin.single_threaded,
/// What type of mutex you'd like to use, for thread safety.
/// when specfied, the mutex type must have the same shape as `std.Thread.Mutex` and
/// `std.Thread.Mutex.Dummy`, and have no required fields. Specifying this field causes
/// the `thread_safe` field to be ignored.
///
/// when null (default):
/// * the mutex type defaults to `std.Thread.Mutex` when thread_safe is enabled.
/// * the mutex type defaults to `std.Thread.Mutex.Dummy` otherwise.
MutexType: ?type = null,
/// This is a temporary debugging trick you can use to turn segfaults into more helpful
/// logged error messages with stack trace details. The downside is that every allocation
/// will be leaked, unless used with retain_metadata!
never_unmap: bool = false,
/// This is a temporary debugging aid that retains metadata about allocations indefinitely.
/// This allows a greater range of double frees to be reported. All metadata is freed when
/// deinit is called. When used with never_unmap, deliberately leaked memory is also freed
/// during deinit. Currently should be used with never_unmap to avoid segfaults.
/// TODO https://github.com/ziglang/zig/issues/4298 will allow use without never_unmap
retain_metadata: bool = false,
/// Enables emitting info messages with the size and address of every allocation.
verbose_log: bool = false,
};
pub fn GeneralPurposeAllocator(comptime config: Config) type {
return struct {
allocator: Allocator = Allocator{
.allocFn = alloc,
.resizeFn = resize,
},
backing_allocator: *Allocator = std.heap.page_allocator,
buckets: [small_bucket_count]?*BucketHeader = [1]?*BucketHeader{null} ** small_bucket_count,
large_allocations: LargeAllocTable = .{},
empty_buckets: if (config.retain_metadata) ?*BucketHeader else void =
if (config.retain_metadata) null else {},
total_requested_bytes: @TypeOf(total_requested_bytes_init) = total_requested_bytes_init,
requested_memory_limit: @TypeOf(requested_memory_limit_init) = requested_memory_limit_init,
mutex: @TypeOf(mutex_init) = mutex_init,
const Self = @This();
const total_requested_bytes_init = if (config.enable_memory_limit) @as(usize, 0) else {};
const requested_memory_limit_init = if (config.enable_memory_limit) @as(usize, math.maxInt(usize)) else {};
const mutex_init = if (config.MutexType) |T|
T{}
else if (config.thread_safe)
std.Thread.Mutex{}
else
std.Thread.Mutex.Dummy{};
const stack_n = config.stack_trace_frames;
const one_trace_size = @sizeOf(usize) * stack_n;
const traces_per_slot = 2;
pub const Error = mem.Allocator.Error;
const small_bucket_count = math.log2(page_size);
const largest_bucket_object_size = 1 << (small_bucket_count - 1);
const LargeAlloc = struct {
bytes: []u8,
stack_addresses: [trace_n][stack_n]usize,
freed: if (config.retain_metadata) bool else void,
ptr_align: if (config.never_unmap and config.retain_metadata) u29 else void,
const trace_n = if (config.retain_metadata) traces_per_slot else 1;
fn dumpStackTrace(self: *LargeAlloc, trace_kind: TraceKind) void {
std.debug.dumpStackTrace(self.getStackTrace(trace_kind));
}
fn getStackTrace(self: *LargeAlloc, trace_kind: TraceKind) std.builtin.StackTrace {
assert(@enumToInt(trace_kind) < trace_n);
const stack_addresses = &self.stack_addresses[@enumToInt(trace_kind)];
var len: usize = 0;
while (len < stack_n and stack_addresses[len] != 0) {
len += 1;
}
return .{
.instruction_addresses = stack_addresses,
.index = len,
};
}
fn captureStackTrace(self: *LargeAlloc, ret_addr: usize, trace_kind: TraceKind) void {
assert(@enumToInt(trace_kind) < trace_n);
const stack_addresses = &self.stack_addresses[@enumToInt(trace_kind)];
collectStackTrace(ret_addr, stack_addresses);
}
};
const LargeAllocTable = std.AutoHashMapUnmanaged(usize, LargeAlloc);
// Bucket: In memory, in order:
// * BucketHeader
// * bucket_used_bits: [N]u8, // 1 bit for every slot; 1 byte for every 8 slots
// * stack_trace_addresses: [N]usize, // traces_per_slot for every allocation
const BucketHeader = struct {
prev: *BucketHeader,
next: *BucketHeader,
page: [*]align(page_size) u8,
alloc_cursor: SlotIndex,
used_count: SlotIndex,
fn usedBits(bucket: *BucketHeader, index: usize) *u8 {
return @intToPtr(*u8, @ptrToInt(bucket) + @sizeOf(BucketHeader) + index);
}
fn stackTracePtr(
bucket: *BucketHeader,
size_class: usize,
slot_index: SlotIndex,
trace_kind: TraceKind,
) *[stack_n]usize {
const start_ptr = @ptrCast([*]u8, bucket) + bucketStackFramesStart(size_class);
const addr = start_ptr + one_trace_size * traces_per_slot * slot_index +
@enumToInt(trace_kind) * @as(usize, one_trace_size);
return @ptrCast(*[stack_n]usize, @alignCast(@alignOf(usize), addr));
}
fn captureStackTrace(
bucket: *BucketHeader,
ret_addr: usize,
size_class: usize,
slot_index: SlotIndex,
trace_kind: TraceKind,
) void {
// Initialize them to 0. When determining the count we must look
// for non zero addresses.
const stack_addresses = bucket.stackTracePtr(size_class, slot_index, trace_kind);
collectStackTrace(ret_addr, stack_addresses);
}
};
fn bucketStackTrace(
bucket: *BucketHeader,
size_class: usize,
slot_index: SlotIndex,
trace_kind: TraceKind,
) StackTrace {
const stack_addresses = bucket.stackTracePtr(size_class, slot_index, trace_kind);
var len: usize = 0;
while (len < stack_n and stack_addresses[len] != 0) {
len += 1;
}
return StackTrace{
.instruction_addresses = stack_addresses,
.index = len,
};
}
fn bucketStackFramesStart(size_class: usize) usize {
return mem.alignForward(
@sizeOf(BucketHeader) + usedBitsCount(size_class),
@alignOf(usize),
);
}
fn bucketSize(size_class: usize) usize {
const slot_count = @divExact(page_size, size_class);
return bucketStackFramesStart(size_class) + one_trace_size * traces_per_slot * slot_count;
}
fn usedBitsCount(size_class: usize) usize {
const slot_count = @divExact(page_size, size_class);
if (slot_count < 8) return 1;
return @divExact(slot_count, 8);
}
fn detectLeaksInBucket(
bucket: *BucketHeader,
size_class: usize,
used_bits_count: usize,
) bool {
var leaks = false;
var used_bits_byte: usize = 0;
while (used_bits_byte < used_bits_count) : (used_bits_byte += 1) {
const used_byte = bucket.usedBits(used_bits_byte).*;
if (used_byte != 0) {
var bit_index: u3 = 0;
while (true) : (bit_index += 1) {
const is_used = @truncate(u1, used_byte >> bit_index) != 0;
if (is_used) {
const slot_index = @intCast(SlotIndex, used_bits_byte * 8 + bit_index);
const stack_trace = bucketStackTrace(bucket, size_class, slot_index, .alloc);
const addr = bucket.page + slot_index * size_class;
log.err("memory address 0x{x} leaked: {s}", .{
@ptrToInt(addr), stack_trace,
});
leaks = true;
}
if (bit_index == math.maxInt(u3))
break;
}
}
}
return leaks;
}
/// Emits log messages for leaks and then returns whether there were any leaks.
pub fn detectLeaks(self: *Self) bool {
var leaks = false;
for (self.buckets) |optional_bucket, bucket_i| {
const first_bucket = optional_bucket orelse continue;
const size_class = @as(usize, 1) << @intCast(math.Log2Int(usize), bucket_i);
const used_bits_count = usedBitsCount(size_class);
var bucket = first_bucket;
while (true) {
leaks = detectLeaksInBucket(bucket, size_class, used_bits_count) or leaks;
bucket = bucket.next;
if (bucket == first_bucket)
break;
}
}
var it = self.large_allocations.valueIterator();
while (it.next()) |large_alloc| {
if (config.retain_metadata and large_alloc.freed) continue;
log.err("memory address 0x{x} leaked: {s}", .{
@ptrToInt(large_alloc.bytes.ptr), large_alloc.getStackTrace(.alloc),
});
leaks = true;
}
return leaks;
}
fn freeBucket(self: *Self, bucket: *BucketHeader, size_class: usize) void {
const bucket_size = bucketSize(size_class);
const bucket_slice = @ptrCast([*]align(@alignOf(BucketHeader)) u8, bucket)[0..bucket_size];
self.backing_allocator.free(bucket_slice);
}
fn freeRetainedMetadata(self: *Self) void {
if (config.retain_metadata) {
if (config.never_unmap) {
// free large allocations that were intentionally leaked by never_unmap
var it = self.large_allocations.iterator();
while (it.next()) |large| {
if (large.value_ptr.freed) {
_ = self.backing_allocator.resizeFn(self.backing_allocator, large.value_ptr.bytes,
large.value_ptr.ptr_align, 0, 0, @returnAddress()) catch unreachable;
}
}
}
// free retained metadata for small allocations
if (self.empty_buckets) |first_bucket| {
var bucket = first_bucket;
while (true) {
const prev = bucket.prev;
if (config.never_unmap) {
// free page that was intentionally leaked by never_unmap
self.backing_allocator.free(bucket.page[0..page_size]);
}
// alloc_cursor was set to slot count when bucket added to empty_buckets
self.freeBucket(bucket, @divExact(page_size, bucket.alloc_cursor));
bucket = prev;
if (bucket == first_bucket)
break;
}
self.empty_buckets = null;
}
}
}
pub usingnamespace if (config.retain_metadata) struct {
pub fn flushRetainedMetadata(self: *Self) void {
self.freeRetainedMetadata();
// also remove entries from large_allocations
var it = self.large_allocations.iterator();
while (it.next()) |large| {
if (large.value_ptr.freed) {
_ = self.large_allocations.remove(@ptrToInt(large.value_ptr.bytes.ptr));
}
}
}
} else struct {};
pub fn deinit(self: *Self) bool {
const leaks = if (config.safety) self.detectLeaks() else false;
if (config.retain_metadata) {
self.freeRetainedMetadata();
}
self.large_allocations.deinit(self.backing_allocator);
self.* = undefined;
return leaks;
}
fn collectStackTrace(first_trace_addr: usize, addresses: *[stack_n]usize) void {
if (stack_n == 0) return;
mem.set(usize, addresses, 0);
var stack_trace = StackTrace{
.instruction_addresses = addresses,
.index = 0,
};
std.debug.captureStackTrace(first_trace_addr, &stack_trace);
}
fn reportDoubleFree(ret_addr: usize, alloc_stack_trace: StackTrace, free_stack_trace: StackTrace) void {
var addresses: [stack_n]usize = [1]usize{0} ** stack_n;
var second_free_stack_trace = StackTrace{
.instruction_addresses = &addresses,
.index = 0,
};
std.debug.captureStackTrace(ret_addr, &second_free_stack_trace);
log.err("Double free detected. Allocation: {s} First free: {s} Second free: {s}", .{
alloc_stack_trace, free_stack_trace, second_free_stack_trace,
});
}
fn allocSlot(self: *Self, size_class: usize, trace_addr: usize) Error![*]u8 {
const bucket_index = math.log2(size_class);
const first_bucket = self.buckets[bucket_index] orelse try self.createBucket(
size_class,
bucket_index,
);
var bucket = first_bucket;
const slot_count = @divExact(page_size, size_class);
while (bucket.alloc_cursor == slot_count) {
const prev_bucket = bucket;
bucket = prev_bucket.next;
if (bucket == first_bucket) {
// make a new one
bucket = try self.createBucket(size_class, bucket_index);
bucket.prev = prev_bucket;
bucket.next = prev_bucket.next;
prev_bucket.next = bucket;
bucket.next.prev = bucket;
}
}
// change the allocator's current bucket to be this one
self.buckets[bucket_index] = bucket;
const slot_index = bucket.alloc_cursor;
bucket.alloc_cursor += 1;
var used_bits_byte = bucket.usedBits(slot_index / 8);
const used_bit_index: u3 = @intCast(u3, slot_index % 8); // TODO cast should be unnecessary
used_bits_byte.* |= (@as(u8, 1) << used_bit_index);
bucket.used_count += 1;
bucket.captureStackTrace(trace_addr, size_class, slot_index, .alloc);
return bucket.page + slot_index * size_class;
}
fn searchBucket(
bucket_list: ?*BucketHeader,
addr: usize,
) ?*BucketHeader {
const first_bucket = bucket_list orelse return null;
var bucket = first_bucket;
while (true) {
const in_bucket_range = (addr >= @ptrToInt(bucket.page) and
addr < @ptrToInt(bucket.page) + page_size);
if (in_bucket_range) return bucket;
bucket = bucket.prev;
if (bucket == first_bucket) {
return null;
}
}
}
/// This function assumes the object is in the large object storage regardless
/// of the parameters.
fn resizeLarge(
self: *Self,
old_mem: []u8,
old_align: u29,
new_size: usize,
len_align: u29,
ret_addr: usize,
) Error!usize {
const entry = self.large_allocations.getEntry(@ptrToInt(old_mem.ptr)) orelse {
if (config.safety) {
@panic("Invalid free");
} else {
unreachable;
}
};
if (config.retain_metadata and entry.value_ptr.freed) {
if (config.safety) {
reportDoubleFree(ret_addr,
entry.value_ptr.getStackTrace(.alloc),
entry.value_ptr.getStackTrace(.free)
);
if (new_size == 0) {
// Recoverable. Restore self.total_requested_bytes if needed.
if (config.enable_memory_limit) {
self.total_requested_bytes += old_mem.len;
}
return @as(usize, 0);
}
@panic("Unrecoverable double free");
} else {
unreachable;
}
}
if (config.safety and old_mem.len != entry.value_ptr.bytes.len) {
var addresses: [stack_n]usize = [1]usize{0} ** stack_n;
var free_stack_trace = StackTrace{
.instruction_addresses = &addresses,
.index = 0,
};
std.debug.captureStackTrace(ret_addr, &free_stack_trace);
log.err("Allocation size {d} bytes does not match free size {d}. Allocation: {s} Free: {s}", .{
entry.value_ptr.bytes.len,
old_mem.len,
entry.value_ptr.getStackTrace(.alloc),
free_stack_trace,
});
}
const result_len = if (config.never_unmap and new_size == 0) 0 else
try self.backing_allocator.resizeFn(self.backing_allocator, old_mem, old_align, new_size, len_align, ret_addr);
if (result_len == 0) {
if (config.verbose_log) {
log.info("large free {d} bytes at {*}", .{ old_mem.len, old_mem.ptr });
}
if (!config.retain_metadata) {
assert(self.large_allocations.remove(@ptrToInt(old_mem.ptr)));
} else {
entry.value_ptr.freed = true;
entry.value_ptr.captureStackTrace(ret_addr, .free);
}
return 0;
}
if (config.verbose_log) {
log.info("large resize {d} bytes at {*} to {d}", .{
old_mem.len, old_mem.ptr, new_size,
});
}
entry.value_ptr.bytes = old_mem.ptr[0..result_len];
entry.value_ptr.captureStackTrace(ret_addr, .alloc);
return result_len;
}
pub fn setRequestedMemoryLimit(self: *Self, limit: usize) void {
self.requested_memory_limit = limit;
}
fn resize(
allocator: *Allocator,
old_mem: []u8,
old_align: u29,
new_size: usize,
len_align: u29,
ret_addr: usize,
) Error!usize {
const self = @fieldParentPtr(Self, "allocator", allocator);
const held = self.mutex.acquire();
defer held.release();
const prev_req_bytes = self.total_requested_bytes;
if (config.enable_memory_limit) {
const new_req_bytes = prev_req_bytes + new_size - old_mem.len;
if (new_req_bytes > prev_req_bytes and new_req_bytes > self.requested_memory_limit) {
return error.OutOfMemory;
}
self.total_requested_bytes = new_req_bytes;
}
errdefer if (config.enable_memory_limit) {
self.total_requested_bytes = prev_req_bytes;
};
assert(old_mem.len != 0);
const aligned_size = math.max(old_mem.len, old_align);
if (aligned_size > largest_bucket_object_size) {
return self.resizeLarge(old_mem, old_align, new_size, len_align, ret_addr);
}
const size_class_hint = math.ceilPowerOfTwoAssert(usize, aligned_size);
var bucket_index = math.log2(size_class_hint);
var size_class: usize = size_class_hint;
const bucket = while (bucket_index < small_bucket_count) : (bucket_index += 1) {
if (searchBucket(self.buckets[bucket_index], @ptrToInt(old_mem.ptr))) |bucket| {
// move bucket to head of list to optimize search for nearby allocations
self.buckets[bucket_index] = bucket;
break bucket;
}
size_class *= 2;
} else blk: {
if (config.retain_metadata) {
if (!self.large_allocations.contains(@ptrToInt(old_mem.ptr))) {
// object not in active buckets or a large allocation, so search empty buckets
if (searchBucket(self.empty_buckets, @ptrToInt(old_mem.ptr))) |bucket| {
// bucket is empty so is_used below will always be false and we exit there
break :blk bucket;
} else {
@panic("Invalid free");
}
}
}
return self.resizeLarge(old_mem, old_align, new_size, len_align, ret_addr);
};
const byte_offset = @ptrToInt(old_mem.ptr) - @ptrToInt(bucket.page);
const slot_index = @intCast(SlotIndex, byte_offset / size_class);
const used_byte_index = slot_index / 8;
const used_bit_index = @intCast(u3, slot_index % 8);
const used_byte = bucket.usedBits(used_byte_index);
const is_used = @truncate(u1, used_byte.* >> used_bit_index) != 0;
if (!is_used) {
if (config.safety) {
reportDoubleFree(ret_addr,
bucketStackTrace(bucket, size_class, slot_index, .alloc),
bucketStackTrace(bucket, size_class, slot_index, .free)
);
if (new_size == 0) {
// Recoverable. Restore self.total_requested_bytes if needed, as we
// don't return an error value so the errdefer above does not run.
if (config.enable_memory_limit) {
self.total_requested_bytes = prev_req_bytes;
}
return @as(usize, 0);
}
@panic("Unrecoverable double free");
} else {
unreachable;
}
}
if (new_size == 0) {
// Capture stack trace to be the "first free", in case a double free happens.
bucket.captureStackTrace(ret_addr, size_class, slot_index, .free);
used_byte.* &= ~(@as(u8, 1) << used_bit_index);
bucket.used_count -= 1;
if (bucket.used_count == 0) {
if (bucket.next == bucket) {
// it's the only bucket and therefore the current one
self.buckets[bucket_index] = null;
} else {
bucket.next.prev = bucket.prev;
bucket.prev.next = bucket.next;
self.buckets[bucket_index] = bucket.prev;
}
if (!config.never_unmap) {
self.backing_allocator.free(bucket.page[0..page_size]);
}
if (!config.retain_metadata) {
self.freeBucket(bucket, size_class);
} else {
// move alloc_cursor to end so we can tell size_class later
const slot_count = @divExact(page_size, size_class);
bucket.alloc_cursor = @truncate(SlotIndex, slot_count);
if (self.empty_buckets) |prev_bucket| {
// empty_buckets is ordered newest to oldest through prev so that if
// config.never_unmap is false and backing_allocator reuses freed memory
// then searchBuckets will always return the newer, relevant bucket
bucket.prev = prev_bucket;
bucket.next = prev_bucket.next;
prev_bucket.next = bucket;
bucket.next.prev = bucket;
} else {
bucket.prev = bucket;
bucket.next = bucket;
}
self.empty_buckets = bucket;
}
} else {
@memset(old_mem.ptr, undefined, old_mem.len);
}
if (config.verbose_log) {
log.info("small free {d} bytes at {*}", .{ old_mem.len, old_mem.ptr });
}
return @as(usize, 0);
}
const new_aligned_size = math.max(new_size, old_align);
const new_size_class = math.ceilPowerOfTwoAssert(usize, new_aligned_size);
if (new_size_class <= size_class) {
if (old_mem.len > new_size) {
@memset(old_mem.ptr + new_size, undefined, old_mem.len - new_size);
}
if (config.verbose_log) {
log.info("small resize {d} bytes at {*} to {d}", .{
old_mem.len, old_mem.ptr, new_size,
});
}
return new_size;
}
return error.OutOfMemory;
}
// Returns true if an allocation of `size` bytes is within the specified
// limits if enable_memory_limit is true
fn isAllocationAllowed(self: *Self, size: usize) bool {
if (config.enable_memory_limit) {
const new_req_bytes = self.total_requested_bytes + size;
if (new_req_bytes > self.requested_memory_limit)
return false;
self.total_requested_bytes = new_req_bytes;
}
return true;
}
fn alloc(allocator: *Allocator, len: usize, ptr_align: u29, len_align: u29, ret_addr: usize) Error![]u8 {
const self = @fieldParentPtr(Self, "allocator", allocator);
const held = self.mutex.acquire();
defer held.release();
const new_aligned_size = math.max(len, ptr_align);
if (new_aligned_size > largest_bucket_object_size) {
try self.large_allocations.ensureCapacity(
self.backing_allocator,
self.large_allocations.count() + 1,
);
const slice = try self.backing_allocator.allocFn(self.backing_allocator, len, ptr_align, len_align, ret_addr);
// The backing allocator may return a memory block bigger than
// `len`, use the effective size for bookkeeping purposes
if (!self.isAllocationAllowed(slice.len)) {
// Free the block so no memory is leaked
const new_len = try self.backing_allocator.resizeFn(self.backing_allocator, slice, ptr_align, 0, 0, ret_addr);
assert(new_len == 0);
return error.OutOfMemory;
}
const gop = self.large_allocations.getOrPutAssumeCapacity(@ptrToInt(slice.ptr));
if (config.retain_metadata and !config.never_unmap) {
// Backing allocator may be reusing memory that we're retaining metadata for
assert(!gop.found_existing or gop.value_ptr.freed);
} else {
assert(!gop.found_existing); // This would mean the kernel double-mapped pages.
}
gop.value_ptr.bytes = slice;
gop.value_ptr.captureStackTrace(ret_addr, .alloc);
if (config.retain_metadata) {
gop.value_ptr.freed = false;
if (config.never_unmap) {
gop.value_ptr.ptr_align = ptr_align;
}
}
if (config.verbose_log) {
log.info("large alloc {d} bytes at {*}", .{ slice.len, slice.ptr });
}
return slice;
}
if (!self.isAllocationAllowed(len)) {
return error.OutOfMemory;
}
const new_size_class = math.ceilPowerOfTwoAssert(usize, new_aligned_size);
const ptr = try self.allocSlot(new_size_class, ret_addr);
if (config.verbose_log) {
log.info("small alloc {d} bytes at {*}", .{ len, ptr });
}
return ptr[0..len];
}
fn createBucket(self: *Self, size_class: usize, bucket_index: usize) Error!*BucketHeader {
const page = try self.backing_allocator.allocAdvanced(u8, page_size, page_size, .exact);
errdefer self.backing_allocator.free(page);
const bucket_size = bucketSize(size_class);
const bucket_bytes = try self.backing_allocator.allocAdvanced(u8, @alignOf(BucketHeader), bucket_size, .exact);
const ptr = @ptrCast(*BucketHeader, bucket_bytes.ptr);
ptr.* = BucketHeader{
.prev = ptr,
.next = ptr,
.page = page.ptr,
.alloc_cursor = 0,
.used_count = 0,
};
self.buckets[bucket_index] = ptr;
// Set the used bits to all zeroes
@memset(@as(*[1]u8, ptr.usedBits(0)), 0, usedBitsCount(size_class));
return ptr;
}
};
}
const TraceKind = enum {
alloc,
free,
};
const test_config = Config{};
test "small allocations - free in same order" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var list = std.ArrayList(*u64).init(std.testing.allocator);
defer list.deinit();
var i: usize = 0;
while (i < 513) : (i += 1) {
const ptr = try allocator.create(u64);
try list.append(ptr);
}
for (list.items) |ptr| {
allocator.destroy(ptr);
}
}
test "small allocations - free in reverse order" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var list = std.ArrayList(*u64).init(std.testing.allocator);
defer list.deinit();
var i: usize = 0;
while (i < 513) : (i += 1) {
const ptr = try allocator.create(u64);
try list.append(ptr);
}
while (list.popOrNull()) |ptr| {
allocator.destroy(ptr);
}
}
test "large allocations" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
const ptr1 = try allocator.alloc(u64, 42768);
const ptr2 = try allocator.alloc(u64, 52768);
allocator.free(ptr1);
const ptr3 = try allocator.alloc(u64, 62768);
allocator.free(ptr3);
allocator.free(ptr2);
}
test "realloc" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var slice = try allocator.alignedAlloc(u8, @alignOf(u32), 1);
defer allocator.free(slice);
slice[0] = 0x12;
// This reallocation should keep its pointer address.
const old_slice = slice;
slice = try allocator.realloc(slice, 2);
try std.testing.expect(old_slice.ptr == slice.ptr);
try std.testing.expect(slice[0] == 0x12);
slice[1] = 0x34;
// This requires upgrading to a larger size class
slice = try allocator.realloc(slice, 17);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[1] == 0x34);
}
test "shrink" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var slice = try allocator.alloc(u8, 20);
defer allocator.free(slice);
mem.set(u8, slice, 0x11);
slice = allocator.shrink(slice, 17);
for (slice) |b| {
try std.testing.expect(b == 0x11);
}
slice = allocator.shrink(slice, 16);
for (slice) |b| {
try std.testing.expect(b == 0x11);
}
}
test "large object - grow" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var slice1 = try allocator.alloc(u8, page_size * 2 - 20);
defer allocator.free(slice1);
const old = slice1;
slice1 = try allocator.realloc(slice1, page_size * 2 - 10);
try std.testing.expect(slice1.ptr == old.ptr);
slice1 = try allocator.realloc(slice1, page_size * 2);
try std.testing.expect(slice1.ptr == old.ptr);
slice1 = try allocator.realloc(slice1, page_size * 2 + 1);
}
test "realloc small object to large object" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var slice = try allocator.alloc(u8, 70);
defer allocator.free(slice);
slice[0] = 0x12;
slice[60] = 0x34;
// This requires upgrading to a large object
const large_object_size = page_size * 2 + 50;
slice = try allocator.realloc(slice, large_object_size);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[60] == 0x34);
}
test "shrink large object to large object" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var slice = try allocator.alloc(u8, page_size * 2 + 50);
defer allocator.free(slice);
slice[0] = 0x12;
slice[60] = 0x34;
slice = try allocator.resize(slice, page_size * 2 + 1);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[60] == 0x34);
slice = allocator.shrink(slice, page_size * 2 + 1);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[60] == 0x34);
slice = try allocator.realloc(slice, page_size * 2);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[60] == 0x34);
}
test "shrink large object to large object with larger alignment" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var debug_buffer: [1000]u8 = undefined;
const debug_allocator = &std.heap.FixedBufferAllocator.init(&debug_buffer).allocator;
const alloc_size = page_size * 2 + 50;
var slice = try allocator.alignedAlloc(u8, 16, alloc_size);
defer allocator.free(slice);
const big_alignment: usize = switch (std.Target.current.os.tag) {
.windows => page_size * 32, // Windows aligns to 64K.
else => page_size * 2,
};
// This loop allocates until we find a page that is not aligned to the big
// alignment. Then we shrink the allocation after the loop, but increase the
// alignment to the higher one, that we know will force it to realloc.
var stuff_to_free = std.ArrayList([]align(16) u8).init(debug_allocator);
while (mem.isAligned(@ptrToInt(slice.ptr), big_alignment)) {
try stuff_to_free.append(slice);
slice = try allocator.alignedAlloc(u8, 16, alloc_size);
}
while (stuff_to_free.popOrNull()) |item| {
allocator.free(item);
}
slice[0] = 0x12;
slice[60] = 0x34;
slice = try allocator.reallocAdvanced(slice, big_alignment, alloc_size / 2, .exact);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[60] == 0x34);
}
test "realloc large object to small object" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var slice = try allocator.alloc(u8, page_size * 2 + 50);
defer allocator.free(slice);
slice[0] = 0x12;
slice[16] = 0x34;
slice = try allocator.realloc(slice, 19);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[16] == 0x34);
}
test "overrideable mutexes" {
var gpa = GeneralPurposeAllocator(.{ .MutexType = std.Thread.Mutex }){
.backing_allocator = std.testing.allocator,
.mutex = std.Thread.Mutex{},
};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
const ptr = try allocator.create(i32);
defer allocator.destroy(ptr);
}
test "non-page-allocator backing allocator" {
var gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = std.testing.allocator };
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
const ptr = try allocator.create(i32);
defer allocator.destroy(ptr);
}
test "realloc large object to larger alignment" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var debug_buffer: [1000]u8 = undefined;
const debug_allocator = &std.heap.FixedBufferAllocator.init(&debug_buffer).allocator;
var slice = try allocator.alignedAlloc(u8, 16, page_size * 2 + 50);
defer allocator.free(slice);
const big_alignment: usize = switch (std.Target.current.os.tag) {
.windows => page_size * 32, // Windows aligns to 64K.
else => page_size * 2,
};
// This loop allocates until we find a page that is not aligned to the big alignment.
var stuff_to_free = std.ArrayList([]align(16) u8).init(debug_allocator);
while (mem.isAligned(@ptrToInt(slice.ptr), big_alignment)) {
try stuff_to_free.append(slice);
slice = try allocator.alignedAlloc(u8, 16, page_size * 2 + 50);
}
while (stuff_to_free.popOrNull()) |item| {
allocator.free(item);
}
slice[0] = 0x12;
slice[16] = 0x34;
slice = try allocator.reallocAdvanced(slice, 32, page_size * 2 + 100, .exact);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[16] == 0x34);
slice = try allocator.reallocAdvanced(slice, 32, page_size * 2 + 25, .exact);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[16] == 0x34);
slice = try allocator.reallocAdvanced(slice, big_alignment, page_size * 2 + 100, .exact);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[16] == 0x34);
}
test "large object shrinks to small but allocation fails during shrink" {
var failing_allocator = std.testing.FailingAllocator.init(std.heap.page_allocator, 3);
var gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = &failing_allocator.allocator };
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
var slice = try allocator.alloc(u8, page_size * 2 + 50);
defer allocator.free(slice);
slice[0] = 0x12;
slice[3] = 0x34;
// Next allocation will fail in the backing allocator of the GeneralPurposeAllocator
slice = allocator.shrink(slice, 4);
try std.testing.expect(slice[0] == 0x12);
try std.testing.expect(slice[3] == 0x34);
}
test "objects of size 1024 and 2048" {
var gpa = GeneralPurposeAllocator(test_config){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
const slice = try allocator.alloc(u8, 1025);
const slice2 = try allocator.alloc(u8, 3000);
allocator.free(slice);
allocator.free(slice2);
}
test "setting a memory cap" {
var gpa = GeneralPurposeAllocator(.{ .enable_memory_limit = true }){};
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
gpa.setRequestedMemoryLimit(1010);
const small = try allocator.create(i32);
try std.testing.expect(gpa.total_requested_bytes == 4);
const big = try allocator.alloc(u8, 1000);
try std.testing.expect(gpa.total_requested_bytes == 1004);
try std.testing.expectError(error.OutOfMemory, allocator.create(u64));
allocator.destroy(small);
try std.testing.expect(gpa.total_requested_bytes == 1000);
allocator.free(big);
try std.testing.expect(gpa.total_requested_bytes == 0);
const exact = try allocator.alloc(u8, 1010);
try std.testing.expect(gpa.total_requested_bytes == 1010);
allocator.free(exact);
}
test "double frees" {
// use a GPA to back a GPA to check for leaks of the latter's metadata
var backing_gpa = GeneralPurposeAllocator(.{ .safety = true }){};
defer std.testing.expect(!backing_gpa.deinit()) catch @panic("leak");
const GPA = GeneralPurposeAllocator(.{ .safety = true, .never_unmap = true, .retain_metadata = true });
var gpa = GPA{ .backing_allocator = &backing_gpa.allocator };
defer std.testing.expect(!gpa.deinit()) catch @panic("leak");
const allocator = &gpa.allocator;
// detect a small allocation double free, even though bucket is emptied
const index: usize = 6;
const size_class: usize = @as(usize, 1) << 6;
const small = try allocator.alloc(u8, size_class);
try std.testing.expect(GPA.searchBucket(gpa.buckets[index], @ptrToInt(small.ptr)) != null);
allocator.free(small);
try std.testing.expect(GPA.searchBucket(gpa.buckets[index], @ptrToInt(small.ptr)) == null);
try std.testing.expect(GPA.searchBucket(gpa.empty_buckets, @ptrToInt(small.ptr)) != null);
// detect a large allocation double free
const large = try allocator.alloc(u8, 2 * page_size);
try std.testing.expect(gpa.large_allocations.contains(@ptrToInt(large.ptr)));
try std.testing.expectEqual(gpa.large_allocations.getEntry(@ptrToInt(large.ptr)).?.value_ptr.bytes, large);
allocator.free(large);
try std.testing.expect(gpa.large_allocations.contains(@ptrToInt(large.ptr)));
try std.testing.expect(gpa.large_allocations.getEntry(@ptrToInt(large.ptr)).?.value_ptr.freed);
const normal_small = try allocator.alloc(u8, size_class);
defer allocator.free(normal_small);
const normal_large = try allocator.alloc(u8, 2 * page_size);
defer allocator.free(normal_large);
// check that flushing retained metadata doesn't disturb live allocations
gpa.flushRetainedMetadata();
try std.testing.expect(gpa.empty_buckets == null);
try std.testing.expect(GPA.searchBucket(gpa.buckets[index], @ptrToInt(normal_small.ptr)) != null);
try std.testing.expect(gpa.large_allocations.contains(@ptrToInt(normal_large.ptr)));
try std.testing.expect(!gpa.large_allocations.contains(@ptrToInt(large.ptr)));
} | lib/std/heap/general_purpose_allocator.zig |
const Coff = @This();
const std = @import("std");
const log = std.log.scoped(.link);
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const fs = std.fs;
const allocPrint = std.fmt.allocPrint;
const mem = std.mem;
const trace = @import("../tracy.zig").trace;
const Module = @import("../Module.zig");
const Compilation = @import("../Compilation.zig");
const codegen = @import("../codegen.zig");
const link = @import("../link.zig");
const build_options = @import("build_options");
const Cache = @import("../Cache.zig");
const mingw = @import("../mingw.zig");
const llvm_backend = @import("../codegen/llvm.zig");
const allocation_padding = 4 / 3;
const minimum_text_block_size = 64 * allocation_padding;
const section_alignment = 4096;
const file_alignment = 512;
const default_image_base = 0x400_000;
const section_table_size = 2 * 40;
comptime {
assert(mem.isAligned(default_image_base, section_alignment));
}
pub const base_tag: link.File.Tag = .coff;
const msdos_stub = @embedFile("msdos-stub.bin");
/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
llvm_object: ?*llvm_backend.Object = null,
base: link.File,
ptr_width: PtrWidth,
error_flags: link.File.ErrorFlags = .{},
text_block_free_list: std.ArrayListUnmanaged(*TextBlock) = .{},
last_text_block: ?*TextBlock = null,
/// Section table file pointer.
section_table_offset: u32 = 0,
/// Section data file pointer.
section_data_offset: u32 = 0,
/// Optiona header file pointer.
optional_header_offset: u32 = 0,
/// Absolute virtual address of the offset table when the executable is loaded in memory.
offset_table_virtual_address: u32 = 0,
/// Current size of the offset table on disk, must be a multiple of `file_alignment`
offset_table_size: u32 = 0,
/// Contains absolute virtual addresses
offset_table: std.ArrayListUnmanaged(u64) = .{},
/// Free list of offset table indices
offset_table_free_list: std.ArrayListUnmanaged(u32) = .{},
/// Virtual address of the entry point procedure relative to image base.
entry_addr: ?u32 = null,
/// Absolute virtual address of the text section when the executable is loaded in memory.
text_section_virtual_address: u32 = 0,
/// Current size of the `.text` section on disk, must be a multiple of `file_alignment`
text_section_size: u32 = 0,
offset_table_size_dirty: bool = false,
text_section_size_dirty: bool = false,
/// This flag is set when the virtual size of the whole image file when loaded in memory has changed
/// and needs to be updated in the optional header.
size_of_image_dirty: bool = false,
pub const PtrWidth = enum { p32, p64 };
pub const TextBlock = struct {
/// Offset of the code relative to the start of the text section
text_offset: u32,
/// Used size of the text block
size: u32,
/// This field is undefined for symbols with size = 0.
offset_table_index: u32,
/// Points to the previous and next neighbors, based on the `text_offset`.
/// This can be used to find, for example, the capacity of this `TextBlock`.
prev: ?*TextBlock,
next: ?*TextBlock,
pub const empty = TextBlock{
.text_offset = 0,
.size = 0,
.offset_table_index = undefined,
.prev = null,
.next = null,
};
/// Returns how much room there is to grow in virtual address space.
fn capacity(self: TextBlock) u64 {
if (self.next) |next| {
return next.text_offset - self.text_offset;
}
// This is the last block, the capacity is only limited by the address space.
return std.math.maxInt(u32) - self.text_offset;
}
fn freeListEligible(self: TextBlock) bool {
// No need to keep a free list node for the last block.
const next = self.next orelse return false;
const cap = next.text_offset - self.text_offset;
const ideal_cap = self.size * allocation_padding;
if (cap <= ideal_cap) return false;
const surplus = cap - ideal_cap;
return surplus >= minimum_text_block_size;
}
/// Absolute virtual address of the text block when the file is loaded in memory.
fn getVAddr(self: TextBlock, coff: Coff) u32 {
return coff.text_section_virtual_address + self.text_offset;
}
};
pub const SrcFn = void;
pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Options) !*Coff {
assert(options.object_format == .coff);
if (build_options.have_llvm and options.use_llvm) {
const self = try createEmpty(allocator, options);
errdefer self.base.destroy();
self.llvm_object = try llvm_backend.Object.create(allocator, sub_path, options);
return self;
}
const file = try options.emit.?.directory.handle.createFile(sub_path, .{
.truncate = false,
.read = true,
.mode = link.determineMode(options),
});
errdefer file.close();
const self = try createEmpty(allocator, options);
errdefer self.base.destroy();
self.base.file = file;
// TODO Write object specific relocations, COFF symbol table, then enable object file output.
switch (options.output_mode) {
.Exe => {},
.Obj => return error.TODOImplementWritingObjFiles,
.Lib => return error.TODOImplementWritingLibFiles,
}
var coff_file_header_offset: u32 = 0;
if (options.output_mode == .Exe) {
// Write the MS-DOS stub and the PE signature
try self.base.file.?.pwriteAll(msdos_stub ++ "PE\x00\x00", 0);
coff_file_header_offset = msdos_stub.len + 4;
}
// COFF file header
const data_directory_count = 0;
var hdr_data: [112 + data_directory_count * 8 + section_table_size]u8 = undefined;
var index: usize = 0;
const machine = self.base.options.target.cpu.arch.toCoffMachine();
if (machine == .Unknown) {
return error.UnsupportedCOFFArchitecture;
}
mem.writeIntLittle(u16, hdr_data[0..2], @enumToInt(machine));
index += 2;
// Number of sections (we only use .got, .text)
mem.writeIntLittle(u16, hdr_data[index..][0..2], 2);
index += 2;
// TimeDateStamp (u32), PointerToSymbolTable (u32), NumberOfSymbols (u32)
mem.set(u8, hdr_data[index..][0..12], 0);
index += 12;
const optional_header_size = switch (options.output_mode) {
.Exe => data_directory_count * 8 + switch (self.ptr_width) {
.p32 => @as(u16, 96),
.p64 => 112,
},
else => 0,
};
const section_table_offset = coff_file_header_offset + 20 + optional_header_size;
const default_offset_table_size = file_alignment;
const default_size_of_code = 0;
self.section_data_offset = mem.alignForwardGeneric(u32, self.section_table_offset + section_table_size, file_alignment);
const section_data_relative_virtual_address = mem.alignForwardGeneric(u32, self.section_table_offset + section_table_size, section_alignment);
self.offset_table_virtual_address = default_image_base + section_data_relative_virtual_address;
self.offset_table_size = default_offset_table_size;
self.section_table_offset = section_table_offset;
self.text_section_virtual_address = default_image_base + section_data_relative_virtual_address + section_alignment;
self.text_section_size = default_size_of_code;
// Size of file when loaded in memory
const size_of_image = mem.alignForwardGeneric(u32, self.text_section_virtual_address - default_image_base + default_size_of_code, section_alignment);
mem.writeIntLittle(u16, hdr_data[index..][0..2], optional_header_size);
index += 2;
// Characteristics
var characteristics: u16 = std.coff.IMAGE_FILE_DEBUG_STRIPPED | std.coff.IMAGE_FILE_RELOCS_STRIPPED; // TODO Remove debug info stripped flag when necessary
if (options.output_mode == .Exe) {
characteristics |= std.coff.IMAGE_FILE_EXECUTABLE_IMAGE;
}
switch (self.ptr_width) {
.p32 => characteristics |= std.coff.IMAGE_FILE_32BIT_MACHINE,
.p64 => characteristics |= std.coff.IMAGE_FILE_LARGE_ADDRESS_AWARE,
}
mem.writeIntLittle(u16, hdr_data[index..][0..2], characteristics);
index += 2;
assert(index == 20);
try self.base.file.?.pwriteAll(hdr_data[0..index], coff_file_header_offset);
if (options.output_mode == .Exe) {
self.optional_header_offset = coff_file_header_offset + 20;
// Optional header
index = 0;
mem.writeIntLittle(u16, hdr_data[0..2], switch (self.ptr_width) {
.p32 => @as(u16, 0x10b),
.p64 => 0x20b,
});
index += 2;
// Linker version (u8 + u8)
mem.set(u8, hdr_data[index..][0..2], 0);
index += 2;
// SizeOfCode (UNUSED, u32), SizeOfInitializedData (u32), SizeOfUninitializedData (u32), AddressOfEntryPoint (u32), BaseOfCode (UNUSED, u32)
mem.set(u8, hdr_data[index..][0..20], 0);
index += 20;
if (self.ptr_width == .p32) {
// Base of data relative to the image base (UNUSED)
mem.set(u8, hdr_data[index..][0..4], 0);
index += 4;
// Image base address
mem.writeIntLittle(u32, hdr_data[index..][0..4], default_image_base);
index += 4;
} else {
// Image base address
mem.writeIntLittle(u64, hdr_data[index..][0..8], default_image_base);
index += 8;
}
// Section alignment
mem.writeIntLittle(u32, hdr_data[index..][0..4], section_alignment);
index += 4;
// File alignment
mem.writeIntLittle(u32, hdr_data[index..][0..4], file_alignment);
index += 4;
// Required OS version, 6.0 is vista
mem.writeIntLittle(u16, hdr_data[index..][0..2], 6);
index += 2;
mem.writeIntLittle(u16, hdr_data[index..][0..2], 0);
index += 2;
// Image version
mem.set(u8, hdr_data[index..][0..4], 0);
index += 4;
// Required subsystem version, same as OS version
mem.writeIntLittle(u16, hdr_data[index..][0..2], 6);
index += 2;
mem.writeIntLittle(u16, hdr_data[index..][0..2], 0);
index += 2;
// Reserved zeroes (u32)
mem.set(u8, hdr_data[index..][0..4], 0);
index += 4;
mem.writeIntLittle(u32, hdr_data[index..][0..4], size_of_image);
index += 4;
mem.writeIntLittle(u32, hdr_data[index..][0..4], self.section_data_offset);
index += 4;
// CheckSum (u32)
mem.set(u8, hdr_data[index..][0..4], 0);
index += 4;
// Subsystem, TODO: Let users specify the subsystem, always CUI for now
mem.writeIntLittle(u16, hdr_data[index..][0..2], 3);
index += 2;
// DLL characteristics
mem.writeIntLittle(u16, hdr_data[index..][0..2], 0x0);
index += 2;
switch (self.ptr_width) {
.p32 => {
// Size of stack reserve + commit
mem.writeIntLittle(u32, hdr_data[index..][0..4], 0x1_000_000);
index += 4;
mem.writeIntLittle(u32, hdr_data[index..][0..4], 0x1_000);
index += 4;
// Size of heap reserve + commit
mem.writeIntLittle(u32, hdr_data[index..][0..4], 0x100_000);
index += 4;
mem.writeIntLittle(u32, hdr_data[index..][0..4], 0x1_000);
index += 4;
},
.p64 => {
// Size of stack reserve + commit
mem.writeIntLittle(u64, hdr_data[index..][0..8], 0x1_000_000);
index += 8;
mem.writeIntLittle(u64, hdr_data[index..][0..8], 0x1_000);
index += 8;
// Size of heap reserve + commit
mem.writeIntLittle(u64, hdr_data[index..][0..8], 0x100_000);
index += 8;
mem.writeIntLittle(u64, hdr_data[index..][0..8], 0x1_000);
index += 8;
},
}
// Reserved zeroes
mem.set(u8, hdr_data[index..][0..4], 0);
index += 4;
// Number of data directories
mem.writeIntLittle(u32, hdr_data[index..][0..4], data_directory_count);
index += 4;
// Initialize data directories to zero
mem.set(u8, hdr_data[index..][0 .. data_directory_count * 8], 0);
index += data_directory_count * 8;
assert(index == optional_header_size);
}
// Write section table.
// First, the .got section
hdr_data[index..][0..8].* = ".got\x00\x00\x00\x00".*;
index += 8;
if (options.output_mode == .Exe) {
// Virtual size (u32)
mem.writeIntLittle(u32, hdr_data[index..][0..4], default_offset_table_size);
index += 4;
// Virtual address (u32)
mem.writeIntLittle(u32, hdr_data[index..][0..4], self.offset_table_virtual_address - default_image_base);
index += 4;
} else {
mem.set(u8, hdr_data[index..][0..8], 0);
index += 8;
}
// Size of raw data (u32)
mem.writeIntLittle(u32, hdr_data[index..][0..4], default_offset_table_size);
index += 4;
// File pointer to the start of the section
mem.writeIntLittle(u32, hdr_data[index..][0..4], self.section_data_offset);
index += 4;
// Pointer to relocations (u32), PointerToLinenumbers (u32), NumberOfRelocations (u16), NumberOfLinenumbers (u16)
mem.set(u8, hdr_data[index..][0..12], 0);
index += 12;
// Section flags
mem.writeIntLittle(u32, hdr_data[index..][0..4], std.coff.IMAGE_SCN_CNT_INITIALIZED_DATA | std.coff.IMAGE_SCN_MEM_READ);
index += 4;
// Then, the .text section
hdr_data[index..][0..8].* = ".text\x00\x00\x00".*;
index += 8;
if (options.output_mode == .Exe) {
// Virtual size (u32)
mem.writeIntLittle(u32, hdr_data[index..][0..4], default_size_of_code);
index += 4;
// Virtual address (u32)
mem.writeIntLittle(u32, hdr_data[index..][0..4], self.text_section_virtual_address - default_image_base);
index += 4;
} else {
mem.set(u8, hdr_data[index..][0..8], 0);
index += 8;
}
// Size of raw data (u32)
mem.writeIntLittle(u32, hdr_data[index..][0..4], default_size_of_code);
index += 4;
// File pointer to the start of the section
mem.writeIntLittle(u32, hdr_data[index..][0..4], self.section_data_offset + default_offset_table_size);
index += 4;
// Pointer to relocations (u32), PointerToLinenumbers (u32), NumberOfRelocations (u16), NumberOfLinenumbers (u16)
mem.set(u8, hdr_data[index..][0..12], 0);
index += 12;
// Section flags
mem.writeIntLittle(
u32,
hdr_data[index..][0..4],
std.coff.IMAGE_SCN_CNT_CODE | std.coff.IMAGE_SCN_MEM_EXECUTE | std.coff.IMAGE_SCN_MEM_READ | std.coff.IMAGE_SCN_MEM_WRITE,
);
index += 4;
assert(index == optional_header_size + section_table_size);
try self.base.file.?.pwriteAll(hdr_data[0..index], self.optional_header_offset);
try self.base.file.?.setEndPos(self.section_data_offset + default_offset_table_size + default_size_of_code);
return self;
}
pub fn createEmpty(gpa: *Allocator, options: link.Options) !*Coff {
const ptr_width: PtrWidth = switch (options.target.cpu.arch.ptrBitWidth()) {
0...32 => .p32,
33...64 => .p64,
else => return error.UnsupportedCOFFArchitecture,
};
const self = try gpa.create(Coff);
self.* = .{
.base = .{
.tag = .coff,
.options = options,
.allocator = gpa,
.file = null,
},
.ptr_width = ptr_width,
};
return self;
}
pub fn allocateDeclIndexes(self: *Coff, decl: *Module.Decl) !void {
if (self.llvm_object) |_| return;
try self.offset_table.ensureCapacity(self.base.allocator, self.offset_table.items.len + 1);
if (self.offset_table_free_list.popOrNull()) |i| {
decl.link.coff.offset_table_index = i;
} else {
decl.link.coff.offset_table_index = @intCast(u32, self.offset_table.items.len);
_ = self.offset_table.addOneAssumeCapacity();
const entry_size = self.base.options.target.cpu.arch.ptrBitWidth() / 8;
if (self.offset_table.items.len > self.offset_table_size / entry_size) {
self.offset_table_size_dirty = true;
}
}
self.offset_table.items[decl.link.coff.offset_table_index] = 0;
}
fn allocateTextBlock(self: *Coff, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
const new_block_min_capacity = new_block_size * allocation_padding;
// We use these to indicate our intention to update metadata, placing the new block,
// and possibly removing a free list node.
// It would be simpler to do it inside the for loop below, but that would cause a
// problem if an error was returned later in the function. So this action
// is actually carried out at the end of the function, when errors are no longer possible.
var block_placement: ?*TextBlock = null;
var free_list_removal: ?usize = null;
const vaddr = blk: {
var i: usize = 0;
while (i < self.text_block_free_list.items.len) {
const free_block = self.text_block_free_list.items[i];
const next_block_text_offset = free_block.text_offset + free_block.capacity();
const new_block_text_offset = mem.alignForwardGeneric(u64, free_block.getVAddr(self.*) + free_block.size, alignment) - self.text_section_virtual_address;
if (new_block_text_offset < next_block_text_offset and next_block_text_offset - new_block_text_offset >= new_block_min_capacity) {
block_placement = free_block;
const remaining_capacity = next_block_text_offset - new_block_text_offset - new_block_min_capacity;
if (remaining_capacity < minimum_text_block_size) {
free_list_removal = i;
}
break :blk new_block_text_offset + self.text_section_virtual_address;
} else {
if (!free_block.freeListEligible()) {
_ = self.text_block_free_list.swapRemove(i);
} else {
i += 1;
}
continue;
}
} else if (self.last_text_block) |last| {
const new_block_vaddr = mem.alignForwardGeneric(u64, last.getVAddr(self.*) + last.size, alignment);
block_placement = last;
break :blk new_block_vaddr;
} else {
break :blk self.text_section_virtual_address;
}
};
const expand_text_section = block_placement == null or block_placement.?.next == null;
if (expand_text_section) {
const needed_size = @intCast(u32, mem.alignForwardGeneric(u64, vaddr + new_block_size - self.text_section_virtual_address, file_alignment));
if (needed_size > self.text_section_size) {
const current_text_section_virtual_size = mem.alignForwardGeneric(u32, self.text_section_size, section_alignment);
const new_text_section_virtual_size = mem.alignForwardGeneric(u32, needed_size, section_alignment);
if (current_text_section_virtual_size != new_text_section_virtual_size) {
self.size_of_image_dirty = true;
// Write new virtual size
var buf: [4]u8 = undefined;
mem.writeIntLittle(u32, &buf, new_text_section_virtual_size);
try self.base.file.?.pwriteAll(&buf, self.section_table_offset + 40 + 8);
}
self.text_section_size = needed_size;
self.text_section_size_dirty = true;
}
self.last_text_block = text_block;
}
text_block.text_offset = @intCast(u32, vaddr - self.text_section_virtual_address);
text_block.size = @intCast(u32, new_block_size);
// This function can also reallocate a text block.
// In this case we need to "unplug" it from its previous location before
// plugging it in to its new location.
if (text_block.prev) |prev| {
prev.next = text_block.next;
}
if (text_block.next) |next| {
next.prev = text_block.prev;
}
if (block_placement) |big_block| {
text_block.prev = big_block;
text_block.next = big_block.next;
big_block.next = text_block;
} else {
text_block.prev = null;
text_block.next = null;
}
if (free_list_removal) |i| {
_ = self.text_block_free_list.swapRemove(i);
}
return vaddr;
}
fn growTextBlock(self: *Coff, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
const block_vaddr = text_block.getVAddr(self.*);
const align_ok = mem.alignBackwardGeneric(u64, block_vaddr, alignment) == block_vaddr;
const need_realloc = !align_ok or new_block_size > text_block.capacity();
if (!need_realloc) return @as(u64, block_vaddr);
return self.allocateTextBlock(text_block, new_block_size, alignment);
}
fn shrinkTextBlock(self: *Coff, text_block: *TextBlock, new_block_size: u64) void {
text_block.size = @intCast(u32, new_block_size);
if (text_block.capacity() - text_block.size >= minimum_text_block_size) {
self.text_block_free_list.append(self.base.allocator, text_block) catch {};
}
}
fn freeTextBlock(self: *Coff, text_block: *TextBlock) void {
var already_have_free_list_node = false;
{
var i: usize = 0;
// TODO turn text_block_free_list into a hash map
while (i < self.text_block_free_list.items.len) {
if (self.text_block_free_list.items[i] == text_block) {
_ = self.text_block_free_list.swapRemove(i);
continue;
}
if (self.text_block_free_list.items[i] == text_block.prev) {
already_have_free_list_node = true;
}
i += 1;
}
}
if (self.last_text_block == text_block) {
self.last_text_block = text_block.prev;
}
if (text_block.prev) |prev| {
prev.next = text_block.next;
if (!already_have_free_list_node and prev.freeListEligible()) {
// The free list is heuristics, it doesn't have to be perfect, so we can
// ignore the OOM here.
self.text_block_free_list.append(self.base.allocator, prev) catch {};
}
}
if (text_block.next) |next| {
next.prev = text_block.prev;
}
}
fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
const entry_size = self.base.options.target.cpu.arch.ptrBitWidth() / 8;
const endian = self.base.options.target.cpu.arch.endian();
const offset_table_start = self.section_data_offset;
if (self.offset_table_size_dirty) {
const current_raw_size = self.offset_table_size;
const new_raw_size = self.offset_table_size * 2;
log.debug("growing offset table from raw size {} to {}\n", .{ current_raw_size, new_raw_size });
// Move the text section to a new place in the executable
const current_text_section_start = self.section_data_offset + current_raw_size;
const new_text_section_start = self.section_data_offset + new_raw_size;
const amt = try self.base.file.?.copyRangeAll(current_text_section_start, self.base.file.?, new_text_section_start, self.text_section_size);
if (amt != self.text_section_size) return error.InputOutput;
// Write the new raw size in the .got header
var buf: [8]u8 = undefined;
mem.writeIntLittle(u32, buf[0..4], new_raw_size);
try self.base.file.?.pwriteAll(buf[0..4], self.section_table_offset + 16);
// Write the new .text section file offset in the .text section header
mem.writeIntLittle(u32, buf[0..4], new_text_section_start);
try self.base.file.?.pwriteAll(buf[0..4], self.section_table_offset + 40 + 20);
const current_virtual_size = mem.alignForwardGeneric(u32, self.offset_table_size, section_alignment);
const new_virtual_size = mem.alignForwardGeneric(u32, new_raw_size, section_alignment);
// If we had to move in the virtual address space, we need to fix the VAs in the offset table, as well as the virtual address of the `.text` section
// and the virutal size of the `.got` section
if (new_virtual_size != current_virtual_size) {
log.debug("growing offset table from virtual size {} to {}\n", .{ current_virtual_size, new_virtual_size });
self.size_of_image_dirty = true;
const va_offset = new_virtual_size - current_virtual_size;
// Write .got virtual size
mem.writeIntLittle(u32, buf[0..4], new_virtual_size);
try self.base.file.?.pwriteAll(buf[0..4], self.section_table_offset + 8);
// Write .text new virtual address
self.text_section_virtual_address = self.text_section_virtual_address + va_offset;
mem.writeIntLittle(u32, buf[0..4], self.text_section_virtual_address - default_image_base);
try self.base.file.?.pwriteAll(buf[0..4], self.section_table_offset + 40 + 12);
// Fix the VAs in the offset table
for (self.offset_table.items) |*va, idx| {
if (va.* != 0) {
va.* += va_offset;
switch (entry_size) {
4 => {
mem.writeInt(u32, buf[0..4], @intCast(u32, va.*), endian);
try self.base.file.?.pwriteAll(buf[0..4], offset_table_start + idx * entry_size);
},
8 => {
mem.writeInt(u64, &buf, va.*, endian);
try self.base.file.?.pwriteAll(&buf, offset_table_start + idx * entry_size);
},
else => unreachable,
}
}
}
}
self.offset_table_size = new_raw_size;
self.offset_table_size_dirty = false;
}
// Write the new entry
switch (entry_size) {
4 => {
var buf: [4]u8 = undefined;
mem.writeInt(u32, &buf, @intCast(u32, self.offset_table.items[index]), endian);
try self.base.file.?.pwriteAll(&buf, offset_table_start + index * entry_size);
},
8 => {
var buf: [8]u8 = undefined;
mem.writeInt(u64, &buf, self.offset_table.items[index], endian);
try self.base.file.?.pwriteAll(&buf, offset_table_start + index * entry_size);
},
else => unreachable,
}
}
pub fn updateDecl(self: *Coff, module: *Module, decl: *Module.Decl) !void {
// TODO COFF/PE debug information
// TODO Implement exports
const tracy = trace(@src());
defer tracy.end();
if (build_options.have_llvm)
if (self.llvm_object) |llvm_object| return try llvm_object.updateDecl(module, decl);
if (decl.val.tag() == .extern_fn) {
return; // TODO Should we do more when front-end analyzed extern decl?
}
var code_buffer = std.ArrayList(u8).init(self.base.allocator);
defer code_buffer.deinit();
const res = try codegen.generateSymbol(&self.base, decl.srcLoc(), .{
.ty = decl.ty,
.val = decl.val,
}, &code_buffer, .none);
const code = switch (res) {
.externally_managed => |x| x,
.appended => code_buffer.items,
.fail => |em| {
decl.analysis = .codegen_failure;
try module.failed_decls.put(module.gpa, decl, em);
return;
},
};
const required_alignment = decl.ty.abiAlignment(self.base.options.target);
const curr_size = decl.link.coff.size;
if (curr_size != 0) {
const capacity = decl.link.coff.capacity();
const need_realloc = code.len > capacity or
!mem.isAlignedGeneric(u32, decl.link.coff.text_offset, required_alignment);
if (need_realloc) {
const curr_vaddr = self.getDeclVAddr(decl);
const vaddr = try self.growTextBlock(&decl.link.coff, code.len, required_alignment);
log.debug("growing {s} from 0x{x} to 0x{x}\n", .{ decl.name, curr_vaddr, vaddr });
if (vaddr != curr_vaddr) {
log.debug(" (writing new offset table entry)\n", .{});
self.offset_table.items[decl.link.coff.offset_table_index] = vaddr;
try self.writeOffsetTableEntry(decl.link.coff.offset_table_index);
}
} else if (code.len < curr_size) {
self.shrinkTextBlock(&decl.link.coff, code.len);
}
} else {
const vaddr = try self.allocateTextBlock(&decl.link.coff, code.len, required_alignment);
log.debug("allocated text block for {s} at 0x{x} (size: {Bi})\n", .{
mem.spanZ(decl.name),
vaddr,
std.fmt.fmtIntSizeDec(code.len),
});
errdefer self.freeTextBlock(&decl.link.coff);
self.offset_table.items[decl.link.coff.offset_table_index] = vaddr;
try self.writeOffsetTableEntry(decl.link.coff.offset_table_index);
}
// Write the code into the file
try self.base.file.?.pwriteAll(code, self.section_data_offset + self.offset_table_size + decl.link.coff.text_offset);
// Since we updated the vaddr and the size, each corresponding export symbol also needs to be updated.
const decl_exports = module.decl_exports.get(decl) orelse &[0]*Module.Export{};
return self.updateDeclExports(module, decl, decl_exports);
}
pub fn freeDecl(self: *Coff, decl: *Module.Decl) void {
if (self.llvm_object) |_| return;
// Appending to free lists is allowed to fail because the free lists are heuristics based anyway.
self.freeTextBlock(&decl.link.coff);
self.offset_table_free_list.append(self.base.allocator, decl.link.coff.offset_table_index) catch {};
}
pub fn updateDeclExports(self: *Coff, module: *Module, decl: *Module.Decl, exports: []const *Module.Export) !void {
if (self.llvm_object) |_| return;
for (exports) |exp| {
if (exp.options.section) |section_name| {
if (!mem.eql(u8, section_name, ".text")) {
try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
module.failed_exports.putAssumeCapacityNoClobber(
exp,
try Module.ErrorMsg.create(self.base.allocator, decl.srcLoc(), "Unimplemented: ExportOptions.section", .{}),
);
continue;
}
}
if (mem.eql(u8, exp.options.name, "_start")) {
self.entry_addr = decl.link.coff.getVAddr(self.*) - default_image_base;
} else {
try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
module.failed_exports.putAssumeCapacityNoClobber(
exp,
try Module.ErrorMsg.create(self.base.allocator, decl.srcLoc(), "Unimplemented: Exports other than '_start'", .{}),
);
continue;
}
}
}
pub fn flush(self: *Coff, comp: *Compilation) !void {
if (build_options.have_llvm and self.base.options.use_lld) {
return self.linkWithLLD(comp);
} else {
switch (self.base.options.effectiveOutputMode()) {
.Exe, .Obj => {},
.Lib => return error.TODOImplementWritingLibFiles,
}
return self.flushModule(comp);
}
}
pub fn flushModule(self: *Coff, comp: *Compilation) !void {
const tracy = trace(@src());
defer tracy.end();
if (build_options.have_llvm)
if (self.llvm_object) |llvm_object| return try llvm_object.flushModule(comp);
if (self.text_section_size_dirty) {
// Write the new raw size in the .text header
var buf: [4]u8 = undefined;
mem.writeIntLittle(u32, &buf, self.text_section_size);
try self.base.file.?.pwriteAll(&buf, self.section_table_offset + 40 + 16);
try self.base.file.?.setEndPos(self.section_data_offset + self.offset_table_size + self.text_section_size);
self.text_section_size_dirty = false;
}
if (self.base.options.output_mode == .Exe and self.size_of_image_dirty) {
const new_size_of_image = mem.alignForwardGeneric(u32, self.text_section_virtual_address - default_image_base + self.text_section_size, section_alignment);
var buf: [4]u8 = undefined;
mem.writeIntLittle(u32, &buf, new_size_of_image);
try self.base.file.?.pwriteAll(&buf, self.optional_header_offset + 56);
self.size_of_image_dirty = false;
}
if (self.entry_addr == null and self.base.options.output_mode == .Exe) {
log.debug("flushing. no_entry_point_found = true\n", .{});
self.error_flags.no_entry_point_found = true;
} else {
log.debug("flushing. no_entry_point_found = false\n", .{});
self.error_flags.no_entry_point_found = false;
if (self.base.options.output_mode == .Exe) {
// Write AddressOfEntryPoint
var buf: [4]u8 = undefined;
mem.writeIntLittle(u32, &buf, self.entry_addr.?);
try self.base.file.?.pwriteAll(&buf, self.optional_header_offset + 16);
}
}
}
fn linkWithLLD(self: *Coff, comp: *Compilation) !void {
const tracy = trace(@src());
defer tracy.end();
var arena_allocator = std.heap.ArenaAllocator.init(self.base.allocator);
defer arena_allocator.deinit();
const arena = &arena_allocator.allocator;
const directory = self.base.options.emit.?.directory; // Just an alias to make it shorter to type.
// If there is no Zig code to compile, then we should skip flushing the output file because it
// will not be part of the linker line anyway.
const module_obj_path: ?[]const u8 = if (self.base.options.module) |module| blk: {
// Both stage1 and stage2 LLVM backend put the object file in the cache directory.
if (self.base.options.use_llvm) {
// Stage2 has to call flushModule since that outputs the LLVM object file.
if (!build_options.is_stage1) try self.flushModule(comp);
const obj_basename = try std.zig.binNameAlloc(arena, .{
.root_name = self.base.options.root_name,
.target = self.base.options.target,
.output_mode = .Obj,
});
const o_directory = self.base.options.module.?.zig_cache_artifact_directory;
const full_obj_path = try o_directory.join(arena, &[_][]const u8{obj_basename});
break :blk full_obj_path;
}
try self.flushModule(comp);
const obj_basename = self.base.intermediary_basename.?;
const full_obj_path = try directory.join(arena, &[_][]const u8{obj_basename});
break :blk full_obj_path;
} else null;
const is_lib = self.base.options.output_mode == .Lib;
const is_dyn_lib = self.base.options.link_mode == .Dynamic and is_lib;
const is_exe_or_dyn_lib = is_dyn_lib or self.base.options.output_mode == .Exe;
const link_in_crt = self.base.options.link_libc and is_exe_or_dyn_lib;
const target = self.base.options.target;
// See link/Elf.zig for comments on how this mechanism works.
const id_symlink_basename = "lld.id";
var man: Cache.Manifest = undefined;
defer if (!self.base.options.disable_lld_caching) man.deinit();
var digest: [Cache.hex_digest_len]u8 = undefined;
if (!self.base.options.disable_lld_caching) {
man = comp.cache_parent.obtain();
self.base.releaseLock();
try man.addListOfFiles(self.base.options.objects);
for (comp.c_object_table.items()) |entry| {
_ = try man.addFile(entry.key.status.success.object_path, null);
}
try man.addOptionalFile(module_obj_path);
man.hash.addOptional(self.base.options.stack_size_override);
man.hash.addOptional(self.base.options.image_base_override);
man.hash.addListOfBytes(self.base.options.extra_lld_args);
man.hash.addListOfBytes(self.base.options.lib_dirs);
man.hash.add(self.base.options.skip_linker_dependencies);
if (self.base.options.link_libc) {
man.hash.add(self.base.options.libc_installation != null);
if (self.base.options.libc_installation) |libc_installation| {
man.hash.addBytes(libc_installation.crt_dir.?);
if (target.abi == .msvc) {
man.hash.addBytes(libc_installation.msvc_lib_dir.?);
man.hash.addBytes(libc_installation.kernel32_lib_dir.?);
}
}
}
man.hash.addStringSet(self.base.options.system_libs);
man.hash.addOptional(self.base.options.subsystem);
man.hash.add(self.base.options.is_test);
man.hash.add(self.base.options.tsaware);
man.hash.add(self.base.options.nxcompat);
man.hash.add(self.base.options.dynamicbase);
man.hash.addOptional(self.base.options.major_subsystem_version);
man.hash.addOptional(self.base.options.minor_subsystem_version);
// We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
_ = try man.hit();
digest = man.final();
var prev_digest_buf: [digest.len]u8 = undefined;
const prev_digest: []u8 = Cache.readSmallFile(
directory.handle,
id_symlink_basename,
&prev_digest_buf,
) catch |err| blk: {
log.debug("COFF LLD new_digest={s} error: {s}", .{ std.fmt.fmtSliceHexLower(&digest), @errorName(err) });
// Handle this as a cache miss.
break :blk prev_digest_buf[0..0];
};
if (mem.eql(u8, prev_digest, &digest)) {
log.debug("COFF LLD digest={s} match - skipping invocation", .{std.fmt.fmtSliceHexLower(&digest)});
// Hot diggity dog! The output binary is already there.
self.base.lock = man.toOwnedLock();
return;
}
log.debug("COFF LLD prev_digest={s} new_digest={s}", .{ std.fmt.fmtSliceHexLower(prev_digest), std.fmt.fmtSliceHexLower(&digest) });
// We are about to change the output file to be different, so we invalidate the build hash now.
directory.handle.deleteFile(id_symlink_basename) catch |err| switch (err) {
error.FileNotFound => {},
else => |e| return e,
};
}
const full_out_path = try directory.join(arena, &[_][]const u8{self.base.options.emit.?.sub_path});
if (self.base.options.output_mode == .Obj) {
// LLD's COFF driver does not support the equvialent of `-r` so we do a simple file copy
// here. TODO: think carefully about how we can avoid this redundant operation when doing
// build-obj. See also the corresponding TODO in linkAsArchive.
const the_object_path = blk: {
if (self.base.options.objects.len != 0)
break :blk self.base.options.objects[0];
if (comp.c_object_table.count() != 0)
break :blk comp.c_object_table.items()[0].key.status.success.object_path;
if (module_obj_path) |p|
break :blk p;
// TODO I think this is unreachable. Audit this situation when solving the above TODO
// regarding eliding redundant object -> object transformations.
return error.NoObjectsToLink;
};
// This can happen when using --enable-cache and using the stage1 backend. In this case
// we can skip the file copy.
if (!mem.eql(u8, the_object_path, full_out_path)) {
try fs.cwd().copyFile(the_object_path, fs.cwd(), full_out_path, .{});
}
} else {
// Create an LLD command line and invoke it.
var argv = std.ArrayList([]const u8).init(self.base.allocator);
defer argv.deinit();
// We will invoke ourselves as a child process to gain access to LLD.
// This is necessary because LLD does not behave properly as a library -
// it calls exit() and does not reset all global data between invocations.
try argv.appendSlice(&[_][]const u8{ comp.self_exe_path.?, "lld-link" });
try argv.append("-ERRORLIMIT:0");
try argv.append("-NOLOGO");
if (!self.base.options.strip) {
try argv.append("-DEBUG");
}
if (self.base.options.lto) {
switch (self.base.options.optimize_mode) {
.Debug => {},
.ReleaseSmall => try argv.append("-OPT:lldlto=2"),
.ReleaseFast, .ReleaseSafe => try argv.append("-OPT:lldlto=3"),
}
}
if (self.base.options.output_mode == .Exe) {
const stack_size = self.base.options.stack_size_override orelse 16777216;
try argv.append(try allocPrint(arena, "-STACK:{d}", .{stack_size}));
}
if (self.base.options.image_base_override) |image_base| {
try argv.append(try std.fmt.allocPrint(arena, "-BASE:{d}", .{image_base}));
}
if (target.cpu.arch == .i386) {
try argv.append("-MACHINE:X86");
} else if (target.cpu.arch == .x86_64) {
try argv.append("-MACHINE:X64");
} else if (target.cpu.arch.isARM()) {
if (target.cpu.arch.ptrBitWidth() == 32) {
try argv.append("-MACHINE:ARM");
} else {
try argv.append("-MACHINE:ARM64");
}
}
if (is_dyn_lib) {
try argv.append("-DLL");
}
if (self.base.options.tsaware) {
try argv.append("-tsaware");
}
if (self.base.options.nxcompat) {
try argv.append("-nxcompat");
}
if (self.base.options.dynamicbase) {
try argv.append("-dynamicbase");
}
const subsystem_suffix = ss: {
if (self.base.options.major_subsystem_version) |major| {
if (self.base.options.minor_subsystem_version) |minor| {
break :ss try allocPrint(arena, ",{d}.{d}", .{ major, minor });
} else {
break :ss try allocPrint(arena, ",{d}", .{major});
}
}
break :ss "";
};
try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path}));
if (self.base.options.link_libc) {
if (self.base.options.libc_installation) |libc_installation| {
try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.crt_dir.?}));
if (target.abi == .msvc) {
try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.msvc_lib_dir.?}));
try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.kernel32_lib_dir.?}));
}
}
}
for (self.base.options.lib_dirs) |lib_dir| {
try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{lib_dir}));
}
try argv.appendSlice(self.base.options.objects);
for (comp.c_object_table.items()) |entry| {
try argv.append(entry.key.status.success.object_path);
}
if (module_obj_path) |p| {
try argv.append(p);
}
const resolved_subsystem: ?std.Target.SubSystem = blk: {
if (self.base.options.subsystem) |explicit| break :blk explicit;
switch (target.os.tag) {
.windows => {
if (self.base.options.module) |module| {
if (module.stage1_flags.have_dllmain_crt_startup or is_dyn_lib)
break :blk null;
if (module.stage1_flags.have_c_main or self.base.options.is_test or
module.stage1_flags.have_winmain_crt_startup or
module.stage1_flags.have_wwinmain_crt_startup)
{
break :blk .Console;
}
if (module.stage1_flags.have_winmain or module.stage1_flags.have_wwinmain)
break :blk .Windows;
}
},
.uefi => break :blk .EfiApplication,
else => {},
}
break :blk null;
};
const Mode = enum { uefi, win32 };
const mode: Mode = mode: {
if (resolved_subsystem) |subsystem| switch (subsystem) {
.Console => {
try argv.append(try allocPrint(arena, "-SUBSYSTEM:console{s}", .{
subsystem_suffix,
}));
break :mode .win32;
},
.EfiApplication => {
try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_application{s}", .{
subsystem_suffix,
}));
break :mode .uefi;
},
.EfiBootServiceDriver => {
try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_boot_service_driver{s}", .{
subsystem_suffix,
}));
break :mode .uefi;
},
.EfiRom => {
try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_rom{s}", .{
subsystem_suffix,
}));
break :mode .uefi;
},
.EfiRuntimeDriver => {
try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_runtime_driver{s}", .{
subsystem_suffix,
}));
break :mode .uefi;
},
.Native => {
try argv.append(try allocPrint(arena, "-SUBSYSTEM:native{s}", .{
subsystem_suffix,
}));
break :mode .win32;
},
.Posix => {
try argv.append(try allocPrint(arena, "-SUBSYSTEM:posix{s}", .{
subsystem_suffix,
}));
break :mode .win32;
},
.Windows => {
try argv.append(try allocPrint(arena, "-SUBSYSTEM:windows{s}", .{
subsystem_suffix,
}));
break :mode .win32;
},
} else if (target.os.tag == .uefi) {
break :mode .uefi;
} else {
break :mode .win32;
}
};
switch (mode) {
.uefi => try argv.appendSlice(&[_][]const u8{
"-BASE:0",
"-ENTRY:EfiMain",
"-OPT:REF",
"-SAFESEH:NO",
"-MERGE:.rdata=.data",
"-ALIGN:32",
"-NODEFAULTLIB",
"-SECTION:.xdata,D",
}),
.win32 => {
if (link_in_crt) {
if (target.abi.isGnu()) {
try argv.append("-lldmingw");
if (target.cpu.arch == .i386) {
try argv.append("-ALTERNATENAME:__image_base__=___ImageBase");
} else {
try argv.append("-ALTERNATENAME:__image_base__=__ImageBase");
}
if (is_dyn_lib) {
try argv.append(try comp.get_libc_crt_file(arena, "dllcrt2.o"));
if (target.cpu.arch == .i386) {
try argv.append("-ALTERNATENAME:__DllMainCRTStartup@12=_DllMainCRTStartup@12");
} else {
try argv.append("-ALTERNATENAME:_DllMainCRTStartup=DllMainCRTStartup");
}
} else {
try argv.append(try comp.get_libc_crt_file(arena, "crt2.o"));
}
try argv.append(try comp.get_libc_crt_file(arena, "mingw32.lib"));
try argv.append(try comp.get_libc_crt_file(arena, "mingwex.lib"));
try argv.append(try comp.get_libc_crt_file(arena, "msvcrt-os.lib"));
for (mingw.always_link_libs) |name| {
if (!self.base.options.system_libs.contains(name)) {
const lib_basename = try allocPrint(arena, "{s}.lib", .{name});
try argv.append(try comp.get_libc_crt_file(arena, lib_basename));
}
}
} else {
const lib_str = switch (self.base.options.link_mode) {
.Dynamic => "",
.Static => "lib",
};
const d_str = switch (self.base.options.optimize_mode) {
.Debug => "d",
else => "",
};
switch (self.base.options.link_mode) {
.Static => try argv.append(try allocPrint(arena, "libcmt{s}.lib", .{d_str})),
.Dynamic => try argv.append(try allocPrint(arena, "msvcrt{s}.lib", .{d_str})),
}
try argv.append(try allocPrint(arena, "{s}vcruntime{s}.lib", .{ lib_str, d_str }));
try argv.append(try allocPrint(arena, "{s}ucrt{s}.lib", .{ lib_str, d_str }));
//Visual C++ 2015 Conformance Changes
//https://msdn.microsoft.com/en-us/library/bb531344.aspx
try argv.append("legacy_stdio_definitions.lib");
// msvcrt depends on kernel32 and ntdll
try argv.append("kernel32.lib");
try argv.append("ntdll.lib");
}
} else {
try argv.append("-NODEFAULTLIB");
if (!is_lib) {
if (self.base.options.module) |module| {
if (module.stage1_flags.have_winmain_crt_startup) {
try argv.append("-ENTRY:WinMainCRTStartup");
} else {
try argv.append("-ENTRY:wWinMainCRTStartup");
}
} else {
try argv.append("-ENTRY:wWinMainCRTStartup");
}
}
}
},
}
// libc++ dep
if (self.base.options.link_libcpp) {
try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
try argv.append(comp.libcxx_static_lib.?.full_object_path);
try argv.append(comp.libunwind_static_lib.?.full_object_path);
}
// TODO: remove when stage2 can build compiler_rt.zig, c.zig and ssp.zig
// compiler-rt, libc and libssp
if (is_exe_or_dyn_lib and !self.base.options.skip_linker_dependencies and build_options.is_stage1) {
if (!self.base.options.link_libc) {
try argv.append(comp.libc_static_lib.?.full_object_path);
}
// MinGW doesn't provide libssp symbols
if (target.abi.isGnu()) {
try argv.append(comp.libssp_static_lib.?.full_object_path);
}
// MSVC compiler_rt is missing some stuff, so we build it unconditionally but
// and rely on weak linkage to allow MSVC compiler_rt functions to override ours.
try argv.append(comp.compiler_rt_static_lib.?.full_object_path);
}
for (self.base.options.system_libs.items()) |entry| {
const lib_basename = try allocPrint(arena, "{s}.lib", .{entry.key});
if (comp.crt_files.get(lib_basename)) |crt_file| {
try argv.append(crt_file.full_object_path);
} else {
try argv.append(lib_basename);
}
}
if (self.base.options.verbose_link) {
// Skip over our own name so that the LLD linker name is the first argv item.
Compilation.dump_argv(argv.items[1..]);
}
// Sadly, we must run LLD as a child process because it does not behave
// properly as a library.
const child = try std.ChildProcess.init(argv.items, arena);
defer child.deinit();
if (comp.clang_passthrough_mode) {
child.stdin_behavior = .Inherit;
child.stdout_behavior = .Inherit;
child.stderr_behavior = .Inherit;
const term = child.spawnAndWait() catch |err| {
log.err("unable to spawn {s}: {s}", .{ argv.items[0], @errorName(err) });
return error.UnableToSpawnSelf;
};
switch (term) {
.Exited => |code| {
if (code != 0) {
// TODO https://github.com/ziglang/zig/issues/6342
std.process.exit(1);
}
},
else => std.process.abort(),
}
} else {
child.stdin_behavior = .Ignore;
child.stdout_behavior = .Ignore;
child.stderr_behavior = .Pipe;
try child.spawn();
const stderr = try child.stderr.?.reader().readAllAlloc(arena, 10 * 1024 * 1024);
const term = child.wait() catch |err| {
log.err("unable to spawn {s}: {s}", .{ argv.items[0], @errorName(err) });
return error.UnableToSpawnSelf;
};
switch (term) {
.Exited => |code| {
if (code != 0) {
// TODO parse this output and surface with the Compilation API rather than
// directly outputting to stderr here.
std.debug.print("{s}", .{stderr});
return error.LLDReportedFailure;
}
},
else => {
log.err("{s} terminated with stderr:\n{s}", .{ argv.items[0], stderr });
return error.LLDCrashed;
},
}
if (stderr.len != 0) {
log.warn("unexpected LLD stderr:\n{s}", .{stderr});
}
}
}
if (!self.base.options.disable_lld_caching) {
// Update the file with the digest. If it fails we can continue; it only
// means that the next invocation will have an unnecessary cache miss.
Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
log.warn("failed to save linking hash digest file: {s}", .{@errorName(err)});
};
// Again failure here only means an unnecessary cache miss.
man.writeManifest() catch |err| {
log.warn("failed to write cache manifest when linking: {s}", .{@errorName(err)});
};
// We hang on to this lock so that the output file path can be used without
// other processes clobbering it.
self.base.lock = man.toOwnedLock();
}
}
pub fn getDeclVAddr(self: *Coff, decl: *const Module.Decl) u64 {
assert(self.llvm_object == null);
return self.text_section_virtual_address + decl.link.coff.text_offset;
}
pub fn updateDeclLineNumber(self: *Coff, module: *Module, decl: *Module.Decl) !void {
// TODO Implement this
}
pub fn deinit(self: *Coff) void {
if (build_options.have_llvm)
if (self.llvm_object) |ir_module| ir_module.deinit(self.base.allocator);
self.text_block_free_list.deinit(self.base.allocator);
self.offset_table.deinit(self.base.allocator);
self.offset_table_free_list.deinit(self.base.allocator);
} | src/link/Coff.zig |
const std = @import("../../index.zig");
const builtin = @import("builtin");
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const Allocator = mem.Allocator;
const ArrayList = std.ArrayList;
const TypeId = builtin.TypeId;
pub const Limb = usize;
pub const DoubleLimb = @IntType(false, 2 * Limb.bit_count);
pub const Log2Limb = math.Log2Int(Limb);
comptime {
debug.assert(math.floorPowerOfTwo(usize, Limb.bit_count) == Limb.bit_count);
debug.assert(Limb.bit_count <= 64); // u128 set is unsupported
debug.assert(Limb.is_signed == false);
}
pub const Int = struct {
allocator: *Allocator,
positive: bool,
// - little-endian ordered
// - len >= 1 always
// - zero value -> len == 1 with limbs[0] == 0
limbs: []Limb,
len: usize,
const default_capacity = 4;
pub fn init(allocator: *Allocator) !Int {
return try Int.initCapacity(allocator, default_capacity);
}
pub fn initSet(allocator: *Allocator, value: var) !Int {
var s = try Int.init(allocator);
try s.set(value);
return s;
}
pub fn initCapacity(allocator: *Allocator, capacity: usize) !Int {
return Int{
.allocator = allocator,
.positive = true,
.limbs = block: {
var limbs = try allocator.alloc(Limb, math.max(default_capacity, capacity));
limbs[0] = 0;
break :block limbs;
},
.len = 1,
};
}
pub fn ensureCapacity(self: *Int, capacity: usize) !void {
if (capacity <= self.limbs.len) {
return;
}
self.limbs = try self.allocator.realloc(Limb, self.limbs, capacity);
}
pub fn deinit(self: Int) void {
self.allocator.free(self.limbs);
}
pub fn clone(other: Int) !Int {
return Int{
.allocator = other.allocator,
.positive = other.positive,
.limbs = block: {
var limbs = try other.allocator.alloc(Limb, other.len);
mem.copy(Limb, limbs[0..], other.limbs[0..other.len]);
break :block limbs;
},
.len = other.len,
};
}
pub fn copy(self: *Int, other: Int) !void {
if (self == &other) {
return;
}
self.positive = other.positive;
try self.ensureCapacity(other.len);
mem.copy(Limb, self.limbs[0..], other.limbs[0..other.len]);
self.len = other.len;
}
pub fn swap(self: *Int, other: *Int) void {
mem.swap(Int, self, other);
}
pub fn dump(self: Int) void {
for (self.limbs) |limb| {
debug.warn("{x} ", limb);
}
debug.warn("\n");
}
pub fn negate(r: *Int) void {
r.positive = !r.positive;
}
pub fn abs(r: *Int) void {
r.positive = true;
}
pub fn isOdd(r: Int) bool {
return r.limbs[0] & 1 != 0;
}
pub fn isEven(r: Int) bool {
return !r.isOdd();
}
fn bitcount(self: Int) usize {
const u_bit_count = (self.len - 1) * Limb.bit_count + (Limb.bit_count - @clz(self.limbs[self.len - 1]));
return usize(@boolToInt(!self.positive)) + u_bit_count;
}
pub fn sizeInBase(self: Int, base: usize) usize {
return (self.bitcount() / math.log2(base)) + 1;
}
pub fn set(self: *Int, value: var) Allocator.Error!void {
const T = @typeOf(value);
switch (@typeInfo(T)) {
TypeId.Int => |info| {
const UT = if (T.is_signed) @IntType(false, T.bit_count - 1) else T;
try self.ensureCapacity(@sizeOf(UT) / @sizeOf(Limb));
self.positive = value >= 0;
self.len = 0;
var w_value: UT = if (value < 0) @intCast(UT, -value) else @intCast(UT, value);
if (info.bits <= Limb.bit_count) {
self.limbs[0] = Limb(w_value);
self.len = 1;
} else {
var i: usize = 0;
while (w_value != 0) : (i += 1) {
self.limbs[i] = @truncate(Limb, w_value);
self.len += 1;
// TODO: shift == 64 at compile-time fails. Fails on u128 limbs.
w_value >>= Limb.bit_count / 2;
w_value >>= Limb.bit_count / 2;
}
}
},
TypeId.ComptimeInt => {
comptime var w_value = if (value < 0) -value else value;
const req_limbs = @divFloor(math.log2(w_value), Limb.bit_count) + 1;
try self.ensureCapacity(req_limbs);
self.positive = value >= 0;
self.len = req_limbs;
if (w_value <= @maxValue(Limb)) {
self.limbs[0] = w_value;
} else {
const mask = (1 << Limb.bit_count) - 1;
comptime var i = 0;
inline while (w_value != 0) : (i += 1) {
self.limbs[i] = w_value & mask;
w_value >>= Limb.bit_count / 2;
w_value >>= Limb.bit_count / 2;
}
}
},
else => {
@compileError("cannot set Int using type " ++ @typeName(T));
},
}
}
pub const ConvertError = error{
NegativeIntoUnsigned,
TargetTooSmall,
};
pub fn to(self: Int, comptime T: type) ConvertError!T {
switch (@typeId(T)) {
TypeId.Int => {
const UT = if (T.is_signed) @IntType(false, T.bit_count - 1) else T;
if (self.bitcount() > 8 * @sizeOf(UT)) {
return error.TargetTooSmall;
}
var r: UT = 0;
if (@sizeOf(UT) <= @sizeOf(Limb)) {
r = @intCast(UT, self.limbs[0]);
} else {
for (self.limbs[0..self.len]) |_, ri| {
const limb = self.limbs[self.len - ri - 1];
r <<= Limb.bit_count;
r |= limb;
}
}
if (!T.is_signed) {
return if (self.positive) r else error.NegativeIntoUnsigned;
} else {
return if (self.positive) @intCast(T, r) else -@intCast(T, r);
}
},
else => {
@compileError("cannot convert Int to type " ++ @typeName(T));
},
}
}
fn charToDigit(ch: u8, base: u8) !u8 {
const d = switch (ch) {
'0'...'9' => ch - '0',
'a'...'f' => (ch - 'a') + 0xa,
else => return error.InvalidCharForDigit,
};
return if (d < base) d else return error.DigitTooLargeForBase;
}
fn digitToChar(d: u8, base: u8) !u8 {
if (d >= base) {
return error.DigitTooLargeForBase;
}
return switch (d) {
0...9 => '0' + d,
0xa...0xf => ('a' - 0xa) + d,
else => unreachable,
};
}
pub fn setString(self: *Int, base: u8, value: []const u8) !void {
if (base < 2 or base > 16) {
return error.InvalidBase;
}
var i: usize = 0;
var positive = true;
if (value.len > 0 and value[0] == '-') {
positive = false;
i += 1;
}
// TODO values less than limb size should guarantee non allocating
var base_buffer: [512]u8 = undefined;
const base_al = &std.heap.FixedBufferAllocator.init(base_buffer[0..]).allocator;
const base_ap = try Int.initSet(base_al, base);
var d_buffer: [512]u8 = undefined;
var d_fba = std.heap.FixedBufferAllocator.init(d_buffer[0..]);
const d_al = &d_fba.allocator;
try self.set(0);
for (value[i..]) |ch| {
const d = try charToDigit(ch, base);
d_fba.end_index = 0;
const d_ap = try Int.initSet(d_al, d);
try self.mul(self.*, base_ap);
try self.add(self.*, d_ap);
}
self.positive = positive;
}
pub fn toString(self: Int, allocator: *Allocator, base: u8) ![]const u8 {
if (base < 2 or base > 16) {
return error.InvalidBase;
}
var digits = ArrayList(u8).init(allocator);
try digits.ensureCapacity(self.sizeInBase(base) + 1);
defer digits.deinit();
if (self.eqZero()) {
try digits.append('0');
return digits.toOwnedSlice();
}
// Power of two: can do a single pass and use masks to extract digits.
if (base & (base - 1) == 0) {
const base_shift = math.log2_int(Limb, base);
for (self.limbs[0..self.len]) |limb| {
var shift: usize = 0;
while (shift < Limb.bit_count) : (shift += base_shift) {
const r = @intCast(u8, (limb >> @intCast(Log2Limb, shift)) & Limb(base - 1));
const ch = try digitToChar(r, base);
try digits.append(ch);
}
}
while (true) {
// always will have a non-zero digit somewhere
const c = digits.pop();
if (c != '0') {
digits.append(c) catch unreachable;
break;
}
}
} // Non power-of-two: batch divisions per word size.
else {
const digits_per_limb = math.log(Limb, base, @maxValue(Limb));
var limb_base: Limb = 1;
var j: usize = 0;
while (j < digits_per_limb) : (j += 1) {
limb_base *= base;
}
var q = try self.clone();
q.positive = true;
var r = try Int.init(allocator);
var b = try Int.initSet(allocator, limb_base);
while (q.len >= 2) {
try Int.divTrunc(&q, &r, q, b);
var r_word = r.limbs[0];
var i: usize = 0;
while (i < digits_per_limb) : (i += 1) {
const ch = try digitToChar(@intCast(u8, r_word % base), base);
r_word /= base;
try digits.append(ch);
}
}
{
debug.assert(q.len == 1);
var r_word = q.limbs[0];
while (r_word != 0) {
const ch = try digitToChar(@intCast(u8, r_word % base), base);
r_word /= base;
try digits.append(ch);
}
}
}
if (!self.positive) {
try digits.append('-');
}
var s = digits.toOwnedSlice();
mem.reverse(u8, s);
return s;
}
// returns -1, 0, 1 if |a| < |b|, |a| == |b| or |a| > |b| respectively.
pub fn cmpAbs(a: Int, b: Int) i8 {
if (a.len < b.len) {
return -1;
}
if (a.len > b.len) {
return 1;
}
var i: usize = a.len - 1;
while (i != 0) : (i -= 1) {
if (a.limbs[i] != b.limbs[i]) {
break;
}
}
if (a.limbs[i] < b.limbs[i]) {
return -1;
} else if (a.limbs[i] > b.limbs[i]) {
return 1;
} else {
return 0;
}
}
// returns -1, 0, 1 if a < b, a == b or a > b respectively.
pub fn cmp(a: Int, b: Int) i8 {
if (a.positive != b.positive) {
return if (a.positive) i8(1) else -1;
} else {
const r = cmpAbs(a, b);
return if (a.positive) r else -r;
}
}
// if a == 0
pub fn eqZero(a: Int) bool {
return a.len == 1 and a.limbs[0] == 0;
}
// if |a| == |b|
pub fn eqAbs(a: Int, b: Int) bool {
return cmpAbs(a, b) == 0;
}
// if a == b
pub fn eq(a: Int, b: Int) bool {
return cmp(a, b) == 0;
}
// Normalize for a possible single carry digit.
//
// [1, 2, 3, 4, 0] -> [1, 2, 3, 4]
// [1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]
// [0] -> [0]
fn norm1(r: *Int, length: usize) void {
debug.assert(length > 0);
debug.assert(length <= r.limbs.len);
if (r.limbs[length - 1] == 0) {
r.len = if (length > 1) length - 1 else 1;
} else {
r.len = length;
}
}
// Normalize a possible sequence of leading zeros.
//
// [1, 2, 3, 4, 0] -> [1, 2, 3, 4]
// [1, 2, 0, 0, 0] -> [1, 2]
// [0, 0, 0, 0, 0] -> [0]
fn normN(r: *Int, length: usize) void {
debug.assert(length > 0);
debug.assert(length <= r.limbs.len);
var j = length;
while (j > 0) : (j -= 1) {
if (r.limbs[j - 1] != 0) {
break;
}
}
// Handle zero
r.len = if (j != 0) j else 1;
}
// r = a + b
pub fn add(r: *Int, a: Int, b: Int) Allocator.Error!void {
if (a.eqZero()) {
try r.copy(b);
return;
} else if (b.eqZero()) {
try r.copy(a);
return;
}
if (a.positive != b.positive) {
if (a.positive) {
// (a) + (-b) => a - b
const bp = Int{
.allocator = undefined,
.positive = true,
.limbs = b.limbs,
.len = b.len,
};
try r.sub(a, bp);
} else {
// (-a) + (b) => b - a
const ap = Int{
.allocator = undefined,
.positive = true,
.limbs = a.limbs,
.len = a.len,
};
try r.sub(b, ap);
}
} else {
if (a.len >= b.len) {
try r.ensureCapacity(a.len + 1);
lladd(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
r.norm1(a.len + 1);
} else {
try r.ensureCapacity(b.len + 1);
lladd(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
r.norm1(b.len + 1);
}
r.positive = a.positive;
}
}
// Knuth 4.3.1, Algorithm A.
fn lladd(r: []Limb, a: []const Limb, b: []const Limb) void {
@setRuntimeSafety(false);
debug.assert(a.len != 0 and b.len != 0);
debug.assert(a.len >= b.len);
debug.assert(r.len >= a.len + 1);
var i: usize = 0;
var carry: Limb = 0;
while (i < b.len) : (i += 1) {
var c: Limb = 0;
c += @boolToInt(@addWithOverflow(Limb, a[i], b[i], &r[i]));
c += @boolToInt(@addWithOverflow(Limb, r[i], carry, &r[i]));
carry = c;
}
while (i < a.len) : (i += 1) {
carry = @boolToInt(@addWithOverflow(Limb, a[i], carry, &r[i]));
}
r[i] = carry;
}
// r = a - b
pub fn sub(r: *Int, a: Int, b: Int) !void {
if (a.positive != b.positive) {
if (a.positive) {
// (a) - (-b) => a + b
const bp = Int{
.allocator = undefined,
.positive = true,
.limbs = b.limbs,
.len = b.len,
};
try r.add(a, bp);
} else {
// (-a) - (b) => -(a + b)
const ap = Int{
.allocator = undefined,
.positive = true,
.limbs = a.limbs,
.len = a.len,
};
try r.add(ap, b);
r.positive = false;
}
} else {
if (a.positive) {
// (a) - (b) => a - b
if (a.cmp(b) >= 0) {
try r.ensureCapacity(a.len + 1);
llsub(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
r.normN(a.len);
r.positive = true;
} else {
try r.ensureCapacity(b.len + 1);
llsub(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
r.normN(b.len);
r.positive = false;
}
} else {
// (-a) - (-b) => -(a - b)
if (a.cmp(b) < 0) {
try r.ensureCapacity(a.len + 1);
llsub(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
r.normN(a.len);
r.positive = false;
} else {
try r.ensureCapacity(b.len + 1);
llsub(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
r.normN(b.len);
r.positive = true;
}
}
}
}
// Knuth 4.3.1, Algorithm S.
fn llsub(r: []Limb, a: []const Limb, b: []const Limb) void {
@setRuntimeSafety(false);
debug.assert(a.len != 0 and b.len != 0);
debug.assert(a.len > b.len or (a.len == b.len and a[a.len - 1] >= b[b.len - 1]));
debug.assert(r.len >= a.len);
var i: usize = 0;
var borrow: Limb = 0;
while (i < b.len) : (i += 1) {
var c: Limb = 0;
c += @boolToInt(@subWithOverflow(Limb, a[i], b[i], &r[i]));
c += @boolToInt(@subWithOverflow(Limb, r[i], borrow, &r[i]));
borrow = c;
}
while (i < a.len) : (i += 1) {
borrow = @boolToInt(@subWithOverflow(Limb, a[i], borrow, &r[i]));
}
debug.assert(borrow == 0);
}
// rma = a * b
//
// For greatest efficiency, ensure rma does not alias a or b.
pub fn mul(rma: *Int, a: Int, b: Int) !void {
var r = rma;
var aliased = rma.limbs.ptr == a.limbs.ptr or rma.limbs.ptr == b.limbs.ptr;
var sr: Int = undefined;
if (aliased) {
sr = try Int.initCapacity(rma.allocator, a.len + b.len);
r = &sr;
aliased = true;
}
defer if (aliased) {
rma.swap(r);
r.deinit();
};
try r.ensureCapacity(a.len + b.len);
if (a.len >= b.len) {
llmul(r.limbs, a.limbs[0..a.len], b.limbs[0..b.len]);
} else {
llmul(r.limbs, b.limbs[0..b.len], a.limbs[0..a.len]);
}
r.positive = a.positive == b.positive;
r.normN(a.len + b.len);
}
// a + b * c + *carry, sets carry to the overflow bits
pub fn addMulLimbWithCarry(a: Limb, b: Limb, c: Limb, carry: *Limb) Limb {
var r1: Limb = undefined;
// r1 = a + *carry
const c1: Limb = @boolToInt(@addWithOverflow(Limb, a, carry.*, &r1));
// r2 = b * c
//
// We still use a DoubleLimb here since the @mulWithOverflow builtin does not
// return the carry and lower bits separately so we would need to perform this
// anyway to get the carry bits. The branch on the overflow case costs more than
// just computing them unconditionally and splitting.
//
// This could be a single x86 mul instruction, which stores the carry/lower in rdx:rax.
const bc = DoubleLimb(b) * DoubleLimb(c);
const r2 = @truncate(Limb, bc);
const c2 = @truncate(Limb, bc >> Limb.bit_count);
// r1 = r1 + r2
const c3: Limb = @boolToInt(@addWithOverflow(Limb, r1, r2, &r1));
// This never overflows, c1, c3 are either 0 or 1 and if both are 1 then
// c2 is at least <= @maxValue(Limb) - 2.
carry.* = c1 + c2 + c3;
return r1;
}
// Knuth 4.3.1, Algorithm M.
//
// r MUST NOT alias any of a or b.
fn llmul(r: []Limb, a: []const Limb, b: []const Limb) void {
@setRuntimeSafety(false);
debug.assert(a.len >= b.len);
debug.assert(r.len >= a.len + b.len);
mem.set(Limb, r[0 .. a.len + b.len], 0);
var i: usize = 0;
while (i < a.len) : (i += 1) {
var carry: Limb = 0;
var j: usize = 0;
while (j < b.len) : (j += 1) {
r[i + j] = @inlineCall(addMulLimbWithCarry, r[i + j], a[i], b[j], &carry);
}
r[i + j] = carry;
}
}
pub fn divFloor(q: *Int, r: *Int, a: Int, b: Int) !void {
try div(q, r, a, b);
// Trunc -> Floor.
if (!q.positive) {
// TODO values less than limb size should guarantee non allocating
var one_buffer: [512]u8 = undefined;
const one_al = &std.heap.FixedBufferAllocator.init(one_buffer[0..]).allocator;
const one_ap = try Int.initSet(one_al, 1);
try q.sub(q.*, one_ap);
try r.add(q.*, one_ap);
}
r.positive = b.positive;
}
pub fn divTrunc(q: *Int, r: *Int, a: Int, b: Int) !void {
try div(q, r, a, b);
r.positive = a.positive;
}
// Truncates by default.
fn div(quo: *Int, rem: *Int, a: Int, b: Int) !void {
if (b.eqZero()) {
@panic("division by zero");
}
if (quo == rem) {
@panic("quo and rem cannot be same variable");
}
if (a.cmpAbs(b) < 0) {
// quo may alias a so handle rem first
try rem.copy(a);
rem.positive = a.positive == b.positive;
quo.positive = true;
quo.len = 1;
quo.limbs[0] = 0;
return;
}
if (b.len == 1) {
try quo.ensureCapacity(a.len);
lldiv1(quo.limbs[0..], &rem.limbs[0], a.limbs[0..a.len], b.limbs[0]);
quo.norm1(a.len);
quo.positive = a.positive == b.positive;
rem.len = 1;
rem.positive = true;
} else {
// x and y are modified during division
var x = try a.clone();
defer x.deinit();
var y = try b.clone();
defer y.deinit();
// x may grow one limb during normalization
try quo.ensureCapacity(a.len + y.len);
try divN(quo.allocator, quo, rem, &x, &y);
quo.positive = a.positive == b.positive;
}
}
// Knuth 4.3.1, Exercise 16.
fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {
@setRuntimeSafety(false);
debug.assert(a.len > 1 or a[0] >= b);
debug.assert(quo.len >= a.len);
rem.* = 0;
for (a) |_, ri| {
const i = a.len - ri - 1;
const pdiv = ((DoubleLimb(rem.*) << Limb.bit_count) | a[i]);
if (pdiv == 0) {
quo[i] = 0;
rem.* = 0;
} else if (pdiv < b) {
quo[i] = 0;
rem.* = @truncate(Limb, pdiv);
} else if (pdiv == b) {
quo[i] = 1;
rem.* = 0;
} else {
quo[i] = @truncate(Limb, @divTrunc(pdiv, b));
rem.* = @truncate(Limb, pdiv - (quo[i] *% b));
}
}
}
// Handbook of Applied Cryptography, 14.20
//
// x = qy + r where 0 <= r < y
fn divN(allocator: *Allocator, q: *Int, r: *Int, x: *Int, y: *Int) !void {
debug.assert(y.len >= 2);
debug.assert(x.len >= y.len);
debug.assert(q.limbs.len >= x.len + y.len - 1);
debug.assert(default_capacity >= 3); // see 3.2
var tmp = try Int.init(allocator);
defer tmp.deinit();
// Normalize so y > Limb.bit_count / 2 (i.e. leading bit is set)
const norm_shift = @clz(y.limbs[y.len - 1]);
try x.shiftLeft(x.*, norm_shift);
try y.shiftLeft(y.*, norm_shift);
const n = x.len - 1;
const t = y.len - 1;
// 1.
q.len = n - t + 1;
mem.set(Limb, q.limbs[0..q.len], 0);
// 2.
try tmp.shiftLeft(y.*, Limb.bit_count * (n - t));
while (x.cmp(tmp) >= 0) {
q.limbs[n - t] += 1;
try x.sub(x.*, tmp);
}
// 3.
var i = n;
while (i > t) : (i -= 1) {
// 3.1
if (x.limbs[i] == y.limbs[t]) {
q.limbs[i - t - 1] = @maxValue(Limb);
} else {
const num = (DoubleLimb(x.limbs[i]) << Limb.bit_count) | DoubleLimb(x.limbs[i - 1]);
const z = @intCast(Limb, num / DoubleLimb(y.limbs[t]));
q.limbs[i - t - 1] = if (z > @maxValue(Limb)) @maxValue(Limb) else Limb(z);
}
// 3.2
tmp.limbs[0] = if (i >= 2) x.limbs[i - 2] else 0;
tmp.limbs[1] = if (i >= 1) x.limbs[i - 1] else 0;
tmp.limbs[2] = x.limbs[i];
tmp.normN(3);
while (true) {
// 2x1 limb multiplication unrolled against single-limb q[i-t-1]
var carry: Limb = 0;
r.limbs[0] = addMulLimbWithCarry(0, if (t >= 1) y.limbs[t - 1] else 0, q.limbs[i - t - 1], &carry);
r.limbs[1] = addMulLimbWithCarry(0, y.limbs[t], q.limbs[i - t - 1], &carry);
r.limbs[2] = carry;
r.normN(3);
if (r.cmpAbs(tmp) <= 0) {
break;
}
q.limbs[i - t - 1] -= 1;
}
// 3.3
try tmp.set(q.limbs[i - t - 1]);
try tmp.mul(tmp, y.*);
try tmp.shiftLeft(tmp, Limb.bit_count * (i - t - 1));
try x.sub(x.*, tmp);
if (!x.positive) {
try tmp.shiftLeft(y.*, Limb.bit_count * (i - t - 1));
try x.add(x.*, tmp);
q.limbs[i - t - 1] -= 1;
}
}
// Denormalize
q.normN(q.len);
try r.shiftRight(x.*, norm_shift);
r.normN(r.len);
}
// r = a << shift, in other words, r = a * 2^shift
pub fn shiftLeft(r: *Int, a: Int, shift: usize) !void {
try r.ensureCapacity(a.len + (shift / Limb.bit_count) + 1);
llshl(r.limbs[0..], a.limbs[0..a.len], shift);
r.norm1(a.len + (shift / Limb.bit_count) + 1);
r.positive = a.positive;
}
fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
@setRuntimeSafety(false);
debug.assert(a.len >= 1);
debug.assert(r.len >= a.len + (shift / Limb.bit_count) + 1);
const limb_shift = shift / Limb.bit_count + 1;
const interior_limb_shift = @intCast(Log2Limb, shift % Limb.bit_count);
var carry: Limb = 0;
var i: usize = 0;
while (i < a.len) : (i += 1) {
const src_i = a.len - i - 1;
const dst_i = src_i + limb_shift;
const src_digit = a[src_i];
r[dst_i] = carry | @inlineCall(math.shr, Limb, src_digit, Limb.bit_count - @intCast(Limb, interior_limb_shift));
carry = (src_digit << interior_limb_shift);
}
r[limb_shift - 1] = carry;
mem.set(Limb, r[0 .. limb_shift - 1], 0);
}
// r = a >> shift
pub fn shiftRight(r: *Int, a: Int, shift: usize) !void {
if (a.len <= shift / Limb.bit_count) {
r.len = 1;
r.limbs[0] = 0;
r.positive = true;
return;
}
try r.ensureCapacity(a.len - (shift / Limb.bit_count));
const r_len = llshr(r.limbs[0..], a.limbs[0..a.len], shift);
r.len = a.len - (shift / Limb.bit_count);
r.positive = a.positive;
}
fn llshr(r: []Limb, a: []const Limb, shift: usize) void {
@setRuntimeSafety(false);
debug.assert(a.len >= 1);
debug.assert(r.len >= a.len - (shift / Limb.bit_count));
const limb_shift = shift / Limb.bit_count;
const interior_limb_shift = @intCast(Log2Limb, shift % Limb.bit_count);
var carry: Limb = 0;
var i: usize = 0;
while (i < a.len - limb_shift) : (i += 1) {
const src_i = a.len - i - 1;
const dst_i = src_i - limb_shift;
const src_digit = a[src_i];
r[dst_i] = carry | (src_digit >> interior_limb_shift);
carry = @inlineCall(math.shl, Limb, src_digit, Limb.bit_count - @intCast(Limb, interior_limb_shift));
}
}
// r = a | b
pub fn bitOr(r: *Int, a: Int, b: Int) !void {
if (a.len > b.len) {
try r.ensureCapacity(a.len);
llor(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
r.len = a.len;
} else {
try r.ensureCapacity(b.len);
llor(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
r.len = b.len;
}
}
fn llor(r: []Limb, a: []const Limb, b: []const Limb) void {
@setRuntimeSafety(false);
debug.assert(r.len >= a.len);
debug.assert(a.len >= b.len);
var i: usize = 0;
while (i < b.len) : (i += 1) {
r[i] = a[i] | b[i];
}
while (i < a.len) : (i += 1) {
r[i] = a[i];
}
}
// r = a & b
pub fn bitAnd(r: *Int, a: Int, b: Int) !void {
if (a.len > b.len) {
try r.ensureCapacity(b.len);
lland(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
r.normN(b.len);
} else {
try r.ensureCapacity(a.len);
lland(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
r.normN(a.len);
}
}
fn lland(r: []Limb, a: []const Limb, b: []const Limb) void {
@setRuntimeSafety(false);
debug.assert(r.len >= b.len);
debug.assert(a.len >= b.len);
var i: usize = 0;
while (i < b.len) : (i += 1) {
r[i] = a[i] & b[i];
}
}
// r = a ^ b
pub fn bitXor(r: *Int, a: Int, b: Int) !void {
if (a.len > b.len) {
try r.ensureCapacity(a.len);
llxor(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
r.normN(a.len);
} else {
try r.ensureCapacity(b.len);
llxor(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
r.normN(b.len);
}
}
fn llxor(r: []Limb, a: []const Limb, b: []const Limb) void {
@setRuntimeSafety(false);
debug.assert(r.len >= a.len);
debug.assert(a.len >= b.len);
var i: usize = 0;
while (i < b.len) : (i += 1) {
r[i] = a[i] ^ b[i];
}
while (i < a.len) : (i += 1) {
r[i] = a[i];
}
}
};
// NOTE: All the following tests assume the max machine-word will be 64-bit.
//
// They will still run on larger than this and should pass, but the multi-limb code-paths
// may be untested in some cases.
const u256 = @IntType(false, 256);
const al = debug.global_allocator;
test "big.int comptime_int set" {
comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab;
var a = try Int.initSet(al, s);
const s_limb_count = 128 / Limb.bit_count;
comptime var i: usize = 0;
inline while (i < s_limb_count) : (i += 1) {
const result = Limb(s & @maxValue(Limb));
s >>= Limb.bit_count / 2;
s >>= Limb.bit_count / 2;
debug.assert(a.limbs[i] == result);
}
}
test "big.int comptime_int set negative" {
var a = try Int.initSet(al, -10);
debug.assert(a.limbs[0] == 10);
debug.assert(a.positive == false);
}
test "big.int int set unaligned small" {
var a = try Int.initSet(al, u7(45));
debug.assert(a.limbs[0] == 45);
debug.assert(a.positive == true);
}
test "big.int comptime_int to" {
const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);
debug.assert((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab);
}
test "big.int sub-limb to" {
const a = try Int.initSet(al, 10);
debug.assert((try a.to(u8)) == 10);
}
test "big.int to target too small error" {
const a = try Int.initSet(al, 0xffffffff);
if (a.to(u8)) |_| {
unreachable;
} else |err| {
debug.assert(err == error.TargetTooSmall);
}
}
test "big.int norm1" {
var a = try Int.init(al);
try a.ensureCapacity(8);
a.limbs[0] = 1;
a.limbs[1] = 2;
a.limbs[2] = 3;
a.limbs[3] = 0;
a.norm1(4);
debug.assert(a.len == 3);
a.limbs[0] = 1;
a.limbs[1] = 2;
a.limbs[2] = 3;
a.norm1(3);
debug.assert(a.len == 3);
a.limbs[0] = 0;
a.limbs[1] = 0;
a.norm1(2);
debug.assert(a.len == 1);
a.limbs[0] = 0;
a.norm1(1);
debug.assert(a.len == 1);
}
test "big.int normN" {
var a = try Int.init(al);
try a.ensureCapacity(8);
a.limbs[0] = 1;
a.limbs[1] = 2;
a.limbs[2] = 0;
a.limbs[3] = 0;
a.normN(4);
debug.assert(a.len == 2);
a.limbs[0] = 1;
a.limbs[1] = 2;
a.limbs[2] = 3;
a.normN(3);
debug.assert(a.len == 3);
a.limbs[0] = 0;
a.limbs[1] = 0;
a.limbs[2] = 0;
a.limbs[3] = 0;
a.normN(4);
debug.assert(a.len == 1);
a.limbs[0] = 0;
a.normN(1);
debug.assert(a.len == 1);
}
test "big.int parity" {
var a = try Int.init(al);
try a.set(0);
debug.assert(a.isEven());
debug.assert(!a.isOdd());
try a.set(7);
debug.assert(!a.isEven());
debug.assert(a.isOdd());
}
test "big.int bitcount + sizeInBase" {
var a = try Int.init(al);
try a.set(0b100);
debug.assert(a.bitcount() == 3);
debug.assert(a.sizeInBase(2) >= 3);
debug.assert(a.sizeInBase(10) >= 1);
try a.set(0xffffffff);
debug.assert(a.bitcount() == 32);
debug.assert(a.sizeInBase(2) >= 32);
debug.assert(a.sizeInBase(10) >= 10);
try a.shiftLeft(a, 5000);
debug.assert(a.bitcount() == 5032);
debug.assert(a.sizeInBase(2) >= 5032);
a.positive = false;
debug.assert(a.bitcount() == 5033);
debug.assert(a.sizeInBase(2) >= 5033);
}
test "big.int string set" {
var a = try Int.init(al);
try a.setString(10, "120317241209124781241290847124");
debug.assert((try a.to(u128)) == 120317241209124781241290847124);
}
test "big.int string negative" {
var a = try Int.init(al);
try a.setString(10, "-1023");
debug.assert((try a.to(i32)) == -1023);
}
test "big.int string set bad char error" {
var a = try Int.init(al);
a.setString(10, "x") catch |err| debug.assert(err == error.InvalidCharForDigit);
}
test "big.int string set bad base error" {
var a = try Int.init(al);
a.setString(45, "10") catch |err| debug.assert(err == error.InvalidBase);
}
test "big.int string to" {
const a = try Int.initSet(al, 120317241209124781241290847124);
const as = try a.toString(al, 10);
const es = "120317241209124781241290847124";
debug.assert(mem.eql(u8, as, es));
}
test "big.int string to base base error" {
const a = try Int.initSet(al, 0xffffffff);
if (a.toString(al, 45)) |_| {
unreachable;
} else |err| {
debug.assert(err == error.InvalidBase);
}
}
test "big.int string to base 2" {
const a = try Int.initSet(al, -0b1011);
const as = try a.toString(al, 2);
const es = "-1011";
debug.assert(mem.eql(u8, as, es));
}
test "big.int string to base 16" {
const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);
const as = try a.toString(al, 16);
const es = "efffffff00000001eeeeeeefaaaaaaab";
debug.assert(mem.eql(u8, as, es));
}
test "big.int neg string to" {
const a = try Int.initSet(al, -123907434);
const as = try a.toString(al, 10);
const es = "-123907434";
debug.assert(mem.eql(u8, as, es));
}
test "big.int zero string to" {
const a = try Int.initSet(al, 0);
const as = try a.toString(al, 10);
const es = "0";
debug.assert(mem.eql(u8, as, es));
}
test "big.int clone" {
var a = try Int.initSet(al, 1234);
const b = try a.clone();
debug.assert((try a.to(u32)) == 1234);
debug.assert((try b.to(u32)) == 1234);
try a.set(77);
debug.assert((try a.to(u32)) == 77);
debug.assert((try b.to(u32)) == 1234);
}
test "big.int swap" {
var a = try Int.initSet(al, 1234);
var b = try Int.initSet(al, 5678);
debug.assert((try a.to(u32)) == 1234);
debug.assert((try b.to(u32)) == 5678);
a.swap(&b);
debug.assert((try a.to(u32)) == 5678);
debug.assert((try b.to(u32)) == 1234);
}
test "big.int to negative" {
var a = try Int.initSet(al, -10);
debug.assert((try a.to(i32)) == -10);
}
test "big.int compare" {
var a = try Int.initSet(al, -11);
var b = try Int.initSet(al, 10);
debug.assert(a.cmpAbs(b) == 1);
debug.assert(a.cmp(b) == -1);
}
test "big.int compare similar" {
var a = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeee);
var b = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeef);
debug.assert(a.cmpAbs(b) == -1);
debug.assert(b.cmpAbs(a) == 1);
}
test "big.int compare different limb size" {
var a = try Int.initSet(al, @maxValue(Limb) + 1);
var b = try Int.initSet(al, 1);
debug.assert(a.cmpAbs(b) == 1);
debug.assert(b.cmpAbs(a) == -1);
}
test "big.int compare multi-limb" {
var a = try Int.initSet(al, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);
var b = try Int.initSet(al, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);
debug.assert(a.cmpAbs(b) == 1);
debug.assert(a.cmp(b) == -1);
}
test "big.int equality" {
var a = try Int.initSet(al, 0xffffffff1);
var b = try Int.initSet(al, -0xffffffff1);
debug.assert(a.eqAbs(b));
debug.assert(!a.eq(b));
}
test "big.int abs" {
var a = try Int.initSet(al, -5);
a.abs();
debug.assert((try a.to(u32)) == 5);
a.abs();
debug.assert((try a.to(u32)) == 5);
}
test "big.int negate" {
var a = try Int.initSet(al, 5);
a.negate();
debug.assert((try a.to(i32)) == -5);
a.negate();
debug.assert((try a.to(i32)) == 5);
}
test "big.int add single-single" {
var a = try Int.initSet(al, 50);
var b = try Int.initSet(al, 5);
var c = try Int.init(al);
try c.add(a, b);
debug.assert((try c.to(u32)) == 55);
}
test "big.int add multi-single" {
var a = try Int.initSet(al, @maxValue(Limb) + 1);
var b = try Int.initSet(al, 1);
var c = try Int.init(al);
try c.add(a, b);
debug.assert((try c.to(DoubleLimb)) == @maxValue(Limb) + 2);
try c.add(b, a);
debug.assert((try c.to(DoubleLimb)) == @maxValue(Limb) + 2);
}
test "big.int add multi-multi" {
const op1 = 0xefefefef7f7f7f7f;
const op2 = 0xfefefefe9f9f9f9f;
var a = try Int.initSet(al, op1);
var b = try Int.initSet(al, op2);
var c = try Int.init(al);
try c.add(a, b);
debug.assert((try c.to(u128)) == op1 + op2);
}
test "big.int add zero-zero" {
var a = try Int.initSet(al, 0);
var b = try Int.initSet(al, 0);
var c = try Int.init(al);
try c.add(a, b);
debug.assert((try c.to(u32)) == 0);
}
test "big.int add alias multi-limb nonzero-zero" {
const op1 = 0xffffffff777777771;
var a = try Int.initSet(al, op1);
var b = try Int.initSet(al, 0);
try a.add(a, b);
debug.assert((try a.to(u128)) == op1);
}
test "big.int add sign" {
var a = try Int.init(al);
const one = try Int.initSet(al, 1);
const two = try Int.initSet(al, 2);
const neg_one = try Int.initSet(al, -1);
const neg_two = try Int.initSet(al, -2);
try a.add(one, two);
debug.assert((try a.to(i32)) == 3);
try a.add(neg_one, two);
debug.assert((try a.to(i32)) == 1);
try a.add(one, neg_two);
debug.assert((try a.to(i32)) == -1);
try a.add(neg_one, neg_two);
debug.assert((try a.to(i32)) == -3);
}
test "big.int sub single-single" {
var a = try Int.initSet(al, 50);
var b = try Int.initSet(al, 5);
var c = try Int.init(al);
try c.sub(a, b);
debug.assert((try c.to(u32)) == 45);
}
test "big.int sub multi-single" {
var a = try Int.initSet(al, @maxValue(Limb) + 1);
var b = try Int.initSet(al, 1);
var c = try Int.init(al);
try c.sub(a, b);
debug.assert((try c.to(Limb)) == @maxValue(Limb));
}
test "big.int sub multi-multi" {
const op1 = 0xefefefefefefefefefefefef;
const op2 = 0xabababababababababababab;
var a = try Int.initSet(al, op1);
var b = try Int.initSet(al, op2);
var c = try Int.init(al);
try c.sub(a, b);
debug.assert((try c.to(u128)) == op1 - op2);
}
test "big.int sub equal" {
var a = try Int.initSet(al, 0x11efefefefefefefefefefefef);
var b = try Int.initSet(al, 0x11efefefefefefefefefefefef);
var c = try Int.init(al);
try c.sub(a, b);
debug.assert((try c.to(u32)) == 0);
}
test "big.int sub sign" {
var a = try Int.init(al);
const one = try Int.initSet(al, 1);
const two = try Int.initSet(al, 2);
const neg_one = try Int.initSet(al, -1);
const neg_two = try Int.initSet(al, -2);
try a.sub(one, two);
debug.assert((try a.to(i32)) == -1);
try a.sub(neg_one, two);
debug.assert((try a.to(i32)) == -3);
try a.sub(one, neg_two);
debug.assert((try a.to(i32)) == 3);
try a.sub(neg_one, neg_two);
debug.assert((try a.to(i32)) == 1);
try a.sub(neg_two, neg_one);
debug.assert((try a.to(i32)) == -1);
}
test "big.int mul single-single" {
var a = try Int.initSet(al, 50);
var b = try Int.initSet(al, 5);
var c = try Int.init(al);
try c.mul(a, b);
debug.assert((try c.to(u64)) == 250);
}
test "big.int mul multi-single" {
var a = try Int.initSet(al, @maxValue(Limb));
var b = try Int.initSet(al, 2);
var c = try Int.init(al);
try c.mul(a, b);
debug.assert((try c.to(DoubleLimb)) == 2 * @maxValue(Limb));
}
test "big.int mul multi-multi" {
const op1 = 0x998888efefefefefefefef;
const op2 = 0x333000abababababababab;
var a = try Int.initSet(al, op1);
var b = try Int.initSet(al, op2);
var c = try Int.init(al);
try c.mul(a, b);
debug.assert((try c.to(u256)) == op1 * op2);
}
test "big.int mul alias r with a" {
var a = try Int.initSet(al, @maxValue(Limb));
var b = try Int.initSet(al, 2);
try a.mul(a, b);
debug.assert((try a.to(DoubleLimb)) == 2 * @maxValue(Limb));
}
test "big.int mul alias r with b" {
var a = try Int.initSet(al, @maxValue(Limb));
var b = try Int.initSet(al, 2);
try a.mul(b, a);
debug.assert((try a.to(DoubleLimb)) == 2 * @maxValue(Limb));
}
test "big.int mul alias r with a and b" {
var a = try Int.initSet(al, @maxValue(Limb));
try a.mul(a, a);
debug.assert((try a.to(DoubleLimb)) == @maxValue(Limb) * @maxValue(Limb));
}
test "big.int mul a*0" {
var a = try Int.initSet(al, 0xefefefefefefefef);
var b = try Int.initSet(al, 0);
var c = try Int.init(al);
try c.mul(a, b);
debug.assert((try c.to(u32)) == 0);
}
test "big.int mul 0*0" {
var a = try Int.initSet(al, 0);
var b = try Int.initSet(al, 0);
var c = try Int.init(al);
try c.mul(a, b);
debug.assert((try c.to(u32)) == 0);
}
test "big.int div single-single no rem" {
var a = try Int.initSet(al, 50);
var b = try Int.initSet(al, 5);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u32)) == 10);
debug.assert((try r.to(u32)) == 0);
}
test "big.int div single-single with rem" {
var a = try Int.initSet(al, 49);
var b = try Int.initSet(al, 5);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u32)) == 9);
debug.assert((try r.to(u32)) == 4);
}
test "big.int div multi-single no rem" {
const op1 = 0xffffeeeeddddcccc;
const op2 = 34;
var a = try Int.initSet(al, op1);
var b = try Int.initSet(al, op2);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u64)) == op1 / op2);
debug.assert((try r.to(u64)) == 0);
}
test "big.int div multi-single with rem" {
const op1 = 0xffffeeeeddddcccf;
const op2 = 34;
var a = try Int.initSet(al, op1);
var b = try Int.initSet(al, op2);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u64)) == op1 / op2);
debug.assert((try r.to(u64)) == 3);
}
test "big.int div multi>2-single" {
const op1 = 0xfefefefefefefefefefefefefefefefe;
const op2 = 0xefab8;
var a = try Int.initSet(al, op1);
var b = try Int.initSet(al, op2);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u128)) == op1 / op2);
debug.assert((try r.to(u32)) == 0x3e4e);
}
test "big.int div single-single q < r" {
var a = try Int.initSet(al, 0x0078f432);
var b = try Int.initSet(al, 0x01000000);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u64)) == 0);
debug.assert((try r.to(u64)) == 0x0078f432);
}
test "big.int div single-single q == r" {
var a = try Int.initSet(al, 10);
var b = try Int.initSet(al, 10);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u64)) == 1);
debug.assert((try r.to(u64)) == 0);
}
test "big.int div q=0 alias" {
var a = try Int.initSet(al, 3);
var b = try Int.initSet(al, 10);
try Int.divTrunc(&a, &b, a, b);
debug.assert((try a.to(u64)) == 0);
debug.assert((try b.to(u64)) == 3);
}
test "big.int div multi-multi q < r" {
const op1 = 0x1ffffffff0078f432;
const op2 = 0x1ffffffff01000000;
var a = try Int.initSet(al, op1);
var b = try Int.initSet(al, op2);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u128)) == 0);
debug.assert((try r.to(u128)) == op1);
}
test "big.int div trunc single-single +/+" {
const u: i32 = 5;
const v: i32 = 3;
var a = try Int.initSet(al, u);
var b = try Int.initSet(al, v);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
// n = q * d + r
// 5 = 1 * 3 + 2
const eq = @divTrunc(u, v);
const er = @mod(u, v);
debug.assert((try q.to(i32)) == eq);
debug.assert((try r.to(i32)) == er);
}
test "big.int div trunc single-single -/+" {
const u: i32 = -5;
const v: i32 = 3;
var a = try Int.initSet(al, u);
var b = try Int.initSet(al, v);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
// n = q * d + r
// -5 = 1 * -3 - 2
const eq = -1;
const er = -2;
debug.assert((try q.to(i32)) == eq);
debug.assert((try r.to(i32)) == er);
}
test "big.int div trunc single-single +/-" {
const u: i32 = 5;
const v: i32 = -3;
var a = try Int.initSet(al, u);
var b = try Int.initSet(al, v);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
// n = q * d + r
// 5 = -1 * -3 + 2
const eq = -1;
const er = 2;
debug.assert((try q.to(i32)) == eq);
debug.assert((try r.to(i32)) == er);
}
test "big.int div trunc single-single -/-" {
const u: i32 = -5;
const v: i32 = -3;
var a = try Int.initSet(al, u);
var b = try Int.initSet(al, v);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
// n = q * d + r
// -5 = 1 * -3 - 2
const eq = 1;
const er = -2;
debug.assert((try q.to(i32)) == eq);
debug.assert((try r.to(i32)) == er);
}
test "big.int div floor single-single +/+" {
const u: i32 = 5;
const v: i32 = 3;
var a = try Int.initSet(al, u);
var b = try Int.initSet(al, v);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divFloor(&q, &r, a, b);
// n = q * d + r
// 5 = 1 * 3 + 2
const eq = 1;
const er = 2;
debug.assert((try q.to(i32)) == eq);
debug.assert((try r.to(i32)) == er);
}
test "big.int div floor single-single -/+" {
const u: i32 = -5;
const v: i32 = 3;
var a = try Int.initSet(al, u);
var b = try Int.initSet(al, v);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divFloor(&q, &r, a, b);
// n = q * d + r
// -5 = -2 * 3 + 1
const eq = -2;
const er = 1;
debug.assert((try q.to(i32)) == eq);
debug.assert((try r.to(i32)) == er);
}
test "big.int div floor single-single +/-" {
const u: i32 = 5;
const v: i32 = -3;
var a = try Int.initSet(al, u);
var b = try Int.initSet(al, v);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divFloor(&q, &r, a, b);
// n = q * d + r
// 5 = -2 * -3 - 1
const eq = -2;
const er = -1;
debug.assert((try q.to(i32)) == eq);
debug.assert((try r.to(i32)) == er);
}
test "big.int div floor single-single -/-" {
const u: i32 = -5;
const v: i32 = -3;
var a = try Int.initSet(al, u);
var b = try Int.initSet(al, v);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divFloor(&q, &r, a, b);
// n = q * d + r
// -5 = 2 * -3 + 1
const eq = 1;
const er = -2;
debug.assert((try q.to(i32)) == eq);
debug.assert((try r.to(i32)) == er);
}
test "big.int div multi-multi with rem" {
var a = try Int.initSet(al, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
var b = try Int.initSet(al, 0x99990000111122223333);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
debug.assert((try r.to(u128)) == 0x28de0acacd806823638);
}
test "big.int div multi-multi no rem" {
var a = try Int.initSet(al, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
var b = try Int.initSet(al, 0x99990000111122223333);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
debug.assert((try r.to(u128)) == 0);
}
test "big.int div multi-multi (2 branch)" {
var a = try Int.initSet(al, 0x866666665555555588888887777777761111111111111111);
var b = try Int.initSet(al, 0x86666666555555554444444433333333);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u128)) == 0x10000000000000000);
debug.assert((try r.to(u128)) == 0x44444443444444431111111111111111);
}
test "big.int div multi-multi (3.1/3.3 branch)" {
var a = try Int.initSet(al, 0x11111111111111111111111111111111111111111111111111111111111111);
var b = try Int.initSet(al, 0x1111111111111111111111111111111111111111171);
var q = try Int.init(al);
var r = try Int.init(al);
try Int.divTrunc(&q, &r, a, b);
debug.assert((try q.to(u128)) == 0xfffffffffffffffffff);
debug.assert((try r.to(u256)) == 0x1111111111111111111110b12222222222222222282);
}
test "big.int shift-right single" {
var a = try Int.initSet(al, 0xffff0000);
try a.shiftRight(a, 16);
debug.assert((try a.to(u32)) == 0xffff);
}
test "big.int shift-right multi" {
var a = try Int.initSet(al, 0xffff0000eeee1111dddd2222cccc3333);
try a.shiftRight(a, 67);
debug.assert((try a.to(u64)) == 0x1fffe0001dddc222);
}
test "big.int shift-left single" {
var a = try Int.initSet(al, 0xffff);
try a.shiftLeft(a, 16);
debug.assert((try a.to(u64)) == 0xffff0000);
}
test "big.int shift-left multi" {
var a = try Int.initSet(al, 0x1fffe0001dddc222);
try a.shiftLeft(a, 67);
debug.assert((try a.to(u128)) == 0xffff0000eeee11100000000000000000);
}
test "big.int shift-right negative" {
var a = try Int.init(al);
try a.shiftRight(try Int.initSet(al, -20), 2);
debug.assert((try a.to(i32)) == -20 >> 2);
try a.shiftRight(try Int.initSet(al, -5), 10);
debug.assert((try a.to(i32)) == -5 >> 10);
}
test "big.int shift-left negative" {
var a = try Int.init(al);
try a.shiftRight(try Int.initSet(al, -10), 1232);
debug.assert((try a.to(i32)) == -10 >> 1232);
}
test "big.int bitwise and simple" {
var a = try Int.initSet(al, 0xffffffff11111111);
var b = try Int.initSet(al, 0xeeeeeeee22222222);
try a.bitAnd(a, b);
debug.assert((try a.to(u64)) == 0xeeeeeeee00000000);
}
test "big.int bitwise and multi-limb" {
var a = try Int.initSet(al, @maxValue(Limb) + 1);
var b = try Int.initSet(al, @maxValue(Limb));
try a.bitAnd(a, b);
debug.assert((try a.to(u128)) == 0);
}
test "big.int bitwise xor simple" {
var a = try Int.initSet(al, 0xffffffff11111111);
var b = try Int.initSet(al, 0xeeeeeeee22222222);
try a.bitXor(a, b);
debug.assert((try a.to(u64)) == 0x1111111133333333);
}
test "big.int bitwise xor multi-limb" {
var a = try Int.initSet(al, @maxValue(Limb) + 1);
var b = try Int.initSet(al, @maxValue(Limb));
try a.bitXor(a, b);
debug.assert((try a.to(DoubleLimb)) == (@maxValue(Limb) + 1) ^ @maxValue(Limb));
}
test "big.int bitwise or simple" {
var a = try Int.initSet(al, 0xffffffff11111111);
var b = try Int.initSet(al, 0xeeeeeeee22222222);
try a.bitOr(a, b);
debug.assert((try a.to(u64)) == 0xffffffff33333333);
}
test "big.int bitwise or multi-limb" {
var a = try Int.initSet(al, @maxValue(Limb) + 1);
var b = try Int.initSet(al, @maxValue(Limb));
try a.bitOr(a, b);
// TODO: big.int.cpp or is wrong on multi-limb.
debug.assert((try a.to(DoubleLimb)) == (@maxValue(Limb) + 1) + @maxValue(Limb));
}
test "big.int var args" {
var a = try Int.initSet(al, 5);
try a.add(a, try Int.initSet(al, 6));
debug.assert((try a.to(u64)) == 11);
debug.assert(a.cmp(try Int.initSet(al, 11)) == 0);
debug.assert(a.cmp(try Int.initSet(al, 14)) <= 0);
} | std/math/big/int.zig |
const std = @import("std");
const crypto = std.crypto;
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const Poly1305 = crypto.onetimeauth.Poly1305;
const Blake2b = crypto.hash.blake2.Blake2b;
const X25519 = crypto.dh.X25519;
const Salsa20NonVecImpl = struct {
const BlockVec = [16]u32;
fn initContext(key: [8]u32, d: [4]u32) BlockVec {
const c = "expand 32-byte k";
const constant_le = comptime [4]u32{
mem.readIntLittle(u32, c[0..4]),
mem.readIntLittle(u32, c[4..8]),
mem.readIntLittle(u32, c[8..12]),
mem.readIntLittle(u32, c[12..16]),
};
return BlockVec{
constant_le[0], key[0], key[1], key[2],
key[3], constant_le[1], d[0], d[1],
d[2], d[3], constant_le[2], key[4],
key[5], key[6], key[7], constant_le[3],
};
}
const QuarterRound = struct {
a: usize,
b: usize,
c: usize,
d: u6,
};
inline fn Rp(comptime a: usize, comptime b: usize, comptime c: usize, comptime d: u6) QuarterRound {
return QuarterRound{
.a = a,
.b = b,
.c = c,
.d = d,
};
}
inline fn salsa20Core(x: *BlockVec, input: BlockVec) void {
const arx_steps = comptime [_]QuarterRound{
Rp(4, 0, 12, 7), Rp(8, 4, 0, 9), Rp(12, 8, 4, 13), Rp(0, 12, 8, 18),
Rp(9, 5, 1, 7), Rp(13, 9, 5, 9), Rp(1, 13, 9, 13), Rp(5, 1, 13, 18),
Rp(14, 10, 6, 7), Rp(2, 14, 10, 9), Rp(6, 2, 14, 13), Rp(10, 6, 2, 18),
Rp(3, 15, 11, 7), Rp(7, 3, 15, 9), Rp(11, 7, 3, 13), Rp(15, 11, 7, 18),
Rp(1, 0, 3, 7), Rp(2, 1, 0, 9), Rp(3, 2, 1, 13), Rp(0, 3, 2, 18),
Rp(6, 5, 4, 7), Rp(7, 6, 5, 9), Rp(4, 7, 6, 13), Rp(5, 4, 7, 18),
Rp(11, 10, 9, 7), Rp(8, 11, 10, 9), Rp(9, 8, 11, 13), Rp(10, 9, 8, 18),
Rp(12, 15, 14, 7), Rp(13, 12, 15, 9), Rp(14, 13, 12, 13), Rp(15, 14, 13, 18),
};
x.* = input;
var j: usize = 0;
while (j < 20) : (j += 2) {
inline for (arx_steps) |r| {
x[r.a] ^= math.rotl(u32, x[r.b] +% x[r.c], r.d);
}
}
}
fn hashToBytes(out: *[64]u8, x: BlockVec) void {
for (x) |w, i| {
mem.writeIntLittle(u32, out[i * 4 ..][0..4], w);
}
}
fn contextFeedback(x: *BlockVec, ctx: BlockVec) void {
var i: usize = 0;
while (i < 16) : (i += 1) {
x[i] +%= ctx[i];
}
}
fn salsa20Internal(out: []u8, in: []const u8, key: [8]u32, d: [4]u32) void {
var ctx = initContext(key, d);
var x: BlockVec = undefined;
var buf: [64]u8 = undefined;
var i: usize = 0;
while (i + 64 <= in.len) : (i += 64) {
salsa20Core(x[0..], ctx);
contextFeedback(&x, ctx);
hashToBytes(buf[0..], x);
var xout = out[i..];
const xin = in[i..];
var j: usize = 0;
while (j < 64) : (j += 1) {
xout[j] = xin[j];
}
j = 0;
while (j < 64) : (j += 1) {
xout[j] ^= buf[j];
}
ctx[9] += @boolToInt(@addWithOverflow(u32, ctx[8], 1, &ctx[8]));
}
if (i < in.len) {
salsa20Core(x[0..], ctx);
contextFeedback(&x, ctx);
hashToBytes(buf[0..], x);
var xout = out[i..];
const xin = in[i..];
var j: usize = 0;
while (j < in.len % 64) : (j += 1) {
xout[j] = xin[j] ^ buf[j];
}
}
}
fn hsalsa20(input: [16]u8, key: [32]u8) [32]u8 {
var c: [4]u32 = undefined;
for (c) |_, i| {
c[i] = mem.readIntLittle(u32, input[4 * i ..][0..4]);
}
const ctx = initContext(keyToWords(key), c);
var x: BlockVec = undefined;
salsa20Core(x[0..], ctx);
var out: [32]u8 = undefined;
mem.writeIntLittle(u32, out[0..4], x[0]);
mem.writeIntLittle(u32, out[4..8], x[5]);
mem.writeIntLittle(u32, out[8..12], x[10]);
mem.writeIntLittle(u32, out[12..16], x[15]);
mem.writeIntLittle(u32, out[16..20], x[6]);
mem.writeIntLittle(u32, out[20..24], x[7]);
mem.writeIntLittle(u32, out[24..28], x[8]);
mem.writeIntLittle(u32, out[28..32], x[9]);
return out;
}
};
const Salsa20Impl = Salsa20NonVecImpl;
fn keyToWords(key: [32]u8) [8]u32 {
var k: [8]u32 = undefined;
var i: usize = 0;
while (i < 8) : (i += 1) {
k[i] = mem.readIntLittle(u32, key[i * 4 ..][0..4]);
}
return k;
}
fn extend(key: [32]u8, nonce: [24]u8) struct { key: [32]u8, nonce: [8]u8 } {
return .{
.key = Salsa20Impl.hsalsa20(nonce[0..16].*, key),
.nonce = nonce[16..24].*,
};
}
/// The Salsa20 stream cipher.
pub const Salsa20 = struct {
/// Nonce length in bytes.
pub const nonce_length = 8;
/// Key length in bytes.
pub const key_length = 32;
/// Add the output of the Salsa20 stream cipher to `in` and stores the result into `out`.
/// WARNING: This function doesn't provide authenticated encryption.
/// Using the AEAD or one of the `box` versions is usually preferred.
pub fn xor(out: []u8, in: []const u8, counter: u64, key: [key_length]u8, nonce: [nonce_length]u8) void {
debug.assert(in.len == out.len);
var d: [4]u32 = undefined;
d[0] = mem.readIntLittle(u32, nonce[0..4]);
d[1] = mem.readIntLittle(u32, nonce[4..8]);
d[2] = @truncate(u32, counter);
d[3] = @truncate(u32, counter >> 32);
Salsa20Impl.salsa20Internal(out, in, keyToWords(key), d);
}
};
/// The XSalsa20 stream cipher.
pub const XSalsa20 = struct {
/// Nonce length in bytes.
pub const nonce_length = 24;
/// Key length in bytes.
pub const key_length = 32;
/// Add the output of the XSalsa20 stream cipher to `in` and stores the result into `out`.
/// WARNING: This function doesn't provide authenticated encryption.
/// Using the AEAD or one of the `box` versions is usually preferred.
pub fn xor(out: []u8, in: []const u8, counter: u64, key: [key_length]u8, nonce: [nonce_length]u8) void {
const extended = extend(key, nonce);
Salsa20.xor(out, in, counter, extended.key, extended.nonce);
}
};
/// The XSalsa20 stream cipher, combined with the Poly1305 MAC
pub const XSalsa20Poly1305 = struct {
/// Authentication tag length in bytes.
pub const tag_length = Poly1305.mac_length;
/// Nonce length in bytes.
pub const nonce_length = XSalsa20.nonce_length;
/// Key length in bytes.
pub const key_length = XSalsa20.key_length;
/// c: ciphertext: output buffer should be of size m.len
/// tag: authentication tag: output MAC
/// m: message
/// ad: Associated Data
/// npub: public nonce
/// k: private key
pub fn encrypt(c: []u8, tag: *[tag_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8, k: [key_length]u8) void {
debug.assert(c.len == m.len);
const extended = extend(k, npub);
var block0 = [_]u8{0} ** 64;
const mlen0 = math.min(32, m.len);
mem.copy(u8, block0[32..][0..mlen0], m[0..mlen0]);
Salsa20.xor(block0[0..], block0[0..], 0, extended.key, extended.nonce);
mem.copy(u8, c[0..mlen0], block0[32..][0..mlen0]);
Salsa20.xor(c[mlen0..], m[mlen0..], 1, extended.key, extended.nonce);
var mac = Poly1305.init(block0[0..32]);
mac.update(ad);
mac.update(c);
mac.final(tag);
}
/// m: message: output buffer should be of size c.len
/// c: ciphertext
/// tag: authentication tag
/// ad: Associated Data
/// npub: public nonce
/// k: private key
pub fn decrypt(m: []u8, c: []const u8, tag: [tag_length]u8, ad: []const u8, npub: [nonce_length]u8, k: [key_length]u8) !void {
debug.assert(c.len == m.len);
const extended = extend(k, npub);
var block0 = [_]u8{0} ** 64;
const mlen0 = math.min(32, c.len);
mem.copy(u8, block0[32..][0..mlen0], c[0..mlen0]);
Salsa20.xor(block0[0..], block0[0..], 0, extended.key, extended.nonce);
var mac = Poly1305.init(block0[0..32]);
mac.update(ad);
mac.update(c);
var computedTag: [tag_length]u8 = undefined;
mac.final(&computedTag);
var acc: u8 = 0;
for (computedTag) |_, i| {
acc |= (computedTag[i] ^ tag[i]);
}
if (acc != 0) {
mem.secureZero(u8, &computedTag);
return error.AuthenticationFailed;
}
mem.copy(u8, m[0..mlen0], block0[32..][0..mlen0]);
Salsa20.xor(m[mlen0..], c[mlen0..], 1, extended.key, extended.nonce);
}
};
/// NaCl-compatible secretbox API.
///
/// A secretbox contains both an encrypted message and an authentication tag to verify that it hasn't been tampered with.
/// A secret key shared by all the recipients must be already known in order to use this API.
///
/// Nonces are 192-bit large and can safely be chosen with a random number generator.
pub const secretBox = struct {
/// Key length in bytes.
pub const key_length = XSalsa20Poly1305.key_length;
/// Nonce length in bytes.
pub const nonce_length = XSalsa20Poly1305.nonce_length;
/// Authentication tag length in bytes.
pub const tag_length = XSalsa20Poly1305.tag_length;
/// Encrypt and authenticate `m` using a nonce `npub` and a key `k`.
/// `c` must be exactly `tag_length` longer than `m`, as it will store both the ciphertext and the authentication tag.
pub fn seal(c: []u8, m: []const u8, npub: [nonce_length]u8, k: [key_length]u8) void {
debug.assert(c.len == tag_length + m.len);
XSalsa20Poly1305.encrypt(c[tag_length..], c[0..tag_length], m, "", npub, k);
}
/// Verify and decrypt `c` using a nonce `npub` and a key `k`.
/// `m` must be exactly `tag_length` smaller than `c`, as `c` includes an authentication tag in addition to the encrypted message.
pub fn open(m: []u8, c: []const u8, npub: [nonce_length]u8, k: [key_length]u8) !void {
if (c.len < tag_length) {
return error.AuthenticationFailed;
}
debug.assert(m.len == c.len - tag_length);
return XSalsa20Poly1305.decrypt(m, c[tag_length..], c[0..tag_length].*, "", npub, k);
}
};
/// NaCl-compatible box API.
///
/// A secretbox contains both an encrypted message and an authentication tag to verify that it hasn't been tampered with.
/// This construction uses public-key cryptography. A shared secret doesn't have to be known in advance by both parties.
/// Instead, a message is encrypted using a sender's secret key and a recipient's public key,
/// and is decrypted using the recipient's secret key and the sender's public key.
///
/// Nonces are 192-bit large and can safely be chosen with a random number generator.
pub const box = struct {
/// Public key length in bytes.
pub const public_length = X25519.public_length;
/// Secret key length in bytes.
pub const secret_length = X25519.secret_length;
/// Shared key length in bytes.
pub const shared_length = XSalsa20Poly1305.key_length;
/// Seed (for key pair creation) length in bytes.
pub const seed_length = X25519.seed_length;
/// Nonce length in bytes.
pub const nonce_length = XSalsa20Poly1305.nonce_length;
/// Authentication tag length in bytes.
pub const tag_length = XSalsa20Poly1305.tag_length;
/// A key pair.
pub const KeyPair = X25519.KeyPair;
/// Compute a secret suitable for `secretbox` given a recipent's public key and a sender's secret key.
pub fn createSharedSecret(public_key: [public_length]u8, secret_key: [secret_length]u8) ![shared_length]u8 {
var p: [32]u8 = undefined;
try X25519.scalarmult(&p, secret_key, public_key);
const zero = [_]u8{0} ** 16;
return Salsa20Impl.hsalsa20(zero, p);
}
/// Encrypt and authenticate a message using a recipient's public key `public_key` and a sender's `secret_key`.
pub fn seal(c: []u8, m: []const u8, npub: [nonce_length]u8, public_key: [public_length]u8, secret_key: [secret_length]u8) !void {
const shared_key = try createSharedSecret(public_key, secret_key);
return secretBox.seal(c, m, npub, shared_key);
}
/// Verify and decrypt a message using a recipient's secret key `public_key` and a sender's `public_key`.
pub fn open(m: []u8, c: []const u8, npub: [nonce_length]u8, public_key: [public_length]u8, secret_key: [secret_length]u8) !void {
const shared_key = try createSharedSecret(public_key, secret_key);
return secretBox.open(m, c, npub, shared_key);
}
};
/// libsodium-compatible sealed boxes
///
/// Sealed boxes are designed to anonymously send messages to a recipient given their public key.
/// Only the recipient can decrypt these messages, using their private key.
/// While the recipient can verify the integrity of the message, it cannot verify the identity of the sender.
///
/// A message is encrypted using an ephemeral key pair, whose secret part is destroyed right after the encryption process.
pub const sealedBox = struct {
pub const public_length = box.public_length;
pub const secret_length = box.secret_length;
pub const seed_length = box.seed_length;
pub const seal_length = box.public_length + box.tag_length;
/// A key pair.
pub const KeyPair = box.KeyPair;
fn createNonce(pk1: [public_length]u8, pk2: [public_length]u8) [box.nonce_length]u8 {
var hasher = Blake2b(box.nonce_length * 8).init(.{});
hasher.update(&pk1);
hasher.update(&pk2);
var nonce: [box.nonce_length]u8 = undefined;
hasher.final(&nonce);
return nonce;
}
/// Encrypt a message `m` for a recipient whose public key is `public_key`.
/// `c` must be `seal_length` bytes larger than `m`, so that the required metadata can be added.
pub fn seal(c: []u8, m: []const u8, public_key: [public_length]u8) !void {
debug.assert(c.len == m.len + seal_length);
var ekp = try KeyPair.create(null);
const nonce = createNonce(ekp.public_key, public_key);
mem.copy(u8, c[0..public_length], ekp.public_key[0..]);
try box.seal(c[box.public_length..], m, nonce, public_key, ekp.secret_key);
mem.secureZero(u8, ekp.secret_key[0..]);
}
/// Decrypt a message using a key pair.
/// `m` must be exactly `seal_length` bytes smaller than `c`, as `c` also includes metadata.
pub fn open(m: []u8, c: []const u8, keypair: KeyPair) !void {
if (c.len < seal_length) {
return error.AuthenticationFailed;
}
const epk = c[0..public_length];
const nonce = createNonce(epk.*, keypair.public_key);
return box.open(m, c[public_length..], nonce, epk.*, keypair.secret_key);
}
};
test "xsalsa20poly1305" {
var msg: [100]u8 = undefined;
var msg2: [msg.len]u8 = undefined;
var c: [msg.len]u8 = undefined;
var key: [XSalsa20Poly1305.key_length]u8 = undefined;
var nonce: [XSalsa20Poly1305.nonce_length]u8 = undefined;
var tag: [XSalsa20Poly1305.tag_length]u8 = undefined;
try crypto.randomBytes(&msg);
try crypto.randomBytes(&key);
try crypto.randomBytes(&nonce);
XSalsa20Poly1305.encrypt(c[0..], &tag, msg[0..], "ad", nonce, key);
try XSalsa20Poly1305.decrypt(msg2[0..], c[0..], tag, "ad", nonce, key);
}
test "xsalsa20poly1305 secretbox" {
var msg: [100]u8 = undefined;
var msg2: [msg.len]u8 = undefined;
var key: [XSalsa20Poly1305.key_length]u8 = undefined;
var nonce: [box.nonce_length]u8 = undefined;
var boxed: [msg.len + box.tag_length]u8 = undefined;
try crypto.randomBytes(&msg);
try crypto.randomBytes(&key);
try crypto.randomBytes(&nonce);
secretBox.seal(boxed[0..], msg[0..], nonce, key);
try secretBox.open(msg2[0..], boxed[0..], nonce, key);
}
test "xsalsa20poly1305 box" {
var msg: [100]u8 = undefined;
var msg2: [msg.len]u8 = undefined;
var nonce: [box.nonce_length]u8 = undefined;
var boxed: [msg.len + box.tag_length]u8 = undefined;
try crypto.randomBytes(&msg);
try crypto.randomBytes(&nonce);
var kp1 = try box.KeyPair.create(null);
var kp2 = try box.KeyPair.create(null);
try box.seal(boxed[0..], msg[0..], nonce, kp1.public_key, kp2.secret_key);
try box.open(msg2[0..], boxed[0..], nonce, kp2.public_key, kp1.secret_key);
}
test "xsalsa20poly1305 sealedbox" {
var msg: [100]u8 = undefined;
var msg2: [msg.len]u8 = undefined;
var boxed: [msg.len + sealedBox.seal_length]u8 = undefined;
try crypto.randomBytes(&msg);
var kp = try box.KeyPair.create(null);
try sealedBox.seal(boxed[0..], msg[0..], kp.public_key);
try sealedBox.open(msg2[0..], boxed[0..], kp);
} | lib/std/crypto/salsa20.zig |
const std = @import("../../std.zig");
const mem = std.mem;
const debug = std.debug;
const Vector = std.meta.Vector;
const BlockVec = Vector(2, u64);
/// A single AES block.
pub const Block = struct {
pub const block_size: usize = 16;
/// Internal representation of a block.
repr: BlockVec,
/// Convert a byte sequence into an internal representation.
pub inline fn fromBytes(bytes: *const [16]u8) Block {
const repr = mem.bytesToValue(BlockVec, bytes);
return Block{ .repr = repr };
}
/// Convert the internal representation of a block into a byte sequence.
pub inline fn toBytes(block: Block) [16]u8 {
return mem.toBytes(block.repr);
}
/// XOR the block with a byte sequence.
pub inline fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 {
const x = block.repr ^ fromBytes(bytes).repr;
return mem.toBytes(x);
}
/// Encrypt a block with a round key.
pub inline fn encrypt(block: Block, round_key: Block) Block {
return Block{
.repr = asm (
\\ vaesenc %[rk], %[in], %[out]
: [out] "=x" (-> BlockVec)
: [in] "x" (block.repr),
[rk] "x" (round_key.repr)
),
};
}
/// Encrypt a block with the last round key.
pub inline fn encryptLast(block: Block, round_key: Block) Block {
return Block{
.repr = asm (
\\ vaesenclast %[rk], %[in], %[out]
: [out] "=x" (-> BlockVec)
: [in] "x" (block.repr),
[rk] "x" (round_key.repr)
),
};
}
/// Decrypt a block with a round key.
pub inline fn decrypt(block: Block, inv_round_key: Block) Block {
return Block{
.repr = asm (
\\ vaesdec %[rk], %[in], %[out]
: [out] "=x" (-> BlockVec)
: [in] "x" (block.repr),
[rk] "x" (inv_round_key.repr)
),
};
}
/// Decrypt a block with the last round key.
pub inline fn decryptLast(block: Block, inv_round_key: Block) Block {
return Block{
.repr = asm (
\\ vaesdeclast %[rk], %[in], %[out]
: [out] "=x" (-> BlockVec)
: [in] "x" (block.repr),
[rk] "x" (inv_round_key.repr)
),
};
}
/// XOR the content of two blocks.
pub inline fn xor(block1: Block, block2: Block) Block {
return Block{ .repr = block1.repr ^ block2.repr };
}
/// Perform operations on multiple blocks in parallel.
pub const parallel = struct {
/// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
pub const optimal_parallel_blocks = 8;
/// Encrypt multiple blocks in parallel, each their own round key.
pub inline fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].encrypt(round_keys[i]);
}
return out;
}
/// Decrypt multiple blocks in parallel, each their own round key.
pub inline fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].decrypt(round_keys[i]);
}
return out;
}
/// Encrypt multple blocks in parallel with the same round key.
pub inline fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].encrypt(round_key);
}
return out;
}
/// Decrypt multple blocks in parallel with the same round key.
pub inline fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].decrypt(round_key);
}
return out;
}
/// Encrypt multple blocks in parallel with the same last round key.
pub inline fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].encryptLast(round_key);
}
return out;
}
/// Decrypt multple blocks in parallel with the same last round key.
pub inline fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
comptime var i = 0;
var out: [count]Block = undefined;
inline while (i < count) : (i += 1) {
out[i] = blocks[i].decryptLast(round_key);
}
return out;
}
};
};
fn KeySchedule(comptime AES: type) type {
std.debug.assert(AES.rounds == 10 or AES.rounds == 14);
const rounds = AES.rounds;
return struct {
const Self = @This();
round_keys: [rounds + 1]Block,
fn drc(comptime second: bool, comptime rc: u8, t: BlockVec, tx: BlockVec) BlockVec {
var s: BlockVec = undefined;
var ts: BlockVec = undefined;
return asm (
\\ vaeskeygenassist %[rc], %[t], %[s]
\\ vpslldq $4, %[tx], %[ts]
\\ vpxor %[ts], %[tx], %[r]
\\ vpslldq $8, %[r], %[ts]
\\ vpxor %[ts], %[r], %[r]
\\ vpshufd %[mask], %[s], %[ts]
\\ vpxor %[ts], %[r], %[r]
: [r] "=&x" (-> BlockVec),
[s] "=&x" (s),
[ts] "=&x" (ts)
: [rc] "n" (rc),
[t] "x" (t),
[tx] "x" (tx),
[mask] "n" (@as(u8, if (second) 0xaa else 0xff))
);
}
fn expand128(t1: *Block) Self {
var round_keys: [11]Block = undefined;
const rcs = [_]u8{ 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 };
inline for (rcs) |rc, round| {
round_keys[round] = t1.*;
t1.repr = drc(false, rc, t1.repr, t1.repr);
}
round_keys[rcs.len] = t1.*;
return Self{ .round_keys = round_keys };
}
fn expand256(t1: *Block, t2: *Block) Self {
var round_keys: [15]Block = undefined;
const rcs = [_]u8{ 1, 2, 4, 8, 16, 32 };
round_keys[0] = t1.*;
inline for (rcs) |rc, round| {
round_keys[round * 2 + 1] = t2.*;
t1.repr = drc(false, rc, t2.repr, t1.repr);
round_keys[round * 2 + 2] = t1.*;
t2.repr = drc(true, rc, t1.repr, t2.repr);
}
round_keys[rcs.len * 2 + 1] = t2.*;
t1.repr = drc(false, 64, t2.repr, t1.repr);
round_keys[rcs.len * 2 + 2] = t1.*;
return Self{ .round_keys = round_keys };
}
/// Invert the key schedule.
pub fn invert(key_schedule: Self) Self {
const round_keys = &key_schedule.round_keys;
var inv_round_keys: [rounds + 1]Block = undefined;
inv_round_keys[0] = round_keys[rounds];
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
inv_round_keys[i] = Block{
.repr = asm (
\\ vaesimc %[rk], %[inv_rk]
: [inv_rk] "=x" (-> BlockVec)
: [rk] "x" (round_keys[rounds - i].repr)
),
};
}
inv_round_keys[rounds] = round_keys[0];
return Self{ .round_keys = inv_round_keys };
}
};
}
/// A context to perform encryption using the standard AES key schedule.
pub fn AESEncryptCtx(comptime AES: type) type {
std.debug.assert(AES.key_bits == 128 or AES.key_bits == 256);
const rounds = AES.rounds;
return struct {
const Self = @This();
pub const block = AES.block;
pub const block_size = block.block_size;
key_schedule: KeySchedule(AES),
/// Create a new encryption context with the given key.
pub fn init(key: [AES.key_bits / 8]u8) Self {
var t1 = Block.fromBytes(key[0..16]);
const key_schedule = if (AES.key_bits == 128) ks: {
break :ks KeySchedule(AES).expand128(&t1);
} else ks: {
var t2 = Block.fromBytes(key[16..32]);
break :ks KeySchedule(AES).expand256(&t1, &t2);
};
return Self{
.key_schedule = key_schedule,
};
}
/// Encrypt a single block.
pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
const round_keys = ctx.key_schedule.round_keys;
var t = Block.fromBytes(src).xor(round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.encrypt(round_keys[i]);
}
t = t.encryptLast(round_keys[rounds]);
dst.* = t.toBytes();
}
/// Encrypt+XOR a single block.
pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void {
const round_keys = ctx.key_schedule.round_keys;
var t = Block.fromBytes(&counter).xor(round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.encrypt(round_keys[i]);
}
t = t.encryptLast(round_keys[rounds]);
dst.* = t.xorBytes(src);
}
/// Encrypt multiple blocks, possibly leveraging parallelization.
pub fn encryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void {
const round_keys = ctx.key_schedule.round_keys;
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xor(round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
}
i = 1;
inline while (i < count) : (i += 1) {
ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
}
j = 0;
inline while (j < count) : (j += 1) {
dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
}
}
/// Encrypt+XOR multiple blocks, possibly leveraging parallelization.
pub fn xorWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8, counters: [16 * count]u8) void {
const round_keys = ctx.key_schedule.round_keys;
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xor(round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
}
ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
j = 0;
inline while (j < count) : (j += 1) {
dst[16 * j .. 16 * j + 16].* = ts[j].xorBytes(src[16 * j .. 16 * j + 16]);
}
}
};
}
/// A context to perform decryption using the standard AES key schedule.
pub fn AESDecryptCtx(comptime AES: type) type {
std.debug.assert(AES.key_bits == 128 or AES.key_bits == 256);
const rounds = AES.rounds;
return struct {
const Self = @This();
pub const block = AES.block;
pub const block_size = block.block_size;
key_schedule: KeySchedule(AES),
/// Create a decryption context from an existing encryption context.
pub fn initFromEnc(ctx: AESEncryptCtx(AES)) Self {
return Self{
.key_schedule = ctx.key_schedule.invert(),
};
}
/// Create a new decryption context with the given key.
pub fn init(key: [AES.key_bits / 8]u8) Self {
const enc_ctx = AESEncryptCtx(AES).init(key);
return initFromEnc(enc_ctx);
}
/// Decrypt a single block.
pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
const inv_round_keys = ctx.key_schedule.round_keys;
var t = Block.fromBytes(src).xor(inv_round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.decrypt(inv_round_keys[i]);
}
t = t.decryptLast(inv_round_keys[rounds]);
dst.* = t.toBytes();
}
/// Decrypt multiple blocks, possibly leveraging parallelization.
pub fn decryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void {
const inv_round_keys = ctx.key_schedule.round_keys;
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xor(inv_round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
ts = Block.parallel.decryptWide(count, ts, inv_round_keys[i]);
}
i = 1;
inline while (i < count) : (i += 1) {
ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]);
}
j = 0;
inline while (j < count) : (j += 1) {
dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
}
}
};
}
/// AES-128 with the standard key schedule.
pub const AES128 = struct {
pub const key_bits: usize = 128;
pub const rounds = ((key_bits - 64) / 32 + 8);
pub const block = Block;
/// Create a new context for encryption.
pub fn initEnc(key: [key_bits / 8]u8) AESEncryptCtx(AES128) {
return AESEncryptCtx(AES128).init(key);
}
/// Create a new context for decryption.
pub fn initDec(key: [key_bits / 8]u8) AESDecryptCtx(AES128) {
return AESDecryptCtx(AES128).init(key);
}
};
/// AES-256 with the standard key schedule.
pub const AES256 = struct {
pub const key_bits: usize = 256;
pub const rounds = ((key_bits - 64) / 32 + 8);
pub const block = Block;
/// Create a new context for encryption.
pub fn initEnc(key: [key_bits / 8]u8) AESEncryptCtx(AES256) {
return AESEncryptCtx(AES256).init(key);
}
/// Create a new context for decryption.
pub fn initDec(key: [key_bits / 8]u8) AESDecryptCtx(AES256) {
return AESDecryptCtx(AES256).init(key);
}
}; | lib/std/crypto/aes/aesni.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const Octopus = union(enum) {
Normal: u8, // power level
Flashing: usize, // step number
};
const Octopuses = std.AutoHashMap(aoc.Coord, Octopus);
pub fn run(problem: *aoc.Problem) !aoc.Solution {
var octopuses = Octopuses.init(problem.allocator);
defer octopuses.deinit();
var coord = aoc.Coord.init(.{0, 0});
for (problem.input) |c| {
if (c == '\n') {
coord.row += 1;
coord.col = 0;
}
else {
try octopuses.putNoClobber(coord, Octopus{ .Normal = c - '0' });
coord.col += 1;
}
}
var total_flashes: usize = 0;
var step: usize = 0;
const first_step_simultaneous_flashes = blk: {
while (true) : (step += 1) {
var flashes: usize = 0;
var iter = octopuses.iterator();
while (iter.next()) |kv| {
tickOctopus(kv, step, &octopuses, &flashes);
}
if (step < 100) {
total_flashes += flashes;
}
if (flashes == 100) {
break :blk step + 1;
}
}
unreachable;
};
return problem.solution(total_flashes, first_step_simultaneous_flashes);
}
fn tickOctopus(kv_opt: ?Octopuses.Entry, step: usize, octopuses: *const Octopuses, flashes: *usize) void {
if (kv_opt == null) {
return;
}
var kv = kv_opt.?;
switch (kv.value_ptr.*) {
.Normal => |*power| {
if (power.* == 9) {
kv.value_ptr.* = Octopus{ .Flashing = step };
flashes.* += 1;
var neighbors = kv.key_ptr.neighbors(false);
while (neighbors.next()) |neighbor| {
tickOctopus(octopuses.getEntry(neighbor), step, octopuses, flashes);
}
}
else {
power.* += 1;
}
},
.Flashing => |flashing_step| {
if (flashing_step != step) {
kv.value_ptr.* = Octopus{ .Normal = 1 };
}
},
}
} | src/main/zig/2021/day11.zig |
//--------------------------------------------------------------------------------
// Section: Types (8)
//--------------------------------------------------------------------------------
pub const POINTER_FLAGS = enum(u32) {
NONE = 0,
NEW = 1,
INRANGE = 2,
INCONTACT = 4,
FIRSTBUTTON = 16,
SECONDBUTTON = 32,
THIRDBUTTON = 64,
FOURTHBUTTON = 128,
FIFTHBUTTON = 256,
PRIMARY = 8192,
CONFIDENCE = 16384,
CANCELED = 32768,
DOWN = 65536,
UPDATE = 131072,
UP = 262144,
WHEEL = 524288,
HWHEEL = 1048576,
CAPTURECHANGED = 2097152,
HASTRANSFORM = 4194304,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
NEW: u1 = 0,
INRANGE: u1 = 0,
INCONTACT: u1 = 0,
FIRSTBUTTON: u1 = 0,
SECONDBUTTON: u1 = 0,
THIRDBUTTON: u1 = 0,
FOURTHBUTTON: u1 = 0,
FIFTHBUTTON: u1 = 0,
PRIMARY: u1 = 0,
CONFIDENCE: u1 = 0,
CANCELED: u1 = 0,
DOWN: u1 = 0,
UPDATE: u1 = 0,
UP: u1 = 0,
WHEEL: u1 = 0,
HWHEEL: u1 = 0,
CAPTURECHANGED: u1 = 0,
HASTRANSFORM: u1 = 0,
}) POINTER_FLAGS {
return @intToEnum(POINTER_FLAGS,
(if (o.NONE == 1) @enumToInt(POINTER_FLAGS.NONE) else 0)
| (if (o.NEW == 1) @enumToInt(POINTER_FLAGS.NEW) else 0)
| (if (o.INRANGE == 1) @enumToInt(POINTER_FLAGS.INRANGE) else 0)
| (if (o.INCONTACT == 1) @enumToInt(POINTER_FLAGS.INCONTACT) else 0)
| (if (o.FIRSTBUTTON == 1) @enumToInt(POINTER_FLAGS.FIRSTBUTTON) else 0)
| (if (o.SECONDBUTTON == 1) @enumToInt(POINTER_FLAGS.SECONDBUTTON) else 0)
| (if (o.THIRDBUTTON == 1) @enumToInt(POINTER_FLAGS.THIRDBUTTON) else 0)
| (if (o.FOURTHBUTTON == 1) @enumToInt(POINTER_FLAGS.FOURTHBUTTON) else 0)
| (if (o.FIFTHBUTTON == 1) @enumToInt(POINTER_FLAGS.FIFTHBUTTON) else 0)
| (if (o.PRIMARY == 1) @enumToInt(POINTER_FLAGS.PRIMARY) else 0)
| (if (o.CONFIDENCE == 1) @enumToInt(POINTER_FLAGS.CONFIDENCE) else 0)
| (if (o.CANCELED == 1) @enumToInt(POINTER_FLAGS.CANCELED) else 0)
| (if (o.DOWN == 1) @enumToInt(POINTER_FLAGS.DOWN) else 0)
| (if (o.UPDATE == 1) @enumToInt(POINTER_FLAGS.UPDATE) else 0)
| (if (o.UP == 1) @enumToInt(POINTER_FLAGS.UP) else 0)
| (if (o.WHEEL == 1) @enumToInt(POINTER_FLAGS.WHEEL) else 0)
| (if (o.HWHEEL == 1) @enumToInt(POINTER_FLAGS.HWHEEL) else 0)
| (if (o.CAPTURECHANGED == 1) @enumToInt(POINTER_FLAGS.CAPTURECHANGED) else 0)
| (if (o.HASTRANSFORM == 1) @enumToInt(POINTER_FLAGS.HASTRANSFORM) else 0)
);
}
};
pub const POINTER_FLAG_NONE = POINTER_FLAGS.NONE;
pub const POINTER_FLAG_NEW = POINTER_FLAGS.NEW;
pub const POINTER_FLAG_INRANGE = POINTER_FLAGS.INRANGE;
pub const POINTER_FLAG_INCONTACT = POINTER_FLAGS.INCONTACT;
pub const POINTER_FLAG_FIRSTBUTTON = POINTER_FLAGS.FIRSTBUTTON;
pub const POINTER_FLAG_SECONDBUTTON = POINTER_FLAGS.SECONDBUTTON;
pub const POINTER_FLAG_THIRDBUTTON = POINTER_FLAGS.THIRDBUTTON;
pub const POINTER_FLAG_FOURTHBUTTON = POINTER_FLAGS.FOURTHBUTTON;
pub const POINTER_FLAG_FIFTHBUTTON = POINTER_FLAGS.FIFTHBUTTON;
pub const POINTER_FLAG_PRIMARY = POINTER_FLAGS.PRIMARY;
pub const POINTER_FLAG_CONFIDENCE = POINTER_FLAGS.CONFIDENCE;
pub const POINTER_FLAG_CANCELED = POINTER_FLAGS.CANCELED;
pub const POINTER_FLAG_DOWN = POINTER_FLAGS.DOWN;
pub const POINTER_FLAG_UPDATE = POINTER_FLAGS.UPDATE;
pub const POINTER_FLAG_UP = POINTER_FLAGS.UP;
pub const POINTER_FLAG_WHEEL = POINTER_FLAGS.WHEEL;
pub const POINTER_FLAG_HWHEEL = POINTER_FLAGS.HWHEEL;
pub const POINTER_FLAG_CAPTURECHANGED = POINTER_FLAGS.CAPTURECHANGED;
pub const POINTER_FLAG_HASTRANSFORM = POINTER_FLAGS.HASTRANSFORM;
pub const TOUCH_FEEDBACK_MODE = enum(u32) {
DEFAULT = 1,
INDIRECT = 2,
NONE = 3,
};
pub const TOUCH_FEEDBACK_DEFAULT = TOUCH_FEEDBACK_MODE.DEFAULT;
pub const TOUCH_FEEDBACK_INDIRECT = TOUCH_FEEDBACK_MODE.INDIRECT;
pub const TOUCH_FEEDBACK_NONE = TOUCH_FEEDBACK_MODE.NONE;
pub const POINTER_BUTTON_CHANGE_TYPE = enum(i32) {
NONE = 0,
FIRSTBUTTON_DOWN = 1,
FIRSTBUTTON_UP = 2,
SECONDBUTTON_DOWN = 3,
SECONDBUTTON_UP = 4,
THIRDBUTTON_DOWN = 5,
THIRDBUTTON_UP = 6,
FOURTHBUTTON_DOWN = 7,
FOURTHBUTTON_UP = 8,
FIFTHBUTTON_DOWN = 9,
FIFTHBUTTON_UP = 10,
};
pub const POINTER_CHANGE_NONE = POINTER_BUTTON_CHANGE_TYPE.NONE;
pub const POINTER_CHANGE_FIRSTBUTTON_DOWN = POINTER_BUTTON_CHANGE_TYPE.FIRSTBUTTON_DOWN;
pub const POINTER_CHANGE_FIRSTBUTTON_UP = POINTER_BUTTON_CHANGE_TYPE.FIRSTBUTTON_UP;
pub const POINTER_CHANGE_SECONDBUTTON_DOWN = POINTER_BUTTON_CHANGE_TYPE.SECONDBUTTON_DOWN;
pub const POINTER_CHANGE_SECONDBUTTON_UP = POINTER_BUTTON_CHANGE_TYPE.SECONDBUTTON_UP;
pub const POINTER_CHANGE_THIRDBUTTON_DOWN = POINTER_BUTTON_CHANGE_TYPE.THIRDBUTTON_DOWN;
pub const POINTER_CHANGE_THIRDBUTTON_UP = POINTER_BUTTON_CHANGE_TYPE.THIRDBUTTON_UP;
pub const POINTER_CHANGE_FOURTHBUTTON_DOWN = POINTER_BUTTON_CHANGE_TYPE.FOURTHBUTTON_DOWN;
pub const POINTER_CHANGE_FOURTHBUTTON_UP = POINTER_BUTTON_CHANGE_TYPE.FOURTHBUTTON_UP;
pub const POINTER_CHANGE_FIFTHBUTTON_DOWN = POINTER_BUTTON_CHANGE_TYPE.FIFTHBUTTON_DOWN;
pub const POINTER_CHANGE_FIFTHBUTTON_UP = POINTER_BUTTON_CHANGE_TYPE.FIFTHBUTTON_UP;
pub const POINTER_INFO = extern struct {
pointerType: POINTER_INPUT_TYPE,
pointerId: u32,
frameId: u32,
pointerFlags: POINTER_FLAGS,
sourceDevice: ?HANDLE,
hwndTarget: ?HWND,
ptPixelLocation: POINT,
ptHimetricLocation: POINT,
ptPixelLocationRaw: POINT,
ptHimetricLocationRaw: POINT,
dwTime: u32,
historyCount: u32,
InputData: i32,
dwKeyStates: u32,
PerformanceCount: u64,
ButtonChangeType: POINTER_BUTTON_CHANGE_TYPE,
};
pub const POINTER_TOUCH_INFO = extern struct {
pointerInfo: POINTER_INFO,
touchFlags: u32,
touchMask: u32,
rcContact: RECT,
rcContactRaw: RECT,
orientation: u32,
pressure: u32,
};
pub const POINTER_PEN_INFO = extern struct {
pointerInfo: POINTER_INFO,
penFlags: u32,
penMask: u32,
pressure: u32,
rotation: u32,
tiltX: i32,
tiltY: i32,
};
pub const INPUT_INJECTION_VALUE = extern struct {
page: u16,
usage: u16,
value: i32,
index: u16,
};
pub const INPUT_TRANSFORM = extern struct {
Anonymous: extern union {
Anonymous: extern struct {
_11: f32,
_12: f32,
_13: f32,
_14: f32,
_21: f32,
_22: f32,
_23: f32,
_24: f32,
_31: f32,
_32: f32,
_33: f32,
_34: f32,
_41: f32,
_42: f32,
_43: f32,
_44: f32,
},
m: [16]f32,
},
};
//--------------------------------------------------------------------------------
// Section: Functions (28)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetUnpredictedMessagePos(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn InitializeTouchInjection(
maxCount: u32,
dwMode: TOUCH_FEEDBACK_MODE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn InjectTouchInput(
count: u32,
contacts: [*]const POINTER_TOUCH_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerType(
pointerId: u32,
pointerType: ?*POINTER_INPUT_TYPE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerCursorId(
pointerId: u32,
cursorId: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerInfo(
pointerId: u32,
pointerInfo: ?*POINTER_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerInfoHistory(
pointerId: u32,
entriesCount: ?*u32,
pointerInfo: ?[*]POINTER_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerFrameInfo(
pointerId: u32,
pointerCount: ?*u32,
pointerInfo: ?[*]POINTER_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerFrameInfoHistory(
pointerId: u32,
entriesCount: ?*u32,
pointerCount: ?*u32,
pointerInfo: ?*POINTER_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerTouchInfo(
pointerId: u32,
touchInfo: ?*POINTER_TOUCH_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerTouchInfoHistory(
pointerId: u32,
entriesCount: ?*u32,
touchInfo: ?[*]POINTER_TOUCH_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerFrameTouchInfo(
pointerId: u32,
pointerCount: ?*u32,
touchInfo: ?[*]POINTER_TOUCH_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerFrameTouchInfoHistory(
pointerId: u32,
entriesCount: ?*u32,
pointerCount: ?*u32,
touchInfo: ?*POINTER_TOUCH_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerPenInfo(
pointerId: u32,
penInfo: ?*POINTER_PEN_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerPenInfoHistory(
pointerId: u32,
entriesCount: ?*u32,
penInfo: ?[*]POINTER_PEN_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerFramePenInfo(
pointerId: u32,
pointerCount: ?*u32,
penInfo: ?[*]POINTER_PEN_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerFramePenInfoHistory(
pointerId: u32,
entriesCount: ?*u32,
pointerCount: ?*u32,
penInfo: ?*POINTER_PEN_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn SkipPointerFrameMessages(
pointerId: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows10.0.17763'
pub extern "USER32" fn InjectSyntheticPointerInput(
device: ?HSYNTHETICPOINTERDEVICE,
pointerInfo: [*]const POINTER_TYPE_INFO,
count: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn EnableMouseInPointer(
fEnable: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn IsMouseInPointerEnabled(
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "USER32" fn GetPointerInputTransform(
pointerId: u32,
historyCount: u32,
inputTransform: [*]INPUT_TRANSFORM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerDevices(
deviceCount: ?*u32,
pointerDevices: ?[*]POINTER_DEVICE_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerDevice(
device: ?HANDLE,
pointerDevice: ?*POINTER_DEVICE_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerDeviceProperties(
device: ?HANDLE,
propertyCount: ?*u32,
pointerProperties: ?[*]POINTER_DEVICE_PROPERTY,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerDeviceRects(
device: ?HANDLE,
pointerDeviceRect: ?*RECT,
displayRect: ?*RECT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetPointerDeviceCursors(
device: ?HANDLE,
cursorCount: ?*u32,
deviceCursors: ?[*]POINTER_DEVICE_CURSOR_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "USER32" fn GetRawPointerDeviceData(
pointerId: u32,
historyCount: u32,
propertiesCount: u32,
pProperties: [*]POINTER_DEVICE_PROPERTY,
pValues: ?*i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (11)
//--------------------------------------------------------------------------------
const BOOL = @import("../../foundation.zig").BOOL;
const HANDLE = @import("../../foundation.zig").HANDLE;
const HSYNTHETICPOINTERDEVICE = @import("../../ui/controls.zig").HSYNTHETICPOINTERDEVICE;
const HWND = @import("../../foundation.zig").HWND;
const POINT = @import("../../foundation.zig").POINT;
const POINTER_DEVICE_CURSOR_INFO = @import("../../ui/controls.zig").POINTER_DEVICE_CURSOR_INFO;
const POINTER_DEVICE_INFO = @import("../../ui/controls.zig").POINTER_DEVICE_INFO;
const POINTER_DEVICE_PROPERTY = @import("../../ui/controls.zig").POINTER_DEVICE_PROPERTY;
const POINTER_INPUT_TYPE = @import("../../ui/windows_and_messaging.zig").POINTER_INPUT_TYPE;
const POINTER_TYPE_INFO = @import("../../ui/controls.zig").POINTER_TYPE_INFO;
const RECT = @import("../../foundation.zig").RECT;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/ui/input/pointer.zig |
const std = @import("std");
const print = std.debug.print;
const aro = @import("aro");
const Codegen = aro.Codegen;
const Tree = aro.Tree;
const Token = Tree.Token;
const NodeIndex = Tree.NodeIndex;
const AllocatorError = std.mem.Allocator.Error;
const predefined_macros =
\\#define EXPECT(x) _Static_assert(x, "unexpected result")
;
var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
pub fn main() !void {
const gpa = &general_purpose_allocator.allocator;
defer _ = general_purpose_allocator.deinit();
var args = try std.process.argsAlloc(gpa);
defer std.process.argsFree(gpa, args);
if (args.len != 3) {
print("expected test case directory and zig executable as only arguments\n", .{});
return error.InvalidArguments;
}
var path_buf = std.ArrayList(u8).init(gpa);
defer path_buf.deinit();
var cases = std.ArrayList(struct { start: usize, end: usize }).init(gpa);
defer cases.deinit();
// collect all cases
{
var cases_dir = try std.fs.cwd().openDir(args[1], .{ .iterate = true });
defer cases_dir.close();
var it = cases_dir.iterate();
while (try it.next()) |entry| {
if (entry.kind != .File) {
print("skipping non file entry '{s}'\n", .{entry.name});
continue;
}
const start = path_buf.items.len;
try path_buf.writer().print("{s}{c}{s}", .{ args[1], std.fs.path.sep, entry.name });
try cases.append(.{ .start = start, .end = path_buf.items.len });
}
}
var progress = std.Progress{};
const root_node = try progress.start("Test", cases.items.len);
// prepare compiler
var comp = aro.Compilation.init(gpa);
defer comp.deinit();
try comp.defineSystemIncludes();
const test_runner_macros = blk: {
const duped_path = try gpa.dupe(u8, "<test_runner>");
errdefer comp.gpa.free(duped_path);
const contents = try gpa.dupe(u8, predefined_macros);
errdefer comp.gpa.free(contents);
const source = aro.Source{
.id = @intToEnum(aro.Source.Id, comp.sources.count() + 2),
.path = duped_path,
.buf = contents,
};
try comp.sources.put(duped_path, source);
break :blk source;
};
// apparently we can't use setAstCwd without libc on windows yet
const win = @import("builtin").os.tag == .windows;
var tmp_dir = if (!win) std.testing.tmpDir(.{});
defer if (!win) tmp_dir.cleanup();
if (!win) try tmp_dir.dir.setAsCwd();
// iterate over all cases
var ok_count: u32 = 0;
var fail_count: u32 = 0;
var skip_count: u32 = 0;
for (cases.items) |range| {
const path = path_buf.items[range.start..range.end];
comp.langopts.standard = .default;
const file = comp.addSource(path) catch |err| {
fail_count += 1;
progress.log("could not add source '{s}': {s}\n", .{ path, @errorName(err) });
continue;
};
defer {
_ = comp.sources.swapRemove(path);
gpa.free(file.path);
gpa.free(file.buf);
}
if (std.mem.startsWith(u8, file.buf, "//std=")) {
const suffix = file.buf["//std=".len..];
var it = std.mem.tokenize(u8, suffix, " \r\n");
if (it.next()) |standard| {
try comp.langopts.setStandard(standard);
}
}
const builtin_macros = try comp.generateBuiltinMacros();
defer {
_ = comp.sources.swapRemove(builtin_macros.path);
gpa.free(builtin_macros.path);
gpa.free(builtin_macros.buf);
}
const case = std.mem.sliceTo(std.fs.path.basename(path), '.');
var case_node = root_node.start(case, 0);
case_node.activate();
defer case_node.end();
progress.refresh();
comp.diag.errors = 0;
var pp = aro.Preprocessor.init(&comp);
defer pp.deinit();
try pp.preprocess(builtin_macros);
try pp.preprocess(test_runner_macros);
pp.preprocess(file) catch |err| {
fail_count += 1;
progress.log("could not preprocess file '{s}': {s}\n", .{ path, @errorName(err) });
continue;
};
try pp.tokens.append(pp.comp.gpa, .{
.id = .eof,
.loc = .{ .id = file.id, .byte_offset = @intCast(u32, file.buf.len) },
});
if (pp.defines.get("TESTS_SKIPPED")) |macro| {
if (macro != .simple or macro.simple.tokens.len != 1 or macro.simple.tokens[0].id != .integer_literal) {
fail_count += 1;
progress.log("invalid TESTS_SKIPPED, definition should contain exactly one integer literal {}\n", .{macro});
continue;
}
const tok_slice = pp.tokSliceSafe(macro.simple.tokens[0]);
const tests_skipped = try std.fmt.parseInt(u32, tok_slice, 0);
progress.log("{d} test{s} skipped\n", .{ tests_skipped, if (tests_skipped == 1) @as([]const u8, "") else "s" });
skip_count += tests_skipped;
}
if (pp.defines.get("EXPECTED_TOKENS")) |macro| {
comp.renderErrors();
const expected_tokens = switch (macro) {
.simple => |simple| simple.tokens,
.empty => &[_]aro.Tokenizer.Token{},
else => {
fail_count += 1;
progress.log("invalid EXPECTED_TOKENS {}\n", .{macro});
continue;
},
};
if (pp.tokens.len - 1 != expected_tokens.len) {
fail_count += 1;
progress.log(
"EXPECTED_TOKENS count differs: expected {d} found {d}\n",
.{ expected_tokens.len, pp.tokens.len - 1 },
);
continue;
}
var i: usize = 0;
while (true) : (i += 1) {
const tok = pp.tokens.get(i);
if (tok.id == .eof) {
if (comp.diag.errors != 0) fail_count += 1 else ok_count += 1;
break;
}
const expected = pp.tokSliceSafe(expected_tokens[i]);
const actual = pp.expandedSlice(tok);
if (!std.mem.eql(u8, expected, actual)) {
fail_count += 1;
progress.log(
"unexpected token found: expected '{s}' found '{s}'\n",
.{ expected, actual },
);
break;
}
}
continue;
}
const expected_types = pp.defines.get("EXPECTED_TYPES");
if (expected_types) |_| pp.comp.diag.options.@"unused-value" = .off;
defer pp.comp.diag.options.@"unused-value" = .warning;
var tree = try aro.Parser.parse(&pp);
defer tree.deinit();
tree.dump(std.io.null_writer) catch {};
if (expected_types) |types| {
const test_fn = for (tree.root_decls) |decl| {
if (tree.nodes.items(.tag)[@enumToInt(decl)] == .fn_def) break tree.nodes.items(.data)[@enumToInt(decl)];
} else {
fail_count += 1;
progress.log("EXPECTED_TYPES requires a function to be defined\n", .{});
break;
};
var actual = StmtTypeDumper.init(gpa);
defer actual.deinit(gpa);
try actual.dump(&tree, test_fn.decl.node, gpa);
if (types.simple.tokens.len != actual.types.items.len) {
fail_count += 1;
progress.log("EXPECTED_TYPES count of {d} does not match function statement length of {d}\n", .{
types.simple.tokens.len,
actual.types.items.len,
});
break;
}
for (types.simple.tokens) |str, i| {
if (str.id != .string_literal) {
fail_count += 1;
progress.log("EXPECTED_TYPES tokens must be string literals (found {s})\n", .{@tagName(str.id)});
break;
}
const expected_type = std.mem.trim(u8, pp.tokSliceSafe(str), "\"");
const actual_type = actual.types.items[i];
if (!std.mem.eql(u8, expected_type, actual_type)) {
fail_count += 1;
progress.log("expected type '{s}' did not match actual type '{s}'\n", .{
expected_type,
actual_type,
});
break;
}
}
}
if (pp.defines.get("EXPECTED_ERRORS")) |macro| {
const expected_count = comp.diag.list.items.len;
var m = MsgWriter.init(gpa);
defer m.deinit();
aro.Diagnostics.renderExtra(&comp, &m);
if (macro != .simple) {
fail_count += 1;
progress.log("invalid EXPECTED_ERRORS {}\n", .{macro});
continue;
}
if (macro.simple.tokens.len != expected_count) {
fail_count += 1;
progress.log(
\\EXPECTED_ERRORS missing errors, expected {d} found {d},
\\=== actual output ===
\\{s}
\\
\\
, .{ macro.simple.tokens.len, expected_count, m.buf.items });
continue;
}
for (macro.simple.tokens) |str| {
if (str.id != .string_literal) {
fail_count += 1;
progress.log("EXPECTED_ERRORS tokens must be string literals (found {s})\n", .{@tagName(str.id)});
break;
}
const start = path_buf.items.len;
defer path_buf.items.len = start;
// realistically the strings will only contain \" if any escapes so we can use Zig's string parsing
std.debug.assert((try std.zig.string_literal.parseAppend(&path_buf, pp.tokSliceSafe(str))) == .success);
const expected_error = path_buf.items[start..];
const index = std.mem.indexOf(u8, m.buf.items, expected_error);
if (index == null or m.buf.items[index.? + expected_error.len] != '\n') {
fail_count += 1;
progress.log(
\\
\\======= expected to find error =======
\\{s}
\\
\\=== but output does not contain it ===
\\{s}
\\
\\
, .{ expected_error, m.buf.items });
break;
}
} else ok_count += 1;
continue;
}
comp.renderErrors();
if (pp.defines.get("EXPECTED_OUTPUT")) |macro| blk: {
if (comp.diag.errors != 0) break :blk;
if (macro != .simple) {
fail_count += 1;
progress.log("invalid EXPECTED_OUTPUT {}\n", .{macro});
continue;
}
if (macro.simple.tokens.len != 1 or macro.simple.tokens[0].id != .string_literal) {
fail_count += 1;
progress.log("EXPECTED_OUTPUT takes exactly one string", .{});
continue;
}
const start = path_buf.items.len;
defer path_buf.items.len = start;
// realistically the strings will only contain \" if any escapes so we can use Zig's string parsing
std.debug.assert((try std.zig.string_literal.parseAppend(&path_buf, pp.tokSliceSafe(macro.simple.tokens[0]))) == .success);
const expected_output = path_buf.items[start..];
const obj_name = "test_object.o";
{
const obj = try Codegen.generateTree(&comp, tree);
defer obj.deinit();
const out_file = try std.fs.cwd().createFile(obj_name, .{});
defer out_file.close();
try obj.finish(out_file);
}
var child = try std.ChildProcess.init(&.{ args[2], "run", "-lc", obj_name }, comp.gpa);
defer child.deinit();
child.stdout_behavior = .Pipe;
try child.spawn();
const stdout = try child.stdout.?.reader().readAllAlloc(comp.gpa, std.math.maxInt(u16));
defer comp.gpa.free(stdout);
switch (try child.wait()) {
.Exited => |code| if (code != 0) {
fail_count += 1;
continue;
},
else => {
fail_count += 1;
continue;
},
}
if (!std.mem.eql(u8, expected_output, stdout)) {
fail_count += 1;
progress.log(
\\
\\======= expected output =======
\\{s}
\\
\\=== but output does not contain it ===
\\{s}
\\
\\
, .{ expected_output, stdout });
break;
}
ok_count += 1;
continue;
}
if (comp.diag.errors != 0) fail_count += 1 else ok_count += 1;
}
root_node.end();
if (ok_count == cases.items.len and skip_count == 0) {
print("All {d} tests passed.\n", .{ok_count});
} else if (fail_count == 0) {
print("{d} passed; {d} skipped.\n", .{ ok_count, skip_count });
} else {
print("{d} passed; {d} failed.\n\n", .{ ok_count, fail_count });
std.process.exit(1);
}
}
const MsgWriter = struct {
buf: std.ArrayList(u8),
fn init(gpa: *std.mem.Allocator) MsgWriter {
return .{
.buf = std.ArrayList(u8).init(gpa),
};
}
fn deinit(m: *MsgWriter) void {
m.buf.deinit();
}
pub fn print(m: *MsgWriter, comptime fmt: []const u8, args: anytype) void {
m.buf.writer().print(fmt, args) catch {};
}
pub fn write(m: *MsgWriter, msg: []const u8) void {
m.buf.writer().writeAll(msg) catch {};
}
pub fn location(m: *MsgWriter, path: []const u8, lcs: aro.Source.LCS) void {
m.print("{s}:{d}:{d}: ", .{ path, lcs.line, lcs.col });
}
pub fn start(m: *MsgWriter, kind: aro.Diagnostics.Kind) void {
m.print("{s}: ", .{@tagName(kind)});
}
pub fn end(m: *MsgWriter, lcs: ?aro.Source.LCS) void {
if (lcs == null) {
m.write("\n");
return;
}
m.print("\n{s}\n", .{lcs.?.str});
m.print("{s: >[1]}^\n", .{ "", lcs.?.col - 1 });
}
};
const StmtTypeDumper = struct {
types: std.ArrayList([]const u8),
fn deinit(self: *StmtTypeDumper, allocator: *std.mem.Allocator) void {
for (self.types.items) |t| {
allocator.free(t);
}
self.types.deinit();
}
fn init(allocator: *std.mem.Allocator) StmtTypeDumper {
return .{
.types = std.ArrayList([]const u8).init(allocator),
};
}
fn dumpNode(self: *StmtTypeDumper, tree: *const aro.Tree, node: NodeIndex, m: *MsgWriter) AllocatorError!void {
if (node == .none) return;
const tag = tree.nodes.items(.tag)[@enumToInt(node)];
if (tag == .implicit_return) return;
const ty = tree.nodes.items(.ty)[@enumToInt(node)];
ty.dump(m.buf.writer()) catch {};
try self.types.append(m.buf.toOwnedSlice());
}
fn dump(self: *StmtTypeDumper, tree: *const aro.Tree, decl_idx: NodeIndex, allocator: *std.mem.Allocator) AllocatorError!void {
var m = MsgWriter.init(allocator);
defer m.deinit();
const idx = @enumToInt(decl_idx);
const tag = tree.nodes.items(.tag)[idx];
const data = tree.nodes.items(.data)[idx];
switch (tag) {
.compound_stmt_two => {
try self.dumpNode(tree, data.bin.lhs, &m);
try self.dumpNode(tree, data.bin.rhs, &m);
},
.compound_stmt => {
for (tree.data[data.range.start..data.range.end]) |stmt| {
try self.dumpNode(tree, stmt, &m);
}
},
else => unreachable,
}
}
}; | test/runner.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = true;
const with_dissassemble = false;
const assert = std.debug.assert;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const Map = tools.Map(u8, 5, 5, false);
const Vec2 = tools.Vec2;
fn dostep(grid: Map) Map {
var new = Map{ .default_tile = 0 };
var p = grid.bbox.min;
while (p.y <= grid.bbox.max.y) : (p.y += 1) {
p.x = grid.bbox.min.x;
while (p.x <= grid.bbox.max.x) : (p.x += 1) {
const neighbours = [_]Vec2{ Vec2{ .x = -1, .y = 0 }, Vec2{ .x = 1, .y = 0 }, Vec2{ .x = 0, .y = -1 }, Vec2{ .x = 0, .y = 1 } };
var nbneib: u32 = 0;
for (neighbours) |n| {
const g = grid.get(Vec2{ .x = p.x + n.x, .y = p.y + n.y }) orelse '.';
if (g == '#')
nbneib += 1;
}
const g = grid.at(p);
if (g == '#' and nbneib != 1) {
new.set(p, '.');
} else if (g == '.' and (nbneib == 1 or nbneib == 2)) {
new.set(p, '#');
} else {
new.set(p, g);
}
}
}
return new;
}
pub fn main() anyerror!void {
const stdout = std.io.getStdOut().writer();
const allocator = &std.heap.ArenaAllocator.init(std.heap.page_allocator).allocator;
const limit = 1 * 1024 * 1024 * 1024;
const text =
\\ ..###
\\ .####
\\ ...#.
\\ .#..#
\\ #.###
;
const text0 =
\\ ....#
\\ #..#.
\\ #..##
\\ ..#..
\\ #....
;
var grid = Map{ .default_tile = 0 };
var i: u32 = 0;
for (text) |c| {
if (c == '.' or c == '#') {
const p = Vec2{ .x = @intCast(i32, i % 5), .y = @intCast(i32, i / 5) };
grid.set(p, c);
i += 1;
}
}
var buf: [5000]u8 = undefined;
trace("map= \n{}\n", .{grid.printToBuf(Vec2{ .x = -1, .y = -1 }, null, &buf)});
var visited = std.AutoHashMap(Map, bool).init(allocator);
_ = try visited.put(grid, true);
while (true) {
grid = dostep(grid);
trace("map= \n{}\n", .{grid.printToBuf(Vec2{ .x = -1, .y = -1 }, null, &buf)});
if (try visited.put(grid, true)) |_| {
trace("repeat!\n", .{});
const biodiversity = blk: {
var b: u25 = 0;
var sq: u32 = 1;
for (grid.map) |m| {
if (m == '#')
b += @intCast(u25, sq);
sq *= 2;
}
break :blk b;
};
trace("biodiversity = {}\n", .{biodiversity});
break;
}
}
} | 2019/day24a.zig |
const std = @import("std");
const with_trace = true;
const assert = std.debug.assert;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const Opcode = enum {
hlf,
tpl,
inc,
jmp,
jie,
jio,
};
const Instruction = struct {
op: Opcode,
reg: u1,
off: i32,
};
fn parse_line(line: []const u8) Instruction {
var insn: Instruction = undefined;
var it = std.mem.tokenize(u8, line, " ,");
if (it.next()) |opcode| {
if (std.mem.eql(u8, opcode, "hlf")) insn.op = .hlf;
if (std.mem.eql(u8, opcode, "tpl")) insn.op = .tpl;
if (std.mem.eql(u8, opcode, "inc")) insn.op = .inc;
if (std.mem.eql(u8, opcode, "jmp")) insn.op = .jmp;
if (std.mem.eql(u8, opcode, "jie")) insn.op = .jie;
if (std.mem.eql(u8, opcode, "jio")) insn.op = .jio;
}
if (insn.op != .jmp) {
if (it.next()) |register| {
insn.reg = if (register[0] == 'a') 0 else 1;
}
}
if (insn.op == .jmp or insn.op == .jie or insn.op == .jio) {
if (it.next()) |offset| {
insn.off = std.fmt.parseInt(i32, offset, 10) catch unreachable;
}
}
return insn;
}
pub fn main() anyerror!void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
const limit = 1 * 1024 * 1024 * 1024;
const text = try std.fs.cwd().readFileAlloc(allocator, "day23.txt", limit);
var program_storage: [500]Instruction = undefined;
var program_size: u32 = 0;
var it = std.mem.tokenize(u8, text, "\n");
while (it.next()) |line| {
if (line.len == 0)
continue;
program_storage[program_size] = parse_line(line);
trace("{}\n", program_storage[program_size]);
program_size += 1;
}
const program = program_storage[0..program_size];
var regs = [2]u64{ 1, 0 };
var pc: i32 = 0;
while (true) {
if (pc < 0 or @intCast(u32, pc) >= program_size)
break;
const insn = program[@intCast(usize, pc)];
// trace(" [{}] (a={}, b={}) \t{}\n", pc, regs[0], regs[1], insn);
switch (insn.op) {
.hlf => {
regs[insn.reg] /= 2;
pc += 1;
},
.tpl => {
regs[insn.reg] *= 3;
pc += 1;
},
.inc => {
regs[insn.reg] += 1;
pc += 1;
},
.jmp => {
pc += insn.off;
},
.jie => {
if (regs[insn.reg] % 2 == 0) {
pc += insn.off;
} else {
pc += 1;
}
},
.jio => {
if (regs[insn.reg] == 1) {
pc += insn.off;
} else {
pc += 1;
}
},
}
}
const out = std.io.getStdOut().writer();
try out.print("regs: a={} b={}\n", regs[0], regs[1]);
// return error.SolutionNotFound;
} | 2015/day23.zig |
const std = @import("std");
const builtin = @import("builtin");
pub fn Serializer(comptime Writer: type, endian: std.builtin.Endian) type {
return struct {
writer: std.io.CountingWriter(Writer),
const Self = @This();
pub fn serialize(self: *Self, value: anytype) !void {
const T = @TypeOf(value);
const writer = self.writer.writer();
switch (T) {
u8 => {
try writer.writeByte(value);
},
bool => {
try self.alignForward(4);
try writer.writeInt(u32, @boolToInt(value), endian);
},
i16, u16, i32, u32, i64, u64 => {
try self.alignForward(@sizeOf(T));
try writer.writeInt(T, value, endian);
},
f64 => {
try self.alignForward(8);
if (endian == builtin.target.cpu.arch.endian()) {
try writer.writeAll(std.mem.asBytes(&value));
} else {
var bytes = std.mem.toBytes(value);
std.mem.reverse(u8, &bytes);
try writer.writeAll(&bytes);
}
},
[]const u8 => {
try self.alignForward(4);
try writer.writeInt(u32, @intCast(u32, value.len), endian);
try writer.writeAll(value);
try writer.writeAll(&[_]u8{0});
},
else => {
// Not a primitive type; assume it has a serialize method
value.serialize(self);
},
}
}
pub fn writeAll(self: *Self, bytes: []const u8) !void {
const writer = self.writer.writer();
try writer.writeAll(bytes);
}
pub fn alignForward(self: *Self, alignment: usize) !void {
var align_bytes = std.mem.alignForward(self.writer.bytes_written, alignment) - self.writer.bytes_written;
const writer = self.writer.writer();
while (align_bytes != 0) : (align_bytes -= 1) {
try writer.writeByte(0);
}
}
};
}
pub fn serializer(writer: anytype, comptime endian: std.builtin.Endian) Serializer(@TypeOf(writer), endian) {
return .{ .writer = std.io.countingWriter(writer) };
}
test "serialize" {
try testSerialize(.Little);
try testSerialize(.Big);
}
fn testSerialize(comptime endian: std.builtin.Endian) !void {
var out_buffer: [1024]u8 = undefined;
var stream = std.io.fixedBufferStream(&out_buffer);
var ser = serializer(stream.writer(), endian);
const false_value = "\x00\x00\x00\x00";
const true_value = switch (endian) {
.Little => "\x01\x00\x00\x00",
.Big => "\x00\x00\x00\x01",
};
stream.reset();
ser.writer.bytes_written = 0;
try ser.serialize(false);
try std.testing.expectEqual(@as(usize, 4), ser.writer.bytes_written);
try std.testing.expectEqualSlices(u8, false_value, stream.getWritten());
stream.reset();
ser.writer.bytes_written = 0;
try ser.serialize(true);
try std.testing.expectEqual(@as(usize, 4), ser.writer.bytes_written);
try std.testing.expectEqualSlices(u8, true_value, stream.getWritten());
stream.reset();
ser.writer.bytes_written = 1;
try ser.serialize(false);
try std.testing.expectEqual(@as(usize, 8), ser.writer.bytes_written);
try std.testing.expectEqualSlices(u8, "\x00" ** 3 ++ false_value, stream.getWritten());
stream.reset();
ser.writer.bytes_written = 1;
try ser.serialize(true);
try std.testing.expectEqual(@as(usize, 8), ser.writer.bytes_written);
try std.testing.expectEqualSlices(u8, "\x00" ** 3 ++ true_value, stream.getWritten());
const u16_value = switch (endian) {
.Little => "\x34\x12",
.Big => "\x12\x34",
};
stream.reset();
ser.writer.bytes_written = 0;
try ser.serialize(@as(u16, 0x1234));
try std.testing.expectEqual(@as(usize, 2), ser.writer.bytes_written);
try std.testing.expectEqualSlices(u8, u16_value, stream.getWritten());
stream.reset();
ser.writer.bytes_written = 1;
try ser.serialize(@as(u16, 0x1234));
try std.testing.expectEqual(@as(usize, 4), ser.writer.bytes_written);
try std.testing.expectEqualSlices(u8, "\x00" ++ u16_value, stream.getWritten());
const float_value = switch (endian) {
.Little => "\x00\x00\x00\x00\x00\x00\xf0\x3f",
.Big => "\x3f\xf0\x00\x00\x00\x00\x00\x00",
};
stream.reset();
ser.writer.bytes_written = 0;
try ser.serialize(@as(f64, 1.0));
try std.testing.expectEqual(@as(usize, 8), ser.writer.bytes_written);
try std.testing.expectEqualSlices(u8, float_value, stream.getWritten());
stream.reset();
ser.writer.bytes_written = 1;
try ser.serialize(@as(f64, 1.0));
try std.testing.expectEqual(@as(usize, 16), ser.writer.bytes_written);
try std.testing.expectEqualSlices(u8, "\x00" ** 7 ++ float_value, stream.getWritten());
} | src/serializer.zig |
const std = @import("std");
const mem = std.mem;
const field_size = [32]u8{
0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, // 2^252+27742317777372353535851937790883648493
};
const ScalarExpanded = struct {
limbs: [64]i64 = [_]i64{0} ** 64,
fn fromBytes(s: [32]u8) ScalarExpanded {
var limbs: [64]i64 = undefined;
for (s) |x, idx| {
limbs[idx] = @as(i64, x);
}
mem.set(i64, limbs[32..], 0);
return .{ .limbs = limbs };
}
fn fromBytes64(s: [64]u8) ScalarExpanded {
var limbs: [64]i64 = undefined;
for (s) |x, idx| {
limbs[idx] = @as(i64, x);
}
return .{ .limbs = limbs };
}
fn reduce(e: *ScalarExpanded) void {
const limbs = &e.limbs;
var carry: i64 = undefined;
var i: usize = 63;
while (i >= 32) : (i -= 1) {
carry = 0;
const k = i - 12;
const xi = limbs[i];
var j = i - 32;
while (j < k) : (j += 1) {
const xj = limbs[j] + carry - 16 * xi * @as(i64, field_size[j - (i - 32)]);
carry = (xj + 128) >> 8;
limbs[j] = xj - carry * 256;
}
limbs[k] += carry;
limbs[i] = 0;
}
carry = 0;
comptime var j: usize = 0;
inline while (j < 32) : (j += 1) {
const xi = limbs[j] + carry - (limbs[31] >> 4) * @as(i64, field_size[j]);
carry = xi >> 8;
limbs[j] = xi & 255;
}
j = 0;
inline while (j < 32) : (j += 1) {
limbs[j] -= carry * @as(i64, field_size[j]);
}
j = 0;
inline while (j < 32) : (j += 1) {
limbs[j + 1] += limbs[j] >> 8;
}
}
fn toBytes(e: *ScalarExpanded) [32]u8 {
e.reduce();
var r: [32]u8 = undefined;
var i: usize = 0;
while (i < 32) : (i += 1) {
r[i] = @intCast(u8, e.limbs[i]);
}
return r;
}
fn add(a: ScalarExpanded, b: ScalarExpanded) ScalarExpanded {
var r = ScalarExpanded{};
comptime var i = 0;
inline while (i < 64) : (i += 1) {
r.limbs[i] = a.limbs[i] + b.limbs[i];
}
return r;
}
fn mul(a: ScalarExpanded, b: ScalarExpanded) ScalarExpanded {
var r = ScalarExpanded{};
var i: usize = 0;
while (i < 32) : (i += 1) {
const ai = a.limbs[i];
comptime var j = 0;
inline while (j < 32) : (j += 1) {
r.limbs[i + j] += ai * b.limbs[j];
}
}
r.reduce();
return r;
}
fn sq(a: ScalarExpanded) ScalarExpanded {
return a.mul(a);
}
fn mulAdd(a: ScalarExpanded, b: ScalarExpanded, c: ScalarExpanded) ScalarExpanded {
var r: ScalarExpanded = .{ .limbs = c.limbs };
var i: usize = 0;
while (i < 32) : (i += 1) {
const ai = a.limbs[i];
comptime var j = 0;
inline while (j < 32) : (j += 1) {
r.limbs[i + j] += ai * b.limbs[j];
}
}
r.reduce();
return r;
}
};
/// Reject a scalar whose encoding is not canonical.
pub fn rejectNonCanonical(s: [32]u8) !void {
var c: u8 = 0;
var n: u8 = 1;
var i: usize = 31;
while (true) : (i -= 1) {
const xs = @as(u16, s[i]);
const xfield_size = @as(u16, field_size[i]);
c |= @intCast(u8, ((xs -% xfield_size) >> 8) & n);
n &= @intCast(u8, ((xs ^ xfield_size) -% 1) >> 8);
if (i == 0) break;
}
if (c == 0) {
return error.NonCanonical;
}
}
/// Reduce a scalar to the field size.
pub fn reduce(s: [32]u8) [32]u8 {
return ScalarExpanded.fromBytes(s).toBytes();
}
/// Reduce a 64-bytes scalar to the field size.
pub fn reduce64(s: [64]u8) [32]u8 {
return ScalarExpanded.fromBytes64(s).toBytes();
}
/// Perform the X25519 "clamping" operation.
/// The scalar is then guaranteed to be a multiple of the cofactor.
pub inline fn clamp(s: *[32]u8) void {
s[0] &= 248;
s[31] = (s[31] & 127) | 64;
}
/// Return a*b+c (mod L)
pub fn mulAdd(a: [32]u8, b: [32]u8, c: [32]u8) [32]u8 {
return ScalarExpanded.fromBytes(a).mulAdd(ScalarExpanded.fromBytes(b), ScalarExpanded.fromBytes(c)).toBytes();
}
test "scalar25519" {
const bytes: [32]u8 = .{ 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 255 };
var x = ScalarExpanded.fromBytes(bytes);
var y = x.toBytes();
try rejectNonCanonical(y);
var buf: [128]u8 = undefined;
std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{X}", .{y}), "1E979B917937F3DE71D18077F961F6CEFF01030405060708010203040506070F");
const reduced = reduce(field_size);
std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{X}", .{reduced}), "0000000000000000000000000000000000000000000000000000000000000000");
}
test "non-canonical scalar25519" {
const too_targe: [32]u8 = .{ 0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 };
std.testing.expectError(error.NonCanonical, rejectNonCanonical(too_targe));
}
test "mulAdd overflow check" {
const a: [32]u8 = [_]u8{0xff} ** 32;
const b: [32]u8 = [_]u8{0xff} ** 32;
const c: [32]u8 = [_]u8{0xff} ** 32;
const x = mulAdd(a, b, c);
var buf: [128]u8 = undefined;
std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{X}", .{x}), "D14DF91389432C25AD60FF9791B9FD1D67BEF517D273ECCE3D9A307C1B419903");
} | lib/std/crypto/25519/scalar.zig |
const std = @import("std");
const ziglet = @import("../ziglet.zig");
const util = @import("util.zig");
const mem = std.mem;
pub const Event = union(enum) {
KeyDown: Key,
KeyUp: Key,
Char: u8,
MouseDown: MouseButton,
MouseUp: MouseButton,
MouseScroll: [2]f32,
MouseMove: [2]f32,
MouseEnter: void,
MouseLeave: void,
Resized: [2]i32,
Iconified: void,
Restored: void,
// FileDroppped: []const u8,
};
pub const EventPump = util.RingBuffer(Event);
pub const MouseButton = enum {
Left,
Right,
Middle,
};
pub const Key = enum {
Unknown,
Space,
Apostrophe,
Comma,
Minus,
Period,
Slash,
Key0,
Key1,
Key2,
Key3,
Key4,
Key5,
Key6,
Key7,
Key8,
Key9,
Semicolon,
Equal,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
LeftBracket,
Backslash,
RightBracket,
Backquote,
World1,
World2,
Escape,
Enter,
Tab,
Backspace,
Insert,
Delete,
Right,
Left,
Down,
Up,
PageUp,
PageDown,
Home,
End,
CapsLock,
ScrollLock,
NumLock,
PrintScreen,
Pause,
F1,
F2,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
F10,
F11,
F12,
F13,
F14,
F15,
F16,
F17,
F18,
F19,
F20,
F21,
F22,
F23,
F24,
F25,
Kp0,
Kp1,
Kp2,
Kp3,
Kp4,
Kp5,
Kp6,
Kp7,
Kp8,
Kp9,
KpDecimal,
KpDivide,
KpMultiply,
KpSubtract,
KpAdd,
KpEnter,
KpEqual,
LeftShift,
LeftControl,
LeftAlt,
LeftSuper,
RightShift,
RightControl,
RightAlt,
RightSuper,
Menu,
};
const Keyboard = struct {
prev_time: u64,
delta_time: f32,
keys: [512]bool,
keys_down_duration: [512]f32,
key_repeat_delay: f32,
key_repeat_rate: f32,
pub fn new() Keyboard {
return Keyboard{
.prev_time = 0,
.delta_time = 0,
.keys = []bool{false} ** 512,
.keys_down_duration = []f32{-1.0} ** 512,
.key_repeat_delay = 0.0,
.key_repeat_rate = 0.0,
};
}
pub fn update(self: *Keyboard) void {
const current_time = std.os.time.timestamp();
const delta_time = @intToFloat(f32, current_time - self.prev_time);
self.prev_time = current_time;
self.delta_time = delta_time;
for (self.keys_down_duration) |*key, idx| {
if (self.keys[idx]) {
if (key.* < 0.0) {
key.* = 0.0;
} else {
key.* += delta_time;
}
} else {
key.* = -1.0;
}
}
}
pub inline fn set_key(self: *Keyboard, key: Key, state: bool) void {
self.keys[@enumToInt(key)] = state;
}
pub fn is_down(self: *Keyboard, key: Key) bool {
return self.keys[@enumToInt(key)];
}
pub fn keys_down(self: *Keyboard, alloc: *std.mem.Allocator) !std.ArrayList(Key) {
var result = std.ArrayList(Key).init(alloc);
for (self.keys) |down, idx| {
if (down) {
const e = @truncate(u7, idx);
try result.append(@intToEnum(Key, e));
}
}
return result;
}
pub fn was_pressed(self: *Keyboard, key: Key, repeat: bool) bool {
const t = self.keys_down_duration[@enumToInt(key)];
if (t == 0.0) return true;
if (repeat and (t > self.key_repeat_delay)) {
const delay = self.key_repeat_delay;
const rate = self.key_repeat_rate;
if ((@rem(t - delay, rate) > rate * 0.5) != (@rem(t - delay - self.delta_time, rate) > rate * 0.5)) {
return true;
}
}
return false;
}
pub fn keys_pressed(self: *Keyboard, alloc: *std.mem.Allocator, repeat: bool) !std.ArrayList(Key) {
var result = std.ArrayList(Key).init(alloc);
for (self.keys) |down, idx| {
const e = @truncate(u7, idx);
if (self.was_pressed(@intToEnum(Key, e), repeat)) {
try result.append(@intToEnum(Key, e));
}
}
return result;
}
pub fn set_key_repeat_delay(self: *Keyboard, delay: f32) void {
self.key_repeat_delay = delay;
}
pub fn set_key_repeat_rate(self: *Keyboard, rate: f32) void {
self.key_repeat_rate = rate;
}
}; | src/app/event.zig |
const gpio = @import("gpio.zig");
const cpu = @import("cpu.zig");
const rs_pin = 12;
const en_pin = 11;
const data_pins = [4]comptime_int{ 5, 4, 3, 2 };
const cols = 16;
const rows = 2;
const Control = struct {
const clear_display: u8 = 0x01;
const return_home: u8 = 0x02;
const entry_mode_set: u8 = 0x04;
const display_control: u8 = 0x08;
const cursor_shift: u8 = 0x10;
const function_set: u8 = 0x20;
const set_CGRAM_address: u8 = 0x40;
const set_DDRAM_address: u8 = 0x80;
};
const Flags = struct {
const entry_right = 0x00;
const entry_left = 0x02;
const entry_shift_inc = 0x01;
const entry_shift_dec = 0x00;
const blink: u8 = 0x01;
const cursor: u8 = 0x02;
const display_on: u8 = 0x04;
const move_right: u8 = 0x04;
const display_move: u8 = 0x08;
const lcd_2lines: u8 = 0x08;
};
const CurrentDisp = struct {
var function: u8 = undefined;
var mode: u8 = undefined;
var control: u8 = undefined;
};
pub fn begin() void {
CurrentDisp.function = Flags.lcd_2lines;
CurrentDisp.mode = 0;
CurrentDisp.control = 0;
gpio.init(en_pin, .output);
gpio.init(rs_pin, .output);
inline for (data_pins) |pin| {
gpio.init(pin, .output);
}
cpu.delayMilliseconds(45);
gpio.write(en_pin, .low);
gpio.write(rs_pin, .low);
write4bits(0x3);
cpu.delayMilliseconds(5);
write4bits(0x3);
cpu.delayMilliseconds(5);
write4bits(0x3);
cpu.delayMicroseconds(120);
write4bits(0x2);
command(Control.function_set | CurrentDisp.function);
displayOn();
clear();
}
pub fn clear() void {
command(Control.set_DDRAM_address);
command(Control.clear_display);
cpu.delayMilliseconds(2);
}
pub fn displayOn() void {
CurrentDisp.control |= Flags.display_on;
command(Control.display_control | CurrentDisp.control);
}
pub fn write(value: u8) void {
gpio.write(rs_pin, .high);
write4bitsTwice(value);
}
pub fn writeU16(value: u16) void {
var val = value;
var i: u3 = 0;
while (i < 4) : (i += 1) {
const nibble = @truncate(u8, (val & 0xf000) >> 12);
switch (nibble) {
0...9 => write('0' + nibble),
else => write('a' - 10 + nibble),
}
val <<= 4;
}
}
pub fn writeLines(line1: []const u8, line2: []const u8) void {
for (line1) |c|
write(c);
command(Control.set_DDRAM_address | 0x40);
for (line2) |c|
write(c);
}
pub fn setCursor(col: u8, row: u8) void {
var c = col;
if (col > 15) c = 15;
var off: u8 = 0;
if (row > 0) off = 0x40;
command(Control.set_DDRAM_address | (c + off));
}
pub fn writePanic(msg: []const u8) void {
begin();
for ("Panic! Msg:") |c|
write(c);
const short = if (msg.len > 16) msg[0..16] else msg;
command(Control.set_DDRAM_address | 0x40);
for (msg) |c|
write(c);
}
fn command(value: u8) void {
gpio.write(rs_pin, .low);
write4bitsTwice(value);
}
fn write4bits(value: u4) void {
inline for (data_pins) |pin, i| {
if ((value >> i) & 1 != 0) {
gpio.write(pin, .high);
} else {
gpio.write(pin, .low);
}
}
pulseEnable();
}
fn write4bitsTwice(value: u8) void {
write4bits(@truncate(u4, (value >> 4) & 0xf));
write4bits(@truncate(u4, value & 0xf));
}
fn pulseEnable() void {
gpio.write(en_pin, .low);
cpu.delayMicroseconds(1);
gpio.write(en_pin, .high);
cpu.delayMicroseconds(1);
gpio.write(en_pin, .low);
cpu.delayMicroseconds(100);
} | src/lcd.zig |
const clap = @import("clap");
const std = @import("std");
const util = @import("util");
const rom = @import("rom.zig");
const debug = std.debug;
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const io = std.io;
const mem = std.mem;
const os = std.os;
const path = fs.path;
const nds = rom.nds;
const Program = @This();
allocator: mem.Allocator,
in: []const u8,
out: []const u8,
pub const main = util.generateMain(Program);
pub const version = "0.0.0";
pub const description =
\\Reads a Nintendo DS rom and extract its file system into a folder.
\\
;
pub const params = &[_]clap.Param(clap.Help){
clap.parseParam("-h, --help Display this help text and exit. ") catch unreachable,
clap.parseParam("-o, --output <FILE> Override destination path. ") catch unreachable,
clap.parseParam("-v, --version Output version information and exit.") catch unreachable,
clap.parseParam("<ROM>") catch unreachable,
};
pub fn init(allocator: mem.Allocator, args: anytype) !Program {
const pos = args.positionals();
const file_name = if (pos.len > 0) pos[0] else return error.MissingFile;
const out = args.option("--output") orelse
try fmt.allocPrint(allocator, "{s}.output", .{path.basename(file_name)});
return Program{
.allocator = allocator,
.in = file_name,
.out = out,
};
}
pub fn run(
program: *Program,
comptime Reader: type,
comptime Writer: type,
stdio: util.CustomStdIoStreams(Reader, Writer),
) anyerror!void {
_ = stdio;
const allocator = program.allocator;
const cwd = fs.cwd();
const rom_file = try cwd.openFile(program.in, .{});
defer rom_file.close();
var nds_rom = try nds.Rom.fromFile(rom_file, allocator);
try cwd.makePath(program.out);
// All dir instances should actually be `const`, but `Dir.close` takes mutable pointer, so we
// can't actually do that...
var out_dir = try cwd.openDir(program.out, .{});
defer out_dir.close();
try out_dir.makeDir("arm9_overlays");
try out_dir.makeDir("arm7_overlays");
try out_dir.makeDir("root");
var arm9_overlays_dir = try out_dir.openDir("arm9_overlays", .{});
defer arm9_overlays_dir.close();
var arm7_overlays_dir = try out_dir.openDir("arm7_overlays", .{});
defer arm7_overlays_dir.close();
var root_dir = try out_dir.openDir("root", .{});
defer root_dir.close();
try out_dir.writeFile("arm9", nds_rom.arm9());
if (rom.nds.blz.decode(allocator, nds_rom.arm9())) |arm9| {
try out_dir.writeFile("arm9_decoded", arm9);
} else |_| {}
try out_dir.writeFile("arm7", nds_rom.arm7());
try out_dir.writeFile("nitro_footer", nds_rom.nitroFooter());
if (nds_rom.banner()) |banner|
try out_dir.writeFile("banner", mem.asBytes(banner));
const file_system = nds_rom.fileSystem();
try writeOverlays(arm9_overlays_dir, file_system, nds_rom.arm9OverlayTable(), allocator);
try writeOverlays(arm7_overlays_dir, file_system, nds_rom.arm7OverlayTable(), allocator);
try writeFs(root_dir, file_system, nds.fs.root);
}
fn writeFs(dir: fs.Dir, file_system: nds.fs.Fs, folder: nds.fs.Dir) anyerror!void {
var it = file_system.iterate(folder);
while (it.next()) |entry| {
switch (entry.handle) {
.file => |file| try dir.writeFile(entry.name, file_system.fileData(file)),
.dir => |sub_folder| {
try dir.makeDir(entry.name);
var sub_dir = try dir.openDir(entry.name, .{});
defer sub_dir.close();
try writeFs(sub_dir, file_system, sub_folder);
},
}
}
}
fn writeOverlays(dir: fs.Dir, file_system: nds.fs.Fs, overlays: []const nds.Overlay, allocator: mem.Allocator) !void {
var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
for (overlays) |*overlay, i| {
try dir.writeFile(fmt.bufPrint(&buf, "overlay{}", .{i}) catch unreachable, mem.asBytes(overlay));
const data = file_system.fileData(.{ .i = overlay.file_id.value() });
if (nds.blz.decode(allocator, data)) |d| {
std.log.info("Decompressed overlay {}", .{i});
try dir.writeFile(fmt.bufPrint(&buf, "file{}", .{i}) catch unreachable, d);
} else |_| {
try dir.writeFile(fmt.bufPrint(&buf, "file{}", .{i}) catch unreachable, data);
}
}
} | src/core/tm35-nds-extract.zig |
const escape = @import("details/escape.zig");
const fmt = @import("details/fmt.zig");
const std = @import("std");
const Formatter = @import("../../../lib.zig").ser.Formatter;
pub fn PrettyFormatter(comptime Writer: type) type {
return struct {
current: usize,
has_value: bool,
indent: []const u8,
const Self = @This();
const impl = @"impl PrettyFormatter"(Writer);
/// Construct a pretty printer formatter that defaults to using two
/// spaces for indentation.
pub fn init() Self {
return initWithIndent(" ");
}
/// Construct a pretty printer formatter that uses the `indent` string
/// for indentation.
pub fn initWithIndent(indent: []const u8) Self {
return .{
.current = 0,
.has_value = false,
.indent = indent,
};
}
fn doIndent(self: *Self, writer: anytype) Writer.Error!void {
var i: usize = 0;
while (i < self.current) : (i += 1) {
try writer.writeAll(self.indent);
}
}
pub usingnamespace Formatter(
*Self,
Writer,
impl.formatter.writeNull,
impl.formatter.writeBool,
impl.formatter.writeInt,
impl.formatter.writeFloat,
impl.formatter.writeNumberString,
impl.formatter.beginString,
impl.formatter.endString,
impl.formatter.writeStringFragment,
impl.formatter.writeCharEscape,
impl.formatter.beginArray,
impl.formatter.endArray,
impl.formatter.beginArrayValue,
impl.formatter.endArrayValue,
impl.formatter.beginObject,
impl.formatter.endObject,
impl.formatter.beginObjectKey,
impl.formatter.endObjectKey,
impl.formatter.beginObjectValue,
impl.formatter.endObjectValue,
impl.formatter.writeRawFragment,
);
};
}
fn @"impl PrettyFormatter"(comptime Writer: type) type {
const Self = PrettyFormatter(Writer);
return struct {
pub const formatter = struct {
pub fn writeNull(_: *Self, writer: Writer) Writer.Error!void {
try writer.writeAll("null");
}
pub fn writeBool(_: *Self, writer: Writer, value: bool) Writer.Error!void {
try writer.writeAll(if (value) "true" else "false");
}
pub fn writeInt(_: *Self, writer: Writer, value: anytype) Writer.Error!void {
try fmt.formatInt(value, writer);
}
pub fn writeFloat(_: *Self, writer: Writer, value: anytype) Writer.Error!void {
var buf: [512]u8 = undefined;
var stream = std.io.fixedBufferStream(&buf);
std.fmt.formatFloatDecimal(value, std.fmt.FormatOptions{}, stream.writer()) catch |err| switch (err) {
error.NoSpaceLeft => unreachable,
else => unreachable, // TODO: handle error
};
// TODO: fix getPos error
try writer.writeAll(buf[0 .. stream.getPos() catch unreachable]);
}
pub fn writeNumberString(_: *Self, writer: Writer, value: []const u8) Writer.Error!void {
try writer.writeAll(value);
}
pub fn beginString(_: *Self, writer: Writer) Writer.Error!void {
try writer.writeAll("\"");
}
pub fn endString(_: *Self, writer: Writer) Writer.Error!void {
try writer.writeAll("\"");
}
pub fn writeStringFragment(_: *Self, writer: Writer, value: []const u8) Writer.Error!void {
try writer.writeAll(value);
}
pub fn writeCharEscape(_: *Self, writer: Writer, value: u21) Writer.Error!void {
try escape.escapeChar(value, writer);
}
pub fn beginArray(self: *Self, writer: Writer) Writer.Error!void {
self.current += 1;
self.has_value = false;
try writer.writeAll("[");
}
pub fn endArray(self: *Self, writer: Writer) Writer.Error!void {
self.current -= 1;
if (self.has_value) {
try writer.writeAll("\n");
try self.doIndent(writer);
}
try writer.writeAll("]");
}
pub fn beginArrayValue(self: *Self, writer: Writer, first: bool) Writer.Error!void {
if (first) {
try writer.writeAll("\n");
} else {
try writer.writeAll(",\n");
}
try self.doIndent(writer);
}
pub fn endArrayValue(self: *Self, writer: Writer) Writer.Error!void {
_ = writer;
self.has_value = true;
}
pub fn beginObject(self: *Self, writer: Writer) Writer.Error!void {
self.current += 1;
self.has_value = false;
try writer.writeAll("{");
}
pub fn endObject(self: *Self, writer: Writer) Writer.Error!void {
self.current -= 1;
if (self.has_value) {
try writer.writeAll("\n");
try self.doIndent(writer);
}
try writer.writeAll("}");
}
pub fn beginObjectKey(self: *Self, writer: Writer, first: bool) Writer.Error!void {
if (first) {
try writer.writeAll("\n");
} else {
try writer.writeAll(",\n");
}
try self.doIndent(writer);
}
pub fn endObjectKey(self: *Self, writer: Writer) Writer.Error!void {
_ = self;
_ = writer;
}
pub fn beginObjectValue(self: *Self, writer: Writer) Writer.Error!void {
_ = self;
try writer.writeAll(": ");
}
pub fn endObjectValue(self: *Self, writer: Writer) Writer.Error!void {
_ = writer;
self.has_value = true;
}
pub fn writeRawFragment(self: *Self, writer: Writer, value: []const u8) Writer.Error!void {
_ = self;
try writer.writeAll(value);
}
};
};
} | src/ser/impl/formatter/pretty.zig |
const std = @import("std");
const IR = @import("../IR.zig");
pub const Opt = struct {};
pub fn emit(m: IR.Module, writer: anytype, comptime opt: Opt) !void {
const e = Emitter(@TypeOf(writer)){ .writer = writer, .m = &m, .opt = opt };
try writer.writeAll(&std.wasm.magic);
try writer.writeAll(&std.wasm.version);
try e.section(.type);
try e.section(.import);
try e.section(.function);
try e.section(.table);
try e.section(.memory);
try e.section(.global);
try e.section(.@"export");
try e.section(.start);
try e.section(.element);
//MAYBE: data_count
try e.section(.code);
try e.section(.data);
//TODO: custom linking
}
fn Emitter(comptime Writer: type) type {
return struct {
writer: Writer,
m: *const IR.Module,
opt: Opt,
const E = @This();
pub fn section(e: E, comptime kind: std.wasm.Section) !void {
// A bit too meta...
const fn_name = @tagName(kind) ++ "Section";
var size = std.io.countingWriter(std.io.null_writer);
const se = Emitter(@TypeOf(size).Writer){ .m = e.m, .opt = e.opt, .writer = size.writer() };
try @field(se, fn_name)();
if (size.bytes_written == 0) return;
try e.byte(std.wasm.section(kind));
try e.uleb(size.bytes_written);
try @field(e, fn_name)();
}
fn uleb(e: E, v: usize) !void {
return std.leb.writeULEB128(e.writer, v);
}
fn string(e: E, str: []const u8) !void {
try e.uleb(str.len);
try e.writer.writeAll(str);
}
fn byte(e: E, b: u8) !void {
return e.writer.writeByte(b);
}
fn limits(e: E, l: std.wasm.Limits) !void {
try e.byte(@boolToInt(l.max != null));
try e.uleb(l.min);
if (l.max) |max|
try e.uleb(max);
}
fn constExpr(e: E, expr: IR.InitExpr) !void {
try e.byte(std.wasm.opcode(IR.initExpr(expr)));
switch (expr) {
.i32_const => |i| try std.leb.writeILEB128(e.writer, i),
.i64_const => |i| try std.leb.writeILEB128(e.writer, i),
.f32_const => |f| try e.writer.writeIntNative(u32, @bitCast(u32, @floatCast(f32, f))),
.f64_const => |f| try e.writer.writeIntNative(u64, @bitCast(u64, f)),
.global_get => |u| try e.uleb(u),
}
try e.byte(std.wasm.opcode(.end));
}
fn functype(e: E, sig: IR.Func.Sig) !void {
try e.byte(std.wasm.function_type);
try e.uleb(sig.params.len);
for (sig.params) |param|
try e.byte(std.wasm.valtype(param.lower()));
try e.uleb(sig.results.len);
for (sig.results) |ret|
try e.byte(std.wasm.valtype(ret.lower()));
}
fn typeSection(e: E) !void {
//MAYBE: deduplicate
//NOTE: reftype not handled...
if (e.m.funcs.len == 0) return;
var len: usize = 0;
for (e.m.funcs) |func| {
len += 1 + switch (func.body) {
.code => |code| code.types.len,
.import => 0,
};
}
try e.uleb(len);
for (e.m.funcs) |func| {
try e.functype(func.type);
switch (func.body) {
.code => |code| for (code.types) |sig|
try e.functype(sig),
.import => {},
}
}
}
fn importSection(e: E) !void {
var len: usize = 0;
var iter = e.m.imports();
while (iter.next() != null) len += 1;
if (len == 0) return;
try e.uleb(len);
iter = e.m.imports();
while (iter.next()) |cur| {
try e.string(cur.key.module);
try e.string(cur.key.name);
try e.byte(@enumToInt(cur.kind));
switch (cur.kind) {
.function => try e.uleb(cur.index),
.table => {
const t = &e.m.tables[cur.index];
try e.byte(std.wasm.reftype(t.type));
try e.limits(t.size);
},
.memory => try e.limits(e.m.memory.?.size),
.global => {
const g = &e.m.globals[cur.index];
try e.byte(std.wasm.valtype(g.type.lower()));
try e.byte(@boolToInt(g.mutable));
},
}
}
}
fn functionSection(e: E) !void {
var len: usize = 0;
for (e.m.funcs) |func| if (func.body == .code) {
len += 1;
};
if (len == 0) return;
var typeidx: usize = 0;
try e.uleb(len);
for (e.m.funcs) |func| {
switch (func.body) {
.code => |code| {
try e.uleb(typeidx);
typeidx += code.types.len;
},
else => {},
}
typeidx += 1;
}
}
fn tableSection(e: E) !void {
var len: usize = 0;
for (e.m.tables) |table| if (table.body == .intern) {
len += 1;
};
if (len == 0) return;
try e.uleb(len);
for (e.m.tables) |table| if (table.body == .intern) {
try e.byte(std.wasm.reftype(table.type));
try e.limits(table.size);
};
}
fn memorySection(e: E) !void {
if (e.m.memory) |mem| if (mem.import == null) {
try e.uleb(1);
try e.limits(mem.size);
};
}
fn globalSection(e: E) !void {
var len: usize = 0;
for (e.m.globals) |global| if (global.body == .init) {
len += 1;
};
if (len == 0) return;
try e.uleb(len);
for (e.m.globals) |global| switch (global.body) {
.init => |init| {
try e.byte(std.wasm.valtype(global.type.lower()));
try e.byte(@boolToInt(global.mutable));
try e.constExpr(init);
},
else => {},
};
}
fn exportSection(e: E) !void {
var len: usize = 0;
var iter = e.m.exports();
while (iter.next() != null) len += 1;
if (len == 0) return;
iter = e.m.exports();
try e.uleb(len);
while (iter.next()) |cur| {
try e.string(cur.key);
try e.byte(@enumToInt(cur.kind));
try e.uleb(cur.index);
}
}
fn startSection(e: E) !void {
if (e.m.start) |s|
try e.uleb(s);
}
fn elementSection(e: E) !void {
if (e.m.elements.len == 0) return;
try e.uleb(e.m.elements.len);
for (e.m.elements) |elem| {
var flag: u8 = switch (elem.mode) {
.passive => 0x1,
.declarative => 0x3,
.active => |act| if (act.table == 0) @as(u8, 0x0) else 0x2,
};
if (elem.init == .val) flag |= 0b100;
try e.byte(flag);
switch (elem.mode) {
.active => |act| {
if (act.table != 0)
try e.uleb(act.table);
try e.constExpr(act.offset);
},
else => {},
}
if (elem.mode != .active or elem.mode.active.table != 0)
try e.byte(@enumToInt(elem.type));
switch (elem.init) {
.val => |vs| {
try e.uleb(vs.len);
for (vs) |v|
try e.constExpr(v);
},
.func => |vs| {
try e.uleb(vs.len);
for (vs) |v|
try e.uleb(v);
},
}
}
}
fn codeSection(e: E) !void {
var len: usize = 0;
for (e.m.funcs) |func| {
switch (func.body) {
.code => len += 1,
else => {},
}
}
if (len == 0) return;
var typeidx: usize = 0;
try e.uleb(len);
for (e.m.funcs) |func| {
typeidx += 1;
switch (func.body) {
.code => |code| {
try e.uleb(code.bytes.len);
// NOTE: expect relocs stored by offset and not overlaping
var sent: u32 = 0;
for (code.relocs) |reloc| {
try e.writer.writeAll(code.bytes[sent..reloc.offset]);
sent = reloc.offset;
switch (reloc.type) {
.typeIndexLeb => {
const v = @truncate(u32, typeidx + reloc.index);
var buf: [5]u8 = undefined;
std.leb.writeUnsignedFixed(5, &buf, v);
try e.writer.writeAll(&buf);
sent += 5;
},
else => unreachable,
}
}
try e.writer.writeAll(code.bytes[sent..]);
typeidx += code.types.len;
},
else => {},
}
}
}
fn dataSection(e: E) !void {
if (e.m.datas.len == 0) return;
try e.uleb(e.m.datas.len);
for (e.m.datas) |data| {
switch (data.body) {
.active => |act| {
if (act.mem == 0) {
try e.byte(0);
} else {
try e.byte(2);
try e.uleb(act.mem);
}
try e.constExpr(act.offset);
try e.string(act.content);
},
.passive => |pas| {
try e.byte(1);
try e.string(pas);
},
}
}
}
};
} | src/Wasm/Emit.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const mustache = @import("mustache");
pub fn main() anyerror!void {
std.debug.print("Benchmark\n{s}\n", .{"https://github.com/batiati/mustache_benchmark"});
std.debug.print("=============================\n\n", .{});
try runTemplate("Template 1", Binding1, "../data/template1.html", "../data/bindings1.json");
try runTemplate("Template 2", Binding2, "../data/template2.html", "../data/bindings2.json");
try runTemplate("Template 3", Binding3, "../data/template3.html", "../data/bindings3.json");
}
const TIMES = 1_000_000;
const Binding1 = struct {
title: []const u8,
txt1: []const u8,
txt2: []const u8,
txt3: []const u8,
pub fn free(self: *Binding1, allocator: Allocator) void {
allocator.free(self.title);
allocator.free(self.txt1);
allocator.free(self.txt2);
allocator.free(self.txt3);
}
};
const Binding2 = struct {
title: []const u8,
image_url: []const u8,
icon_url: []const u8,
short_description: []const u8,
detail_description: []const u8,
offer_id: u32,
pub fn free(self: *Binding2, allocator: Allocator) void {
allocator.free(self.title);
allocator.free(self.image_url);
allocator.free(self.icon_url);
allocator.free(self.short_description);
allocator.free(self.detail_description);
}
};
const Binding3 = struct {
const Repo = struct { name: []const u8 };
name: []const u8,
age: u32,
company: []const u8,
person: bool,
repo: []const Repo,
repo2: []const Repo,
pub fn free(self: *Binding3, allocator: Allocator) void {
allocator.free(self.name);
allocator.free(self.company);
for (self.repo) |item| {
allocator.free(item.name);
}
for (self.repo2) |item| {
allocator.free(item.name);
}
allocator.free(self.repo);
allocator.free(self.repo2);
}
};
fn runTemplate(comptime caption: []const u8, comptime TBinding: type, comptime template: []const u8, comptime json: []const u8) !void {
const template_text = @embedFile(template);
const allocator = std.heap.c_allocator;
var cached_template = parseTemplate(allocator, template_text);
defer cached_template.deinit(allocator);
try runTemplatePreParsed(allocator, caption ++ " - pre-parsed", TBinding, json, cached_template);
try runTemplateNotParsed(allocator, caption ++ " - not parsed", TBinding, json, template_text);
}
fn runTemplatePreParsed(allocator: Allocator, comptime caption: []const u8, comptime TBinding: type, comptime json: []const u8, template: mustache.Template) !void {
var data = try loadData(TBinding, allocator, json);
defer data.free(allocator);
var total_bytes: usize = 0;
var repeat: u32 = 0;
const start = std.time.nanoTimestamp();
while (repeat < TIMES) : (repeat += 1) {
const result = try mustache.allocRender(allocator, template, &data);
total_bytes += result.len;
allocator.free(result);
}
const end = std.time.nanoTimestamp();
const ellapsed = end - start;
printSummary(caption, ellapsed, total_bytes);
}
fn runTemplateNotParsed(allocator: Allocator, comptime caption: []const u8, comptime TBinding: type, comptime json: []const u8, comptime template_text: []const u8) !void {
var data = try loadData(TBinding, allocator, json);
defer data.free(allocator);
var total_bytes: usize = 0;
var repeat: u32 = 0;
const start = std.time.nanoTimestamp();
while (repeat < TIMES) : (repeat += 1) {
const result = try mustache.allocRenderText(allocator, template_text, &data);
total_bytes += result.len;
allocator.free(result);
}
const end = std.time.nanoTimestamp();
const ellapsed = end - start;
printSummary(caption, ellapsed, total_bytes);
}
fn printSummary(caption: []const u8, ellapsed: i128, total_bytes: usize) void {
std.debug.print("\n{s}\n", .{caption});
std.debug.print("Total time {d:.3}s\n", .{@intToFloat(f64, ellapsed) / std.time.ns_per_s});
std.debug.print("{d:.0} ops/s\n", .{TIMES / (@intToFloat(f64, ellapsed) / std.time.ns_per_s)});
std.debug.print("{d:.0} ns/iter\n", .{@intToFloat(f64, ellapsed) / TIMES});
std.debug.print("{d:.0} MB/s\n", .{(@intToFloat(f64, total_bytes) / 1024 / 1024) / (@intToFloat(f64, ellapsed) / std.time.ns_per_s)});
}
fn parseTemplate(allocator: Allocator, template_text: []const u8) mustache.Template {
return switch (mustache.parseText(allocator, template_text, .{}, .{ .copy_strings = false }) catch unreachable) {
.ParseError => |detail| {
std.log.err("Parse error {s} at lin {}, col {}", .{ @errorName(detail.parse_error), detail.lin, detail.col });
@panic("parser error");
},
.Success => |ret| ret,
};
}
fn loadData(comptime T: type, allocator: Allocator, comptime json: []const u8) !T {
var token_stream = std.json.TokenStream.init(@embedFile(json));
return try std.json.parse(T, &token_stream, .{ .allocator = allocator });
} | benchmark/src/main.zig |
const clap = @import("clap");
const std = @import("std");
const ascii = std.ascii;
const fmt = std.fmt;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const process = std.process;
const time = std.time;
const Param = clap.Param(clap.Help);
const params = [_]Param{
clap.parseParam("-d, --delay-first-line Also have the delay before the first line.") catch unreachable,
clap.parseParam("-h, --help Display this help text and exit.") catch unreachable,
clap.parseParam("<TIME>") catch unreachable,
};
fn usage(stream: anytype) !void {
try stream.writeAll("Usage: delay-line ");
try clap.usage(stream, ¶ms);
try stream.writeAll("\nCopies standard input to standard output with a fixed delay " ++
"between each line.\n" ++
"\n" ++
"Options:\n");
try clap.help(stream, ¶ms);
}
pub fn main() !u8 {
const stdin = std.io.getStdIn();
const stdout = std.io.getStdOut().outStream();
const stderr = std.io.getStdErr().outStream();
var arena = heap.ArenaAllocator.init(heap.page_allocator);
var diag = clap.Diagnostic{};
var args = clap.parse(clap.Help, ¶ms, &arena.allocator, &diag) catch |err| {
diag.report(stderr, err) catch {};
usage(stderr) catch {};
return 1;
};
if (args.flag("--help")) {
try usage(stdout);
return 0;
}
const delay_first_line = args.flag("--delay-first-line");
const pos = args.positionals();
const time_per_line = str_to_time(if (pos.len > 0) pos[0] else "1") catch |err| {
stderr.print("{}\n", .{err}) catch {};
usage(stderr) catch {};
return 1;
};
var start: usize = 0;
var end: usize = 0;
var buf: [1024]u8 = undefined;
var timer = try time.Timer.start();
var next_milestone = timer.read() + time_per_line;
var first_line = true;
done: while (true) : ({
next_milestone += time_per_line;
first_line = false;
}) {
while (!first_line or !delay_first_line) {
if (mem.indexOfScalar(u8, buf[start..end], '\n')) |i| {
try stdout.writeAll(buf[start..][0 .. i + 1]);
start = start + i + 1;
break;
}
try stdout.writeAll(buf[start..end]);
start = 0;
end = try stdin.read(&buf);
if (end == 0)
break :done;
}
while (math.sub(u64, next_milestone, timer.read())) |time_to_sleep| {
time.sleep(time_to_sleep);
} else |_| {}
}
return 0;
}
fn str_to_time(str: []const u8) !u64 {
if (str.len == 0)
return error.InvalidFormat;
const suffix = mem.trimLeft(u8, str, "0123456789");
const time_str = str[0 .. @ptrToInt(suffix.ptr) - @ptrToInt(str.ptr)];
const res = try fmt.parseUnsigned(u64, time_str, 10);
for ([_]struct { suffix: []const u8, scale: u64 }{
.{ .suffix = "ns", .scale = 1 },
.{ .suffix = "us", .scale = time.ns_per_us },
.{ .suffix = "ms", .scale = time.ns_per_ms },
.{ .suffix = "s", .scale = time.ns_per_s },
.{ .suffix = "", .scale = time.ns_per_s },
.{ .suffix = "m", .scale = time.ns_per_min },
.{ .suffix = "h", .scale = time.ns_per_hour },
}) |spec| {
if (mem.eql(u8, suffix, spec.suffix))
return res * spec.scale;
}
return error.InvalidFormat;
} | src/main.zig |
const std = @import("std");
const log = std.log;
const csl = @import("csl_json.zig");
const ast = @import("ast.zig");
const Parser = @import("parser.zig").Parser;
pub const BuiltinCall = enum {
cite = 0,
textcite,
cites,
bibliography,
sc,
label,
ref,
};
pub const BuiltinCallInfo = struct {
// 0 -> varargs
pos_params: i16,
kw_params: u16,
// whether BuiltinResult should be allocated and stored persistently
persistent: bool,
};
pub const builtin_call_info = [_]BuiltinCallInfo {
.{ .pos_params = 1, .kw_params = 4, .persistent = true }, // cite
.{ .pos_params = 1, .kw_params = 4, .persistent = true }, // textcite
.{ .pos_params = -1, .kw_params = 0, .persistent = true }, // cites
.{ .pos_params = 0, .kw_params = 0, .persistent = false }, // bibliography
.{ .pos_params = 1, .kw_params = 0, .persistent = false }, // sc
.{ .pos_params = 1, .kw_params = 0, .persistent = true }, // label
.{ .pos_params = 1, .kw_params = 0, .persistent = true }, // ref
};
// TODO @CleanUp should this be a sep tag and union, since the result is optional we never
// use the tagged union properly, only the payload and tag separately
pub const BuiltinResult = union(BuiltinCall) {
cite: csl.CitationItem,
// citeproc doesn't propely support \textcite behaviour from biblatex where
// the author is printed outside parens and only the year is inside:
// @textcite(walter99) -> Walter (1999)
// => needs to be two CitationItem with the first being author-only and the second
// being suppress-author
textcite: [2]csl.CitationItem,
cites: []const csl.CitationItem,
bibliography: *ast.Node,
sc,
label: []const u8,
ref: []const u8,
};
pub const Error = error {
OutOfMemory,
SyntaxError,
ArgumentMismatch,
InvalidArgument,
BuiltinNotAllowed,
};
// anytype means we can pass anonymous structs like: .{ .parser = self, .. }
// checkted at compile time (aka "comptime duck-typing")
/// expects that the correct amount of positional arguments are already validated by parse_builtin
/// evaluate_builtin and derivatives are expected to clean up the argument nodes
/// so that only the builtin_node itself OR the result nodes remain!
pub fn evaluate_builtin(
allocator: *std.mem.Allocator,
builtin_node: *ast.Node,
builtin_type: BuiltinCall,
data: anytype
) Error!BuiltinResult {
var result: BuiltinResult = undefined;
// NOTE: theoretically builtins using results of other arbitrary builtins are allowed
// under the condition that the builtin can be __fully__ evaluated directly (without
// having to e.g. wait for citeproc to process it; e.g. using @textcite as post kwarg
// for @cite would thus not work since the post kwarg has to be sent to citeproc, but
// the value is not known yet until citeproc is run etc..
switch (builtin_type) {
.cite => {
result = .{
.cite = try evaluate_builtin_cite(builtin_node, .cite, data),
};
// clean up arguments
builtin_node.delete_children(allocator);
},
.textcite => {
result = .{
.textcite = try evaluate_builtin_textcite(builtin_node, .textcite, .{}),
};
// clean up arguments
builtin_node.delete_children(allocator);
},
.cites => {
// TODO @MemoryLeak this is not free'd
var citations = std.ArrayList(csl.CitationItem).init(allocator);
var mb_next = builtin_node.first_child;
while (mb_next) |next| : (mb_next = next.next) {
switch (next.first_child.?.data) {
.BuiltinCall => |call| {
switch (call.builtin_type) {
// .cite and .textcite nodes will have been evaluated already
// just use the resul ptr
.cite => {
try citations.append(call.result.?.cite);
},
.textcite => {
// TODO compiler stuck in an infinite loop
// [999/10000+] with inferred error set
// [4000/6000] with explicit error set but still infinite loop
// const tc = try evaluate_builtin(
// allocator, next.first_child.?, .textcite, .{});
// try citations.append(tc.textcite[0]);
// try citations.append(tc.textcite[1]);
const tc_result = call.result.?;
try citations.append(tc_result.textcite[0]);
try citations.append(tc_result.textcite[1]);
},
else => {
log.err(
"Only calls to @cite or @textcite are allowed as arguments " ++
"to builtin call '{s}'!\n",
.{ @tagName(builtin_type) });
return Error.ArgumentMismatch;
},
}
},
else => {
log.err(
"Only calls to @cite or @textcite are allowed as arguments " ++
"to builtin call '{s}'!\n",
.{ @tagName(builtin_type) });
return Error.ArgumentMismatch;
},
}
}
log.debug("Multicite:\n", .{});
for (citations.items) |it| {
log.debug(" {s}\n", .{ it });
}
log.debug("Multicite END\n", .{});
// clean up arguments
builtin_node.delete_children(allocator);
result = .{
.cites = citations.toOwnedSlice(),
};
},
.bibliography => {
var bib_node = try ast.Node.create(allocator);
bib_node.data = .Bibliography;
builtin_node.append_child(bib_node);
result = .{
.bibliography = bib_node,
};
},
.sc => {
var only_arg = builtin_node.first_child.?;
var text_node = only_arg.first_child.?;
text_node.detach(); // remove from only_arg
// TODO validate arg types in a pre-pass?
// insert parent .SmallCaps node above text_node
var parent = try ast.Node.create(allocator);
parent.data = .SmallCaps;
parent.append_child(text_node);
builtin_node.append_child(parent);
// there are no argument nodes to clean up
result = .sc;
},
.label => {
var only_arg = builtin_node.first_child.?;
result = .{
.label = only_arg.first_child.?.data.Text.text,
};
// not neccessary/effective since we require to be called with the node
// ArenaAllocator (and freeing allocations has no effect unless it's the
// last allocation)
only_arg.delete_direct_children(allocator);
allocator.destroy(only_arg);
builtin_node.first_child = null;
},
.ref => {
var only_arg = builtin_node.first_child.?;
result = .{
.ref = only_arg.first_child.?.data.Text.text,
};
only_arg.delete_direct_children(allocator);
allocator.destroy(only_arg);
builtin_node.first_child = null;
},
}
return result;
}
/// just here since recursive calls won't compile with the compiler being stuck in an
/// infinite loop during semantic analysis see: https://github.com/ziglang/zig/issues/4572
pub fn evaluate_builtin_textcite(
builtin_node: *ast.Node,
builtin_type: BuiltinCall,
data: anytype
) Error![2]csl.CitationItem {
// TODO fix kwargs on textcite since we use two separate cites to emulate a real textcite
// the pre/post/etc get printed twice
var cite_author_only = try evaluate_builtin_cite(builtin_node, .textcite, data);
var cite_no_author: csl.CitationItem = cite_author_only;
cite_author_only.@"author-only" = .{ .boolean = true };
cite_no_author.@"suppress-author" = .{ .boolean = true };
return [2]csl.CitationItem { cite_author_only, cite_no_author };
}
pub fn evaluate_builtin_cite(
builtin_node: *ast.Node,
builtin_type: BuiltinCall,
data: anytype
) Error!csl.CitationItem {
// return BuiltinResult here as well?
// var result: BuiltinResult = undefined;
var citation = csl.CitationItem{
.id = undefined,
.prefix = null,
.suffix = null,
.locator = null,
.label = null,
.@"suppress-author" = null,
.@"author-only" = null,
};
if (builtin_node.first_child) |fchild| {
if (fchild.data != .PostionalArg) {
log.err(
"Builtin call '{s}' missing first postional argument 'id'!\n",
.{ @tagName(builtin_type) });
return Error.ArgumentMismatch;
}
var id = fchild.first_child.?.data.Text.text;
if (id[0] == '-') {
// id starting with '-' -> suppress author
citation.@"suppress-author" = .{ .boolean = true };
id = id[1..];
}
citation.id.string = id;
log.debug("First pos arg: {s}\n", .{ fchild.first_child.?.data.Text.text });
var mb_next = fchild.next;
while (mb_next) |next| : (mb_next = next.next) {
if (next.first_child == null or next.first_child.?.data != .Text) {
log.err(
"Only textual arguments allowed for builtin call '{s}'!\n",
.{ @tagName(builtin_type) });
log.debug("Other data: {}\n", .{ next.data });
return Error.ArgumentMismatch;
}
// check that no there are no other cite calls that we depend on
var mb_current: ?*ast.Node = next;
while (mb_current) |current| : (mb_current = current.dfs_next()) {
if (current.data == .BuiltinCall) {
switch (current.data.BuiltinCall.builtin_type) {
.cite, .textcite, .cites => {
// TODO: @Improvement include starting token in ast.Node
// so we can inlcude line_nr when error reporting?
log.err("Nested calls to cite " ++
"builtins are not allowed!", .{});
return Error.BuiltinNotAllowed;
},
else => {},
}
}
}
if (std.mem.eql(u8, next.data.KeywordArg.keyword, "pre")) {
citation.prefix = next.first_child.?.data.Text.text;
} else if (std.mem.eql(u8, next.data.KeywordArg.keyword, "post")) {
citation.suffix = next.first_child.?.data.Text.text;
} else if (std.mem.eql(u8, next.data.KeywordArg.keyword, "loc")) {
citation.locator = next.first_child.?.data.Text.text;
} else if (std.mem.eql(u8, next.data.KeywordArg.keyword, "label")) {
const mb_loc_type = std.meta.stringToEnum(
csl.CitationItem.LocatorType, next.first_child.?.data.Text.text);
if (mb_loc_type) |loc_type| {
citation.label = loc_type;
} else {
log.err(
"'label={s}' is not a valid locator type! See " ++
"https://docs.citationstyles.org/en/stable/" ++
"specification.html#locators for valid locator types!\n",
.{ next.first_child.?.data.Text.text });
return Error.InvalidArgument;
}
} else {
log.err(
"Unexpected keyword argument '{s}' for builtin call '{s}'!\n",
.{ next.data.KeywordArg.keyword, @tagName(builtin_type) });
return Error.ArgumentMismatch;
}
}
log.debug("After collecting kwargs:\n{}\n", .{ citation });
} else {
log.err(
"Builtin call has no arguments!\n", .{});
return Error.ArgumentMismatch;
}
return citation;
} | src/builtin.zig |
Subsets and Splits