code
stringlengths 38
801k
| repo_path
stringlengths 6
263
|
|---|---|
const std = @import("std");
const TypeId = @import("builtin").TypeId;
const assert = std.debug.assert;
const time = std.time;
const warn = std.debug.warn;
const Timer = time.Timer;
const BenchFn = fn (*Context) void;
pub const Context = struct {
timer: Timer,
iter: u32,
count: u32,
state: State,
nanoseconds: u64,
const HeatingTime = time.second / 2;
const RunTime = time.second / 2;
const State = enum {
None,
Heating,
Running,
Finished,
};
pub fn init() Context {
return Context{ .timer = Timer.start() catch unreachable, .iter = 0, .count = 0, .state = .None, .nanoseconds = 0 };
}
pub fn run(self: *Context) bool {
switch (self.state) {
.None => {
self.state = .Heating;
self.timer.reset();
return true;
},
.Heating => {
self.count += 1;
const elapsed = self.timer.read();
if (elapsed >= HeatingTime) {
// Caches should be hot
self.count = @intCast(u32, RunTime / (HeatingTime / self.count));
self.state = .Running;
self.timer.reset();
}
return true;
},
.Running => {
if (self.iter < self.count) {
self.iter += 1;
return true;
} else {
self.nanoseconds = self.timer.read();
self.state = .Finished;
return false;
}
},
.Finished => unreachable,
}
}
pub fn startTimer(self: *Context) void {
self.timer.reset();
}
pub fn stopTimer(self: *Context) void {
const elapsed = self.timer.read();
self.nanoseconds += elapsed;
}
pub fn runExplicitTiming(self: *Context) bool {
switch (self.state) {
.None => {
self.state = .Heating;
return true;
},
.Heating => {
self.count += 1;
if (self.nanoseconds >= HeatingTime) {
// Caches should be hot
self.count = @intCast(u32, RunTime / (HeatingTime / self.count));
self.nanoseconds = 0;
self.state = .Running;
}
return true;
},
.Running => {
if (self.iter < self.count) {
self.iter += 1;
return true;
} else {
self.state = .Finished;
return false;
}
},
.Finished => unreachable,
}
}
pub fn averageTime(self: *Context, unit: u64) f32 {
assert(self.state == .Finished);
return @intToFloat(f32, self.nanoseconds / unit) / @intToFloat(f32, self.iter);
}
};
pub fn benchmark(name: comptime []const u8, f: BenchFn) void {
var ctx = Context.init();
@noInlineCall(f, &ctx);
var unit: u64 = undefined;
var unit_name: []const u8 = undefined;
const avg_time = ctx.averageTime(1);
assert(avg_time >= 0);
if (avg_time <= time.microsecond) {
unit = 1;
unit_name = "ns";
} else if (avg_time <= time.millisecond) {
unit = time.microsecond;
unit_name = "us";
} else {
unit = time.millisecond;
unit_name = "ms";
}
warn("{}: avg {d:.3}{} ({} iterations)\n", name, ctx.averageTime(unit), unit_name, ctx.iter);
}
fn benchArgFn(comptime argType: type) type {
return fn (*Context, argType) void;
}
fn argTypeFromFn(comptime f: var) type {
comptime const F = @typeOf(f);
if (@typeId(F) != TypeId.Fn) {
@compileError("Argument must be a function.");
}
const fnInfo = @typeInfo(F).Fn;
if (fnInfo.args.len != 2) {
@compileError("Only functions taking 1 argument are accepted.");
}
return fnInfo.args[1].arg_type.?;
}
pub fn benchmarkArgs(comptime name: []const u8, comptime f: var, comptime args: []const argTypeFromFn(f)) void {
inline for (args) |a| {
var ctx = Context.init();
@noInlineCall(f, &ctx, a);
var unit: u64 = undefined;
var unit_name: []const u8 = undefined;
const avg_time = ctx.averageTime(1);
assert(avg_time >= 0);
if (avg_time <= time.microsecond) {
unit = 1;
unit_name = "ns";
} else if (avg_time <= time.millisecond) {
unit = time.microsecond;
unit_name = "us";
} else {
unit = time.millisecond;
unit_name = "ms";
}
warn("{} <{}>: avg {d:.3}{} ({} iterations)\n", name, if (@typeOf(a) == type) @typeName(a) else a, ctx.averageTime(unit), unit_name, ctx.iter);
}
}
pub fn doNotOptimize(value: var) void {
// LLVM triggers an assert if we pass non-trivial types as inputs for the
// asm volatile expression.
// Workaround until asm support is better on Zig's end.
const T = @typeOf(value);
const typeId = @typeId(T);
switch (typeId) {
.Bool, .Int, .Float => {
asm volatile (""
:
: [_] "r,m" (value)
: "memory"
);
},
.Optional => {
if (value) |v| doNotOptimize(v);
},
.Struct => {
inline for (comptime std.meta.fields(T)) |field| {
doNotOptimize(@field(value, field.name));
}
},
.Type, .Void, .NoReturn, .ComptimeFloat, .ComptimeInt, .Undefined, .Null, .Fn, .BoundFn => @compileError("doNotOptimize makes no sense for " ++ @tagName(typeId)),
else => @compileError("doNotOptimize is not implemented for " ++ @tagName(typeId)),
}
}
pub fn clobberMemory() void {
asm volatile (""
:
:
: "memory"
);
}
test "benchmark" {
const benchSleep57 = struct {
fn benchSleep57(ctx: *Context) void {
while (ctx.run()) {
time.sleep(57 * time.millisecond);
}
}
}.benchSleep57;
std.debug.warn("\n");
benchmark("Sleep57", benchSleep57);
}
test "benchmarkArgs" {
const benchSleep = struct {
fn benchSleep(ctx: *Context, ms: u32) void {
while (ctx.run()) {
time.sleep(ms * time.millisecond);
}
}
}.benchSleep;
std.debug.warn("\n");
benchmarkArgs("Sleep", benchSleep, [_]u32{ 20, 30, 57 });
}
test "benchmarkArgs types" {
const benchMin = struct {
fn benchMin(ctx: *Context, comptime intType: type) void {
while (ctx.run()) {
time.sleep(std.math.min(37, 48) * time.millisecond);
}
}
}.benchMin;
std.debug.warn("\n");
benchmarkArgs("Min", benchMin, [_]type{ u32, u64 });
}
test "benchmark custom timing" {
const sleep = struct {
fn sleep(ctx: *Context) void {
while (ctx.runExplicitTiming()) {
time.sleep(30 * time.millisecond);
ctx.startTimer();
defer ctx.stopTimer();
time.sleep(10 * time.millisecond);
}
}
}.sleep;
std.debug.warn("\n");
benchmark("sleep", sleep);
}
|
bench.zig
|
const std = @import("std");
const Wat = @import("../wat.zig");
const Instance = @import("../instance.zig");
test "i32 math" {
var fbs = std.io.fixedBufferStream(
\\(module
\\ (func (result i32)
\\ i32.const 40
\\ i32.const 2
\\ i32.add)
\\ (func (result i32)
\\ i32.const 40
\\ i32.const 2
\\ i32.sub)
\\ (func (result i32)
\\ i32.const 40
\\ i32.const 2
\\ i32.mul)
\\ (func (result i32)
\\ i32.const 40
\\ i32.const 2
\\ i32.div_s)
\\ (export "add" (func 0))
\\ (export "sub" (func 1))
\\ (export "mul" (func 2))
\\ (export "div" (func 3)))
);
var module = try Wat.parse(std.testing.allocator, fbs.reader());
defer module.deinit();
var instance = try module.instantiate(std.testing.allocator, null, struct {});
defer instance.deinit();
{
const result = try instance.call("add", .{});
try std.testing.expectEqual(@as(i32, 42), result.?.I32);
}
{
const result = try instance.call("sub", .{});
try std.testing.expectEqual(@as(i32, 38), result.?.I32);
}
{
const result = try instance.call("mul", .{});
try std.testing.expectEqual(@as(i32, 80), result.?.I32);
}
{
const result = try instance.call("div", .{});
try std.testing.expectEqual(@as(i32, 20), result.?.I32);
}
}
test "i64 math" {
var fbs = std.io.fixedBufferStream(
\\(module
\\ (func (result i64)
\\ i64.const 40
\\ i64.const 2
\\ i64.add)
\\ (func (result i64)
\\ i64.const 40
\\ i64.const 2
\\ i64.sub)
\\ (func (result i64)
\\ i64.const 40
\\ i64.const 2
\\ i64.mul)
\\ (func (result i64)
\\ i64.const 40
\\ i64.const 2
\\ i64.div_s)
\\ (export "add" (func 0))
\\ (export "sub" (func 1))
\\ (export "mul" (func 2))
\\ (export "div" (func 3)))
);
var module = try Wat.parse(std.testing.allocator, fbs.reader());
defer module.deinit();
var instance = try module.instantiate(std.testing.allocator, null, struct {});
defer instance.deinit();
{
const result = try instance.call("add", .{});
try std.testing.expectEqual(@as(i64, 42), result.?.I64);
}
{
const result = try instance.call("sub", .{});
try std.testing.expectEqual(@as(i64, 38), result.?.I64);
}
{
const result = try instance.call("mul", .{});
try std.testing.expectEqual(@as(i64, 80), result.?.I64);
}
{
const result = try instance.call("div", .{});
try std.testing.expectEqual(@as(i64, 20), result.?.I64);
}
}
test "f32 math" {
var fbs = std.io.fixedBufferStream(
\\(module
\\ (func (result f32)
\\ f32.const 40
\\ f32.const 2
\\ f32.add)
\\ (func (result f32)
\\ f32.const 40
\\ f32.const 2
\\ f32.sub)
\\ (func (result f32)
\\ f32.const 40
\\ f32.const 2
\\ f32.mul)
\\ (func (result f32)
\\ f32.const 40
\\ f32.const 2
\\ f32.div)
\\ (export "add" (func 0))
\\ (export "sub" (func 1))
\\ (export "mul" (func 2))
\\ (export "div" (func 3)))
);
var module = try Wat.parse(std.testing.allocator, fbs.reader());
defer module.deinit();
var instance = try module.instantiate(std.testing.allocator, null, struct {});
defer instance.deinit();
{
const result = try instance.call("add", .{});
try std.testing.expectEqual(@as(f32, 42), result.?.F32);
}
{
const result = try instance.call("sub", .{});
try std.testing.expectEqual(@as(f32, 38), result.?.F32);
}
{
const result = try instance.call("mul", .{});
try std.testing.expectEqual(@as(f32, 80), result.?.F32);
}
{
const result = try instance.call("div", .{});
try std.testing.expectEqual(@as(f32, 20), result.?.F32);
}
}
test "f64 math" {
var fbs = std.io.fixedBufferStream(
\\(module
\\ (func (result f64)
\\ f64.const 1
\\ f64.const 2
\\ f64.add)
\\ (func (result f64)
\\ f64.const 1
\\ f64.const 2
\\ f64.sub)
\\ (func (result f64)
\\ f64.const 1
\\ f64.const 2
\\ f64.mul)
\\ (func (result f64)
\\ f64.const 1
\\ f64.const 2
\\ f64.div)
\\ (export "add" (func 0))
\\ (export "sub" (func 1))
\\ (export "mul" (func 2))
\\ (export "div" (func 3)))
);
var module = try Wat.parse(std.testing.allocator, fbs.reader());
defer module.deinit();
var instance = try module.instantiate(std.testing.allocator, null, struct {});
defer instance.deinit();
{
const result = try instance.call("add", .{});
try std.testing.expectEqual(@as(f64, 3), result.?.F64);
}
{
const result = try instance.call("sub", .{});
try std.testing.expectEqual(@as(f64, -1), result.?.F64);
}
{
const result = try instance.call("mul", .{});
try std.testing.expectEqual(@as(f64, 2), result.?.F64);
}
{
const result = try instance.call("div", .{});
try std.testing.expectEqual(@as(f64, 0.5), result.?.F64);
}
}
test "call with args" {
var fbs = std.io.fixedBufferStream(
\\(module
\\ (func (param i32) (param i32) (result i32)
\\ local.get 0
\\ local.get 1
\\ i32.add)
\\ (func (param i32) (param i32) (result i32) (local i32) (local i64) (local f64)
\\ local.get 0
\\ local.get 1
\\ i32.add)
\\ (export "add" (func 0))
\\ (export "addtemp" (func 1)))
);
var module = try Wat.parse(std.testing.allocator, fbs.reader());
defer module.deinit();
var instance = try module.instantiate(std.testing.allocator, null, struct {});
defer instance.deinit();
try std.testing.expectError(error.TypeSignatureMismatch, instance.call("add", &[0]Instance.Value{}));
{
const result = try instance.call("add", .{ @as(i32, 16), @as(i32, 8) });
try std.testing.expectEqual(@as(i32, 24), result.?.I32);
}
{
const result = try instance.call("addtemp", .{ @as(i32, 16), @as(i32, 8) });
try std.testing.expectEqual(@as(i32, 24), result.?.I32);
}
}
test "call call call" {
var fbs = std.io.fixedBufferStream(
\\(module
\\ (func (param i32) (param i32) (result i32)
\\ local.get 0
\\ local.get 1
\\ i32.add)
\\ (func (param i32) (param i32) (result i32)
\\ local.get 0
\\ local.get 1
\\ call 0
\\ i32.const 2
\\ i32.mul)
\\ (export "addDouble" (func 1)))
);
var module = try Wat.parse(std.testing.allocator, fbs.reader());
defer module.deinit();
var instance = try module.instantiate(std.testing.allocator, null, struct {});
defer instance.deinit();
{
const result = try instance.call("addDouble", .{ @as(i32, 16), @as(i32, 8) });
try std.testing.expectEqual(@as(i32, 48), result.?.I32);
}
}
|
src/func/basic.zig
|
const std = @import("std");
const Type = @import("../type.zig").Type;
const Allocator = std.mem.Allocator;
pub const Node = extern union {
/// If the tag value is less than Tag.no_payload_count, then no pointer
/// dereference is needed.
tag_if_small_enough: usize,
ptr_otherwise: *Payload,
pub const Tag = enum {
/// Declarations add themselves to the correct scopes and should not be emitted as this tag.
declaration,
null_literal,
undefined_literal,
/// opaque {}
opaque_literal,
true_literal,
false_literal,
empty_block,
return_void,
zero_literal,
one_literal,
void_type,
noreturn_type,
@"anytype",
@"continue",
@"break",
/// pub usingnamespace @import("std").c.builtins;
usingnamespace_builtins,
// After this, the tag requires a payload.
integer_literal,
float_literal,
string_literal,
char_literal,
enum_literal,
/// "string"[0..end]
string_slice,
identifier,
@"if",
/// if (!operand) break;
if_not_break,
@"while",
/// while (true) operand
while_true,
@"switch",
/// else => operand,
switch_else,
/// items => body,
switch_prong,
break_val,
@"return",
field_access,
array_access,
call,
var_decl,
func,
warning,
/// All enums are non-exhaustive
@"enum",
@"struct",
@"union",
@"comptime",
@"defer",
array_init,
tuple,
container_init,
std_meta_cast,
/// _ = operand;
discard,
// a + b
add,
// a = b
add_assign,
// c = (a = b)
add_wrap,
add_wrap_assign,
sub,
sub_assign,
sub_wrap,
sub_wrap_assign,
mul,
mul_assign,
mul_wrap,
mul_wrap_assign,
div,
div_assign,
shl,
shl_assign,
shr,
shr_assign,
mod,
mod_assign,
@"and",
@"or",
less_than,
less_than_equal,
greater_than,
greater_than_equal,
equal,
not_equal,
bit_and,
bit_and_assign,
bit_or,
bit_or_assign,
bit_xor,
bit_xor_assign,
array_cat,
ellipsis3,
assign,
log2_int_type,
/// @import("std").math.Log2Int(operand)
std_math_Log2Int,
/// @intCast(lhs, rhs)
int_cast,
/// @import("std").meta.promoteIntLiteral(value, type, radix)
std_meta_promoteIntLiteral,
/// @import("std").meta.alignment(value)
std_meta_alignment,
/// @rem(lhs, rhs)
rem,
/// @divTrunc(lhs, rhs)
div_trunc,
/// @boolToInt(operand)
bool_to_int,
/// @as(lhs, rhs)
as,
/// @truncate(lhs, rhs)
truncate,
/// @bitCast(lhs, rhs)
bit_cast,
/// @floatCast(lhs, rhs)
float_cast,
/// @floatToInt(lhs, rhs)
float_to_int,
/// @intToFloat(lhs, rhs)
int_to_float,
/// @intToEnum(lhs, rhs)
int_to_enum,
/// @enumToInt(operand)
enum_to_int,
/// @intToPtr(lhs, rhs)
int_to_ptr,
/// @ptrToInt(operand)
ptr_to_int,
/// @alignCast(lhs, rhs)
align_cast,
/// @ptrCast(lhs, rhs)
ptr_cast,
/// @divExact(lhs, rhs)
div_exact,
/// @byteOffsetOf(lhs, rhs)
byte_offset_of,
/// @shuffle(type, a, b, mask)
shuffle,
asm_simple,
negate,
negate_wrap,
bit_not,
not,
address_of,
/// .?
unwrap,
/// .*
deref,
block,
/// { operand }
block_single,
sizeof,
alignof,
typeof,
typeinfo,
type,
optional_type,
c_pointer,
single_pointer,
array_type,
null_sentinel_array_type,
/// @import("std").meta.sizeof(operand)
std_meta_sizeof,
/// @import("std").meta.shuffleVectorIndex(lhs, rhs)
std_meta_shuffle_vector_index,
/// @import("std").meta.Vector(lhs, rhs)
std_meta_vector,
/// @import("std").mem.zeroes(operand)
std_mem_zeroes,
/// @import("std").mem.zeroInit(lhs, rhs)
std_mem_zeroinit,
// pub const name = @compileError(msg);
fail_decl,
// var actual = mangled;
arg_redecl,
/// pub const alias = actual;
alias,
/// const name = init;
var_simple,
/// pub const name = init;
pub_var_simple,
/// pub const enum_field_name = @enumToInt(enum_name.field_name);
pub_enum_redecl,
enum_redecl,
/// pub inline fn name(params) return_type body
pub_inline_fn,
/// [0]type{}
empty_array,
/// [1]type{val} ** count
array_filler,
pub const last_no_payload_tag = Tag.usingnamespace_builtins;
pub const no_payload_count = @enumToInt(last_no_payload_tag) + 1;
pub fn Type(comptime t: Tag) type {
return switch (t) {
.declaration,
.null_literal,
.undefined_literal,
.opaque_literal,
.true_literal,
.false_literal,
.empty_block,
.usingnamespace_builtins,
.return_void,
.zero_literal,
.one_literal,
.void_type,
.noreturn_type,
.@"anytype",
.@"continue",
.@"break",
=> @compileError("Type Tag " ++ @tagName(t) ++ " has no payload"),
.std_mem_zeroes,
.@"return",
.@"comptime",
.@"defer",
.asm_simple,
.discard,
.std_math_Log2Int,
.negate,
.negate_wrap,
.bit_not,
.not,
.optional_type,
.address_of,
.unwrap,
.deref,
.ptr_to_int,
.enum_to_int,
.empty_array,
.while_true,
.if_not_break,
.switch_else,
.block_single,
.std_meta_sizeof,
.std_meta_alignment,
.bool_to_int,
.sizeof,
.alignof,
.typeof,
.typeinfo,
=> Payload.UnOp,
.add,
.add_assign,
.add_wrap,
.add_wrap_assign,
.sub,
.sub_assign,
.sub_wrap,
.sub_wrap_assign,
.mul,
.mul_assign,
.mul_wrap,
.mul_wrap_assign,
.div,
.div_assign,
.shl,
.shl_assign,
.shr,
.shr_assign,
.mod,
.mod_assign,
.@"and",
.@"or",
.less_than,
.less_than_equal,
.greater_than,
.greater_than_equal,
.equal,
.not_equal,
.bit_and,
.bit_and_assign,
.bit_or,
.bit_or_assign,
.bit_xor,
.bit_xor_assign,
.div_trunc,
.rem,
.int_cast,
.as,
.truncate,
.bit_cast,
.float_cast,
.float_to_int,
.int_to_float,
.int_to_enum,
.int_to_ptr,
.array_cat,
.ellipsis3,
.assign,
.align_cast,
.array_access,
.std_mem_zeroinit,
.std_meta_shuffle_vector_index,
.std_meta_vector,
.ptr_cast,
.div_exact,
.byte_offset_of,
=> Payload.BinOp,
.integer_literal,
.float_literal,
.string_literal,
.char_literal,
.enum_literal,
.identifier,
.warning,
.type,
=> Payload.Value,
.@"if" => Payload.If,
.@"while" => Payload.While,
.@"switch", .array_init, .switch_prong => Payload.Switch,
.break_val => Payload.BreakVal,
.call => Payload.Call,
.var_decl => Payload.VarDecl,
.func => Payload.Func,
.@"enum" => Payload.Enum,
.@"struct", .@"union" => Payload.Record,
.tuple => Payload.TupleInit,
.container_init => Payload.ContainerInit,
.std_meta_cast => Payload.Infix,
.std_meta_promoteIntLiteral => Payload.PromoteIntLiteral,
.block => Payload.Block,
.c_pointer, .single_pointer => Payload.Pointer,
.array_type, .null_sentinel_array_type => Payload.Array,
.arg_redecl, .alias, .fail_decl => Payload.ArgRedecl,
.log2_int_type => Payload.Log2IntType,
.var_simple, .pub_var_simple => Payload.SimpleVarDecl,
.pub_enum_redecl, .enum_redecl => Payload.EnumRedecl,
.array_filler => Payload.ArrayFiller,
.pub_inline_fn => Payload.PubInlineFn,
.field_access => Payload.FieldAccess,
.string_slice => Payload.StringSlice,
.shuffle => Payload.Shuffle,
};
}
pub fn init(comptime t: Tag) Node {
comptime std.debug.assert(@enumToInt(t) < Tag.no_payload_count);
return .{ .tag_if_small_enough = @enumToInt(t) };
}
pub fn create(comptime t: Tag, ally: *Allocator, data: Data(t)) error{OutOfMemory}!Node {
const ptr = try ally.create(t.Type());
ptr.* = .{
.base = .{ .tag = t },
.data = data,
};
return Node{ .ptr_otherwise = &ptr.base };
}
pub fn Data(comptime t: Tag) type {
return std.meta.fieldInfo(t.Type(), .data).field_type;
}
};
pub fn tag(self: Node) Tag {
if (self.tag_if_small_enough < Tag.no_payload_count) {
return @intToEnum(Tag, @intCast(std.meta.Tag(Tag), self.tag_if_small_enough));
} else {
return self.ptr_otherwise.tag;
}
}
pub fn castTag(self: Node, comptime t: Tag) ?*t.Type() {
if (self.tag_if_small_enough < Tag.no_payload_count)
return null;
if (self.ptr_otherwise.tag == t)
return @fieldParentPtr(t.Type(), "base", self.ptr_otherwise);
return null;
}
pub fn initPayload(payload: *Payload) Node {
std.debug.assert(@enumToInt(payload.tag) >= Tag.no_payload_count);
return .{ .ptr_otherwise = payload };
}
pub fn isNoreturn(node: Node, break_counts: bool) bool {
switch (node.tag()) {
.block => {
const block_node = node.castTag(.block).?;
if (block_node.data.stmts.len == 0) return false;
const last = block_node.data.stmts[block_node.data.stmts.len - 1];
return last.isNoreturn(break_counts);
},
.@"switch" => {
const switch_node = node.castTag(.@"switch").?;
for (switch_node.data.cases) |case| {
const body = if (case.castTag(.switch_else)) |some|
some.data
else if (case.castTag(.switch_prong)) |some|
some.data.cond
else
unreachable;
if (!body.isNoreturn(break_counts)) return false;
}
return true;
},
.@"return", .return_void => return true,
.@"break" => if (break_counts) return true,
else => {},
}
return false;
}
};
pub const Payload = struct {
tag: Node.Tag,
pub const Infix = struct {
base: Payload,
data: struct {
lhs: Node,
rhs: Node,
},
};
pub const Value = struct {
base: Payload,
data: []const u8,
};
pub const UnOp = struct {
base: Payload,
data: Node,
};
pub const BinOp = struct {
base: Payload,
data: struct {
lhs: Node,
rhs: Node,
},
};
pub const If = struct {
base: Payload,
data: struct {
cond: Node,
then: Node,
@"else": ?Node,
},
};
pub const While = struct {
base: Payload,
data: struct {
cond: Node,
body: Node,
cont_expr: ?Node,
},
};
pub const Switch = struct {
base: Payload,
data: struct {
cond: Node,
cases: []Node,
},
};
pub const BreakVal = struct {
base: Payload,
data: struct {
label: ?[]const u8,
val: Node,
},
};
pub const Call = struct {
base: Payload,
data: struct {
lhs: Node,
args: []Node,
},
};
pub const VarDecl = struct {
base: Payload,
data: struct {
is_pub: bool,
is_const: bool,
is_extern: bool,
is_export: bool,
is_threadlocal: bool,
alignment: ?c_uint,
linksection_string: ?[]const u8,
name: []const u8,
type: Node,
init: ?Node,
},
};
pub const Func = struct {
base: Payload,
data: struct {
is_pub: bool,
is_extern: bool,
is_export: bool,
is_var_args: bool,
name: ?[]const u8,
linksection_string: ?[]const u8,
explicit_callconv: ?std.builtin.CallingConvention,
params: []Param,
return_type: Node,
body: ?Node,
alignment: ?c_uint,
},
};
pub const Param = struct {
is_noalias: bool,
name: ?[]const u8,
type: Node,
};
pub const Enum = struct {
base: Payload,
data: struct {
int_type: Node,
fields: []Field,
},
pub const Field = struct {
name: []const u8,
value: ?Node,
};
};
pub const Record = struct {
base: Payload,
data: struct {
is_packed: bool,
fields: []Field,
},
pub const Field = struct {
name: []const u8,
type: Node,
alignment: ?c_uint,
};
};
pub const TupleInit = struct {
base: Payload,
data: []Node,
};
pub const ContainerInit = struct {
base: Payload,
data: struct {
lhs: Node,
inits: []Initializer,
},
pub const Initializer = struct {
name: []const u8,
value: Node,
};
};
pub const Block = struct {
base: Payload,
data: struct {
label: ?[]const u8,
stmts: []Node,
},
};
pub const Array = struct {
base: Payload,
data: ArrayTypeInfo,
pub const ArrayTypeInfo = struct {
elem_type: Node,
len: usize,
};
};
pub const Pointer = struct {
base: Payload,
data: struct {
elem_type: Node,
is_const: bool,
is_volatile: bool,
},
};
pub const ArgRedecl = struct {
base: Payload,
data: struct {
actual: []const u8,
mangled: []const u8,
},
};
pub const Log2IntType = struct {
base: Payload,
data: std.math.Log2Int(u64),
};
pub const SimpleVarDecl = struct {
base: Payload,
data: struct {
name: []const u8,
init: Node,
},
};
pub const EnumRedecl = struct {
base: Payload,
data: struct {
enum_val_name: []const u8,
field_name: []const u8,
enum_name: []const u8,
},
};
pub const ArrayFiller = struct {
base: Payload,
data: struct {
type: Node,
filler: Node,
count: usize,
},
};
pub const PubInlineFn = struct {
base: Payload,
data: struct {
name: []const u8,
params: []Param,
return_type: Node,
body: Node,
},
};
pub const FieldAccess = struct {
base: Payload,
data: struct {
lhs: Node,
field_name: []const u8,
},
};
pub const PromoteIntLiteral = struct {
base: Payload,
data: struct {
value: Node,
type: Node,
radix: Node,
},
};
pub const StringSlice = struct {
base: Payload,
data: struct {
string: Node,
end: usize,
},
};
pub const Shuffle = struct {
base: Payload,
data: struct {
element_type: Node,
a: Node,
b: Node,
mask_vector: Node,
},
};
};
/// Converts the nodes into a Zig ast.
/// Caller must free the source slice.
pub fn render(gpa: *Allocator, nodes: []const Node) !std.zig.ast.Tree {
var ctx = Context{
.gpa = gpa,
.buf = std.ArrayList(u8).init(gpa),
};
defer ctx.buf.deinit();
defer ctx.nodes.deinit(gpa);
defer ctx.extra_data.deinit(gpa);
defer ctx.tokens.deinit(gpa);
// Estimate that each top level node has 10 child nodes.
const estimated_node_count = nodes.len * 10;
try ctx.nodes.ensureCapacity(gpa, estimated_node_count);
// Estimate that each each node has 2 tokens.
const estimated_tokens_count = estimated_node_count * 2;
try ctx.tokens.ensureCapacity(gpa, estimated_tokens_count);
// Estimate that each each token is 3 bytes long.
const estimated_buf_len = estimated_tokens_count * 3;
try ctx.buf.ensureCapacity(estimated_buf_len);
ctx.nodes.appendAssumeCapacity(.{
.tag = .root,
.main_token = 0,
.data = .{
.lhs = undefined,
.rhs = undefined,
},
});
const root_members = blk: {
var result = std.ArrayList(NodeIndex).init(gpa);
defer result.deinit();
for (nodes) |node| {
const res = try renderNode(&ctx, node);
if (node.tag() == .warning) continue;
try result.append(res);
}
break :blk try ctx.listToSpan(result.items);
};
ctx.nodes.items(.data)[0] = .{
.lhs = root_members.start,
.rhs = root_members.end,
};
try ctx.tokens.append(gpa, .{
.tag = .eof,
.start = @intCast(u32, ctx.buf.items.len),
});
return std.zig.ast.Tree{
.source = ctx.buf.toOwnedSlice(),
.tokens = ctx.tokens.toOwnedSlice(),
.nodes = ctx.nodes.toOwnedSlice(),
.extra_data = ctx.extra_data.toOwnedSlice(gpa),
.errors = &.{},
};
}
const NodeIndex = std.zig.ast.Node.Index;
const NodeSubRange = std.zig.ast.Node.SubRange;
const TokenIndex = std.zig.ast.TokenIndex;
const TokenTag = std.zig.Token.Tag;
const Context = struct {
gpa: *Allocator,
buf: std.ArrayList(u8) = .{},
nodes: std.zig.ast.NodeList = .{},
extra_data: std.ArrayListUnmanaged(std.zig.ast.Node.Index) = .{},
tokens: std.zig.ast.TokenList = .{},
fn addTokenFmt(c: *Context, tag: TokenTag, comptime format: []const u8, args: anytype) Allocator.Error!TokenIndex {
const start_index = c.buf.items.len;
try c.buf.writer().print(format ++ " ", args);
try c.tokens.append(c.gpa, .{
.tag = tag,
.start = @intCast(u32, start_index),
});
return @intCast(u32, c.tokens.len - 1);
}
fn addToken(c: *Context, tag: TokenTag, bytes: []const u8) Allocator.Error!TokenIndex {
return addTokenFmt(c, tag, "{s}", .{bytes});
}
fn addIdentifier(c: *Context, bytes: []const u8) Allocator.Error!TokenIndex {
return addTokenFmt(c, .identifier, "{s}", .{std.zig.fmtId(bytes)});
}
fn listToSpan(c: *Context, list: []const NodeIndex) Allocator.Error!NodeSubRange {
try c.extra_data.appendSlice(c.gpa, list);
return NodeSubRange{
.start = @intCast(NodeIndex, c.extra_data.items.len - list.len),
.end = @intCast(NodeIndex, c.extra_data.items.len),
};
}
fn addNode(c: *Context, elem: std.zig.ast.NodeList.Elem) Allocator.Error!NodeIndex {
const result = @intCast(NodeIndex, c.nodes.len);
try c.nodes.append(c.gpa, elem);
return result;
}
fn addExtra(c: *Context, extra: anytype) Allocator.Error!NodeIndex {
const fields = std.meta.fields(@TypeOf(extra));
try c.extra_data.ensureCapacity(c.gpa, c.extra_data.items.len + fields.len);
const result = @intCast(u32, c.extra_data.items.len);
inline for (fields) |field| {
comptime std.debug.assert(field.field_type == NodeIndex);
c.extra_data.appendAssumeCapacity(@field(extra, field.name));
}
return result;
}
};
fn renderNodes(c: *Context, nodes: []const Node) Allocator.Error!NodeSubRange {
var result = std.ArrayList(NodeIndex).init(c.gpa);
defer result.deinit();
for (nodes) |node| {
const res = try renderNode(c, node);
if (node.tag() == .warning) continue;
try result.append(res);
}
return try c.listToSpan(result.items);
}
fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
switch (node.tag()) {
.declaration => unreachable,
.warning => {
const payload = node.castTag(.warning).?.data;
try c.buf.appendSlice(payload);
try c.buf.append('\n');
return @as(NodeIndex, 0); // error: integer value 0 cannot be coerced to type 'std.mem.Allocator.Error!u32'
},
.usingnamespace_builtins => {
// pub usingnamespace @import("std").c.builtins;
_ = try c.addToken(.keyword_pub, "pub");
const usingnamespace_token = try c.addToken(.keyword_usingnamespace, "usingnamespace");
const import_node = try renderStdImport(c, "c", "builtins");
_ = try c.addToken(.semicolon, ";");
return c.addNode(.{
.tag = .@"usingnamespace",
.main_token = usingnamespace_token,
.data = .{
.lhs = import_node,
.rhs = undefined,
},
});
},
.std_math_Log2Int => {
const payload = node.castTag(.std_math_Log2Int).?.data;
const import_node = try renderStdImport(c, "math", "Log2Int");
return renderCall(c, import_node, &.{payload});
},
.std_meta_cast => {
const payload = node.castTag(.std_meta_cast).?.data;
const import_node = try renderStdImport(c, "meta", "cast");
return renderCall(c, import_node, &.{ payload.lhs, payload.rhs });
},
.std_meta_promoteIntLiteral => {
const payload = node.castTag(.std_meta_promoteIntLiteral).?.data;
const import_node = try renderStdImport(c, "meta", "promoteIntLiteral");
return renderCall(c, import_node, &.{ payload.type, payload.value, payload.radix });
},
.std_meta_alignment => {
const payload = node.castTag(.std_meta_alignment).?.data;
const import_node = try renderStdImport(c, "meta", "alignment");
return renderCall(c, import_node, &.{payload});
},
.std_meta_sizeof => {
const payload = node.castTag(.std_meta_sizeof).?.data;
const import_node = try renderStdImport(c, "meta", "sizeof");
return renderCall(c, import_node, &.{payload});
},
.std_mem_zeroes => {
const payload = node.castTag(.std_mem_zeroes).?.data;
const import_node = try renderStdImport(c, "mem", "zeroes");
return renderCall(c, import_node, &.{payload});
},
.std_mem_zeroinit => {
const payload = node.castTag(.std_mem_zeroinit).?.data;
const import_node = try renderStdImport(c, "mem", "zeroInit");
return renderCall(c, import_node, &.{ payload.lhs, payload.rhs });
},
.std_meta_shuffle_vector_index => {
const payload = node.castTag(.std_meta_shuffle_vector_index).?.data;
const import_node = try renderStdImport(c, "meta", "shuffleVectorIndex");
return renderCall(c, import_node, &.{ payload.lhs, payload.rhs });
},
.std_meta_vector => {
const payload = node.castTag(.std_meta_vector).?.data;
const import_node = try renderStdImport(c, "meta", "Vector");
return renderCall(c, import_node, &.{ payload.lhs, payload.rhs });
},
.call => {
const payload = node.castTag(.call).?.data;
const lhs = try renderNode(c, payload.lhs);
return renderCall(c, lhs, payload.args);
},
.null_literal => return c.addNode(.{
.tag = .null_literal,
.main_token = try c.addToken(.keyword_null, "null"),
.data = undefined,
}),
.undefined_literal => return c.addNode(.{
.tag = .undefined_literal,
.main_token = try c.addToken(.keyword_undefined, "undefined"),
.data = undefined,
}),
.true_literal => return c.addNode(.{
.tag = .true_literal,
.main_token = try c.addToken(.keyword_true, "true"),
.data = undefined,
}),
.false_literal => return c.addNode(.{
.tag = .false_literal,
.main_token = try c.addToken(.keyword_false, "false"),
.data = undefined,
}),
.zero_literal => return c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addToken(.integer_literal, "0"),
.data = undefined,
}),
.one_literal => return c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addToken(.integer_literal, "1"),
.data = undefined,
}),
.void_type => return c.addNode(.{
.tag = .identifier,
.main_token = try c.addToken(.identifier, "void"),
.data = undefined,
}),
.noreturn_type => return c.addNode(.{
.tag = .identifier,
.main_token = try c.addToken(.identifier, "noreturn"),
.data = undefined,
}),
.@"continue" => return c.addNode(.{
.tag = .@"continue",
.main_token = try c.addToken(.keyword_continue, "continue"),
.data = .{
.lhs = 0,
.rhs = undefined,
},
}),
.return_void => return c.addNode(.{
.tag = .@"return",
.main_token = try c.addToken(.keyword_return, "return"),
.data = .{
.lhs = 0,
.rhs = undefined,
},
}),
.@"break" => return c.addNode(.{
.tag = .@"break",
.main_token = try c.addToken(.keyword_break, "break"),
.data = .{
.lhs = 0,
.rhs = 0,
},
}),
.break_val => {
const payload = node.castTag(.break_val).?.data;
const tok = try c.addToken(.keyword_break, "break");
const break_label = if (payload.label) |some| blk: {
_ = try c.addToken(.colon, ":");
break :blk try c.addIdentifier(some);
} else 0;
return c.addNode(.{
.tag = .@"break",
.main_token = tok,
.data = .{
.lhs = break_label,
.rhs = try renderNode(c, payload.val),
},
});
},
.@"return" => {
const payload = node.castTag(.@"return").?.data;
return c.addNode(.{
.tag = .@"return",
.main_token = try c.addToken(.keyword_return, "return"),
.data = .{
.lhs = try renderNode(c, payload),
.rhs = undefined,
},
});
},
.@"comptime" => {
const payload = node.castTag(.@"comptime").?.data;
return c.addNode(.{
.tag = .@"comptime",
.main_token = try c.addToken(.keyword_comptime, "comptime"),
.data = .{
.lhs = try renderNode(c, payload),
.rhs = undefined,
},
});
},
.@"defer" => {
const payload = node.castTag(.@"defer").?.data;
return c.addNode(.{
.tag = .@"defer",
.main_token = try c.addToken(.keyword_defer, "defer"),
.data = .{
.lhs = undefined,
.rhs = try renderNode(c, payload),
},
});
},
.asm_simple => {
const payload = node.castTag(.asm_simple).?.data;
const asm_token = try c.addToken(.keyword_asm, "asm");
_ = try c.addToken(.l_paren, "(");
return c.addNode(.{
.tag = .asm_simple,
.main_token = asm_token,
.data = .{
.lhs = try renderNode(c, payload),
.rhs = try c.addToken(.r_paren, ")"),
},
});
},
.type => {
const payload = node.castTag(.type).?.data;
return c.addNode(.{
.tag = .identifier,
.main_token = try c.addToken(.identifier, payload),
.data = undefined,
});
},
.log2_int_type => {
const payload = node.castTag(.log2_int_type).?.data;
return c.addNode(.{
.tag = .identifier,
.main_token = try c.addTokenFmt(.identifier, "u{d}", .{payload}),
.data = undefined,
});
},
.identifier => {
const payload = node.castTag(.identifier).?.data;
return c.addNode(.{
.tag = .identifier,
.main_token = try c.addIdentifier(payload),
.data = undefined,
});
},
.float_literal => {
const payload = node.castTag(.float_literal).?.data;
return c.addNode(.{
.tag = .float_literal,
.main_token = try c.addToken(.float_literal, payload),
.data = undefined,
});
},
.integer_literal => {
const payload = node.castTag(.integer_literal).?.data;
return c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addToken(.integer_literal, payload),
.data = undefined,
});
},
.string_literal => {
const payload = node.castTag(.string_literal).?.data;
return c.addNode(.{
.tag = .identifier,
.main_token = try c.addToken(.string_literal, payload),
.data = undefined,
});
},
.char_literal => {
const payload = node.castTag(.char_literal).?.data;
return c.addNode(.{
.tag = .identifier,
.main_token = try c.addToken(.char_literal, payload),
.data = undefined,
});
},
.enum_literal => {
const payload = node.castTag(.enum_literal).?.data;
_ = try c.addToken(.period, ".");
return c.addNode(.{
.tag = .enum_literal,
.main_token = try c.addToken(.identifier, payload),
.data = undefined,
});
},
.string_slice => {
const payload = node.castTag(.string_slice).?.data;
const string = try renderNode(c, payload.string);
const l_bracket = try c.addToken(.l_bracket, "[");
const start = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addToken(.integer_literal, "0"),
.data = undefined,
});
_ = try c.addToken(.ellipsis2, "..");
const end = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addTokenFmt(.integer_literal, "{d}", .{payload.end}),
.data = undefined,
});
_ = try c.addToken(.r_bracket, "]");
return c.addNode(.{
.tag = .slice,
.main_token = l_bracket,
.data = .{
.lhs = string,
.rhs = try c.addExtra(std.zig.ast.Node.Slice{
.start = start,
.end = end,
}),
},
});
},
.fail_decl => {
const payload = node.castTag(.fail_decl).?.data;
// pub const name = @compileError(msg);
_ = try c.addToken(.keyword_pub, "pub");
const const_tok = try c.addToken(.keyword_const, "const");
_ = try c.addIdentifier(payload.actual);
_ = try c.addToken(.equal, "=");
const compile_error_tok = try c.addToken(.builtin, "@compileError");
_ = try c.addToken(.l_paren, "(");
const err_msg_tok = try c.addTokenFmt(.string_literal, "\"{}\"", .{std.zig.fmtEscapes(payload.mangled)});
const err_msg = try c.addNode(.{
.tag = .string_literal,
.main_token = err_msg_tok,
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
const compile_error = try c.addNode(.{
.tag = .builtin_call_two,
.main_token = compile_error_tok,
.data = .{
.lhs = err_msg,
.rhs = 0,
},
});
_ = try c.addToken(.semicolon, ";");
return c.addNode(.{
.tag = .simple_var_decl,
.main_token = const_tok,
.data = .{
.lhs = 0,
.rhs = compile_error,
},
});
},
.pub_var_simple, .var_simple => {
const payload = @fieldParentPtr(Payload.SimpleVarDecl, "base", node.ptr_otherwise).data;
if (node.tag() == .pub_var_simple) _ = try c.addToken(.keyword_pub, "pub");
const const_tok = try c.addToken(.keyword_const, "const");
_ = try c.addIdentifier(payload.name);
_ = try c.addToken(.equal, "=");
const init = try renderNode(c, payload.init);
_ = try c.addToken(.semicolon, ";");
return c.addNode(.{
.tag = .simple_var_decl,
.main_token = const_tok,
.data = .{
.lhs = 0,
.rhs = init,
},
});
},
.var_decl => return renderVar(c, node),
.arg_redecl, .alias => {
const payload = @fieldParentPtr(Payload.ArgRedecl, "base", node.ptr_otherwise).data;
if (node.tag() == .alias) _ = try c.addToken(.keyword_pub, "pub");
const mut_tok = if (node.tag() == .alias)
try c.addToken(.keyword_const, "const")
else
try c.addToken(.keyword_var, "var");
_ = try c.addIdentifier(payload.actual);
_ = try c.addToken(.equal, "=");
const init = try c.addNode(.{
.tag = .identifier,
.main_token = try c.addIdentifier(payload.mangled),
.data = undefined,
});
_ = try c.addToken(.semicolon, ";");
return c.addNode(.{
.tag = .simple_var_decl,
.main_token = mut_tok,
.data = .{
.lhs = 0,
.rhs = init,
},
});
},
.int_cast => {
const payload = node.castTag(.int_cast).?.data;
return renderBuiltinCall(c, "@intCast", &.{ payload.lhs, payload.rhs });
},
.rem => {
const payload = node.castTag(.rem).?.data;
return renderBuiltinCall(c, "@rem", &.{ payload.lhs, payload.rhs });
},
.div_trunc => {
const payload = node.castTag(.div_trunc).?.data;
return renderBuiltinCall(c, "@divTrunc", &.{ payload.lhs, payload.rhs });
},
.bool_to_int => {
const payload = node.castTag(.bool_to_int).?.data;
return renderBuiltinCall(c, "@boolToInt", &.{payload});
},
.as => {
const payload = node.castTag(.as).?.data;
return renderBuiltinCall(c, "@as", &.{ payload.lhs, payload.rhs });
},
.truncate => {
const payload = node.castTag(.truncate).?.data;
return renderBuiltinCall(c, "@truncate", &.{ payload.lhs, payload.rhs });
},
.bit_cast => {
const payload = node.castTag(.bit_cast).?.data;
return renderBuiltinCall(c, "@bitCast", &.{ payload.lhs, payload.rhs });
},
.float_cast => {
const payload = node.castTag(.float_cast).?.data;
return renderBuiltinCall(c, "@floatCast", &.{ payload.lhs, payload.rhs });
},
.float_to_int => {
const payload = node.castTag(.float_to_int).?.data;
return renderBuiltinCall(c, "@floatToInt", &.{ payload.lhs, payload.rhs });
},
.int_to_float => {
const payload = node.castTag(.int_to_float).?.data;
return renderBuiltinCall(c, "@intToFloat", &.{ payload.lhs, payload.rhs });
},
.int_to_enum => {
const payload = node.castTag(.int_to_enum).?.data;
return renderBuiltinCall(c, "@intToEnum", &.{ payload.lhs, payload.rhs });
},
.enum_to_int => {
const payload = node.castTag(.enum_to_int).?.data;
return renderBuiltinCall(c, "@enumToInt", &.{payload});
},
.int_to_ptr => {
const payload = node.castTag(.int_to_ptr).?.data;
return renderBuiltinCall(c, "@intToPtr", &.{ payload.lhs, payload.rhs });
},
.ptr_to_int => {
const payload = node.castTag(.ptr_to_int).?.data;
return renderBuiltinCall(c, "@ptrToInt", &.{payload});
},
.align_cast => {
const payload = node.castTag(.align_cast).?.data;
return renderBuiltinCall(c, "@alignCast", &.{ payload.lhs, payload.rhs });
},
.ptr_cast => {
const payload = node.castTag(.ptr_cast).?.data;
return renderBuiltinCall(c, "@ptrCast", &.{ payload.lhs, payload.rhs });
},
.div_exact => {
const payload = node.castTag(.div_exact).?.data;
return renderBuiltinCall(c, "@divExact", &.{ payload.lhs, payload.rhs });
},
.byte_offset_of => {
const payload = node.castTag(.byte_offset_of).?.data;
return renderBuiltinCall(c, "@byteOffsetOf", &.{ payload.lhs, payload.rhs });
},
.sizeof => {
const payload = node.castTag(.sizeof).?.data;
return renderBuiltinCall(c, "@sizeOf", &.{payload});
},
.shuffle => {
const payload = node.castTag(.shuffle).?.data;
return renderBuiltinCall(c, "@shuffle", &.{
payload.element_type,
payload.a,
payload.b,
payload.mask_vector,
});
},
.alignof => {
const payload = node.castTag(.alignof).?.data;
return renderBuiltinCall(c, "@alignOf", &.{payload});
},
.typeof => {
const payload = node.castTag(.typeof).?.data;
return renderBuiltinCall(c, "@TypeOf", &.{payload});
},
.typeinfo => {
const payload = node.castTag(.typeinfo).?.data;
return renderBuiltinCall(c, "@typeInfo", &.{payload});
},
.negate => return renderPrefixOp(c, node, .negation, .minus, "-"),
.negate_wrap => return renderPrefixOp(c, node, .negation_wrap, .minus_percent, "-%"),
.bit_not => return renderPrefixOp(c, node, .bit_not, .tilde, "~"),
.not => return renderPrefixOp(c, node, .bool_not, .bang, "!"),
.optional_type => return renderPrefixOp(c, node, .optional_type, .question_mark, "?"),
.address_of => return renderPrefixOp(c, node, .address_of, .ampersand, "&"),
.deref => {
const payload = node.castTag(.deref).?.data;
const operand = try renderNodeGrouped(c, payload);
const deref_tok = try c.addToken(.period_asterisk, ".*");
return c.addNode(.{
.tag = .deref,
.main_token = deref_tok,
.data = .{
.lhs = operand,
.rhs = undefined,
},
});
},
.unwrap => {
const payload = node.castTag(.unwrap).?.data;
const operand = try renderNodeGrouped(c, payload);
const period = try c.addToken(.period, ".");
const question_mark = try c.addToken(.question_mark, "?");
return c.addNode(.{
.tag = .unwrap_optional,
.main_token = period,
.data = .{
.lhs = operand,
.rhs = question_mark,
},
});
},
.c_pointer, .single_pointer => {
const payload = @fieldParentPtr(Payload.Pointer, "base", node.ptr_otherwise).data;
const asterisk = if (node.tag() == .single_pointer)
try c.addToken(.asterisk, "*")
else blk: {
_ = try c.addToken(.l_bracket, "[");
const res = try c.addToken(.asterisk, "*");
_ = try c.addIdentifier("c");
_ = try c.addToken(.r_bracket, "]");
break :blk res;
};
if (payload.is_const) _ = try c.addToken(.keyword_const, "const");
if (payload.is_volatile) _ = try c.addToken(.keyword_volatile, "volatile");
const elem_type = try renderNodeGrouped(c, payload.elem_type);
return c.addNode(.{
.tag = .ptr_type_aligned,
.main_token = asterisk,
.data = .{
.lhs = 0,
.rhs = elem_type,
},
});
},
.add => return renderBinOpGrouped(c, node, .add, .plus, "+"),
.add_assign => return renderBinOp(c, node, .assign_add, .plus_equal, "+="),
.add_wrap => return renderBinOpGrouped(c, node, .add_wrap, .plus_percent, "+%"),
.add_wrap_assign => return renderBinOp(c, node, .assign_add_wrap, .plus_percent_equal, "+%="),
.sub => return renderBinOpGrouped(c, node, .sub, .minus, "-"),
.sub_assign => return renderBinOp(c, node, .assign_sub, .minus_equal, "-="),
.sub_wrap => return renderBinOpGrouped(c, node, .sub_wrap, .minus_percent, "-%"),
.sub_wrap_assign => return renderBinOp(c, node, .assign_sub_wrap, .minus_percent_equal, "-%="),
.mul => return renderBinOpGrouped(c, node, .mul, .asterisk, "*"),
.mul_assign => return renderBinOp(c, node, .assign_mul, .asterisk_equal, "*="),
.mul_wrap => return renderBinOpGrouped(c, node, .mul_wrap, .asterisk_percent, "*%"),
.mul_wrap_assign => return renderBinOp(c, node, .assign_mul_wrap, .asterisk_percent_equal, "*%="),
.div => return renderBinOpGrouped(c, node, .div, .slash, "/"),
.div_assign => return renderBinOp(c, node, .assign_div, .slash_equal, "/="),
.shl => return renderBinOpGrouped(c, node, .bit_shift_left, .angle_bracket_angle_bracket_left, "<<"),
.shl_assign => return renderBinOp(c, node, .assign_bit_shift_left, .angle_bracket_angle_bracket_left_equal, "<<="),
.shr => return renderBinOpGrouped(c, node, .bit_shift_right, .angle_bracket_angle_bracket_right, ">>"),
.shr_assign => return renderBinOp(c, node, .assign_bit_shift_right, .angle_bracket_angle_bracket_right_equal, ">>="),
.mod => return renderBinOpGrouped(c, node, .mod, .percent, "%"),
.mod_assign => return renderBinOp(c, node, .assign_mod, .percent_equal, "%="),
.@"and" => return renderBinOpGrouped(c, node, .bool_and, .keyword_and, "and"),
.@"or" => return renderBinOpGrouped(c, node, .bool_or, .keyword_or, "or"),
.less_than => return renderBinOpGrouped(c, node, .less_than, .angle_bracket_left, "<"),
.less_than_equal => return renderBinOpGrouped(c, node, .less_or_equal, .angle_bracket_left_equal, "<="),
.greater_than => return renderBinOpGrouped(c, node, .greater_than, .angle_bracket_right, ">="),
.greater_than_equal => return renderBinOpGrouped(c, node, .greater_or_equal, .angle_bracket_right_equal, ">="),
.equal => return renderBinOpGrouped(c, node, .equal_equal, .equal_equal, "=="),
.not_equal => return renderBinOpGrouped(c, node, .bang_equal, .bang_equal, "!="),
.bit_and => return renderBinOpGrouped(c, node, .bit_and, .ampersand, "&"),
.bit_and_assign => return renderBinOp(c, node, .assign_bit_and, .ampersand_equal, "&="),
.bit_or => return renderBinOpGrouped(c, node, .bit_or, .pipe, "|"),
.bit_or_assign => return renderBinOp(c, node, .assign_bit_or, .pipe_equal, "|="),
.bit_xor => return renderBinOpGrouped(c, node, .bit_xor, .caret, "^"),
.bit_xor_assign => return renderBinOp(c, node, .assign_bit_xor, .caret_equal, "^="),
.array_cat => return renderBinOp(c, node, .array_cat, .plus_plus, "++"),
.ellipsis3 => return renderBinOpGrouped(c, node, .switch_range, .ellipsis3, "..."),
.assign => return renderBinOp(c, node, .assign, .equal, "="),
.empty_block => {
const l_brace = try c.addToken(.l_brace, "{");
_ = try c.addToken(.r_brace, "}");
return c.addNode(.{
.tag = .block_two,
.main_token = l_brace,
.data = .{
.lhs = 0,
.rhs = 0,
},
});
},
.block_single => {
const payload = node.castTag(.block_single).?.data;
const l_brace = try c.addToken(.l_brace, "{");
const stmt = try renderNode(c, payload);
try addSemicolonIfNeeded(c, payload);
_ = try c.addToken(.r_brace, "}");
return c.addNode(.{
.tag = .block_two_semicolon,
.main_token = l_brace,
.data = .{
.lhs = stmt,
.rhs = 0,
},
});
},
.block => {
const payload = node.castTag(.block).?.data;
if (payload.label) |some| {
_ = try c.addIdentifier(some);
_ = try c.addToken(.colon, ":");
}
const l_brace = try c.addToken(.l_brace, "{");
var stmts = std.ArrayList(NodeIndex).init(c.gpa);
defer stmts.deinit();
for (payload.stmts) |stmt| {
const res = try renderNode(c, stmt);
if (res == 0) continue;
try addSemicolonIfNeeded(c, stmt);
try stmts.append(res);
}
const span = try c.listToSpan(stmts.items);
_ = try c.addToken(.r_brace, "}");
const semicolon = c.tokens.items(.tag)[c.tokens.len - 2] == .semicolon;
return c.addNode(.{
.tag = if (semicolon) .block_semicolon else .block,
.main_token = l_brace,
.data = .{
.lhs = span.start,
.rhs = span.end,
},
});
},
.func => return renderFunc(c, node),
.pub_inline_fn => return renderMacroFunc(c, node),
.discard => {
const payload = node.castTag(.discard).?.data;
const lhs = try c.addNode(.{
.tag = .identifier,
.main_token = try c.addToken(.identifier, "_"),
.data = undefined,
});
return c.addNode(.{
.tag = .assign,
.main_token = try c.addToken(.equal, "="),
.data = .{
.lhs = lhs,
.rhs = try renderNode(c, payload),
},
});
},
.@"while" => {
const payload = node.castTag(.@"while").?.data;
const while_tok = try c.addToken(.keyword_while, "while");
_ = try c.addToken(.l_paren, "(");
const cond = try renderNode(c, payload.cond);
_ = try c.addToken(.r_paren, ")");
const cont_expr = if (payload.cont_expr) |some| blk: {
_ = try c.addToken(.colon, ":");
_ = try c.addToken(.l_paren, "(");
const res = try renderNode(c, some);
_ = try c.addToken(.r_paren, ")");
break :blk res;
} else 0;
const body = try renderNode(c, payload.body);
if (cont_expr == 0) {
return c.addNode(.{
.tag = .while_simple,
.main_token = while_tok,
.data = .{
.lhs = cond,
.rhs = body,
},
});
} else {
return c.addNode(.{
.tag = .while_cont,
.main_token = while_tok,
.data = .{
.lhs = cond,
.rhs = try c.addExtra(std.zig.ast.Node.WhileCont{
.cont_expr = cont_expr,
.then_expr = body,
}),
},
});
}
},
.while_true => {
const payload = node.castTag(.while_true).?.data;
const while_tok = try c.addToken(.keyword_while, "while");
_ = try c.addToken(.l_paren, "(");
const cond = try c.addNode(.{
.tag = .true_literal,
.main_token = try c.addToken(.keyword_true, "true"),
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
const body = try renderNode(c, payload);
return c.addNode(.{
.tag = .while_simple,
.main_token = while_tok,
.data = .{
.lhs = cond,
.rhs = body,
},
});
},
.@"if" => {
const payload = node.castTag(.@"if").?.data;
const if_tok = try c.addToken(.keyword_if, "if");
_ = try c.addToken(.l_paren, "(");
const cond = try renderNode(c, payload.cond);
_ = try c.addToken(.r_paren, ")");
const then_expr = try renderNode(c, payload.then);
const else_node = payload.@"else" orelse return c.addNode(.{
.tag = .if_simple,
.main_token = if_tok,
.data = .{
.lhs = cond,
.rhs = then_expr,
},
});
_ = try c.addToken(.keyword_else, "else");
const else_expr = try renderNode(c, else_node);
return c.addNode(.{
.tag = .@"if",
.main_token = if_tok,
.data = .{
.lhs = cond,
.rhs = try c.addExtra(std.zig.ast.Node.If{
.then_expr = then_expr,
.else_expr = else_expr,
}),
},
});
},
.if_not_break => {
const payload = node.castTag(.if_not_break).?.data;
const if_tok = try c.addToken(.keyword_if, "if");
_ = try c.addToken(.l_paren, "(");
const cond = try c.addNode(.{
.tag = .bool_not,
.main_token = try c.addToken(.bang, "!"),
.data = .{
.lhs = try renderNodeGrouped(c, payload),
.rhs = undefined,
},
});
_ = try c.addToken(.r_paren, ")");
const then_expr = try c.addNode(.{
.tag = .@"break",
.main_token = try c.addToken(.keyword_break, "break"),
.data = .{
.lhs = 0,
.rhs = 0,
},
});
return c.addNode(.{
.tag = .if_simple,
.main_token = if_tok,
.data = .{
.lhs = cond,
.rhs = then_expr,
},
});
},
.@"switch" => {
const payload = node.castTag(.@"switch").?.data;
const switch_tok = try c.addToken(.keyword_switch, "switch");
_ = try c.addToken(.l_paren, "(");
const cond = try renderNode(c, payload.cond);
_ = try c.addToken(.r_paren, ")");
_ = try c.addToken(.l_brace, "{");
var cases = try c.gpa.alloc(NodeIndex, payload.cases.len);
defer c.gpa.free(cases);
for (payload.cases) |case, i| {
cases[i] = try renderNode(c, case);
_ = try c.addToken(.comma, ",");
}
const span = try c.listToSpan(cases);
_ = try c.addToken(.r_brace, "}");
return c.addNode(.{
.tag = .switch_comma,
.main_token = switch_tok,
.data = .{
.lhs = cond,
.rhs = try c.addExtra(NodeSubRange{
.start = span.start,
.end = span.end,
}),
},
});
},
.switch_else => {
const payload = node.castTag(.switch_else).?.data;
_ = try c.addToken(.keyword_else, "else");
return c.addNode(.{
.tag = .switch_case_one,
.main_token = try c.addToken(.equal_angle_bracket_right, "=>"),
.data = .{
.lhs = 0,
.rhs = try renderNode(c, payload),
},
});
},
.switch_prong => {
const payload = node.castTag(.switch_prong).?.data;
var items = try c.gpa.alloc(NodeIndex, std.math.max(payload.cases.len, 1));
defer c.gpa.free(items);
items[0] = 0;
for (payload.cases) |item, i| {
if (i != 0) _ = try c.addToken(.comma, ",");
items[i] = try renderNode(c, item);
}
_ = try c.addToken(.r_brace, "}");
if (items.len < 2) {
return c.addNode(.{
.tag = .switch_case_one,
.main_token = try c.addToken(.equal_angle_bracket_right, "=>"),
.data = .{
.lhs = items[0],
.rhs = try renderNode(c, payload.cond),
},
});
} else {
const span = try c.listToSpan(items);
return c.addNode(.{
.tag = .switch_case,
.main_token = try c.addToken(.equal_angle_bracket_right, "=>"),
.data = .{
.lhs = try c.addExtra(NodeSubRange{
.start = span.start,
.end = span.end,
}),
.rhs = try renderNode(c, payload.cond),
},
});
}
},
.opaque_literal => {
const opaque_tok = try c.addToken(.keyword_opaque, "opaque");
_ = try c.addToken(.l_brace, "{");
_ = try c.addToken(.r_brace, "}");
return c.addNode(.{
.tag = .container_decl_two,
.main_token = opaque_tok,
.data = .{
.lhs = 0,
.rhs = 0,
},
});
},
.array_access => {
const payload = node.castTag(.array_access).?.data;
const lhs = try renderNodeGrouped(c, payload.lhs);
const l_bracket = try c.addToken(.l_bracket, "[");
const index_expr = try renderNode(c, payload.rhs);
_ = try c.addToken(.r_bracket, "]");
return c.addNode(.{
.tag = .array_access,
.main_token = l_bracket,
.data = .{
.lhs = lhs,
.rhs = index_expr,
},
});
},
.array_type => {
const payload = node.castTag(.array_type).?.data;
return renderArrayType(c, payload.len, payload.elem_type);
},
.null_sentinel_array_type => {
const payload = node.castTag(.null_sentinel_array_type).?.data;
return renderNullSentinelArrayType(c, payload.len, payload.elem_type);
},
.array_filler => {
const payload = node.castTag(.array_filler).?.data;
const type_expr = try renderArrayType(c, 1, payload.type);
const l_brace = try c.addToken(.l_brace, "{");
const val = try renderNode(c, payload.filler);
_ = try c.addToken(.r_brace, "}");
const init = try c.addNode(.{
.tag = .array_init_one,
.main_token = l_brace,
.data = .{
.lhs = type_expr,
.rhs = val,
},
});
return c.addNode(.{
.tag = .array_cat,
.main_token = try c.addToken(.asterisk_asterisk, "**"),
.data = .{
.lhs = init,
.rhs = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addTokenFmt(.integer_literal, "{d}", .{payload.count}),
.data = undefined,
}),
},
});
},
.empty_array => {
const payload = node.castTag(.empty_array).?.data;
const type_expr = try renderArrayType(c, 0, payload);
return renderArrayInit(c, type_expr, &.{});
},
.array_init => {
const payload = node.castTag(.array_init).?.data;
const type_expr = try renderNode(c, payload.cond);
return renderArrayInit(c, type_expr, payload.cases);
},
.field_access => {
const payload = node.castTag(.field_access).?.data;
const lhs = try renderNodeGrouped(c, payload.lhs);
return renderFieldAccess(c, lhs, payload.field_name);
},
.@"struct", .@"union" => return renderRecord(c, node),
.@"enum" => {
const payload = node.castTag(.@"enum").?.data;
_ = try c.addToken(.keyword_extern, "extern");
const enum_tok = try c.addToken(.keyword_enum, "enum");
_ = try c.addToken(.l_paren, "(");
const arg_expr = try renderNode(c, payload.int_type);
_ = try c.addToken(.r_paren, ")");
_ = try c.addToken(.l_brace, "{");
const members = try c.gpa.alloc(NodeIndex, std.math.max(payload.fields.len + 1, 1));
defer c.gpa.free(members);
members[0] = 0;
for (payload.fields) |field, i| {
const name_tok = try c.addIdentifier(field.name);
const value_expr = if (field.value) |some| blk: {
_ = try c.addToken(.equal, "=");
break :blk try renderNode(c, some);
} else 0;
members[i] = try c.addNode(.{
.tag = .container_field_init,
.main_token = name_tok,
.data = .{
.lhs = 0,
.rhs = value_expr,
},
});
_ = try c.addToken(.comma, ",");
}
// make non-exhaustive
members[payload.fields.len] = try c.addNode(.{
.tag = .container_field_init,
.main_token = try c.addIdentifier("_"),
.data = .{
.lhs = 0,
.rhs = 0,
},
});
_ = try c.addToken(.comma, ",");
_ = try c.addToken(.r_brace, "}");
const span = try c.listToSpan(members);
return c.addNode(.{
.tag = .container_decl_arg_trailing,
.main_token = enum_tok,
.data = .{
.lhs = arg_expr,
.rhs = try c.addExtra(NodeSubRange{
.start = span.start,
.end = span.end,
}),
},
});
},
.pub_enum_redecl, .enum_redecl => {
const payload = @fieldParentPtr(Payload.EnumRedecl, "base", node.ptr_otherwise).data;
if (node.tag() == .pub_enum_redecl) _ = try c.addToken(.keyword_pub, "pub");
const const_tok = try c.addToken(.keyword_const, "const");
_ = try c.addIdentifier(payload.enum_val_name);
_ = try c.addToken(.equal, "=");
const enum_to_int_tok = try c.addToken(.builtin, "@enumToInt");
_ = try c.addToken(.l_paren, "(");
const enum_name = try c.addNode(.{
.tag = .identifier,
.main_token = try c.addIdentifier(payload.enum_name),
.data = undefined,
});
const field_access = try renderFieldAccess(c, enum_name, payload.field_name);
const init_node = try c.addNode(.{
.tag = .builtin_call_two,
.main_token = enum_to_int_tok,
.data = .{
.lhs = field_access,
.rhs = 0,
},
});
_ = try c.addToken(.r_paren, ")");
_ = try c.addToken(.semicolon, ";");
return c.addNode(.{
.tag = .simple_var_decl,
.main_token = const_tok,
.data = .{
.lhs = 0,
.rhs = init_node,
},
});
},
.tuple => {
const payload = node.castTag(.tuple).?.data;
_ = try c.addToken(.period, ".");
const l_brace = try c.addToken(.l_brace, "{");
var inits = try c.gpa.alloc(NodeIndex, std.math.max(payload.len, 2));
defer c.gpa.free(inits);
inits[0] = 0;
inits[1] = 0;
for (payload) |init, i| {
if (i != 0) _ = try c.addToken(.comma, ",");
inits[i] = try renderNode(c, init);
}
_ = try c.addToken(.r_brace, "}");
if (payload.len < 3) {
return c.addNode(.{
.tag = .array_init_dot_two,
.main_token = l_brace,
.data = .{
.lhs = inits[0],
.rhs = inits[1],
},
});
} else {
const span = try c.listToSpan(inits);
return c.addNode(.{
.tag = .array_init_dot,
.main_token = l_brace,
.data = .{
.lhs = span.start,
.rhs = span.end,
},
});
}
},
.container_init => {
const payload = node.castTag(.container_init).?.data;
const lhs = try renderNode(c, payload.lhs);
const l_brace = try c.addToken(.l_brace, "{");
var inits = try c.gpa.alloc(NodeIndex, std.math.max(payload.inits.len, 1));
defer c.gpa.free(inits);
inits[0] = 0;
for (payload.inits) |init, i| {
_ = try c.addToken(.period, ".");
_ = try c.addIdentifier(init.name);
_ = try c.addToken(.equal, "=");
inits[i] = try renderNode(c, init.value);
_ = try c.addToken(.comma, ",");
}
_ = try c.addToken(.r_brace, "}");
if (payload.inits.len < 2) {
return c.addNode(.{
.tag = .struct_init_one_comma,
.main_token = l_brace,
.data = .{
.lhs = lhs,
.rhs = inits[0],
},
});
} else {
const span = try c.listToSpan(inits);
return c.addNode(.{
.tag = .struct_init_comma,
.main_token = l_brace,
.data = .{
.lhs = lhs,
.rhs = try c.addExtra(NodeSubRange{
.start = span.start,
.end = span.end,
}),
},
});
}
},
.@"anytype" => unreachable, // Handled in renderParams
}
}
fn renderRecord(c: *Context, node: Node) !NodeIndex {
const payload = @fieldParentPtr(Payload.Record, "base", node.ptr_otherwise).data;
if (payload.is_packed)
_ = try c.addToken(.keyword_packed, "packed")
else
_ = try c.addToken(.keyword_extern, "extern");
const kind_tok = if (node.tag() == .@"struct")
try c.addToken(.keyword_struct, "struct")
else
try c.addToken(.keyword_union, "union");
_ = try c.addToken(.l_brace, "{");
const members = try c.gpa.alloc(NodeIndex, std.math.max(payload.fields.len, 2));
defer c.gpa.free(members);
members[0] = 0;
members[1] = 0;
for (payload.fields) |field, i| {
const name_tok = try c.addIdentifier(field.name);
_ = try c.addToken(.colon, ":");
const type_expr = try renderNode(c, field.type);
const alignment = field.alignment orelse {
members[i] = try c.addNode(.{
.tag = .container_field_init,
.main_token = name_tok,
.data = .{
.lhs = type_expr,
.rhs = 0,
},
});
_ = try c.addToken(.comma, ",");
continue;
};
_ = try c.addToken(.keyword_align, "align");
_ = try c.addToken(.l_paren, "(");
const align_expr = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addTokenFmt(.integer_literal, "{d}", .{alignment}),
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
members[i] = try c.addNode(.{
.tag = .container_field_align,
.main_token = name_tok,
.data = .{
.lhs = type_expr,
.rhs = align_expr,
},
});
_ = try c.addToken(.comma, ",");
}
_ = try c.addToken(.r_brace, "}");
if (payload.fields.len == 0) {
return c.addNode(.{
.tag = .container_decl_two,
.main_token = kind_tok,
.data = .{
.lhs = 0,
.rhs = 0,
},
});
} else if (payload.fields.len <= 2) {
return c.addNode(.{
.tag = .container_decl_two_trailing,
.main_token = kind_tok,
.data = .{
.lhs = members[0],
.rhs = members[1],
},
});
} else {
const span = try c.listToSpan(members);
return c.addNode(.{
.tag = .container_decl_trailing,
.main_token = kind_tok,
.data = .{
.lhs = span.start,
.rhs = span.end,
},
});
}
}
fn renderFieldAccess(c: *Context, lhs: NodeIndex, field_name: []const u8) !NodeIndex {
return c.addNode(.{
.tag = .field_access,
.main_token = try c.addToken(.period, "."),
.data = .{
.lhs = lhs,
.rhs = try c.addIdentifier(field_name),
},
});
}
fn renderArrayInit(c: *Context, lhs: NodeIndex, inits: []const Node) !NodeIndex {
const l_brace = try c.addToken(.l_brace, "{");
var rendered = try c.gpa.alloc(NodeIndex, std.math.max(inits.len, 1));
defer c.gpa.free(rendered);
rendered[0] = 0;
for (inits) |init, i| {
rendered[i] = try renderNode(c, init);
_ = try c.addToken(.comma, ",");
}
_ = try c.addToken(.r_brace, "}");
if (inits.len < 2) {
return c.addNode(.{
.tag = .array_init_one_comma,
.main_token = l_brace,
.data = .{
.lhs = lhs,
.rhs = rendered[0],
},
});
} else {
const span = try c.listToSpan(rendered);
return c.addNode(.{
.tag = .array_init_comma,
.main_token = l_brace,
.data = .{
.lhs = lhs,
.rhs = try c.addExtra(NodeSubRange{
.start = span.start,
.end = span.end,
}),
},
});
}
}
fn renderArrayType(c: *Context, len: usize, elem_type: Node) !NodeIndex {
const l_bracket = try c.addToken(.l_bracket, "[");
const len_expr = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addTokenFmt(.integer_literal, "{d}", .{len}),
.data = undefined,
});
_ = try c.addToken(.r_bracket, "]");
const elem_type_expr = try renderNode(c, elem_type);
return c.addNode(.{
.tag = .array_type,
.main_token = l_bracket,
.data = .{
.lhs = len_expr,
.rhs = elem_type_expr,
},
});
}
fn renderNullSentinelArrayType(c: *Context, len: usize, elem_type: Node) !NodeIndex {
const l_bracket = try c.addToken(.l_bracket, "[");
const len_expr = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addTokenFmt(.integer_literal, "{d}", .{len}),
.data = undefined,
});
_ = try c.addToken(.colon, ":");
const sentinel_expr = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addToken(.integer_literal, "0"),
.data = undefined,
});
_ = try c.addToken(.r_bracket, "]");
const elem_type_expr = try renderNode(c, elem_type);
return c.addNode(.{
.tag = .array_type_sentinel,
.main_token = l_bracket,
.data = .{
.lhs = len_expr,
.rhs = try c.addExtra(std.zig.ast.Node.ArrayTypeSentinel{
.sentinel = sentinel_expr,
.elem_type = elem_type_expr,
}),
},
});
}
fn addSemicolonIfNeeded(c: *Context, node: Node) !void {
switch (node.tag()) {
.warning => unreachable,
.var_decl, .var_simple, .arg_redecl, .alias, .enum_redecl, .block, .empty_block, .block_single, .@"switch" => {},
.while_true => {
const payload = node.castTag(.while_true).?.data;
return addSemicolonIfNotBlock(c, payload);
},
.@"while" => {
const payload = node.castTag(.@"while").?.data;
return addSemicolonIfNotBlock(c, payload.body);
},
.@"if" => {
const payload = node.castTag(.@"if").?.data;
if (payload.@"else") |some|
return addSemicolonIfNeeded(c, some);
return addSemicolonIfNotBlock(c, payload.then);
},
else => _ = try c.addToken(.semicolon, ";"),
}
}
fn addSemicolonIfNotBlock(c: *Context, node: Node) !void {
switch (node.tag()) {
.block, .empty_block, .block_single => {},
else => _ = try c.addToken(.semicolon, ";"),
}
}
fn renderNodeGrouped(c: *Context, node: Node) !NodeIndex {
switch (node.tag()) {
.declaration => unreachable,
.null_literal,
.undefined_literal,
.true_literal,
.false_literal,
.return_void,
.zero_literal,
.one_literal,
.void_type,
.noreturn_type,
.@"anytype",
.div_trunc,
.rem,
.int_cast,
.as,
.truncate,
.bit_cast,
.float_cast,
.float_to_int,
.int_to_float,
.int_to_enum,
.int_to_ptr,
.std_mem_zeroes,
.std_math_Log2Int,
.log2_int_type,
.ptr_to_int,
.enum_to_int,
.sizeof,
.alignof,
.typeof,
.typeinfo,
.std_meta_sizeof,
.std_meta_alignment,
.std_meta_cast,
.std_meta_promoteIntLiteral,
.std_meta_vector,
.std_meta_shuffle_vector_index,
.std_mem_zeroinit,
.integer_literal,
.float_literal,
.string_literal,
.string_slice,
.char_literal,
.enum_literal,
.identifier,
.field_access,
.ptr_cast,
.type,
.array_access,
.align_cast,
.optional_type,
.c_pointer,
.single_pointer,
.unwrap,
.deref,
.address_of,
.not,
.negate,
.negate_wrap,
.bit_not,
.func,
.call,
.array_type,
.null_sentinel_array_type,
.bool_to_int,
.div_exact,
.byte_offset_of,
.shuffle,
=> {
// no grouping needed
return renderNode(c, node);
},
.opaque_literal,
.empty_array,
.block_single,
.add,
.add_wrap,
.sub,
.sub_wrap,
.mul,
.mul_wrap,
.div,
.shl,
.shr,
.mod,
.@"and",
.@"or",
.less_than,
.less_than_equal,
.greater_than,
.greater_than_equal,
.equal,
.not_equal,
.bit_and,
.bit_or,
.bit_xor,
.empty_block,
.array_cat,
.array_filler,
.@"if",
.@"enum",
.@"struct",
.@"union",
.array_init,
.tuple,
.container_init,
.block,
=> return c.addNode(.{
.tag = .grouped_expression,
.main_token = try c.addToken(.l_paren, "("),
.data = .{
.lhs = try renderNode(c, node),
.rhs = try c.addToken(.r_paren, ")"),
},
}),
.ellipsis3,
.switch_prong,
.warning,
.var_decl,
.fail_decl,
.arg_redecl,
.alias,
.var_simple,
.pub_var_simple,
.pub_enum_redecl,
.enum_redecl,
.@"while",
.@"switch",
.@"break",
.break_val,
.pub_inline_fn,
.discard,
.@"continue",
.@"return",
.@"comptime",
.@"defer",
.asm_simple,
.usingnamespace_builtins,
.while_true,
.if_not_break,
.switch_else,
.add_assign,
.add_wrap_assign,
.sub_assign,
.sub_wrap_assign,
.mul_assign,
.mul_wrap_assign,
.div_assign,
.shl_assign,
.shr_assign,
.mod_assign,
.bit_and_assign,
.bit_or_assign,
.bit_xor_assign,
.assign,
=> {
// these should never appear in places where grouping might be needed.
unreachable;
},
}
}
fn renderPrefixOp(c: *Context, node: Node, tag: std.zig.ast.Node.Tag, tok_tag: TokenTag, bytes: []const u8) !NodeIndex {
const payload = @fieldParentPtr(Payload.UnOp, "base", node.ptr_otherwise).data;
return c.addNode(.{
.tag = tag,
.main_token = try c.addToken(tok_tag, bytes),
.data = .{
.lhs = try renderNodeGrouped(c, payload),
.rhs = undefined,
},
});
}
fn renderBinOpGrouped(c: *Context, node: Node, tag: std.zig.ast.Node.Tag, tok_tag: TokenTag, bytes: []const u8) !NodeIndex {
const payload = @fieldParentPtr(Payload.BinOp, "base", node.ptr_otherwise).data;
const lhs = try renderNodeGrouped(c, payload.lhs);
return c.addNode(.{
.tag = tag,
.main_token = try c.addToken(tok_tag, bytes),
.data = .{
.lhs = lhs,
.rhs = try renderNodeGrouped(c, payload.rhs),
},
});
}
fn renderBinOp(c: *Context, node: Node, tag: std.zig.ast.Node.Tag, tok_tag: TokenTag, bytes: []const u8) !NodeIndex {
const payload = @fieldParentPtr(Payload.BinOp, "base", node.ptr_otherwise).data;
const lhs = try renderNode(c, payload.lhs);
return c.addNode(.{
.tag = tag,
.main_token = try c.addToken(tok_tag, bytes),
.data = .{
.lhs = lhs,
.rhs = try renderNode(c, payload.rhs),
},
});
}
fn renderStdImport(c: *Context, first: []const u8, second: []const u8) !NodeIndex {
const import_tok = try c.addToken(.builtin, "@import");
_ = try c.addToken(.l_paren, "(");
const std_tok = try c.addToken(.string_literal, "\"std\"");
const std_node = try c.addNode(.{
.tag = .string_literal,
.main_token = std_tok,
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
const import_node = try c.addNode(.{
.tag = .builtin_call_two,
.main_token = import_tok,
.data = .{
.lhs = std_node,
.rhs = 0,
},
});
var access_chain = import_node;
access_chain = try renderFieldAccess(c, access_chain, first);
access_chain = try renderFieldAccess(c, access_chain, second);
return access_chain;
}
fn renderCall(c: *Context, lhs: NodeIndex, args: []const Node) !NodeIndex {
const lparen = try c.addToken(.l_paren, "(");
const res = switch (args.len) {
0 => try c.addNode(.{
.tag = .call_one,
.main_token = lparen,
.data = .{
.lhs = lhs,
.rhs = 0,
},
}),
1 => blk: {
const arg = try renderNode(c, args[0]);
break :blk try c.addNode(.{
.tag = .call_one,
.main_token = lparen,
.data = .{
.lhs = lhs,
.rhs = arg,
},
});
},
else => blk: {
var rendered = try c.gpa.alloc(NodeIndex, args.len);
defer c.gpa.free(rendered);
for (args) |arg, i| {
if (i != 0) _ = try c.addToken(.comma, ",");
rendered[i] = try renderNode(c, arg);
}
const span = try c.listToSpan(rendered);
break :blk try c.addNode(.{
.tag = .call,
.main_token = lparen,
.data = .{
.lhs = lhs,
.rhs = try c.addExtra(NodeSubRange{
.start = span.start,
.end = span.end,
}),
},
});
},
};
_ = try c.addToken(.r_paren, ")");
return res;
}
fn renderBuiltinCall(c: *Context, builtin: []const u8, args: []const Node) !NodeIndex {
const builtin_tok = try c.addToken(.builtin, builtin);
_ = try c.addToken(.l_paren, "(");
var arg_1: NodeIndex = 0;
var arg_2: NodeIndex = 0;
var arg_3: NodeIndex = 0;
var arg_4: NodeIndex = 0;
switch (args.len) {
0 => {},
1 => {
arg_1 = try renderNode(c, args[0]);
},
2 => {
arg_1 = try renderNode(c, args[0]);
_ = try c.addToken(.comma, ",");
arg_2 = try renderNode(c, args[1]);
},
4 => {
arg_1 = try renderNode(c, args[0]);
_ = try c.addToken(.comma, ",");
arg_2 = try renderNode(c, args[1]);
_ = try c.addToken(.comma, ",");
arg_3 = try renderNode(c, args[2]);
_ = try c.addToken(.comma, ",");
arg_4 = try renderNode(c, args[3]);
},
else => unreachable, // expand this function as needed.
}
_ = try c.addToken(.r_paren, ")");
if (args.len <= 2) {
return c.addNode(.{
.tag = .builtin_call_two,
.main_token = builtin_tok,
.data = .{
.lhs = arg_1,
.rhs = arg_2,
},
});
} else {
std.debug.assert(args.len == 4);
const params = try c.listToSpan(&.{ arg_1, arg_2, arg_3, arg_4 });
return c.addNode(.{
.tag = .builtin_call,
.main_token = builtin_tok,
.data = .{
.lhs = params.start,
.rhs = params.end,
},
});
}
}
fn renderVar(c: *Context, node: Node) !NodeIndex {
const payload = node.castTag(.var_decl).?.data;
if (payload.is_pub) _ = try c.addToken(.keyword_pub, "pub");
if (payload.is_extern) _ = try c.addToken(.keyword_extern, "extern");
if (payload.is_export) _ = try c.addToken(.keyword_export, "export");
if (payload.is_threadlocal) _ = try c.addToken(.keyword_threadlocal, "threadlocal");
const mut_tok = if (payload.is_const)
try c.addToken(.keyword_const, "const")
else
try c.addToken(.keyword_var, "var");
_ = try c.addIdentifier(payload.name);
_ = try c.addToken(.colon, ":");
const type_node = try renderNode(c, payload.type);
const align_node = if (payload.alignment) |some| blk: {
_ = try c.addToken(.keyword_align, "align");
_ = try c.addToken(.l_paren, "(");
const res = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addTokenFmt(.integer_literal, "{d}", .{some}),
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
break :blk res;
} else 0;
const section_node = if (payload.linksection_string) |some| blk: {
_ = try c.addToken(.keyword_linksection, "linksection");
_ = try c.addToken(.l_paren, "(");
const res = try c.addNode(.{
.tag = .string_literal,
.main_token = try c.addTokenFmt(.string_literal, "\"{}\"", .{std.zig.fmtEscapes(some)}),
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
break :blk res;
} else 0;
const init_node = if (payload.init) |some| blk: {
_ = try c.addToken(.equal, "=");
break :blk try renderNode(c, some);
} else 0;
_ = try c.addToken(.semicolon, ";");
if (section_node == 0) {
if (align_node == 0) {
return c.addNode(.{
.tag = .simple_var_decl,
.main_token = mut_tok,
.data = .{
.lhs = type_node,
.rhs = init_node,
},
});
} else {
return c.addNode(.{
.tag = .local_var_decl,
.main_token = mut_tok,
.data = .{
.lhs = try c.addExtra(std.zig.ast.Node.LocalVarDecl{
.type_node = type_node,
.align_node = align_node,
}),
.rhs = init_node,
},
});
}
} else {
return c.addNode(.{
.tag = .global_var_decl,
.main_token = mut_tok,
.data = .{
.lhs = try c.addExtra(std.zig.ast.Node.GlobalVarDecl{
.type_node = type_node,
.align_node = align_node,
.section_node = section_node,
}),
.rhs = init_node,
},
});
}
}
fn renderFunc(c: *Context, node: Node) !NodeIndex {
const payload = node.castTag(.func).?.data;
if (payload.is_pub) _ = try c.addToken(.keyword_pub, "pub");
if (payload.is_extern) _ = try c.addToken(.keyword_extern, "extern");
if (payload.is_export) _ = try c.addToken(.keyword_export, "export");
const fn_token = try c.addToken(.keyword_fn, "fn");
if (payload.name) |some| _ = try c.addIdentifier(some);
const params = try renderParams(c, payload.params, payload.is_var_args);
defer params.deinit();
var span: NodeSubRange = undefined;
if (params.items.len > 1) span = try c.listToSpan(params.items);
const align_expr = if (payload.alignment) |some| blk: {
_ = try c.addToken(.keyword_align, "align");
_ = try c.addToken(.l_paren, "(");
const res = try c.addNode(.{
.tag = .integer_literal,
.main_token = try c.addTokenFmt(.integer_literal, "{d}", .{some}),
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
break :blk res;
} else 0;
const section_expr = if (payload.linksection_string) |some| blk: {
_ = try c.addToken(.keyword_linksection, "linksection");
_ = try c.addToken(.l_paren, "(");
const res = try c.addNode(.{
.tag = .string_literal,
.main_token = try c.addTokenFmt(.string_literal, "\"{}\"", .{std.zig.fmtEscapes(some)}),
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
break :blk res;
} else 0;
const callconv_expr = if (payload.explicit_callconv) |some| blk: {
_ = try c.addToken(.keyword_callconv, "callconv");
_ = try c.addToken(.l_paren, "(");
_ = try c.addToken(.period, ".");
const res = try c.addNode(.{
.tag = .enum_literal,
.main_token = try c.addTokenFmt(.identifier, "{s}", .{@tagName(some)}),
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
break :blk res;
} else 0;
const return_type_expr = try renderNode(c, payload.return_type);
const fn_proto = try blk: {
if (align_expr == 0 and section_expr == 0 and callconv_expr == 0) {
if (params.items.len < 2)
break :blk c.addNode(.{
.tag = .fn_proto_simple,
.main_token = fn_token,
.data = .{
.lhs = params.items[0],
.rhs = return_type_expr,
},
})
else
break :blk c.addNode(.{
.tag = .fn_proto_multi,
.main_token = fn_token,
.data = .{
.lhs = try c.addExtra(NodeSubRange{
.start = span.start,
.end = span.end,
}),
.rhs = return_type_expr,
},
});
}
if (params.items.len < 2)
break :blk c.addNode(.{
.tag = .fn_proto_one,
.main_token = fn_token,
.data = .{
.lhs = try c.addExtra(std.zig.ast.Node.FnProtoOne{
.param = params.items[0],
.align_expr = align_expr,
.section_expr = section_expr,
.callconv_expr = callconv_expr,
}),
.rhs = return_type_expr,
},
})
else
break :blk c.addNode(.{
.tag = .fn_proto,
.main_token = fn_token,
.data = .{
.lhs = try c.addExtra(std.zig.ast.Node.FnProto{
.params_start = span.start,
.params_end = span.end,
.align_expr = align_expr,
.section_expr = section_expr,
.callconv_expr = callconv_expr,
}),
.rhs = return_type_expr,
},
});
};
const payload_body = payload.body orelse {
if (payload.is_extern) {
_ = try c.addToken(.semicolon, ";");
}
return fn_proto;
};
const body = try renderNode(c, payload_body);
return c.addNode(.{
.tag = .fn_decl,
.main_token = fn_token,
.data = .{
.lhs = fn_proto,
.rhs = body,
},
});
}
fn renderMacroFunc(c: *Context, node: Node) !NodeIndex {
const payload = node.castTag(.pub_inline_fn).?.data;
_ = try c.addToken(.keyword_pub, "pub");
const fn_token = try c.addToken(.keyword_fn, "fn");
_ = try c.addIdentifier(payload.name);
const params = try renderParams(c, payload.params, false);
defer params.deinit();
var span: NodeSubRange = undefined;
if (params.items.len > 1) span = try c.listToSpan(params.items);
const callconv_expr = blk: {
_ = try c.addToken(.keyword_callconv, "callconv");
_ = try c.addToken(.l_paren, "(");
_ = try c.addToken(.period, ".");
const res = try c.addNode(.{
.tag = .enum_literal,
.main_token = try c.addToken(.identifier, "Inline"),
.data = undefined,
});
_ = try c.addToken(.r_paren, ")");
break :blk res;
};
const return_type_expr = try renderNodeGrouped(c, payload.return_type);
const fn_proto = try blk: {
if (params.items.len < 2)
break :blk c.addNode(.{
.tag = .fn_proto_one,
.main_token = fn_token,
.data = .{
.lhs = try c.addExtra(std.zig.ast.Node.FnProtoOne{
.param = params.items[0],
.align_expr = 0,
.section_expr = 0,
.callconv_expr = callconv_expr,
}),
.rhs = return_type_expr,
},
})
else
break :blk c.addNode(.{
.tag = .fn_proto,
.main_token = fn_token,
.data = .{
.lhs = try c.addExtra(std.zig.ast.Node.FnProto{
.params_start = span.start,
.params_end = span.end,
.align_expr = 0,
.section_expr = 0,
.callconv_expr = callconv_expr,
}),
.rhs = return_type_expr,
},
});
};
return c.addNode(.{
.tag = .fn_decl,
.main_token = fn_token,
.data = .{
.lhs = fn_proto,
.rhs = try renderNode(c, payload.body),
},
});
}
fn renderParams(c: *Context, params: []Payload.Param, is_var_args: bool) !std.ArrayList(NodeIndex) {
_ = try c.addToken(.l_paren, "(");
var rendered = std.ArrayList(NodeIndex).init(c.gpa);
errdefer rendered.deinit();
try rendered.ensureCapacity(std.math.max(params.len, 1));
for (params) |param, i| {
if (i != 0) _ = try c.addToken(.comma, ",");
if (param.is_noalias) _ = try c.addToken(.keyword_noalias, "noalias");
if (param.name) |some| {
_ = try c.addIdentifier(some);
_ = try c.addToken(.colon, ":");
}
if (param.type.tag() == .@"anytype") {
_ = try c.addToken(.keyword_anytype, "anytype");
continue;
}
rendered.appendAssumeCapacity(try renderNode(c, param.type));
}
if (is_var_args) {
if (params.len != 0) _ = try c.addToken(.comma, ",");
_ = try c.addToken(.ellipsis3, "...");
}
_ = try c.addToken(.r_paren, ")");
if (rendered.items.len == 0) rendered.appendAssumeCapacity(0);
return rendered;
}
|
src/translate_c/ast.zig
|
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
const TableHeader = uefi.tables.TableHeader;
const Time = uefi.Time;
const TimeCapabilities = uefi.TimeCapabilities;
const Status = uefi.Status;
/// Runtime services are provided by the firmware before and after exitBootServices has been called.
///
/// As the runtime_services table may grow with new UEFI versions, it is important to check hdr.header_size.
///
/// Some functions may not be supported. Check the RuntimeServicesSupported variable using getVariable.
/// getVariable is one of the functions that may not be supported.
///
/// Some functions may not be called while other functions are running.
pub const RuntimeServices = extern struct {
hdr: TableHeader,
/// Returns the current time and date information, and the time-keeping capabilities of the hardware platform.
getTime: extern fn (*uefi.Time, ?*TimeCapabilities) Status,
setTime: Status, // TODO
getWakeupTime: Status, // TODO
setWakeupTime: Status, // TODO
setVirtualAddressMap: Status, // TODO
convertPointer: Status, // TODO
/// Returns the value of a variable.
getVariable: extern fn ([*:0]const u16, *align(8) const Guid, ?*u32, *usize, ?*c_void) Status,
/// Enumerates the current variable names.
getNextVariableName: extern fn (*usize, [*:0]u16, *align(8) Guid) Status,
/// Sets the value of a variable.
setVariable: extern fn ([*:0]const u16, *align(8) const Guid, u32, usize, *c_void) Status,
getNextHighMonotonicCount: Status, // TODO
/// Resets the entire platform.
resetSystem: extern fn (ResetType, Status, usize, ?*const c_void) noreturn,
updateCapsule: Status, // TODO
queryCapsuleCapabilities: Status, // TODO
queryVariableInfo: Status, // TODO
pub const signature: u64 = 0x56524553544e5552;
};
pub const ResetType = extern enum(u32) {
ResetCold,
ResetWarm,
ResetShutdown,
ResetPlatformSpecific,
};
pub const global_variable align(8) = Guid{
.time_low = 0x8be4df61,
.time_mid = 0x93ca,
.time_high_and_version = 0x11d2,
.clock_seq_high_and_reserved = 0xaa,
.clock_seq_low = 0x0d,
.node = [_]u8{ 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c },
};
|
lib/std/os/uefi/tables/runtime_services.zig
|
const std = @import("std");
const lola = @import("lola");
////
// Serialization API example:
// This example shows how to save a whole-program state into a buffer
// and restore that later to continue execution.
//
// NOTE: This example is work-in-progress!
const example_source =
\\for(i in Range(1, 100)) {
\\ Print("Round ", i);
\\}
;
pub const ObjectPool = lola.runtime.ObjectPool([_]type{
lola.libs.runtime.LoLaDictionary,
lola.libs.runtime.LoLaList,
});
// this will store our intermediate data
var serialization_buffer: [4096]u8 = undefined;
pub fn main() anyerror!void {
{
var gpa_state = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa_state.deinit();
try run_serialization(&gpa_state.allocator);
}
{
var gpa_state = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa_state.deinit();
try run_deserialization(&gpa_state.allocator);
}
}
fn run_serialization(allocator: *std.mem.Allocator) !void {
var diagnostics = lola.compiler.Diagnostics.init(allocator);
defer {
for (diagnostics.messages.items) |msg| {
std.debug.print("{}\n", .{msg});
}
diagnostics.deinit();
}
var compile_unit = (try lola.compiler.compile(allocator, &diagnostics, "example_source", example_source)) orelse return error.FailedToCompile;
defer compile_unit.deinit();
var pool = ObjectPool.init(allocator);
defer pool.deinit();
var env = try lola.runtime.Environment.init(allocator, &compile_unit, pool.interface());
defer env.deinit();
try lola.libs.std.install(&env, allocator);
try lola.libs.runtime.install(&env, allocator);
var vm = try lola.runtime.VM.init(allocator, &env);
defer vm.deinit();
var result = try vm.execute(405);
std.debug.assert(result == .exhausted); // we didn't finish running our nice example
var stdout = std.io.getStdOut().writer();
try stdout.writeAll("Suspend at\n");
try vm.printStackTrace(stdout);
{
var stream = std.io.fixedBufferStream(&serialization_buffer);
var writer = stream.writer();
try compile_unit.saveToStream(writer);
// This saves all objects associated with their handles.
// This will only work when all object classes are serializable though.
try pool.serialize(writer);
// this saves all global variables saved in the environment
try env.serialize(writer);
var registry = lola.runtime.EnvironmentMap.init(allocator);
defer registry.deinit();
try registry.add(1234, &env);
// This saves the current virtual machine state
try vm.serialize(®istry, writer);
try stdout.print("saved state to {} bytes!\n", .{
stream.getWritten().len,
});
}
}
fn run_deserialization(allocator: *std.mem.Allocator) !void {
var stream = std.io.fixedBufferStream(&serialization_buffer);
var reader = stream.reader();
// Trivial deserialization:
// Just load the compile unit from disk again
var compile_unit = try lola.CompileUnit.loadFromStream(allocator, reader);
defer compile_unit.deinit();
// This is the reason we need to specialize lola.runtime.ObjectPool() on
// a type list:
// We need a way to do generic deserialization (arbitrary types) and it requires
// a way to get a runtime type-handle and turn it back into a deserialization function.
// this is done by storing the type indices per created object which can then be turned back
// into a real lola.runtime.Object.
var object_pool = try ObjectPool.deserialize(allocator, reader);
defer object_pool.deinit();
// Environments cannot be deserialized directly from a stream:
// Each environment contains function pointers and references its compile unit.
// Both of these things cannot be done by a pure stream serialization.
// Thus, we need to restore the constant part of the environment by hand and
// install all functions as well:
var env = try lola.runtime.Environment.init(allocator, &compile_unit, object_pool.interface());
defer env.deinit();
// Installs the functions back into the environment.
try lola.libs.std.install(&env, allocator);
try lola.libs.runtime.install(&env, allocator);
// This will restore the whole environment state back to how it was at serialization
// time. All globals will be restored here.
try env.deserialize(reader);
// This is needed for deserialization:
// We need means to have a unique Environment <-> ID mapping
// which is persistent over the serialization process.
var registry = lola.runtime.EnvironmentMap.init(allocator);
defer registry.deinit();
// Here we need to add all environments that were previously serialized with
// the same IDs as before.
try registry.add(1234, &env);
// Restore the virtual machine with all function calls.
var vm = try lola.runtime.VM.deserialize(allocator, ®istry, reader);
defer vm.deinit();
var stdout = std.io.getStdOut().writer();
try stdout.print("restored state with {} bytes!\n", .{
stream.getWritten().len,
});
try stdout.writeAll("Resume at\n");
try vm.printStackTrace(stdout);
// let the program finish
_ = try vm.execute(null);
}
|
examples/host/serialization/main.zig
|
const std = @import("std.zig");
const builtin = @import("builtin");
const debug = std.debug;
const mem = std.mem;
const testing = std.testing;
pub const line_sep = switch (builtin.os.tag) {
.windows => "\r\n",
else => "\n",
};
pub fn cmp(a: [*:0]const u8, b: [*:0]const u8) i8 {
var index: usize = 0;
while (a[index] == b[index] and a[index] != 0) : (index += 1) {}
if (a[index] > b[index]) {
return 1;
} else if (a[index] < b[index]) {
return -1;
} else {
return 0;
}
}
test "cstr fns" {
comptime try testCStrFnsImpl();
try testCStrFnsImpl();
}
fn testCStrFnsImpl() !void {
try testing.expect(cmp("aoeu", "aoez") == -1);
try testing.expect(mem.len("123456789") == 9);
}
/// Returns a mutable, null-terminated slice with the same length as `slice`.
/// Caller owns the returned memory.
pub fn addNullByte(allocator: *mem.Allocator, slice: []const u8) ![:0]u8 {
const result = try allocator.alloc(u8, slice.len + 1);
mem.copy(u8, result, slice);
result[slice.len] = 0;
return result[0..slice.len :0];
}
test "addNullByte" {
const slice = try addNullByte(std.testing.allocator, "hello"[0..4]);
defer std.testing.allocator.free(slice);
try testing.expect(slice.len == 4);
try testing.expect(slice[4] == 0);
}
pub const NullTerminated2DArray = struct {
allocator: *mem.Allocator,
byte_count: usize,
ptr: ?[*:null]?[*:0]u8,
/// Takes N lists of strings, concatenates the lists together, and adds a null terminator
/// Caller must deinit result
pub fn fromSlices(allocator: *mem.Allocator, slices: []const []const []const u8) !NullTerminated2DArray {
var new_len: usize = 1; // 1 for the list null
var byte_count: usize = 0;
for (slices) |slice| {
new_len += slice.len;
for (slice) |inner| {
byte_count += inner.len;
}
byte_count += slice.len; // for the null terminators of inner
}
const index_size = @sizeOf(usize) * new_len; // size of the ptrs
byte_count += index_size;
const buf = try allocator.alignedAlloc(u8, @alignOf(?*u8), byte_count);
errdefer allocator.free(buf);
var write_index = index_size;
const index_buf = mem.bytesAsSlice(?[*]u8, buf);
var i: usize = 0;
for (slices) |slice| {
for (slice) |inner| {
index_buf[i] = buf.ptr + write_index;
i += 1;
mem.copy(u8, buf[write_index..], inner);
write_index += inner.len;
buf[write_index] = 0;
write_index += 1;
}
}
index_buf[i] = null;
return NullTerminated2DArray{
.allocator = allocator,
.byte_count = byte_count,
.ptr = @ptrCast(?[*:null]?[*:0]u8, buf.ptr),
};
}
pub fn deinit(self: *NullTerminated2DArray) void {
const buf = @ptrCast([*]u8, self.ptr);
self.allocator.free(buf[0..self.byte_count]);
}
};
|
lib/std/cstr.zig
|
test "var args macro functions" {
try expectStr(
\\#define foo(a,...) #__VA_ARGS__
\\foo(1,2,3,4,5,6)
\\
\\#define bar(a,...) bar __VA_ARGS__
\\#define baz(a,...) baz bar(__VA_ARGS__)
\\baz(1,2,3,4)
, "\"2 , 3 , 4 , 5 , 6\" baz bar 3 , 4\n");
}
test "X macro" {
try expectStr(
\\#define X(a) Foo_ ## a = a,
\\enum Foo {
\\X(1)
\\X(2)
\\X(3)
\\X(4)
\\X(5)
\\};
, "enum Foo { Foo_1 = 1 , Foo_2 = 2 , Foo_3 = 3 , Foo_4 = 4 , Foo_5 = 5 , } ;\n");
}
test "function macro expansion" {
try expectStr(
\\#define HE HI
\\#define LLO _THERE
\\#define HELLO "HI THERE"
\\#define CAT(a,b) a##b
\\#define XCAT(a,b) CAT(a,b)
\\#define CALL(fn) fn(HE,LLO)
\\CAT(HE, LLO)
\\XCAT(HE, LLO)
\\CALL(CAT)
, "\"HI THERE\" HI_THERE \"HI THERE\"\n");
}
test "#if constant expression" {
try expectStr(
\\#if defined FOO
\\void
\\#elif !defined(BAR)
\\long
\\#endif
, "long\n");
}
test "nested #ifs" {
try expectStr(
\\#define FOO
\\#ifdef FOO
\\#ifdef FOO
\\#else
\\#endif
\\#endif
, "");
}
test "object macro token pasting" {
try expectStr(
\\#define x a##1
\\x
\\#define a 1
\\x
, "a1 a1\n");
}
test "recursive object macro" {
try expectStr(
\\#define y x
\\#define x y
\\x
, "x\n");
try expectStr(
\\#define x x
\\x
, "x\n");
}
test "object macro expansion" {
try expectTokens(
\\#define x a
\\x
\\#define a 1
\\x
, &.{ .identifier, .integer_literal });
try expectTokens(
\\#define x define
\\x
, &.{.identifier});
}
test "ifdef" {
try expectTokens(
\\#define FOO
\\#ifdef FOO
\\long
\\#else
\\int
\\#endif
, &.{.keyword_long});
try expectTokens(
\\#define BAR
\\#ifdef FOO
\\long
\\#else
\\int
\\#endif
, &.{.keyword_int});
}
test "define undefin" {
try expectTokens(
\\#define FOO 1
\\#undef FOO
, &.{});
}
const std = @import("std");
const aro = @import("aro");
const Source = aro.Source;
const Token = aro.Tokenizer.Token;
const Preprocessor = aro.Preprocessor;
const Compilation = aro.Compilation;
fn expectTokens(buf: []const u8, expected_tokens: []const Token.Id) !void {
var comp = Compilation.init(std.testing.allocator);
defer comp.deinit();
const source = Source{
.buf = buf,
.id = @intToEnum(Source.Id, 2),
.path = "<test-buf>",
};
try comp.sources.putNoClobber(source.path, source);
defer comp.sources.clearAndFree();
var pp = Preprocessor.init(&comp);
defer pp.deinit();
try pp.preprocess(source);
comp.renderErrors();
try std.testing.expect(comp.diag.errors == 0);
for (expected_tokens) |expected_token_id, i| {
const actual = pp.tokens.items(.id)[i];
if (!std.meta.eql(actual, expected_token_id)) {
std.debug.print("expected {s}, found {s}\n", .{ @tagName(expected_token_id), @tagName(actual) });
return error.TokensDoNotEqual;
}
}
}
fn expectStr(buf: []const u8, expected: []const u8) !void {
var comp = Compilation.init(std.testing.allocator);
defer comp.deinit();
const source = Source{
.buf = buf,
.id = @intToEnum(Source.Id, 2),
.path = "<test-buf>",
};
try comp.sources.putNoClobber(source.path, source);
defer comp.sources.clearAndFree();
var pp = Preprocessor.init(&comp);
defer pp.deinit();
try pp.preprocess(source);
try pp.tokens.append(comp.gpa, .{ .id = .eof, .loc = undefined });
comp.renderErrors();
try std.testing.expect(comp.diag.errors == 0);
var actual = std.ArrayList(u8).init(std.testing.allocator);
defer actual.deinit();
try pp.prettyPrintTokens(actual.writer());
try std.testing.expectEqualStrings(expected, actual.items);
}
|
test/preprocessor.zig
|
const std = @import("std");
const assert = std.debug.assert;
const allocator = std.testing.allocator;
pub const Factory = struct {
rules: std.StringHashMap(Rule),
ore_produced: usize,
const Rule = struct {
needed: std.StringHashMap(usize),
material: []u8,
amount: usize,
pub fn init() Rule {
var self = Rule{
.needed = std.StringHashMap(usize).init(allocator),
.material = undefined,
.amount = 0,
};
return self;
}
pub fn deinit(self: *Rule) void {
var it = self.needed.iterator();
while (it.next()) |needed| {
allocator.free(needed.key_ptr.*);
}
allocator.free(self.material);
self.needed.deinit();
}
pub fn parse(self: *Rule, str: []const u8) void {
var statel: usize = 0;
var itl = std.mem.split(u8, str, "=>");
while (itl.next()) |side| {
if (statel == 0) {
// left hand: needed
var itr = std.mem.split(u8, std.mem.trim(u8, side, " "), ",");
while (itr.next()) |rule| {
var amount: usize = 0;
var staten: usize = 0;
var itn = std.mem.split(u8, std.mem.trim(u8, rule, " "), " ");
while (itn.next()) |data| {
if (staten == 0) {
amount = std.fmt.parseInt(usize, data, 10) catch unreachable;
staten = 1;
} else {
// std.debug.warn("NEEDED: {} [{}]\n",.{ amount, data});
const needed = allocator.alloc(u8, data.len) catch unreachable;
std.mem.copy(u8, needed, data);
if (self.needed.contains(needed)) {
std.debug.warn("=== DUPLICATE needed [{s}]\n", .{needed});
} else {
_ = self.needed.put(needed, amount) catch unreachable;
}
staten = 0;
}
}
}
statel = 1;
} else {
// right hand: produced
var amount: usize = 0;
var statep: usize = 0;
var itp = std.mem.split(u8, std.mem.trim(u8, side, " "), " ");
while (itp.next()) |data| {
if (statep == 0) {
amount = std.fmt.parseInt(usize, data, 10) catch unreachable;
statep = 1;
} else {
// std.debug.warn("PRODUCED: {} [{}]\n",.{ amount, data});
self.amount = amount;
self.material = allocator.alloc(u8, data.len) catch unreachable;
std.mem.copy(u8, self.material, data);
statep = 0;
}
}
statel = 0;
}
}
}
pub fn show(self: Rule) void {
std.debug.warn("RULE to produce {} of [{}]:\n", .{ self.amount, self.material });
var it = self.needed.iterator();
while (it.next()) |needed| {
std.debug.warn(" NEED {} of [{}]\n", .{ needed.value, needed.key });
}
}
};
pub fn init() Factory {
var self = Factory{
.rules = std.StringHashMap(Rule).init(allocator),
.ore_produced = 0,
};
return self;
}
pub fn deinit(self: *Factory) void {
var it = self.rules.iterator();
while (it.next()) |rule| {
rule.value_ptr.*.deinit();
}
self.rules.deinit();
}
pub fn parse(self: *Factory, str: []const u8) void {
var rule = Rule.init();
rule.parse(str);
self.add_rule(rule);
}
pub fn add_rule(self: *Factory, rule: Rule) void {
const name = rule.material;
if (self.rules.contains(name)) {
std.debug.warn("=== DUPLICATE rule for [{s}]\n", .{name});
} else {
_ = self.rules.put(name, rule) catch unreachable;
}
}
pub fn show(self: Factory) void {
std.debug.warn("ALL RULES\n", .{});
var it = self.rules.iterator();
while (it.next()) |rule| {
std.debug.warn(" RULE for [{}]:\n", .{rule.key});
rule.value.show();
}
}
pub fn ore_needed_for_fuel(self: *Factory, amount: usize) usize {
var left = std.StringHashMap(usize).init(allocator);
defer left.deinit();
self.ore_produced = 0;
self.ore_needed("FUEL", amount, &left);
return self.ore_produced;
}
fn ore_needed(self: *Factory, material: []const u8, needed: usize, left: *std.StringHashMap(usize)) void {
var amount_left: usize = 0;
if (left.contains(material)) {
amount_left = left.get(material).?;
}
var amount_needed: usize = needed;
if (amount_left >= amount_needed) {
// std.debug.warn("ENOUGH [{}]: LEFT {}, NEEDED {}\n",.{ material, amount_left, amount_needed});
amount_left -= amount_needed;
_ = left.put(material, amount_left) catch unreachable;
return;
}
if (std.mem.eql(u8, material, "ORE")) {
const produced = amount_needed - amount_left;
self.ore_produced += produced;
// std.debug.warn("PRODUCE [{}]: LEFT {}, NEEDED {}, PRODUCED {}, TOTAL {}\n",.{ material, amount_left, amount_needed, produced, self.ore_produced});
amount_left = 0;
_ = left.put(material, amount_left) catch unreachable;
return;
}
if (!self.rules.contains(material)) {
std.debug.warn("=== NO RULE for [{s}]:\n", .{material});
return;
}
if (amount_left > 0) {
// std.debug.warn("HAVE {} for [{}]\n",.{ amount_left, material});
amount_needed -= amount_left;
amount_left = 0;
}
const rules = self.rules.get(material).?;
const can_produce = rules.amount;
const runs = (amount_needed + can_produce - 1) / can_produce;
const produced = can_produce * runs;
amount_left = produced - amount_needed;
var it = rules.needed.iterator();
while (it.next()) |rule| {
// we need X of a product, and have rules to produce Y, which require A of m1, B of m2, etc
// we will have to run several copies of the rule
const ingredient_name = rule.key_ptr.*;
const ingredient_needed = runs * rule.value_ptr.*;
// std.debug.warn("NEED for {} [{}]: [{}] -- required {}\n",.{ amount_needed, material, ingredient_name, ingredient_needed});
self.ore_needed(ingredient_name, ingredient_needed, left);
// std.debug.warn("MADE for {} [{}]: [{}] -- produced {}\n",.{ amount_needed, material, ingredient_name, ingredient_produced});
}
_ = left.put(material, amount_left) catch unreachable;
}
pub fn fuel_possible(self: *Factory, available_ore: usize) usize {
// we will do a binary search, need to bracket with two points, one too low and one too high
const need_for_one = self.ore_needed_for_fuel(1);
var fuel_lo: usize = @intCast(usize, available_ore / need_for_one); // estimation, will be too small
// var need_lo = self.ore_needed_for_fuel(fuel_lo);
// std.debug.warn("LO {} {} -- {}\n",.{ fuel_lo, need_lo, @intCast(i64, available_ore - need_lo}));
var fuel_hi: usize = fuel_lo * 2; // estimation
var need_hi: usize = 0;
while (true) {
need_hi = self.ore_needed_for_fuel(fuel_hi);
if (need_hi >= available_ore) break;
fuel_hi *= 2;
}
// std.debug.warn("HI {} {} -- {}\n",.{ fuel_hi, need_hi, @intCast(i64, available_ore) - @intCast(i64, need_hi)});
// now a classic binary search
var j: usize = 0;
while (true) : (j += 1) {
const fuel_half: usize = (fuel_lo + fuel_hi) / 2;
const need_half = self.ore_needed_for_fuel(fuel_half);
// std.debug.warn("#{}: {} {} -> {} {} -- {}\n",.{ j, fuel_lo, fuel_hi, fuel_half, need_half, @intCast(i64, available_ore) - @intCast(i64, need_half)});
if (fuel_hi == fuel_half or fuel_lo == fuel_half) break;
if (need_half > available_ore) {
fuel_hi = fuel_half;
} else {
fuel_lo = fuel_half;
}
}
return fuel_lo;
}
};
test "ore needed 1" {
const data =
\\10 ORE => 10 A
\\1 ORE => 1 B
\\7 A, 1 B => 1 C
\\7 A, 1 C => 1 D
\\7 A, 1 D => 1 E
\\7 A, 1 E => 1 FUEL
;
var factory = Factory.init();
defer factory.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
factory.parse(line);
}
const needed = factory.ore_needed_for_fuel(1);
// std.debug.warn("NEEDED {} ore\n",.{ needed});
assert(needed == 31);
}
test "ore needed 2" {
const data =
\\9 ORE => 2 A
\\8 ORE => 3 B
\\7 ORE => 5 C
\\3 A, 4 B => 1 AB
\\5 B, 7 C => 1 BC
\\4 C, 1 A => 1 CA
\\2 AB, 3 BC, 4 CA => 1 FUEL
;
var factory = Factory.init();
defer factory.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
factory.parse(line);
}
const needed = factory.ore_needed_for_fuel(1);
// std.debug.warn("NEEDED {} ore\n",.{ needed});
assert(needed == 165);
}
test "ore needed 3" {
const data =
\\157 ORE => 5 NZVS
\\165 ORE => 6 DCFZ
\\44 XJWVT, 5 KHKGT, 1 QDVJ, 29 NZVS, 9 GPVTF, 48 HKGWZ => 1 FUEL
\\12 HKGWZ, 1 GPVTF, 8 PSHF => 9 QDVJ
\\179 ORE => 7 PSHF
\\177 ORE => 5 HKGWZ
\\7 DCFZ, 7 PSHF => 2 XJWVT
\\165 ORE => 2 GPVTF
\\3 DCFZ, 7 NZVS, 5 HKGWZ, 10 PSHF => 8 KHKGT
;
var factory = Factory.init();
defer factory.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
factory.parse(line);
}
const needed = factory.ore_needed_for_fuel(1);
// std.debug.warn("NEEDED {} ore\n",.{ needed});
assert(needed == 13312);
}
test "ore needed 4" {
const data =
\\2 VPVL, 7 FWMGM, 2 CXFTF, 11 MNCFX => 1 STKFG
\\17 NVRVD, 3 JNWZP => 8 VPVL
\\53 STKFG, 6 MNCFX, 46 VJHF, 81 HVMC, 68 CXFTF, 25 GNMV => 1 FUEL
\\22 VJHF, 37 MNCFX => 5 FWMGM
\\139 ORE => 4 NVRVD
\\144 ORE => 7 JNWZP
\\5 MNCFX, 7 RFSQX, 2 FWMGM, 2 VPVL, 19 CXFTF => 3 HVMC
\\5 VJHF, 7 MNCFX, 9 VPVL, 37 CXFTF => 6 GNMV
\\145 ORE => 6 MNCFX
\\1 NVRVD => 8 CXFTF
\\1 VJHF, 6 MNCFX => 4 RFSQX
\\176 ORE => 6 VJHF
;
var factory = Factory.init();
defer factory.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
factory.parse(line);
}
const needed = factory.ore_needed_for_fuel(1);
// std.debug.warn("NEEDED {} ore\n",.{ needed});
assert(needed == 180697);
}
test "ore needed 5" {
const data =
\\171 ORE => 8 CNZTR
\\7 ZLQW, 3 BMBT, 9 XCVML, 26 XMNCP, 1 WPTQ, 2 MZWV, 1 RJRHP => 4 PLWSL
\\114 ORE => 4 BHXH
\\14 VRPVC => 6 BMBT
\\6 BHXH, 18 KTJDG, 12 WPTQ, 7 PLWSL, 31 FHTLT, 37 ZDVW => 1 FUEL
\\6 WPTQ, 2 BMBT, 8 ZLQW, 18 KTJDG, 1 XMNCP, 6 MZWV, 1 RJRHP => 6 FHTLT
\\15 XDBXC, 2 LTCX, 1 VRPVC => 6 ZLQW
\\13 WPTQ, 10 LTCX, 3 RJRHP, 14 XMNCP, 2 MZWV, 1 ZLQW => 1 ZDVW
\\5 BMBT => 4 WPTQ
\\189 ORE => 9 KTJDG
\\1 MZWV, 17 XDBXC, 3 XCVML => 2 XMNCP
\\12 VRPVC, 27 CNZTR => 2 XDBXC
\\15 KTJDG, 12 BHXH => 5 XCVML
\\3 BHXH, 2 VRPVC => 7 MZWV
\\121 ORE => 7 VRPVC
\\7 XCVML => 6 RJRHP
\\5 BHXH, 4 VRPVC => 5 LTCX
;
var factory = Factory.init();
defer factory.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
factory.parse(line);
}
const needed = factory.ore_needed_for_fuel(1);
// std.debug.warn("NEEDED {} ore\n",.{ needed});
assert(needed == 2210736);
}
test "fuel possible to make 3" {
const data =
\\157 ORE => 5 NZVS
\\165 ORE => 6 DCFZ
\\44 XJWVT, 5 KHKGT, 1 QDVJ, 29 NZVS, 9 GPVTF, 48 HKGWZ => 1 FUEL
\\12 HKGWZ, 1 GPVTF, 8 PSHF => 9 QDVJ
\\179 ORE => 7 PSHF
\\177 ORE => 5 HKGWZ
\\7 DCFZ, 7 PSHF => 2 XJWVT
\\165 ORE => 2 GPVTF
\\3 DCFZ, 7 NZVS, 5 HKGWZ, 10 PSHF => 8 KHKGT
;
var factory = Factory.init();
defer factory.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
factory.parse(line);
}
const result = factory.fuel_possible(1000000000000);
assert(result == 82892753);
}
test "fuel possible to make 4" {
const data =
\\2 VPVL, 7 FWMGM, 2 CXFTF, 11 MNCFX => 1 STKFG
\\17 NVRVD, 3 JNWZP => 8 VPVL
\\53 STKFG, 6 MNCFX, 46 VJHF, 81 HVMC, 68 CXFTF, 25 GNMV => 1 FUEL
\\22 VJHF, 37 MNCFX => 5 FWMGM
\\139 ORE => 4 NVRVD
\\144 ORE => 7 JNWZP
\\5 MNCFX, 7 RFSQX, 2 FWMGM, 2 VPVL, 19 CXFTF => 3 HVMC
\\5 VJHF, 7 MNCFX, 9 VPVL, 37 CXFTF => 6 GNMV
\\145 ORE => 6 MNCFX
\\1 NVRVD => 8 CXFTF
\\1 VJHF, 6 MNCFX => 4 RFSQX
\\176 ORE => 6 VJHF
;
var factory = Factory.init();
defer factory.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
factory.parse(line);
}
const result = factory.fuel_possible(1000000000000);
assert(result == 5586022);
}
test "fuel possible to make 5" {
const data =
\\171 ORE => 8 CNZTR
\\7 ZLQW, 3 BMBT, 9 XCVML, 26 XMNCP, 1 WPTQ, 2 MZWV, 1 RJRHP => 4 PLWSL
\\114 ORE => 4 BHXH
\\14 VRPVC => 6 BMBT
\\6 BHXH, 18 KTJDG, 12 WPTQ, 7 PLWSL, 31 FHTLT, 37 ZDVW => 1 FUEL
\\6 WPTQ, 2 BMBT, 8 ZLQW, 18 KTJDG, 1 XMNCP, 6 MZWV, 1 RJRHP => 6 FHTLT
\\15 XDBXC, 2 LTCX, 1 VRPVC => 6 ZLQW
\\13 WPTQ, 10 LTCX, 3 RJRHP, 14 XMNCP, 2 MZWV, 1 ZLQW => 1 ZDVW
\\5 BMBT => 4 WPTQ
\\189 ORE => 9 KTJDG
\\1 MZWV, 17 XDBXC, 3 XCVML => 2 XMNCP
\\12 VRPVC, 27 CNZTR => 2 XDBXC
\\15 KTJDG, 12 BHXH => 5 XCVML
\\3 BHXH, 2 VRPVC => 7 MZWV
\\121 ORE => 7 VRPVC
\\7 XCVML => 6 RJRHP
\\5 BHXH, 4 VRPVC => 5 LTCX
;
var factory = Factory.init();
defer factory.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
factory.parse(line);
}
const result = factory.fuel_possible(1000000000000);
assert(result == 460664);
}
|
2019/p14/factory.zig
|
const std = @import("std");
const Builder = std.build.Builder;
const raylib = @import("lib.zig").Pkg(".");
const Program = struct {
name: []const u8,
path: []const u8,
desc: []const u8,
};
pub fn build(b: *Builder) void {
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const examples = [_]Program{
.{
.name = "basic_window",
.path = "examples/core/basic_window.zig",
.desc = "Creates a basic window with text",
},
.{
.name = "input_keys",
.path = "examples/core/input_keys.zig",
.desc = "Simple keyboard input",
},
.{
.name = "input_mouse",
.path = "examples/core/input_mouse.zig",
.desc = "Simple mouse input",
},
.{
.name = "input_mouse_wheel",
.path = "examples/core/input_mouse_wheel.zig",
.desc = "Mouse wheel input",
},
.{
.name = "input_multitouch",
.path = "examples/core/input_multitouch.zig",
.desc = "Multitouch input",
},
.{
.name = "2d_camera",
.path = "examples/core/2d_camera.zig",
.desc = "Shows the functionality of a 2D camera",
},
// .{
// .name = "models_loading",
// .path = "examples/models/models_loading.zig",
// .desc = "Loads a model and renders it",
// },
// .{
// .name = "shaders_basic_lighting",
// .path = "examples/shaders/shaders_basic_lighting.zig",
// .desc = "Loads a model and renders it",
// },
};
const examples_step = b.step("examples", "Builds all the examples");
const system_lib = b.option(bool, "system-raylib", "link to preinstalled raylib libraries") orelse false;
for (examples) |ex| {
const exe = b.addExecutable(ex.name, ex.path);
exe.setBuildMode(mode);
exe.setTarget(target);
raylib.link(exe, system_lib);
raylib.addAsPackage("raylib", exe);
raylib.math.addAsPackage("raylib-math", exe);
const run_cmd = exe.run();
const run_step = b.step(ex.name, ex.desc);
run_step.dependOn(&run_cmd.step);
examples_step.dependOn(&exe.step);
}
}
|
build.zig
|
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
pub fn run(input: []const u8, allocator: std.mem.Allocator) ![2][]const u8 {
const Bag = struct {
count: u8,
items: [24]struct { n: u16, col: u16 },
};
var colors = std.StringHashMap(u16).init(allocator);
defer colors.deinit();
// index by color_id
var contents: []Bag = undefined;
var parents: []Bag = undefined;
{
var contents_desc = std.ArrayList([]const u8).init(allocator);
defer contents_desc.deinit();
// parse all colors:
{
var it = std.mem.tokenize(u8, input, "\n\r");
while (it.next()) |line| {
const fields = tools.match_pattern("{} bags contain {}.", line) orelse unreachable;
const color = fields[0].lit;
const desc = fields[1].lit;
const color_id = contents_desc.items.len;
try colors.putNoClobber(color, @intCast(u16, color_id));
try contents_desc.append(desc);
}
}
// parse all coNTENTS:
contents = try allocator.alloc(Bag, contents_desc.items.len);
parents = try allocator.alloc(Bag, contents_desc.items.len);
errdefer allocator.free(contents);
errdefer allocator.free(parents);
std.mem.set(Bag, parents, Bag{ .count = 0, .items = undefined });
for (contents_desc.items) |desc, color_id| {
const c = &contents[color_id];
if (std.mem.eql(u8, desc, "no other bags")) {
c.* = Bag{ .count = 0, .items = undefined };
} else {
c.count = 0;
var iter = std.mem.tokenize(u8, desc, ",");
while (iter.next()) |item| {
const v = tools.match_pattern("{} {} bag", item) orelse unreachable;
const n = @intCast(u8, v[0].imm);
const col = colors.get(v[1].lit) orelse unreachable;
c.items[c.count].n = n;
c.items[c.count].col = col;
c.count += 1;
const p = &parents[col];
p.items[p.count].n = n;
p.items[p.count].col = @intCast(u16, color_id);
p.count += 1;
}
}
}
}
defer allocator.free(contents);
defer allocator.free(parents);
const ans1 = ans: {
var containers = std.AutoHashMap(u16, void).init(allocator);
defer containers.deinit();
var queue = std.ArrayList(u16).init(allocator);
defer queue.deinit();
const root_id = colors.get("shiny gold") orelse unreachable;
try queue.append(root_id);
while (queue.items.len > 0) {
const col = queue.pop();
for (parents[col].items[0..parents[col].count]) |it| {
const r = try containers.getOrPut(it.col);
if (!r.found_existing)
try queue.append(it.col);
}
}
break :ans containers.count();
};
const ans2 = ans: {
var queue = std.ArrayList(struct { n: u16, col: u16 }).init(allocator);
defer queue.deinit();
const root_id = colors.get("shiny gold") orelse unreachable;
try queue.append(.{ .n = 1, .col = root_id });
var total: u64 = 0;
while (queue.items.len > 0) {
const c = queue.pop();
total += c.n;
for (contents[c.col].items[0..contents[c.col].count]) |it| {
try queue.append(.{ .n = c.n * it.n, .col = it.col });
}
}
break :ans total - 1;
};
return [_][]const u8{
try std.fmt.allocPrint(allocator, "{}", .{ans1}),
try std.fmt.allocPrint(allocator, "{}", .{ans2}),
};
}
pub const main = tools.defaultMain("2020/input_day07.txt", run);
|
2020/day07.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/day14.txt", run);
pub fn run(input: []const u8, gpa: std.mem.Allocator) tools.RunError![2][]const u8 {
//var arena_alloc = std.heap.ArenaAllocator.init(gpa);
//defer arena_alloc.deinit();
//const arena = arena_alloc.allocator();
const table_base = '@' * 256;
const table_count = (('Z' + 1) - '@') * 256; // @,A,..,Z
var it = std.mem.tokenize(u8, input, "\n");
const template = it.next().?;
var rules_table: [table_count]u8 = undefined;
std.mem.set(u8, &rules_table, 0);
while (it.next()) |line| {
if (tools.match_pattern("{} -> {}", line)) |val| {
const pair = @ptrCast(*align(1) const u16, val[0].lit.ptr).*;
const insert = val[1].lit;
rules_table[pair - table_base] = insert[0]; // little endian
} else {
std.debug.print("skipping {s}\n", .{line});
}
}
const ans1 = ans: {
// version bourrin in-extenso
var bufs = [2][]u8{
try gpa.alloc(u8, 64 * 1024),
try gpa.alloc(u8, 64 * 1024),
};
defer {
gpa.free(bufs[0]);
gpa.free(bufs[1]);
}
var state = [2]usize{ template.len, 0 };
std.mem.copy(u8, bufs[0][0..state[0]], template);
var gen: u32 = 0;
while (gen < 10) : (gen += 1) {
const from = bufs[gen % 2][0..state[gen % 2]];
const to = bufs[1 - gen % 2];
var len: usize = 0;
var i: u32 = 1;
while (i < from.len) : (i += 1) {
to[len] = from[i - 1];
len += 1;
const pair = @ptrCast(*align(1) const u16, &from[i - 1]).*;
const insert = rules_table[pair - table_base];
if (insert != 0) {
to[len] = insert;
len += 1;
}
}
to[len] = from[from.len - 1];
len += 1;
state[1 - gen % 2] = len;
trace("gen{} : {s}\n", .{ gen + 1, to[0..len] });
}
const final = bufs[gen % 2][0..state[gen % 2]];
var quantities = [1]u32{0} ** 128;
for (final) |c| quantities[c] += 1;
var min: u32 = 0xFFFFFFFF;
var max: u32 = 0;
for (quantities) |q| {
if (q == 0) continue;
min = @minimum(min, q);
max = @maximum(max, q);
}
break :ans max - min;
};
const ans2 = ans: {
// pour éviter les problèmes avec l'overlap, on considère que des paires: (dont on ne compte que la première lettre pour les stats)
// NNCB == "NN + NC + CB + B@"
// on réécrit les règles pour marcher par paires,
// puis on pourra facilement avoir un compte par type de paires.
const all_pairs = comptime blk: {
var p: [26 * 27]u16 = undefined;
for ("ABCDEFGHIJKLMNOPQRSTUVWXYZ") |letter1, i| {
for ("ABCDEFGHIJKLMNOPQRSTUVWXYZ@") |letter2, j| {
p[i * 27 + j] = @as(u16, letter2) << 8 | letter1;
}
}
break :blk p;
};
var rules_as_pairs: [table_count][2]u16 = undefined;
for (all_pairs) |pair| {
const insert = rules_table[pair - table_base];
if (insert != 0) {
const letter1 = @intCast(u8, pair & 0xFF);
const letter2 = @intCast(u8, (pair >> 8) & 0xFF);
rules_as_pairs[pair - table_base][0] = @as(u16, insert) << 8 | letter1;
rules_as_pairs[pair - table_base][1] = @as(u16, letter2) << 8 | insert;
} else {
rules_as_pairs[pair - table_base][0] = pair;
rules_as_pairs[pair - table_base][1] = 0;
}
}
var pairs_count: [table_count]u64 = undefined;
std.mem.set(u64, &pairs_count, 0);
var i: u32 = 0;
while (i < template.len) : (i += 1) {
const pair = if (i < template.len - 1) @ptrCast(*align(1) const u16, &template[i]).* else (@as(u16, '@') << 8 | template[i]);
pairs_count[pair - table_base] += 1;
}
var gen: u32 = 0;
while (gen < 40) : (gen += 1) {
var count2: [table_count]u64 = undefined;
std.mem.set(u64, &count2, 0);
for (all_pairs) |pair| {
for (rules_as_pairs[pair - table_base]) |out| {
if (out != 0) count2[out - table_base] += pairs_count[pair - table_base];
}
}
std.mem.copy(u64, &pairs_count, &count2);
}
{
var quantities = [1]u64{0} ** 128;
for (all_pairs) |pair| {
const letter1 = @intCast(u8, pair & 0xFF);
quantities[letter1] += pairs_count[pair - table_base];
}
var min: u64 = 0xFFFFFFFFFFFFFFFF;
var max: u64 = 0;
for (quantities) |q| {
if (q == 0) continue;
min = @minimum(min, q);
max = @maximum(max, q);
}
break :ans max - min;
}
};
return [_][]const u8{
try std.fmt.allocPrint(gpa, "{}", .{ans1}),
try std.fmt.allocPrint(gpa, "{}", .{ans2}),
};
}
test {
const res0 = try run(
\\NNCB
\\
\\CH -> B
\\HH -> N
\\CB -> H
\\NH -> C
\\HB -> C
\\HC -> B
\\HN -> C
\\NN -> C
\\BH -> H
\\NC -> B
\\NB -> B
\\BN -> B
\\BB -> N
\\BC -> B
\\CC -> N
\\CN -> C
, std.testing.allocator);
defer std.testing.allocator.free(res0[0]);
defer std.testing.allocator.free(res0[1]);
try std.testing.expectEqualStrings("1588", res0[0]);
try std.testing.expectEqualStrings("2188189693529", res0[1]);
}
|
2021/day14.zig
|
const std = @import("std");
const rk = @import("renderkit");
const gk = @import("../gamekit.zig");
const math = gk.math;
const IndexBuffer = rk.IndexBuffer;
const VertexBuffer = rk.VertexBuffer;
pub const MultiVertex = extern struct {
pos: math.Vec2,
uv: math.Vec2 = .{ .x = 0, .y = 0 },
col: u32 = 0xFFFFFFFF,
tid: f32 = 0,
};
pub const MultiBatcher = struct {
mesh: gk.gfx.DynamicMesh(u16, MultiVertex),
vert_index: usize = 0, // current index into the vertex array
textures: [8]rk.Image = undefined,
last_texture: usize = 0,
pub fn init(allocator: std.mem.Allocator, max_sprites: usize) MultiBatcher {
if (max_sprites * 6 > std.math.maxInt(u16)) @panic("max_sprites exceeds u16 index buffer size");
var indices = allocator.alloc(u16, max_sprites * 6) catch unreachable;
var i: usize = 0;
while (i < max_sprites) : (i += 1) {
indices[i * 3 * 2 + 0] = @intCast(u16, i) * 4 + 0;
indices[i * 3 * 2 + 1] = @intCast(u16, i) * 4 + 1;
indices[i * 3 * 2 + 2] = @intCast(u16, i) * 4 + 2;
indices[i * 3 * 2 + 3] = @intCast(u16, i) * 4 + 0;
indices[i * 3 * 2 + 4] = @intCast(u16, i) * 4 + 2;
indices[i * 3 * 2 + 5] = @intCast(u16, i) * 4 + 3;
}
return .{
.mesh = gk.gfx.DynamicMesh(u16, MultiVertex).init(allocator, max_sprites * 4, indices) catch unreachable,
.textures = [_]rk.Image{0} ** 8,
};
}
pub fn deinit(self: *MultiBatcher) void {
self.mesh.deinit();
}
pub fn begin(self: *MultiBatcher) void {
self.vert_index = 0;
}
pub fn end(self: *MultiBatcher) void {
self.flush();
}
pub fn flush(self: *MultiBatcher) void {
if (self.vert_index == 0) return;
// send data to gpu
self.mesh.updateVertSlice(self.vert_index);
// bind textures
for (self.textures) |tid, slot| {
if (slot == self.last_texture) break;
self.mesh.bindImage(tid, @intCast(c_uint, slot));
}
// draw
const quads = @divExact(self.vert_index, 4);
self.mesh.draw(0, @intCast(c_int, quads * 6));
// reset state
for (self.textures) |*tid, slot| {
if (slot == self.last_texture) break;
self.mesh.bindImage(tid.*, @intCast(c_uint, slot));
tid.* = 0;
}
self.vert_index = 0;
self.last_texture = 0;
}
inline fn submitTexture(self: *MultiBatcher, img: rk.Image) f32 {
if (std.mem.indexOfScalar(rk.Image, &self.textures, img)) |index| return @intToFloat(f32, index);
self.textures[self.last_texture] = img;
self.last_texture += 1;
return @intToFloat(f32, self.last_texture - 1);
}
pub fn drawTex(self: *MultiBatcher, pos: math.Vec2, col: u32, texture: gk.gfx.Texture) void {
if (self.vert_index >= self.mesh.verts.len) {
self.flush();
}
const tid = self.submitTexture(texture.img);
var verts = self.mesh.verts[self.vert_index .. self.vert_index + 4];
verts[0].pos = pos; // tl
verts[0].uv = .{ .x = 0, .y = 0 };
verts[0].col = col;
verts[0].tid = tid;
verts[1].pos = .{ .x = pos.x + texture.width, .y = pos.y }; // tr
verts[1].uv = .{ .x = 1, .y = 0 };
verts[1].col = col;
verts[1].tid = tid;
verts[2].pos = .{ .x = pos.x + texture.width, .y = pos.y + texture.height }; // br
verts[2].uv = .{ .x = 1, .y = 1 };
verts[2].col = col;
verts[2].tid = tid;
verts[3].pos = .{ .x = pos.x, .y = pos.y + texture.height }; // bl
verts[3].uv = .{ .x = 0, .y = 1 };
verts[3].col = col;
verts[3].tid = tid;
self.vert_index += 4;
}
};
|
gamekit/graphics/multi_batcher.zig
|
const std = @import("std");
// There's just 256 different input valus - just use a table.
const srgb8_to_f32_tab = [256]u32{
0x00000000, 0x399f22b4, 0x3a1f22b4, 0x3a6eb40f, 0x3a9f22b4, 0x3ac6eb61, 0x3aeeb40f, 0x3b0b3e5e,
0x3b1f22b4, 0x3b33070b, 0x3b46eb61, 0x3b5b518d, 0x3b70f18d, 0x3b83e1c6, 0x3b8fe616, 0x3b9c87fd,
0x3ba9c9b7, 0x3bb7ad6f, 0x3bc63549, 0x3bd56361, 0x3be539c1, 0x3bf5ba70, 0x3c0373b5, 0x3c0c6152,
0x3c15a703, 0x3c1f45be, 0x3c293e6b, 0x3c3391f7, 0x3c3e4149, 0x3c494d43, 0x3c54b6c7, 0x3c607eb1,
0x3c6ca5df, 0x3c792d22, 0x3c830aa8, 0x3c89af9f, 0x3c9085db, 0x3c978dc5, 0x3c9ec7c2, 0x3ca63433,
0x3cadd37d, 0x3cb5a601, 0x3cbdac20, 0x3cc5e639, 0x3cce54ab, 0x3cd6f7d5, 0x3cdfd010, 0x3ce8ddb9,
0x3cf22131, 0x3cfb9ac6, 0x3d02a56c, 0x3d0798df, 0x3d0ca7e7, 0x3d11d2b2, 0x3d171965, 0x3d1c7c31,
0x3d21fb3f, 0x3d2796b5, 0x3d2d4ebe, 0x3d332384, 0x3d39152e, 0x3d3f23e6, 0x3d454fd4, 0x3d4b991f,
0x3d51ffef, 0x3d58846a, 0x3d5f26b7, 0x3d65e6fe, 0x3d6cc564, 0x3d73c20f, 0x3d7add29, 0x3d810b67,
0x3d84b795, 0x3d887330, 0x3d8c3e4a, 0x3d9018f6, 0x3d940345, 0x3d97fd4a, 0x3d9c0716, 0x3da020bb,
0x3da44a4b, 0x3da883d7, 0x3daccd70, 0x3db12728, 0x3db59112, 0x3dba0b3b, 0x3dbe95b5, 0x3dc33092,
0x3dc7dbe2, 0x3dcc97b6, 0x3dd1641f, 0x3dd6412c, 0x3ddb2eef, 0x3de02d77, 0x3de53cd5, 0x3dea5d19,
0x3def8e55, 0x3df4d093, 0x3dfa23ea, 0x3dff8864, 0x3e027f09, 0x3e054282, 0x3e080ea5, 0x3e0ae379,
0x3e0dc107, 0x3e10a755, 0x3e13966c, 0x3e168e53, 0x3e198f11, 0x3e1c98ae, 0x3e1fab32, 0x3e22c6a3,
0x3e25eb0b, 0x3e29186d, 0x3e2c4ed4, 0x3e2f8e45, 0x3e32d6c8, 0x3e362865, 0x3e398322, 0x3e3ce706,
0x3e405419, 0x3e43ca62, 0x3e4749e8, 0x3e4ad2b1, 0x3e4e64c6, 0x3e52002b, 0x3e55a4e9, 0x3e595307,
0x3e5d0a8b, 0x3e60cb7c, 0x3e6495e0, 0x3e6869bf, 0x3e6c4720, 0x3e702e0c, 0x3e741e84, 0x3e781890,
0x3e7c1c38, 0x3e8014c2, 0x3e82203c, 0x3e84308d, 0x3e8645ba, 0x3e885fc5, 0x3e8a7eb2, 0x3e8ca283,
0x3e8ecb3d, 0x3e90f8e1, 0x3e932b74, 0x3e9562f8, 0x3e979f71, 0x3e99e0e2, 0x3e9c274e, 0x3e9e72b7,
0x3ea0c322, 0x3ea31892, 0x3ea57308, 0x3ea7d289, 0x3eaa3718, 0x3eaca0b7, 0x3eaf0f69, 0x3eb18333,
0x3eb3fc18, 0x3eb67a18, 0x3eb8fd37, 0x3ebb8579, 0x3ebe12e1, 0x3ec0a571, 0x3ec33d2d, 0x3ec5da17,
0x3ec87c33, 0x3ecb2383, 0x3ecdd00b, 0x3ed081cd, 0x3ed338cc, 0x3ed5f50b, 0x3ed8b68d, 0x3edb7d54,
0x3ede4965, 0x3ee11ac1, 0x3ee3f16b, 0x3ee6cd67, 0x3ee9aeb6, 0x3eec955d, 0x3eef815d, 0x3ef272ba,
0x3ef56976, 0x3ef86594, 0x3efb6717, 0x3efe6e02, 0x3f00bd2d, 0x3f02460e, 0x3f03d1a7, 0x3f055ff9,
0x3f06f108, 0x3f0884d1, 0x3f0a1b57, 0x3f0bb49d, 0x3f0d50a2, 0x3f0eef69, 0x3f1090f2, 0x3f123540,
0x3f13dc53, 0x3f15862d, 0x3f1732cf, 0x3f18e23b, 0x3f1a9471, 0x3f1c4973, 0x3f1e0143, 0x3f1fbbe1,
0x3f217950, 0x3f23398f, 0x3f24fca2, 0x3f26c288, 0x3f288b43, 0x3f2a56d5, 0x3f2c253f, 0x3f2df681,
0x3f2fca9e, 0x3f31a199, 0x3f337b6e, 0x3f355822, 0x3f3737b5, 0x3f391a28, 0x3f3aff7e, 0x3f3ce7b7,
0x3f3ed2d4, 0x3f40c0d6, 0x3f42b1c0, 0x3f44a592, 0x3f469c4d, 0x3f4895f3, 0x3f4a9284, 0x3f4c9203,
0x3f4e9470, 0x3f5099cd, 0x3f52a21a, 0x3f54ad59, 0x3f56bb8c, 0x3f58ccb3, 0x3f5ae0cf, 0x3f5cf7e2,
0x3f5f11ee, 0x3f612ef2, 0x3f634eef, 0x3f6571ec, 0x3f6797e3, 0x3f69c0db, 0x3f6beccd, 0x3f6e1bc4,
0x3f704db8, 0x3f7282b4, 0x3f74baae, 0x3f76f5b3, 0x3f7933b9, 0x3f7b74cb, 0x3f7db8e0, 0x3f800000,
};
pub fn srgb8ToF32(srgb8: u8) f32 {
return @bitCast(f32, srgb8_to_f32_tab[srgb8]);
}
pub fn f32ToLinear8(f: f32) u8 {
return @floatToInt(u8, std.math.round(f * 255));
}
pub fn bitFloat(comptime T: type, comptime int: comptime_int) T {
const IntType = @Type(.{ .Int = .{ .signedness = .unsigned, .bits = @typeInfo(T).Float.bits } });
return @bitCast(f32, @as(IntType, int));
}
pub fn f32ToSrgb8Exact(f: f32) u8 {
var s = @as(f32, undefined);
if (!(f > 0)) {
s = 0;
} else if (f <= 0.0031308) {
s = 12.92 * f;
} else if (f < 1) {
s = 1.055 * std.math.pow(f32, f, 1 / 2.4) - 0.055;
} else {
s = 1;
}
return @floatToInt(u8, s * 255);
}
const f32_to_srgb8_table = [104]u32{
0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d,
0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a,
0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033,
0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067,
0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5,
0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2,
0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143,
0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af,
0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240,
0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300,
0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401,
0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559,
0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723,
};
pub fn f32ToSrgb8(f: f32) u8 {
const almostone = bitFloat(f32, 0x3f7fffff); // 1-eps)
const minval = bitFloat(f32, (127 - 13) << 23);
const clampf = std.math.clamp(f, minval, almostone);
const i = (@bitCast(u32, clampf) - @bitCast(u32, minval)) >> 20;
const tab = f32_to_srgb8_table[i];
const bias = (tab >> 16) << 9;
const scale = tab & 0xffff;
const t = (@bitCast(u32, clampf) >> 12) & 0xFF;
return @intCast(u8, (bias + scale * t) >> 16);
}
pub fn rsqrt(t: anytype) @TypeOf(t) {
return 1 / @sqrt(t);
}
pub fn lerp(a: anytype, b: @TypeOf(a), t: anytype) @TypeOf(a) {
return a.mulScalar(t).add(b.mulScalar(1 - t));
}
pub fn Vec3(comptime T: type) type {
return extern union {
col: extern struct { r: T, g: T, b: T },
pos: extern struct { x: T, y: T, z: T },
arr: [3]T,
pub fn init(a: T, b: T, c: T) @This() {
return @This(){ .arr = [3]T{ a, b, c } };
}
pub fn dot(v1: @This(), v2: @This()) T {
var ret = @as(T, 0);
for (v1.arr) |_, i| {
ret += v1.arr[i] * v2.arr[i];
}
return ret;
}
pub fn add(v1: @This(), v2: @This()) @This() {
var ret = @as(@This(), undefined);
for (ret.arr) |*s, i| {
s.* = v1.arr[i] + v2.arr[i];
}
return ret;
}
pub fn sub(v1: @This(), v2: @This()) @This() {
var ret = @as(@This(), undefined);
for (ret.arr) |*s, i| {
s.* = v1.arr[i] - v2.arr[i];
}
return ret;
}
pub fn mul(v1: @This(), v2: @This()) @This() {
var ret = @as(@This(), undefined);
for (ret.arr) |*s, i| {
s.* = v1.arr[i] * v2.arr[i];
}
return ret;
}
pub fn div(v1: @This(), v2: @This()) @This() {
var ret = @as(@This(), undefined);
for (ret.arr) |*s, i| {
s.* = v1.arr[i] / v2.arr[i];
}
return ret;
}
pub fn addScalar(v1: @This(), scalar: T) @This() {
var ret = @as(@This(), undefined);
for (ret.arr) |*s, i| {
s.* = v1.arr[i] + scalar;
}
return ret;
}
pub fn subScalar(v1: @This(), scalar: T) @This() {
var ret = @as(@This(), undefined);
for (ret.arr) |*s, i| {
s.* = v1.arr[i] - scalar;
}
return ret;
}
pub fn divScalar(v1: @This(), scalar: T) @This() {
var ret = @as(@This(), undefined);
for (ret.arr) |*s, i| {
s.* = v1.arr[i] / scalar;
}
return ret;
}
pub fn mulScalar(v1: @This(), scalar: T) @This() {
var ret = @as(@This(), undefined);
for (ret.arr) |*s, i| {
s.* = v1.arr[i] * scalar;
}
return ret;
}
pub fn squareLen(this: @This()) T {
var square_len = @as(T, 0);
for (this.arr) |i| {
square_len += i * i;
}
return square_len;
}
pub fn normalize(this: @This()) @This() {
var square_len = this.squareLen();
return this.mulScalar(rsqrt(square_len));
}
};
}
pub fn Ray(comptime T: type) type {
return struct {
p: Vec3(T),
dir: Vec3(T), // Must be normalized
pub fn pointAtDistance(this: @This(), t: T) Vec3(T) {
return this.p.add(this.dir.mulScalar(t));
}
};
}
pub fn randomInUnitSphere(rng: *std.rand.Random) Vec3(f32) {
while (true) {
const v = Vec3(f32).init(
rng.float(f32) * 2 - 1,
rng.float(f32) * 2 - 1,
rng.float(f32) * 2 - 1,
);
if (v.squareLen() < 1) {
return v;
}
}
}
pub fn randomUnitVec(rng: *std.rand.Random) Vec3(f32) {
return Vec3(f32).init(
rng.float(f32) * 2 - 1,
rng.float(f32) * 2 - 1,
rng.float(f32) * 2 - 1,
).normalize();
}
pub fn randomInUnitHemisphere(rng: *std.rand.Random, n: Vec3(f32)) Vec3(f32) {
const randVec = randomInUnitSphere(rng);
if (randVec.dot(n) > 0) {
return randVec;
} else {
return randVec.mulScalar(-1);
}
}
|
src/math.zig
|
const std = @import("std");
const assert = std.debug.assert;
pub const ArrayError = error {
OutOfBounds,
};
pub fn Array(comptime T: type) type {
return struct {
const Self = @This();
arr: []T,
allocator: *std.mem.Allocator,
pub fn init(allocator: *std.mem.Allocator) Self {
return Self {
.arr = [_]T{},
.allocator = allocator,
};
}
pub fn initNew(allocator: *std.mem.Allocator, count: usize) !Self {
return Self {
.arr = try allocator.alloc(T,count),
.allocator = allocator,
};
}
pub fn deinit(self: Self) void {
self.allocator.free(self.arr);
}
pub fn fromOwnedSlice(allocator: *std.mem.Allocator, slice: []T) Self {
return Self {
.arr = slice,
.allocator = allocator,
};
}
pub fn toOwnedSlice(self: *Self) []T {
const arr = self.arr;
self.arr = [_]T{};
return arr;
}
pub fn toSlice(self: Self, start_pos: usize, count: usize) []T {
if(start_pos >= self.arr.len or start_pos+count-1 >= self.arr.len)
@panic("Array.toSlice() range is out of bounds");
return self.arr[start_pos..start_pos+count];
}
pub fn toSliceConst(self: Self, start_pos: usize, count: usize) []const T {
if(start_pos >= self.arr.len or start_pos+count-1 >= self.arr.len)
@panic("Array.toSliceConst() range is out of bounds");
return self.arr[start_pos..start_pos+count];
}
pub fn at(self: Self, pos: usize) T {
assert(pos < self.arr.len);
return self.arr[pos];
}
pub fn safeAt(self: Self, pos: usize) !T {
if(pos>=self.arr.len)
return ArrayError.OutOfBounds;
return self.arr[pos];
}
pub fn set(self: Self, pos: usize, item: T) void {
assert(pos < self.arr.len);
self.arr[pos] = item;
}
pub fn safeSet(self: Self, pos: usize, item: T) !void {
if(pos >= self.arr.len)
return ArrayError.OutOfBounds;
self.arr[pos] = item;
}
pub fn len(self: Self) usize {
return self.arr.len;
}
pub fn clone(self: Self) !Self {
const tmp = try self.allocator.alloc(T,self.arr.len);
return Self {
.arr = std.mem.copy(T,tmp,self.arr),
.allocator = self.allocator,
};
}
pub fn filter(self: Self, predicate: fn(T)bool) !Self {
var arr = try self.allocator.alloc(T,self.arr.len);
var count: usize = 0;
for(self.arr) |item| {
if(predicate(item)){
arr[count] = item;
count += 1;
}
}
return Self {
.arr = try self.allocator.realloc(arr,count),
.allocator = self.allocator,
};
}
pub fn map(self: Self, comptime X: type, mapper: fn(T)X) !Array(X) {
var arr = try self.allocator.alloc(X,self.arr.len);
for(self.arr) |item,i| {
arr[i] = mapper(item);
}
return Array(X) {
.arr = arr,
.allocator = self.allocator,
};
}
pub fn reduce(self: Self, comptime X: type, reducer: var, initial: X) X {
var accumulator = initial;
for(self.arr) |item| {
accumulator = reducer(accumulator,item);
}
return accumulator;
}
};
}
|
array.zig
|
const builtin = @import("builtin");
const std = @import("std");
const mem = std.mem;
const assert = std.debug.assert;
const warn = std.debug.warn;
const gl = @import("modules/zig-sdl2/src/index.zig");
pub const EventResult = enum {
NoEvents,
Continue,
Quit,
};
pub const EventInterface = struct {
event: gl.SDL_Event,
handleKeyEvent: fn (pThing: *c_void, event: *gl.SDL_Event) EventResult,
handleMouseEvent: fn (pThing: *c_void, event: *gl.SDL_Event) EventResult,
handleOtherEvent: fn (pThing: *c_void, event: *gl.SDL_Event) EventResult,
};
pub fn processEvent(pThing: *c_void, pEi: *EventInterface, event: *gl.SDL_Event) EventResult {
switch (event.type) {
gl.SDL_QUIT => {
return EventResult.Quit;
},
gl.SDL_KEYUP, gl.SDL_KEYDOWN => |et| {
return pEi.handleKeyEvent(pThing, event);
},
gl.SDL_MOUSEBUTTONUP, gl.SDL_MOUSEBUTTONDOWN, gl.SDL_MOUSEMOTION => |et| {
return pEi.handleMouseEvent(pThing, event);
},
else => return pEi.handleOtherEvent(pThing, event),
}
}
pub fn pollInputEvent(pThing: *c_void, pEi: *EventInterface) EventResult {
var event: gl.SDL_Event = undefined;
if (gl.SDL_PollEvent(&event) == 0) return EventResult.NoEvents;
return processEvent(pThing, pEi, &event);
}
// Test
fn handleKeyEvent(pThing: *c_void, event: *gl.SDL_Event) EventResult {
var pMyThing: *Thing = @intToPtr(*Thing, @ptrToInt(pThing));
pMyThing.key_count += 1;
return EventResult.Continue;
}
fn handleMouseEvent(pThing: *c_void, event: *gl.SDL_Event) EventResult {
var pMyThing: *Thing = @intToPtr(*Thing, @ptrToInt(pThing));
pMyThing.mouse_count += 1;
return EventResult.Continue;
}
fn handleOtherEvent(pThing: *c_void, event: *gl.SDL_Event) EventResult {
var pMyThing: *Thing = @intToPtr(*Thing, @ptrToInt(pThing));
pMyThing.other_count += 1;
return EventResult.Continue;
}
const Thing = struct {
key_count: usize,
mouse_count: usize,
other_count: usize,
};
test "inputEvents" {
var thing = Thing{
.key_count = 0,
.mouse_count = 0,
.other_count = 0,
};
var ei = EventInterface{
.event = undefined,
.handleKeyEvent = handleKeyEvent,
.handleMouseEvent = handleMouseEvent,
.handleOtherEvent = handleOtherEvent,
};
var event: gl.SDL_Event = undefined;
event.type = gl.SDL_KEYDOWN;
assert(processEvent(&thing, &ei, &event) == EventResult.Continue);
assert(thing.key_count == 1);
event.type = gl.SDL_KEYUP;
assert(processEvent(&thing, &ei, &event) == EventResult.Continue);
assert(thing.key_count == 2);
event.type = gl.SDL_MOUSEBUTTONDOWN;
assert(processEvent(&thing, &ei, &event) == EventResult.Continue);
assert(thing.mouse_count == 1);
event.type = gl.SDL_MOUSEBUTTONUP;
assert(processEvent(&thing, &ei, &event) == EventResult.Continue);
assert(thing.mouse_count == 2);
event.type = gl.SDL_MOUSEMOTION;
assert(processEvent(&thing, &ei, &event) == EventResult.Continue);
assert(thing.mouse_count == 3);
}
|
src/input_events.zig
|
const std = @import("std");
const io = std.io;
const rpc = @import("jsonrpc2.zig");
const warn = std.debug.warn;
const testing = std.testing;
const Buffer = std.Buffer;
const json = std.json;
const mem = std.mem;
const Dump = @import("../json/json.zig").Dump;
test "Conn.readRequestData" {
const src = "Content-Length: 43\r\n\r\n{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"example\"}";
var stream = &io.SliceInStream.init(src).stream;
var a = std.debug.global_allocator;
var buf = &try std.Buffer.init(a, "");
defer buf.deinit();
try rpc.Conn.readRequestData(buf, stream);
const message =
\\{"jsonrpc":"2.0","id":1,"method":"example"}
;
testing.expect(buf.eql(message));
}
fn testEncode(buf: *Buffer, object: var, want: []const u8) !void {
var arena = std.heap.ArenaAllocator.init(buf.list.allocator);
defer arena.deinit();
var alloc = &arena.allocator;
var dump = &try Dump.init(alloc);
try buf.resize(0);
var stream = &std.io.BufferOutStream.init(buf).stream;
var v = object.encode(alloc);
try dump.dump(v, stream);
// warn("{}\n", buf.toSlice());
// warn("{}\n", buf.eql(want));
testing.expect(buf.eql(want));
}
fn testEncodeErr(buf: *Buffer, object: var, want: []const u8) !void {
var arena = std.heap.ArenaAllocator.init(buf.list.allocator);
defer arena.deinit();
var alloc = &arena.allocator;
var dump = &try Dump.init(alloc);
try buf.resize(0);
var stream = &std.io.BufferOutStream.init(buf).stream;
var v = try object.encode(alloc);
try dump.dump(v, stream);
// warn("\n{}\n", buf.toSlice());
}
test "rpc.ID" {
var a = std.debug.global_allocator;
var buf = &try std.Buffer.init(a, "");
defer buf.deinit();
var name_id = rpc.ID{ .Name = "id" };
try testEncode(buf, name_id,
\\"id"
);
var number_id = rpc.ID{ .Number = 1 };
try testEncode(buf, number_id,
\\1
);
var id: rpc.ID = undefined;
try (&id).decode(json.Value{ .Integer = 1 });
testing.expectEqual(id.Number, 1);
try (&id).decode(json.Value{ .String = "id" });
testing.expect(mem.eql(u8, id.Name, "id"));
}
|
src/lsp/jsonrpc2/jsonrpc2_test.zig
|
// TODO: Right now, this allocator only handles small allocations (at most 256
// bytes or so, which are the most common case for many programs) and defers
// all others to the child allocator. If the child allocator is
// DirectAllocator, this will mean that medium-sized allocations (e.g. 1024
// bytes) are very inefficient. The plan is for this library to provide
// another allocator layer that fits between this small-block allocator and
// DirectAllocator for handling medium-sized allocations.
const std = @import("std");
const assert = std.debug.assert;
const assertError = std.debug.assertError;
const Allocator = std.mem.Allocator;
const params = @import("params.zig");
const sblock = @import("sblock.zig");
const Superblock = sblock.Superblock(STHeap);
const SuperblockList = sblock.SuperblockList(STHeap);
//===========================================================================//
/// How many distinct block sizes there are. Right now, all block sizes are
/// powers of 2, from params.min_block_size to params.max_block_size inclusive.
const num_block_sizes = std.math.log2_int_ceil(usize, params.max_block_size) -
std.math.log2_int_ceil(usize, params.min_block_size) + 1;
//===========================================================================//
/// A heap for a single-threaded allocator.
const STHeap = struct {
/// The block size of superblocks in this heap.
block_size: u32,
/// Array of doubly-linked lists of superblocks in various states of
/// emptyness.
emptyness_buckets: [params.num_emptyness_buckets]SuperblockList,
fn init(self: *this, block_size: u32) void {
self.block_size = block_size;
for (self.emptyness_buckets) |*bucket| {
bucket.init();
assert(bucket.isEmpty());
}
}
fn deinit(self: *this, child_allocator: *Allocator) void {
for (self.emptyness_buckets) |*bucket| {
bucket.deinit(child_allocator);
}
}
/// Allocates a slice of memory of the given size (which must be no more
/// than this heap's block size) from this heap; returns `OutOfMemory` if
/// all superblocks in the heap are totally full and we fail to allocate a
/// new superblock from the child allocator.
fn alloc(self: *this, size: usize,
child_allocator: *Allocator) Allocator.Error![]u8 {
assert(size <= self.block_size);
// Check each bucket from most to least full (skipping bucket #0, since
// that's the totally-full superblocks).
assert(if (self.emptyness_buckets[0].head()) |superblock|
superblock.isFull() else true);
for (self.emptyness_buckets[1..]) |*bucket, i| {
const old_index = i + 1;
if (bucket.head()) |superblock| {
return try self.allocFrom(superblock, old_index, size);
}
}
// All superblocks are full, so allocate a new one.
const superblock =
try Superblock.init(self.block_size, self, child_allocator);
assert(superblock.emptynessBucketIndex() ==
params.totally_empty_bucket_index);
superblock.transferTo(
&self.emptyness_buckets[params.totally_empty_bucket_index]);
return try self.allocFrom(
superblock, params.totally_empty_bucket_index, size);
}
/// Allocates a slice of memory from the given superblock within this heap.
/// `old_index` must be the superblock's current emptyness bucket index.
fn allocFrom(self: *this, superblock: *Superblock,
old_index: usize, size: usize) Allocator.Error![]u8 {
assert(superblock.header.heap == self);
const mem = try superblock.alloc(size);
const new_index = superblock.emptynessBucketIndex();
if (new_index != old_index) {
superblock.transferTo(&self.emptyness_buckets[new_index]);
}
return mem;
}
/// Frees a slice of memory from the given superblock within this heap.
fn freeFrom(self: *this, superblock: *Superblock,
old_mem: []u8) void {
assert(superblock.header.heap == self);
assert(superblock.header.block_size == self.block_size);
superblock.free(old_mem);
const index = superblock.emptynessBucketIndex();
if (index == params.totally_empty_bucket_index) {
// TODO: Under certain conditions, free the now-totally-empty
// superblock back to the child allocator here.
}
// Move the superblock to its new emptyness bucket (or to the front of
// its same emptyness bucket).
superblock.transferTo(&self.emptyness_buckets[index]);
}
};
//===========================================================================//
/// A single-threaded (that is, non-thread-safe) allocator.
pub const ZiegfriedAllocator = struct {
const Heap = STHeap;
pub allocator: Allocator,
child_allocator: *Allocator,
heaps: []Heap,
pub fn init(child_allocator: *Allocator) !ZiegfriedAllocator {
const num_heaps = num_block_sizes;
var heaps = try child_allocator.alloc(Heap, num_heaps);
var block_size: u32 = params.min_block_size;
for (heaps) |*heap| {
heap.init(block_size);
block_size <<= 1;
}
return ZiegfriedAllocator{
.allocator = Allocator{
.allocFn = alloc,
.reallocFn = realloc,
.freeFn = free,
},
.child_allocator = child_allocator,
.heaps = heaps,
};
}
pub fn deinit(self: *ZiegfriedAllocator) void {
for (self.heaps) |*heap| {
heap.deinit(self.child_allocator);
}
self.child_allocator.free(self.heaps);
}
fn alloc(allocator: *Allocator, size: usize, alignment: u29) ![]u8 {
assert(alignment <= size);
const self = @fieldParentPtr(ZiegfriedAllocator, "allocator",
allocator);
if (size > params.max_block_size) {
return try self.child_allocator.allocFn(self.child_allocator, size,
alignment);
}
const heap = &self.heaps[blockSizeIndex(size)];
return try heap.alloc(size, self.child_allocator);
}
fn realloc(allocator: *Allocator, old_mem: []u8, new_size: usize,
alignment: u29) ![]u8 {
assert(alignment <= new_size);
const self = @fieldParentPtr(ZiegfriedAllocator, "allocator",
allocator);
const old_size = old_mem.len;
if (self.superblockForAlloc(old_mem)) |superblock| {
assert(old_size <= superblock.header.block_size);
const old_heap = superblock.header.heap;
assert(old_heap.block_size == superblock.header.block_size);
if (new_size > params.max_block_size) {
// The new size is large enough that it must be handled by the
// child allocator.
assert(new_size > old_size);
var new_mem = try self.child_allocator.allocFn(
self.child_allocator, new_size, alignment);
std.mem.copy(u8, new_mem, old_mem);
old_heap.freeFrom(superblock, old_mem);
return new_mem;
} else {
const new_heap = &self.heaps[blockSizeIndex(new_size)];
assert(new_size <= new_heap.block_size);
if (new_heap == old_heap) {
// We don't need to be in a different superblock, so we can
// just use the same block we're using now.
assert(new_size <= superblock.header.block_size);
return old_mem.ptr[0..new_size];
} else if (new_heap.block_size > old_heap.block_size) {
// We need a larger block size.
assert(new_size > superblock.header.block_size);
assert(new_size > old_size);
var new_mem =
try new_heap.alloc(new_size, self.child_allocator);
std.mem.copy(u8, new_mem, old_mem);
old_heap.freeFrom(superblock, old_mem);
return new_mem;
} else {
// The new size will fit in a smaller block size. Try to
// allocate a smaller block, but if that fails, we can just
// reuse the old block.
assert(new_heap.block_size < old_heap.block_size);
assert(new_size < old_size);
var new_mem =
new_heap.alloc(new_size, self.child_allocator) catch
return old_mem.ptr[0..new_size];
std.mem.copy(u8, new_mem, old_mem[0..new_size]);
old_heap.freeFrom(superblock, old_mem);
return new_mem;
}
}
} else {
// If we're here, that means the old memory belongs to the child
// allocator. Typically this implies that old_size >
// params.max_block_size, but it's possible that old_size is
// actually very small, if we previously realloced a large
// allocation to a smaller size and failed to allocate a new
// superblock at that time.
if (new_size > params.max_block_size) {
// The new size also needs to be handled directly by the child
// allocator, so we can just let the child allocator handle the
// whole realloc.
return try self.child_allocator.reallocFn(
self.child_allocator, old_mem, new_size, alignment);
} else {
// The new size is small enough that we should allocate it from
// a superblock. However, if that fails, we can fall back to
// asking the child allocator to do the realloc. This allows
// us to obey the requirement that a realloc to a smaller size
// must succeed.
const heap = &self.heaps[blockSizeIndex(new_size)];
var new_mem = heap.alloc(new_size, self.child_allocator)
catch return try self.child_allocator.reallocFn(
self.child_allocator, old_mem, new_size, alignment);
std.mem.copy(u8, new_mem, old_mem[0..new_size]);
self.child_allocator.freeFn(self.child_allocator, old_mem);
return new_mem;
}
}
}
fn free(allocator: *Allocator, old_mem: []u8) void {
const self = @fieldParentPtr(ZiegfriedAllocator, "allocator",
allocator);
if (self.superblockForAlloc(old_mem)) |superblock| {
superblock.header.heap.freeFrom(superblock, old_mem);
} else {
self.child_allocator.freeFn(self.child_allocator, old_mem);
}
}
fn blockSizeIndex(size: usize) usize {
const virtual_size = std.math.max(size, params.min_block_size);
const block_size_exponent =
std.math.log2_int_ceil(usize, virtual_size);
assert(block_size_exponent >=
std.math.log2_int_ceil(usize, params.min_block_size));
assert(block_size_exponent <=
std.math.log2_int_ceil(usize, params.max_block_size));
return block_size_exponent -
std.math.log2_int_ceil(usize, params.min_block_size);
}
fn superblockForAlloc(self: *this, old_mem: []u8) ?*Superblock {
if (old_mem.len > params.max_block_size) {
// This memory slice is too large to fit in any block, so it must
// belong to the child allocator.
return null;
}
const ptrOriginal = @ptrToInt(old_mem.ptr);
const ptrMasked = ptrOriginal & params.superblock_ptr_mask;
if (ptrMasked == ptrOriginal) {
// Blocks are never aligned to the size of a superblock, so this
// must belong to the child allocator (e.g. it may be a large
// allocation made directly from a DirectAllocator).
return null;
}
const superblock: *Superblock = @intToPtr(*Superblock, ptrMasked);
if (superblock.header.magic_number != params.superblock_magic_number) {
// This memory isn't within a Superblock struct, so it must belong
// to the child allocator.
return null;
}
// The superblock's magic number is correct, but there's still a chance
// that that's a coincidence, so as a final check, make sure the
// superblock's heap pointer actually points to one of our heaps.
const heapPtr = @ptrToInt(superblock.header.heap);
if (heapPtr < @ptrToInt(&self.heaps[0]) or
heapPtr > @ptrToInt(&self.heaps[self.heaps.len - 1])) {
return null;
}
// At this point, it is extremely unlikely that this is not one of our
// superblocks.
return superblock;
}
};
//===========================================================================//
fn assertMsg(condition: bool, comptime format: []const u8, args: ...) void {
if (!condition) {
std.debug.panic(format, args);
}
}
//===========================================================================//
test "createOne(i32)" {
var buffer: [1 << 16]u8 = undefined;
var buffer_allocator = std.heap.FixedBufferAllocator.init(buffer[0..]);
var ziegfried = try ZiegfriedAllocator.init(&buffer_allocator.allocator);
defer ziegfried.deinit();
var ptr = try ziegfried.allocator.createOne(i32);
ptr.* = 12345;
ziegfried.allocator.destroy(ptr);
}
test "huge allocation, out of memory" {
var buffer: [1 << 16]u8 = undefined;
var buffer_allocator = std.heap.FixedBufferAllocator.init(buffer[0..]);
var ziegfried = try ZiegfriedAllocator.init(&buffer_allocator.allocator);
defer ziegfried.deinit();
assertError(ziegfried.allocator.alignedAlloc(u8, 1, 1 << 20),
Allocator.Error.OutOfMemory);
}
test "allocate a bunch of small objects" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var slice = try ziegfried.allocator.alloc(*i32, 50);
defer ziegfried.allocator.free(slice);
assert(slice.len == 50);
for (slice) |*item, i| {
item.* = try ziegfried.allocator.create(@intCast(i32, i));
}
for (slice) |item, i| {
assert(item.* == @intCast(i32, i));
ziegfried.allocator.destroy(item);
}
}
test "allocate many differently-sized objects" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var prng = std.rand.DefaultPrng.init(12345);
var slice = try ziegfried.allocator.alloc([]u8, 10000);
defer ziegfried.allocator.free(slice);
for (slice) |*item| {
const size = prng.random.range(u8, 1, 250);
item.* = try ziegfried.allocator.alloc(u8, size);
assert(item.len == size);
for (item.*) |*byte| byte.* = size;
}
prng.random.shuffle([]u8, slice);
for (slice) |item| {
assert(item.len <= 250);
const size = @intCast(u8, item.len);
for (item) |byte| assert(byte == size);
ziegfried.allocator.free(item);
}
}
test "realloc from huge to huge" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var old_slice = try ziegfried.allocator.alloc(u8, 15000);
assertMsg(old_slice.len == 15000, "old_slice.len = {}", old_slice.len);
for (old_slice) |*value, i| value.* = @intCast(u8, i % 256);
var new_slice = try ziegfried.allocator.realloc(u8, old_slice, 10000);
assertMsg(new_slice.len == 10000, "new_slice.len = {}", old_slice.len);
for (new_slice) |value, i| assert(value == i % 256);
ziegfried.allocator.free(new_slice);
}
test "realloc from huge to small" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var old_slice = try ziegfried.allocator.alloc(u8, 10000);
assertMsg(old_slice.len == 10000, "old_slice.len = {}", old_slice.len);
for (old_slice) |*value, i| value.* = @intCast(u8, i % 256);
var new_slice = try ziegfried.allocator.realloc(u8, old_slice, 50);
assertMsg(new_slice.len == 50, "new_slice.len = {}", old_slice.len);
assert(new_slice.ptr != old_slice.ptr);
for (new_slice) |value, i| assert(value == i);
ziegfried.allocator.free(new_slice);
}
test "realloc from small to huge" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var old_slice = try ziegfried.allocator.alloc(u8, 50);
assertMsg(old_slice.len == 50, "old_slice.len = {}", old_slice.len);
for (old_slice) |*value, i| value.* = @intCast(u8, i);
var new_slice = try ziegfried.allocator.realloc(u8, old_slice, 10000);
assertMsg(new_slice.len == 10000, "new_slice.len = {}", old_slice.len);
assert(new_slice.ptr != old_slice.ptr);
for (new_slice[0..50]) |value, i| assert(value == i);
ziegfried.allocator.free(new_slice);
}
test "realloc smaller within same block size" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var old_slice = try ziegfried.allocator.alloc(usize, 7);
assertMsg(old_slice.len == 7, "old_slice.len = {}", old_slice.len);
for (old_slice) |*value, i| value.* = i;
var new_slice = try ziegfried.allocator.realloc(usize, old_slice, 5);
assertMsg(new_slice.len == 5, "new_slice.len = {}", old_slice.len);
assertMsg(new_slice.ptr == old_slice.ptr, "old ptr = {}, new ptr = {}",
old_slice.ptr, new_slice.ptr);
for (new_slice) |value, i| assert(value == i);
ziegfried.allocator.free(new_slice);
}
test "realloc bigger within same block size" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var old_slice = try ziegfried.allocator.alloc(usize, 5);
assertMsg(old_slice.len == 5, "old_slice.len = {}", old_slice.len);
for (old_slice) |*value, i| value.* = i;
var new_slice = try ziegfried.allocator.realloc(usize, old_slice, 7);
assertMsg(new_slice.len == 7, "new_slice.len = {}", old_slice.len);
assertMsg(new_slice.ptr == old_slice.ptr, "old ptr = {}, new ptr = {}",
old_slice.ptr, new_slice.ptr);
for (new_slice[0..5]) |value, i| assert(value == i);
ziegfried.allocator.free(new_slice);
}
test "realloc small to big block size" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var old_slice = try ziegfried.allocator.alloc(u8, 30);
assertMsg(old_slice.len == 30, "old_slice.len = {}", old_slice.len);
for (old_slice) |*value, i| value.* = @intCast(u8, i);
var new_slice = try ziegfried.allocator.realloc(u8, old_slice, 100);
assertMsg(new_slice.len == 100, "new_slice.len = {}", old_slice.len);
assert(new_slice.ptr != old_slice.ptr);
for (new_slice[0..30]) |value, i| assert(value == i);
ziegfried.allocator.free(new_slice);
}
test "realloc big to small block size" {
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var ziegfried = try ZiegfriedAllocator.init(&direct.allocator);
defer ziegfried.deinit();
var old_slice = try ziegfried.allocator.alloc(u8, 100);
assertMsg(old_slice.len == 100, "old_slice.len = {}", old_slice.len);
for (old_slice) |*value, i| value.* = @intCast(u8, i);
var new_slice = try ziegfried.allocator.realloc(u8, old_slice, 30);
assertMsg(new_slice.len == 30, "new_slice.len = {}", old_slice.len);
assert(new_slice.ptr != old_slice.ptr);
for (new_slice) |value, i| assert(value == i);
ziegfried.allocator.free(new_slice);
}
test "realloc big to small block size with OOM" {
// Make the child allocator have just enough memory for the heap array and
// one superblock.
var direct = std.heap.DirectAllocator.init();
defer direct.deinit();
var buffer = try direct.allocator.alignedAlloc(
u8, params.superblock_size, 2 * params.superblock_size);
defer direct.allocator.free(buffer);
var buffer_allocator = std.heap.FixedBufferAllocator.init(buffer[0..]);
var ziegfried = try ZiegfriedAllocator.init(&buffer_allocator.allocator);
defer ziegfried.deinit();
// Allocate a block, which will create a new superblock.
var old_slice = try ziegfried.allocator.alloc(u8, 100);
assertMsg(old_slice.len == 100, "old_slice.len = {}", old_slice.len);
for (old_slice) |*value, i| value.* = @intCast(u8, i);
// Verify that we cannot create a new smaller block (because the child
// allocator doesn't have room for another superblock).
assertError(ziegfried.allocator.alloc(u8, 30),
Allocator.Error.OutOfMemory);
// Now reallac the first block to a smaller block size. Since we can't
// create a new superblock, as a fallback it should just give us back the
// same block, trimmed to the smaller size.
var new_slice = try ziegfried.allocator.realloc(u8, old_slice, 30);
assertMsg(new_slice.len == 30, "new_slice.len = {}", old_slice.len);
assert(new_slice.ptr == old_slice.ptr);
ziegfried.allocator.free(new_slice);
}
test "realloc from huge to small with OOM" {
// Make the child allocator have just enough memory for the heap array and
// one huge allocation.
var buffer: [2 * params.superblock_size]u8 = undefined;
var buffer_allocator = std.heap.FixedBufferAllocator.init(buffer[0..]);
var ziegfried = try ZiegfriedAllocator.init(&buffer_allocator.allocator);
defer ziegfried.deinit();
// Allocate a huge block, which will come from the child allocator.
var old_slice = try ziegfried.allocator.alloc(u8, params.superblock_size);
assert(old_slice.len == params.superblock_size);
// Verify that we cannot create a new smaller block (because the child
// allocator doesn't have room for another superblock).
assertError(ziegfried.allocator.alloc(u8, 30),
Allocator.Error.OutOfMemory);
// Now reallac the first block to a smaller block size. Since we can't
// create a new superblock, as a fallback it should ask the child allocator
// to handle the realloc.
var new_slice = try ziegfried.allocator.realloc(u8, old_slice, 30);
assertMsg(new_slice.len == 30, "new_slice.len = {}", old_slice.len);
assert(new_slice.ptr == old_slice.ptr);
// Finally, free the block. Even though the block is now small enough that
// it could be part of a superblock, we should correctly deduce that it
// isn't, and ask the child allocator to free it.
ziegfried.allocator.free(new_slice);
}
//===========================================================================//
|
src/ziegfried/index.zig
|
const std = @import("std");
const Value = @import("value.zig").Value;
const Type = @import("type.zig").Type;
const Module = @import("Module.zig");
/// These are in-memory, analyzed instructions. See `zir.Inst` for the representation
/// of instructions that correspond to the ZIR text format.
/// This struct owns the `Value` and `Type` memory. When the struct is deallocated,
/// so are the `Value` and `Type`. The value of a constant must be copied into
/// a memory location for the value to survive after a const instruction.
pub const Inst = struct {
tag: Tag,
ty: Type,
/// Byte offset into the source.
src: usize,
pub const Tag = enum {
assembly,
bitcast,
breakpoint,
call,
cmp,
condbr,
constant,
isnonnull,
isnull,
ptrtoint,
ret,
unreach,
};
pub fn cast(base: *Inst, comptime T: type) ?*T {
if (base.tag != T.base_tag)
return null;
return @fieldParentPtr(T, "base", base);
}
pub fn Args(comptime T: type) type {
return std.meta.fieldInfo(T, "args").field_type;
}
/// Returns `null` if runtime-known.
pub fn value(base: *Inst) ?Value {
if (base.ty.onePossibleValue())
return Value.initTag(.the_one_possible_value);
const inst = base.cast(Constant) orelse return null;
return inst.val;
}
pub const Assembly = struct {
pub const base_tag = Tag.assembly;
base: Inst,
args: struct {
asm_source: []const u8,
is_volatile: bool,
output: ?[]const u8,
inputs: []const []const u8,
clobbers: []const []const u8,
args: []const *Inst,
},
};
pub const BitCast = struct {
pub const base_tag = Tag.bitcast;
base: Inst,
args: struct {
operand: *Inst,
},
};
pub const Breakpoint = struct {
pub const base_tag = Tag.breakpoint;
base: Inst,
args: void,
};
pub const Call = struct {
pub const base_tag = Tag.call;
base: Inst,
args: struct {
func: *Inst,
args: []const *Inst,
},
};
pub const Cmp = struct {
pub const base_tag = Tag.cmp;
base: Inst,
args: struct {
lhs: *Inst,
op: std.math.CompareOperator,
rhs: *Inst,
},
};
pub const CondBr = struct {
pub const base_tag = Tag.condbr;
base: Inst,
args: struct {
condition: *Inst,
true_body: Module.Body,
false_body: Module.Body,
},
};
pub const Constant = struct {
pub const base_tag = Tag.constant;
base: Inst,
val: Value,
};
pub const IsNonNull = struct {
pub const base_tag = Tag.isnonnull;
base: Inst,
args: struct {
operand: *Inst,
},
};
pub const IsNull = struct {
pub const base_tag = Tag.isnull;
base: Inst,
args: struct {
operand: *Inst,
},
};
pub const PtrToInt = struct {
pub const base_tag = Tag.ptrtoint;
base: Inst,
args: struct {
ptr: *Inst,
},
};
pub const Ret = struct {
pub const base_tag = Tag.ret;
base: Inst,
args: void,
};
pub const Unreach = struct {
pub const base_tag = Tag.unreach;
base: Inst,
args: void,
};
};
|
src-self-hosted/ir.zig
|
const std = @import("std");
const font = @import("font.zig");
const arch = @import("../arch.zig");
const hw = @import("../hw.zig");
const paging = @import("../paging.zig");
pub const CONSOLE_DIMENSION = u16;
var fb: ?[*]u32 = null;
var fb_vert: u32 = undefined;
var fb_horiz: u32 = undefined;
pub var console_height: CONSOLE_DIMENSION = undefined;
pub var console_width: CONSOLE_DIMENSION = undefined;
// These are only used in calculating the size of console_buf we should allocate.
// Feel free to increase for a larger HDMI screen.
const MAX_CONSOLE_WIDTH = 1024;
const MAX_CONSOLE_HEIGHT = 600;
var console_buf: [(MAX_CONSOLE_WIDTH / font.FONT_WIDTH) * (MAX_CONSOLE_HEIGHT / font.FONT_HEIGHT)]u16 = undefined;
var console_col: CONSOLE_DIMENSION = 0;
var console_row: CONSOLE_DIMENSION = 0;
var console_colour: u8 = 0x07;
pub fn init(in_fb: [*]u32, in_vert: u32, in_horiz: u32) void {
fb = mapFb(in_fb, in_vert * in_horiz);
fb_vert = in_vert;
fb_horiz = in_horiz;
console_height = @truncate(CONSOLE_DIMENSION, fb_vert / font.FONT_HEIGHT);
console_width = @truncate(CONSOLE_DIMENSION, fb_horiz / font.FONT_WIDTH);
if (console_height * console_width > console_buf.len) {
@panic("can't fit console");
}
std.mem.set(u16, console_buf[0 .. console_width * console_height], 0);
std.mem.set(u32, fb.?[0 .. fb_horiz * fb_vert], 0);
arch.sleep(500);
drawEnergyStar(false);
arch.sleep(50);
drawEnergyStar(true);
arch.sleep(50);
drawEnergyStar(false);
}
fn mapFb(base: [*]u32, pixels: usize) [*]u32 {
var page_count = (pixels * 4 + paging.PAGING.page_size - 1) / paging.PAGING.page_size;
var virt = paging.mapPagesConsecutive(@ptrToInt(base), page_count, .peripheral) catch @panic("oom");
hw.entry_uart.carefully(.{ "MAP: FB at ", virt, "~\r\n" });
return @intToPtr([*]u32, virt);
}
pub fn present() callconv(.Inline) bool {
return fb != null;
}
pub fn panicMessage(msg: []const u8) void {
const msg_len: CONSOLE_DIMENSION = @truncate(CONSOLE_DIMENSION, "kernel panic: ".len + msg.len);
const left: CONSOLE_DIMENSION = console_width - msg_len - 2;
colour(0x4f);
locate(0, left);
var x: CONSOLE_DIMENSION = 0;
while (x < msg_len + 2) : (x += 1) {
print(" ");
}
locate(1, left);
printf(" kernel panic: {s} ", .{msg});
locate(2, left);
x = 0;
while (x < msg_len + 2) : (x += 1) {
print(" ");
}
}
fn drawEnergyStar(comptime allWhite: bool) void {
const WIDTH = 138;
const HEIGHT = 103;
const DATA = @embedFile("../assets/energystar.vga");
const left = fb_horiz - WIDTH;
var y: u32 = 0;
while (y < HEIGHT) : (y += 1) {
var x: u32 = 0;
while (x < WIDTH) : (x += 1) {
var s = DATA[(WIDTH * y + x) * 3 .. (WIDTH * y + x + 1) * 3];
const c = (@as(u32, s[0]) << 16) | (@as(u32, s[1]) << 8) | @as(u32, s[2]);
if (allWhite) {
plot(left + x, y, if (c != 0) 0xffffff else 0);
} else {
plot(left + x, y, c);
}
}
}
}
pub fn plot(x: u32, y: u32, c: u32) callconv(.Inline) void {
fb.?[fb_horiz * y + x] = c;
}
pub fn colour(bgfg: u8) callconv(.Inline) void {
console_colour = bgfg;
}
pub fn locate(row: CONSOLE_DIMENSION, col: CONSOLE_DIMENSION) callconv(.Inline) void {
console_row = row;
console_col = col;
}
pub fn print(msg: []const u8) void {
var state: enum { NORMAL, ESCAPE } = .NORMAL;
loop: for (msg) |c, i| {
switch (state) {
.NORMAL => {
switch (c) {
'\x1b' => {
state = .ESCAPE;
continue :loop;
},
'\n' => {
if (fb != null) {
console_col = 0;
console_row += 1;
}
hw.uart.write("\r\n") catch {};
},
'\x08' => {
hw.uart.write("\x08") catch {};
if (console_col > 0) {
console_col -= 1;
} else if (console_row > 0) {
console_row -= 1;
console_col = console_width - 1;
}
},
else => {
hw.uart.write(&[_]u8{c}) catch {};
if (fb != null) {
font.putChar(console_row, console_col, c, console_colour);
console_buf[console_row * console_width + console_col] = (@as(u16, console_colour) << 8) | c;
console_col += 1;
}
},
}
if (fb != null) {
if (console_col >= console_width) {
console_row += 1;
console_col = 0;
}
if (console_row >= console_height) {
scroll();
console_row -= 1;
}
}
},
.ESCAPE => {
colour(c);
state = .NORMAL;
},
}
}
}
fn scroll() void {
var row: CONSOLE_DIMENSION = 0;
while (row < console_height - 1) : (row += 1) {
std.mem.copy(u16, console_buf[row * console_width .. (row + 1) * console_width], console_buf[(row + 1) * console_width .. (row + 2) * console_width]);
}
std.mem.set(u16, console_buf[(console_height - 1) * console_width .. console_height * console_width], 0);
refresh();
}
fn refresh() void {
if (fb == null) {
return;
}
var row: CONSOLE_DIMENSION = 0;
while (row < console_height) : (row += 1) {
var col: CONSOLE_DIMENSION = 0;
while (col < console_width) : (col += 1) {
const pair = console_buf[row * console_width + col];
font.putChar(row, col, @truncate(u8, pair), @truncate(u8, pair >> 8));
}
}
}
var printf_buf: [1024]u8 = undefined;
pub fn printf(comptime format: []const u8, args: anytype) void {
const slice = std.fmt.bufPrint(printf_buf[0..], format, args) catch @panic("bufPrint failure");
print(slice);
}
pub fn placechar(c: u8) void {
if (fb != null) {
font.putChar(console_row, console_col, c, console_colour);
}
console_buf[console_row * console_width + console_col] = (@as(u16, console_colour) << 8) | c;
}
pub fn putchar(c: u8) void {
placechar(c);
console_col += 1;
if (console_col >= console_width) {
console_row += 1;
console_col = 0;
}
if (console_row >= console_height) {
scroll();
console_row -= 1;
}
}
|
dainkrnl/src/console/fb.zig
|
const std = @import("std");
const print = std.debug.print;
const data = @embedFile("../data/day06.txt");
pub fn main() !void {
var timer = try std.time.Timer.start();
var lanternfishes = [_]u64{0} ** 9;
var iterator = std.mem.tokenize(data, ", \r\n");
while (iterator.next()) |lanternfish| {
lanternfishes[try std.fmt.parseInt(u8, lanternfish, 10)] += 1;
}
{
var day : usize = 0;
const days = 80;
while (day < days) : (day += 1) {
var zero_day_lanternfish = lanternfishes[0];
var index : usize = 1;
while (index < lanternfishes.len) : (index += 1) {
lanternfishes[index - 1] = lanternfishes[index];
}
// When a lanternfish reaches 0, we make it relive in slot 6, but it also
// spawns a new fish in slot 8.
lanternfishes[6] += zero_day_lanternfish;
lanternfishes[8] = zero_day_lanternfish;
}
}
{
var total : u64 = 0;
var index : usize = 0;
while (index < lanternfishes.len) : (index += 1) {
total += lanternfishes[index];
}
print("🎁 Lanternfish after 80 days: {}\n", .{total});
print("Day 06 - part 01 took {:15}ns\n", .{timer.lap()});
timer.reset();
}
{
var day : usize = 80;
const days = 256;
while (day < days) : (day += 1) {
var zero_day_lanternfish = lanternfishes[0];
var index : usize = 1;
while (index < lanternfishes.len) : (index += 1) {
lanternfishes[index - 1] = lanternfishes[index];
}
// When a lanternfish reaches 0, we make it relive in slot 6, but it also
// spawns a new fish in slot 8.
lanternfishes[6] += zero_day_lanternfish;
lanternfishes[8] = zero_day_lanternfish;
}
}
{
var total : u64 = 0;
var index : usize = 0;
while (index < lanternfishes.len) : (index += 1) {
total += lanternfishes[index];
}
print("🎁 Lanternfish after 256 days: {}\n", .{total});
print("Day 06 - part 02 took {:15}ns\n", .{timer.lap()});
print("❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️\n", .{});
}
}
|
src/day06.zig
|
const std = @import("std");
const alka = @import("alka");
const m = alka.math;
usingnamespace alka.log;
pub const mlog = std.log.scoped(.app);
pub const log_level: std.log.Level = .debug;
const RectangleStore = alka.ecs.StoreComponent("Rectangle", m.Rectangle, maxent);
const SpeedStore = alka.ecs.StoreComponent("Speed", f32, maxent);
const VelocityStore = alka.ecs.StoreComponent("Velocity", m.Vec2f, maxent);
const ColourStore = alka.ecs.StoreComponent("Colour", alka.Colour, maxent);
const World = alka.ecs.World(struct { r: RectangleStore, col: ColourStore, sp: SpeedStore, vl: VelocityStore });
const maxent: u64 = 1024 * 100;
var random: *std.rand.Random = undefined;
var world: World = undefined;
var mouseleftPtr: *const alka.input.State = undefined;
var index: u64 = 0;
fn createEntity(i: u64) !void {
var reg = try world.createRegister(i);
try reg.create();
try reg.attach("Rectangle", m.Rectangle{
.position = alka.getMousePosition(),
.size = m.Vec2f{
.x = @intToFloat(f32, random.intRangeAtMost(i32, 10, 50)),
.y = @intToFloat(f32, random.intRangeAtMost(i32, 10, 50)),
},
});
const speed: f32 = 200 * @intToFloat(f32, random.intRangeAtMost(i32, -1, 1));
try reg.attach("Speed", speed);
try reg.attach("Velocity", m.Vec2f{});
try reg.attach("Colour", alka.Colour.rgba(random.intRangeAtMost(u8, 0, 200), random.intRangeAtMost(u8, 0, 200), random.intRangeAtMost(u8, 0, 200), 255));
//mlog.info("created {}", .{i});
}
fn update(dt: f32) !void {
if (mouseleftPtr.* == alka.input.State.down) {
if (index < maxent) {
var i: u64 = index;
while (i < index + 10) : (i += 1) {
try createEntity(i);
}
index = i;
}
}
const comps = [_][]const u8{ "Velocity", "Speed", "Rectangle" };
var it = World.iterator(comps.len, comps){ .world = &world };
while (it.next()) |entry| {
if (entry.value) |entity| {
var vel = try entity.getPtr("Velocity", m.Vec2f);
var speed = try entity.getPtr("Speed", f32);
const rect = try entity.get("Rectangle", m.Rectangle);
if (rect.position.x > 1024 - rect.size.x) {
speed.* = -speed.*;
} else if (rect.position.x < 0) {
speed.* = m.abs(speed.*);
}
vel.x += speed.* * dt;
}
}
}
fn fupdate(dt: f32) !void {
const comps = [_][]const u8{ "Velocity", "Rectangle" };
var it = World.iterator(comps.len, comps){ .world = &world };
while (it.next()) |entry| {
if (entry.value) |entity| {
var rect = try entity.getPtr("Rectangle", m.Rectangle);
var vel = try entity.getPtr("Velocity", m.Vec2f);
rect.position.x += vel.x;
vel.* = m.Vec2f{};
}
}
}
fn draw() !void {
const comps = [_][]const u8{ "Rectangle", "Colour" };
var it = World.iterator(comps.len, comps){ .world = &world };
while (it.next()) |entry| {
if (entry.value) |entity| {
const rect = try entity.get("Rectangle", m.Rectangle);
const colour = try entity.get("Colour", alka.Colour);
try alka.drawRectangle(rect, colour);
}
}
const asset = alka.getAssetManager();
const font = try asset.getFont(0);
const col = alka.Colour.rgba(200, 30, 70, 255);
var debug = try alka.getDebug();
defer alka.getAllocator().free(debug);
try alka.drawText(0, debug, m.Vec2f{ .x = 20, .y = 20 }, 24, col);
mlog.info("{s}", .{debug});
debug = try std.fmt.bufPrint(debug, "total: {}", .{index});
try alka.drawText(0, debug, m.Vec2f{ .x = 20, .y = 45 }, 24, col);
mlog.info("{s}", .{debug});
}
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{
.enable_memory_limit = false,
}){};
//gpa.setRequestedMemoryLimit(1048 * 1000 * 5);
const callbacks = alka.Callbacks{
.update = update,
.fixed = fupdate,
.draw = draw,
};
try alka.init(&gpa.allocator, callbacks, 1024, 768, "ECS Benchmark", 1000, false);
var prng = std.rand.DefaultPrng.init(blk: {
var seed: u64 = undefined;
try std.os.getrandom(std.mem.asBytes(&seed));
break :blk seed;
});
random = &prng.random;
var input = alka.getInput();
try input.bindMouse(alka.input.Mouse.ButtonLeft);
mouseleftPtr = try input.mouseStatePtr(alka.input.Mouse.ButtonLeft);
try alka.getAssetManager().loadFont(0, "assets/arial.ttf", 128);
const font = try alka.getAssetManager().getFont(0);
font.texture.setFilter(alka.gl.TextureParamater.filter_mipmap_nearest, alka.gl.TextureParamater.filter_linear);
world = try World.init(&gpa.allocator);
try alka.open();
try alka.update();
try alka.close();
world.deinit();
try alka.deinit();
const leaked = gpa.deinit();
if (leaked) return error.Leak;
}
|
examples/ecs_benchmark.zig
|
const std = @import("std");
const String = @This();
const mem = std.mem;
const Allocator = mem.Allocator;
const bog = @import("bog.zig");
const Vm = bog.Vm;
const Value = bog.Value;
const Type = bog.Type;
const default_dump_depth = 4;
/// Memory used by the string contents.
data: []const u8,
/// If 0 memory is a constant reference
capacity: usize = 0,
pub const Builder = struct {
inner: std.ArrayList(u8),
pub fn finish(b: Builder) String {
return .{
.data = b.inner.items,
.capacity = b.inner.capacity,
};
}
pub fn cancel(b: *Builder) void {
b.inner.deinit();
b.* = undefined;
}
pub fn append(b: *Builder, data: []const u8) !void {
try b.inner.appendSlice(data);
}
pub const Writer = std.io.Writer(*Builder, error{OutOfMemory}, appendWrite);
/// Initializes a Writer which will append to the builder.
pub fn writer(self: *Builder) Writer {
return .{ .context = self };
}
/// Same as `append` except it returns the number of bytes written, which is always the same
/// as `m.len`. The purpose of this function existing is to match `std.io.Writer` API.
fn appendWrite(self: *Builder, data: []const u8) !usize {
try self.append(data);
return data.len;
}
};
pub fn builder(allocator: Allocator) Builder {
return Builder{
.inner = std.ArrayList(u8).init(allocator),
};
}
pub fn init(allocator: Allocator, comptime fmt: []const u8, args: anytype) !String {
var b = builder(allocator);
errdefer b.cancel();
try b.writer().print(fmt, args);
return b.finish();
}
pub fn deinit(str: *String, allocator: Allocator) void {
if (str.capacity != 0) {
allocator.free(str.data);
}
str.* = undefined;
}
pub fn eql(a: String, b: String) bool {
return mem.eql(u8, a.data, b.data);
}
pub fn dump(str: String, writer: anytype) !void {
try writer.print("\"{}\"", .{std.zig.fmtEscapes(str.data)});
}
pub fn get(str: *const String, vm: *Vm, index: *const Value, res: *?*Value) Vm.Error!void {
switch (index.*) {
.int => return vm.fatal("TODO get str"),
.range => return vm.fatal("TODO get with ranges"),
.str => |*s| {
if (res.* == null) {
res.* = try vm.gc.alloc();
}
if (mem.eql(u8, s.data, "len")) {
res.*.?.* = .{ .int = @intCast(i64, str.data.len) };
} else if (mem.eql(u8, s.data, "append")) {
res.* = try Value.zigToBog(vm, struct {
fn append(_vm: *Vm, val: String) !void {
if (_vm.last_get.* != .str)
return _vm.fatal("expected string");
try _vm.last_get.str.append(_vm.gc.gpa, val.data);
}
}.append);
} else if (mem.eql(u8, s.data, "format")) {
res.* = try Value.zigToBog(vm, struct {
fn format(_vm: *Vm, args: []const *Value) !*Value {
if (_vm.last_get.* != .str)
return _vm.fatal("expected string");
return _vm.last_get.str.format(_vm, args);
}
}.format);
} else if (mem.eql(u8, s.data, "join")) {
res.* = try Value.zigToBog(vm, struct {
fn join(_vm: *Vm, args: []const *Value) !*Value {
if (_vm.last_get.* != .str)
return _vm.fatal("expected string");
return _vm.last_get.str.join(_vm, args);
}
}.join);
} else {
return vm.fatal("no such property");
}
},
else => return vm.fatal("invalid index type"),
}
}
pub fn set(str: *String, vm: *Vm, index: *const Value, new_val: *const Value) Vm.Error!void {
_ = str;
_ = index;
_ = new_val;
return vm.fatal("TODO set string");
}
pub fn as(str: *String, vm: *Vm, type_id: Type) Vm.Error!*Value {
if (type_id == .none) {
return &Value.None;
} else if (type_id == .bool) {
if (mem.eql(u8, str.data, "true"))
return &Value.True
else if (mem.eql(u8, str.data, "false"))
return &Value.False
else
return vm.errorVal("cannot cast string to bool");
}
const new_val = try vm.gc.alloc();
new_val.* = switch (type_id) {
.int => .{
.int = @import("util.zig").parseInt(str.data) catch
return vm.errorVal("cannot cast string to int"),
},
.num => .{
.num = @import("util.zig").parseNum(str.data) catch
return vm.errorVal("cannot cast string to num"),
},
.bool => unreachable,
.str => unreachable, // already string
.tuple,
.map,
.list,
=> return vm.fatal("TODO more casts from string"),
else => unreachable,
};
return new_val;
}
pub fn from(val: *Value, vm: *Vm) Vm.Error!*Value {
const str = try vm.gc.alloc();
if (val.* == .none) {
str.* = Value.string("none");
} else if (val.* == .bool) {
str.* = if (val.bool)
Value.string("true")
else
Value.string("false");
} else {
var b = builder(vm.gc.gpa);
try val.dump(b.writer(), default_dump_depth);
str.* = .{ .str = b.finish() };
}
return str;
}
pub fn in(str: *const String, val: *const Value) bool {
if (val.* != .str) return false;
return mem.indexOf(u8, str.data, val.str.data) != null;
}
pub fn append(str: *String, allocator: Allocator, data: []const u8) !void {
var b = builder(allocator);
errdefer b.cancel();
try b.append(str.data);
try b.append(data);
str.deinit(allocator);
str.* = b.finish();
}
pub fn format(str: String, vm: *Vm, args: []const *Value) !*Value {
var b = builder(vm.gc.gpa);
errdefer b.cancel();
try b.inner.ensureTotalCapacity(str.data.len);
const w = b.writer();
var state: enum {
start,
brace,
format,
} = .start;
var arg_i: usize = 0;
var format_start: usize = 0;
var options = std.fmt.FormatOptions{};
var i: usize = 0;
while (i < str.data.len) : (i += 1) {
const c = str.data[i];
switch (state) {
.start => if (c == '{') {
state = .brace;
} else {
try w.writeByte(c);
},
.brace => if (c == '{') {
try w.writeByte(c);
} else {
if (arg_i >= args.len) {
return vm.errorVal("too few arguments");
}
format_start = i;
state = .format;
options = .{};
i -= 1;
},
.format => if (c == '}') {
const fmt = str.data[format_start..i];
var fmt_type: u8 = 0;
if (fmt.len == 1) {
fmt_type = fmt[0];
} else {
// TODO properly parse format options
}
switch (fmt_type) {
'x', 'X' => {
if (args[arg_i].* != .int) {
return vm.typeError(.int, args[arg_i].*);
}
try std.fmt.formatInt(args[arg_i].int, 16, @intToEnum(std.fmt.Case, @boolToInt(fmt[0] == 'X')), options, w);
},
0 => if (args[arg_i].* == .str) {
try b.append(args[arg_i].str.data);
} else {
try args[arg_i].dump(w, default_dump_depth);
},
else => {
return vm.errorVal("unknown format specifier");
},
}
state = .start;
arg_i += 1;
},
}
}
if (arg_i != args.len) {
return vm.errorVal("unused arguments");
}
const ret = try vm.gc.alloc();
ret.* = Value{ .str = b.finish() };
return ret;
}
pub fn join(str: String, vm: *Vm, args: []const *Value) !*Value {
var b = builder(vm.gc.gpa);
errdefer b.cancel();
try b.inner.ensureTotalCapacity(args.len * str.data.len);
for (args) |arg, i| {
if (i != 0) {
try b.append(str.data);
}
if (arg.* != .str) {
return vm.typeError(.str, arg.*);
}
try b.append(arg.str.data);
}
const ret = try vm.gc.alloc();
ret.* = Value{ .str = b.finish() };
return ret;
}
|
src/String.zig
|
const __floattitf = @import("floattitf.zig").__floattitf;
const testing = @import("std").testing;
fn test__floattitf(a: i128, expected: f128) !void {
const x = __floattitf(a);
try testing.expect(x == expected);
}
test "floattitf" {
try test__floattitf(0, 0.0);
try test__floattitf(1, 1.0);
try test__floattitf(2, 2.0);
try test__floattitf(20, 20.0);
try test__floattitf(-1, -1.0);
try test__floattitf(-2, -2.0);
try test__floattitf(-20, -20.0);
try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126);
try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
}
fn make_ti(high: u64, low: u64) i128 {
var result: u128 = high;
result <<= 64;
result |= low;
return @bitCast(i128, result);
}
|
lib/std/special/compiler_rt/floattitf_test.zig
|
const __truncsfhf2 = @import("truncXfYf2.zig").__truncsfhf2;
fn test__truncsfhf2(a: u32, expected: u16) void {
const actual = __truncsfhf2(@bitCast(f32, a));
if (actual == expected) {
return;
}
@panic("__truncsfhf2 test failure");
}
test "truncsfhf2" {
test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN
test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN
test__truncsfhf2(0, 0); // 0
test__truncsfhf2(0x80000000, 0x8000); // -0
test__truncsfhf2(0x7f800000, 0x7c00); // inf
test__truncsfhf2(0xff800000, 0xfc00); // -inf
test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf
test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf
test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf
test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf
test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14
test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14
test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504
test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504
test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504
test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504
test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504
test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504
test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10
test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10
test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3
test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3
test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535
test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535
test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12
test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1
test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14
test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24
test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24
test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2**-14 - 2**-24
test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2**-14 + 2**-24
test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20
test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24
test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
}
|
std/special/compiler_rt/truncXfYf2_test.zig
|
const std = @import("std");
const mem = std.mem;
const ascii = std.ascii;
const testing = std.testing;
pub const Version = struct {
epoch: isize,
major: isize,
minor: isize,
patch: isize,
// Some packages have MAJOR.MINOR.PATCH.EXTRA - just going to assume it stops there
extra: isize,
// I'm not even sure if this is a reliable pattern.
// Most packages seem to have a <revision>-<short-sha1> format
vcs_rev: isize,
release: isize,
const Self = @This();
pub fn init(version: []const u8) !Self {
// Epoch parsing, epoch is optional
var epoch_iter = mem.split(u8, version, ":");
const epoch_first_half = epoch_iter.next().?;
const epoch_second_half = epoch_iter.next();
const epochless_base = if (epoch_second_half == null) epoch_first_half else epoch_second_half;
const epoch = if (epoch_second_half == null) null else epoch_first_half;
// Release parsing, not optional
var release_iter = mem.split(u8, epochless_base.?, "-");
const releaseless_base = release_iter.next().?;
const release = release_iter.next().?;
// VCS version thingy
var vcs_iter = mem.split(u8, releaseless_base, "+");
const vcsless_base = vcs_iter.next().?;
var vcs_rev: ?isize = null;
while (vcs_iter.next()) |vcs| {
// Go through each "+" segment and use the first valid number that we see
vcs_rev = parseInt(vcs) catch {
continue;
};
if (vcs_rev != null) {
break;
}
}
// Semver-ish-thing, anything goes here really
var semver_iter = mem.split(u8, vcsless_base, ".");
const major = semver_iter.next().?;
const minor = semver_iter.next();
const patch = if (minor != null) semver_iter.next() else null;
const extra = if (patch != null) semver_iter.next() else null;
return Version{
.epoch = if (epoch != null) try parseInt(epoch.?) else 0,
.major = try parseInt(major),
.minor = if (minor != null) try parseInt(minor.?) else 0,
.patch = if (patch != null) try parseInt(patch.?) else 0,
.extra = if (extra != null) try parseInt(extra.?) else 0,
.vcs_rev = vcs_rev orelse 0,
.release = try parseInt(release),
};
}
pub fn olderThan(self: Self, new_version: Version) bool {
if (self.epoch < new_version.epoch) {
return true;
} else if (self.epoch > new_version.epoch) {
return false;
}
if (self.major < new_version.major) {
return true;
} else if (self.major > new_version.major) {
return false;
}
if (self.minor < new_version.minor) {
return true;
} else if (self.minor > new_version.minor) {
return false;
}
if (self.patch < new_version.patch) {
return true;
} else if (self.patch > new_version.patch) {
return false;
}
if (self.extra < new_version.extra) {
return true;
} else if (self.extra > new_version.extra) {
return false;
}
if (self.vcs_rev < new_version.vcs_rev) {
return true;
} else if (self.vcs_rev > new_version.vcs_rev) {
return false;
}
if (self.release < new_version.release) {
return true;
} else if (self.release > new_version.release) {
return false;
}
// everything is equal
return false;
}
// Hacky wrapper aruond std.fmt.parseInt to add a retry after stripping all non-number chars
fn parseInt(str: []const u8) !isize {
const num = std.fmt.parseUnsigned(isize, str, 10) catch {
const buf_size = 16;
var new_str: [buf_size]u8 = undefined;
var new_str_i: u8 = 0;
var found_num = false;
for (str) |char| {
if (ascii.isDigit(char)) {
new_str[new_str_i] = char;
new_str_i += 1;
if (new_str_i == buf_size) {
return error.ParseIntDigitTooLarge;
}
found_num = true;
} else if (found_num) {
// Only consider contiguous digits
break;
}
}
if (mem.eql(u8 , str, "alpha")) {
return -2;
} else if (mem.eql(u8 , str, "beta")) {
return -1;
}
if (new_str_i == 0) {
return error.NotANumber;
}
const buf: []u8 = new_str[0..new_str_i];
const p = try std.fmt.parseUnsigned(isize, buf, 10);
return p;
};
return num;
}
};
test "Version.init - standard semver without epoch" {
const input = "1.2.3-4";
const expected = Version{
.epoch = 0,
.major = 1,
.minor = 2,
.patch = 3,
.extra = 0,
.vcs_rev = 0,
.release = 4,
};
try testing.expectEqual(expected, try Version.init(input));
}
test "Version.init - standard semver with epoch" {
const input = "1:2.3.4-5";
const expected = Version{
.epoch = 1,
.major = 2,
.minor = 3,
.patch = 4,
.extra = 0,
.vcs_rev = 0,
.release = 5,
};
try testing.expectEqual(expected, try Version.init(input));
}
test "Version.init - everything" {
const input = "1:2.3.4.69+42+abc1234-5";
const expected = Version{
.epoch = 1,
.major = 2,
.minor = 3,
.patch = 4,
.extra = 69,
.vcs_rev = 42,
.release = 5,
};
try testing.expectEqual(expected, try Version.init(input));
}
test "Version.init - only major" {
const input = "1000-1";
const expected = Version{
.epoch = 0,
.major = 1000,
.minor = 0,
.patch = 0,
.extra = 0,
.vcs_rev = 0,
.release = 1,
};
try testing.expectEqual(expected, try Version.init(input));
}
test "Version.init - only major and minor" {
const input = "1000.2-1";
const expected = Version{
.epoch = 0,
.major = 1000,
.minor = 2,
.patch = 0,
.extra = 0,
.vcs_rev = 0,
.release = 1,
};
try testing.expectEqual(expected, try Version.init(input));
}
test "Version.init - neovim-nightly-bin" {
const input = "0.5.0+dev+1194+gc20ae3aad-1";
const expected = Version{
.epoch = 0,
.major = 0,
.minor = 5,
.patch = 0,
.extra = 0,
.vcs_rev = 1194,
.release = 1,
};
try testing.expectEqual(expected, try Version.init(input));
}
test "Version.init - gnome-backgrounds" {
const input = "40rc-1";
const expected = Version{
.epoch = 0,
.major = 40,
.minor = 0,
.patch = 0,
.extra = 0,
.vcs_rev = 0,
.release = 1,
};
try testing.expectEqual(expected, try Version.init(input));
}
test "Version.olderThan - gnome-calculator" {
const old = try Version.init("3.26.3-1");
const new = try Version.init("3.26.3+2+g966ec1c5-1");
const expected = true;
const actual = old.olderThan(new);
try testing.expectEqual(expected, actual);
}
test "Version.olderThan - slang" {
const old = try Version.init("2.3.1a-1");
const new = try Version.init("2.3.1a-2");
const expected = true;
const actual = old.olderThan(new);
const reverse_expected = false;
const reverse_actual = new.olderThan(old);
try testing.expectEqual(expected, actual);
try testing.expectEqual(reverse_expected, reverse_actual);
}
test "Version.olderThan - libinput - 1" {
const old = try Version.init("1.10.0-1");
const new = try Version.init("1.10.0+25+g3e77f2e9-1");
const expected = true;
const actual = old.olderThan(new);
const reverse_expected = false;
const reverse_actual = new.olderThan(old);
try testing.expectEqual(expected, actual);
try testing.expectEqual(reverse_expected, reverse_actual);
}
test "Version.olderThan - libinput - 2" {
const old = try Version.init("1.10.0+25+g3e77f2e9-1");
const new = try Version.init("1.10.1-1");
const expected = true;
const actual = old.olderThan(new);
const reverse_expected = false;
const reverse_actual = new.olderThan(old);
try testing.expectEqual(expected, actual);
try testing.expectEqual(reverse_expected, reverse_actual);
}
test "Version.olderThan - gnome-keyring" {
const old = try Version.init("1:3.27.2-1");
const new = try Version.init("1:3.27.4+8+gff229abc-1");
const expected = true;
const actual = old.olderThan(new);
const reverse_expected = false;
const reverse_actual = new.olderThan(old);
try testing.expectEqual(expected, actual);
try testing.expectEqual(reverse_expected, reverse_actual);
}
test "Version.olderThan - libxml2" {
const old = try Version.init("2.9.7+4+g72182550-2");
const new = try Version.init("2.9.8-1");
const expected = true;
const actual = old.olderThan(new);
const reverse_expected = false;
const reverse_actual = new.olderThan(old);
try testing.expectEqual(expected, actual);
try testing.expectEqual(reverse_expected, reverse_actual);
}
test "Version.olderThan - libnm" {
const old = try Version.init("1.10.5dev+3+g5159c34ea-1");
const new = try Version.init("1.10.6-1");
const expected = true;
const actual = old.olderThan(new);
const reverse_expected = false;
const reverse_actual = new.olderThan(old);
try testing.expectEqual(expected, actual);
try testing.expectEqual(reverse_expected, reverse_actual);
}
test "Version.olderThan - libytnef" {
const old = try Version.init("1.9.3+7+g24fe30e-2");
const new = try Version.init("1:1.9.3-1");
const expected = true;
const actual = old.olderThan(new);
const reverse_expected = false;
const reverse_actual = new.olderThan(old);
try testing.expectEqual(expected, actual);
try testing.expectEqual(reverse_expected, reverse_actual);
}
test "Version.olderThan - neovim-nightly-bin" {
const old = try Version.init("0.5.0+dev+1130+g7c204af87-1");
const new = try Version.init("0.5.0+dev+1157+g0ab88c2ea-1");
const expected = true;
const actual = old.olderThan(new);
const reverse_expected = false;
const reverse_actual = new.olderThan(old);
try testing.expectEqual(expected, actual);
try testing.expectEqual(reverse_expected, reverse_actual);
}
// TODO: Make this pass
// test "Version.olderThan - zoom" {
// const old = try Version.init("5.7.6-1");
// const new = try Version.init("5.7.6a-1");
// const expected = true;
// const actual = old.olderThan(new);
// const reverse_expected = false;
// const reverse_actual = new.olderThan(old);
// try testing.expectEqual(expected, actual);
// try testing.expectEqual(reverse_expected, reverse_actual);
// }
|
src/version.zig
|
const util = @import("../sdf_util.zig");
pub const info: util.SdfInfo = .{
.name = "Round Cone",
.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 {
start: util.math.vec3,
end: util.math.vec3,
start_radius: f32,
end_radius: f32,
mat: usize,
};
const function_definition: []const u8 =
\\float sdRoundCone(vec3 p, vec3 a, vec3 b, float r1, float r2){
\\ vec3 ba = b - a;
\\ float l2 = dot(ba,ba);
\\ float rr = r1 - r2;
\\ float a2 = l2 - rr*rr;
\\ float il2 = 1./l2;
\\
\\ vec3 pa = p - a;
\\ float y = dot(pa,ba);
\\ float z = y - l2;
\\ float x2 = dot2(pa*l2 - ba*y);
\\ float y2 = y*y*l2;
\\ float z2 = z*z*l2;
\\
\\ float k = sign(rr)*rr*rr*x2;
\\ if (sign(z)*a2*z2 > k) return sqrt(x2 + z2) * il2 - r2;
\\ if (sign(y)*a2*y2 < k) return sqrt(x2 + y2) * il2 - r1;
\\ return (sqrt(x2*a2*il2)+y*rr)*il2 - r1;
\\}
\\
;
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} = sdRoundCone({s},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.start[0],
data.start[1],
data.start[2],
data.end[0],
data.end[1],
data.end[2],
data.start_radius,
data.end_radius,
}) 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.start,
.r = data.start_radius,
},
.{
.pos = data.end,
.r = data.end_radius,
},
);
}
|
src/sdf/surfaces/round_cone.zig
|
const Value = @import("../_common_utils.zig").Value;
/// SET key value [EX seconds|PX milliseconds] [NX|XX]
pub const SET = struct {
//! Command builder for SET.
//!
//! Allows you to use both strings and numbers as values.
//! ```
//! const cmd1 = SET.init("mykey", 42, .NoExpire, .NoConditions);
//! const cmd2 = SET.init("mykey", "banana", .NoExpire, .IfNotExisting);
//! ```
key: []const u8,
/// Users should provide either a string or a number to `.init()`.
value: Value,
/// Time To Live (TTL) for the key, defaults to `.NoExpire`.
expire: Expire = .NoExpire,
/// Execution constraints, defaults to `.NoCondition` (executes the command unconditionally).
conditions: Conditions = .NoConditions,
/// Provide either a number or a string as `value`.
pub fn init(key: []const u8, value: anytype, expire: Expire, conditions: Conditions) SET {
return .{
.key = key,
.value = Value.fromVar(value),
.expire = expire,
.conditions = conditions,
};
}
pub fn validate(self: SET) !void {
if (self.key.len == 0) return error.EmptyKeyName;
}
pub const RedisCommand = struct {
pub fn serialize(self: SET, comptime rootSerializer: type, msg: anytype) !void {
return rootSerializer.serializeCommand(msg, .{
"SET",
self.key,
self.value,
self.expire,
self.conditions,
});
}
};
pub const Expire = union(enum) {
NoExpire,
Seconds: u64,
Milliseconds: u64,
pub const RedisArguments = struct {
pub fn count(self: Expire) usize {
return switch (self) {
.NoExpire => 0,
else => 2,
};
}
pub fn serialize(self: Expire, comptime rootSerializer: type, msg: anytype) !void {
switch (self) {
.NoExpire => {},
.Seconds => |s| {
try rootSerializer.serializeArgument(msg, []const u8, "EX");
try rootSerializer.serializeArgument(msg, u64, s);
},
.Milliseconds => |m| {
try rootSerializer.serializeArgument(msg, []const u8, "PX");
try rootSerializer.serializeArgument(msg, u64, m);
},
}
}
};
};
pub const Conditions = union(enum) {
/// Creates the key uncontidionally.
NoConditions,
/// Creates the key only if it does not exist yet.
IfNotExisting,
/// Only overrides an existing key.
IfAlreadyExisting,
pub const RedisArguments = struct {
pub fn count(self: Conditions) usize {
return switch (self) {
.NoConditions => 0,
else => 1,
};
}
pub fn serialize(self: Conditions, comptime rootSerializer: type, msg: anytype) !void {
switch (self) {
.NoConditions => {},
.IfNotExisting => |s| try rootSerializer.serializeArgument(msg, []const u8, "NX"),
.IfAlreadyExisting => |m| try rootSerializer.serializeArgument(msg, []const u8, "XX"),
}
}
};
};
};
test "basic usage" {
var cmd = SET.init("mykey", 42, .NoExpire, .NoConditions);
cmd = SET.init("mykey", "banana", .NoExpire, .IfNotExisting);
try cmd.validate();
}
test "serializer" {
const std = @import("std");
const serializer = @import("../../serializer.zig").CommandSerializer;
var correctBuf: [1000]u8 = undefined;
var correctMsg = std.io.fixedBufferStream(correctBuf[0..]);
var testBuf: [1000]u8 = undefined;
var testMsg = std.io.fixedBufferStream(testBuf[0..]);
{
{
correctMsg.reset();
testMsg.reset();
try serializer.serializeCommand(
testMsg.outStream(),
SET.init("mykey", 42, .NoExpire, .NoConditions),
);
try serializer.serializeCommand(
correctMsg.outStream(),
.{ "SET", "mykey", "42" },
);
std.testing.expectEqualSlices(u8, correctMsg.getWritten(), testMsg.getWritten());
}
{
correctMsg.reset();
testMsg.reset();
try serializer.serializeCommand(
testMsg.outStream(),
SET.init("mykey", "banana", .NoExpire, .IfNotExisting),
);
try serializer.serializeCommand(
correctMsg.outStream(),
.{ "SET", "mykey", "banana", "NX" },
);
std.testing.expectEqualSlices(u8, correctMsg.getWritten(), testMsg.getWritten());
}
{
correctMsg.reset();
testMsg.reset();
try serializer.serializeCommand(
testMsg.outStream(),
SET.init("mykey", "banana", SET.Expire{ .Seconds = 20 }, .IfAlreadyExisting),
);
try serializer.serializeCommand(
correctMsg.outStream(),
.{ "SET", "mykey", "banana", "EX", "20", "XX" },
);
std.testing.expectEqualSlices(u8, correctMsg.getWritten(), testMsg.getWritten());
}
}
}
|
src/commands/strings/set.zig
|
const std = @import("std");
const target = @import("builtin").target;
const arch = target.cpu.arch;
const os_tag = target.os.tag;
const builtin = @import("builtin");
const Atomic = std.atomic.Atomic;
pub const Futex = std.Thread.Futex;
pub const is_x86 = switch (arch) {
.i386, .x86_64 => true,
else => false,
};
pub const is_arm = switch (arch) {
.arm, .aarch64 => true,
else => false,
};
pub const is_linux = os_tag == .linux;
pub const is_windows = os_tag == .windows;
pub const is_darwin = switch (os_tag) {
.macos, .watchos, .tvos, .ios => true,
else => false,
};
pub const is_posix = builtin.link_libc and (switch (os_tag) {
.linux,
.minix,
.macos,
.watchos,
.tvos,
.ios,
.solaris,
.aix,
.openbsd,
.kfreebsd,
.freebsd,
.netbsd,
.dragonfly,
.hermit,
.haiku,
.cloudabi,
.fuchsia => true,
else => false,
});
pub fn yieldCpu(iterations: usize) void {
var i = iterations;
while (i != 0) : (i -= 1) {
std.atomic.spinLoopHint();
}
}
pub fn yieldThread(iterations: usize) void {
var i = iterations;
while (i != 0) : (i -= 1) {
switch (os_tag) {
.windows => _ = std.os.windows.kernel32.SwitchToThread(),
else => _ = std.os.system.sched_yield(),
}
}
}
pub fn nanotime() u64 {
if (is_windows) {
var now = std.os.windows.QueryPerformanceCounter();
const Static = struct {
var delta = Atomic(u64).init(0);
var frequency = Atomic(u64).init(0);
};
var freq = Static.frequency.load(.Monotonic);
if (freq == 0) {
freq = std.os.windows.QueryPerformanceFrequency();
Static.frequency.store(freq, .Monotonic);
}
var delta = Static.delta.load(.Monotonic);
if (delta == 0) {
delta = Static.delta.compareAndSwap(0, now, .Monotonic, .Monotonic) orelse now;
}
if (now < delta) now = delta;
return ((now - delta) * std.time.ns_per_s) / freq;
}
if (is_darwin) {
const now = std.os.darwin.mach_absolute_time();
const Static = struct {
var info: std.os.darwin.mach_timebase_info_data = undefined;
var delta = Atomic(u64).init(0);
};
if (@atomicLoad(u32, &Static.info.numer, .Monotonic) == 0) {
std.os.darwin.mach_timebase_info(&Static.info);
}
var delta = Static.delta.load(.Monotonic);
if (delta == 0) {
delta = Static.delta.compareAndSwap(0, now, .Monotonic, .Monotonic) orelse now;
}
var current = now - delta;
if (Static.info.numer != 1) current *= Static.info.numer;
if (Static.info.denom != 1) current /= Static.info.denom;
return current;
}
var ts: std.os.timespec = undefined;
std.os.clock_gettime(std.os.CLOCK.MONOTONIC, &ts) catch unreachable;
return @intCast(u64, ts.tv_sec) * std.time.ns_per_s + @intCast(u64, ts.tv_nsec);
}
pub const SpinWait = struct {
counter: usize = 0,
pub fn reset(self: *SpinWait) void {
self.* = .{};
}
pub fn yield(self: *SpinWait) bool {
if (self.counter >= 100) return false;
self.counter += 1;
yieldCpu(1);
// switch (self.counter % 10) {
// 0 => yieldThread(1),
// else => yieldCpu(1),
// }
return true;
// if (self.counter >= 10) return false;
// self.counter += 1;
// if (self.counter <= 3) {
// yieldCpu(@as(usize, 1) << @intCast(u3, self.counter));
// } else {
// yieldThread(1);
// }
// return true;
}
};
pub const Event = struct {
state: Atomic(u32) = Atomic(u32).init(0),
pub fn reset(self: *Event) void {
self.* = .{};
}
pub fn wait(self: *Event) void {
while (self.state.load(.Acquire) == 0) {
Futex.wait(&self.state, 0, null) catch unreachable;
}
}
pub fn notify(self: *Event) void {
self.state.store(1, .Release);
Futex.wake(&self.state, 1);
}
};
|
utils.zig
|
const std = @import("std");
const mem = std.mem;
const warn = std.debug.warn;
const identStep = struct {
ident: []const u8,
rest: []const u8,
};
pub fn nextIdent(x: []const u8) identStep {
var i: usize = 0;
while (i < x.len and x[i] != '.') : (i += 1) {}
return identStep{ .ident = x[0..i], .rest = x[1..] };
}
fn isIdentChar(c: u8) bool {
return 'A' <= c and c <= 'Z' or 'a' <= c and c <= 'z' or '0' <= c and c <= '9' or c == '-';
}
fn isNum(v: []const u8) bool {
var i: usize = 0;
while (i < v.len and '0' <= v[i] and v[i] <= '9') : (i += 1) {}
return i == v.len;
}
fn isBadNum(v: []const u8) bool {
var i: usize = 0;
while (i < v.len and '0' <= v[i] and v[i] <= '9') : (i += 1) {}
return i == v.len and i > 1 and v[0] == '0';
}
pub const Comparison = enum {
LessThan,
Equal,
GreaterThan,
};
pub fn compare(x: []const u8, y: []const u8) !Comparison {
var a = try parse(x);
var b = try parse(y);
return a.compare(b);
}
fn compareInt(x: []const u8, y: []const u8) Comparison {
if (mem.eql(u8, x, y)) {
return Comparison.Equal;
}
if (x.len < y.len) {
return Comparison.LessThan;
}
if (x.len > y.len) {
return Comparison.GreaterThan;
}
const cmp = mem.compare(u8, x, y);
return switch (cmp) {
mem.Compare.LessThan => Comparison.LessThan,
mem.Compare.Equal => Comparison.Equal,
mem.Compare.GreaterThan => Comparison.GreaterThan,
else => unreachable,
};
}
fn comparePrerelease(x: ?[]const u8, y: ?[]const u8) Comparison {
// safely handle null pre releases
if (x == null and y == null) {
return Comparison.Equal;
}
if (x == null and y != null) {
return Comparison.GreaterThan;
}
if (x != null and y == null) {
return Comparison.LessThan;
}
// "When major, minor, and patch are equal, a pre-release version has
// lower precedence than a normal version.
// Example: 1.0.0-alpha < 1.0.0.
// Precedence for two pre-release versions with the same major, minor,
// and patch version MUST be determined by comparing each dot separated
// identifier from left to right until a difference is found as follows:
// identifiers consisting of only digits are compared numerically and
// identifiers with letters or hyphens are compared lexically in ASCII
// sort order. Numeric identifiers always have lower precedence than
// non-numeric identifiers. A larger set of pre-release fields has a
// higher precedence than a smaller set, if all of the preceding
// identifiers are equal.
// Example: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta <
// 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0.
if (mem.eql(u8, x.?, y.?)) {
return Comparison.Equal;
}
var i: usize = 0;
while (true) : (i += 1) {
var xx = x.?[i..];
var yy = y.?[i..];
var dx = nextIdent(xx);
var dy = nextIdent(yy);
if (!mem.eql(u8, dx.ident, dy.ident)) {
const ix = isNum(dx.ident);
const iy = isNum(dy.ident);
if (ix != iy) {
if (ix) {
return Comparison.LessThan;
}
return Comparison.GreaterThan;
}
if (ix) {
if (dx.ident.len < dy.ident.len) {
return Comparison.LessThan;
}
if (dx.ident.len > dy.ident.len) {
return Comparison.GreaterThan;
}
}
switch (mem.compare(u8, dx.ident, dy.ident)) {
mem.Compare.LessThan => return Comparison.LessThan,
else => {},
}
return Comparison.GreaterThan;
}
if (!(i != x.?.len - 1 and i != y.?.len - 1)) {
if (x.?.len - 1 == i) {
return Comparison.LessThan;
}
return Comparison.GreaterThan;
}
}
}
pub const Version = struct {
major: []const u8,
minor: []const u8,
patch: []const u8,
pre_release: ?[]const u8,
build: ?[]const u8,
pub fn compare(self: Version, v: Version) Comparison {
const major = compareInt(self.major, v.major);
if (major != Comparison.Equal) {
return major;
}
const minor = compareInt(self.minor, v.minor);
if (minor != Comparison.Equal) {
return minor;
}
const patch = compareInt(self.patch, v.patch);
if (patch != Comparison.Equal) {
return patch;
}
return comparePrerelease(self.pre_release, v.pre_release);
}
/// print writes semantic version string to the stream. stream should
/// implement io.OutStream intreface.
/// This prefixes the version string with v. The output takes the following
/// form
/// v{major}.{minor}.{patch}-{pre_release}+{build}
pub fn print(self: Version, stream: var) !void {
const fmt = "v{}.{}.{}";
try stream.print(fmt, self.major, self.minor, self.patch);
if (self.pre_release) |value| {
try stream.print("-{}", value);
}
if (self.build) |value| {
try stream.print("+{}", value);
}
}
/// printBuffer is like print but wites the version string to buffer.
pub fn printBuffer(self: Version, buf: *std.Buffer) !void {
var b = std.io.BufferOutStream.init(buf);
try self.print(&b.stream);
}
};
pub fn parse(v: []const u8) !Version {
if (v.len == 0) {
return error.EmptyString;
}
var n: usize = 0;
var x = n;
if (v[0] == 'v') {
x += 1;
}
var version: Version = undefined;
if (parseInt(v[x..])) |value| {
version.major = value;
} else |err| {
return error.BadMajorVersion;
}
n += x + version.major.len;
if (n >= v.len) {
version.minor = "0";
version.patch = "0";
return version;
}
if (v[n] != '.') {
return error.BadMinorPrefix;
}
if (parseInt(v[n + 1 ..])) |value| {
version.minor = value;
} else |err| {
return error.BadMinorVersion;
}
n += 1 + version.minor.len;
if (n >= v.len) {
version.patch = "0";
return version;
}
if (v[n] != '.') {
return error.BadPatchPrefix;
}
if (parseInt(v[n + 1 ..])) |value| {
version.patch = value;
} else |err| {
return error.BadPatchVersion;
}
n += 1 + version.patch.len;
if (n < v.len and v[n] == '-') {
version.pre_release = try parsePreRelease(v[n..]);
}
if (version.pre_release) |value| {
n += 1 + value.len;
}
if (n < v.len and v[n] == '+') {
version.build = try parseBuild(v[n..]);
}
return version;
}
fn parseInt(v: []const u8) ![]const u8 {
if (v.len == 0) {
return error.NaN;
}
if (v[0] < '0' or '9' < v[0]) {
return error.Nan;
}
var i: usize = 0;
while (i < v.len and '0' <= v[i] and v[i] <= '9') : (i += 1) {}
return v[0..i];
}
fn parsePreRelease(v: []const u8) ![]const u8 {
if (v.len == 0 or v[0] != '-') {
return error.BadPrerelease;
}
var i: usize = 1;
var start: usize = 1;
while (i < v.len and v[i] != '+') {
if (!isIdentChar(v[i]) and v[i] != '.') {
return error.BadPrerelease;
}
if (v[i] == '.') {
if (start == i or isBadNum(v[start..])) {
return error.BadPrerelease;
}
start = i + 1;
}
i += 1;
}
if (start == i or isBadNum(v[start..i])) {
return error.BadPrerelease;
}
return v[1..i];
}
fn parseBuild(v: []const u8) ![]const u8 {
if (v.len == 0 or v[0] != '+') {
return error.BadBuild;
}
var i: usize = 1;
var start: usize = 1;
while (i < v.len) {
if (!isIdentChar(v[i])) {
return error.BadBuild;
}
if (v[i] == '.') {
if (start == i) {
return error.BadBuild;
}
start = i + 1;
}
i += 1;
}
if (start == i) {
return error.BadBuild;
}
return v[1..i];
}
// returns true if v is a valid semvar string and false otherwise.
pub fn isValid(v: []const u8) bool {
if (parse(v)) |_| {
return true;
} else |err| {
return false;
}
}
|
src/main.zig
|
const std = @import("std");
const CompileUnit = @import("CompileUnit.zig");
const Decoder = @import("Decoder.zig");
const ir = @import("ir.zig");
pub const DisassemblerOptions = struct {
/// Prefix each line of the disassembly with the hexadecimal address.
addressPrefix: bool = false,
/// If set, a hexdump with both hex- and ascii display will be emitted.
/// Each line of text will contain `hexwidth` number of bytes.
hexwidth: ?usize = null,
/// If set to `true`, the output will contain a line with the
/// name of function that starts at this offset. This option
/// is set by default.
labelOutput: bool = true,
/// If set to `true`, the disassembled instruction will be emitted.
/// This is set by default.
instructionOutput: bool = true,
};
/// Disassembles a given compile unit into a text stream.
/// The output of the disassembler is adjustable to different formats.
/// If all output is disabled in the config, this function can also be used
/// to verify that a compile unit can be parsed completly without any problems.
pub fn disassemble(stream: anytype, cu: CompileUnit, options: DisassemblerOptions) !void {
var decoder = Decoder.init(cu.code);
const anyOutput = options.addressPrefix or options.labelOutput or options.instructionOutput or (options.hexwidth != null);
if (options.addressPrefix)
try stream.print("{X:0>6}\t", .{decoder.offset});
if (options.labelOutput)
try stream.writeAll("<main>:\n");
while (!decoder.isEof()) {
if (options.labelOutput) {
for (cu.functions) |fun| {
if (fun.entryPoint == decoder.offset) {
if (options.addressPrefix)
try stream.print("{X:0>6}\t", .{decoder.offset});
try stream.print("{s}:\n", .{fun.name});
}
}
}
if (options.addressPrefix)
try stream.print("{X:0>6}\t", .{decoder.offset});
const start = decoder.offset;
const instr = try decoder.read(ir.Instruction);
const end = decoder.offset;
if (options.hexwidth) |hw| {
try writeHexDump(stream, decoder.data, start, end, hw);
}
if (options.instructionOutput) {
try stream.writeAll("\t");
try stream.writeAll(@tagName(@as(ir.InstructionName, instr)));
inline for (std.meta.fields(ir.Instruction)) |fld| {
const instr_name = @field(ir.InstructionName, fld.name);
if (instr == instr_name) {
if (fld.field_type == ir.Instruction.Deprecated) {
// no-op
} else if (fld.field_type == ir.Instruction.NoArg) {
// no-op
} else if (fld.field_type == ir.Instruction.CallArg) {
const args = @field(instr, fld.name);
try stream.print(" {s} {d}", .{ args.function, args.argc });
} else {
if (@TypeOf(@field(instr, fld.name).value) == f64) {
try stream.print(" {d}", .{@field(instr, fld.name).value});
} else if (instr_name == .jif or instr_name == .jmp or instr_name == .jnf) {
try stream.print(" 0x{X}", .{@field(instr, fld.name).value});
} else {
try stream.print(" {any}", .{@field(instr, fld.name).value});
}
}
}
}
}
if (anyOutput)
try stream.writeAll("\n");
if (options.hexwidth) |hw| {
var cursor = start + hw;
var paddedEnd = start + 2 * hw;
while (paddedEnd < end + hw) : (paddedEnd += hw) {
if (options.addressPrefix)
try stream.print("{X:0>6}\t", .{cursor});
try writeHexDump(stream, decoder.data, cursor, end, hw);
cursor += hw;
try stream.writeAll("\n");
}
}
}
}
fn writeHexDump(stream: anytype, data: []const u8, begin: usize, end: usize, width: usize) !void {
var offset_hex = begin;
while (offset_hex < begin + width) : (offset_hex += 1) {
if (offset_hex < end) {
try stream.print("{X:0>2} ", .{data[offset_hex]});
} else {
try stream.writeAll(" ");
}
}
try stream.writeAll("|");
var offset_bin = begin;
while (offset_bin < begin + width) : (offset_bin += 1) {
if (offset_bin < end) {
if (std.ascii.isPrint(data[offset_bin])) {
try stream.print("{c}", .{data[offset_bin]});
} else {
try stream.writeAll(".");
}
} else {
try stream.writeAll(" ");
}
}
try stream.writeAll("|");
}
test "disassemble" {
// dummy test
_ = disassemble;
}
|
src/library/common/disassembler.zig
|
const std = @import("std");
const util = @import("util.zig");
const data = @embedFile("../data/day21.txt");
const Input = struct {
start1: u16,
start2: u16,
pub fn init(input_text: []const u8, allocator: std.mem.Allocator) !@This() {
_ = allocator;
var lines = std.mem.tokenize(u8, input_text, "\r\n");
const line1 = lines.next().?;
const line2 = lines.next().?;
var input = Input{
.start1 = try parseInt(u16, line1[28..], 10),
.start2 = try parseInt(u16, line2[28..], 10),
};
return input;
}
pub fn deinit(self: @This()) void {
_ = self;
}
};
fn part1(input: Input) i64 {
var pos1: u16 = input.start1;
var pos2: u16 = input.start2;
var score1: i64 = 0;
var score2: i64 = 0;
var die: u16 = 0;
var roll_count: i64 = 0;
while (score1 < 1000 and score2 < 1000) {
// player 1 turn
die = if (die == 100) @as(u16, 1) else die + 1;
const roll1a = die;
die = if (die == 100) @as(u16, 1) else die + 1;
const roll1b = die;
die = if (die == 100) @as(u16, 1) else die + 1;
const roll1c = die;
roll_count += 3;
pos1 = ((pos1 - 1 + roll1a + roll1b + roll1c) % 10) + 1;
score1 += pos1;
//print("Player 1 rolls {d}+{d}+{d} and moves to {d} for a total score of {d}\n",
// .{roll1a, roll1b, roll1c, pos1, score1});
if (score1 >= 1000) {
return roll_count * score2;
}
// player 2 turn
die = if (die == 100) @as(u16, 1) else die + 1;
const roll2a = die;
die = if (die == 100) @as(u16, 1) else die + 1;
const roll2b = die;
die = if (die == 100) @as(u16, 1) else die + 1;
const roll2c = die;
roll_count += 3;
pos2 = ((pos2 - 1 + roll2a + roll2b + roll2c) % 10) + 1;
score2 += pos2;
//print("Player 2 rolls {d}+{d}+{d} and moves to {d} for a total score of {d}\n",
// .{roll2a, roll2b, roll2c, pos2, score2});
if (score2 >= 1000) {
return roll_count * score1;
}
}
unreachable;
}
const GameState = struct {
pos1: u16,
pos2: u16,
score1: i64,
score2: i64,
universes: i64,
};
const DiracRoll = struct {
move: u16,
count: i64,
};
const DIRAC_ROLLS = [7]DiracRoll{
DiracRoll{ .move = 3, .count = 1 },
DiracRoll{ .move = 4, .count = 3 },
DiracRoll{ .move = 5, .count = 6 },
DiracRoll{ .move = 6, .count = 7 },
DiracRoll{ .move = 7, .count = 6 },
DiracRoll{ .move = 8, .count = 3 },
DiracRoll{ .move = 9, .count = 1 },
};
fn simulateRound(state: GameState, turn: u32, wins1: *i64, wins2: *i64) void {
if (turn == 1) {
for (DIRAC_ROLLS) |roll| {
const new_pos1 = ((state.pos1 - 1 + roll.move) % 10) + 1;
const new_score1 = state.score1 + new_pos1;
const new_universes = state.universes * roll.count;
if (new_score1 >= 21) {
wins1.* += new_universes;
continue;
}
var new_state = GameState{
.pos1 = new_pos1,
.pos2 = state.pos2,
.score1 = new_score1,
.score2 = state.score2,
.universes = new_universes,
};
simulateRound(new_state, 2, wins1, wins2);
}
} else if (turn == 2) {
for (DIRAC_ROLLS) |roll| {
const new_pos2 = ((state.pos2 - 1 + roll.move) % 10) + 1;
const new_score2 = state.score2 + new_pos2;
const new_universes = state.universes * roll.count;
if (new_score2 >= 21) {
wins2.* += new_universes;
continue;
}
var new_state = GameState{
.pos1 = state.pos1,
.pos2 = new_pos2,
.score1 = state.score1,
.score2 = new_score2,
.universes = new_universes,
};
simulateRound(new_state, 1, wins1, wins2);
}
}
}
fn part2(input: Input) i64 {
const state = GameState{ .pos1 = input.start1, .pos2 = input.start2, .score1 = 0, .score2 = 0, .universes = 1 };
var wins1: i64 = 0;
var wins2: i64 = 0;
simulateRound(state, 1, &wins1, &wins2);
return std.math.max(wins1, wins2);
}
const test_data =
\\Player 1 starting position: 4
\\Player 2 starting position: 8
;
const part1_test_solution: ?i64 = 739785;
const part1_solution: ?i64 = 675024;
const part2_test_solution: ?i64 = 444356092776315;
const part2_solution: ?i64 = 570239341223618;
// Just boilerplate below here, nothing to see
fn testPart1() !void {
var test_input = try Input.init(test_data, std.testing.allocator);
defer test_input.deinit();
if (part1_test_solution) |solution| {
try std.testing.expectEqual(solution, part1(test_input));
}
var timer = try std.time.Timer.start();
var input = try Input.init(data, std.testing.allocator);
defer input.deinit();
if (part1_solution) |solution| {
try std.testing.expectEqual(solution, part1(input));
print("part1 took {d:9.3}ms\n", .{@intToFloat(f64, timer.lap()) / 1000000.0});
}
}
fn testPart2() !void {
var test_input = try Input.init(test_data, std.testing.allocator);
defer test_input.deinit();
if (part2_test_solution) |solution| {
try std.testing.expectEqual(solution, part2(test_input));
}
var timer = try std.time.Timer.start();
var input = try Input.init(data, std.testing.allocator);
defer input.deinit();
if (part2_solution) |solution| {
try std.testing.expectEqual(solution, part2(input));
print("part2 took {d:9.3}ms\n", .{@intToFloat(f64, timer.lap()) / 1000000.0});
}
}
pub fn main() !void {
try testPart1();
try testPart2();
}
test "part1" {
try testPart1();
}
test "part2" {
try testPart2();
}
// Useful stdlib functions
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const parseInt = std.fmt.parseInt;
const min = std.math.min;
const max = std.math.max;
const print = std.debug.print;
const expect = std.testing.expect;
const assert = std.debug.assert;
|
src/day21.zig
|
const freetype = @import("freetype");
const c = @import("c");
const Face = @import("face.zig").Face;
const Buffer = @import("buffer.zig").Buffer;
const Feature = @import("common.zig").Feature;
const SegmentProps = @import("buffer.zig").SegmentProps;
pub const Font = struct {
handle: *c.hb_font_t,
pub fn init(face: Face) Font {
return .{ .handle = c.hb_font_create(face.handle).? };
}
pub fn fromFtFace(face: freetype.Face) Font {
return .{ .handle = c.hb_ft_font_create_referenced(face.handle).? };
}
pub fn createSubFont(self: Font) Font {
return .{
.handle = c.hb_font_create_sub_font(self.handle).?,
};
}
pub fn deinit(self: Font) void {
c.hb_font_destroy(self.handle);
}
pub fn ftFaceChanged(self: Font) void {
c.hb_ft_font_changed(self.handle);
}
pub fn setFtLoadFlags(self: Font, flags: freetype.LoadFlags) void {
c.hb_ft_font_set_load_flags(self.handle, flags.cast());
}
pub fn getFace(self: Font) Face {
return .{ .handle = c.hb_font_get_face(self.handle).? };
}
pub fn getFreetypeFace(self: Font) freetype.Face {
return .{ .handle = c.hb_ft_font_get_face(self.handle) };
}
pub fn getGlyph(self: Font, unicode: u32, variation_selector: u32) ?u32 {
var g: u32 = 0;
return if (c.hb_font_get_glyph(self.handle, unicode, variation_selector, &g) > 0)
g
else
null;
}
pub fn getParent(self: Font) ?Font {
return Font{ .handle = c.hb_font_get_parent(self.handle) orelse return null };
}
pub fn getPPEM(self: Font) @Vector(2, u32) {
var x: u32 = 0;
var y: u32 = 0;
c.hb_font_get_ppem(self.handle, &@intCast(c_uint, x), &@intCast(c_uint, y));
return @Vector(2, u32){ x, y };
}
pub fn getPTEM(self: Font) f32 {
return c.hb_font_get_ptem(self.handle);
}
pub fn getScale(self: Font) @Vector(2, u32) {
var x: u32 = 0;
var y: u32 = 0;
c.hb_font_get_scale(self.handle, &@intCast(c_int, x), &@intCast(c_int, y));
return @Vector(2, u32){ x, y };
}
pub fn setFace(self: Font, face: Face) void {
return c.hb_font_set_face(self.handle, face.handle);
}
pub fn shape(self: Font, buf: Buffer, features: ?[]const Feature) void {
hb_shape(
self.handle,
buf.handle,
if (features) |f| f.ptr else null,
if (features) |f| @intCast(c_uint, f.len) else 0,
);
}
pub fn shapeFull(self: Font, buf: Buffer, features: ?[]const Feature, shapers: []const []const u8) error{ShapingFailed}!void {
if (hb_shape_full(
self.handle,
buf.handle,
if (features) |f| f.ptr else null,
if (features) |f| @intCast(c_uint, f.len) else 0,
@ptrCast([*c]const [*c]const u8, shapers),
) < 1) return error.ShapingFailed;
}
};
pub extern fn hb_shape(font: ?*c.hb_font_t, buffer: ?*c.hb_buffer_t, features: [*c]const Feature, num_features: c_uint) void;
pub extern fn hb_shape_full(font: ?*c.hb_font_t, buffer: ?*c.hb_buffer_t, features: [*c]const Feature, num_features: c_uint, shaper_list: [*c]const [*c]const u8) u8;
|
freetype/src/harfbuzz/font.zig
|
pub const CLSID_SoftwareBitmapNativeFactory = Guid.initString("84e65691-8602-4a84-be46-708be9cd4b74");
//--------------------------------------------------------------------------------
// Section: Types (2)
//--------------------------------------------------------------------------------
const IID_ISoftwareBitmapNative_Value = Guid.initString("94bc8415-04ea-4b2e-af13-4de95aa898eb");
pub const IID_ISoftwareBitmapNative = &IID_ISoftwareBitmapNative_Value;
pub const ISoftwareBitmapNative = extern struct {
pub const VTable = extern struct {
base: IInspectable.VTable,
GetData: fn(
self: *const ISoftwareBitmapNative,
riid: ?*const Guid,
ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IInspectable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISoftwareBitmapNative_GetData(self: *const T, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ISoftwareBitmapNative.VTable, self.vtable).GetData(@ptrCast(*const ISoftwareBitmapNative, self), riid, ppv);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISoftwareBitmapNativeFactory_Value = Guid.initString("c3c181ec-2914-4791-af02-02d224a10b43");
pub const IID_ISoftwareBitmapNativeFactory = &IID_ISoftwareBitmapNativeFactory_Value;
pub const ISoftwareBitmapNativeFactory = extern struct {
pub const VTable = extern struct {
base: IInspectable.VTable,
CreateFromWICBitmap: fn(
self: *const ISoftwareBitmapNativeFactory,
data: ?*IWICBitmap,
forceReadOnly: BOOL,
riid: ?*const Guid,
ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateFromMF2DBuffer2: fn(
self: *const ISoftwareBitmapNativeFactory,
data: ?*IMF2DBuffer2,
subtype: ?*const Guid,
width: u32,
height: u32,
forceReadOnly: BOOL,
minDisplayAperture: ?*const MFVideoArea,
riid: ?*const Guid,
ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IInspectable.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISoftwareBitmapNativeFactory_CreateFromWICBitmap(self: *const T, data: ?*IWICBitmap, forceReadOnly: BOOL, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ISoftwareBitmapNativeFactory.VTable, self.vtable).CreateFromWICBitmap(@ptrCast(*const ISoftwareBitmapNativeFactory, self), data, forceReadOnly, riid, ppv);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISoftwareBitmapNativeFactory_CreateFromMF2DBuffer2(self: *const T, data: ?*IMF2DBuffer2, subtype: ?*const Guid, width: u32, height: u32, forceReadOnly: BOOL, minDisplayAperture: ?*const MFVideoArea, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ISoftwareBitmapNativeFactory.VTable, self.vtable).CreateFromMF2DBuffer2(@ptrCast(*const ISoftwareBitmapNativeFactory, self), data, subtype, width, height, forceReadOnly, minDisplayAperture, riid, ppv);
}
};}
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 HRESULT = @import("../../../foundation.zig").HRESULT;
const IInspectable = @import("../../../system/win_rt.zig").IInspectable;
const IMF2DBuffer2 = @import("../../../media/media_foundation.zig").IMF2DBuffer2;
const IWICBitmap = @import("../../../graphics/imaging.zig").IWICBitmap;
const MFVideoArea = @import("../../../media/media_foundation.zig").MFVideoArea;
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/win_rt/graphics/imaging.zig
|
/// The function fiatP256AddcarryxU64 is an addition with carry.
/// Postconditions:
/// out1 = (arg1 + arg2 + arg3) mod 2^64
/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋
///
/// Input Bounds:
/// arg1: [0x0 ~> 0x1]
/// arg2: [0x0 ~> 0xffffffffffffffff]
/// arg3: [0x0 ~> 0xffffffffffffffff]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffffffffffff]
/// out2: [0x0 ~> 0x1]
fn fiatP256AddcarryxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) callconv(.Inline) void {
const x1: u128 = ((@intCast(u128, arg1) + @intCast(u128, arg2)) + @intCast(u128, arg3));
const x2: u64 = @intCast(u64, (x1 & @intCast(u128, 0xffffffffffffffff)));
const x3: u1 = @intCast(u1, (x1 >> 64));
out1.* = x2;
out2.* = x3;
}
/// The function fiatP256SubborrowxU64 is a subtraction with borrow.
/// Postconditions:
/// out1 = (-arg1 + arg2 + -arg3) mod 2^64
/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋
///
/// Input Bounds:
/// arg1: [0x0 ~> 0x1]
/// arg2: [0x0 ~> 0xffffffffffffffff]
/// arg3: [0x0 ~> 0xffffffffffffffff]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffffffffffff]
/// out2: [0x0 ~> 0x1]
fn fiatP256SubborrowxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) callconv(.Inline) void {
const x1: i128 = ((@intCast(i128, arg2) - @intCast(i128, arg1)) - @intCast(i128, arg3));
const x2: i1 = @intCast(i1, (x1 >> 64));
const x3: u64 = @intCast(u64, (x1 & @intCast(i128, 0xffffffffffffffff)));
out1.* = x3;
out2.* = @intCast(u1, (@intCast(i2, 0x0) - @intCast(i2, x2)));
}
/// The function fiatP256MulxU64 is a multiplication, returning the full double-width result.
/// Postconditions:
/// out1 = (arg1 * arg2) mod 2^64
/// out2 = ⌊arg1 * arg2 / 2^64⌋
///
/// Input Bounds:
/// arg1: [0x0 ~> 0xffffffffffffffff]
/// arg2: [0x0 ~> 0xffffffffffffffff]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffffffffffff]
/// out2: [0x0 ~> 0xffffffffffffffff]
fn fiatP256MulxU64(out1: *u64, out2: *u64, arg1: u64, arg2: u64) callconv(.Inline) void {
const x1: u128 = (@intCast(u128, arg1) * @intCast(u128, arg2));
const x2: u64 = @intCast(u64, (x1 & @intCast(u128, 0xffffffffffffffff)));
const x3: u64 = @intCast(u64, (x1 >> 64));
out1.* = x2;
out2.* = x3;
}
/// The function fiatP256CmovznzU64 is a single-word conditional move.
/// Postconditions:
/// out1 = (if arg1 = 0 then arg2 else arg3)
///
/// Input Bounds:
/// arg1: [0x0 ~> 0x1]
/// arg2: [0x0 ~> 0xffffffffffffffff]
/// arg3: [0x0 ~> 0xffffffffffffffff]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffffffffffff]
fn fiatP256CmovznzU64(out1: *u64, arg1: u1, arg2: u64, arg3: u64) callconv(.Inline) void {
const x1: u1 = (~(~arg1));
const x2: u64 = @intCast(u64, (@intCast(i128, @intCast(i1, (@intCast(i2, 0x0) - @intCast(i2, x1)))) & @intCast(i128, 0xffffffffffffffff)));
const x3: u64 = ((x2 & arg3) | ((~x2) & arg2));
out1.* = x3;
}
/// The function fiatP256Mul multiplies two field elements in the Montgomery domain.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// 0 ≤ eval arg2 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256Mul(out1: *[4]u64, arg1: [4]u64, arg2: [4]u64) void {
const x1: u64 = (arg1[1]);
const x2: u64 = (arg1[2]);
const x3: u64 = (arg1[3]);
const x4: u64 = (arg1[0]);
var x5: u64 = undefined;
var x6: u64 = undefined;
fiatP256MulxU64(&x5, &x6, x4, (arg2[3]));
var x7: u64 = undefined;
var x8: u64 = undefined;
fiatP256MulxU64(&x7, &x8, x4, (arg2[2]));
var x9: u64 = undefined;
var x10: u64 = undefined;
fiatP256MulxU64(&x9, &x10, x4, (arg2[1]));
var x11: u64 = undefined;
var x12: u64 = undefined;
fiatP256MulxU64(&x11, &x12, x4, (arg2[0]));
var x13: u64 = undefined;
var x14: u1 = undefined;
fiatP256AddcarryxU64(&x13, &x14, 0x0, x12, x9);
var x15: u64 = undefined;
var x16: u1 = undefined;
fiatP256AddcarryxU64(&x15, &x16, x14, x10, x7);
var x17: u64 = undefined;
var x18: u1 = undefined;
fiatP256AddcarryxU64(&x17, &x18, x16, x8, x5);
const x19: u64 = (@intCast(u64, x18) + x6);
var x20: u64 = undefined;
var x21: u64 = undefined;
fiatP256MulxU64(&x20, &x21, x11, 0xffffffff00000001);
var x22: u64 = undefined;
var x23: u64 = undefined;
fiatP256MulxU64(&x22, &x23, x11, 0xffffffff);
var x24: u64 = undefined;
var x25: u64 = undefined;
fiatP256MulxU64(&x24, &x25, x11, 0xffffffffffffffff);
var x26: u64 = undefined;
var x27: u1 = undefined;
fiatP256AddcarryxU64(&x26, &x27, 0x0, x25, x22);
const x28: u64 = (@intCast(u64, x27) + x23);
var x29: u64 = undefined;
var x30: u1 = undefined;
fiatP256AddcarryxU64(&x29, &x30, 0x0, x11, x24);
var x31: u64 = undefined;
var x32: u1 = undefined;
fiatP256AddcarryxU64(&x31, &x32, x30, x13, x26);
var x33: u64 = undefined;
var x34: u1 = undefined;
fiatP256AddcarryxU64(&x33, &x34, x32, x15, x28);
var x35: u64 = undefined;
var x36: u1 = undefined;
fiatP256AddcarryxU64(&x35, &x36, x34, x17, x20);
var x37: u64 = undefined;
var x38: u1 = undefined;
fiatP256AddcarryxU64(&x37, &x38, x36, x19, x21);
var x39: u64 = undefined;
var x40: u64 = undefined;
fiatP256MulxU64(&x39, &x40, x1, (arg2[3]));
var x41: u64 = undefined;
var x42: u64 = undefined;
fiatP256MulxU64(&x41, &x42, x1, (arg2[2]));
var x43: u64 = undefined;
var x44: u64 = undefined;
fiatP256MulxU64(&x43, &x44, x1, (arg2[1]));
var x45: u64 = undefined;
var x46: u64 = undefined;
fiatP256MulxU64(&x45, &x46, x1, (arg2[0]));
var x47: u64 = undefined;
var x48: u1 = undefined;
fiatP256AddcarryxU64(&x47, &x48, 0x0, x46, x43);
var x49: u64 = undefined;
var x50: u1 = undefined;
fiatP256AddcarryxU64(&x49, &x50, x48, x44, x41);
var x51: u64 = undefined;
var x52: u1 = undefined;
fiatP256AddcarryxU64(&x51, &x52, x50, x42, x39);
const x53: u64 = (@intCast(u64, x52) + x40);
var x54: u64 = undefined;
var x55: u1 = undefined;
fiatP256AddcarryxU64(&x54, &x55, 0x0, x31, x45);
var x56: u64 = undefined;
var x57: u1 = undefined;
fiatP256AddcarryxU64(&x56, &x57, x55, x33, x47);
var x58: u64 = undefined;
var x59: u1 = undefined;
fiatP256AddcarryxU64(&x58, &x59, x57, x35, x49);
var x60: u64 = undefined;
var x61: u1 = undefined;
fiatP256AddcarryxU64(&x60, &x61, x59, x37, x51);
var x62: u64 = undefined;
var x63: u1 = undefined;
fiatP256AddcarryxU64(&x62, &x63, x61, @intCast(u64, x38), x53);
var x64: u64 = undefined;
var x65: u64 = undefined;
fiatP256MulxU64(&x64, &x65, x54, 0xffffffff00000001);
var x66: u64 = undefined;
var x67: u64 = undefined;
fiatP256MulxU64(&x66, &x67, x54, 0xffffffff);
var x68: u64 = undefined;
var x69: u64 = undefined;
fiatP256MulxU64(&x68, &x69, x54, 0xffffffffffffffff);
var x70: u64 = undefined;
var x71: u1 = undefined;
fiatP256AddcarryxU64(&x70, &x71, 0x0, x69, x66);
const x72: u64 = (@intCast(u64, x71) + x67);
var x73: u64 = undefined;
var x74: u1 = undefined;
fiatP256AddcarryxU64(&x73, &x74, 0x0, x54, x68);
var x75: u64 = undefined;
var x76: u1 = undefined;
fiatP256AddcarryxU64(&x75, &x76, x74, x56, x70);
var x77: u64 = undefined;
var x78: u1 = undefined;
fiatP256AddcarryxU64(&x77, &x78, x76, x58, x72);
var x79: u64 = undefined;
var x80: u1 = undefined;
fiatP256AddcarryxU64(&x79, &x80, x78, x60, x64);
var x81: u64 = undefined;
var x82: u1 = undefined;
fiatP256AddcarryxU64(&x81, &x82, x80, x62, x65);
const x83: u64 = (@intCast(u64, x82) + @intCast(u64, x63));
var x84: u64 = undefined;
var x85: u64 = undefined;
fiatP256MulxU64(&x84, &x85, x2, (arg2[3]));
var x86: u64 = undefined;
var x87: u64 = undefined;
fiatP256MulxU64(&x86, &x87, x2, (arg2[2]));
var x88: u64 = undefined;
var x89: u64 = undefined;
fiatP256MulxU64(&x88, &x89, x2, (arg2[1]));
var x90: u64 = undefined;
var x91: u64 = undefined;
fiatP256MulxU64(&x90, &x91, x2, (arg2[0]));
var x92: u64 = undefined;
var x93: u1 = undefined;
fiatP256AddcarryxU64(&x92, &x93, 0x0, x91, x88);
var x94: u64 = undefined;
var x95: u1 = undefined;
fiatP256AddcarryxU64(&x94, &x95, x93, x89, x86);
var x96: u64 = undefined;
var x97: u1 = undefined;
fiatP256AddcarryxU64(&x96, &x97, x95, x87, x84);
const x98: u64 = (@intCast(u64, x97) + x85);
var x99: u64 = undefined;
var x100: u1 = undefined;
fiatP256AddcarryxU64(&x99, &x100, 0x0, x75, x90);
var x101: u64 = undefined;
var x102: u1 = undefined;
fiatP256AddcarryxU64(&x101, &x102, x100, x77, x92);
var x103: u64 = undefined;
var x104: u1 = undefined;
fiatP256AddcarryxU64(&x103, &x104, x102, x79, x94);
var x105: u64 = undefined;
var x106: u1 = undefined;
fiatP256AddcarryxU64(&x105, &x106, x104, x81, x96);
var x107: u64 = undefined;
var x108: u1 = undefined;
fiatP256AddcarryxU64(&x107, &x108, x106, x83, x98);
var x109: u64 = undefined;
var x110: u64 = undefined;
fiatP256MulxU64(&x109, &x110, x99, 0xffffffff00000001);
var x111: u64 = undefined;
var x112: u64 = undefined;
fiatP256MulxU64(&x111, &x112, x99, 0xffffffff);
var x113: u64 = undefined;
var x114: u64 = undefined;
fiatP256MulxU64(&x113, &x114, x99, 0xffffffffffffffff);
var x115: u64 = undefined;
var x116: u1 = undefined;
fiatP256AddcarryxU64(&x115, &x116, 0x0, x114, x111);
const x117: u64 = (@intCast(u64, x116) + x112);
var x118: u64 = undefined;
var x119: u1 = undefined;
fiatP256AddcarryxU64(&x118, &x119, 0x0, x99, x113);
var x120: u64 = undefined;
var x121: u1 = undefined;
fiatP256AddcarryxU64(&x120, &x121, x119, x101, x115);
var x122: u64 = undefined;
var x123: u1 = undefined;
fiatP256AddcarryxU64(&x122, &x123, x121, x103, x117);
var x124: u64 = undefined;
var x125: u1 = undefined;
fiatP256AddcarryxU64(&x124, &x125, x123, x105, x109);
var x126: u64 = undefined;
var x127: u1 = undefined;
fiatP256AddcarryxU64(&x126, &x127, x125, x107, x110);
const x128: u64 = (@intCast(u64, x127) + @intCast(u64, x108));
var x129: u64 = undefined;
var x130: u64 = undefined;
fiatP256MulxU64(&x129, &x130, x3, (arg2[3]));
var x131: u64 = undefined;
var x132: u64 = undefined;
fiatP256MulxU64(&x131, &x132, x3, (arg2[2]));
var x133: u64 = undefined;
var x134: u64 = undefined;
fiatP256MulxU64(&x133, &x134, x3, (arg2[1]));
var x135: u64 = undefined;
var x136: u64 = undefined;
fiatP256MulxU64(&x135, &x136, x3, (arg2[0]));
var x137: u64 = undefined;
var x138: u1 = undefined;
fiatP256AddcarryxU64(&x137, &x138, 0x0, x136, x133);
var x139: u64 = undefined;
var x140: u1 = undefined;
fiatP256AddcarryxU64(&x139, &x140, x138, x134, x131);
var x141: u64 = undefined;
var x142: u1 = undefined;
fiatP256AddcarryxU64(&x141, &x142, x140, x132, x129);
const x143: u64 = (@intCast(u64, x142) + x130);
var x144: u64 = undefined;
var x145: u1 = undefined;
fiatP256AddcarryxU64(&x144, &x145, 0x0, x120, x135);
var x146: u64 = undefined;
var x147: u1 = undefined;
fiatP256AddcarryxU64(&x146, &x147, x145, x122, x137);
var x148: u64 = undefined;
var x149: u1 = undefined;
fiatP256AddcarryxU64(&x148, &x149, x147, x124, x139);
var x150: u64 = undefined;
var x151: u1 = undefined;
fiatP256AddcarryxU64(&x150, &x151, x149, x126, x141);
var x152: u64 = undefined;
var x153: u1 = undefined;
fiatP256AddcarryxU64(&x152, &x153, x151, x128, x143);
var x154: u64 = undefined;
var x155: u64 = undefined;
fiatP256MulxU64(&x154, &x155, x144, 0xffffffff00000001);
var x156: u64 = undefined;
var x157: u64 = undefined;
fiatP256MulxU64(&x156, &x157, x144, 0xffffffff);
var x158: u64 = undefined;
var x159: u64 = undefined;
fiatP256MulxU64(&x158, &x159, x144, 0xffffffffffffffff);
var x160: u64 = undefined;
var x161: u1 = undefined;
fiatP256AddcarryxU64(&x160, &x161, 0x0, x159, x156);
const x162: u64 = (@intCast(u64, x161) + x157);
var x163: u64 = undefined;
var x164: u1 = undefined;
fiatP256AddcarryxU64(&x163, &x164, 0x0, x144, x158);
var x165: u64 = undefined;
var x166: u1 = undefined;
fiatP256AddcarryxU64(&x165, &x166, x164, x146, x160);
var x167: u64 = undefined;
var x168: u1 = undefined;
fiatP256AddcarryxU64(&x167, &x168, x166, x148, x162);
var x169: u64 = undefined;
var x170: u1 = undefined;
fiatP256AddcarryxU64(&x169, &x170, x168, x150, x154);
var x171: u64 = undefined;
var x172: u1 = undefined;
fiatP256AddcarryxU64(&x171, &x172, x170, x152, x155);
const x173: u64 = (@intCast(u64, x172) + @intCast(u64, x153));
var x174: u64 = undefined;
var x175: u1 = undefined;
fiatP256SubborrowxU64(&x174, &x175, 0x0, x165, 0xffffffffffffffff);
var x176: u64 = undefined;
var x177: u1 = undefined;
fiatP256SubborrowxU64(&x176, &x177, x175, x167, 0xffffffff);
var x178: u64 = undefined;
var x179: u1 = undefined;
fiatP256SubborrowxU64(&x178, &x179, x177, x169, @intCast(u64, 0x0));
var x180: u64 = undefined;
var x181: u1 = undefined;
fiatP256SubborrowxU64(&x180, &x181, x179, x171, 0xffffffff00000001);
var x182: u64 = undefined;
var x183: u1 = undefined;
fiatP256SubborrowxU64(&x182, &x183, x181, x173, @intCast(u64, 0x0));
var x184: u64 = undefined;
fiatP256CmovznzU64(&x184, x183, x174, x165);
var x185: u64 = undefined;
fiatP256CmovznzU64(&x185, x183, x176, x167);
var x186: u64 = undefined;
fiatP256CmovznzU64(&x186, x183, x178, x169);
var x187: u64 = undefined;
fiatP256CmovznzU64(&x187, x183, x180, x171);
out1[0] = x184;
out1[1] = x185;
out1[2] = x186;
out1[3] = x187;
}
/// The function fiatP256Square squares a field element in the Montgomery domain.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256Square(out1: *[4]u64, arg1: [4]u64) void {
const x1: u64 = (arg1[1]);
const x2: u64 = (arg1[2]);
const x3: u64 = (arg1[3]);
const x4: u64 = (arg1[0]);
var x5: u64 = undefined;
var x6: u64 = undefined;
fiatP256MulxU64(&x5, &x6, x4, (arg1[3]));
var x7: u64 = undefined;
var x8: u64 = undefined;
fiatP256MulxU64(&x7, &x8, x4, (arg1[2]));
var x9: u64 = undefined;
var x10: u64 = undefined;
fiatP256MulxU64(&x9, &x10, x4, (arg1[1]));
var x11: u64 = undefined;
var x12: u64 = undefined;
fiatP256MulxU64(&x11, &x12, x4, (arg1[0]));
var x13: u64 = undefined;
var x14: u1 = undefined;
fiatP256AddcarryxU64(&x13, &x14, 0x0, x12, x9);
var x15: u64 = undefined;
var x16: u1 = undefined;
fiatP256AddcarryxU64(&x15, &x16, x14, x10, x7);
var x17: u64 = undefined;
var x18: u1 = undefined;
fiatP256AddcarryxU64(&x17, &x18, x16, x8, x5);
const x19: u64 = (@intCast(u64, x18) + x6);
var x20: u64 = undefined;
var x21: u64 = undefined;
fiatP256MulxU64(&x20, &x21, x11, 0xffffffff00000001);
var x22: u64 = undefined;
var x23: u64 = undefined;
fiatP256MulxU64(&x22, &x23, x11, 0xffffffff);
var x24: u64 = undefined;
var x25: u64 = undefined;
fiatP256MulxU64(&x24, &x25, x11, 0xffffffffffffffff);
var x26: u64 = undefined;
var x27: u1 = undefined;
fiatP256AddcarryxU64(&x26, &x27, 0x0, x25, x22);
const x28: u64 = (@intCast(u64, x27) + x23);
var x29: u64 = undefined;
var x30: u1 = undefined;
fiatP256AddcarryxU64(&x29, &x30, 0x0, x11, x24);
var x31: u64 = undefined;
var x32: u1 = undefined;
fiatP256AddcarryxU64(&x31, &x32, x30, x13, x26);
var x33: u64 = undefined;
var x34: u1 = undefined;
fiatP256AddcarryxU64(&x33, &x34, x32, x15, x28);
var x35: u64 = undefined;
var x36: u1 = undefined;
fiatP256AddcarryxU64(&x35, &x36, x34, x17, x20);
var x37: u64 = undefined;
var x38: u1 = undefined;
fiatP256AddcarryxU64(&x37, &x38, x36, x19, x21);
var x39: u64 = undefined;
var x40: u64 = undefined;
fiatP256MulxU64(&x39, &x40, x1, (arg1[3]));
var x41: u64 = undefined;
var x42: u64 = undefined;
fiatP256MulxU64(&x41, &x42, x1, (arg1[2]));
var x43: u64 = undefined;
var x44: u64 = undefined;
fiatP256MulxU64(&x43, &x44, x1, (arg1[1]));
var x45: u64 = undefined;
var x46: u64 = undefined;
fiatP256MulxU64(&x45, &x46, x1, (arg1[0]));
var x47: u64 = undefined;
var x48: u1 = undefined;
fiatP256AddcarryxU64(&x47, &x48, 0x0, x46, x43);
var x49: u64 = undefined;
var x50: u1 = undefined;
fiatP256AddcarryxU64(&x49, &x50, x48, x44, x41);
var x51: u64 = undefined;
var x52: u1 = undefined;
fiatP256AddcarryxU64(&x51, &x52, x50, x42, x39);
const x53: u64 = (@intCast(u64, x52) + x40);
var x54: u64 = undefined;
var x55: u1 = undefined;
fiatP256AddcarryxU64(&x54, &x55, 0x0, x31, x45);
var x56: u64 = undefined;
var x57: u1 = undefined;
fiatP256AddcarryxU64(&x56, &x57, x55, x33, x47);
var x58: u64 = undefined;
var x59: u1 = undefined;
fiatP256AddcarryxU64(&x58, &x59, x57, x35, x49);
var x60: u64 = undefined;
var x61: u1 = undefined;
fiatP256AddcarryxU64(&x60, &x61, x59, x37, x51);
var x62: u64 = undefined;
var x63: u1 = undefined;
fiatP256AddcarryxU64(&x62, &x63, x61, @intCast(u64, x38), x53);
var x64: u64 = undefined;
var x65: u64 = undefined;
fiatP256MulxU64(&x64, &x65, x54, 0xffffffff00000001);
var x66: u64 = undefined;
var x67: u64 = undefined;
fiatP256MulxU64(&x66, &x67, x54, 0xffffffff);
var x68: u64 = undefined;
var x69: u64 = undefined;
fiatP256MulxU64(&x68, &x69, x54, 0xffffffffffffffff);
var x70: u64 = undefined;
var x71: u1 = undefined;
fiatP256AddcarryxU64(&x70, &x71, 0x0, x69, x66);
const x72: u64 = (@intCast(u64, x71) + x67);
var x73: u64 = undefined;
var x74: u1 = undefined;
fiatP256AddcarryxU64(&x73, &x74, 0x0, x54, x68);
var x75: u64 = undefined;
var x76: u1 = undefined;
fiatP256AddcarryxU64(&x75, &x76, x74, x56, x70);
var x77: u64 = undefined;
var x78: u1 = undefined;
fiatP256AddcarryxU64(&x77, &x78, x76, x58, x72);
var x79: u64 = undefined;
var x80: u1 = undefined;
fiatP256AddcarryxU64(&x79, &x80, x78, x60, x64);
var x81: u64 = undefined;
var x82: u1 = undefined;
fiatP256AddcarryxU64(&x81, &x82, x80, x62, x65);
const x83: u64 = (@intCast(u64, x82) + @intCast(u64, x63));
var x84: u64 = undefined;
var x85: u64 = undefined;
fiatP256MulxU64(&x84, &x85, x2, (arg1[3]));
var x86: u64 = undefined;
var x87: u64 = undefined;
fiatP256MulxU64(&x86, &x87, x2, (arg1[2]));
var x88: u64 = undefined;
var x89: u64 = undefined;
fiatP256MulxU64(&x88, &x89, x2, (arg1[1]));
var x90: u64 = undefined;
var x91: u64 = undefined;
fiatP256MulxU64(&x90, &x91, x2, (arg1[0]));
var x92: u64 = undefined;
var x93: u1 = undefined;
fiatP256AddcarryxU64(&x92, &x93, 0x0, x91, x88);
var x94: u64 = undefined;
var x95: u1 = undefined;
fiatP256AddcarryxU64(&x94, &x95, x93, x89, x86);
var x96: u64 = undefined;
var x97: u1 = undefined;
fiatP256AddcarryxU64(&x96, &x97, x95, x87, x84);
const x98: u64 = (@intCast(u64, x97) + x85);
var x99: u64 = undefined;
var x100: u1 = undefined;
fiatP256AddcarryxU64(&x99, &x100, 0x0, x75, x90);
var x101: u64 = undefined;
var x102: u1 = undefined;
fiatP256AddcarryxU64(&x101, &x102, x100, x77, x92);
var x103: u64 = undefined;
var x104: u1 = undefined;
fiatP256AddcarryxU64(&x103, &x104, x102, x79, x94);
var x105: u64 = undefined;
var x106: u1 = undefined;
fiatP256AddcarryxU64(&x105, &x106, x104, x81, x96);
var x107: u64 = undefined;
var x108: u1 = undefined;
fiatP256AddcarryxU64(&x107, &x108, x106, x83, x98);
var x109: u64 = undefined;
var x110: u64 = undefined;
fiatP256MulxU64(&x109, &x110, x99, 0xffffffff00000001);
var x111: u64 = undefined;
var x112: u64 = undefined;
fiatP256MulxU64(&x111, &x112, x99, 0xffffffff);
var x113: u64 = undefined;
var x114: u64 = undefined;
fiatP256MulxU64(&x113, &x114, x99, 0xffffffffffffffff);
var x115: u64 = undefined;
var x116: u1 = undefined;
fiatP256AddcarryxU64(&x115, &x116, 0x0, x114, x111);
const x117: u64 = (@intCast(u64, x116) + x112);
var x118: u64 = undefined;
var x119: u1 = undefined;
fiatP256AddcarryxU64(&x118, &x119, 0x0, x99, x113);
var x120: u64 = undefined;
var x121: u1 = undefined;
fiatP256AddcarryxU64(&x120, &x121, x119, x101, x115);
var x122: u64 = undefined;
var x123: u1 = undefined;
fiatP256AddcarryxU64(&x122, &x123, x121, x103, x117);
var x124: u64 = undefined;
var x125: u1 = undefined;
fiatP256AddcarryxU64(&x124, &x125, x123, x105, x109);
var x126: u64 = undefined;
var x127: u1 = undefined;
fiatP256AddcarryxU64(&x126, &x127, x125, x107, x110);
const x128: u64 = (@intCast(u64, x127) + @intCast(u64, x108));
var x129: u64 = undefined;
var x130: u64 = undefined;
fiatP256MulxU64(&x129, &x130, x3, (arg1[3]));
var x131: u64 = undefined;
var x132: u64 = undefined;
fiatP256MulxU64(&x131, &x132, x3, (arg1[2]));
var x133: u64 = undefined;
var x134: u64 = undefined;
fiatP256MulxU64(&x133, &x134, x3, (arg1[1]));
var x135: u64 = undefined;
var x136: u64 = undefined;
fiatP256MulxU64(&x135, &x136, x3, (arg1[0]));
var x137: u64 = undefined;
var x138: u1 = undefined;
fiatP256AddcarryxU64(&x137, &x138, 0x0, x136, x133);
var x139: u64 = undefined;
var x140: u1 = undefined;
fiatP256AddcarryxU64(&x139, &x140, x138, x134, x131);
var x141: u64 = undefined;
var x142: u1 = undefined;
fiatP256AddcarryxU64(&x141, &x142, x140, x132, x129);
const x143: u64 = (@intCast(u64, x142) + x130);
var x144: u64 = undefined;
var x145: u1 = undefined;
fiatP256AddcarryxU64(&x144, &x145, 0x0, x120, x135);
var x146: u64 = undefined;
var x147: u1 = undefined;
fiatP256AddcarryxU64(&x146, &x147, x145, x122, x137);
var x148: u64 = undefined;
var x149: u1 = undefined;
fiatP256AddcarryxU64(&x148, &x149, x147, x124, x139);
var x150: u64 = undefined;
var x151: u1 = undefined;
fiatP256AddcarryxU64(&x150, &x151, x149, x126, x141);
var x152: u64 = undefined;
var x153: u1 = undefined;
fiatP256AddcarryxU64(&x152, &x153, x151, x128, x143);
var x154: u64 = undefined;
var x155: u64 = undefined;
fiatP256MulxU64(&x154, &x155, x144, 0xffffffff00000001);
var x156: u64 = undefined;
var x157: u64 = undefined;
fiatP256MulxU64(&x156, &x157, x144, 0xffffffff);
var x158: u64 = undefined;
var x159: u64 = undefined;
fiatP256MulxU64(&x158, &x159, x144, 0xffffffffffffffff);
var x160: u64 = undefined;
var x161: u1 = undefined;
fiatP256AddcarryxU64(&x160, &x161, 0x0, x159, x156);
const x162: u64 = (@intCast(u64, x161) + x157);
var x163: u64 = undefined;
var x164: u1 = undefined;
fiatP256AddcarryxU64(&x163, &x164, 0x0, x144, x158);
var x165: u64 = undefined;
var x166: u1 = undefined;
fiatP256AddcarryxU64(&x165, &x166, x164, x146, x160);
var x167: u64 = undefined;
var x168: u1 = undefined;
fiatP256AddcarryxU64(&x167, &x168, x166, x148, x162);
var x169: u64 = undefined;
var x170: u1 = undefined;
fiatP256AddcarryxU64(&x169, &x170, x168, x150, x154);
var x171: u64 = undefined;
var x172: u1 = undefined;
fiatP256AddcarryxU64(&x171, &x172, x170, x152, x155);
const x173: u64 = (@intCast(u64, x172) + @intCast(u64, x153));
var x174: u64 = undefined;
var x175: u1 = undefined;
fiatP256SubborrowxU64(&x174, &x175, 0x0, x165, 0xffffffffffffffff);
var x176: u64 = undefined;
var x177: u1 = undefined;
fiatP256SubborrowxU64(&x176, &x177, x175, x167, 0xffffffff);
var x178: u64 = undefined;
var x179: u1 = undefined;
fiatP256SubborrowxU64(&x178, &x179, x177, x169, @intCast(u64, 0x0));
var x180: u64 = undefined;
var x181: u1 = undefined;
fiatP256SubborrowxU64(&x180, &x181, x179, x171, 0xffffffff00000001);
var x182: u64 = undefined;
var x183: u1 = undefined;
fiatP256SubborrowxU64(&x182, &x183, x181, x173, @intCast(u64, 0x0));
var x184: u64 = undefined;
fiatP256CmovznzU64(&x184, x183, x174, x165);
var x185: u64 = undefined;
fiatP256CmovznzU64(&x185, x183, x176, x167);
var x186: u64 = undefined;
fiatP256CmovznzU64(&x186, x183, x178, x169);
var x187: u64 = undefined;
fiatP256CmovznzU64(&x187, x183, x180, x171);
out1[0] = x184;
out1[1] = x185;
out1[2] = x186;
out1[3] = x187;
}
/// The function fiatP256Add adds two field elements in the Montgomery domain.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// 0 ≤ eval arg2 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256Add(out1: *[4]u64, arg1: [4]u64, arg2: [4]u64) void {
var x1: u64 = undefined;
var x2: u1 = undefined;
fiatP256AddcarryxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0]));
var x3: u64 = undefined;
var x4: u1 = undefined;
fiatP256AddcarryxU64(&x3, &x4, x2, (arg1[1]), (arg2[1]));
var x5: u64 = undefined;
var x6: u1 = undefined;
fiatP256AddcarryxU64(&x5, &x6, x4, (arg1[2]), (arg2[2]));
var x7: u64 = undefined;
var x8: u1 = undefined;
fiatP256AddcarryxU64(&x7, &x8, x6, (arg1[3]), (arg2[3]));
var x9: u64 = undefined;
var x10: u1 = undefined;
fiatP256SubborrowxU64(&x9, &x10, 0x0, x1, 0xffffffffffffffff);
var x11: u64 = undefined;
var x12: u1 = undefined;
fiatP256SubborrowxU64(&x11, &x12, x10, x3, 0xffffffff);
var x13: u64 = undefined;
var x14: u1 = undefined;
fiatP256SubborrowxU64(&x13, &x14, x12, x5, @intCast(u64, 0x0));
var x15: u64 = undefined;
var x16: u1 = undefined;
fiatP256SubborrowxU64(&x15, &x16, x14, x7, 0xffffffff00000001);
var x17: u64 = undefined;
var x18: u1 = undefined;
fiatP256SubborrowxU64(&x17, &x18, x16, @intCast(u64, x8), @intCast(u64, 0x0));
var x19: u64 = undefined;
fiatP256CmovznzU64(&x19, x18, x9, x1);
var x20: u64 = undefined;
fiatP256CmovznzU64(&x20, x18, x11, x3);
var x21: u64 = undefined;
fiatP256CmovznzU64(&x21, x18, x13, x5);
var x22: u64 = undefined;
fiatP256CmovznzU64(&x22, x18, x15, x7);
out1[0] = x19;
out1[1] = x20;
out1[2] = x21;
out1[3] = x22;
}
/// The function fiatP256Sub subtracts two field elements in the Montgomery domain.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// 0 ≤ eval arg2 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256Sub(out1: *[4]u64, arg1: [4]u64, arg2: [4]u64) void {
var x1: u64 = undefined;
var x2: u1 = undefined;
fiatP256SubborrowxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0]));
var x3: u64 = undefined;
var x4: u1 = undefined;
fiatP256SubborrowxU64(&x3, &x4, x2, (arg1[1]), (arg2[1]));
var x5: u64 = undefined;
var x6: u1 = undefined;
fiatP256SubborrowxU64(&x5, &x6, x4, (arg1[2]), (arg2[2]));
var x7: u64 = undefined;
var x8: u1 = undefined;
fiatP256SubborrowxU64(&x7, &x8, x6, (arg1[3]), (arg2[3]));
var x9: u64 = undefined;
fiatP256CmovznzU64(&x9, x8, @intCast(u64, 0x0), 0xffffffffffffffff);
var x10: u64 = undefined;
var x11: u1 = undefined;
fiatP256AddcarryxU64(&x10, &x11, 0x0, x1, x9);
var x12: u64 = undefined;
var x13: u1 = undefined;
fiatP256AddcarryxU64(&x12, &x13, x11, x3, (x9 & 0xffffffff));
var x14: u64 = undefined;
var x15: u1 = undefined;
fiatP256AddcarryxU64(&x14, &x15, x13, x5, @intCast(u64, 0x0));
var x16: u64 = undefined;
var x17: u1 = undefined;
fiatP256AddcarryxU64(&x16, &x17, x15, x7, (x9 & 0xffffffff00000001));
out1[0] = x10;
out1[1] = x12;
out1[2] = x14;
out1[3] = x16;
}
/// The function fiatP256Opp negates a field element in the Montgomery domain.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256Opp(out1: *[4]u64, arg1: [4]u64) void {
var x1: u64 = undefined;
var x2: u1 = undefined;
fiatP256SubborrowxU64(&x1, &x2, 0x0, @intCast(u64, 0x0), (arg1[0]));
var x3: u64 = undefined;
var x4: u1 = undefined;
fiatP256SubborrowxU64(&x3, &x4, x2, @intCast(u64, 0x0), (arg1[1]));
var x5: u64 = undefined;
var x6: u1 = undefined;
fiatP256SubborrowxU64(&x5, &x6, x4, @intCast(u64, 0x0), (arg1[2]));
var x7: u64 = undefined;
var x8: u1 = undefined;
fiatP256SubborrowxU64(&x7, &x8, x6, @intCast(u64, 0x0), (arg1[3]));
var x9: u64 = undefined;
fiatP256CmovznzU64(&x9, x8, @intCast(u64, 0x0), 0xffffffffffffffff);
var x10: u64 = undefined;
var x11: u1 = undefined;
fiatP256AddcarryxU64(&x10, &x11, 0x0, x1, x9);
var x12: u64 = undefined;
var x13: u1 = undefined;
fiatP256AddcarryxU64(&x12, &x13, x11, x3, (x9 & 0xffffffff));
var x14: u64 = undefined;
var x15: u1 = undefined;
fiatP256AddcarryxU64(&x14, &x15, x13, x5, @intCast(u64, 0x0));
var x16: u64 = undefined;
var x17: u1 = undefined;
fiatP256AddcarryxU64(&x16, &x17, x15, x7, (x9 & 0xffffffff00000001));
out1[0] = x10;
out1[1] = x12;
out1[2] = x14;
out1[3] = x16;
}
/// The function fiatP256FromMontgomery translates a field element out of the Montgomery domain.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256FromMontgomery(out1: *[4]u64, arg1: [4]u64) void {
const x1: u64 = (arg1[0]);
var x2: u64 = undefined;
var x3: u64 = undefined;
fiatP256MulxU64(&x2, &x3, x1, 0xffffffff00000001);
var x4: u64 = undefined;
var x5: u64 = undefined;
fiatP256MulxU64(&x4, &x5, x1, 0xffffffff);
var x6: u64 = undefined;
var x7: u64 = undefined;
fiatP256MulxU64(&x6, &x7, x1, 0xffffffffffffffff);
var x8: u64 = undefined;
var x9: u1 = undefined;
fiatP256AddcarryxU64(&x8, &x9, 0x0, x7, x4);
var x10: u64 = undefined;
var x11: u1 = undefined;
fiatP256AddcarryxU64(&x10, &x11, 0x0, x1, x6);
var x12: u64 = undefined;
var x13: u1 = undefined;
fiatP256AddcarryxU64(&x12, &x13, x11, @intCast(u64, 0x0), x8);
var x14: u64 = undefined;
var x15: u1 = undefined;
fiatP256AddcarryxU64(&x14, &x15, 0x0, x12, (arg1[1]));
var x16: u64 = undefined;
var x17: u64 = undefined;
fiatP256MulxU64(&x16, &x17, x14, 0xffffffff00000001);
var x18: u64 = undefined;
var x19: u64 = undefined;
fiatP256MulxU64(&x18, &x19, x14, 0xffffffff);
var x20: u64 = undefined;
var x21: u64 = undefined;
fiatP256MulxU64(&x20, &x21, x14, 0xffffffffffffffff);
var x22: u64 = undefined;
var x23: u1 = undefined;
fiatP256AddcarryxU64(&x22, &x23, 0x0, x21, x18);
var x24: u64 = undefined;
var x25: u1 = undefined;
fiatP256AddcarryxU64(&x24, &x25, 0x0, x14, x20);
var x26: u64 = undefined;
var x27: u1 = undefined;
fiatP256AddcarryxU64(&x26, &x27, x25, (@intCast(u64, x15) + (@intCast(u64, x13) + (@intCast(u64, x9) + x5))), x22);
var x28: u64 = undefined;
var x29: u1 = undefined;
fiatP256AddcarryxU64(&x28, &x29, x27, x2, (@intCast(u64, x23) + x19));
var x30: u64 = undefined;
var x31: u1 = undefined;
fiatP256AddcarryxU64(&x30, &x31, x29, x3, x16);
var x32: u64 = undefined;
var x33: u1 = undefined;
fiatP256AddcarryxU64(&x32, &x33, 0x0, x26, (arg1[2]));
var x34: u64 = undefined;
var x35: u1 = undefined;
fiatP256AddcarryxU64(&x34, &x35, x33, x28, @intCast(u64, 0x0));
var x36: u64 = undefined;
var x37: u1 = undefined;
fiatP256AddcarryxU64(&x36, &x37, x35, x30, @intCast(u64, 0x0));
var x38: u64 = undefined;
var x39: u64 = undefined;
fiatP256MulxU64(&x38, &x39, x32, 0xffffffff00000001);
var x40: u64 = undefined;
var x41: u64 = undefined;
fiatP256MulxU64(&x40, &x41, x32, 0xffffffff);
var x42: u64 = undefined;
var x43: u64 = undefined;
fiatP256MulxU64(&x42, &x43, x32, 0xffffffffffffffff);
var x44: u64 = undefined;
var x45: u1 = undefined;
fiatP256AddcarryxU64(&x44, &x45, 0x0, x43, x40);
var x46: u64 = undefined;
var x47: u1 = undefined;
fiatP256AddcarryxU64(&x46, &x47, 0x0, x32, x42);
var x48: u64 = undefined;
var x49: u1 = undefined;
fiatP256AddcarryxU64(&x48, &x49, x47, x34, x44);
var x50: u64 = undefined;
var x51: u1 = undefined;
fiatP256AddcarryxU64(&x50, &x51, x49, x36, (@intCast(u64, x45) + x41));
var x52: u64 = undefined;
var x53: u1 = undefined;
fiatP256AddcarryxU64(&x52, &x53, x51, (@intCast(u64, x37) + (@intCast(u64, x31) + x17)), x38);
var x54: u64 = undefined;
var x55: u1 = undefined;
fiatP256AddcarryxU64(&x54, &x55, 0x0, x48, (arg1[3]));
var x56: u64 = undefined;
var x57: u1 = undefined;
fiatP256AddcarryxU64(&x56, &x57, x55, x50, @intCast(u64, 0x0));
var x58: u64 = undefined;
var x59: u1 = undefined;
fiatP256AddcarryxU64(&x58, &x59, x57, x52, @intCast(u64, 0x0));
var x60: u64 = undefined;
var x61: u64 = undefined;
fiatP256MulxU64(&x60, &x61, x54, 0xffffffff00000001);
var x62: u64 = undefined;
var x63: u64 = undefined;
fiatP256MulxU64(&x62, &x63, x54, 0xffffffff);
var x64: u64 = undefined;
var x65: u64 = undefined;
fiatP256MulxU64(&x64, &x65, x54, 0xffffffffffffffff);
var x66: u64 = undefined;
var x67: u1 = undefined;
fiatP256AddcarryxU64(&x66, &x67, 0x0, x65, x62);
var x68: u64 = undefined;
var x69: u1 = undefined;
fiatP256AddcarryxU64(&x68, &x69, 0x0, x54, x64);
var x70: u64 = undefined;
var x71: u1 = undefined;
fiatP256AddcarryxU64(&x70, &x71, x69, x56, x66);
var x72: u64 = undefined;
var x73: u1 = undefined;
fiatP256AddcarryxU64(&x72, &x73, x71, x58, (@intCast(u64, x67) + x63));
var x74: u64 = undefined;
var x75: u1 = undefined;
fiatP256AddcarryxU64(&x74, &x75, x73, (@intCast(u64, x59) + (@intCast(u64, x53) + x39)), x60);
const x76: u64 = (@intCast(u64, x75) + x61);
var x77: u64 = undefined;
var x78: u1 = undefined;
fiatP256SubborrowxU64(&x77, &x78, 0x0, x70, 0xffffffffffffffff);
var x79: u64 = undefined;
var x80: u1 = undefined;
fiatP256SubborrowxU64(&x79, &x80, x78, x72, 0xffffffff);
var x81: u64 = undefined;
var x82: u1 = undefined;
fiatP256SubborrowxU64(&x81, &x82, x80, x74, @intCast(u64, 0x0));
var x83: u64 = undefined;
var x84: u1 = undefined;
fiatP256SubborrowxU64(&x83, &x84, x82, x76, 0xffffffff00000001);
var x85: u64 = undefined;
var x86: u1 = undefined;
fiatP256SubborrowxU64(&x85, &x86, x84, @intCast(u64, 0x0), @intCast(u64, 0x0));
var x87: u64 = undefined;
fiatP256CmovznzU64(&x87, x86, x77, x70);
var x88: u64 = undefined;
fiatP256CmovznzU64(&x88, x86, x79, x72);
var x89: u64 = undefined;
fiatP256CmovznzU64(&x89, x86, x81, x74);
var x90: u64 = undefined;
fiatP256CmovznzU64(&x90, x86, x83, x76);
out1[0] = x87;
out1[1] = x88;
out1[2] = x89;
out1[3] = x90;
}
/// The function fiatP256ToMontgomery translates a field element into the Montgomery domain.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = eval arg1 mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256ToMontgomery(out1: *[4]u64, arg1: [4]u64) void {
const x1: u64 = (arg1[1]);
const x2: u64 = (arg1[2]);
const x3: u64 = (arg1[3]);
const x4: u64 = (arg1[0]);
var x5: u64 = undefined;
var x6: u64 = undefined;
fiatP256MulxU64(&x5, &x6, x4, 0x4fffffffd);
var x7: u64 = undefined;
var x8: u64 = undefined;
fiatP256MulxU64(&x7, &x8, x4, 0xfffffffffffffffe);
var x9: u64 = undefined;
var x10: u64 = undefined;
fiatP256MulxU64(&x9, &x10, x4, 0xfffffffbffffffff);
var x11: u64 = undefined;
var x12: u64 = undefined;
fiatP256MulxU64(&x11, &x12, x4, 0x3);
var x13: u64 = undefined;
var x14: u1 = undefined;
fiatP256AddcarryxU64(&x13, &x14, 0x0, x12, x9);
var x15: u64 = undefined;
var x16: u1 = undefined;
fiatP256AddcarryxU64(&x15, &x16, x14, x10, x7);
var x17: u64 = undefined;
var x18: u1 = undefined;
fiatP256AddcarryxU64(&x17, &x18, x16, x8, x5);
var x19: u64 = undefined;
var x20: u64 = undefined;
fiatP256MulxU64(&x19, &x20, x11, 0xffffffff00000001);
var x21: u64 = undefined;
var x22: u64 = undefined;
fiatP256MulxU64(&x21, &x22, x11, 0xffffffff);
var x23: u64 = undefined;
var x24: u64 = undefined;
fiatP256MulxU64(&x23, &x24, x11, 0xffffffffffffffff);
var x25: u64 = undefined;
var x26: u1 = undefined;
fiatP256AddcarryxU64(&x25, &x26, 0x0, x24, x21);
var x27: u64 = undefined;
var x28: u1 = undefined;
fiatP256AddcarryxU64(&x27, &x28, 0x0, x11, x23);
var x29: u64 = undefined;
var x30: u1 = undefined;
fiatP256AddcarryxU64(&x29, &x30, x28, x13, x25);
var x31: u64 = undefined;
var x32: u1 = undefined;
fiatP256AddcarryxU64(&x31, &x32, x30, x15, (@intCast(u64, x26) + x22));
var x33: u64 = undefined;
var x34: u1 = undefined;
fiatP256AddcarryxU64(&x33, &x34, x32, x17, x19);
var x35: u64 = undefined;
var x36: u1 = undefined;
fiatP256AddcarryxU64(&x35, &x36, x34, (@intCast(u64, x18) + x6), x20);
var x37: u64 = undefined;
var x38: u64 = undefined;
fiatP256MulxU64(&x37, &x38, x1, 0x4fffffffd);
var x39: u64 = undefined;
var x40: u64 = undefined;
fiatP256MulxU64(&x39, &x40, x1, 0xfffffffffffffffe);
var x41: u64 = undefined;
var x42: u64 = undefined;
fiatP256MulxU64(&x41, &x42, x1, 0xfffffffbffffffff);
var x43: u64 = undefined;
var x44: u64 = undefined;
fiatP256MulxU64(&x43, &x44, x1, 0x3);
var x45: u64 = undefined;
var x46: u1 = undefined;
fiatP256AddcarryxU64(&x45, &x46, 0x0, x44, x41);
var x47: u64 = undefined;
var x48: u1 = undefined;
fiatP256AddcarryxU64(&x47, &x48, x46, x42, x39);
var x49: u64 = undefined;
var x50: u1 = undefined;
fiatP256AddcarryxU64(&x49, &x50, x48, x40, x37);
var x51: u64 = undefined;
var x52: u1 = undefined;
fiatP256AddcarryxU64(&x51, &x52, 0x0, x29, x43);
var x53: u64 = undefined;
var x54: u1 = undefined;
fiatP256AddcarryxU64(&x53, &x54, x52, x31, x45);
var x55: u64 = undefined;
var x56: u1 = undefined;
fiatP256AddcarryxU64(&x55, &x56, x54, x33, x47);
var x57: u64 = undefined;
var x58: u1 = undefined;
fiatP256AddcarryxU64(&x57, &x58, x56, x35, x49);
var x59: u64 = undefined;
var x60: u64 = undefined;
fiatP256MulxU64(&x59, &x60, x51, 0xffffffff00000001);
var x61: u64 = undefined;
var x62: u64 = undefined;
fiatP256MulxU64(&x61, &x62, x51, 0xffffffff);
var x63: u64 = undefined;
var x64: u64 = undefined;
fiatP256MulxU64(&x63, &x64, x51, 0xffffffffffffffff);
var x65: u64 = undefined;
var x66: u1 = undefined;
fiatP256AddcarryxU64(&x65, &x66, 0x0, x64, x61);
var x67: u64 = undefined;
var x68: u1 = undefined;
fiatP256AddcarryxU64(&x67, &x68, 0x0, x51, x63);
var x69: u64 = undefined;
var x70: u1 = undefined;
fiatP256AddcarryxU64(&x69, &x70, x68, x53, x65);
var x71: u64 = undefined;
var x72: u1 = undefined;
fiatP256AddcarryxU64(&x71, &x72, x70, x55, (@intCast(u64, x66) + x62));
var x73: u64 = undefined;
var x74: u1 = undefined;
fiatP256AddcarryxU64(&x73, &x74, x72, x57, x59);
var x75: u64 = undefined;
var x76: u1 = undefined;
fiatP256AddcarryxU64(&x75, &x76, x74, ((@intCast(u64, x58) + @intCast(u64, x36)) + (@intCast(u64, x50) + x38)), x60);
var x77: u64 = undefined;
var x78: u64 = undefined;
fiatP256MulxU64(&x77, &x78, x2, 0x4fffffffd);
var x79: u64 = undefined;
var x80: u64 = undefined;
fiatP256MulxU64(&x79, &x80, x2, 0xfffffffffffffffe);
var x81: u64 = undefined;
var x82: u64 = undefined;
fiatP256MulxU64(&x81, &x82, x2, 0xfffffffbffffffff);
var x83: u64 = undefined;
var x84: u64 = undefined;
fiatP256MulxU64(&x83, &x84, x2, 0x3);
var x85: u64 = undefined;
var x86: u1 = undefined;
fiatP256AddcarryxU64(&x85, &x86, 0x0, x84, x81);
var x87: u64 = undefined;
var x88: u1 = undefined;
fiatP256AddcarryxU64(&x87, &x88, x86, x82, x79);
var x89: u64 = undefined;
var x90: u1 = undefined;
fiatP256AddcarryxU64(&x89, &x90, x88, x80, x77);
var x91: u64 = undefined;
var x92: u1 = undefined;
fiatP256AddcarryxU64(&x91, &x92, 0x0, x69, x83);
var x93: u64 = undefined;
var x94: u1 = undefined;
fiatP256AddcarryxU64(&x93, &x94, x92, x71, x85);
var x95: u64 = undefined;
var x96: u1 = undefined;
fiatP256AddcarryxU64(&x95, &x96, x94, x73, x87);
var x97: u64 = undefined;
var x98: u1 = undefined;
fiatP256AddcarryxU64(&x97, &x98, x96, x75, x89);
var x99: u64 = undefined;
var x100: u64 = undefined;
fiatP256MulxU64(&x99, &x100, x91, 0xffffffff00000001);
var x101: u64 = undefined;
var x102: u64 = undefined;
fiatP256MulxU64(&x101, &x102, x91, 0xffffffff);
var x103: u64 = undefined;
var x104: u64 = undefined;
fiatP256MulxU64(&x103, &x104, x91, 0xffffffffffffffff);
var x105: u64 = undefined;
var x106: u1 = undefined;
fiatP256AddcarryxU64(&x105, &x106, 0x0, x104, x101);
var x107: u64 = undefined;
var x108: u1 = undefined;
fiatP256AddcarryxU64(&x107, &x108, 0x0, x91, x103);
var x109: u64 = undefined;
var x110: u1 = undefined;
fiatP256AddcarryxU64(&x109, &x110, x108, x93, x105);
var x111: u64 = undefined;
var x112: u1 = undefined;
fiatP256AddcarryxU64(&x111, &x112, x110, x95, (@intCast(u64, x106) + x102));
var x113: u64 = undefined;
var x114: u1 = undefined;
fiatP256AddcarryxU64(&x113, &x114, x112, x97, x99);
var x115: u64 = undefined;
var x116: u1 = undefined;
fiatP256AddcarryxU64(&x115, &x116, x114, ((@intCast(u64, x98) + @intCast(u64, x76)) + (@intCast(u64, x90) + x78)), x100);
var x117: u64 = undefined;
var x118: u64 = undefined;
fiatP256MulxU64(&x117, &x118, x3, 0x4fffffffd);
var x119: u64 = undefined;
var x120: u64 = undefined;
fiatP256MulxU64(&x119, &x120, x3, 0xfffffffffffffffe);
var x121: u64 = undefined;
var x122: u64 = undefined;
fiatP256MulxU64(&x121, &x122, x3, 0xfffffffbffffffff);
var x123: u64 = undefined;
var x124: u64 = undefined;
fiatP256MulxU64(&x123, &x124, x3, 0x3);
var x125: u64 = undefined;
var x126: u1 = undefined;
fiatP256AddcarryxU64(&x125, &x126, 0x0, x124, x121);
var x127: u64 = undefined;
var x128: u1 = undefined;
fiatP256AddcarryxU64(&x127, &x128, x126, x122, x119);
var x129: u64 = undefined;
var x130: u1 = undefined;
fiatP256AddcarryxU64(&x129, &x130, x128, x120, x117);
var x131: u64 = undefined;
var x132: u1 = undefined;
fiatP256AddcarryxU64(&x131, &x132, 0x0, x109, x123);
var x133: u64 = undefined;
var x134: u1 = undefined;
fiatP256AddcarryxU64(&x133, &x134, x132, x111, x125);
var x135: u64 = undefined;
var x136: u1 = undefined;
fiatP256AddcarryxU64(&x135, &x136, x134, x113, x127);
var x137: u64 = undefined;
var x138: u1 = undefined;
fiatP256AddcarryxU64(&x137, &x138, x136, x115, x129);
var x139: u64 = undefined;
var x140: u64 = undefined;
fiatP256MulxU64(&x139, &x140, x131, 0xffffffff00000001);
var x141: u64 = undefined;
var x142: u64 = undefined;
fiatP256MulxU64(&x141, &x142, x131, 0xffffffff);
var x143: u64 = undefined;
var x144: u64 = undefined;
fiatP256MulxU64(&x143, &x144, x131, 0xffffffffffffffff);
var x145: u64 = undefined;
var x146: u1 = undefined;
fiatP256AddcarryxU64(&x145, &x146, 0x0, x144, x141);
var x147: u64 = undefined;
var x148: u1 = undefined;
fiatP256AddcarryxU64(&x147, &x148, 0x0, x131, x143);
var x149: u64 = undefined;
var x150: u1 = undefined;
fiatP256AddcarryxU64(&x149, &x150, x148, x133, x145);
var x151: u64 = undefined;
var x152: u1 = undefined;
fiatP256AddcarryxU64(&x151, &x152, x150, x135, (@intCast(u64, x146) + x142));
var x153: u64 = undefined;
var x154: u1 = undefined;
fiatP256AddcarryxU64(&x153, &x154, x152, x137, x139);
var x155: u64 = undefined;
var x156: u1 = undefined;
fiatP256AddcarryxU64(&x155, &x156, x154, ((@intCast(u64, x138) + @intCast(u64, x116)) + (@intCast(u64, x130) + x118)), x140);
var x157: u64 = undefined;
var x158: u1 = undefined;
fiatP256SubborrowxU64(&x157, &x158, 0x0, x149, 0xffffffffffffffff);
var x159: u64 = undefined;
var x160: u1 = undefined;
fiatP256SubborrowxU64(&x159, &x160, x158, x151, 0xffffffff);
var x161: u64 = undefined;
var x162: u1 = undefined;
fiatP256SubborrowxU64(&x161, &x162, x160, x153, @intCast(u64, 0x0));
var x163: u64 = undefined;
var x164: u1 = undefined;
fiatP256SubborrowxU64(&x163, &x164, x162, x155, 0xffffffff00000001);
var x165: u64 = undefined;
var x166: u1 = undefined;
fiatP256SubborrowxU64(&x165, &x166, x164, @intCast(u64, x156), @intCast(u64, 0x0));
var x167: u64 = undefined;
fiatP256CmovznzU64(&x167, x166, x157, x149);
var x168: u64 = undefined;
fiatP256CmovznzU64(&x168, x166, x159, x151);
var x169: u64 = undefined;
fiatP256CmovznzU64(&x169, x166, x161, x153);
var x170: u64 = undefined;
fiatP256CmovznzU64(&x170, x166, x163, x155);
out1[0] = x167;
out1[1] = x168;
out1[2] = x169;
out1[3] = x170;
}
/// The function fiatP256Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffffffffffff]
pub fn fiatP256Nonzero(out1: *u64, arg1: [4]u64) void {
const x1: u64 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3]))));
out1.* = x1;
}
/// The function fiatP256Selectznz is a multi-limb conditional select.
/// Postconditions:
/// eval out1 = (if arg1 = 0 then eval arg2 else eval arg3)
///
/// Input Bounds:
/// arg1: [0x0 ~> 0x1]
/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256Selectznz(out1: *[4]u64, arg1: u1, arg2: [4]u64, arg3: [4]u64) void {
var x1: u64 = undefined;
fiatP256CmovznzU64(&x1, arg1, (arg2[0]), (arg3[0]));
var x2: u64 = undefined;
fiatP256CmovznzU64(&x2, arg1, (arg2[1]), (arg3[1]));
var x3: u64 = undefined;
fiatP256CmovznzU64(&x3, arg1, (arg2[2]), (arg3[2]));
var x4: u64 = undefined;
fiatP256CmovznzU64(&x4, arg1, (arg2[3]), (arg3[3]));
out1[0] = x1;
out1[1] = x2;
out1[2] = x3;
out1[3] = x4;
}
/// The function fiatP256ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31]
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
pub fn fiatP256ToBytes(out1: *[32]u8, arg1: [4]u64) void {
const x1: u64 = (arg1[3]);
const x2: u64 = (arg1[2]);
const x3: u64 = (arg1[1]);
const x4: u64 = (arg1[0]);
const x5: u8 = @intCast(u8, (x4 & @intCast(u64, 0xff)));
const x6: u64 = (x4 >> 8);
const x7: u8 = @intCast(u8, (x6 & @intCast(u64, 0xff)));
const x8: u64 = (x6 >> 8);
const x9: u8 = @intCast(u8, (x8 & @intCast(u64, 0xff)));
const x10: u64 = (x8 >> 8);
const x11: u8 = @intCast(u8, (x10 & @intCast(u64, 0xff)));
const x12: u64 = (x10 >> 8);
const x13: u8 = @intCast(u8, (x12 & @intCast(u64, 0xff)));
const x14: u64 = (x12 >> 8);
const x15: u8 = @intCast(u8, (x14 & @intCast(u64, 0xff)));
const x16: u64 = (x14 >> 8);
const x17: u8 = @intCast(u8, (x16 & @intCast(u64, 0xff)));
const x18: u8 = @intCast(u8, (x16 >> 8));
const x19: u8 = @intCast(u8, (x3 & @intCast(u64, 0xff)));
const x20: u64 = (x3 >> 8);
const x21: u8 = @intCast(u8, (x20 & @intCast(u64, 0xff)));
const x22: u64 = (x20 >> 8);
const x23: u8 = @intCast(u8, (x22 & @intCast(u64, 0xff)));
const x24: u64 = (x22 >> 8);
const x25: u8 = @intCast(u8, (x24 & @intCast(u64, 0xff)));
const x26: u64 = (x24 >> 8);
const x27: u8 = @intCast(u8, (x26 & @intCast(u64, 0xff)));
const x28: u64 = (x26 >> 8);
const x29: u8 = @intCast(u8, (x28 & @intCast(u64, 0xff)));
const x30: u64 = (x28 >> 8);
const x31: u8 = @intCast(u8, (x30 & @intCast(u64, 0xff)));
const x32: u8 = @intCast(u8, (x30 >> 8));
const x33: u8 = @intCast(u8, (x2 & @intCast(u64, 0xff)));
const x34: u64 = (x2 >> 8);
const x35: u8 = @intCast(u8, (x34 & @intCast(u64, 0xff)));
const x36: u64 = (x34 >> 8);
const x37: u8 = @intCast(u8, (x36 & @intCast(u64, 0xff)));
const x38: u64 = (x36 >> 8);
const x39: u8 = @intCast(u8, (x38 & @intCast(u64, 0xff)));
const x40: u64 = (x38 >> 8);
const x41: u8 = @intCast(u8, (x40 & @intCast(u64, 0xff)));
const x42: u64 = (x40 >> 8);
const x43: u8 = @intCast(u8, (x42 & @intCast(u64, 0xff)));
const x44: u64 = (x42 >> 8);
const x45: u8 = @intCast(u8, (x44 & @intCast(u64, 0xff)));
const x46: u8 = @intCast(u8, (x44 >> 8));
const x47: u8 = @intCast(u8, (x1 & @intCast(u64, 0xff)));
const x48: u64 = (x1 >> 8);
const x49: u8 = @intCast(u8, (x48 & @intCast(u64, 0xff)));
const x50: u64 = (x48 >> 8);
const x51: u8 = @intCast(u8, (x50 & @intCast(u64, 0xff)));
const x52: u64 = (x50 >> 8);
const x53: u8 = @intCast(u8, (x52 & @intCast(u64, 0xff)));
const x54: u64 = (x52 >> 8);
const x55: u8 = @intCast(u8, (x54 & @intCast(u64, 0xff)));
const x56: u64 = (x54 >> 8);
const x57: u8 = @intCast(u8, (x56 & @intCast(u64, 0xff)));
const x58: u64 = (x56 >> 8);
const x59: u8 = @intCast(u8, (x58 & @intCast(u64, 0xff)));
const x60: u8 = @intCast(u8, (x58 >> 8));
out1[0] = x5;
out1[1] = x7;
out1[2] = x9;
out1[3] = x11;
out1[4] = x13;
out1[5] = x15;
out1[6] = x17;
out1[7] = x18;
out1[8] = x19;
out1[9] = x21;
out1[10] = x23;
out1[11] = x25;
out1[12] = x27;
out1[13] = x29;
out1[14] = x31;
out1[15] = x32;
out1[16] = x33;
out1[17] = x35;
out1[18] = x37;
out1[19] = x39;
out1[20] = x41;
out1[21] = x43;
out1[22] = x45;
out1[23] = x46;
out1[24] = x47;
out1[25] = x49;
out1[26] = x51;
out1[27] = x53;
out1[28] = x55;
out1[29] = x57;
out1[30] = x59;
out1[31] = x60;
}
/// The function fiatP256FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.
/// Preconditions:
/// 0 ≤ bytes_eval arg1 < m
/// Postconditions:
/// eval out1 mod m = bytes_eval arg1 mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256FromBytes(out1: *[4]u64, arg1: [32]u8) void {
const x1: u64 = (@intCast(u64, (arg1[31])) << 56);
const x2: u64 = (@intCast(u64, (arg1[30])) << 48);
const x3: u64 = (@intCast(u64, (arg1[29])) << 40);
const x4: u64 = (@intCast(u64, (arg1[28])) << 32);
const x5: u64 = (@intCast(u64, (arg1[27])) << 24);
const x6: u64 = (@intCast(u64, (arg1[26])) << 16);
const x7: u64 = (@intCast(u64, (arg1[25])) << 8);
const x8: u8 = (arg1[24]);
const x9: u64 = (@intCast(u64, (arg1[23])) << 56);
const x10: u64 = (@intCast(u64, (arg1[22])) << 48);
const x11: u64 = (@intCast(u64, (arg1[21])) << 40);
const x12: u64 = (@intCast(u64, (arg1[20])) << 32);
const x13: u64 = (@intCast(u64, (arg1[19])) << 24);
const x14: u64 = (@intCast(u64, (arg1[18])) << 16);
const x15: u64 = (@intCast(u64, (arg1[17])) << 8);
const x16: u8 = (arg1[16]);
const x17: u64 = (@intCast(u64, (arg1[15])) << 56);
const x18: u64 = (@intCast(u64, (arg1[14])) << 48);
const x19: u64 = (@intCast(u64, (arg1[13])) << 40);
const x20: u64 = (@intCast(u64, (arg1[12])) << 32);
const x21: u64 = (@intCast(u64, (arg1[11])) << 24);
const x22: u64 = (@intCast(u64, (arg1[10])) << 16);
const x23: u64 = (@intCast(u64, (arg1[9])) << 8);
const x24: u8 = (arg1[8]);
const x25: u64 = (@intCast(u64, (arg1[7])) << 56);
const x26: u64 = (@intCast(u64, (arg1[6])) << 48);
const x27: u64 = (@intCast(u64, (arg1[5])) << 40);
const x28: u64 = (@intCast(u64, (arg1[4])) << 32);
const x29: u64 = (@intCast(u64, (arg1[3])) << 24);
const x30: u64 = (@intCast(u64, (arg1[2])) << 16);
const x31: u64 = (@intCast(u64, (arg1[1])) << 8);
const x32: u8 = (arg1[0]);
const x33: u64 = (x31 + @intCast(u64, x32));
const x34: u64 = (x30 + x33);
const x35: u64 = (x29 + x34);
const x36: u64 = (x28 + x35);
const x37: u64 = (x27 + x36);
const x38: u64 = (x26 + x37);
const x39: u64 = (x25 + x38);
const x40: u64 = (x23 + @intCast(u64, x24));
const x41: u64 = (x22 + x40);
const x42: u64 = (x21 + x41);
const x43: u64 = (x20 + x42);
const x44: u64 = (x19 + x43);
const x45: u64 = (x18 + x44);
const x46: u64 = (x17 + x45);
const x47: u64 = (x15 + @intCast(u64, x16));
const x48: u64 = (x14 + x47);
const x49: u64 = (x13 + x48);
const x50: u64 = (x12 + x49);
const x51: u64 = (x11 + x50);
const x52: u64 = (x10 + x51);
const x53: u64 = (x9 + x52);
const x54: u64 = (x7 + @intCast(u64, x8));
const x55: u64 = (x6 + x54);
const x56: u64 = (x5 + x55);
const x57: u64 = (x4 + x56);
const x58: u64 = (x3 + x57);
const x59: u64 = (x2 + x58);
const x60: u64 = (x1 + x59);
out1[0] = x39;
out1[1] = x46;
out1[2] = x53;
out1[3] = x60;
}
/// The function fiatP256SetOne returns the field element one in the Montgomery domain.
/// Postconditions:
/// eval (from_montgomery out1) mod m = 1 mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256SetOne(out1: *[4]u64) void {
out1[0] = @intCast(u64, 0x1);
out1[1] = 0xffffffff00000000;
out1[2] = 0xffffffffffffffff;
out1[3] = 0xfffffffe;
}
/// The function fiatP256Msat returns the saturated representation of the prime modulus.
/// Postconditions:
/// twos_complement_eval out1 = m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256Msat(out1: *[5]u64) void {
out1[0] = 0xffffffffffffffff;
out1[1] = 0xffffffff;
out1[2] = @intCast(u64, 0x0);
out1[3] = 0xffffffff00000001;
out1[4] = @intCast(u64, 0x0);
}
/// The function fiatP256Divstep computes a divstep.
/// Preconditions:
/// 0 ≤ eval arg4 < m
/// 0 ≤ eval arg5 < m
/// Postconditions:
/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1)
/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2)
/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋)
/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m)
/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m)
/// 0 ≤ eval out5 < m
/// 0 ≤ eval out5 < m
/// 0 ≤ eval out2 < m
/// 0 ≤ eval out3 < m
///
/// Input Bounds:
/// arg1: [0x0 ~> 0xffffffffffffffff]
/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffffffffffff]
/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256Divstep(out1: *u64, out2: *[5]u64, out3: *[5]u64, out4: *[4]u64, out5: *[4]u64, arg1: u64, arg2: [5]u64, arg3: [5]u64, arg4: [4]u64, arg5: [4]u64) void {
var x1: u64 = undefined;
var x2: u1 = undefined;
fiatP256AddcarryxU64(&x1, &x2, 0x0, (~arg1), @intCast(u64, 0x1));
const x3: u1 = (@intCast(u1, (x1 >> 63)) & @intCast(u1, ((arg3[0]) & @intCast(u64, 0x1))));
var x4: u64 = undefined;
var x5: u1 = undefined;
fiatP256AddcarryxU64(&x4, &x5, 0x0, (~arg1), @intCast(u64, 0x1));
var x6: u64 = undefined;
fiatP256CmovznzU64(&x6, x3, arg1, x4);
var x7: u64 = undefined;
fiatP256CmovznzU64(&x7, x3, (arg2[0]), (arg3[0]));
var x8: u64 = undefined;
fiatP256CmovznzU64(&x8, x3, (arg2[1]), (arg3[1]));
var x9: u64 = undefined;
fiatP256CmovznzU64(&x9, x3, (arg2[2]), (arg3[2]));
var x10: u64 = undefined;
fiatP256CmovznzU64(&x10, x3, (arg2[3]), (arg3[3]));
var x11: u64 = undefined;
fiatP256CmovznzU64(&x11, x3, (arg2[4]), (arg3[4]));
var x12: u64 = undefined;
var x13: u1 = undefined;
fiatP256AddcarryxU64(&x12, &x13, 0x0, @intCast(u64, 0x1), (~(arg2[0])));
var x14: u64 = undefined;
var x15: u1 = undefined;
fiatP256AddcarryxU64(&x14, &x15, x13, @intCast(u64, 0x0), (~(arg2[1])));
var x16: u64 = undefined;
var x17: u1 = undefined;
fiatP256AddcarryxU64(&x16, &x17, x15, @intCast(u64, 0x0), (~(arg2[2])));
var x18: u64 = undefined;
var x19: u1 = undefined;
fiatP256AddcarryxU64(&x18, &x19, x17, @intCast(u64, 0x0), (~(arg2[3])));
var x20: u64 = undefined;
var x21: u1 = undefined;
fiatP256AddcarryxU64(&x20, &x21, x19, @intCast(u64, 0x0), (~(arg2[4])));
var x22: u64 = undefined;
fiatP256CmovznzU64(&x22, x3, (arg3[0]), x12);
var x23: u64 = undefined;
fiatP256CmovznzU64(&x23, x3, (arg3[1]), x14);
var x24: u64 = undefined;
fiatP256CmovznzU64(&x24, x3, (arg3[2]), x16);
var x25: u64 = undefined;
fiatP256CmovznzU64(&x25, x3, (arg3[3]), x18);
var x26: u64 = undefined;
fiatP256CmovznzU64(&x26, x3, (arg3[4]), x20);
var x27: u64 = undefined;
fiatP256CmovznzU64(&x27, x3, (arg4[0]), (arg5[0]));
var x28: u64 = undefined;
fiatP256CmovznzU64(&x28, x3, (arg4[1]), (arg5[1]));
var x29: u64 = undefined;
fiatP256CmovznzU64(&x29, x3, (arg4[2]), (arg5[2]));
var x30: u64 = undefined;
fiatP256CmovznzU64(&x30, x3, (arg4[3]), (arg5[3]));
var x31: u64 = undefined;
var x32: u1 = undefined;
fiatP256AddcarryxU64(&x31, &x32, 0x0, x27, x27);
var x33: u64 = undefined;
var x34: u1 = undefined;
fiatP256AddcarryxU64(&x33, &x34, x32, x28, x28);
var x35: u64 = undefined;
var x36: u1 = undefined;
fiatP256AddcarryxU64(&x35, &x36, x34, x29, x29);
var x37: u64 = undefined;
var x38: u1 = undefined;
fiatP256AddcarryxU64(&x37, &x38, x36, x30, x30);
var x39: u64 = undefined;
var x40: u1 = undefined;
fiatP256SubborrowxU64(&x39, &x40, 0x0, x31, 0xffffffffffffffff);
var x41: u64 = undefined;
var x42: u1 = undefined;
fiatP256SubborrowxU64(&x41, &x42, x40, x33, 0xffffffff);
var x43: u64 = undefined;
var x44: u1 = undefined;
fiatP256SubborrowxU64(&x43, &x44, x42, x35, @intCast(u64, 0x0));
var x45: u64 = undefined;
var x46: u1 = undefined;
fiatP256SubborrowxU64(&x45, &x46, x44, x37, 0xffffffff00000001);
var x47: u64 = undefined;
var x48: u1 = undefined;
fiatP256SubborrowxU64(&x47, &x48, x46, @intCast(u64, x38), @intCast(u64, 0x0));
const x49: u64 = (arg4[3]);
const x50: u64 = (arg4[2]);
const x51: u64 = (arg4[1]);
const x52: u64 = (arg4[0]);
var x53: u64 = undefined;
var x54: u1 = undefined;
fiatP256SubborrowxU64(&x53, &x54, 0x0, @intCast(u64, 0x0), x52);
var x55: u64 = undefined;
var x56: u1 = undefined;
fiatP256SubborrowxU64(&x55, &x56, x54, @intCast(u64, 0x0), x51);
var x57: u64 = undefined;
var x58: u1 = undefined;
fiatP256SubborrowxU64(&x57, &x58, x56, @intCast(u64, 0x0), x50);
var x59: u64 = undefined;
var x60: u1 = undefined;
fiatP256SubborrowxU64(&x59, &x60, x58, @intCast(u64, 0x0), x49);
var x61: u64 = undefined;
fiatP256CmovznzU64(&x61, x60, @intCast(u64, 0x0), 0xffffffffffffffff);
var x62: u64 = undefined;
var x63: u1 = undefined;
fiatP256AddcarryxU64(&x62, &x63, 0x0, x53, x61);
var x64: u64 = undefined;
var x65: u1 = undefined;
fiatP256AddcarryxU64(&x64, &x65, x63, x55, (x61 & 0xffffffff));
var x66: u64 = undefined;
var x67: u1 = undefined;
fiatP256AddcarryxU64(&x66, &x67, x65, x57, @intCast(u64, 0x0));
var x68: u64 = undefined;
var x69: u1 = undefined;
fiatP256AddcarryxU64(&x68, &x69, x67, x59, (x61 & 0xffffffff00000001));
var x70: u64 = undefined;
fiatP256CmovznzU64(&x70, x3, (arg5[0]), x62);
var x71: u64 = undefined;
fiatP256CmovznzU64(&x71, x3, (arg5[1]), x64);
var x72: u64 = undefined;
fiatP256CmovznzU64(&x72, x3, (arg5[2]), x66);
var x73: u64 = undefined;
fiatP256CmovznzU64(&x73, x3, (arg5[3]), x68);
const x74: u1 = @intCast(u1, (x22 & @intCast(u64, 0x1)));
var x75: u64 = undefined;
fiatP256CmovznzU64(&x75, x74, @intCast(u64, 0x0), x7);
var x76: u64 = undefined;
fiatP256CmovznzU64(&x76, x74, @intCast(u64, 0x0), x8);
var x77: u64 = undefined;
fiatP256CmovznzU64(&x77, x74, @intCast(u64, 0x0), x9);
var x78: u64 = undefined;
fiatP256CmovznzU64(&x78, x74, @intCast(u64, 0x0), x10);
var x79: u64 = undefined;
fiatP256CmovznzU64(&x79, x74, @intCast(u64, 0x0), x11);
var x80: u64 = undefined;
var x81: u1 = undefined;
fiatP256AddcarryxU64(&x80, &x81, 0x0, x22, x75);
var x82: u64 = undefined;
var x83: u1 = undefined;
fiatP256AddcarryxU64(&x82, &x83, x81, x23, x76);
var x84: u64 = undefined;
var x85: u1 = undefined;
fiatP256AddcarryxU64(&x84, &x85, x83, x24, x77);
var x86: u64 = undefined;
var x87: u1 = undefined;
fiatP256AddcarryxU64(&x86, &x87, x85, x25, x78);
var x88: u64 = undefined;
var x89: u1 = undefined;
fiatP256AddcarryxU64(&x88, &x89, x87, x26, x79);
var x90: u64 = undefined;
fiatP256CmovznzU64(&x90, x74, @intCast(u64, 0x0), x27);
var x91: u64 = undefined;
fiatP256CmovznzU64(&x91, x74, @intCast(u64, 0x0), x28);
var x92: u64 = undefined;
fiatP256CmovznzU64(&x92, x74, @intCast(u64, 0x0), x29);
var x93: u64 = undefined;
fiatP256CmovznzU64(&x93, x74, @intCast(u64, 0x0), x30);
var x94: u64 = undefined;
var x95: u1 = undefined;
fiatP256AddcarryxU64(&x94, &x95, 0x0, x70, x90);
var x96: u64 = undefined;
var x97: u1 = undefined;
fiatP256AddcarryxU64(&x96, &x97, x95, x71, x91);
var x98: u64 = undefined;
var x99: u1 = undefined;
fiatP256AddcarryxU64(&x98, &x99, x97, x72, x92);
var x100: u64 = undefined;
var x101: u1 = undefined;
fiatP256AddcarryxU64(&x100, &x101, x99, x73, x93);
var x102: u64 = undefined;
var x103: u1 = undefined;
fiatP256SubborrowxU64(&x102, &x103, 0x0, x94, 0xffffffffffffffff);
var x104: u64 = undefined;
var x105: u1 = undefined;
fiatP256SubborrowxU64(&x104, &x105, x103, x96, 0xffffffff);
var x106: u64 = undefined;
var x107: u1 = undefined;
fiatP256SubborrowxU64(&x106, &x107, x105, x98, @intCast(u64, 0x0));
var x108: u64 = undefined;
var x109: u1 = undefined;
fiatP256SubborrowxU64(&x108, &x109, x107, x100, 0xffffffff00000001);
var x110: u64 = undefined;
var x111: u1 = undefined;
fiatP256SubborrowxU64(&x110, &x111, x109, @intCast(u64, x101), @intCast(u64, 0x0));
var x112: u64 = undefined;
var x113: u1 = undefined;
fiatP256AddcarryxU64(&x112, &x113, 0x0, x6, @intCast(u64, 0x1));
const x114: u64 = ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff));
const x115: u64 = ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff));
const x116: u64 = ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff));
const x117: u64 = ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff));
const x118: u64 = ((x88 & 0x8000000000000000) | (x88 >> 1));
var x119: u64 = undefined;
fiatP256CmovznzU64(&x119, x48, x39, x31);
var x120: u64 = undefined;
fiatP256CmovznzU64(&x120, x48, x41, x33);
var x121: u64 = undefined;
fiatP256CmovznzU64(&x121, x48, x43, x35);
var x122: u64 = undefined;
fiatP256CmovznzU64(&x122, x48, x45, x37);
var x123: u64 = undefined;
fiatP256CmovznzU64(&x123, x111, x102, x94);
var x124: u64 = undefined;
fiatP256CmovznzU64(&x124, x111, x104, x96);
var x125: u64 = undefined;
fiatP256CmovznzU64(&x125, x111, x106, x98);
var x126: u64 = undefined;
fiatP256CmovznzU64(&x126, x111, x108, x100);
out1.* = x112;
out2[0] = x7;
out2[1] = x8;
out2[2] = x9;
out2[3] = x10;
out2[4] = x11;
out3[0] = x114;
out3[1] = x115;
out3[2] = x116;
out3[3] = x117;
out3[4] = x118;
out4[0] = x119;
out4[1] = x120;
out4[2] = x121;
out4[3] = x122;
out5[0] = x123;
out5[1] = x124;
out5[2] = x125;
out5[3] = x126;
}
/// The function fiatP256DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form).
/// Postconditions:
/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if (log2 m) + 1 < 46 then ⌊(49 * ((log2 m) + 1) + 80) / 17⌋ else ⌊(49 * ((log2 m) + 1) + 57) / 17⌋)
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
pub fn fiatP256DivstepPrecomp(out1: *[4]u64) void {
out1[0] = 0x67ffffffb8000000;
out1[1] = 0xc000000038000000;
out1[2] = 0xd80000007fffffff;
out1[3] = 0x2fffffffffffffff;
}
|
fiat-zig/src/p256_64.zig
|
const kernel = @import("root").kernel;
const print = kernel.print;
const memory = kernel.memory;
const platform = @import("platform.zig");
const pci = @import("pci.zig");
const interrupts = @import("interrupts.zig");
const segments = @import("segments.zig");
const timing = @import("timing.zig");
const ps2 = @import("ps2.zig");
const Error = memory.MemoryError;
const StructParams = packed struct {
port_count: u4, // N_PORTS
port_power_control: bool, // PPC
reserved0: u2,
port_routing_rules: bool,
ports_per_companion: u4, // N_PCC
companion_count: u4, // N_CC
port_indicator: bool, // P_INDICATOR
reserved1: u3,
debug_port_number: u4,
reserved2: u8,
};
const CapParams = packed struct {
has_64b_addr: bool,
programmable_frame_list: bool,
async_schedule_park: bool,
reserved0: bool,
isochronous_scheduling_threshold: u4,
extended_caps_offset: u8,
reserved1: u16, // 4 bits at the start of this are used by v1.1
};
const CapRegs = packed struct {
length: u8, // CAPLENGTH
reserved: u8,
version: u16, // HCIVERSION
_struct_params: StructParams, // HCSPARAMS
_cap_params: CapParams, // HCCPARAMS
pub fn get_struct_params(self: *const CapRegs) StructParams {
return self._struct_params;
}
pub fn get_cap_params(self: *const CapRegs) CapParams {
return self._cap_params;
}
pub fn get(virtual_range: memory.Range) *const CapRegs {
return @intToPtr(*const CapRegs, virtual_range.start);
}
// HCSP-PORTROUTE is after HCCPARAMS, but its size depends on CAPLENGTH and
// its validity depends on struct_params.
pub fn get_companion_port_route(self: *const CapRegs, index: usize) ?u4 {
if (!self.get_struct_params().port_routing_rules) return null;
const count = (@as(usize, self.length) - @sizeOf(CapRegs)) / 2;
if (index >= count) return null;
const byte = @intToPtr(*const u8,
@ptrToInt(self) + @sizeOf(CapRegs) + index / 2).*;
return @truncate(u4, byte >> (@truncate(u3, index & 1) << 2));
}
pub fn get_op_regs(self: *const CapRegs) *OpRegs {
return @intToPtr(*OpRegs, @ptrToInt(self) + self.length);
}
pub fn get_port_regs(self: *const CapRegs) []PortReg {
return @intToPtr([*]PortReg, @ptrToInt(self.get_op_regs()) + @sizeOf(OpRegs))
[0..self.get_struct_params().port_count];
}
pub fn get_extended_caps_id_offset(self: *const CapRegs, dev: *pci.Dev, id: u8) ?u8 {
// Lunt Pages 7-8 and M-7
var offset = self.get_cap_params().extended_caps_offset;
while (true) {
const value = dev.read(u32, offset);
const this_id = @truncate(u8, value);
if (this_id == id) {
return offset;
}
const next = @truncate(u8, value >> 8);
if (next == 0) {
break;
}
offset += next;
}
return null;
}
};
const Command = packed struct {
// Lunt Table 7-10
// TODO: Zig Compiler crashes: "TODO buf_read_value_bytes enum packed"
// const FrameListSize = enum(u2) {
// e1024 = 0b00,
// e512 = 0b01,
// e256 = 0b10,
// e32 = 0b11,
// };
run: bool, // RS
reset: bool, // HCRESET
// frame_list_size: FrameListSize,
frame_list_size: u2,
period_schedule_enabled: bool,
async_schedule_enabled: bool,
async_doorbell_interrupt: bool,
light_host_reset: bool,
async_park_mode_count: u2,
reserved0: bool,
async_park_mode_enabled: bool,
reserved1: u4,
interrupt_threshold: u8,
reserved2: u8,
pub fn init(self: *Command) void {
var new = @bitCast(Command, @as(u32, 0));
new.interrupt_threshold = 8;
// new.async_schedule_enabled = true;
// new.period_schedule_enabled = true;
// new.frame_list_size = FrameListSize.e1024;
new.run = true;
self.* = new;
}
};
/// Lunt Table 7-12
const Status = packed struct {
transfer_interrupt: bool,
error_interrupt: bool,
port_change_detect: bool,
frame_list_rollover: bool,
host_system_error: bool,
doorbell_interrupt: bool,
reserved0: u6,
halted: bool,
reclamation: bool,
periodic_schedule_status: bool,
async_schedule_status: bool,
reserved1: u16,
pub fn clear(self: *Status) void {
self.* = @bitCast(Status, @as(u32, 0x3f));
}
};
/// Lunt Table 7-13
const Interrupts = packed struct {
enabled: bool,
error_enabled: bool,
port_change_enabled: bool,
frame_list_rollover_enabled: bool,
host_system_error_enabled: bool,
async_advance_enabled: bool,
reserved0: u26,
};
/// Lunt Table 7-22
const PortReg = packed struct {
connected: bool, // Read-only
status_changed: bool, //
enabled: bool, // Read/Write only false
enabled_changed: bool, //
over_current: bool, // Read-only
over_current_changed: bool, //
force_port_resume: bool, // Read/Write
suspended: bool, // Read/Write
reset: bool, // Read/Write
reserved0: bool,
status: u2, // Read-only
power: bool, // Read-only or Read/Write if port_power_control is true
release_ownership: bool, // Read/Write
indicator_control: u2, //
test_control: u4, // Read/Write
wake_on_connect: bool, // Read/Write
wake_on_disconnect: bool, // Read/Write
wake_on_over_current: bool, // Read/Write
reserved1: u9,
};
/// Lunt Table 7-8
const OpRegs = packed struct {
command: Command, // USBCMD
status: Status, // USBSTS
interrupts: Interrupts, // USBINTR
frame_index: u32, // FRINDEX
segment_selector: u32, // CTRLDSSEGMENT
frame_list_address: u32, // PERIODICLISTBASE
next_async_list: u32, // ASYNCLISTADDR
reserved: u288,
config_flag: u32, // CONFIGFLAG
// PORTSC is after this, see CapRegs.get_port_regs()
};
pub fn interrupt(interrupt_number: u32, interrupt_stack: *const interrupts.Stack) void {
_ = interrupt_number;
_ = interrupt_stack;
print.string("USB INT\n");
}
var frame_list: ?[]u32 = null;
pub fn init(dev: *pci.Dev) void {
const indent = " - ";
// Zero out PCI Capabilities Pointer and Reserved?
// From Lunt in Step 2 on Chapter 2 Page 10
dev.write(u32, 0x34, 0);
dev.write(u32, 0x38, 0);
// Setup Interrupt Handler
const irq: u8 = 51;
interrupts.IrqInterruptHandler(irq, interrupt).set(
"USB", segments.kernel_code_selector, interrupts.kernel_flags);
interrupts.load();
dev.write(u8, 0x3c, irq);
// Use Memory-Mapped I/O
// This can be set to 5 to use Port I/O, but memory is easier to use.
dev.write(u16, 0x04, 0x0006);
// Map Controller's Address Space
const physical_range = dev.base_addresses[0].?.memory.range;
const pmem = &kernel.memory_mgr.impl;
const range = pmem.get_unused_kernel_space(physical_range.size) catch
@panic("usb.init: get_unused_kernel_space failed");
pmem.map(range, physical_range.start, false) catch
@panic("usb.init: map failed");
ps2.anykey();
// Get Controller Registers
const cap_regs = CapRegs.get(range);
const op_regs = cap_regs.get_op_regs();
// Turn Off BIOS USB to PS/2 Emulation
if (cap_regs.get_cap_params().extended_caps_offset >= 0x40) {
// Find the USB Legacy Support
if (cap_regs.get_extended_caps_id_offset(dev, 1)) |offset| {
// Set the "System Software Owned Semaphore" Bit
// Lunt Pages M-9
dev.write(u32, offset, dev.read(u32, offset) | (1 << 24));
}
}
// Reset the Controller
var reset_timeout: u8 = 30; // Lunt says 20ms, but do 30ms to be safe.
{
var copy = op_regs.command;
copy.run = false;
copy.reset = true;
op_regs.command = copy;
}
while (reset_timeout > 0) {
var copy = op_regs.command;
if (!copy.reset) break;
timing.wait_milliseconds(1);
reset_timeout -= 1;
}
{
var copy = op_regs.command;
if (copy.reset) {
print.string(indent ++ "EHCI Controller failed to respond to reset\n");
return;
}
}
print.string(indent ++ "EHCI Controller Reset\n");
frame_list = kernel.memory_mgr.big_alloc.alloc_array(u32, 1024) catch
@panic("usb.init: alloc frame_list failed");
// Initialize the Controller
var int_copy = op_regs.interrupts;
int_copy.enabled = true;
int_copy.error_enabled = true;
int_copy.port_change_enabled = true;
op_regs.interrupts = int_copy;
op_regs.frame_index = 0;
op_regs.segment_selector = 0;
op_regs.frame_list_address = @ptrToInt(frame_list.?.ptr);
// op_regs.next_async_list = 0; // TODO
op_regs.status.clear();
op_regs.command.init();
op_regs.config_flag = 1;
print.string(indent ++ "EHCI Controller Initialized\n");
const power_control = cap_regs.get_struct_params().port_power_control;
for (cap_regs.get_port_regs()) |*port_reg, i| {
// For some reason the accessing the ports registers in QEMU must be
// done as a whole.
var copy = port_reg.*;
// Check to see if we need to power the port
if (power_control and !copy.power) {
copy.power = true;
port_reg.* = copy;
timing.wait_milliseconds(30);
copy = port_reg.*;
}
if (!copy.connected) continue; // No device
// Reset the Port Lunt 7-25
copy.reset = true;
copy.enabled = false;
port_reg.* = copy;
copy = port_reg.*;
while (!copy.reset) {
copy = port_reg.*;
}
timing.wait_milliseconds(50);
copy.reset = false;
port_reg.* = copy;
copy = port_reg.*;
while (copy.reset) {
copy = port_reg.*;
}
if (!copy.enabled) {
// Not a high-speed device, release ownership to another controller
copy.release_ownership = true;
port_reg.* = copy;
continue;
}
print.format("Port {}: {}\n", .{i, copy});
}
}
|
kernel/platform/usb.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 CompactFormatter(comptime Writer: type) type {
return struct {
const Self = @This();
const impl = @"impl CompactFormatter"(Writer);
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 CompactFormatter"(comptime Writer: type) type {
const Self = CompactFormatter(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 {
// this should be enough to display all decimal places of a decimal f64 number.
var buf: [512]u8 = undefined;
var stream = std.io.fixedBufferStream(&buf);
std.fmt.formatFloatScientific(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, writer: Writer) Writer.Error!void {
try writer.writeAll("[");
}
pub fn endArray(_: *Self, writer: Writer) Writer.Error!void {
try writer.writeAll("]");
}
pub fn beginArrayValue(_: *Self, writer: Writer, first: bool) Writer.Error!void {
if (!first)
try writer.writeAll(",");
}
pub fn endArrayValue(self: *Self, writer: Writer) Writer.Error!void {
_ = self;
_ = writer;
}
pub fn beginObject(_: *Self, writer: Writer) Writer.Error!void {
try writer.writeAll("{");
}
pub fn endObject(_: *Self, writer: Writer) Writer.Error!void {
try writer.writeAll("}");
}
pub fn beginObjectKey(_: *Self, writer: Writer, first: bool) Writer.Error!void {
if (!first)
try writer.writeAll(",");
}
pub fn endObjectKey(self: *Self, writer: Writer) Writer.Error!void {
_ = self;
_ = writer;
}
pub fn beginObjectValue(_: *Self, writer: Writer) Writer.Error!void {
try writer.writeAll(":");
}
pub fn endObjectValue(self: *Self, writer: Writer) Writer.Error!void {
_ = self;
_ = writer;
}
pub fn writeRawFragment(self: *Self, writer: Writer, value: []const u8) Writer.Error!void {
_ = self;
try writer.writeAll(value);
}
};
};
}
|
src/ser/impl/formatter/compact.zig
|
const uefi = @import("std").os.uefi;
const Event = uefi.Event;
const Guid = uefi.Guid;
const Handle = uefi.Handle;
const Status = uefi.Status;
const TableHeader = uefi.tables.TableHeader;
const DevicePathProtocol = uefi.protocols.DevicePathProtocol;
/// Boot services are services provided by the system's firmware until the operating system takes
/// over control over the hardware by calling exitBootServices.
///
/// Boot Services must not be used after exitBootServices has been called. The only exception is
/// getMemoryMap, which may be used after the first unsuccessful call to exitBootServices.
/// After successfully calling exitBootServices, system_table.console_in_handle, system_table.con_in,
/// system_table.console_out_handle, system_table.con_out, system_table.standard_error_handle,
/// system_table.std_err, and system_table.boot_services should be set to null. After setting these
/// attributes to null, system_table.hdr.crc32 must be recomputed.
///
/// As the boot_services table may grow with new UEFI versions, it is important to check hdr.header_size.
pub const BootServices = extern struct {
hdr: TableHeader,
/// Raises a task's priority level and returns its previous level.
raiseTpl: extern fn (usize) usize,
/// Restores a task's priority level to its previous value.
restoreTpl: extern fn (usize) void,
/// Allocates memory pages from the system.
allocatePages: extern fn (AllocateType, MemoryType, usize, *[*]align(4096) u8) Status,
/// Frees memory pages.
freePages: extern fn ([*]align(4096) u8, usize) Status,
/// Returns the current memory map.
getMemoryMap: extern fn (*usize, [*]MemoryDescriptor, *usize, *usize, *u32) Status,
/// Allocates pool memory.
allocatePool: extern fn (MemoryType, usize, *[*]align(8) u8) Status,
/// Returns pool memory to the system.
freePool: extern fn ([*]align(8) u8) Status,
/// Creates an event.
createEvent: extern fn (u32, usize, ?extern fn (Event, ?*c_void) void, ?*const c_void, *Event) Status,
/// Sets the type of timer and the trigger time for a timer event.
setTimer: extern fn (Event, TimerDelay, u64) Status,
/// Stops execution until an event is signaled.
waitForEvent: extern fn (usize, [*]const Event, *usize) Status,
/// Signals an event.
signalEvent: extern fn (Event) Status,
/// Closes an event.
closeEvent: extern fn (Event) Status,
/// Checks whether an event is in the signaled state.
checkEvent: extern fn (Event) Status,
installProtocolInterface: Status, // TODO
reinstallProtocolInterface: Status, // TODO
uninstallProtocolInterface: Status, // TODO
/// Queries a handle to determine if it supports a specified protocol.
handleProtocol: extern fn (Handle, *align(8) const Guid, *?*c_void) Status,
reserved: *c_void,
registerProtocolNotify: Status, // TODO
/// Returns an array of handles that support a specified protocol.
locateHandle: extern fn (LocateSearchType, ?*align(8) const Guid, ?*const c_void, *usize, [*]Handle) Status,
locateDevicePath: Status, // TODO
installConfigurationTable: Status, // TODO
/// Loads an EFI image into memory.
loadImage: extern fn (bool, Handle, ?*const DevicePathProtocol, ?[*]const u8, usize, *?Handle) Status,
/// Transfers control to a loaded image's entry point.
startImage: extern fn (Handle, ?*usize, ?*[*]u16) Status,
/// Terminates a loaded EFI image and returns control to boot services.
exit: extern fn (Handle, Status, usize, ?*const c_void) Status,
/// Unloads an image.
unloadImage: extern fn (Handle) Status,
/// Terminates all boot services.
exitBootServices: extern fn (Handle, usize) Status,
/// Returns a monotonically increasing count for the platform.
getNextMonotonicCount: extern fn (*u64) Status,
/// Induces a fine-grained stall.
stall: extern fn (usize) Status,
/// Sets the system's watchdog timer.
setWatchdogTimer: extern fn (usize, u64, usize, ?[*]const u16) Status,
connectController: Status, // TODO
disconnectController: Status, // TODO
/// Queries a handle to determine if it supports a specified protocol.
openProtocol: extern fn (Handle, *align(8) const Guid, *?*c_void, ?Handle, ?Handle, OpenProtocolAttributes) Status,
/// Closes a protocol on a handle that was opened using openProtocol().
closeProtocol: extern fn (Handle, *align(8) const Guid, Handle, ?Handle) Status,
/// Retrieves the list of agents that currently have a protocol interface opened.
openProtocolInformation: extern fn (Handle, *align(8) const Guid, *[*]ProtocolInformationEntry, *usize) Status,
/// Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated from pool.
protocolsPerHandle: extern fn (Handle, *[*]*align(8) const Guid, *usize) Status,
/// Returns an array of handles that support the requested protocol in a buffer allocated from pool.
locateHandleBuffer: extern fn (LocateSearchType, ?*align(8) const Guid, ?*const c_void, *usize, *[*]Handle) Status,
/// Returns the first protocol instance that matches the given protocol.
locateProtocol: extern fn (*align(8) const Guid, ?*const c_void, *?*c_void) Status,
installMultipleProtocolInterfaces: Status, // TODO
uninstallMultipleProtocolInterfaces: Status, // TODO
/// Computes and returns a 32-bit CRC for a data buffer.
calculateCrc32: extern fn ([*]const u8, usize, *u32) Status,
/// Copies the contents of one buffer to another buffer
copyMem: extern fn ([*]u8, [*]const u8, usize) void,
/// Fills a buffer with a specified value
setMem: extern fn ([*]u8, usize, u8) void,
createEventEx: Status, // TODO
pub const signature: u64 = 0x56524553544f4f42;
pub const event_timer: u32 = 0x80000000;
pub const event_runtime: u32 = 0x40000000;
pub const event_notify_wait: u32 = 0x00000100;
pub const event_notify_signal: u32 = 0x00000200;
pub const event_signal_exit_boot_services: u32 = 0x00000201;
pub const event_signal_virtual_address_change: u32 = 0x00000202;
pub const tpl_application: usize = 4;
pub const tpl_callback: usize = 8;
pub const tpl_notify: usize = 16;
pub const tpl_high_level: usize = 31;
};
pub const TimerDelay = extern enum(u32) {
TimerCancel,
TimerPeriodic,
TimerRelative,
};
pub const MemoryType = extern enum(u32) {
ReservedMemoryType,
LoaderCode,
LoaderData,
BootServicesCode,
BootServicesData,
RuntimeServicesCode,
RuntimeServicesData,
ConventionalMemory,
UnusableMemory,
ACPIReclaimMemory,
ACPIMemoryNVS,
MemoryMappedIO,
MemoryMappedIOPortSpace,
PalCode,
PersistentMemory,
MaxMemoryType,
};
pub const MemoryDescriptor = extern struct {
type: MemoryType,
physical_start: u64,
virtual_start: u64,
number_of_pages: usize,
attribute: packed struct {
uc: bool,
wc: bool,
wt: bool,
wb: bool,
uce: bool,
_pad1: u7,
wp: bool,
rp: bool,
xp: bool,
nv: bool,
more_reliable: bool,
ro: bool,
sp: bool,
cpu_crypto: bool,
_pad2: u43,
memory_runtime: bool,
},
};
pub const LocateSearchType = extern enum(u32) {
AllHandles,
ByRegisterNotify,
ByProtocol,
};
pub const OpenProtocolAttributes = packed struct {
by_handle_protocol: bool = false,
get_protocol: bool = false,
test_protocol: bool = false,
by_child_controller: bool = false,
by_driver: bool = false,
exclusive: bool = false,
_pad: u26 = undefined,
};
pub const ProtocolInformationEntry = extern struct {
agent_handle: ?Handle,
controller_handle: ?Handle,
attributes: OpenProtocolAttributes,
open_count: u32,
};
pub const AllocateType = extern enum(u32) {
AllocateAnyPages,
AllocateMaxAddress,
AllocateAddress,
};
|
lib/std/os/uefi/tables/boot_services.zig
|
const compiler = @import("compiler.zig");
const CompilerResult = @import("compiler.zig").CompilerResult;
const Compilation = @import("Compilation.zig");
const Node = @import("Node.zig");
const CompilerContext = @import("CompilerContext.zig");
const combn = @import("../combn/combn.zig");
const Context = combn.Context;
const Result = combn.Result;
const std = @import("std");
const testing = std.testing;
const mem = std.mem;
const assert = std.debug.assert;
const Program = @This();
/// If compile() fails, this error message and offset explains why and where.
error_message: ?[]const u8,
error_offset: usize,
/// The source of the program, null after successful compilation.
src: ?[]const u8,
/// The compiled program.
program: ?CompilerResult,
/// Context for the program.
context: ?Context(void, *Node),
allocator: *mem.Allocator,
pub const Error = error{
OutOfMemory,
CompilationFailed,
};
/// Initializes a new program with the given source, which is borrowed until compile() is called
/// and returns.
pub fn init(allocator: *mem.Allocator, src: []const u8) Program {
return Program{
.error_message = null,
.error_offset = 0,
.src = src,
.program = null,
.context = null,
.allocator = allocator,
};
}
/// Compiles the program, returning an error if compilation fails.
pub fn compile(self: *Program) !void {
// Compile the syntax.
var compilerResult = try compiler.compile(self.allocator, self.src.?);
switch (compilerResult.compilation.result) {
.err => |e| {
self.error_message = e;
self.error_offset = compilerResult.compilation.offset;
compilerResult.deinit(self.allocator);
return Error.CompilationFailed;
},
.value => {},
}
self.program = compilerResult;
self.src = null;
}
/// Executes the program with the given input.
pub fn execute(self: *Program, input: []const u8) !*Node {
nosuspend {
self.context = try Context(void, *Node).init(self.allocator, input, {});
const compilation = self.program.?.compilation.result.value;
try compilation.value.parser.ptr.parse(&self.context.?);
var sub = self.context.?.subscribe();
var first = sub.next().?;
assert(sub.next() == null); // no ambiguous parse paths here
return first.result.value;
}
}
pub fn deinit(self: *const Program) void {
if (self.program) |prog| {
self.context.?.deinit();
prog.deinit(self.allocator);
}
}
test "example_regex" {
const allocator = testing.allocator;
const String = @import("String.zig");
// Compile the regex.
var program = Program.init(allocator, "//");
defer program.deinit();
program.compile() catch |err| switch (err) {
Error.CompilationFailed => @panic(program.error_message.?),
else => unreachable,
};
// Execute the regex.
const input = "hmmm";
const result = try program.execute(input);
// Serialize to JSON.
var buffer = std.ArrayList(u8).init(allocator);
defer buffer.deinit();
try result.writeJSON(allocator, buffer.writer());
// Confirm the results.
try testing.expectEqualStrings(
\\[
\\ {
\\ "name": "TODO(slimsag): value from parsing regexp!"
\\ }
\\]
, buffer.items);
}
test "example_zorex" {
const allocator = testing.allocator;
const String = @import("String.zig");
// Compile the zorex.
var program = Program.init(allocator, "Date = //; Date");
defer program.deinit();
program.compile() catch |err| switch (err) {
Error.CompilationFailed => @panic(program.error_message.?),
else => unreachable,
};
// Execute the zorex.
const input = "hmmm";
const result = try program.execute(input);
// Serialize to JSON.
var buffer = std.ArrayList(u8).init(allocator);
defer buffer.deinit();
try result.writeJSON(allocator, buffer.writer());
// Confirm the results.
try testing.expectEqualStrings(
\\[
\\ {
\\ "name": "TODO(slimsag): value from parsing regexp!"
\\ },
\\ {
\\ "name": "unknown",
\\ "children": [
\\ 0
\\ ]
\\ }
\\]
, buffer.items);
}
|
src/dsl/Program.zig
|
const aoc = @import("../aoc.zig");
const std = @import("std");
const Packet = struct {
const Operation = enum (u3) {
Sum = 0,
Product = 1,
Minimum = 2,
Maximum = 3,
Literal = 4,
GreaterThan = 5,
LessThan = 6,
Equal = 7,
};
const SubpacketParsage = union (enum) {
Type0: struct {
end_bit: usize,
},
Type1: struct {
count: u11,
idx: u11 = 0,
},
};
version_total: usize,
computation_total: usize,
fn parse(input: []const u8, bit: *usize) Packet {
var version_total: usize = readChunk(u3, input, bit);
const operation = @intToEnum(Operation, readChunk(u3, input, bit));
if (operation == .Literal) {
var literal: usize = 0;
var read_next: u1 = 1;
while (read_next == 1) {
read_next = readChunk(u1, input, bit);
literal = (literal << 4) | readChunk(u4, input, bit);
}
return .{ .version_total = version_total, .computation_total = literal };
}
const length_type_id = readChunk(u1, input, bit);
var subpacket_parsage: SubpacketParsage = if (length_type_id == 0)
SubpacketParsage{ .Type0 = .{ .end_bit = readChunk(u15, input, bit) + bit.* } } // order of operations is very important!
else
SubpacketParsage{ .Type1 = .{ .count = readChunk(u11, input, bit) } };
var computation_total = blk: {
const result = parseSubpacket(input, bit, &subpacket_parsage).?;
version_total += result.version_total;
break :blk result.computation_total;
};
while (parseSubpacket(input, bit, &subpacket_parsage)) |subpacket| {
computation_total = switch (operation) {
.Sum => computation_total + subpacket.computation_total,
.Product => computation_total * subpacket.computation_total,
.Minimum => std.math.min(computation_total, subpacket.computation_total),
.Maximum => std.math.max(computation_total, subpacket.computation_total),
.Literal => unreachable,
.GreaterThan => @boolToInt(computation_total > subpacket.computation_total),
.LessThan => @boolToInt(computation_total < subpacket.computation_total),
.Equal => @boolToInt(computation_total == subpacket.computation_total),
};
version_total += subpacket.version_total;
}
return .{ .version_total = version_total, .computation_total = computation_total };
}
fn parseSubpacket(input: []const u8, bit: *usize, parsage: *SubpacketParsage) ?Packet {
switch (parsage.*) {
.Type0 => |t0| {
if (bit.* == t0.end_bit) {
return null;
}
},
.Type1 => |*t1| {
if (t1.idx == t1.count) {
return null;
}
t1.idx += 1;
}
}
return parse(input, bit);
}
fn readChunk(comptime T: type, input: []const u8, bit: *usize) T {
const end_bit = bit.* + std.meta.bitCount(T);
var result: usize = 0;
while (bit.* != end_bit) {
const from = @intCast(u2, bit.* % 4);
const bits_left_to_read = end_bit - bit.*;
const to_excl = std.math.min(from + bits_left_to_read, 4);
const bits_read = @intCast(u3, to_excl - from);
const nibble = readNibble(input[bit.* / 4], from, @intCast(u2, to_excl - 1));
result = (result << bits_read) | nibble;
bit.* += bits_read;
}
return @intCast(T, result);
}
fn readNibble(input: u8, from: u2, to: u2) u4 {
var result = if (input <= '9') @intCast(u4, input - '0') else @intCast(u4, input - 'A' + 10);
result <<= from;
result >>= 3 - (to - from);
return result;
}
};
pub fn run(problem: *aoc.Problem) !aoc.Solution {
var start_bit: usize = 0;
var packet = Packet.parse(problem.input, &start_bit);
return problem.solution(packet.version_total, packet.computation_total);
}
|
src/main/zig/2021/day16.zig
|
const Archive = @This();
const std = @import("std");
const assert = std.debug.assert;
const fs = std.fs;
const log = std.log.scoped(.archive);
const macho = std.macho;
const mem = std.mem;
const Allocator = mem.Allocator;
const Object = @import("Object.zig");
const parseName = @import("Zld.zig").parseName;
usingnamespace @import("commands.zig");
allocator: *Allocator,
file: fs.File,
header: ar_hdr,
name: []u8,
objects: std.ArrayListUnmanaged(Object) = .{},
/// Parsed table of contents.
/// Each symbol name points to a list of all definition
/// sites within the current static archive.
toc: std.StringArrayHashMapUnmanaged(std.ArrayListUnmanaged(u32)) = .{},
// Archive files start with the ARMAG identifying string. Then follows a
// `struct ar_hdr', and as many bytes of member file data as its `ar_size'
// member indicates, for each member file.
/// String that begins an archive file.
const ARMAG: *const [SARMAG:0]u8 = "!<arch>\n";
/// Size of that string.
const SARMAG: u4 = 8;
/// String in ar_fmag at the end of each header.
const ARFMAG: *const [2:0]u8 = "`\n";
const ar_hdr = extern struct {
/// Member file name, sometimes / terminated.
ar_name: [16]u8,
/// File date, decimal seconds since Epoch.
ar_date: [12]u8,
/// User ID, in ASCII format.
ar_uid: [6]u8,
/// Group ID, in ASCII format.
ar_gid: [6]u8,
/// File mode, in ASCII octal.
ar_mode: [8]u8,
/// File size, in ASCII decimal.
ar_size: [10]u8,
/// Always contains ARFMAG.
ar_fmag: [2]u8,
const NameOrLength = union(enum) {
Name: []const u8,
Length: u64,
};
pub fn nameOrLength(self: ar_hdr) !NameOrLength {
const value = getValue(&self.ar_name);
const slash_index = mem.indexOf(u8, value, "/") orelse return error.MalformedArchive;
const len = value.len;
if (slash_index == len - 1) {
// Name stored directly
return NameOrLength{ .Name = value };
} else {
// Name follows the header directly and its length is encoded in
// the name field.
const length = try std.fmt.parseInt(u64, value[slash_index + 1 ..], 10);
return NameOrLength{ .Length = length };
}
}
pub fn size(self: ar_hdr) !u64 {
const value = getValue(&self.ar_size);
return std.fmt.parseInt(u64, value, 10);
}
fn getValue(raw: []const u8) []const u8 {
return mem.trimRight(u8, raw, &[_]u8{@as(u8, 0x20)});
}
};
pub fn deinit(self: *Archive) void {
self.allocator.free(self.name);
for (self.objects.items) |*object| {
object.deinit();
}
self.objects.deinit(self.allocator);
for (self.toc.items()) |*entry| {
self.allocator.free(entry.key);
entry.value.deinit(self.allocator);
}
self.toc.deinit(self.allocator);
self.file.close();
}
/// Caller owns the returned Archive instance and is responsible for calling
/// `deinit` to free allocated memory.
pub fn initFromFile(allocator: *Allocator, arch: std.Target.Cpu.Arch, ar_name: []const u8, file: fs.File) !Archive {
var reader = file.reader();
var magic = try readMagic(allocator, reader);
defer allocator.free(magic);
if (!mem.eql(u8, magic, ARMAG)) {
// Reset file cursor.
try file.seekTo(0);
return error.NotArchive;
}
const header = try reader.readStruct(ar_hdr);
if (!mem.eql(u8, &header.ar_fmag, ARFMAG))
return error.MalformedArchive;
var embedded_name = try getName(allocator, header, reader);
log.debug("parsing archive '{s}' at '{s}'", .{ embedded_name, ar_name });
defer allocator.free(embedded_name);
var name = try allocator.dupe(u8, ar_name);
var self = Archive{
.allocator = allocator,
.file = file,
.header = header,
.name = name,
};
var object_offsets = try self.readTableOfContents(reader);
defer self.allocator.free(object_offsets);
var i: usize = 1;
while (i < object_offsets.len) : (i += 1) {
const offset = object_offsets[i];
try reader.context.seekTo(offset);
try self.readObject(arch, ar_name, reader);
}
return self;
}
fn readTableOfContents(self: *Archive, reader: anytype) ![]u32 {
const symtab_size = try reader.readIntLittle(u32);
var symtab = try self.allocator.alloc(u8, symtab_size);
defer self.allocator.free(symtab);
try reader.readNoEof(symtab);
const strtab_size = try reader.readIntLittle(u32);
var strtab = try self.allocator.alloc(u8, strtab_size);
defer self.allocator.free(strtab);
try reader.readNoEof(strtab);
var symtab_stream = std.io.fixedBufferStream(symtab);
var symtab_reader = symtab_stream.reader();
var object_offsets = std.ArrayList(u32).init(self.allocator);
try object_offsets.append(0);
var last: usize = 0;
while (true) {
const n_strx = symtab_reader.readIntLittle(u32) catch |err| switch (err) {
error.EndOfStream => break,
else => |e| return e,
};
const object_offset = try symtab_reader.readIntLittle(u32);
const sym_name = mem.spanZ(@ptrCast([*:0]const u8, strtab.ptr + n_strx));
const owned_name = try self.allocator.dupe(u8, sym_name);
const res = try self.toc.getOrPut(self.allocator, owned_name);
defer if (res.found_existing) self.allocator.free(owned_name);
if (!res.found_existing) {
res.entry.value = .{};
}
try res.entry.value.append(self.allocator, object_offset);
// TODO This will go once we properly use archive's TOC to pick
// an object which defines a missing symbol rather than pasting in
// all of the objects always.
// Here, we assume that symbols are NOT sorted in any way, and
// they point to objects in sequence.
if (object_offsets.items[last] != object_offset) {
try object_offsets.append(object_offset);
last += 1;
}
}
return object_offsets.toOwnedSlice();
}
fn readObject(self: *Archive, arch: std.Target.Cpu.Arch, ar_name: []const u8, reader: anytype) !void {
const object_header = try reader.readStruct(ar_hdr);
if (!mem.eql(u8, &object_header.ar_fmag, ARFMAG))
return error.MalformedArchive;
var object_name = try getName(self.allocator, object_header, reader);
log.debug("extracting object '{s}' from archive '{s}'", .{ object_name, self.name });
const offset = @intCast(u32, try reader.context.getPos());
const header = try reader.readStruct(macho.mach_header_64);
const this_arch: std.Target.Cpu.Arch = switch (header.cputype) {
macho.CPU_TYPE_ARM64 => .aarch64,
macho.CPU_TYPE_X86_64 => .x86_64,
else => |value| {
log.err("unsupported cpu architecture 0x{x}", .{value});
return error.UnsupportedCpuArchitecture;
},
};
if (this_arch != arch) {
log.err("mismatched cpu architecture: found {s}, expected {s}", .{ this_arch, arch });
return error.MismatchedCpuArchitecture;
}
// TODO Implement std.fs.File.clone() or similar.
var new_file = try fs.cwd().openFile(ar_name, .{});
var object = Object{
.allocator = self.allocator,
.name = object_name,
.ar_name = try mem.dupe(self.allocator, u8, ar_name),
.file = new_file,
.header = header,
};
try object.readLoadCommands(reader, .{ .offset = offset });
if (object.symtab_cmd_index != null) {
try object.readSymtab();
try object.readStrtab();
}
if (object.data_in_code_cmd_index != null) try object.readDataInCode();
log.debug("\n\n", .{});
log.debug("{s} defines symbols", .{object.name});
for (object.symtab.items) |sym| {
const symname = object.getString(sym.n_strx);
log.debug("'{s}': {}", .{ symname, sym });
}
try self.objects.append(self.allocator, object);
}
fn readMagic(allocator: *Allocator, reader: anytype) ![]u8 {
var magic = std.ArrayList(u8).init(allocator);
try magic.ensureCapacity(SARMAG);
var i: usize = 0;
while (i < SARMAG) : (i += 1) {
const next = try reader.readByte();
magic.appendAssumeCapacity(next);
}
return magic.toOwnedSlice();
}
fn getName(allocator: *Allocator, header: ar_hdr, reader: anytype) ![]u8 {
const name_or_length = try header.nameOrLength();
var name: []u8 = undefined;
switch (name_or_length) {
.Name => |n| {
name = try allocator.dupe(u8, n);
},
.Length => |len| {
var n = try allocator.alloc(u8, len);
defer allocator.free(n);
try reader.readNoEof(n);
const actual_len = mem.indexOfScalar(u8, n, @as(u8, 0)) orelse n.len;
name = try allocator.dupe(u8, n[0..actual_len]);
},
}
return name;
}
|
src/link/MachO/Archive.zig
|
const std = @import("../std.zig");
const builtin = @import("builtin");
const event = std.event;
const assert = std.debug.assert;
const testing = std.testing;
const os = std.os;
const mem = std.mem;
const windows = os.windows;
const Loop = event.Loop;
const fd_t = os.fd_t;
const File = std.fs.File;
const Allocator = mem.Allocator;
const global_event_loop = Loop.instance orelse
@compileError("std.fs.Watch currently only works with event-based I/O");
const WatchEventId = enum {
CloseWrite,
Delete,
};
fn eqlString(a: []const u16, b: []const u16) bool {
if (a.len != b.len) return false;
if (a.ptr == b.ptr) return true;
return mem.compare(u16, a, b) == .Equal;
}
fn hashString(s: []const u16) u32 {
return @truncate(u32, std.hash.Wyhash.hash(0, mem.sliceAsBytes(s)));
}
const WatchEventError = error{
UserResourceLimitReached,
SystemResources,
AccessDenied,
Unexpected, // TODO remove this possibility
};
pub fn Watch(comptime V: type) type {
return struct {
channel: *event.Channel(Event.Error!Event),
os_data: OsData,
allocator: *Allocator,
const OsData = switch (builtin.os.tag) {
// TODO https://github.com/ziglang/zig/issues/3778
.macosx, .freebsd, .netbsd, .dragonfly => KqOsData,
.linux => LinuxOsData,
.windows => WindowsOsData,
else => @compileError("Unsupported OS"),
};
const KqOsData = struct {
file_table: FileTable,
table_lock: event.Lock,
const FileTable = std.StringHashMap(*Put);
const Put = struct {
putter_frame: @Frame(kqPutEvents),
cancelled: bool = false,
value: V,
};
};
const WindowsOsData = struct {
table_lock: event.Lock,
dir_table: DirTable,
all_putters: std.atomic.Queue(Put),
ref_count: std.atomic.Int(usize),
const Put = struct {
putter: anyframe,
cancelled: bool = false,
};
const DirTable = std.StringHashMap(*Dir);
const FileTable = std.HashMap([]const u16, V, hashString, eqlString);
const Dir = struct {
putter_frame: @Frame(windowsDirReader),
file_table: FileTable,
table_lock: event.Lock,
};
};
const LinuxOsData = struct {
putter_frame: @Frame(linuxEventPutter),
inotify_fd: i32,
wd_table: WdTable,
table_lock: event.Lock,
cancelled: bool = false,
const WdTable = std.AutoHashMap(i32, Dir);
const FileTable = std.StringHashMap(V);
const Dir = struct {
dirname: []const u8,
file_table: FileTable,
};
};
const Self = @This();
pub const Event = struct {
id: Id,
data: V,
pub const Id = WatchEventId;
pub const Error = WatchEventError;
};
pub fn init(allocator: *Allocator, event_buf_count: usize) !*Self {
const channel = try allocator.create(event.Channel(Event.Error!Event));
errdefer allocator.destroy(channel);
var buf = try allocator.alloc(Event.Error!Event, event_buf_count);
errdefer allocator.free(buf);
channel.init(buf);
errdefer channel.deinit();
const self = try allocator.create(Self);
errdefer allocator.destroy(self);
switch (builtin.os.tag) {
.linux => {
const inotify_fd = try os.inotify_init1(os.linux.IN_NONBLOCK | os.linux.IN_CLOEXEC);
errdefer os.close(inotify_fd);
self.* = Self{
.allocator = allocator,
.channel = channel,
.os_data = OsData{
.putter_frame = undefined,
.inotify_fd = inotify_fd,
.wd_table = OsData.WdTable.init(allocator),
.table_lock = event.Lock.init(),
},
};
self.os_data.putter_frame = async self.linuxEventPutter();
return self;
},
.windows => {
self.* = Self{
.allocator = allocator,
.channel = channel,
.os_data = OsData{
.table_lock = event.Lock.init(),
.dir_table = OsData.DirTable.init(allocator),
.ref_count = std.atomic.Int(usize).init(1),
.all_putters = std.atomic.Queue(anyframe).init(),
},
};
return self;
},
.macosx, .freebsd, .netbsd, .dragonfly => {
self.* = Self{
.allocator = allocator,
.channel = channel,
.os_data = OsData{
.table_lock = event.Lock.init(),
.file_table = OsData.FileTable.init(allocator),
},
};
return self;
},
else => @compileError("Unsupported OS"),
}
}
/// All addFile calls and removeFile calls must have completed.
pub fn deinit(self: *Self) void {
switch (builtin.os.tag) {
.macosx, .freebsd, .netbsd, .dragonfly => {
// TODO we need to cancel the frames before destroying the lock
self.os_data.table_lock.deinit();
var it = self.os_data.file_table.iterator();
while (it.next()) |entry| {
entry.cancelled = true;
await entry.value.putter;
self.allocator.free(entry.key);
self.allocator.free(entry.value);
}
self.channel.deinit();
self.allocator.destroy(self.channel.buffer_nodes);
self.allocator.destroy(self);
},
.linux => {
self.os_data.cancelled = true;
await self.os_data.putter_frame;
self.allocator.destroy(self);
},
.windows => {
while (self.os_data.all_putters.get()) |putter_node| {
putter_node.cancelled = true;
await putter_node.frame;
}
self.deref();
},
else => @compileError("Unsupported OS"),
}
}
fn ref(self: *Self) void {
_ = self.os_data.ref_count.incr();
}
fn deref(self: *Self) void {
if (self.os_data.ref_count.decr() == 1) {
self.os_data.table_lock.deinit();
var it = self.os_data.dir_table.iterator();
while (it.next()) |entry| {
self.allocator.free(entry.key);
self.allocator.destroy(entry.value);
}
self.os_data.dir_table.deinit();
self.channel.deinit();
self.allocator.destroy(self.channel.buffer_nodes);
self.allocator.destroy(self);
}
}
pub fn addFile(self: *Self, file_path: []const u8, value: V) !?V {
switch (builtin.os.tag) {
.macosx, .freebsd, .netbsd, .dragonfly => return addFileKEvent(self, file_path, value),
.linux => return addFileLinux(self, file_path, value),
.windows => return addFileWindows(self, file_path, value),
else => @compileError("Unsupported OS"),
}
}
fn addFileKEvent(self: *Self, file_path: []const u8, value: V) !?V {
const resolved_path = try std.fs.path.resolve(self.allocator, [_][]const u8{file_path});
var resolved_path_consumed = false;
defer if (!resolved_path_consumed) self.allocator.free(resolved_path);
var close_op = try CloseOperation.start(self.allocator);
var close_op_consumed = false;
defer if (!close_op_consumed) close_op.finish();
const flags = if (comptime std.Target.current.isDarwin()) os.O_SYMLINK | os.O_EVTONLY else 0;
const mode = 0;
const fd = try openPosix(self.allocator, resolved_path, flags, mode);
close_op.setHandle(fd);
var put = try self.allocator.create(OsData.Put);
errdefer self.allocator.destroy(put);
put.* = OsData.Put{
.value = value,
.putter_frame = undefined,
};
put.putter_frame = async self.kqPutEvents(close_op, put);
close_op_consumed = true;
errdefer {
put.cancelled = true;
await put.putter_frame;
}
const result = blk: {
const held = self.os_data.table_lock.acquire();
defer held.release();
const gop = try self.os_data.file_table.getOrPut(resolved_path);
if (gop.found_existing) {
const prev_value = gop.kv.value.value;
await gop.kv.value.putter_frame;
gop.kv.value = put;
break :blk prev_value;
} else {
resolved_path_consumed = true;
gop.kv.value = put;
break :blk null;
}
};
return result;
}
fn kqPutEvents(self: *Self, close_op: *CloseOperation, put: *OsData.Put) void {
global_event_loop.beginOneEvent();
defer {
close_op.finish();
global_event_loop.finishOneEvent();
}
while (!put.cancelled) {
if (global_event_loop.bsdWaitKev(
@intCast(usize, close_op.getHandle()),
os.EVFILT_VNODE,
os.NOTE_WRITE | os.NOTE_DELETE,
)) |kev| {
// TODO handle EV_ERROR
if (kev.fflags & os.NOTE_DELETE != 0) {
self.channel.put(Self.Event{
.id = Event.Id.Delete,
.data = put.value,
});
} else if (kev.fflags & os.NOTE_WRITE != 0) {
self.channel.put(Self.Event{
.id = Event.Id.CloseWrite,
.data = put.value,
});
}
} else |err| switch (err) {
error.EventNotFound => unreachable,
error.ProcessNotFound => unreachable,
error.Overflow => unreachable,
error.AccessDenied, error.SystemResources => |casted_err| {
self.channel.put(casted_err);
},
}
}
}
fn addFileLinux(self: *Self, file_path: []const u8, value: V) !?V {
const dirname = std.fs.path.dirname(file_path) orelse ".";
const dirname_with_null = try std.cstr.addNullByte(self.allocator, dirname);
var dirname_with_null_consumed = false;
defer if (!dirname_with_null_consumed) self.channel.free(dirname_with_null);
const basename = std.fs.path.basename(file_path);
const basename_with_null = try std.cstr.addNullByte(self.allocator, basename);
var basename_with_null_consumed = false;
defer if (!basename_with_null_consumed) self.allocator.free(basename_with_null);
const wd = try os.inotify_add_watchC(
self.os_data.inotify_fd,
dirname_with_null.ptr,
os.linux.IN_CLOSE_WRITE | os.linux.IN_ONLYDIR | os.linux.IN_EXCL_UNLINK,
);
// wd is either a newly created watch or an existing one.
const held = self.os_data.table_lock.acquire();
defer held.release();
const gop = try self.os_data.wd_table.getOrPut(wd);
if (!gop.found_existing) {
gop.kv.value = OsData.Dir{
.dirname = dirname_with_null,
.file_table = OsData.FileTable.init(self.allocator),
};
dirname_with_null_consumed = true;
}
const dir = &gop.kv.value;
const file_table_gop = try dir.file_table.getOrPut(basename_with_null);
if (file_table_gop.found_existing) {
const prev_value = file_table_gop.kv.value;
file_table_gop.kv.value = value;
return prev_value;
} else {
file_table_gop.kv.value = value;
basename_with_null_consumed = true;
return null;
}
}
fn addFileWindows(self: *Self, file_path: []const u8, value: V) !?V {
// TODO we might need to convert dirname and basename to canonical file paths ("short"?)
const dirname = try std.mem.dupe(self.allocator, u8, std.fs.path.dirname(file_path) orelse ".");
var dirname_consumed = false;
defer if (!dirname_consumed) self.allocator.free(dirname);
const dirname_utf16le = try std.unicode.utf8ToUtf16LeWithNull(self.allocator, dirname);
defer self.allocator.free(dirname_utf16le);
// TODO https://github.com/ziglang/zig/issues/265
const basename = std.fs.path.basename(file_path);
const basename_utf16le_null = try std.unicode.utf8ToUtf16LeWithNull(self.allocator, basename);
var basename_utf16le_null_consumed = false;
defer if (!basename_utf16le_null_consumed) self.allocator.free(basename_utf16le_null);
const basename_utf16le_no_null = basename_utf16le_null[0 .. basename_utf16le_null.len - 1];
const dir_handle = try windows.CreateFileW(
dirname_utf16le.ptr,
windows.FILE_LIST_DIRECTORY,
windows.FILE_SHARE_READ | windows.FILE_SHARE_DELETE | windows.FILE_SHARE_WRITE,
null,
windows.OPEN_EXISTING,
windows.FILE_FLAG_BACKUP_SEMANTICS | windows.FILE_FLAG_OVERLAPPED,
null,
);
var dir_handle_consumed = false;
defer if (!dir_handle_consumed) windows.CloseHandle(dir_handle);
const held = self.os_data.table_lock.acquire();
defer held.release();
const gop = try self.os_data.dir_table.getOrPut(dirname);
if (gop.found_existing) {
const dir = gop.kv.value;
const held_dir_lock = dir.table_lock.acquire();
defer held_dir_lock.release();
const file_gop = try dir.file_table.getOrPut(basename_utf16le_no_null);
if (file_gop.found_existing) {
const prev_value = file_gop.kv.value;
file_gop.kv.value = value;
return prev_value;
} else {
file_gop.kv.value = value;
basename_utf16le_null_consumed = true;
return null;
}
} else {
errdefer _ = self.os_data.dir_table.remove(dirname);
const dir = try self.allocator.create(OsData.Dir);
errdefer self.allocator.destroy(dir);
dir.* = OsData.Dir{
.file_table = OsData.FileTable.init(self.allocator),
.table_lock = event.Lock.init(),
.putter_frame = undefined,
};
gop.kv.value = dir;
assert((try dir.file_table.put(basename_utf16le_no_null, value)) == null);
basename_utf16le_null_consumed = true;
dir.putter_frame = async self.windowsDirReader(dir_handle, dir);
dir_handle_consumed = true;
dirname_consumed = true;
return null;
}
}
fn windowsDirReader(self: *Self, dir_handle: windows.HANDLE, dir: *OsData.Dir) void {
self.ref();
defer self.deref();
defer os.close(dir_handle);
var putter_node = std.atomic.Queue(anyframe).Node{
.data = .{ .putter = @frame() },
.prev = null,
.next = null,
};
self.os_data.all_putters.put(&putter_node);
defer _ = self.os_data.all_putters.remove(&putter_node);
var resume_node = Loop.ResumeNode.Basic{
.base = Loop.ResumeNode{
.id = Loop.ResumeNode.Id.Basic,
.handle = @frame(),
.overlapped = windows.OVERLAPPED{
.Internal = 0,
.InternalHigh = 0,
.Offset = 0,
.OffsetHigh = 0,
.hEvent = null,
},
},
};
var event_buf: [4096]u8 align(@alignOf(windows.FILE_NOTIFY_INFORMATION)) = undefined;
// TODO handle this error not in the channel but in the setup
_ = windows.CreateIoCompletionPort(
dir_handle,
global_event_loop.os_data.io_port,
undefined,
undefined,
) catch |err| {
self.channel.put(err);
return;
};
while (!putter_node.data.cancelled) {
{
// TODO only 1 beginOneEvent for the whole function
global_event_loop.beginOneEvent();
errdefer global_event_loop.finishOneEvent();
errdefer {
_ = windows.kernel32.CancelIoEx(dir_handle, &resume_node.base.overlapped);
}
suspend {
_ = windows.kernel32.ReadDirectoryChangesW(
dir_handle,
&event_buf,
@intCast(windows.DWORD, event_buf.len),
windows.FALSE, // watch subtree
windows.FILE_NOTIFY_CHANGE_FILE_NAME | windows.FILE_NOTIFY_CHANGE_DIR_NAME |
windows.FILE_NOTIFY_CHANGE_ATTRIBUTES | windows.FILE_NOTIFY_CHANGE_SIZE |
windows.FILE_NOTIFY_CHANGE_LAST_WRITE | windows.FILE_NOTIFY_CHANGE_LAST_ACCESS |
windows.FILE_NOTIFY_CHANGE_CREATION | windows.FILE_NOTIFY_CHANGE_SECURITY,
null, // number of bytes transferred (unused for async)
&resume_node.base.overlapped,
null, // completion routine - unused because we use IOCP
);
}
}
var bytes_transferred: windows.DWORD = undefined;
if (windows.kernel32.GetOverlappedResult(dir_handle, &resume_node.base.overlapped, &bytes_transferred, windows.FALSE) == 0) {
const err = switch (windows.kernel32.GetLastError()) {
else => |err| windows.unexpectedError(err),
};
self.channel.put(err);
} else {
// can't use @bytesToSlice because of the special variable length name field
var ptr = event_buf[0..].ptr;
const end_ptr = ptr + bytes_transferred;
var ev: *windows.FILE_NOTIFY_INFORMATION = undefined;
while (@ptrToInt(ptr) < @ptrToInt(end_ptr)) : (ptr += ev.NextEntryOffset) {
ev = @ptrCast(*windows.FILE_NOTIFY_INFORMATION, ptr);
const emit = switch (ev.Action) {
windows.FILE_ACTION_REMOVED => WatchEventId.Delete,
windows.FILE_ACTION_MODIFIED => WatchEventId.CloseWrite,
else => null,
};
if (emit) |id| {
const basename_utf16le = ([*]u16)(&ev.FileName)[0 .. ev.FileNameLength / 2];
const user_value = blk: {
const held = dir.table_lock.acquire();
defer held.release();
if (dir.file_table.get(basename_utf16le)) |entry| {
break :blk entry.value;
} else {
break :blk null;
}
};
if (user_value) |v| {
self.channel.put(Event{
.id = id,
.data = v,
});
}
}
if (ev.NextEntryOffset == 0) break;
}
}
}
}
pub fn removeFile(self: *Self, file_path: []const u8) ?V {
@panic("TODO");
}
fn linuxEventPutter(self: *Self) void {
global_event_loop.beginOneEvent();
defer {
self.os_data.table_lock.deinit();
var wd_it = self.os_data.wd_table.iterator();
while (wd_it.next()) |wd_entry| {
var file_it = wd_entry.value.file_table.iterator();
while (file_it.next()) |file_entry| {
self.allocator.free(file_entry.key);
}
self.allocator.free(wd_entry.value.dirname);
wd_entry.value.file_table.deinit();
}
self.os_data.wd_table.deinit();
global_event_loop.finishOneEvent();
os.close(self.os_data.inotify_fd);
self.channel.deinit();
self.allocator.free(self.channel.buffer_nodes);
}
var event_buf: [4096]u8 align(@alignOf(os.linux.inotify_event)) = undefined;
while (!self.os_data.cancelled) {
const rc = os.linux.read(self.os_data.inotify_fd, &event_buf, event_buf.len);
const errno = os.linux.getErrno(rc);
switch (errno) {
0 => {
// can't use @bytesToSlice because of the special variable length name field
var ptr = event_buf[0..].ptr;
const end_ptr = ptr + event_buf.len;
var ev: *os.linux.inotify_event = undefined;
while (@ptrToInt(ptr) < @ptrToInt(end_ptr)) {
ev = @ptrCast(*os.linux.inotify_event, ptr);
if (ev.mask & os.linux.IN_CLOSE_WRITE == os.linux.IN_CLOSE_WRITE) {
const basename_ptr = ptr + @sizeOf(os.linux.inotify_event);
// `ev.len` counts all bytes in `ev.name` including terminating null byte.
const basename_with_null = basename_ptr[0..ev.len];
const user_value = blk: {
const held = self.os_data.table_lock.acquire();
defer held.release();
const dir = &self.os_data.wd_table.get(ev.wd).?.value;
if (dir.file_table.get(basename_with_null)) |entry| {
break :blk entry.value;
} else {
break :blk null;
}
};
if (user_value) |v| {
self.channel.put(Event{
.id = WatchEventId.CloseWrite,
.data = v,
});
}
}
ptr = @alignCast(@alignOf(os.linux.inotify_event), ptr + @sizeOf(os.linux.inotify_event) + ev.len);
}
},
os.linux.EINTR => continue,
os.linux.EINVAL => unreachable,
os.linux.EFAULT => unreachable,
os.linux.EAGAIN => {
global_event_loop.linuxWaitFd(self.os_data.inotify_fd, os.linux.EPOLLET | os.linux.EPOLLIN | os.EPOLLONESHOT);
},
else => unreachable,
}
}
}
};
}
const test_tmp_dir = "std_event_fs_test";
test "write a file, watch it, write it again" {
// TODO re-enable this test
if (true) return error.SkipZigTest;
try fs.cwd().makePath(test_tmp_dir);
defer fs.cwd().deleteTree(test_tmp_dir) catch {};
const allocator = std.heap.page_allocator;
return testFsWatch(&allocator);
}
fn testFsWatch(allocator: *Allocator) !void {
const file_path = try std.fs.path.join(allocator, [_][]const u8{ test_tmp_dir, "file.txt" });
defer allocator.free(file_path);
const contents =
\\line 1
\\line 2
;
const line2_offset = 7;
// first just write then read the file
try writeFile(allocator, file_path, contents);
const read_contents = try readFile(allocator, file_path, 1024 * 1024);
testing.expectEqualSlices(u8, contents, read_contents);
// now watch the file
var watch = try Watch(void).init(allocator, 0);
defer watch.deinit();
testing.expect((try watch.addFile(file_path, {})) == null);
const ev = watch.channel.get();
var ev_consumed = false;
defer if (!ev_consumed) await ev;
// overwrite line 2
const fd = try await openReadWrite(file_path, File.default_mode);
{
defer os.close(fd);
try pwritev(allocator, fd, []const []const u8{"lorem ipsum"}, line2_offset);
}
ev_consumed = true;
switch ((try await ev).id) {
WatchEventId.CloseWrite => {},
WatchEventId.Delete => @panic("wrong event"),
}
const contents_updated = try readFile(allocator, file_path, 1024 * 1024);
testing.expectEqualSlices(u8,
\\line 1
\\lorem ipsum
, contents_updated);
// TODO test deleting the file and then re-adding it. we should get events for both
}
|
lib/std/fs/watch.zig
|
const std = @import("std");
const mem = std.mem;
const assert = std.debug.assert;
pub fn Ast(comptime T: type) type {
return struct {
const Self = @This();
allocator: *mem.Allocator,
data: T,
parent: ?*Self = null,
prev: ?*Self = null,
next: ?*Self = null,
first_child: ?*Self = null,
last_child: ?*Self = null,
pub fn create(allocator: *mem.Allocator, data: T) !*Self {
var obj = try allocator.create(Self);
obj.* = .{
.allocator = allocator,
.data = data,
};
return obj;
}
pub fn deinit(self: *Self) void {
self.data.deinit(self.allocator);
var it = self.first_child;
while (it) |child| {
var next = child.next;
child.deinit();
it = next;
}
self.allocator.destroy(self);
}
pub fn append(self: *Self, child: *Self) void {
child.detach();
child.parent = self;
if (self.last_child) |last_child| {
child.prev = last_child;
assert(last_child.next == null);
last_child.next = child;
} else {
assert(self.first_child == null);
self.first_child = child;
}
self.last_child = child;
}
pub fn insertAfter(self: *Self, sibling: *Self) void {
sibling.detach();
sibling.parent = self.parent;
sibling.prev = self;
if (self.next) |next| {
assert(next.prev.? == self);
next.prev = sibling;
sibling.next = next;
} else if (self.parent) |parent| {
assert(parent.last_child.? == self);
parent.last_child = sibling;
}
self.next = sibling;
}
pub fn insertBefore(self: *Self, sibling: *Self) void {
sibling.detach();
sibling.parent = self.parent;
sibling.next = self;
if (self.prev) |prev| {
sibling.prev = prev;
assert(prev.next.? == self);
prev.next = sibling;
} else if (self.parent) |parent| {
assert(parent.first_child.? == self);
parent.first_child = sibling;
}
self.prev = sibling;
}
pub fn detach(self: *Self) void {
if (self.next) |next| {
next.prev = self.prev;
} else if (self.parent) |parent| {
parent.last_child = self.prev;
}
if (self.prev) |prev| {
prev.next = self.next;
} else if (self.parent) |parent| {
parent.first_child = self.next;
}
self.parent = null;
self.prev = null;
self.next = null;
}
pub fn detachDeinit(self: *Self) void {
self.detach();
self.deinit();
}
pub const ReverseChildrenIterator = struct {
next_value: ?*Self,
pub fn next(self: *@This()) ?*Self {
var to_return = self.next_value;
if (to_return) |n| {
self.next_value = n.prev;
}
return to_return;
}
};
pub fn reverseChildrenIterator(self: *Self) ReverseChildrenIterator {
return .{ .next_value = self.last_child };
}
pub const TraverseIterator = struct {
root: *Self,
upcoming: ?NodeEdge,
const NodeEdge = union(enum) {
Start: *Self,
End: *Self,
};
pub fn next(self: *@This()) ?NodeEdge {
const item = self.upcoming orelse return null;
self.upcoming = switch (item) {
.Start => |node| if (node.first_child) |child|
NodeEdge{ .Start = child }
else
NodeEdge{ .End = node },
.End => |node| if (node == self.root)
null
else if (node.next) |sibling|
NodeEdge{ .Start = sibling }
else if (node.parent) |parent|
NodeEdge{ .End = parent }
else
unreachable,
};
return item;
}
};
pub fn traverseIterator(self: *Self) TraverseIterator {
return .{ .root = self, .upcoming = .{ .Start = self } };
}
pub const DescendantsIterator = struct {
traverse: TraverseIterator,
pub fn next(self: *@This()) ?*Self {
while (true) {
if (self.traverse.next()) |edge| switch (edge) {
.Start => |node| return node,
.End => {},
} else {
return null;
}
}
}
};
pub fn descendantsIterator(self: *Self) DescendantsIterator {
return .{ .traverse = traverseIterator(self) };
}
// These don't quite belong.
pub fn lastChildIsOpen(self: *Self) bool {
if (self.last_child) |n| {
return n.data.open;
}
return false;
}
pub fn endsWithBlankLine(self: *Self) bool {
var it: ?*Self = self;
while (it) |cur| {
if (cur.data.last_line_blank)
return true;
switch (cur.data.value) {
.List, .Item => it = cur.last_child,
else => it = null,
}
}
return false;
}
};
}
|
src/ast.zig
|
const Address = std.net.Address;
const Allocator = std.mem.Allocator;
const LinearFifo = std.fifo.LinearFifo;
const network = @import("network");
const std = @import("std");
const tls = @import("iguanaTLS");
const Uri = @import("http").Uri;
pub const TcpSocket = SocketWrapper(ZigNetwork);
pub const SocketMock = SocketWrapper(NetworkMock);
fn SocketWrapper(comptime Engine: type) type {
return struct {
target: Engine.Socket,
tls_context: TlsContext = undefined,
const Self = @This();
pub const Reader = std.io.Reader(Self, Engine.Socket.ReceiveError, read);
pub const Writer = std.io.Writer(Self, Engine.Socket.SendError, write);
const TlsContext = tls.Client(Engine.Socket.Reader, Engine.Socket.Writer, tls.ciphersuites.all, true);
pub fn connect(allocator: *Allocator, uri: Uri) !Self {
var defaultPort: u16 = if (std.mem.eql(u8, uri.scheme, "https")) 443 else 80;
var port: u16 = uri.port orelse defaultPort;
var socket = switch (uri.host) {
.name => |host| try Self.connectToHost(allocator, host, port),
.ip => |address| try Self.connectToAddress(allocator, address),
};
return Self{ .target = socket };
}
pub fn close(self: *Self) void {
self.target.close();
}
pub fn writer(self: Self) Writer {
return .{ .context = self };
}
pub fn reader(self: Self) Reader {
return .{ .context = self };
}
pub fn read(self: Self, buffer: []u8) !usize {
return self.target.receive(buffer);
}
pub fn write(self: Self, buffer: []const u8) !usize {
return self.target.send(buffer);
}
fn connectToHost(allocator: *Allocator, host: []const u8, port: u16) !Engine.Socket {
return try Engine.connectToHost(allocator, host, port, .tcp);
}
fn connectToAddress(_: *Allocator, address: Address) !Engine.Socket {
switch (address.any.family) {
std.os.AF.INET => {
const bytes = @ptrCast(*const [4]u8, &address.in.sa.addr);
var ipv4 = network.Address{ .ipv4 = network.Address.IPv4.init(bytes[0], bytes[1], bytes[2], bytes[3]) };
var port = address.getPort();
var endpoint = network.EndPoint{ .address = ipv4, .port = port };
var socket = try Engine.Socket.create(.ipv4, .tcp);
try socket.connect(endpoint);
return socket;
},
else => unreachable,
}
}
};
}
const ZigNetwork = struct {
const Socket = network.Socket;
fn connectToHost(allocator: *Allocator, host: []const u8, port: u16, protocol: network.Protocol) !Socket {
return try network.connectToHost(allocator, host, port, protocol);
}
};
const NetworkMock = struct {
const Socket = InMemorySocket;
pub fn connectToHost(allocator: *Allocator, host: []const u8, port: u16, protocol: network.Protocol) !Socket {
_ = allocator;
_ = host;
_ = port;
_ = protocol;
return try Socket.create(.{}, .{});
}
};
const InMemorySocket = struct {
const Context = struct {
read_buffer: ReadBuffer,
write_buffer: WriteBuffer,
const ReadBuffer = LinearFifo(u8, .Dynamic);
const WriteBuffer = std.ArrayList(u8);
pub fn create() !*Context {
var context = try std.mem.Allocator.create(std.testing.allocator, Context);
context.read_buffer = ReadBuffer.init(std.testing.allocator);
context.write_buffer = WriteBuffer.init(std.testing.allocator);
return context;
}
pub fn deinit(self: *Context) void {
self.read_buffer.deinit();
self.write_buffer.deinit();
}
};
context: *Context,
pub const Reader = std.io.Reader(InMemorySocket, ReceiveError, receive);
pub const ReceiveError = anyerror;
pub const Writer = std.io.Writer(InMemorySocket, SendError, send);
pub const SendError = anyerror;
pub fn create(address: anytype, protocol: anytype) !InMemorySocket {
_ = address;
_ = protocol;
return InMemorySocket{ .context = try Context.create() };
}
pub fn close(self: InMemorySocket) void {
self.context.deinit();
std.mem.Allocator.destroy(std.testing.allocator, self.context);
}
pub fn connect(self: InMemorySocket, options: anytype) !void {
_ = self;
_ = options;
}
pub fn has_sent(self: InMemorySocket, data: []const u8) bool {
return std.mem.eql(u8, self.context.write_buffer.items, data);
}
pub fn has_received(self: InMemorySocket, data: []const u8) !void {
try self.context.read_buffer.write(data);
}
pub fn receive(self: InMemorySocket, dest: []u8) !usize {
return self.context.read_buffer.read(dest);
}
pub fn send(self: InMemorySocket, bytes: []const u8) !usize {
self.context.write_buffer.appendSlice(bytes) catch unreachable;
return bytes.len;
}
pub fn reader(self: InMemorySocket) Reader {
return .{ .context = self };
}
pub fn writer(self: InMemorySocket) Writer {
return .{ .context = self };
}
};
|
src/socket.zig
|
const std = @import("std");
const Allocator = std.mem.Allocator;
const objects = @import("objects.zig");
const GameObject = objects.GameObject;
pub const Component = struct {
data: usize,
allocator: Allocator,
name: []const u8,
gameObject: *GameObject = undefined,
// TODO: index into a scene array of objects
pub fn from(allocator: Allocator, x: anytype) !Component {
const T = @TypeOf(x);
var copy = try allocator.create(T);
copy.* = x;
return Component {
.data = if (@sizeOf(T) == 0) 0 else @ptrToInt(copy),
.allocator = allocator,
.name = @typeName(T),
};
}
/// Get the type name of this component.
pub fn getName(self: *const Component) []const u8 {
return self.name.*;
}
/// Get the data, as type T, holded in this component.
pub fn getData(self: *const Component, comptime T: type) *T {
if (@sizeOf(T) == 0) {
return undefined;
} else {
return @intToPtr(*T, self.data);
}
}
pub fn deinit(self: *Component) void {
if (self.data != 0) {
self.allocator.destroy(@intToPtr(*u8, self.data));
}
}
};
pub const ComponentOptions = struct {
/// Functions called regularly depending on the updateTarget value of the Application.
updateFn: ?fn(allocator: Allocator, component: *Component, delta: f32) anyerror!void = null
};
/// System selector to select objects where component T has just been created.
pub fn Created(comptime T: type) type {
_ = T;
}
/// System selector to select objects without component T, you should feed a struct type instead of a pointer to struct type as the
/// pointer info (const or not const) is not used for a Without query.
pub fn Without(comptime T: type) type {
_ = T;
}
/// System selector to select objects with component T, you should feed a pointer to struct type as the
/// pointer info (const or not const) is used for a With query.
/// This is also the default system selector.
pub fn With(comptime T: type) type {
_ = T;
return struct {
const is_condition = true;
pub fn include(go: GameObject) bool {
_ = go;
return true;
}
};
}
fn getComponents(comptime parameters: anytype) []type {
const info = @typeInfo(@TypeOf(parameters)).Struct;
var types: [info.fields.len]type = undefined;
for (info.fields) |field, i| {
types[i] = @field(parameters, field.name);
if (!std.meta.trait.isSingleItemPtr(types[i])) {
@compileError("Invalid type " ++ @typeName(types[i]) ++ ", must be *" ++ @typeName(types[i]) ++ " or *const " ++ @typeName(types[i]));
}
}
return &types;
}
// fn testSystem(pos: *Position, vel: *const Velocity); is used for single item systems
// fn testSystem(ent: Query(.{*Mob}), obs: Query(.{*const Obstacle}))
// fn testSystem(x: Query(.{Without(Velocity), With(*Position)})) without doesn't need a pointer
// Example: Query(.{*Position, *const Velocity})
// You have to specify something like Query(.{*Position, *const Velocity, .sync=true}) to avoid this
/// Queries are to be used for processing multiple components at a time
pub fn Query(comptime parameters: anytype) type {
const SystemQuery = struct {
const Self = @This();
scene: *objects.Scene,
const Result = blk: {
const StructField = std.builtin.TypeInfo.StructField;
var fields: []const StructField = &[0]StructField {};
const comps = getComponents(parameters);
for (comps) |comp| {
const name = @typeName(std.meta.Child(comp));
var newName: [name.len]u8 = undefined;
newName = name.*;
newName[0] = std.ascii.toLower(newName[0]);
const field = StructField {
.name = &newName,
.field_type = comp,
.default_value = null,
.is_comptime = false,
.alignment = @alignOf(comp)
};
fields = fields ++ &[_]StructField {field};
}
const info = std.builtin.TypeInfo {
.Struct = .{
.layout = .Auto,
.fields = fields,
.decls = &[0]std.builtin.TypeInfo.Declaration {},
.is_tuple = false
}
};
break :blk @Type(info);
};
const Iterator = struct {
pos: usize = 0,
query: *const Self,
pub fn next(self: *Iterator) ?Result {
const scene = self.query.scene;
while (self.pos < scene.objects.items.len) : (self.pos += 1) {
const obj = scene.objects.items[self.pos];
const comps = getComponents(parameters);
var result: Result = undefined;
// TODO: use filters
var ok: bool = true;
inline for (comps) |comp| {
const name = @typeName(std.meta.Child(comp));
comptime var newName: [name.len]u8 = undefined;
newName = name.*;
newName[0] = comptime std.ascii.toLower(newName[0]);
if (obj.getComponent(std.meta.Child(comp))) |cp| {
@field(result, &newName) = cp;
} else {
ok = false;
}
}
if (ok) {
self.pos += 1;
return result;
}
}
return null;
}
};
pub fn iterator(self: *const @This()) Iterator {
return Iterator { .query = self };
}
pub fn parallelIterator(self: *const @This(), divides: usize) Iterator {
_ = self;
_ = divides;
@compileError("TODO");
}
};
return SystemQuery;
}
comptime {
std.testing.refAllDecls(@This());
}
|
didot-objects/components.zig
|
const Builder = @import("std").build.Builder;
const builtin = @import("builtin");
const std = @import("std");
const CheckFileStep = std.build.CheckFileStep;
pub fn build(b: *Builder) void {
const target = .{
.cpu_arch = .thumb,
.cpu_model = .{ .explicit = &std.Target.arm.cpu.cortex_m4 },
.os_tag = .freestanding,
.abi = .gnueabihf,
};
const mode = b.standardReleaseOptions();
const elf = b.addExecutable("zig-nrf52-blink.elf", "main.zig");
elf.setTarget(target);
elf.setBuildMode(mode);
const test_step = b.step("test", "Test the program");
b.default_step.dependOn(test_step);
const hex_step = b.addInstallRaw(elf, "hello.hex");
test_step.dependOn(&hex_step.step);
const explicit_format_hex_step = b.addInstallRawWithFormat(elf, "hello.foo", .hex);
test_step.dependOn(&explicit_format_hex_step.step);
const expected_hex = &[_][]const u8{
":020000021000EC",
":1000D400D001010001000000D20101000100000074",
":1000E40028020100010000002402010001000000B8",
":1000F4003A02010001000000E202010001000000D8",
":100104000C03010001000000A50202000000000031",
":1001140000000000000000000000000000000000DB",
":1001240000000000000000000000000000000000CB",
":1001340000000000000000000000000000000000BB",
":10014400AF02020098020100090000004D02010004",
":100154000900000001000000000000000000000091",
":1001640000080002008001010004000010000000EB",
":100174000000000000000000000000001F0000005C",
":1001840048010100000040888000FF01142800524B",
":100194000080610100040020110000000000000044",
":1001A40000000000000000001F000000000000002C",
":1001B400000000000000000000000000000000003B",
":1001C400000000000000000000000000000000002B",
":1001D400000000000000000000000000000000001B",
":1001E400000000000000000000000000000000000B",
":1001F4000000000000000000000000008702010071",
":1002040010000000200201002C0000006B0201001D",
":100214001B000000570201001300000072656D61AD",
":10022400696E646572206469766973696F6E2062B1",
":1002340079207A65726F206F72206E6567617469C8",
":1002440076652076616C756500636F727465782DD0",
":100254006D3400696E646578206F7574206F662054",
":10026400626F756E647300696E746567657220638E",
":10027400617374207472756E63617465642062695D",
":100284007473006469766973696F6E206279207A89",
":1002940065726F00636F727465785F6D340000007F",
":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",
":1002B4000391029007A800F029F803990020069002",
":1002C40048680490FFE704990698019088420FD289",
":1002D400FFE7019903980068405C07F8310C17F8B0",
":1002E400311C07A800F021F8019801300690EAE7D4",
":1002F400029807A9B1E80C50A0E80C5091E81C50F2",
":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",
":1003140040F2DC11C0F20101B1E80C50A0E80C502D",
":1003240091E81C5080E81C50D0BD80B56F4688B061",
":1003340006906FF35F2127F80A1C37F80A0C049023",
":10034400012038B9FFE740F20020C0F2010000218B",
":10035400FFF7A6FF0498C0F3431027F8020C37F800",
":100364000A0C0390002038B9FFE7039800F01F003F",
":100374000290012038B914E040F20820C0F20100D4",
":100384000021FFF78DFF029800F01F0007F8030C0F",
":100394000698009037F8020C0146019109280ED303",
":1003A40006E040F21020C0F201000021FFF778FFC0",
":1003B40040F21820C0F201000021FFF771FF0099FC",
":1003C400019A51F8220017F803CC012303FA0CF325",
":1003D400184341F8220008B080BD81B000F03F000E",
":1003E4008DF802009DF802000F3000F03F00022853",
":1003F40004D3FFE700208DF8030003E001208DF80B",
":100404000300FFE79DF8030001B070470A000000F5",
":1004140012000000020071001200000066000000DB",
":1004240003007D0C06000000000000000001110123",
":10043400250E1305030E10171B0EB44219110112D9",
":0604440006000002340076",
":020000021000EC",
":1000D400D001010001000000D20101000100000074",
":1000E40028020100010000002402010001000000B8",
":1000F4003A02010001000000E202010001000000D8",
":100104000C03010001000000A50202000000000031",
":1001140000000000000000000000000000000000DB",
":1001240000000000000000000000000000000000CB",
":1001340000000000000000000000000000000000BB",
":10014400AF02020098020100090000004D02010004",
":100154000900000001000000000000000000000091",
":1001640000080002008001010004000010000000EB",
":100174000000000000000000000000001F0000005C",
":1001840048010100000040888000FF01142800524B",
":100194000080610100040020110000000000000044",
":1001A40000000000000000001F000000000000002C",
":1001B400000000000000000000000000000000003B",
":1001C400000000000000000000000000000000002B",
":1001D400000000000000000000000000000000001B",
":1001E400000000000000000000000000000000000B",
":1001F4000000000000000000000000008702010071",
":1002040010000000200201002C0000006B0201001D",
":100214001B000000570201001300000072656D61AD",
":10022400696E646572206469766973696F6E2062B1",
":1002340079207A65726F206F72206E6567617469C8",
":1002440076652076616C756500636F727465782DD0",
":100254006D3400696E646578206F7574206F662054",
":10026400626F756E647300696E746567657220638E",
":10027400617374207472756E63617465642062695D",
":100284007473006469766973696F6E206279207A89",
":1002940065726F00636F727465785F6D340000007F",
":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",
":1002B4000391029007A800F029F803990020069002",
":1002C40048680490FFE704990698019088420FD289",
":1002D400FFE7019903980068405C07F8310C17F8B0",
":1002E400311C07A800F021F8019801300690EAE7D4",
":1002F400029807A9B1E80C50A0E80C5091E81C50F2",
":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",
":1003140040F2DC11C0F20101B1E80C50A0E80C502D",
":1003240091E81C5080E81C50D0BD80B56F4688B061",
":1003340006906FF35F2127F80A1C37F80A0C049023",
":10034400012038B9FFE740F20020C0F2010000218B",
":10035400FFF7A6FF0498C0F3431027F8020C37F800",
":100364000A0C0390002038B9FFE7039800F01F003F",
":100374000290012038B914E040F20820C0F20100D4",
":100384000021FFF78DFF029800F01F0007F8030C0F",
":100394000698009037F8020C0146019109280ED303",
":1003A40006E040F21020C0F201000021FFF778FFC0",
":1003B40040F21820C0F201000021FFF771FF0099FC",
":1003C400019A51F8220017F803CC012303FA0CF325",
":1003D400184341F8220008B080BD81B000F03F000E",
":1003E4008DF802009DF802000F3000F03F00022853",
":1003F40004D3FFE700208DF8030003E001208DF80B",
":100404000300FFE79DF8030001B070470A000000F5",
":1004140012000000020071001200000066000000DB",
":1004240003007D0C06000000000000000001110123",
":10043400250E1305030E10171B0EB44219110112D9",
":0604440006000002340076",
":020000022000DC",
":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",
":1002B4000391029007A800F029F803990020069002",
":1002C40048680490FFE704990698019088420FD289",
":1002D400FFE7019903980068405C07F8310C17F8B0",
":1002E400311C07A800F021F8019801300690EAE7D4",
":1002F400029807A9B1E80C50A0E80C5091E81C50F2",
":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",
":1003140040F2DC11C0F20101B1E80C50A0E80C502D",
":1003240091E81C5080E81C50D0BD80B56F4688B061",
":1003340006906FF35F2127F80A1C37F80A0C049023",
":10034400012038B9FFE740F20020C0F2010000218B",
":10035400FFF7A6FF0498C0F3431027F8020C37F800",
":100364000A0C0390002038B9FFE7039800F01F003F",
":100374000290012038B914E040F20820C0F20100D4",
":100384000021FFF78DFF029800F01F0007F8030C0F",
":100394000698009037F8020C0146019109280ED303",
":1003A40006E040F21020C0F201000021FFF778FFC0",
":1003B40040F21820C0F201000021FFF771FF0099FC",
":1003C400019A51F8220017F803CC012303FA0CF325",
":1003D400184341F8220008B080BD81B000F03F000E",
":1003E4008DF802009DF802000F3000F03F00022853",
":1003F40004D3FFE700208DF8030003E001208DF80B",
":0C0404000300FFE79DF8030001B0704703",
":00000001FF",
};
test_step.dependOn(&CheckFileStep.create(b, hex_step.getOutputSource(), expected_hex).step);
test_step.dependOn(&CheckFileStep.create(b, explicit_format_hex_step.getOutputSource(), expected_hex).step);
}
|
test/standalone/install_raw_hex/build.zig
|
const std = @import("std");
const tools = @import("tools");
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);
}
pub fn main() anyerror!void {
const stdout = std.io.getStdOut().writer();
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, "day22.txt", limit);
defer allocator.free(text);
const Disk = struct {
x: u8,
y: u8,
total: u16,
used: u16,
};
var alldiscs: [2000]Disk = undefined;
const discs = blk: {
var len: usize = 0;
var it = std.mem.tokenize(u8, text, "\n");
while (it.next()) |line| {
// "Filesystem Size Used Avail Use%"
// "/dev/grid/node-x19-y28 85T 68T 17T 80%"
const name = line[0..23];
const size_total = line[23..28];
const size_used = line[29..34];
const size_avail = line[35..41];
const d = &alldiscs[len];
len += 1;
if (tools.match_pattern("/dev/grid/node-x{}-y{}", name)) |vals| {
d.x = @intCast(u8, vals[0].imm);
d.y = @intCast(u8, vals[1].imm);
} else {
unreachable;
}
d.total = @intCast(u16, (tools.match_pattern("{}T", size_total) orelse unreachable)[0].imm);
d.used = @intCast(u16, (tools.match_pattern("{}T", size_used) orelse unreachable)[0].imm);
const avail = @intCast(u16, (tools.match_pattern("{}T", size_avail) orelse unreachable)[0].imm);
assert(d.used + avail == d.total);
}
break :blk alldiscs[0..len];
};
try stdout.print("=== part1 ===========================\n", .{});
var w: u32 = 0;
var h: u32 = 0;
{
var count: usize = 0;
for (discs) |d1, i| {
w = if (w < d1.x) d1.x else w;
h = if (h < d1.y) d1.y else h;
for (discs) |d2, j| {
if (j == i)
continue;
if (d1.used == 0)
continue;
if (d1.used > (d2.total - d2.used))
continue;
count += 1;
}
}
w += 1;
h += 1;
try stdout.print("pair count={}, size={}x{}, nbnodes={}\n", .{ count, w, h, discs.len });
}
try stdout.print("=== part2 ===========================\n", .{});
{
// Je pense qu'il faut observer que en fait tout est plein à >50%, et que donc
// les seuls trucs utiles à traquer sont la case vide et les doi. (car on pourra jamais merger deux nodes)
const Usage = packed struct {
doi: u1,
used: u15,
};
const Trace = struct {
usages: [30 * 35]Usage,
text: [4000]u8,
len: usize,
};
const State = [30 * 35]enum(u2) {
empty,
doi,
movable,
unmovable,
};
const stride = w;
var map0: [30 * 35]Disk = undefined;
var cur: State = undefined;
var trc0: Trace = .{ .text = undefined, .len = 0, .usages = undefined };
for (discs) |d| {
const i = stride * @intCast(usize, d.y) + d.x;
map0[i] = d;
const doi = (d.y == 0 and d.x == w - 1);
trc0.usages[i].doi = if (doi) 1 else 0;
trc0.usages[i].used = @intCast(u15, d.used);
if (d.used == 0) {
assert(!doi);
cur[i] = .empty;
} else if (d.used > 200) {
assert(!doi);
cur[i] = .unmovable;
} else if (doi) {
cur[i] = .doi;
} else {
cur[i] = .movable;
}
}
const doimoveweight: i32 = 5;
var dfs = tools.BestFirstSearch(State, Trace).init(allocator);
defer dfs.deinit();
try dfs.insert(.{
.steps = 0,
.rating = doimoveweight * @intCast(i32, w),
.state = cur,
.trace = trc0,
});
trace("sizeof(state)=={}\n", .{@sizeOf(State)});
var depth: u32 = 0;
var best: ?u32 = null;
while (dfs.pop()) |node| {
if (node.state[0 + stride * 0] == .doi) {
try stdout.print("got the data in {} steps: {}\n", .{ node.steps, node.trace.text[0..node.trace.len] });
if (best == null or best.? > node.steps)
best = node.steps;
continue;
}
if (best != null and node.steps >= best.?)
continue;
if (node.steps > depth) {
trace("reached depth = {}, with rating {}, visitednodes={}, agendlen={}\n", .{ node.steps, node.rating, dfs.visited.count(), dfs.agenda.items.len });
depth = node.steps;
{
for (node.state[0 .. w * h]) |s, i| {
if (i != 0 and (i % stride) == 0)
trace("\n", .{});
const char: u8 = switch (s) {
.doi => 'x',
.empty => '_',
.unmovable => '#',
.movable => '.',
};
trace("{c}", .{char});
}
trace("\n", .{});
}
}
// compute next steps
var m = node.state;
var moves: u32 = 0;
var trc: Trace = node.trace;
for (m[0 .. w * h]) |*to, i| {
if (to.* != .empty)
continue;
const used = node.trace.usages[i].used;
const avail = map0[i].total - used;
const x = i % stride;
const y = i / stride;
assert(x < w and y < h);
if (x > 0) {
const j = i - 1;
const from = &m[j];
const from_used = node.trace.usages[j].used;
const from_doi = node.trace.usages[j].doi != 0;
if (from_used > 0 and from_used < avail) {
assert(!from_doi or used == 0);
const from_bak = from.*;
const to_bak = to.*;
trc.usages[i] = node.trace.usages[j];
trc.usages[j].used = 0;
trc.usages[j].doi = 0;
to.* = from.*;
from.* = .empty;
assert(trc.usages[i].used <= map0[i].total);
const rating = node.rating + 1 + if (from_doi) doimoveweight else 0;
trc.len = node.trace.len;
tools.fmt_bufAppend(&trc.text, &trc.len, "{}x{}->{}x{}, ", .{ x - 1, y, x, y });
moves += 1;
try dfs.insert(.{
.steps = node.steps + 1,
.rating = rating,
.state = m,
.trace = trc,
});
to.* = to_bak;
from.* = from_bak;
trc.len = node.trace.len;
trc.usages[i] = node.trace.usages[i];
trc.usages[j] = node.trace.usages[j];
}
}
if (x < w - 1) {
const j = i + 1;
const from = &m[j];
const from_used = node.trace.usages[j].used;
const from_doi = node.trace.usages[j].doi != 0;
if (from_used > 0 and from_used < avail) {
assert(!from_doi or used == 0);
const from_bak = from.*;
const to_bak = to.*;
trc.usages[i] = node.trace.usages[j];
trc.usages[j].used = 0;
trc.usages[j].doi = 0;
to.* = from.*;
from.* = .empty;
assert(trc.usages[i].used <= map0[i].total);
const rating = node.rating + 1 - if (from_doi) doimoveweight else 0;
trc.len = node.trace.len;
tools.fmt_bufAppend(&trc.text, &trc.len, "{}x{}->{}x{}, ", .{ x + 1, y, x, y });
moves += 1;
try dfs.insert(.{
.steps = node.steps + 1,
.rating = rating,
.state = m,
.trace = trc,
});
to.* = to_bak;
from.* = from_bak;
trc.len = node.trace.len;
trc.usages[i] = node.trace.usages[i];
trc.usages[j] = node.trace.usages[j];
}
}
if (y > 0) {
const j = i - stride;
const from = &m[j];
const from_used = node.trace.usages[j].used;
const from_doi = node.trace.usages[j].doi != 0;
if (from_used > 0 and from_used < avail) {
assert(!from_doi or used == 0);
const from_bak = from.*;
const to_bak = to.*;
trc.usages[i] = node.trace.usages[j];
trc.usages[j].used = 0;
trc.usages[j].doi = 0;
to.* = from.*;
from.* = .empty;
assert(trc.usages[i].used <= map0[i].total);
const rating = node.rating + 1 + if (from_doi) doimoveweight else 0;
trc.len = node.trace.len;
tools.fmt_bufAppend(&trc.text, &trc.len, "{}x{}->{}x{}, ", .{ x, y - 1, x, y });
moves += 1;
try dfs.insert(.{
.steps = node.steps + 1,
.rating = rating,
.state = m,
.trace = trc,
});
to.* = to_bak;
from.* = from_bak;
trc.len = node.trace.len;
trc.usages[i] = node.trace.usages[i];
trc.usages[j] = node.trace.usages[j];
}
}
if (y < h - 1) {
const j = i + stride;
const from = &m[j];
const from_used = node.trace.usages[j].used;
const from_doi = node.trace.usages[j].doi != 0;
if (from_used > 0 and from_used < avail) {
assert(!from_doi or used == 0);
const from_bak = from.*;
const to_bak = to.*;
trc.usages[i] = node.trace.usages[j];
trc.usages[j].used = 0;
trc.usages[j].doi = 0;
to.* = from.*;
from.* = .empty;
assert(trc.usages[i].used <= map0[i].total);
const rating = node.rating + 1 - if (from_doi) doimoveweight else 0;
trc.len = node.trace.len;
tools.fmt_bufAppend(&trc.text, &trc.len, "{}x{}->{}x{}, ", .{ x, y + 1, x, y });
moves += 1;
try dfs.insert(.{
.steps = node.steps + 1,
.rating = rating,
.state = m,
.trace = trc,
});
to.* = to_bak;
from.* = from_bak;
trc.len = node.trace.len;
trc.usages[i] = node.trace.usages[i];
trc.usages[j] = node.trace.usages[j];
}
}
}
// trace("moves for step : {}\n", .{moves});
}
}
}
|
2016/day22.zig
|
const idt = @import("idt.zig");
// Interrupt Service Routines defined externally in assembly.
extern fn isr0()void; extern fn isr1()void; extern fn isr2()void; extern fn isr3()void;
extern fn isr4()void; extern fn isr5()void; extern fn isr6()void; extern fn isr7()void;
extern fn isr8()void; extern fn isr9()void; extern fn isr10()void; extern fn isr11()void;
extern fn isr12()void; extern fn isr13()void; extern fn isr14()void; extern fn isr15()void;
extern fn isr16()void; extern fn isr17()void; extern fn isr18()void; extern fn isr19()void;
extern fn isr20()void; extern fn isr21()void; extern fn isr22()void; extern fn isr23()void;
extern fn isr24()void; extern fn isr25()void; extern fn isr26()void; extern fn isr27()void;
extern fn isr28()void; extern fn isr29()void; extern fn isr30()void; extern fn isr31()void;
extern fn isr32()void; extern fn isr33()void; extern fn isr34()void; extern fn isr35()void;
extern fn isr36()void; extern fn isr37()void; extern fn isr38()void; extern fn isr39()void;
extern fn isr40()void; extern fn isr41()void; extern fn isr42()void; extern fn isr43()void;
extern fn isr44()void; extern fn isr45()void; extern fn isr46()void; extern fn isr47()void;
extern fn isr128()void;
// Context saved by Interrupt Service Routines.
pub const Context = packed struct {
registers: Registers, // General purpose registers.
interrupt_n: u32, // Number of the interrupt.
error_code: u32, // Associated error code (or 0).
// CPU status:
eip: u32,
cs: u32,
eflags: u32,
esp: u32,
ss: u32,
pub inline fn setReturnValue(self: &volatile Context, value: var) void {
self.registers.eax = usize(value);
}
};
// Structure holding general purpose registers as saved by PUSHA.
pub const Registers = packed struct {
edi: u32, esi: u32, ebp: u32, esp: u32,
ebx: u32, edx: u32, ecx: u32, eax: u32,
pub fn init() Registers {
return Registers {
.edi = 0, .esi = 0, .ebp = 0, .esp = 0,
.ebx = 0, .edx = 0, .ecx = 0, .eax = 0,
};
}
};
// Pointer to the current saved context.
pub export var context: &volatile Context = undefined;
////
// Install the Interrupt Service Routines in the IDT.
//
pub fn install() void {
// Exceptions.
idt.setGate(0, idt.INTERRUPT_GATE, isr0);
idt.setGate(1, idt.INTERRUPT_GATE, isr1);
idt.setGate(2, idt.INTERRUPT_GATE, isr2);
idt.setGate(3, idt.INTERRUPT_GATE, isr3);
idt.setGate(4, idt.INTERRUPT_GATE, isr4);
idt.setGate(5, idt.INTERRUPT_GATE, isr5);
idt.setGate(6, idt.INTERRUPT_GATE, isr6);
idt.setGate(7, idt.INTERRUPT_GATE, isr7);
idt.setGate(8, idt.INTERRUPT_GATE, isr8);
idt.setGate(9, idt.INTERRUPT_GATE, isr9);
idt.setGate(10, idt.INTERRUPT_GATE, isr10);
idt.setGate(11, idt.INTERRUPT_GATE, isr11);
idt.setGate(12, idt.INTERRUPT_GATE, isr12);
idt.setGate(13, idt.INTERRUPT_GATE, isr13);
idt.setGate(14, idt.INTERRUPT_GATE, isr14);
idt.setGate(15, idt.INTERRUPT_GATE, isr15);
idt.setGate(16, idt.INTERRUPT_GATE, isr16);
idt.setGate(17, idt.INTERRUPT_GATE, isr17);
idt.setGate(18, idt.INTERRUPT_GATE, isr18);
idt.setGate(19, idt.INTERRUPT_GATE, isr19);
idt.setGate(20, idt.INTERRUPT_GATE, isr20);
idt.setGate(21, idt.INTERRUPT_GATE, isr21);
idt.setGate(22, idt.INTERRUPT_GATE, isr22);
idt.setGate(23, idt.INTERRUPT_GATE, isr23);
idt.setGate(24, idt.INTERRUPT_GATE, isr24);
idt.setGate(25, idt.INTERRUPT_GATE, isr25);
idt.setGate(26, idt.INTERRUPT_GATE, isr26);
idt.setGate(27, idt.INTERRUPT_GATE, isr27);
idt.setGate(28, idt.INTERRUPT_GATE, isr28);
idt.setGate(29, idt.INTERRUPT_GATE, isr29);
idt.setGate(30, idt.INTERRUPT_GATE, isr30);
idt.setGate(31, idt.INTERRUPT_GATE, isr31);
// IRQs.
idt.setGate(32, idt.INTERRUPT_GATE, isr32);
idt.setGate(33, idt.INTERRUPT_GATE, isr33);
idt.setGate(34, idt.INTERRUPT_GATE, isr34);
idt.setGate(35, idt.INTERRUPT_GATE, isr35);
idt.setGate(36, idt.INTERRUPT_GATE, isr36);
idt.setGate(37, idt.INTERRUPT_GATE, isr37);
idt.setGate(38, idt.INTERRUPT_GATE, isr38);
idt.setGate(39, idt.INTERRUPT_GATE, isr39);
idt.setGate(40, idt.INTERRUPT_GATE, isr40);
idt.setGate(41, idt.INTERRUPT_GATE, isr41);
idt.setGate(42, idt.INTERRUPT_GATE, isr42);
idt.setGate(43, idt.INTERRUPT_GATE, isr43);
idt.setGate(44, idt.INTERRUPT_GATE, isr44);
idt.setGate(45, idt.INTERRUPT_GATE, isr45);
idt.setGate(46, idt.INTERRUPT_GATE, isr46);
idt.setGate(47, idt.INTERRUPT_GATE, isr47);
// Syscalls.
idt.setGate(128, idt.SYSCALL_GATE, isr128);
}
|
kernel/isr.zig
|
const os = @import("root").os;
const regs = @import("regs.zig");
const std = @import("std");
const builtin = @import("builtin");
const interrupts = @import("interrupts.zig");
// LAPIC
fn lapic_ptr() ?*volatile[0x100]u32 {
if(os.platform.thread.get_current_cpu().platform_data.lapic) |ptr| {
return ptr.get_writeback();
}
return null;
}
fn x2apic_msr(comptime register: u10) comptime_int {
return @as(u32, 0x800) + @truncate(u8, register >> 2);
}
fn write_x2apic(comptime register: u10, value: u32) void {
regs.MSR(u32, x2apic_msr(register)).write(value);
}
fn read_x2apic(comptime register: u10) u32 {
return regs.MSR(u32, x2apic_msr(register)).read();
}
pub fn enable() void {
const spur_reg = @as(u32, 0x100) | interrupts.spurious_vector; // bit 8 = lapic enable, bit 7-0 = spurious vector;
const raw = IA32_APIC_BASE.read();
if(raw & 0x400 != 0) {
// X2APIC
os.platform.thread.get_current_cpu().platform_data.lapic = null;
write_x2apic(SPURIOUS, spur_reg);
return;
}
const phy = raw & 0xFFFFF000; // ignore flags
os.platform.thread.get_current_cpu().platform_data.lapic = os.platform.phys_ptr(*volatile [0x100]u32).from_int(phy);
lapic_ptr().?[SPURIOUS] = spur_reg;
}
pub fn eoi() void {
if(lapic_ptr()) |lapic| {
lapic[EOI] = 0;
} else {
write_x2apic(EOI, 0);
}
}
pub fn timer(ticks: u32, div: u32, vec: u32) void {
if(lapic_ptr()) |lapic| {
lapic[LVT_TIMER] = vec | TIMER_MODE_PERIODIC;
lapic[TIMER_DIV] = div;
lapic[TIMER_INITCNT] = ticks;
} else {
@panic("X2APIC timer NYI");
}
}
// ACPI information
fn handle_processor(apic_id: u32) void {
}
const Override = struct {
gsi: u32,
flags: u16,
ioapic_id: u8,
};
var source_overrides = [1]?Override{null} ** 0x100;
/// Routes the legacy irq to given lapic vector
/// Returns the GSI in case you want to disable it later
pub fn route_irq(lapic_id: u32, irq: u8, vector: u8) u32 {
const gsi_mapping = map_irq_to_gsi(irq);
route_gsi_ioapic(gsi_mapping.ioapic_id, lapic_id, vector, gsi_mapping.gsi, gsi_mapping.flags);
return gsi_mapping.gsi;
}
/// Route a GSI to the given lapic vector
pub fn route_gsi(lapic_id: u32, vector: u8, gsi: u32, flags: u16) void {
route_gsi_ioapic(gsi_to_ioapic(gsi), lapic_id, vector, gsi, flags);
}
fn route_gsi_ioapic(ioapic_id: u8, lapic_id: u32, vector: u8, gsi: u32, flags: u16) void {
const value = 0
| (@as(u64, vector) << 0)
| (@as(u64, flags & 0b1010) << 12)
| (@as(u64, lapic_id) << 56)
;
const ioapic = ioapics[ioapic_id].?;
const gsi_offset = (gsi - ioapic.gsi_base) * 2 + 0x10;
ioapic.write(gsi_offset + 0, @truncate(u32, value));
ioapic.write(gsi_offset + 1, @truncate(u32, value >> 32));
}
fn map_irq_to_gsi(irq: u8) Override {
return source_overrides[irq] orelse Override{.gsi = @as(u32, irq), .flags = 0, .ioapic_id = gsi_to_ioapic(irq), };
}
const IOAPIC = struct {
phys: usize,
gsi_base: u32,
fn reg(self: *const @This(), offset: usize) *volatile u32 {
return os.platform.phys_ptr(*volatile u32).from_int(self.phys + offset).get_uncached();
}
fn write(self: *const @This(), offset: u32, value: u32) void {
self.reg(0x00).* = offset;
self.reg(0x10).* = value;
}
fn read(self: *const @This(), offset: u32) u32 {
self.reg(0x00).* = offset;
return self.reg(0x10).*;
}
fn gsi_count(self: *const @This()) u32 {
return (self.read(1) >> 16) & 0xFF;
}
};
fn gsi_to_ioapic(gsi: u32) u8 {
for(ioapics) |ioa_o, idx| {
if(ioa_o) |ioa| {
const gsi_count = ioa.gsi_count();
if(ioa.gsi_base <= gsi and gsi < ioa.gsi_base + gsi_count)
return @intCast(u8, idx);
}
}
os.log("GSI: {}\n", .{gsi});
@panic("Can't find ioapic for gsi!");
}
var ioapics = [1]?IOAPIC{null} ** os.config.kernel.x86_64.max_ioapics;
pub fn handle_madt(madt: []u8) void {
os.log("APIC: Got MADT (size={x})\n", .{madt.len});
var offset: u64 = 0x2C;
while(offset + 2 <= madt.len) {
const kind = madt[offset + 0];
const size = madt[offset + 1];
const data = madt[offset .. offset + size];
if(offset + size >= madt.len)
break;
switch(kind) {
0x00 => {
const apic_id = data[3];
const flags = std.mem.readIntNative(u32, data[4..8]);
if(flags & 0x3 != 0)
handle_processor(@as(u32, apic_id));
},
0x01 => {
const ioapic_id = data[2];
ioapics[ioapic_id] = .{
.phys = std.mem.readIntNative(u32, data[4..8]),
.gsi_base = std.mem.readIntNative(u32, data[8..12]),
};
},
0x02 => {
// We can probably filter away overrides where irq == gsi and flags == 0
// Until we have a reason to do so, let's not.
const irq = data[3];
source_overrides[irq] = .{
.gsi = std.mem.readIntNative(u32, data[4..8]),
.flags = std.mem.readIntNative(u16, data[8..10]),
.ioapic_id = data[2],
};
},
0x03 => {
std.debug.assert(size >= 8);
os.log("APIC: TODO: NMI source\n", .{});
},
0x04 => {
std.debug.assert(size >= 6);
os.log("APIC: TODO: LAPIC Non-maskable interrupt\n", .{});
},
0x05 => {
std.debug.assert(size >= 12);
os.log("APIC: TODO: LAPIC addr override\n", .{});
},
0x06 => {
std.debug.assert(size >= 16);
os.log("APIC: TODO: I/O SAPIC\n", .{});
},
0x07 => {
std.debug.assert(size >= 17);
os.log("APIC: TODO: Local SAPIC\n", .{});
},
0x08 => {
std.debug.assert(size >= 16);
os.log("APIC: TODO: Platform interrupt sources\n", .{});
},
0x09 => {
const flags = std.mem.readIntNative(u32, data[8..12]);
const apic_id = std.mem.readIntNative(u32, data[12..16]);
if(flags & 0x3 != 0)
handle_processor(apic_id);
},
0x0A => {
std.debug.assert(size >= 12);
os.log("APIC: TODO: LX2APIC NMI\n", .{});
},
else => {
os.log("APIC: Unknown MADT entry: 0x{X}\n", .{kind});
},
}
offset += size;
}
}
const IA32_APIC_BASE = @import("regs.zig").MSR(u64, 0x0000001B);
const LVT_TIMER = 0x320 / 4;
const TIMER_MODE_PERIODIC = 1 << 17;
const TIMER_DIV = 0x3E0 / 4;
const TIMER_INITCNT = 0x380 / 4;
const SPURIOUS = 0xF0 / 4;
const EOI = 0xB0 / 4;
|
src/platform/x86_64/apic.zig
|
usingnamespace @import("vulkan-l1.zig");
pub const ptrdiff_t = c_long;
pub const wchar_t = c_int;
const struct_unnamed_1 = extern struct {
__clang_max_align_nonce1: c_longlong align(8),
__clang_max_align_nonce2: c_longdouble align(16),
};
pub const max_align_t = struct_unnamed_1;
pub const __u_char = u8;
pub const __u_short = c_ushort;
pub const __u_int = c_uint;
pub const __u_long = c_ulong;
pub const __int8_t = i8;
pub const __uint8_t = u8;
pub const __int16_t = c_short;
pub const __uint16_t = c_ushort;
pub const __int32_t = c_int;
pub const __uint32_t = c_uint;
pub const __int64_t = c_long;
pub const __uint64_t = c_ulong;
pub const __int_least8_t = __int8_t;
pub const __uint_least8_t = __uint8_t;
pub const __int_least16_t = __int16_t;
pub const __uint_least16_t = __uint16_t;
pub const __int_least32_t = __int32_t;
pub const __uint_least32_t = __uint32_t;
pub const __int_least64_t = __int64_t;
pub const __uint_least64_t = __uint64_t;
pub const __quad_t = c_long;
pub const __u_quad_t = c_ulong;
pub const __intmax_t = c_long;
pub const __uintmax_t = c_ulong;
pub const __dev_t = c_ulong;
pub const __uid_t = c_uint;
pub const __gid_t = c_uint;
pub const __ino_t = c_ulong;
pub const __ino64_t = c_ulong;
pub const __mode_t = c_uint;
pub const __nlink_t = c_ulong;
pub const __off_t = c_long;
pub const __off64_t = c_long;
pub const __pid_t = c_int;
const struct_unnamed_2 = extern struct {
__val: [2]c_int,
};
pub const __fsid_t = struct_unnamed_2;
pub const __clock_t = c_long;
pub const __rlim_t = c_ulong;
pub const __rlim64_t = c_ulong;
pub const __id_t = c_uint;
pub const __time_t = c_long;
pub const __useconds_t = c_uint;
pub const __suseconds_t = c_long;
pub const __suseconds64_t = c_long;
pub const __daddr_t = c_int;
pub const __key_t = c_int;
pub const __clockid_t = c_int;
pub const __timer_t = ?*c_void;
pub const __blksize_t = c_long;
pub const __blkcnt_t = c_long;
pub const __blkcnt64_t = c_long;
pub const __fsblkcnt_t = c_ulong;
pub const __fsblkcnt64_t = c_ulong;
pub const __fsfilcnt_t = c_ulong;
pub const __fsfilcnt64_t = c_ulong;
pub const __fsword_t = c_long;
pub const __ssize_t = c_long;
pub const __syscall_slong_t = c_long;
pub const __syscall_ulong_t = c_ulong;
pub const __loff_t = __off64_t;
pub const __caddr_t = [*c]u8;
pub const __intptr_t = c_long;
pub const __socklen_t = c_uint;
pub const __sig_atomic_t = c_int;
pub const int_least8_t = __int_least8_t;
pub const int_least16_t = __int_least16_t;
pub const int_least32_t = __int_least32_t;
pub const int_least64_t = __int_least64_t;
pub const uint_least8_t = __uint_least8_t;
pub const uint_least16_t = __uint_least16_t;
pub const uint_least32_t = __uint_least32_t;
pub const uint_least64_t = __uint_least64_t;
pub const int_fast8_t = i8;
pub const int_fast16_t = c_long;
pub const int_fast32_t = c_long;
pub const int_fast64_t = c_long;
pub const uint_fast8_t = u8;
pub const uint_fast16_t = c_ulong;
pub const uint_fast32_t = c_ulong;
pub const uint_fast64_t = c_ulong;
pub const intmax_t = __intmax_t;
pub const uintmax_t = __uintmax_t;
pub const Bool32 = u32;
pub const DeviceAddress = u64;
pub const DeviceSize = u64;
pub const Flags = u32;
pub const SampleMask = u32;
pub const struct_Buffer_T = opaque {};
pub const Buffer = ?*struct_Buffer_T;
pub const struct_Image_T = opaque {};
pub const Image = ?*struct_Image_T;
pub const struct_Instance_T = opaque {};
pub const Instance = ?*struct_Instance_T;
pub const struct_PhysicalDevice_T = opaque {};
pub const PhysicalDevice = ?*struct_PhysicalDevice_T;
pub const struct_Device_T = opaque {};
pub const Device = ?*struct_Device_T;
pub const struct_Queue_T = opaque {};
pub const Queue = ?*struct_Queue_T;
pub const struct_Semaphore_T = opaque {};
pub const Semaphore = ?*struct_Semaphore_T;
pub const struct_CommandBuffer_T = opaque {};
pub const CommandBuffer = ?*struct_CommandBuffer_T;
pub const struct_Fence_T = opaque {};
pub const Fence = ?*struct_Fence_T;
pub const struct_DeviceMemory_T = opaque {};
pub const DeviceMemory = ?*struct_DeviceMemory_T;
pub const struct_Event_T = opaque {};
pub const Event = ?*struct_Event_T;
pub const struct_QueryPool_T = opaque {};
pub const QueryPool = ?*struct_QueryPool_T;
pub const struct_BufferView_T = opaque {};
pub const BufferView = ?*struct_BufferView_T;
pub const struct_ImageView_T = opaque {};
pub const ImageView = ?*struct_ImageView_T;
pub const struct_ShaderModule_T = opaque {};
pub const ShaderModule = ?*struct_ShaderModule_T;
pub const struct_PipelineCache_T = opaque {};
pub const PipelineCache = ?*struct_PipelineCache_T;
pub const struct_PipelineLayout_T = opaque {};
pub const PipelineLayout = ?*struct_PipelineLayout_T;
pub const struct_Pipeline_T = opaque {};
pub const Pipeline = ?*struct_Pipeline_T;
pub const struct_RenderPass_T = opaque {};
pub const RenderPass = ?*struct_RenderPass_T;
pub const struct_DescriptorSetLayout_T = opaque {};
pub const DescriptorSetLayout = ?*struct_DescriptorSetLayout_T;
pub const struct_Sampler_T = opaque {};
pub const Sampler = ?*struct_Sampler_T;
pub const struct_DescriptorSet_T = opaque {};
pub const DescriptorSet = ?*struct_DescriptorSet_T;
pub const struct_DescriptorPool_T = opaque {};
pub const DescriptorPool = ?*struct_DescriptorPool_T;
pub const struct_Framebuffer_T = opaque {};
pub const Framebuffer = ?*struct_Framebuffer_T;
pub const struct_CommandPool_T = opaque {};
pub const CommandPool = ?*struct_CommandPool_T;
pub const SUCCESS = @enumToInt(enum_Result.SUCCESS);
pub const NOT_READY = @enumToInt(enum_Result.NOT_READY);
pub const TIMEOUT = @enumToInt(enum_Result.TIMEOUT);
pub const EVENT_SET = @enumToInt(enum_Result.EVENT_SET);
pub const EVENT_RESET = @enumToInt(enum_Result.EVENT_RESET);
pub const INCOMPLETE = @enumToInt(enum_Result.INCOMPLETE);
pub const ERROR_OUT_OF_HOST_MEMORY = @enumToInt(enum_Result.ERROR_OUT_OF_HOST_MEMORY);
pub const ERROR_OUT_OF_DEVICE_MEMORY = @enumToInt(enum_Result.ERROR_OUT_OF_DEVICE_MEMORY);
pub const ERROR_INITIALIZATION_FAILED = @enumToInt(enum_Result.ERROR_INITIALIZATION_FAILED);
pub const ERROR_DEVICE_LOST = @enumToInt(enum_Result.ERROR_DEVICE_LOST);
pub const ERROR_MEMORY_MAP_FAILED = @enumToInt(enum_Result.ERROR_MEMORY_MAP_FAILED);
pub const ERROR_LAYER_NOT_PRESENT = @enumToInt(enum_Result.ERROR_LAYER_NOT_PRESENT);
pub const ERROR_EXTENSION_NOT_PRESENT = @enumToInt(enum_Result.ERROR_EXTENSION_NOT_PRESENT);
pub const ERROR_FEATURE_NOT_PRESENT = @enumToInt(enum_Result.ERROR_FEATURE_NOT_PRESENT);
pub const ERROR_INCOMPATIBLE_DRIVER = @enumToInt(enum_Result.ERROR_INCOMPATIBLE_DRIVER);
pub const ERROR_TOO_MANY_OBJECTS = @enumToInt(enum_Result.ERROR_TOO_MANY_OBJECTS);
pub const ERROR_FORMAT_NOT_SUPPORTED = @enumToInt(enum_Result.ERROR_FORMAT_NOT_SUPPORTED);
pub const ERROR_FRAGMENTED_POOL = @enumToInt(enum_Result.ERROR_FRAGMENTED_POOL);
pub const ERROR_UNKNOWN = @enumToInt(enum_Result.ERROR_UNKNOWN);
pub const ERROR_OUT_OF_POOL_MEMORY = @enumToInt(enum_Result.ERROR_OUT_OF_POOL_MEMORY);
pub const ERROR_INVALID_EXTERNAL_HANDLE = @enumToInt(enum_Result.ERROR_INVALID_EXTERNAL_HANDLE);
pub const ERROR_FRAGMENTATION = @enumToInt(enum_Result.ERROR_FRAGMENTATION);
pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = @enumToInt(enum_Result.ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS);
pub const ERROR_SURFACE_LOST_KHR = @enumToInt(enum_Result.ERROR_SURFACE_LOST_KHR);
pub const ERROR_NATIVE_WINDOW_IN_USE_KHR = @enumToInt(enum_Result.ERROR_NATIVE_WINDOW_IN_USE_KHR);
pub const SUBOPTIMAL_KHR = @enumToInt(enum_Result.SUBOPTIMAL_KHR);
pub const ERROR_OUT_OF_DATE_KHR = @enumToInt(enum_Result.ERROR_OUT_OF_DATE_KHR);
pub const ERROR_INCOMPATIBLE_DISPLAY_KHR = @enumToInt(enum_Result.ERROR_INCOMPATIBLE_DISPLAY_KHR);
pub const ERROR_VALIDATION_FAILED_EXT = @enumToInt(enum_Result.ERROR_VALIDATION_FAILED_EXT);
pub const ERROR_INVALID_SHADER_NV = @enumToInt(enum_Result.ERROR_INVALID_SHADER_NV);
pub const ERROR_INCOMPATIBLE_VERSION_KHR = @enumToInt(enum_Result.ERROR_INCOMPATIBLE_VERSION_KHR);
pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = @enumToInt(enum_Result.ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
pub const ERROR_NOT_PERMITTED_EXT = @enumToInt(enum_Result.ERROR_NOT_PERMITTED_EXT);
pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = @enumToInt(enum_Result.ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
pub const THREAD_IDLE_KHR = @enumToInt(enum_Result.THREAD_IDLE_KHR);
pub const THREAD_DONE_KHR = @enumToInt(enum_Result.THREAD_DONE_KHR);
pub const OPERATION_DEFERRED_KHR = @enumToInt(enum_Result.OPERATION_DEFERRED_KHR);
pub const OPERATION_NOT_DEFERRED_KHR = @enumToInt(enum_Result.OPERATION_NOT_DEFERRED_KHR);
pub const PIPELINE_COMPILE_REQUIRED_EXT = @enumToInt(enum_Result.PIPELINE_COMPILE_REQUIRED_EXT);
pub const ERROR_OUT_OF_POOL_MEMORY_KHR = @enumToInt(enum_Result.ERROR_OUT_OF_POOL_MEMORY_KHR);
pub const ERROR_INVALID_EXTERNAL_HANDLE_KHR = @enumToInt(enum_Result.ERROR_INVALID_EXTERNAL_HANDLE_KHR);
pub const ERROR_FRAGMENTATION_EXT = @enumToInt(enum_Result.ERROR_FRAGMENTATION_EXT);
pub const ERROR_INVALID_DEVICE_ADDRESS_EXT = @enumToInt(enum_Result.ERROR_INVALID_DEVICE_ADDRESS_EXT);
pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = @enumToInt(enum_Result.ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR);
pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT = @enumToInt(enum_Result.ERROR_PIPELINE_COMPILE_REQUIRED_EXT);
pub const RESULT_MAX_ENUM = @enumToInt(enum_Result.RESULT_MAX_ENUM);
pub const enum_Result = extern enum(c_int) {
SUCCESS = 0,
NOT_READY = 1,
TIMEOUT = 2,
EVENT_SET = 3,
EVENT_RESET = 4,
INCOMPLETE = 5,
ERROR_OUT_OF_HOST_MEMORY = -1,
ERROR_OUT_OF_DEVICE_MEMORY = -2,
ERROR_INITIALIZATION_FAILED = -3,
ERROR_DEVICE_LOST = -4,
ERROR_MEMORY_MAP_FAILED = -5,
ERROR_LAYER_NOT_PRESENT = -6,
ERROR_EXTENSION_NOT_PRESENT = -7,
ERROR_FEATURE_NOT_PRESENT = -8,
ERROR_INCOMPATIBLE_DRIVER = -9,
ERROR_TOO_MANY_OBJECTS = -10,
ERROR_FORMAT_NOT_SUPPORTED = -11,
ERROR_FRAGMENTED_POOL = -12,
ERROR_UNKNOWN = -13,
ERROR_OUT_OF_POOL_MEMORY = -1000069000,
ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
ERROR_FRAGMENTATION = -1000161000,
ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000,
ERROR_SURFACE_LOST_KHR = -1000000000,
ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
SUBOPTIMAL_KHR = 1000001003,
ERROR_OUT_OF_DATE_KHR = -1000001004,
ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
ERROR_VALIDATION_FAILED_EXT = -1000011001,
ERROR_INVALID_SHADER_NV = -1000012000,
ERROR_INCOMPATIBLE_VERSION_KHR = -1000150000,
ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
ERROR_NOT_PERMITTED_EXT = -1000174001,
ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
THREAD_IDLE_KHR = 1000268000,
THREAD_DONE_KHR = 1000268001,
OPERATION_DEFERRED_KHR = 1000268002,
OPERATION_NOT_DEFERRED_KHR = 1000268003,
PIPELINE_COMPILE_REQUIRED_EXT = 1000297000,
ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
ERROR_INVALID_EXTERNAL_HANDLE_KHR = -1000072003,
ERROR_FRAGMENTATION_EXT = -1000161000,
ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000257000,
ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = -1000257000,
ERROR_PIPELINE_COMPILE_REQUIRED_EXT = 1000297000,
RESULT_MAX_ENUM = 2147483647,
_,
};
pub const Result = enum_Result;
pub const enum_StructureType = extern enum(c_int) {
APPLICATION_INFO = 0,
INSTANCE_CREATE_INFO = 1,
DEVICE_QUEUE_CREATE_INFO = 2,
DEVICE_CREATE_INFO = 3,
SUBMIT_INFO = 4,
MEMORY_ALLOCATE_INFO = 5,
MAPPED_MEMORY_RANGE = 6,
BIND_SPARSE_INFO = 7,
FENCE_CREATE_INFO = 8,
SEMAPHORE_CREATE_INFO = 9,
EVENT_CREATE_INFO = 10,
QUERY_POOL_CREATE_INFO = 11,
BUFFER_CREATE_INFO = 12,
BUFFER_VIEW_CREATE_INFO = 13,
IMAGE_CREATE_INFO = 14,
IMAGE_VIEW_CREATE_INFO = 15,
SHADER_MODULE_CREATE_INFO = 16,
PIPELINE_CACHE_CREATE_INFO = 17,
PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
GRAPHICS_PIPELINE_CREATE_INFO = 28,
COMPUTE_PIPELINE_CREATE_INFO = 29,
PIPELINE_LAYOUT_CREATE_INFO = 30,
SAMPLER_CREATE_INFO = 31,
DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
DESCRIPTOR_POOL_CREATE_INFO = 33,
DESCRIPTOR_SET_ALLOCATE_INFO = 34,
WRITE_DESCRIPTOR_SET = 35,
COPY_DESCRIPTOR_SET = 36,
FRAMEBUFFER_CREATE_INFO = 37,
RENDER_PASS_CREATE_INFO = 38,
COMMAND_POOL_CREATE_INFO = 39,
COMMAND_BUFFER_ALLOCATE_INFO = 40,
COMMAND_BUFFER_INHERITANCE_INFO = 41,
COMMAND_BUFFER_BEGIN_INFO = 42,
RENDER_PASS_BEGIN_INFO = 43,
BUFFER_MEMORY_BARRIER = 44,
IMAGE_MEMORY_BARRIER = 45,
MEMORY_BARRIER = 46,
LOADER_INSTANCE_CREATE_INFO = 47,
LOADER_DEVICE_CREATE_INFO = 48,
PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,
BIND_BUFFER_MEMORY_INFO = 1000157000,
BIND_IMAGE_MEMORY_INFO = 1000157001,
PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,
MEMORY_DEDICATED_REQUIREMENTS = 1000127000,
MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,
MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,
DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,
DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
DEVICE_GROUP_SUBMIT_INFO = 1000060005,
DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,
BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,
PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,
BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,
IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,
IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
MEMORY_REQUIREMENTS_2 = 1000146003,
SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,
PHYSICAL_DEVICE_FEATURES_2 = 1000059000,
PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,
FORMAT_PROPERTIES_2 = 1000059002,
IMAGE_FORMAT_PROPERTIES_2 = 1000059003,
PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,
QUEUE_FAMILY_PROPERTIES_2 = 1000059005,
PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,
SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,
PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,
PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,
RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,
IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,
PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,
PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,
PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,
PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,
PROTECTED_SUBMIT_INFO = 1000145000,
PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,
PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
DEVICE_QUEUE_INFO_2 = 1000145003,
SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,
SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,
BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,
IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,
PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,
DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,
PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,
PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,
EXTERNAL_BUFFER_PROPERTIES = 1000071003,
PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,
EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,
EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,
PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
EXTERNAL_FENCE_PROPERTIES = 1000112001,
EXPORT_FENCE_CREATE_INFO = 1000113000,
EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,
PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,
PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,
PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,
PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49,
PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50,
PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51,
PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52,
IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000,
ATTACHMENT_DESCRIPTION_2 = 1000109000,
ATTACHMENT_REFERENCE_2 = 1000109001,
SUBPASS_DESCRIPTION_2 = 1000109002,
SUBPASS_DEPENDENCY_2 = 1000109003,
RENDER_PASS_CREATE_INFO_2 = 1000109004,
SUBPASS_BEGIN_INFO = 1000109005,
SUBPASS_END_INFO = 1000109006,
PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000,
PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000,
PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000,
PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000,
PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000,
DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000,
PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001,
PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002,
DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003,
DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004,
PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000,
SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001,
PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000,
IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000,
PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000,
SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001,
PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000,
PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000,
FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001,
FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002,
RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003,
PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000,
PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000,
PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000,
ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001,
ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002,
PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000,
PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000,
PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001,
SEMAPHORE_TYPE_CREATE_INFO = 1000207002,
TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003,
SEMAPHORE_WAIT_INFO = 1000207004,
SEMAPHORE_SIGNAL_INFO = 1000207005,
PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000,
BUFFER_DEVICE_ADDRESS_INFO = 1000244001,
BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002,
MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003,
DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004,
SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
PRESENT_INFO_KHR = 1000001001,
DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,
IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,
BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,
ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,
DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,
DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,
DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
DISPLAY_PRESENT_INFO_KHR = 1000003000,
XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000,
PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001,
PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002,
IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001,
TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000,
PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,
EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
VALIDATION_FLAGS_EXT = 1000061000,
VI_SURFACE_CREATE_INFO_NN = 1000062000,
PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000,
IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
MEMORY_FD_PROPERTIES_KHR = 1000074001,
MEMORY_GET_FD_INFO_KHR = 1000074002,
WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
PRESENT_REGIONS_KHR = 1000084000,
PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
SURFACE_CAPABILITIES_2_EXT = 1000090000,
DISPLAY_POWER_INFO_EXT = 1000091000,
DEVICE_EVENT_INFO_EXT = 1000091001,
DISPLAY_EVENT_INFO_EXT = 1000091002,
SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
PRESENT_TIMES_INFO_GOOGLE = 1000092000,
PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
HDR_METADATA_EXT = 1000105000,
SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
IMPORT_FENCE_FD_INFO_KHR = 1000115000,
FENCE_GET_FD_INFO_KHR = 1000115001,
PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
PERFORMANCE_COUNTER_KHR = 1000116005,
PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
SURFACE_CAPABILITIES_2_KHR = 1000119001,
SURFACE_FORMAT_2_KHR = 1000119002,
DISPLAY_PROPERTIES_2_KHR = 1000121000,
DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001,
DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002,
DISPLAY_PLANE_INFO_2_KHR = 1000121003,
DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004,
IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
DEBUG_UTILS_LABEL_EXT = 1000128002,
DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,
ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,
ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,
ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,
MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
EXTERNAL_FORMAT_ANDROID = 1000129005,
PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000,
PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001,
WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002,
DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003,
SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
MULTISAMPLE_PROPERTIES_EXT = 1000143004,
PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR = 1000165006,
WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000165007,
ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000,
ACCELERATION_STRUCTURE_CREATE_GEOMETRY_TYPE_INFO_KHR = 1000150001,
ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002,
ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003,
ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004,
ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005,
ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006,
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_KHR = 1000150008,
ACCELERATION_STRUCTURE_VERSION_KHR = 1000150009,
COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010,
COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011,
COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012,
PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR = 1000150013,
PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR = 1000150014,
RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015,
RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016,
ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017,
RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018,
PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000,
PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001,
DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000,
PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002,
IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003,
IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004,
IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005,
VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000,
PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001,
PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,
RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000,
ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001,
GEOMETRY_NV = 1000165003,
GEOMETRY_TRIANGLES_NV = 1000165004,
GEOMETRY_AABB_NV = 1000165005,
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008,
PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009,
RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011,
ACCELERATION_STRUCTURE_INFO_NV = 1000165012,
PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,
PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
PRESENT_FRAME_TOKEN_GGP = 1000191000,
PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000,
PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,
PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,
PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,
PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
CHECKPOINT_DATA_NV = 1000206000,
QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,
QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000,
INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,
PERFORMANCE_MARKER_INFO_INTEL = 1000210002,
PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003,
PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004,
PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005,
PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000,
DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000,
SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001,
IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000,
PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000,
METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000,
PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000,
PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001,
PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002,
FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000,
PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001,
PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002,
PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003,
PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,
PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,
PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = 1000245000,
VALIDATION_FEATURES_EXT = 1000247000,
PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000,
COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001,
PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002,
PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000,
PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001,
FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002,
PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000,
PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000,
SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000,
SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,
PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,
DEFERRED_OPERATION_INFO_KHR = 1000268000,
PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
PIPELINE_INFO_KHR = 1000269001,
PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000,
GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001,
GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002,
INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003,
INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004,
GENERATED_COMMANDS_INFO_NV = 1000277005,
GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006,
PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007,
PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000,
RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001,
PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000,
DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001,
DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002,
PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000,
PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001,
SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000,
PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,
PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,
PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,
PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = 1000295000,
DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = 1000295001,
PRIVATE_DATA_SLOT_CREATE_INFO_EXT = 1000295002,
PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = 1000297000,
PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,
DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001,
PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000,
PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001,
PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002,
PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000,
PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001,
COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000,
PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000,
COPY_BUFFER_INFO_2_KHR = 1000337000,
COPY_IMAGE_INFO_2_KHR = 1000337001,
COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002,
COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003,
BLIT_IMAGE_INFO_2_KHR = 1000337004,
RESOLVE_IMAGE_INFO_2_KHR = 1000337005,
BUFFER_COPY_2_KHR = 1000337006,
IMAGE_COPY_2_KHR = 1000337007,
IMAGE_BLIT_2_KHR = 1000337008,
BUFFER_IMAGE_COPY_2_KHR = 1000337009,
IMAGE_RESOLVE_2_KHR = 1000337010,
PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000,
DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000,
PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000,
PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000,
DEBUG_REPORT_CREATE_INFO_EXT = 1000011000,
RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = 1000053000,
PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = 1000053001,
PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = 1000053002,
PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
FORMAT_PROPERTIES_2_KHR = 1000059002,
IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
MEMORY_ALLOCATE_FLAGS_INFO_KHR = 1000060000,
DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = 1000060003,
DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = 1000060004,
DEVICE_GROUP_SUBMIT_INFO_KHR = 1000060005,
DEVICE_GROUP_BIND_SPARSE_INFO_KHR = 1000060006,
BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = 1000060013,
BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = 1000060014,
PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = 1000070000,
DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = 1000070001,
PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000,
EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001,
PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002,
EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003,
PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004,
EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000,
EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001,
EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002,
PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000,
EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001,
EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000,
PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = 1000082000,
PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = 1000082000,
PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
SURFACE_CAPABILITIES2_EXT = 1000090000,
PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = 1000108000,
FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = 1000108001,
FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = 1000108002,
RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = 1000108003,
ATTACHMENT_DESCRIPTION_2_KHR = 1000109000,
ATTACHMENT_REFERENCE_2_KHR = 1000109001,
SUBPASS_DESCRIPTION_2_KHR = 1000109002,
SUBPASS_DEPENDENCY_2_KHR = 1000109003,
RENDER_PASS_CREATE_INFO_2_KHR = 1000109004,
SUBPASS_BEGIN_INFO_KHR = 1000109005,
SUBPASS_END_INFO_KHR = 1000109006,
PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000,
EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001,
EXPORT_FENCE_CREATE_INFO_KHR = 1000113000,
PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = 1000117000,
RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = 1000117001,
IMAGE_VIEW_USAGE_CREATE_INFO_KHR = 1000117002,
PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = 1000117003,
PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = 1000120000,
PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000,
MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000,
MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001,
PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,
BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000,
IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001,
IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002,
MEMORY_REQUIREMENTS_2_KHR = 1000146003,
SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004,
IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000,
SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = 1000156000,
SAMPLER_YCBCR_CONVERSION_INFO_KHR = 1000156001,
BIND_IMAGE_PLANE_MEMORY_INFO_KHR = 1000156002,
IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = 1000156003,
PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004,
SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = 1000156005,
BIND_BUFFER_MEMORY_INFO_KHR = 1000157000,
BIND_IMAGE_MEMORY_INFO_KHR = 1000157001,
DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000,
PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001,
PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002,
DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003,
DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004,
BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006,
WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007,
PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = 1000168000,
DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = 1000168001,
PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = 1000175000,
PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000,
PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000,
PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = 1000197000,
PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = 1000199000,
SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = 1000199001,
PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = 1000207000,
PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = 1000207001,
SEMAPHORE_TYPE_CREATE_INFO_KHR = 1000207002,
TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = 1000207003,
SEMAPHORE_WAIT_INFO_KHR = 1000207004,
SEMAPHORE_SIGNAL_INFO_KHR = 1000207005,
QUERY_POOL_CREATE_INFO_INTEL = 1000210000,
PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000,
PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000,
PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = 1000241000,
ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001,
ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002,
PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = 1000244000,
BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000,
PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = 1000253000,
PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = 1000257000,
BUFFER_DEVICE_ADDRESS_INFO_KHR = 1000244001,
BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = 1000257002,
MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = 1000257003,
DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = 1000257004,
PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
MAX_ENUM = 2147483647,
_,
};
pub const StructureType = enum_StructureType;
pub const IMAGE_LAYOUT_UNDEFINED = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_UNDEFINED);
pub const IMAGE_LAYOUT_GENERAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_GENERAL);
pub const IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
pub const IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
pub const IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL);
pub const IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
pub const IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
pub const IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
pub const IMAGE_LAYOUT_PREINITIALIZED = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_PREINITIALIZED);
pub const IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL);
pub const IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL);
pub const IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL);
pub const IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL);
pub const IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL);
pub const IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL);
pub const IMAGE_LAYOUT_PRESENT_SRC_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_PRESENT_SRC_KHR);
pub const IMAGE_LAYOUT_SHARED_PRESENT_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_SHARED_PRESENT_KHR);
pub const IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV);
pub const IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT);
pub const IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR);
pub const IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR);
pub const IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR);
pub const IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR);
pub const IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR);
pub const IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR);
pub const IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR);
pub const IMAGE_LAYOUT_MAX_ENUM = @enumToInt(enum_ImageLayout.IMAGE_LAYOUT_MAX_ENUM);
pub const enum_ImageLayout = extern enum(c_int) {
IMAGE_LAYOUT_UNDEFINED = 0,
IMAGE_LAYOUT_GENERAL = 1,
IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
IMAGE_LAYOUT_PREINITIALIZED = 8,
IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000,
IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001,
IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002,
IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003,
IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003,
IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000117000,
IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000117001,
IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003,
IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = 1000241000,
IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = 1000241001,
IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000241002,
IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000241003,
IMAGE_LAYOUT_MAX_ENUM = 2147483647,
_,
};
pub const ImageLayout = enum_ImageLayout;
pub const OBJECT_TYPE_UNKNOWN = @enumToInt(enum_ObjectType.OBJECT_TYPE_UNKNOWN);
pub const OBJECT_TYPE_INSTANCE = @enumToInt(enum_ObjectType.OBJECT_TYPE_INSTANCE);
pub const OBJECT_TYPE_PHYSICAL_DEVICE = @enumToInt(enum_ObjectType.OBJECT_TYPE_PHYSICAL_DEVICE);
pub const OBJECT_TYPE_DEVICE = @enumToInt(enum_ObjectType.OBJECT_TYPE_DEVICE);
pub const OBJECT_TYPE_QUEUE = @enumToInt(enum_ObjectType.OBJECT_TYPE_QUEUE);
pub const OBJECT_TYPE_SEMAPHORE = @enumToInt(enum_ObjectType.OBJECT_TYPE_SEMAPHORE);
pub const OBJECT_TYPE_COMMAND_BUFFER = @enumToInt(enum_ObjectType.OBJECT_TYPE_COMMAND_BUFFER);
pub const OBJECT_TYPE_FENCE = @enumToInt(enum_ObjectType.OBJECT_TYPE_FENCE);
pub const OBJECT_TYPE_DEVICE_MEMORY = @enumToInt(enum_ObjectType.OBJECT_TYPE_DEVICE_MEMORY);
pub const OBJECT_TYPE_BUFFER = @enumToInt(enum_ObjectType.OBJECT_TYPE_BUFFER);
pub const OBJECT_TYPE_IMAGE = @enumToInt(enum_ObjectType.OBJECT_TYPE_IMAGE);
pub const OBJECT_TYPE_EVENT = @enumToInt(enum_ObjectType.OBJECT_TYPE_EVENT);
pub const OBJECT_TYPE_QUERY_POOL = @enumToInt(enum_ObjectType.OBJECT_TYPE_QUERY_POOL);
pub const OBJECT_TYPE_BUFFER_VIEW = @enumToInt(enum_ObjectType.OBJECT_TYPE_BUFFER_VIEW);
pub const OBJECT_TYPE_IMAGE_VIEW = @enumToInt(enum_ObjectType.OBJECT_TYPE_IMAGE_VIEW);
pub const OBJECT_TYPE_SHADER_MODULE = @enumToInt(enum_ObjectType.OBJECT_TYPE_SHADER_MODULE);
pub const OBJECT_TYPE_PIPELINE_CACHE = @enumToInt(enum_ObjectType.OBJECT_TYPE_PIPELINE_CACHE);
pub const OBJECT_TYPE_PIPELINE_LAYOUT = @enumToInt(enum_ObjectType.OBJECT_TYPE_PIPELINE_LAYOUT);
pub const OBJECT_TYPE_RENDER_PASS = @enumToInt(enum_ObjectType.OBJECT_TYPE_RENDER_PASS);
pub const OBJECT_TYPE_PIPELINE = @enumToInt(enum_ObjectType.OBJECT_TYPE_PIPELINE);
pub const OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = @enumToInt(enum_ObjectType.OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
pub const OBJECT_TYPE_SAMPLER = @enumToInt(enum_ObjectType.OBJECT_TYPE_SAMPLER);
pub const OBJECT_TYPE_DESCRIPTOR_POOL = @enumToInt(enum_ObjectType.OBJECT_TYPE_DESCRIPTOR_POOL);
pub const OBJECT_TYPE_DESCRIPTOR_SET = @enumToInt(enum_ObjectType.OBJECT_TYPE_DESCRIPTOR_SET);
pub const OBJECT_TYPE_FRAMEBUFFER = @enumToInt(enum_ObjectType.OBJECT_TYPE_FRAMEBUFFER);
pub const OBJECT_TYPE_COMMAND_POOL = @enumToInt(enum_ObjectType.OBJECT_TYPE_COMMAND_POOL);
pub const OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = @enumToInt(enum_ObjectType.OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION);
pub const OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = @enumToInt(enum_ObjectType.OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
pub const OBJECT_TYPE_SURFACE_KHR = @enumToInt(enum_ObjectType.OBJECT_TYPE_SURFACE_KHR);
pub const OBJECT_TYPE_SWAPCHAIN_KHR = @enumToInt(enum_ObjectType.OBJECT_TYPE_SWAPCHAIN_KHR);
pub const OBJECT_TYPE_DISPLAY_KHR = @enumToInt(enum_ObjectType.OBJECT_TYPE_DISPLAY_KHR);
pub const OBJECT_TYPE_DISPLAY_MODE_KHR = @enumToInt(enum_ObjectType.OBJECT_TYPE_DISPLAY_MODE_KHR);
pub const OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = @enumToInt(enum_ObjectType.OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT);
pub const OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = @enumToInt(enum_ObjectType.OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT);
pub const OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = @enumToInt(enum_ObjectType.OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR);
pub const OBJECT_TYPE_VALIDATION_CACHE_EXT = @enumToInt(enum_ObjectType.OBJECT_TYPE_VALIDATION_CACHE_EXT);
pub const OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = @enumToInt(enum_ObjectType.OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL);
pub const OBJECT_TYPE_DEFERRED_OPERATION_KHR = @enumToInt(enum_ObjectType.OBJECT_TYPE_DEFERRED_OPERATION_KHR);
pub const OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = @enumToInt(enum_ObjectType.OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV);
pub const OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = @enumToInt(enum_ObjectType.OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT);
pub const OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = @enumToInt(enum_ObjectType.OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR);
pub const OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = @enumToInt(enum_ObjectType.OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR);
pub const OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = @enumToInt(enum_ObjectType.OBJECT_TYPE_ACCELERATION_STRUCTURE_NV);
pub const OBJECT_TYPE_MAX_ENUM = @enumToInt(enum_ObjectType.OBJECT_TYPE_MAX_ENUM);
pub const enum_ObjectType = extern enum(c_int) {
OBJECT_TYPE_UNKNOWN = 0,
OBJECT_TYPE_INSTANCE = 1,
OBJECT_TYPE_PHYSICAL_DEVICE = 2,
OBJECT_TYPE_DEVICE = 3,
OBJECT_TYPE_QUEUE = 4,
OBJECT_TYPE_SEMAPHORE = 5,
OBJECT_TYPE_COMMAND_BUFFER = 6,
OBJECT_TYPE_FENCE = 7,
OBJECT_TYPE_DEVICE_MEMORY = 8,
OBJECT_TYPE_BUFFER = 9,
OBJECT_TYPE_IMAGE = 10,
OBJECT_TYPE_EVENT = 11,
OBJECT_TYPE_QUERY_POOL = 12,
OBJECT_TYPE_BUFFER_VIEW = 13,
OBJECT_TYPE_IMAGE_VIEW = 14,
OBJECT_TYPE_SHADER_MODULE = 15,
OBJECT_TYPE_PIPELINE_CACHE = 16,
OBJECT_TYPE_PIPELINE_LAYOUT = 17,
OBJECT_TYPE_RENDER_PASS = 18,
OBJECT_TYPE_PIPELINE = 19,
OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
OBJECT_TYPE_SAMPLER = 21,
OBJECT_TYPE_DESCRIPTOR_POOL = 22,
OBJECT_TYPE_DESCRIPTOR_SET = 23,
OBJECT_TYPE_FRAMEBUFFER = 24,
OBJECT_TYPE_COMMAND_POOL = 25,
OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
OBJECT_TYPE_SURFACE_KHR = 1000000000,
OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
OBJECT_TYPE_DISPLAY_KHR = 1000002000,
OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000165000,
OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000,
OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000,
OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000,
OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = 1000295000,
OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000,
OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = 1000156000,
OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
OBJECT_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const ObjectType = enum_ObjectType;
pub const VENDOR_ID_VIV = @enumToInt(enum_VendorId.VENDOR_ID_VIV);
pub const VENDOR_ID_VSI = @enumToInt(enum_VendorId.VENDOR_ID_VSI);
pub const VENDOR_ID_KAZAN = @enumToInt(enum_VendorId.VENDOR_ID_KAZAN);
pub const VENDOR_ID_CODEPLAY = @enumToInt(enum_VendorId.VENDOR_ID_CODEPLAY);
pub const VENDOR_ID_MESA = @enumToInt(enum_VendorId.VENDOR_ID_MESA);
pub const VENDOR_ID_MAX_ENUM = @enumToInt(enum_VendorId.VENDOR_ID_MAX_ENUM);
pub const enum_VendorId = extern enum(c_int) {
VENDOR_ID_VIV = 65537,
VENDOR_ID_VSI = 65538,
VENDOR_ID_KAZAN = 65539,
VENDOR_ID_CODEPLAY = 65540,
VENDOR_ID_MESA = 65541,
VENDOR_ID_MAX_ENUM = 2147483647,
_,
};
pub const VendorId = enum_VendorId;
pub const PIPELINE_CACHE_HEADER_VERSION_ONE = @enumToInt(enum_PipelineCacheHeaderVersion.PIPELINE_CACHE_HEADER_VERSION_ONE);
pub const PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = @enumToInt(enum_PipelineCacheHeaderVersion.PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM);
pub const enum_PipelineCacheHeaderVersion = extern enum(c_int) {
PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 2147483647,
_,
};
pub const PipelineCacheHeaderVersion = enum_PipelineCacheHeaderVersion;
pub const SYSTEM_ALLOCATION_SCOPE_COMMAND = @enumToInt(enum_SystemAllocationScope.SYSTEM_ALLOCATION_SCOPE_COMMAND);
pub const SYSTEM_ALLOCATION_SCOPE_OBJECT = @enumToInt(enum_SystemAllocationScope.SYSTEM_ALLOCATION_SCOPE_OBJECT);
pub const SYSTEM_ALLOCATION_SCOPE_CACHE = @enumToInt(enum_SystemAllocationScope.SYSTEM_ALLOCATION_SCOPE_CACHE);
pub const SYSTEM_ALLOCATION_SCOPE_DEVICE = @enumToInt(enum_SystemAllocationScope.SYSTEM_ALLOCATION_SCOPE_DEVICE);
pub const SYSTEM_ALLOCATION_SCOPE_INSTANCE = @enumToInt(enum_SystemAllocationScope.SYSTEM_ALLOCATION_SCOPE_INSTANCE);
pub const SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = @enumToInt(enum_SystemAllocationScope.SYSTEM_ALLOCATION_SCOPE_MAX_ENUM);
pub const enum_SystemAllocationScope = extern enum(c_int) {
SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 2147483647,
_,
};
pub const SystemAllocationScope = enum_SystemAllocationScope;
pub const INTERNAL_ALLOCATION_TYPE_EXECUTABLE = @enumToInt(enum_InternalAllocationType.INTERNAL_ALLOCATION_TYPE_EXECUTABLE);
pub const INTERNAL_ALLOCATION_TYPE_MAX_ENUM = @enumToInt(enum_InternalAllocationType.INTERNAL_ALLOCATION_TYPE_MAX_ENUM);
pub const enum_InternalAllocationType = extern enum(c_int) {
INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const InternalAllocationType = enum_InternalAllocationType;
pub const FORMAT_UNDEFINED = @enumToInt(enum_Format.FORMAT_UNDEFINED);
pub const FORMAT_R4G4_UNORM_PACK8 = @enumToInt(enum_Format.FORMAT_R4G4_UNORM_PACK8);
pub const FORMAT_R4G4B4A4_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_R4G4B4A4_UNORM_PACK16);
pub const FORMAT_B4G4R4A4_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_B4G4R4A4_UNORM_PACK16);
pub const FORMAT_R5G6B5_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_R5G6B5_UNORM_PACK16);
pub const FORMAT_B5G6R5_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_B5G6R5_UNORM_PACK16);
pub const FORMAT_R5G5B5A1_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_R5G5B5A1_UNORM_PACK16);
pub const FORMAT_B5G5R5A1_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_B5G5R5A1_UNORM_PACK16);
pub const FORMAT_A1R5G5B5_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_A1R5G5B5_UNORM_PACK16);
pub const FORMAT_R8_UNORM = @enumToInt(enum_Format.FORMAT_R8_UNORM);
pub const FORMAT_R8_SNORM = @enumToInt(enum_Format.FORMAT_R8_SNORM);
pub const FORMAT_R8_USCALED = @enumToInt(enum_Format.FORMAT_R8_USCALED);
pub const FORMAT_R8_SSCALED = @enumToInt(enum_Format.FORMAT_R8_SSCALED);
pub const FORMAT_R8_UINT = @enumToInt(enum_Format.FORMAT_R8_UINT);
pub const FORMAT_R8_SINT = @enumToInt(enum_Format.FORMAT_R8_SINT);
pub const FORMAT_R8_SRGB = @enumToInt(enum_Format.FORMAT_R8_SRGB);
pub const FORMAT_R8G8_UNORM = @enumToInt(enum_Format.FORMAT_R8G8_UNORM);
pub const FORMAT_R8G8_SNORM = @enumToInt(enum_Format.FORMAT_R8G8_SNORM);
pub const FORMAT_R8G8_USCALED = @enumToInt(enum_Format.FORMAT_R8G8_USCALED);
pub const FORMAT_R8G8_SSCALED = @enumToInt(enum_Format.FORMAT_R8G8_SSCALED);
pub const FORMAT_R8G8_UINT = @enumToInt(enum_Format.FORMAT_R8G8_UINT);
pub const FORMAT_R8G8_SINT = @enumToInt(enum_Format.FORMAT_R8G8_SINT);
pub const FORMAT_R8G8_SRGB = @enumToInt(enum_Format.FORMAT_R8G8_SRGB);
pub const FORMAT_R8G8B8_UNORM = @enumToInt(enum_Format.FORMAT_R8G8B8_UNORM);
pub const FORMAT_R8G8B8_SNORM = @enumToInt(enum_Format.FORMAT_R8G8B8_SNORM);
pub const FORMAT_R8G8B8_USCALED = @enumToInt(enum_Format.FORMAT_R8G8B8_USCALED);
pub const FORMAT_R8G8B8_SSCALED = @enumToInt(enum_Format.FORMAT_R8G8B8_SSCALED);
pub const FORMAT_R8G8B8_UINT = @enumToInt(enum_Format.FORMAT_R8G8B8_UINT);
pub const FORMAT_R8G8B8_SINT = @enumToInt(enum_Format.FORMAT_R8G8B8_SINT);
pub const FORMAT_R8G8B8_SRGB = @enumToInt(enum_Format.FORMAT_R8G8B8_SRGB);
pub const FORMAT_B8G8R8_UNORM = @enumToInt(enum_Format.FORMAT_B8G8R8_UNORM);
pub const FORMAT_B8G8R8_SNORM = @enumToInt(enum_Format.FORMAT_B8G8R8_SNORM);
pub const FORMAT_B8G8R8_USCALED = @enumToInt(enum_Format.FORMAT_B8G8R8_USCALED);
pub const FORMAT_B8G8R8_SSCALED = @enumToInt(enum_Format.FORMAT_B8G8R8_SSCALED);
pub const FORMAT_B8G8R8_UINT = @enumToInt(enum_Format.FORMAT_B8G8R8_UINT);
pub const FORMAT_B8G8R8_SINT = @enumToInt(enum_Format.FORMAT_B8G8R8_SINT);
pub const FORMAT_B8G8R8_SRGB = @enumToInt(enum_Format.FORMAT_B8G8R8_SRGB);
pub const FORMAT_R8G8B8A8_UNORM = @enumToInt(enum_Format.FORMAT_R8G8B8A8_UNORM);
pub const FORMAT_R8G8B8A8_SNORM = @enumToInt(enum_Format.FORMAT_R8G8B8A8_SNORM);
pub const FORMAT_R8G8B8A8_USCALED = @enumToInt(enum_Format.FORMAT_R8G8B8A8_USCALED);
pub const FORMAT_R8G8B8A8_SSCALED = @enumToInt(enum_Format.FORMAT_R8G8B8A8_SSCALED);
pub const FORMAT_R8G8B8A8_UINT = @enumToInt(enum_Format.FORMAT_R8G8B8A8_UINT);
pub const FORMAT_R8G8B8A8_SINT = @enumToInt(enum_Format.FORMAT_R8G8B8A8_SINT);
pub const FORMAT_R8G8B8A8_SRGB = @enumToInt(enum_Format.FORMAT_R8G8B8A8_SRGB);
pub const FORMAT_B8G8R8A8_UNORM = @enumToInt(enum_Format.FORMAT_B8G8R8A8_UNORM);
pub const FORMAT_B8G8R8A8_SNORM = @enumToInt(enum_Format.FORMAT_B8G8R8A8_SNORM);
pub const FORMAT_B8G8R8A8_USCALED = @enumToInt(enum_Format.FORMAT_B8G8R8A8_USCALED);
pub const FORMAT_B8G8R8A8_SSCALED = @enumToInt(enum_Format.FORMAT_B8G8R8A8_SSCALED);
pub const FORMAT_B8G8R8A8_UINT = @enumToInt(enum_Format.FORMAT_B8G8R8A8_UINT);
pub const FORMAT_B8G8R8A8_SINT = @enumToInt(enum_Format.FORMAT_B8G8R8A8_SINT);
pub const FORMAT_B8G8R8A8_SRGB = @enumToInt(enum_Format.FORMAT_B8G8R8A8_SRGB);
pub const FORMAT_A8B8G8R8_UNORM_PACK32 = @enumToInt(enum_Format.FORMAT_A8B8G8R8_UNORM_PACK32);
pub const FORMAT_A8B8G8R8_SNORM_PACK32 = @enumToInt(enum_Format.FORMAT_A8B8G8R8_SNORM_PACK32);
pub const FORMAT_A8B8G8R8_USCALED_PACK32 = @enumToInt(enum_Format.FORMAT_A8B8G8R8_USCALED_PACK32);
pub const FORMAT_A8B8G8R8_SSCALED_PACK32 = @enumToInt(enum_Format.FORMAT_A8B8G8R8_SSCALED_PACK32);
pub const FORMAT_A8B8G8R8_UINT_PACK32 = @enumToInt(enum_Format.FORMAT_A8B8G8R8_UINT_PACK32);
pub const FORMAT_A8B8G8R8_SINT_PACK32 = @enumToInt(enum_Format.FORMAT_A8B8G8R8_SINT_PACK32);
pub const FORMAT_A8B8G8R8_SRGB_PACK32 = @enumToInt(enum_Format.FORMAT_A8B8G8R8_SRGB_PACK32);
pub const FORMAT_A2R10G10B10_UNORM_PACK32 = @enumToInt(enum_Format.FORMAT_A2R10G10B10_UNORM_PACK32);
pub const FORMAT_A2R10G10B10_SNORM_PACK32 = @enumToInt(enum_Format.FORMAT_A2R10G10B10_SNORM_PACK32);
pub const FORMAT_A2R10G10B10_USCALED_PACK32 = @enumToInt(enum_Format.FORMAT_A2R10G10B10_USCALED_PACK32);
pub const FORMAT_A2R10G10B10_SSCALED_PACK32 = @enumToInt(enum_Format.FORMAT_A2R10G10B10_SSCALED_PACK32);
pub const FORMAT_A2R10G10B10_UINT_PACK32 = @enumToInt(enum_Format.FORMAT_A2R10G10B10_UINT_PACK32);
pub const FORMAT_A2R10G10B10_SINT_PACK32 = @enumToInt(enum_Format.FORMAT_A2R10G10B10_SINT_PACK32);
pub const FORMAT_A2B10G10R10_UNORM_PACK32 = @enumToInt(enum_Format.FORMAT_A2B10G10R10_UNORM_PACK32);
pub const FORMAT_A2B10G10R10_SNORM_PACK32 = @enumToInt(enum_Format.FORMAT_A2B10G10R10_SNORM_PACK32);
pub const FORMAT_A2B10G10R10_USCALED_PACK32 = @enumToInt(enum_Format.FORMAT_A2B10G10R10_USCALED_PACK32);
pub const FORMAT_A2B10G10R10_SSCALED_PACK32 = @enumToInt(enum_Format.FORMAT_A2B10G10R10_SSCALED_PACK32);
pub const FORMAT_A2B10G10R10_UINT_PACK32 = @enumToInt(enum_Format.FORMAT_A2B10G10R10_UINT_PACK32);
pub const FORMAT_A2B10G10R10_SINT_PACK32 = @enumToInt(enum_Format.FORMAT_A2B10G10R10_SINT_PACK32);
pub const FORMAT_R16_UNORM = @enumToInt(enum_Format.FORMAT_R16_UNORM);
pub const FORMAT_R16_SNORM = @enumToInt(enum_Format.FORMAT_R16_SNORM);
pub const FORMAT_R16_USCALED = @enumToInt(enum_Format.FORMAT_R16_USCALED);
pub const FORMAT_R16_SSCALED = @enumToInt(enum_Format.FORMAT_R16_SSCALED);
pub const FORMAT_R16_UINT = @enumToInt(enum_Format.FORMAT_R16_UINT);
pub const FORMAT_R16_SINT = @enumToInt(enum_Format.FORMAT_R16_SINT);
pub const FORMAT_R16_SFLOAT = @enumToInt(enum_Format.FORMAT_R16_SFLOAT);
pub const FORMAT_R16G16_UNORM = @enumToInt(enum_Format.FORMAT_R16G16_UNORM);
pub const FORMAT_R16G16_SNORM = @enumToInt(enum_Format.FORMAT_R16G16_SNORM);
pub const FORMAT_R16G16_USCALED = @enumToInt(enum_Format.FORMAT_R16G16_USCALED);
pub const FORMAT_R16G16_SSCALED = @enumToInt(enum_Format.FORMAT_R16G16_SSCALED);
pub const FORMAT_R16G16_UINT = @enumToInt(enum_Format.FORMAT_R16G16_UINT);
pub const FORMAT_R16G16_SINT = @enumToInt(enum_Format.FORMAT_R16G16_SINT);
pub const FORMAT_R16G16_SFLOAT = @enumToInt(enum_Format.FORMAT_R16G16_SFLOAT);
pub const FORMAT_R16G16B16_UNORM = @enumToInt(enum_Format.FORMAT_R16G16B16_UNORM);
pub const FORMAT_R16G16B16_SNORM = @enumToInt(enum_Format.FORMAT_R16G16B16_SNORM);
pub const FORMAT_R16G16B16_USCALED = @enumToInt(enum_Format.FORMAT_R16G16B16_USCALED);
pub const FORMAT_R16G16B16_SSCALED = @enumToInt(enum_Format.FORMAT_R16G16B16_SSCALED);
pub const FORMAT_R16G16B16_UINT = @enumToInt(enum_Format.FORMAT_R16G16B16_UINT);
pub const FORMAT_R16G16B16_SINT = @enumToInt(enum_Format.FORMAT_R16G16B16_SINT);
pub const FORMAT_R16G16B16_SFLOAT = @enumToInt(enum_Format.FORMAT_R16G16B16_SFLOAT);
pub const FORMAT_R16G16B16A16_UNORM = @enumToInt(enum_Format.FORMAT_R16G16B16A16_UNORM);
pub const FORMAT_R16G16B16A16_SNORM = @enumToInt(enum_Format.FORMAT_R16G16B16A16_SNORM);
pub const FORMAT_R16G16B16A16_USCALED = @enumToInt(enum_Format.FORMAT_R16G16B16A16_USCALED);
pub const FORMAT_R16G16B16A16_SSCALED = @enumToInt(enum_Format.FORMAT_R16G16B16A16_SSCALED);
pub const FORMAT_R16G16B16A16_UINT = @enumToInt(enum_Format.FORMAT_R16G16B16A16_UINT);
pub const FORMAT_R16G16B16A16_SINT = @enumToInt(enum_Format.FORMAT_R16G16B16A16_SINT);
pub const FORMAT_R16G16B16A16_SFLOAT = @enumToInt(enum_Format.FORMAT_R16G16B16A16_SFLOAT);
pub const FORMAT_R32_UINT = @enumToInt(enum_Format.FORMAT_R32_UINT);
pub const FORMAT_R32_SINT = @enumToInt(enum_Format.FORMAT_R32_SINT);
pub const FORMAT_R32_SFLOAT = @enumToInt(enum_Format.FORMAT_R32_SFLOAT);
pub const FORMAT_R32G32_UINT = @enumToInt(enum_Format.FORMAT_R32G32_UINT);
pub const FORMAT_R32G32_SINT = @enumToInt(enum_Format.FORMAT_R32G32_SINT);
pub const FORMAT_R32G32_SFLOAT = @enumToInt(enum_Format.FORMAT_R32G32_SFLOAT);
pub const FORMAT_R32G32B32_UINT = @enumToInt(enum_Format.FORMAT_R32G32B32_UINT);
pub const FORMAT_R32G32B32_SINT = @enumToInt(enum_Format.FORMAT_R32G32B32_SINT);
pub const FORMAT_R32G32B32_SFLOAT = @enumToInt(enum_Format.FORMAT_R32G32B32_SFLOAT);
pub const FORMAT_R32G32B32A32_UINT = @enumToInt(enum_Format.FORMAT_R32G32B32A32_UINT);
pub const FORMAT_R32G32B32A32_SINT = @enumToInt(enum_Format.FORMAT_R32G32B32A32_SINT);
pub const FORMAT_R32G32B32A32_SFLOAT = @enumToInt(enum_Format.FORMAT_R32G32B32A32_SFLOAT);
pub const FORMAT_R64_UINT = @enumToInt(enum_Format.FORMAT_R64_UINT);
pub const FORMAT_R64_SINT = @enumToInt(enum_Format.FORMAT_R64_SINT);
pub const FORMAT_R64_SFLOAT = @enumToInt(enum_Format.FORMAT_R64_SFLOAT);
pub const FORMAT_R64G64_UINT = @enumToInt(enum_Format.FORMAT_R64G64_UINT);
pub const FORMAT_R64G64_SINT = @enumToInt(enum_Format.FORMAT_R64G64_SINT);
pub const FORMAT_R64G64_SFLOAT = @enumToInt(enum_Format.FORMAT_R64G64_SFLOAT);
pub const FORMAT_R64G64B64_UINT = @enumToInt(enum_Format.FORMAT_R64G64B64_UINT);
pub const FORMAT_R64G64B64_SINT = @enumToInt(enum_Format.FORMAT_R64G64B64_SINT);
pub const FORMAT_R64G64B64_SFLOAT = @enumToInt(enum_Format.FORMAT_R64G64B64_SFLOAT);
pub const FORMAT_R64G64B64A64_UINT = @enumToInt(enum_Format.FORMAT_R64G64B64A64_UINT);
pub const FORMAT_R64G64B64A64_SINT = @enumToInt(enum_Format.FORMAT_R64G64B64A64_SINT);
pub const FORMAT_R64G64B64A64_SFLOAT = @enumToInt(enum_Format.FORMAT_R64G64B64A64_SFLOAT);
pub const FORMAT_B10G11R11_UFLOAT_PACK32 = @enumToInt(enum_Format.FORMAT_B10G11R11_UFLOAT_PACK32);
pub const FORMAT_E5B9G9R9_UFLOAT_PACK32 = @enumToInt(enum_Format.FORMAT_E5B9G9R9_UFLOAT_PACK32);
pub const FORMAT_D16_UNORM = @enumToInt(enum_Format.FORMAT_D16_UNORM);
pub const FORMAT_X8_D24_UNORM_PACK32 = @enumToInt(enum_Format.FORMAT_X8_D24_UNORM_PACK32);
pub const FORMAT_D32_SFLOAT = @enumToInt(enum_Format.FORMAT_D32_SFLOAT);
pub const FORMAT_S8_UINT = @enumToInt(enum_Format.FORMAT_S8_UINT);
pub const FORMAT_D16_UNORM_S8_UINT = @enumToInt(enum_Format.FORMAT_D16_UNORM_S8_UINT);
pub const FORMAT_D24_UNORM_S8_UINT = @enumToInt(enum_Format.FORMAT_D24_UNORM_S8_UINT);
pub const FORMAT_D32_SFLOAT_S8_UINT = @enumToInt(enum_Format.FORMAT_D32_SFLOAT_S8_UINT);
pub const FORMAT_BC1_RGB_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC1_RGB_UNORM_BLOCK);
pub const FORMAT_BC1_RGB_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_BC1_RGB_SRGB_BLOCK);
pub const FORMAT_BC1_RGBA_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC1_RGBA_UNORM_BLOCK);
pub const FORMAT_BC1_RGBA_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_BC1_RGBA_SRGB_BLOCK);
pub const FORMAT_BC2_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC2_UNORM_BLOCK);
pub const FORMAT_BC2_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_BC2_SRGB_BLOCK);
pub const FORMAT_BC3_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC3_UNORM_BLOCK);
pub const FORMAT_BC3_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_BC3_SRGB_BLOCK);
pub const FORMAT_BC4_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC4_UNORM_BLOCK);
pub const FORMAT_BC4_SNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC4_SNORM_BLOCK);
pub const FORMAT_BC5_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC5_UNORM_BLOCK);
pub const FORMAT_BC5_SNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC5_SNORM_BLOCK);
pub const FORMAT_BC6H_UFLOAT_BLOCK = @enumToInt(enum_Format.FORMAT_BC6H_UFLOAT_BLOCK);
pub const FORMAT_BC6H_SFLOAT_BLOCK = @enumToInt(enum_Format.FORMAT_BC6H_SFLOAT_BLOCK);
pub const FORMAT_BC7_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_BC7_UNORM_BLOCK);
pub const FORMAT_BC7_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_BC7_SRGB_BLOCK);
pub const FORMAT_ETC2_R8G8B8_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ETC2_R8G8B8_UNORM_BLOCK);
pub const FORMAT_ETC2_R8G8B8_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ETC2_R8G8B8_SRGB_BLOCK);
pub const FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK);
pub const FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK);
pub const FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK);
pub const FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK);
pub const FORMAT_EAC_R11_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_EAC_R11_UNORM_BLOCK);
pub const FORMAT_EAC_R11_SNORM_BLOCK = @enumToInt(enum_Format.FORMAT_EAC_R11_SNORM_BLOCK);
pub const FORMAT_EAC_R11G11_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_EAC_R11G11_UNORM_BLOCK);
pub const FORMAT_EAC_R11G11_SNORM_BLOCK = @enumToInt(enum_Format.FORMAT_EAC_R11G11_SNORM_BLOCK);
pub const FORMAT_ASTC_4x4_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_4x4_UNORM_BLOCK);
pub const FORMAT_ASTC_4x4_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_4x4_SRGB_BLOCK);
pub const FORMAT_ASTC_5x4_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_5x4_UNORM_BLOCK);
pub const FORMAT_ASTC_5x4_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_5x4_SRGB_BLOCK);
pub const FORMAT_ASTC_5x5_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_5x5_UNORM_BLOCK);
pub const FORMAT_ASTC_5x5_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_5x5_SRGB_BLOCK);
pub const FORMAT_ASTC_6x5_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_6x5_UNORM_BLOCK);
pub const FORMAT_ASTC_6x5_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_6x5_SRGB_BLOCK);
pub const FORMAT_ASTC_6x6_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_6x6_UNORM_BLOCK);
pub const FORMAT_ASTC_6x6_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_6x6_SRGB_BLOCK);
pub const FORMAT_ASTC_8x5_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_8x5_UNORM_BLOCK);
pub const FORMAT_ASTC_8x5_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_8x5_SRGB_BLOCK);
pub const FORMAT_ASTC_8x6_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_8x6_UNORM_BLOCK);
pub const FORMAT_ASTC_8x6_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_8x6_SRGB_BLOCK);
pub const FORMAT_ASTC_8x8_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_8x8_UNORM_BLOCK);
pub const FORMAT_ASTC_8x8_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_8x8_SRGB_BLOCK);
pub const FORMAT_ASTC_10x5_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_10x5_UNORM_BLOCK);
pub const FORMAT_ASTC_10x5_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_10x5_SRGB_BLOCK);
pub const FORMAT_ASTC_10x6_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_10x6_UNORM_BLOCK);
pub const FORMAT_ASTC_10x6_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_10x6_SRGB_BLOCK);
pub const FORMAT_ASTC_10x8_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_10x8_UNORM_BLOCK);
pub const FORMAT_ASTC_10x8_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_10x8_SRGB_BLOCK);
pub const FORMAT_ASTC_10x10_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_10x10_UNORM_BLOCK);
pub const FORMAT_ASTC_10x10_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_10x10_SRGB_BLOCK);
pub const FORMAT_ASTC_12x10_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_12x10_UNORM_BLOCK);
pub const FORMAT_ASTC_12x10_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_12x10_SRGB_BLOCK);
pub const FORMAT_ASTC_12x12_UNORM_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_12x12_UNORM_BLOCK);
pub const FORMAT_ASTC_12x12_SRGB_BLOCK = @enumToInt(enum_Format.FORMAT_ASTC_12x12_SRGB_BLOCK);
pub const FORMAT_G8B8G8R8_422_UNORM = @enumToInt(enum_Format.FORMAT_G8B8G8R8_422_UNORM);
pub const FORMAT_B8G8R8G8_422_UNORM = @enumToInt(enum_Format.FORMAT_B8G8R8G8_422_UNORM);
pub const FORMAT_G8_B8_R8_3PLANE_420_UNORM = @enumToInt(enum_Format.FORMAT_G8_B8_R8_3PLANE_420_UNORM);
pub const FORMAT_G8_B8R8_2PLANE_420_UNORM = @enumToInt(enum_Format.FORMAT_G8_B8R8_2PLANE_420_UNORM);
pub const FORMAT_G8_B8_R8_3PLANE_422_UNORM = @enumToInt(enum_Format.FORMAT_G8_B8_R8_3PLANE_422_UNORM);
pub const FORMAT_G8_B8R8_2PLANE_422_UNORM = @enumToInt(enum_Format.FORMAT_G8_B8R8_2PLANE_422_UNORM);
pub const FORMAT_G8_B8_R8_3PLANE_444_UNORM = @enumToInt(enum_Format.FORMAT_G8_B8_R8_3PLANE_444_UNORM);
pub const FORMAT_R10X6_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_R10X6_UNORM_PACK16);
pub const FORMAT_R10X6G10X6_UNORM_2PACK16 = @enumToInt(enum_Format.FORMAT_R10X6G10X6_UNORM_2PACK16);
pub const FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = @enumToInt(enum_Format.FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16);
pub const FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = @enumToInt(enum_Format.FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16);
pub const FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = @enumToInt(enum_Format.FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16);
pub const FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16);
pub const FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16);
pub const FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16);
pub const FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16);
pub const FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16);
pub const FORMAT_R12X4_UNORM_PACK16 = @enumToInt(enum_Format.FORMAT_R12X4_UNORM_PACK16);
pub const FORMAT_R12X4G12X4_UNORM_2PACK16 = @enumToInt(enum_Format.FORMAT_R12X4G12X4_UNORM_2PACK16);
pub const FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = @enumToInt(enum_Format.FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16);
pub const FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = @enumToInt(enum_Format.FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16);
pub const FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = @enumToInt(enum_Format.FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16);
pub const FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16);
pub const FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16);
pub const FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16);
pub const FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16);
pub const FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = @enumToInt(enum_Format.FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16);
pub const FORMAT_G16B16G16R16_422_UNORM = @enumToInt(enum_Format.FORMAT_G16B16G16R16_422_UNORM);
pub const FORMAT_B16G16R16G16_422_UNORM = @enumToInt(enum_Format.FORMAT_B16G16R16G16_422_UNORM);
pub const FORMAT_G16_B16_R16_3PLANE_420_UNORM = @enumToInt(enum_Format.FORMAT_G16_B16_R16_3PLANE_420_UNORM);
pub const FORMAT_G16_B16R16_2PLANE_420_UNORM = @enumToInt(enum_Format.FORMAT_G16_B16R16_2PLANE_420_UNORM);
pub const FORMAT_G16_B16_R16_3PLANE_422_UNORM = @enumToInt(enum_Format.FORMAT_G16_B16_R16_3PLANE_422_UNORM);
pub const FORMAT_G16_B16R16_2PLANE_422_UNORM = @enumToInt(enum_Format.FORMAT_G16_B16R16_2PLANE_422_UNORM);
pub const FORMAT_G16_B16_R16_3PLANE_444_UNORM = @enumToInt(enum_Format.FORMAT_G16_B16_R16_3PLANE_444_UNORM);
pub const FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = @enumToInt(enum_Format.FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG);
pub const FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = @enumToInt(enum_Format.FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG);
pub const FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = @enumToInt(enum_Format.FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG);
pub const FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = @enumToInt(enum_Format.FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG);
pub const FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = @enumToInt(enum_Format.FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG);
pub const FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = @enumToInt(enum_Format.FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG);
pub const FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = @enumToInt(enum_Format.FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG);
pub const FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = @enumToInt(enum_Format.FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG);
pub const FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT);
pub const FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = @enumToInt(enum_Format.FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT);
pub const FORMAT_A4R4G4B4_UNORM_PACK16_EXT = @enumToInt(enum_Format.FORMAT_A4R4G4B4_UNORM_PACK16_EXT);
pub const FORMAT_A4B4G4R4_UNORM_PACK16_EXT = @enumToInt(enum_Format.FORMAT_A4B4G4R4_UNORM_PACK16_EXT);
pub const FORMAT_G8B8G8R8_422_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G8B8G8R8_422_UNORM_KHR);
pub const FORMAT_B8G8R8G8_422_UNORM_KHR = @enumToInt(enum_Format.FORMAT_B8G8R8G8_422_UNORM_KHR);
pub const FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR);
pub const FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR);
pub const FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR);
pub const FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR);
pub const FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR);
pub const FORMAT_R10X6_UNORM_PACK16_KHR = @enumToInt(enum_Format.FORMAT_R10X6_UNORM_PACK16_KHR);
pub const FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = @enumToInt(enum_Format.FORMAT_R10X6G10X6_UNORM_2PACK16_KHR);
pub const FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = @enumToInt(enum_Format.FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR);
pub const FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = @enumToInt(enum_Format.FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR);
pub const FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = @enumToInt(enum_Format.FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR);
pub const FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR);
pub const FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR);
pub const FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR);
pub const FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR);
pub const FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR);
pub const FORMAT_R12X4_UNORM_PACK16_KHR = @enumToInt(enum_Format.FORMAT_R12X4_UNORM_PACK16_KHR);
pub const FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = @enumToInt(enum_Format.FORMAT_R12X4G12X4_UNORM_2PACK16_KHR);
pub const FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = @enumToInt(enum_Format.FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR);
pub const FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = @enumToInt(enum_Format.FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR);
pub const FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = @enumToInt(enum_Format.FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR);
pub const FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR);
pub const FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR);
pub const FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR);
pub const FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR);
pub const FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = @enumToInt(enum_Format.FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR);
pub const FORMAT_G16B16G16R16_422_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G16B16G16R16_422_UNORM_KHR);
pub const FORMAT_B16G16R16G16_422_UNORM_KHR = @enumToInt(enum_Format.FORMAT_B16G16R16G16_422_UNORM_KHR);
pub const FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR);
pub const FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR);
pub const FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR);
pub const FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR);
pub const FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = @enumToInt(enum_Format.FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR);
pub const FORMAT_MAX_ENUM = @enumToInt(enum_Format.FORMAT_MAX_ENUM);
pub const enum_Format = extern enum(c_int) {
FORMAT_UNDEFINED = 0,
FORMAT_R4G4_UNORM_PACK8 = 1,
FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
FORMAT_R5G6B5_UNORM_PACK16 = 4,
FORMAT_B5G6R5_UNORM_PACK16 = 5,
FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
FORMAT_R8_UNORM = 9,
FORMAT_R8_SNORM = 10,
FORMAT_R8_USCALED = 11,
FORMAT_R8_SSCALED = 12,
FORMAT_R8_UINT = 13,
FORMAT_R8_SINT = 14,
FORMAT_R8_SRGB = 15,
FORMAT_R8G8_UNORM = 16,
FORMAT_R8G8_SNORM = 17,
FORMAT_R8G8_USCALED = 18,
FORMAT_R8G8_SSCALED = 19,
FORMAT_R8G8_UINT = 20,
FORMAT_R8G8_SINT = 21,
FORMAT_R8G8_SRGB = 22,
FORMAT_R8G8B8_UNORM = 23,
FORMAT_R8G8B8_SNORM = 24,
FORMAT_R8G8B8_USCALED = 25,
FORMAT_R8G8B8_SSCALED = 26,
FORMAT_R8G8B8_UINT = 27,
FORMAT_R8G8B8_SINT = 28,
FORMAT_R8G8B8_SRGB = 29,
FORMAT_B8G8R8_UNORM = 30,
FORMAT_B8G8R8_SNORM = 31,
FORMAT_B8G8R8_USCALED = 32,
FORMAT_B8G8R8_SSCALED = 33,
FORMAT_B8G8R8_UINT = 34,
FORMAT_B8G8R8_SINT = 35,
FORMAT_B8G8R8_SRGB = 36,
FORMAT_R8G8B8A8_UNORM = 37,
FORMAT_R8G8B8A8_SNORM = 38,
FORMAT_R8G8B8A8_USCALED = 39,
FORMAT_R8G8B8A8_SSCALED = 40,
FORMAT_R8G8B8A8_UINT = 41,
FORMAT_R8G8B8A8_SINT = 42,
FORMAT_R8G8B8A8_SRGB = 43,
FORMAT_B8G8R8A8_UNORM = 44,
FORMAT_B8G8R8A8_SNORM = 45,
FORMAT_B8G8R8A8_USCALED = 46,
FORMAT_B8G8R8A8_SSCALED = 47,
FORMAT_B8G8R8A8_UINT = 48,
FORMAT_B8G8R8A8_SINT = 49,
FORMAT_B8G8R8A8_SRGB = 50,
FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
FORMAT_A8B8G8R8_UINT_PACK32 = 55,
FORMAT_A8B8G8R8_SINT_PACK32 = 56,
FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
FORMAT_A2R10G10B10_UINT_PACK32 = 62,
FORMAT_A2R10G10B10_SINT_PACK32 = 63,
FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
FORMAT_A2B10G10R10_UINT_PACK32 = 68,
FORMAT_A2B10G10R10_SINT_PACK32 = 69,
FORMAT_R16_UNORM = 70,
FORMAT_R16_SNORM = 71,
FORMAT_R16_USCALED = 72,
FORMAT_R16_SSCALED = 73,
FORMAT_R16_UINT = 74,
FORMAT_R16_SINT = 75,
FORMAT_R16_SFLOAT = 76,
FORMAT_R16G16_UNORM = 77,
FORMAT_R16G16_SNORM = 78,
FORMAT_R16G16_USCALED = 79,
FORMAT_R16G16_SSCALED = 80,
FORMAT_R16G16_UINT = 81,
FORMAT_R16G16_SINT = 82,
FORMAT_R16G16_SFLOAT = 83,
FORMAT_R16G16B16_UNORM = 84,
FORMAT_R16G16B16_SNORM = 85,
FORMAT_R16G16B16_USCALED = 86,
FORMAT_R16G16B16_SSCALED = 87,
FORMAT_R16G16B16_UINT = 88,
FORMAT_R16G16B16_SINT = 89,
FORMAT_R16G16B16_SFLOAT = 90,
FORMAT_R16G16B16A16_UNORM = 91,
FORMAT_R16G16B16A16_SNORM = 92,
FORMAT_R16G16B16A16_USCALED = 93,
FORMAT_R16G16B16A16_SSCALED = 94,
FORMAT_R16G16B16A16_UINT = 95,
FORMAT_R16G16B16A16_SINT = 96,
FORMAT_R16G16B16A16_SFLOAT = 97,
FORMAT_R32_UINT = 98,
FORMAT_R32_SINT = 99,
FORMAT_R32_SFLOAT = 100,
FORMAT_R32G32_UINT = 101,
FORMAT_R32G32_SINT = 102,
FORMAT_R32G32_SFLOAT = 103,
FORMAT_R32G32B32_UINT = 104,
FORMAT_R32G32B32_SINT = 105,
FORMAT_R32G32B32_SFLOAT = 106,
FORMAT_R32G32B32A32_UINT = 107,
FORMAT_R32G32B32A32_SINT = 108,
FORMAT_R32G32B32A32_SFLOAT = 109,
FORMAT_R64_UINT = 110,
FORMAT_R64_SINT = 111,
FORMAT_R64_SFLOAT = 112,
FORMAT_R64G64_UINT = 113,
FORMAT_R64G64_SINT = 114,
FORMAT_R64G64_SFLOAT = 115,
FORMAT_R64G64B64_UINT = 116,
FORMAT_R64G64B64_SINT = 117,
FORMAT_R64G64B64_SFLOAT = 118,
FORMAT_R64G64B64A64_UINT = 119,
FORMAT_R64G64B64A64_SINT = 120,
FORMAT_R64G64B64A64_SFLOAT = 121,
FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
FORMAT_D16_UNORM = 124,
FORMAT_X8_D24_UNORM_PACK32 = 125,
FORMAT_D32_SFLOAT = 126,
FORMAT_S8_UINT = 127,
FORMAT_D16_UNORM_S8_UINT = 128,
FORMAT_D24_UNORM_S8_UINT = 129,
FORMAT_D32_SFLOAT_S8_UINT = 130,
FORMAT_BC1_RGB_UNORM_BLOCK = 131,
FORMAT_BC1_RGB_SRGB_BLOCK = 132,
FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
FORMAT_BC2_UNORM_BLOCK = 135,
FORMAT_BC2_SRGB_BLOCK = 136,
FORMAT_BC3_UNORM_BLOCK = 137,
FORMAT_BC3_SRGB_BLOCK = 138,
FORMAT_BC4_UNORM_BLOCK = 139,
FORMAT_BC4_SNORM_BLOCK = 140,
FORMAT_BC5_UNORM_BLOCK = 141,
FORMAT_BC5_SNORM_BLOCK = 142,
FORMAT_BC6H_UFLOAT_BLOCK = 143,
FORMAT_BC6H_SFLOAT_BLOCK = 144,
FORMAT_BC7_UNORM_BLOCK = 145,
FORMAT_BC7_SRGB_BLOCK = 146,
FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
FORMAT_EAC_R11_UNORM_BLOCK = 153,
FORMAT_EAC_R11_SNORM_BLOCK = 154,
FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
FORMAT_G8B8G8R8_422_UNORM = 1000156000,
FORMAT_B8G8R8G8_422_UNORM = 1000156001,
FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
FORMAT_R10X6_UNORM_PACK16 = 1000156007,
FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
FORMAT_R12X4_UNORM_PACK16 = 1000156017,
FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
FORMAT_G16B16G16R16_422_UNORM = 1000156027,
FORMAT_B16G16R16G16_422_UNORM = 1000156028,
FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000,
FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001,
FORMAT_G8B8G8R8_422_UNORM_KHR = 1000156000,
FORMAT_B8G8R8G8_422_UNORM_KHR = 1000156001,
FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = 1000156002,
FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = 1000156003,
FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = 1000156004,
FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = 1000156005,
FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = 1000156006,
FORMAT_R10X6_UNORM_PACK16_KHR = 1000156007,
FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = 1000156008,
FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = 1000156009,
FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = 1000156010,
FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = 1000156011,
FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012,
FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = 1000156013,
FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014,
FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = 1000156015,
FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016,
FORMAT_R12X4_UNORM_PACK16_KHR = 1000156017,
FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = 1000156018,
FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = 1000156019,
FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = 1000156020,
FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = 1000156021,
FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022,
FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = 1000156023,
FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024,
FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = 1000156025,
FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026,
FORMAT_G16B16G16R16_422_UNORM_KHR = 1000156027,
FORMAT_B16G16R16G16_422_UNORM_KHR = 1000156028,
FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = 1000156029,
FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = 1000156030,
FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = 1000156031,
FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = 1000156032,
FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = 1000156033,
FORMAT_MAX_ENUM = 2147483647,
_,
};
pub const Format = enum_Format;
pub const IMAGE_TILING_OPTIMAL = @enumToInt(enum_ImageTiling.IMAGE_TILING_OPTIMAL);
pub const IMAGE_TILING_LINEAR = @enumToInt(enum_ImageTiling.IMAGE_TILING_LINEAR);
pub const IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = @enumToInt(enum_ImageTiling.IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT);
pub const IMAGE_TILING_MAX_ENUM = @enumToInt(enum_ImageTiling.IMAGE_TILING_MAX_ENUM);
pub const enum_ImageTiling = extern enum(c_int) {
IMAGE_TILING_OPTIMAL = 0,
IMAGE_TILING_LINEAR = 1,
IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,
IMAGE_TILING_MAX_ENUM = 2147483647,
_,
};
pub const ImageTiling = enum_ImageTiling;
pub const IMAGE_TYPE_1D = @enumToInt(enum_ImageType.IMAGE_TYPE_1D);
pub const IMAGE_TYPE_2D = @enumToInt(enum_ImageType.IMAGE_TYPE_2D);
pub const IMAGE_TYPE_3D = @enumToInt(enum_ImageType.IMAGE_TYPE_3D);
pub const IMAGE_TYPE_MAX_ENUM = @enumToInt(enum_ImageType.IMAGE_TYPE_MAX_ENUM);
pub const enum_ImageType = extern enum(c_int) {
IMAGE_TYPE_1D = 0,
IMAGE_TYPE_2D = 1,
IMAGE_TYPE_3D = 2,
IMAGE_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const ImageType = enum_ImageType;
pub const PHYSICAL_DEVICE_TYPE_OTHER = @enumToInt(enum_PhysicalDeviceType.PHYSICAL_DEVICE_TYPE_OTHER);
pub const PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = @enumToInt(enum_PhysicalDeviceType.PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU);
pub const PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = @enumToInt(enum_PhysicalDeviceType.PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
pub const PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = @enumToInt(enum_PhysicalDeviceType.PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);
pub const PHYSICAL_DEVICE_TYPE_CPU = @enumToInt(enum_PhysicalDeviceType.PHYSICAL_DEVICE_TYPE_CPU);
pub const PHYSICAL_DEVICE_TYPE_MAX_ENUM = @enumToInt(enum_PhysicalDeviceType.PHYSICAL_DEVICE_TYPE_MAX_ENUM);
pub const enum_PhysicalDeviceType = extern enum(c_int) {
PHYSICAL_DEVICE_TYPE_OTHER = 0,
PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
PHYSICAL_DEVICE_TYPE_CPU = 4,
PHYSICAL_DEVICE_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const PhysicalDeviceType = enum_PhysicalDeviceType;
pub const QUERY_TYPE_OCCLUSION = @enumToInt(enum_QueryType.QUERY_TYPE_OCCLUSION);
pub const QUERY_TYPE_PIPELINE_STATISTICS = @enumToInt(enum_QueryType.QUERY_TYPE_PIPELINE_STATISTICS);
pub const QUERY_TYPE_TIMESTAMP = @enumToInt(enum_QueryType.QUERY_TYPE_TIMESTAMP);
pub const QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = @enumToInt(enum_QueryType.QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT);
pub const QUERY_TYPE_PERFORMANCE_QUERY_KHR = @enumToInt(enum_QueryType.QUERY_TYPE_PERFORMANCE_QUERY_KHR);
pub const QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = @enumToInt(enum_QueryType.QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR);
pub const QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = @enumToInt(enum_QueryType.QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR);
pub const QUERY_TYPE_PERFORMANCE_QUERY_INTEL = @enumToInt(enum_QueryType.QUERY_TYPE_PERFORMANCE_QUERY_INTEL);
pub const QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = @enumToInt(enum_QueryType.QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV);
pub const QUERY_TYPE_MAX_ENUM = @enumToInt(enum_QueryType.QUERY_TYPE_MAX_ENUM);
pub const enum_QueryType = extern enum(c_int) {
QUERY_TYPE_OCCLUSION = 0,
QUERY_TYPE_PIPELINE_STATISTICS = 1,
QUERY_TYPE_TIMESTAMP = 2,
QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000165000,
QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150000,
QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
QUERY_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const QueryType = enum_QueryType;
pub const SHARING_MODE_EXCLUSIVE = @enumToInt(enum_SharingMode.SHARING_MODE_EXCLUSIVE);
pub const SHARING_MODE_CONCURRENT = @enumToInt(enum_SharingMode.SHARING_MODE_CONCURRENT);
pub const SHARING_MODE_MAX_ENUM = @enumToInt(enum_SharingMode.SHARING_MODE_MAX_ENUM);
pub const enum_SharingMode = extern enum(c_int) {
SHARING_MODE_EXCLUSIVE = 0,
SHARING_MODE_CONCURRENT = 1,
SHARING_MODE_MAX_ENUM = 2147483647,
_,
};
pub const SharingMode = enum_SharingMode;
pub const COMPONENT_SWIZZLE_IDENTITY = @enumToInt(enum_ComponentSwizzle.COMPONENT_SWIZZLE_IDENTITY);
pub const COMPONENT_SWIZZLE_ZERO = @enumToInt(enum_ComponentSwizzle.COMPONENT_SWIZZLE_ZERO);
pub const COMPONENT_SWIZZLE_ONE = @enumToInt(enum_ComponentSwizzle.COMPONENT_SWIZZLE_ONE);
pub const COMPONENT_SWIZZLE_R = @enumToInt(enum_ComponentSwizzle.COMPONENT_SWIZZLE_R);
pub const COMPONENT_SWIZZLE_G = @enumToInt(enum_ComponentSwizzle.COMPONENT_SWIZZLE_G);
pub const COMPONENT_SWIZZLE_B = @enumToInt(enum_ComponentSwizzle.COMPONENT_SWIZZLE_B);
pub const COMPONENT_SWIZZLE_A = @enumToInt(enum_ComponentSwizzle.COMPONENT_SWIZZLE_A);
pub const COMPONENT_SWIZZLE_MAX_ENUM = @enumToInt(enum_ComponentSwizzle.COMPONENT_SWIZZLE_MAX_ENUM);
pub const enum_ComponentSwizzle = extern enum(c_int) {
COMPONENT_SWIZZLE_IDENTITY = 0,
COMPONENT_SWIZZLE_ZERO = 1,
COMPONENT_SWIZZLE_ONE = 2,
COMPONENT_SWIZZLE_R = 3,
COMPONENT_SWIZZLE_G = 4,
COMPONENT_SWIZZLE_B = 5,
COMPONENT_SWIZZLE_A = 6,
COMPONENT_SWIZZLE_MAX_ENUM = 2147483647,
_,
};
pub const ComponentSwizzle = enum_ComponentSwizzle;
pub const IMAGE_VIEW_TYPE_1D = @enumToInt(enum_ImageViewType.IMAGE_VIEW_TYPE_1D);
pub const IMAGE_VIEW_TYPE_2D = @enumToInt(enum_ImageViewType.IMAGE_VIEW_TYPE_2D);
pub const IMAGE_VIEW_TYPE_3D = @enumToInt(enum_ImageViewType.IMAGE_VIEW_TYPE_3D);
pub const IMAGE_VIEW_TYPE_CUBE = @enumToInt(enum_ImageViewType.IMAGE_VIEW_TYPE_CUBE);
pub const IMAGE_VIEW_TYPE_1D_ARRAY = @enumToInt(enum_ImageViewType.IMAGE_VIEW_TYPE_1D_ARRAY);
pub const IMAGE_VIEW_TYPE_2D_ARRAY = @enumToInt(enum_ImageViewType.IMAGE_VIEW_TYPE_2D_ARRAY);
pub const IMAGE_VIEW_TYPE_CUBE_ARRAY = @enumToInt(enum_ImageViewType.IMAGE_VIEW_TYPE_CUBE_ARRAY);
pub const IMAGE_VIEW_TYPE_MAX_ENUM = @enumToInt(enum_ImageViewType.IMAGE_VIEW_TYPE_MAX_ENUM);
pub const enum_ImageViewType = extern enum(c_int) {
IMAGE_VIEW_TYPE_1D = 0,
IMAGE_VIEW_TYPE_2D = 1,
IMAGE_VIEW_TYPE_3D = 2,
IMAGE_VIEW_TYPE_CUBE = 3,
IMAGE_VIEW_TYPE_1D_ARRAY = 4,
IMAGE_VIEW_TYPE_2D_ARRAY = 5,
IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
IMAGE_VIEW_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const ImageViewType = enum_ImageViewType;
pub const BLEND_FACTOR_ZERO = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ZERO);
pub const BLEND_FACTOR_ONE = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE);
pub const BLEND_FACTOR_SRC_COLOR = @enumToInt(enum_BlendFactor.BLEND_FACTOR_SRC_COLOR);
pub const BLEND_FACTOR_ONE_MINUS_SRC_COLOR = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE_MINUS_SRC_COLOR);
pub const BLEND_FACTOR_DST_COLOR = @enumToInt(enum_BlendFactor.BLEND_FACTOR_DST_COLOR);
pub const BLEND_FACTOR_ONE_MINUS_DST_COLOR = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE_MINUS_DST_COLOR);
pub const BLEND_FACTOR_SRC_ALPHA = @enumToInt(enum_BlendFactor.BLEND_FACTOR_SRC_ALPHA);
pub const BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA);
pub const BLEND_FACTOR_DST_ALPHA = @enumToInt(enum_BlendFactor.BLEND_FACTOR_DST_ALPHA);
pub const BLEND_FACTOR_ONE_MINUS_DST_ALPHA = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE_MINUS_DST_ALPHA);
pub const BLEND_FACTOR_CONSTANT_COLOR = @enumToInt(enum_BlendFactor.BLEND_FACTOR_CONSTANT_COLOR);
pub const BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR);
pub const BLEND_FACTOR_CONSTANT_ALPHA = @enumToInt(enum_BlendFactor.BLEND_FACTOR_CONSTANT_ALPHA);
pub const BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA);
pub const BLEND_FACTOR_SRC_ALPHA_SATURATE = @enumToInt(enum_BlendFactor.BLEND_FACTOR_SRC_ALPHA_SATURATE);
pub const BLEND_FACTOR_SRC1_COLOR = @enumToInt(enum_BlendFactor.BLEND_FACTOR_SRC1_COLOR);
pub const BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE_MINUS_SRC1_COLOR);
pub const BLEND_FACTOR_SRC1_ALPHA = @enumToInt(enum_BlendFactor.BLEND_FACTOR_SRC1_ALPHA);
pub const BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = @enumToInt(enum_BlendFactor.BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA);
pub const BLEND_FACTOR_MAX_ENUM = @enumToInt(enum_BlendFactor.BLEND_FACTOR_MAX_ENUM);
pub const enum_BlendFactor = extern enum(c_int) {
BLEND_FACTOR_ZERO = 0,
BLEND_FACTOR_ONE = 1,
BLEND_FACTOR_SRC_COLOR = 2,
BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
BLEND_FACTOR_DST_COLOR = 4,
BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
BLEND_FACTOR_SRC_ALPHA = 6,
BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
BLEND_FACTOR_DST_ALPHA = 8,
BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
BLEND_FACTOR_CONSTANT_COLOR = 10,
BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
BLEND_FACTOR_CONSTANT_ALPHA = 12,
BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
BLEND_FACTOR_SRC1_COLOR = 15,
BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
BLEND_FACTOR_SRC1_ALPHA = 17,
BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
BLEND_FACTOR_MAX_ENUM = 2147483647,
_,
};
pub const BlendFactor = enum_BlendFactor;
pub const BLEND_OP_ADD = @enumToInt(enum_BlendOp.BLEND_OP_ADD);
pub const BLEND_OP_SUBTRACT = @enumToInt(enum_BlendOp.BLEND_OP_SUBTRACT);
pub const BLEND_OP_REVERSE_SUBTRACT = @enumToInt(enum_BlendOp.BLEND_OP_REVERSE_SUBTRACT);
pub const BLEND_OP_MIN = @enumToInt(enum_BlendOp.BLEND_OP_MIN);
pub const BLEND_OP_MAX = @enumToInt(enum_BlendOp.BLEND_OP_MAX);
pub const BLEND_OP_ZERO_EXT = @enumToInt(enum_BlendOp.BLEND_OP_ZERO_EXT);
pub const BLEND_OP_SRC_EXT = @enumToInt(enum_BlendOp.BLEND_OP_SRC_EXT);
pub const BLEND_OP_DST_EXT = @enumToInt(enum_BlendOp.BLEND_OP_DST_EXT);
pub const BLEND_OP_SRC_OVER_EXT = @enumToInt(enum_BlendOp.BLEND_OP_SRC_OVER_EXT);
pub const BLEND_OP_DST_OVER_EXT = @enumToInt(enum_BlendOp.BLEND_OP_DST_OVER_EXT);
pub const BLEND_OP_SRC_IN_EXT = @enumToInt(enum_BlendOp.BLEND_OP_SRC_IN_EXT);
pub const BLEND_OP_DST_IN_EXT = @enumToInt(enum_BlendOp.BLEND_OP_DST_IN_EXT);
pub const BLEND_OP_SRC_OUT_EXT = @enumToInt(enum_BlendOp.BLEND_OP_SRC_OUT_EXT);
pub const BLEND_OP_DST_OUT_EXT = @enumToInt(enum_BlendOp.BLEND_OP_DST_OUT_EXT);
pub const BLEND_OP_SRC_ATOP_EXT = @enumToInt(enum_BlendOp.BLEND_OP_SRC_ATOP_EXT);
pub const BLEND_OP_DST_ATOP_EXT = @enumToInt(enum_BlendOp.BLEND_OP_DST_ATOP_EXT);
pub const BLEND_OP_XOR_EXT = @enumToInt(enum_BlendOp.BLEND_OP_XOR_EXT);
pub const BLEND_OP_MULTIPLY_EXT = @enumToInt(enum_BlendOp.BLEND_OP_MULTIPLY_EXT);
pub const BLEND_OP_SCREEN_EXT = @enumToInt(enum_BlendOp.BLEND_OP_SCREEN_EXT);
pub const BLEND_OP_OVERLAY_EXT = @enumToInt(enum_BlendOp.BLEND_OP_OVERLAY_EXT);
pub const BLEND_OP_DARKEN_EXT = @enumToInt(enum_BlendOp.BLEND_OP_DARKEN_EXT);
pub const BLEND_OP_LIGHTEN_EXT = @enumToInt(enum_BlendOp.BLEND_OP_LIGHTEN_EXT);
pub const BLEND_OP_COLORDODGE_EXT = @enumToInt(enum_BlendOp.BLEND_OP_COLORDODGE_EXT);
pub const BLEND_OP_COLORBURN_EXT = @enumToInt(enum_BlendOp.BLEND_OP_COLORBURN_EXT);
pub const BLEND_OP_HARDLIGHT_EXT = @enumToInt(enum_BlendOp.BLEND_OP_HARDLIGHT_EXT);
pub const BLEND_OP_SOFTLIGHT_EXT = @enumToInt(enum_BlendOp.BLEND_OP_SOFTLIGHT_EXT);
pub const BLEND_OP_DIFFERENCE_EXT = @enumToInt(enum_BlendOp.BLEND_OP_DIFFERENCE_EXT);
pub const BLEND_OP_EXCLUSION_EXT = @enumToInt(enum_BlendOp.BLEND_OP_EXCLUSION_EXT);
pub const BLEND_OP_INVERT_EXT = @enumToInt(enum_BlendOp.BLEND_OP_INVERT_EXT);
pub const BLEND_OP_INVERT_RGB_EXT = @enumToInt(enum_BlendOp.BLEND_OP_INVERT_RGB_EXT);
pub const BLEND_OP_LINEARDODGE_EXT = @enumToInt(enum_BlendOp.BLEND_OP_LINEARDODGE_EXT);
pub const BLEND_OP_LINEARBURN_EXT = @enumToInt(enum_BlendOp.BLEND_OP_LINEARBURN_EXT);
pub const BLEND_OP_VIVIDLIGHT_EXT = @enumToInt(enum_BlendOp.BLEND_OP_VIVIDLIGHT_EXT);
pub const BLEND_OP_LINEARLIGHT_EXT = @enumToInt(enum_BlendOp.BLEND_OP_LINEARLIGHT_EXT);
pub const BLEND_OP_PINLIGHT_EXT = @enumToInt(enum_BlendOp.BLEND_OP_PINLIGHT_EXT);
pub const BLEND_OP_HARDMIX_EXT = @enumToInt(enum_BlendOp.BLEND_OP_HARDMIX_EXT);
pub const BLEND_OP_HSL_HUE_EXT = @enumToInt(enum_BlendOp.BLEND_OP_HSL_HUE_EXT);
pub const BLEND_OP_HSL_SATURATION_EXT = @enumToInt(enum_BlendOp.BLEND_OP_HSL_SATURATION_EXT);
pub const BLEND_OP_HSL_COLOR_EXT = @enumToInt(enum_BlendOp.BLEND_OP_HSL_COLOR_EXT);
pub const BLEND_OP_HSL_LUMINOSITY_EXT = @enumToInt(enum_BlendOp.BLEND_OP_HSL_LUMINOSITY_EXT);
pub const BLEND_OP_PLUS_EXT = @enumToInt(enum_BlendOp.BLEND_OP_PLUS_EXT);
pub const BLEND_OP_PLUS_CLAMPED_EXT = @enumToInt(enum_BlendOp.BLEND_OP_PLUS_CLAMPED_EXT);
pub const BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = @enumToInt(enum_BlendOp.BLEND_OP_PLUS_CLAMPED_ALPHA_EXT);
pub const BLEND_OP_PLUS_DARKER_EXT = @enumToInt(enum_BlendOp.BLEND_OP_PLUS_DARKER_EXT);
pub const BLEND_OP_MINUS_EXT = @enumToInt(enum_BlendOp.BLEND_OP_MINUS_EXT);
pub const BLEND_OP_MINUS_CLAMPED_EXT = @enumToInt(enum_BlendOp.BLEND_OP_MINUS_CLAMPED_EXT);
pub const BLEND_OP_CONTRAST_EXT = @enumToInt(enum_BlendOp.BLEND_OP_CONTRAST_EXT);
pub const BLEND_OP_INVERT_OVG_EXT = @enumToInt(enum_BlendOp.BLEND_OP_INVERT_OVG_EXT);
pub const BLEND_OP_RED_EXT = @enumToInt(enum_BlendOp.BLEND_OP_RED_EXT);
pub const BLEND_OP_GREEN_EXT = @enumToInt(enum_BlendOp.BLEND_OP_GREEN_EXT);
pub const BLEND_OP_BLUE_EXT = @enumToInt(enum_BlendOp.BLEND_OP_BLUE_EXT);
pub const BLEND_OP_MAX_ENUM = @enumToInt(enum_BlendOp.BLEND_OP_MAX_ENUM);
pub const enum_BlendOp = extern enum(c_int) {
BLEND_OP_ADD = 0,
BLEND_OP_SUBTRACT = 1,
BLEND_OP_REVERSE_SUBTRACT = 2,
BLEND_OP_MIN = 3,
BLEND_OP_MAX = 4,
BLEND_OP_ZERO_EXT = 1000148000,
BLEND_OP_SRC_EXT = 1000148001,
BLEND_OP_DST_EXT = 1000148002,
BLEND_OP_SRC_OVER_EXT = 1000148003,
BLEND_OP_DST_OVER_EXT = 1000148004,
BLEND_OP_SRC_IN_EXT = 1000148005,
BLEND_OP_DST_IN_EXT = 1000148006,
BLEND_OP_SRC_OUT_EXT = 1000148007,
BLEND_OP_DST_OUT_EXT = 1000148008,
BLEND_OP_SRC_ATOP_EXT = 1000148009,
BLEND_OP_DST_ATOP_EXT = 1000148010,
BLEND_OP_XOR_EXT = 1000148011,
BLEND_OP_MULTIPLY_EXT = 1000148012,
BLEND_OP_SCREEN_EXT = 1000148013,
BLEND_OP_OVERLAY_EXT = 1000148014,
BLEND_OP_DARKEN_EXT = 1000148015,
BLEND_OP_LIGHTEN_EXT = 1000148016,
BLEND_OP_COLORDODGE_EXT = 1000148017,
BLEND_OP_COLORBURN_EXT = 1000148018,
BLEND_OP_HARDLIGHT_EXT = 1000148019,
BLEND_OP_SOFTLIGHT_EXT = 1000148020,
BLEND_OP_DIFFERENCE_EXT = 1000148021,
BLEND_OP_EXCLUSION_EXT = 1000148022,
BLEND_OP_INVERT_EXT = 1000148023,
BLEND_OP_INVERT_RGB_EXT = 1000148024,
BLEND_OP_LINEARDODGE_EXT = 1000148025,
BLEND_OP_LINEARBURN_EXT = 1000148026,
BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
BLEND_OP_LINEARLIGHT_EXT = 1000148028,
BLEND_OP_PINLIGHT_EXT = 1000148029,
BLEND_OP_HARDMIX_EXT = 1000148030,
BLEND_OP_HSL_HUE_EXT = 1000148031,
BLEND_OP_HSL_SATURATION_EXT = 1000148032,
BLEND_OP_HSL_COLOR_EXT = 1000148033,
BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
BLEND_OP_PLUS_EXT = 1000148035,
BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
BLEND_OP_PLUS_DARKER_EXT = 1000148038,
BLEND_OP_MINUS_EXT = 1000148039,
BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
BLEND_OP_CONTRAST_EXT = 1000148041,
BLEND_OP_INVERT_OVG_EXT = 1000148042,
BLEND_OP_RED_EXT = 1000148043,
BLEND_OP_GREEN_EXT = 1000148044,
BLEND_OP_BLUE_EXT = 1000148045,
BLEND_OP_MAX_ENUM = 2147483647,
_,
};
pub const BlendOp = enum_BlendOp;
pub const COMPARE_OP_NEVER = @enumToInt(enum_CompareOp.COMPARE_OP_NEVER);
pub const COMPARE_OP_LESS = @enumToInt(enum_CompareOp.COMPARE_OP_LESS);
pub const COMPARE_OP_EQUAL = @enumToInt(enum_CompareOp.COMPARE_OP_EQUAL);
pub const COMPARE_OP_LESS_OR_EQUAL = @enumToInt(enum_CompareOp.COMPARE_OP_LESS_OR_EQUAL);
pub const COMPARE_OP_GREATER = @enumToInt(enum_CompareOp.COMPARE_OP_GREATER);
pub const COMPARE_OP_NOT_EQUAL = @enumToInt(enum_CompareOp.COMPARE_OP_NOT_EQUAL);
pub const COMPARE_OP_GREATER_OR_EQUAL = @enumToInt(enum_CompareOp.COMPARE_OP_GREATER_OR_EQUAL);
pub const COMPARE_OP_ALWAYS = @enumToInt(enum_CompareOp.COMPARE_OP_ALWAYS);
pub const COMPARE_OP_MAX_ENUM = @enumToInt(enum_CompareOp.COMPARE_OP_MAX_ENUM);
pub const enum_CompareOp = extern enum(c_int) {
COMPARE_OP_NEVER = 0,
COMPARE_OP_LESS = 1,
COMPARE_OP_EQUAL = 2,
COMPARE_OP_LESS_OR_EQUAL = 3,
COMPARE_OP_GREATER = 4,
COMPARE_OP_NOT_EQUAL = 5,
COMPARE_OP_GREATER_OR_EQUAL = 6,
COMPARE_OP_ALWAYS = 7,
COMPARE_OP_MAX_ENUM = 2147483647,
_,
};
pub const CompareOp = enum_CompareOp;
pub const DYNAMIC_STATE_VIEWPORT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_VIEWPORT);
pub const DYNAMIC_STATE_SCISSOR = @enumToInt(enum_DynamicState.DYNAMIC_STATE_SCISSOR);
pub const DYNAMIC_STATE_LINE_WIDTH = @enumToInt(enum_DynamicState.DYNAMIC_STATE_LINE_WIDTH);
pub const DYNAMIC_STATE_DEPTH_BIAS = @enumToInt(enum_DynamicState.DYNAMIC_STATE_DEPTH_BIAS);
pub const DYNAMIC_STATE_BLEND_CONSTANTS = @enumToInt(enum_DynamicState.DYNAMIC_STATE_BLEND_CONSTANTS);
pub const DYNAMIC_STATE_DEPTH_BOUNDS = @enumToInt(enum_DynamicState.DYNAMIC_STATE_DEPTH_BOUNDS);
pub const DYNAMIC_STATE_STENCIL_COMPARE_MASK = @enumToInt(enum_DynamicState.DYNAMIC_STATE_STENCIL_COMPARE_MASK);
pub const DYNAMIC_STATE_STENCIL_WRITE_MASK = @enumToInt(enum_DynamicState.DYNAMIC_STATE_STENCIL_WRITE_MASK);
pub const DYNAMIC_STATE_STENCIL_REFERENCE = @enumToInt(enum_DynamicState.DYNAMIC_STATE_STENCIL_REFERENCE);
pub const DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = @enumToInt(enum_DynamicState.DYNAMIC_STATE_VIEWPORT_W_SCALING_NV);
pub const DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_DISCARD_RECTANGLE_EXT);
pub const DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT);
pub const DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = @enumToInt(enum_DynamicState.DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV);
pub const DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = @enumToInt(enum_DynamicState.DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV);
pub const DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = @enumToInt(enum_DynamicState.DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV);
pub const DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = @enumToInt(enum_DynamicState.DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR);
pub const DYNAMIC_STATE_LINE_STIPPLE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_LINE_STIPPLE_EXT);
pub const DYNAMIC_STATE_CULL_MODE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_CULL_MODE_EXT);
pub const DYNAMIC_STATE_FRONT_FACE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_FRONT_FACE_EXT);
pub const DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT);
pub const DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT);
pub const DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT);
pub const DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT);
pub const DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT);
pub const DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT);
pub const DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT);
pub const DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT);
pub const DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT);
pub const DYNAMIC_STATE_STENCIL_OP_EXT = @enumToInt(enum_DynamicState.DYNAMIC_STATE_STENCIL_OP_EXT);
pub const DYNAMIC_STATE_MAX_ENUM = @enumToInt(enum_DynamicState.DYNAMIC_STATE_MAX_ENUM);
pub const enum_DynamicState = extern enum(c_int) {
DYNAMIC_STATE_VIEWPORT = 0,
DYNAMIC_STATE_SCISSOR = 1,
DYNAMIC_STATE_LINE_WIDTH = 2,
DYNAMIC_STATE_DEPTH_BIAS = 3,
DYNAMIC_STATE_BLEND_CONSTANTS = 4,
DYNAMIC_STATE_DEPTH_BOUNDS = 5,
DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
DYNAMIC_STATE_STENCIL_REFERENCE = 8,
DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
DYNAMIC_STATE_CULL_MODE_EXT = 1000267000,
DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001,
DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002,
DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003,
DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004,
DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005,
DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006,
DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007,
DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008,
DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009,
DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010,
DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011,
DYNAMIC_STATE_MAX_ENUM = 2147483647,
_,
};
pub const DynamicState = enum_DynamicState;
pub const FRONT_FACE_COUNTER_CLOCKWISE = @enumToInt(enum_FrontFace.FRONT_FACE_COUNTER_CLOCKWISE);
pub const FRONT_FACE_CLOCKWISE = @enumToInt(enum_FrontFace.FRONT_FACE_CLOCKWISE);
pub const FRONT_FACE_MAX_ENUM = @enumToInt(enum_FrontFace.FRONT_FACE_MAX_ENUM);
pub const enum_FrontFace = extern enum(c_int) {
FRONT_FACE_COUNTER_CLOCKWISE = 0,
FRONT_FACE_CLOCKWISE = 1,
FRONT_FACE_MAX_ENUM = 2147483647,
_,
};
pub const FrontFace = enum_FrontFace;
pub const VERTEX_INPUT_RATE_VERTEX = @enumToInt(enum_VertexInputRate.VERTEX_INPUT_RATE_VERTEX);
pub const VERTEX_INPUT_RATE_INSTANCE = @enumToInt(enum_VertexInputRate.VERTEX_INPUT_RATE_INSTANCE);
pub const VERTEX_INPUT_RATE_MAX_ENUM = @enumToInt(enum_VertexInputRate.VERTEX_INPUT_RATE_MAX_ENUM);
pub const enum_VertexInputRate = extern enum(c_int) {
VERTEX_INPUT_RATE_VERTEX = 0,
VERTEX_INPUT_RATE_INSTANCE = 1,
VERTEX_INPUT_RATE_MAX_ENUM = 2147483647,
_,
};
pub const VertexInputRate = enum_VertexInputRate;
pub const PRIMITIVE_TOPOLOGY_POINT_LIST = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_POINT_LIST);
pub const PRIMITIVE_TOPOLOGY_LINE_LIST = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_LINE_LIST);
pub const PRIMITIVE_TOPOLOGY_LINE_STRIP = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_LINE_STRIP);
pub const PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
pub const PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP);
pub const PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_TRIANGLE_FAN);
pub const PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY);
pub const PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY);
pub const PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY);
pub const PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY);
pub const PRIMITIVE_TOPOLOGY_PATCH_LIST = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_PATCH_LIST);
pub const PRIMITIVE_TOPOLOGY_MAX_ENUM = @enumToInt(enum_PrimitiveTopology.PRIMITIVE_TOPOLOGY_MAX_ENUM);
pub const enum_PrimitiveTopology = extern enum(c_int) {
PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
PRIMITIVE_TOPOLOGY_MAX_ENUM = 2147483647,
_,
};
pub const PrimitiveTopology = enum_PrimitiveTopology;
pub const POLYGON_MODE_FILL = @enumToInt(enum_PolygonMode.POLYGON_MODE_FILL);
pub const POLYGON_MODE_LINE = @enumToInt(enum_PolygonMode.POLYGON_MODE_LINE);
pub const POLYGON_MODE_POINT = @enumToInt(enum_PolygonMode.POLYGON_MODE_POINT);
pub const POLYGON_MODE_FILL_RECTANGLE_NV = @enumToInt(enum_PolygonMode.POLYGON_MODE_FILL_RECTANGLE_NV);
pub const POLYGON_MODE_MAX_ENUM = @enumToInt(enum_PolygonMode.POLYGON_MODE_MAX_ENUM);
pub const enum_PolygonMode = extern enum(c_int) {
POLYGON_MODE_FILL = 0,
POLYGON_MODE_LINE = 1,
POLYGON_MODE_POINT = 2,
POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
POLYGON_MODE_MAX_ENUM = 2147483647,
_,
};
pub const PolygonMode = enum_PolygonMode;
pub const STENCIL_OP_KEEP = @enumToInt(enum_StencilOp.STENCIL_OP_KEEP);
pub const STENCIL_OP_ZERO = @enumToInt(enum_StencilOp.STENCIL_OP_ZERO);
pub const STENCIL_OP_REPLACE = @enumToInt(enum_StencilOp.STENCIL_OP_REPLACE);
pub const STENCIL_OP_INCREMENT_AND_CLAMP = @enumToInt(enum_StencilOp.STENCIL_OP_INCREMENT_AND_CLAMP);
pub const STENCIL_OP_DECREMENT_AND_CLAMP = @enumToInt(enum_StencilOp.STENCIL_OP_DECREMENT_AND_CLAMP);
pub const STENCIL_OP_INVERT = @enumToInt(enum_StencilOp.STENCIL_OP_INVERT);
pub const STENCIL_OP_INCREMENT_AND_WRAP = @enumToInt(enum_StencilOp.STENCIL_OP_INCREMENT_AND_WRAP);
pub const STENCIL_OP_DECREMENT_AND_WRAP = @enumToInt(enum_StencilOp.STENCIL_OP_DECREMENT_AND_WRAP);
pub const STENCIL_OP_MAX_ENUM = @enumToInt(enum_StencilOp.STENCIL_OP_MAX_ENUM);
pub const enum_StencilOp = extern enum(c_int) {
STENCIL_OP_KEEP = 0,
STENCIL_OP_ZERO = 1,
STENCIL_OP_REPLACE = 2,
STENCIL_OP_INCREMENT_AND_CLAMP = 3,
STENCIL_OP_DECREMENT_AND_CLAMP = 4,
STENCIL_OP_INVERT = 5,
STENCIL_OP_INCREMENT_AND_WRAP = 6,
STENCIL_OP_DECREMENT_AND_WRAP = 7,
STENCIL_OP_MAX_ENUM = 2147483647,
_,
};
pub const StencilOp = enum_StencilOp;
pub const LOGIC_OP_CLEAR = @enumToInt(enum_LogicOp.LOGIC_OP_CLEAR);
pub const LOGIC_OP_AND = @enumToInt(enum_LogicOp.LOGIC_OP_AND);
pub const LOGIC_OP_AND_REVERSE = @enumToInt(enum_LogicOp.LOGIC_OP_AND_REVERSE);
pub const LOGIC_OP_COPY = @enumToInt(enum_LogicOp.LOGIC_OP_COPY);
pub const LOGIC_OP_AND_INVERTED = @enumToInt(enum_LogicOp.LOGIC_OP_AND_INVERTED);
pub const LOGIC_OP_NO_OP = @enumToInt(enum_LogicOp.LOGIC_OP_NO_OP);
pub const LOGIC_OP_XOR = @enumToInt(enum_LogicOp.LOGIC_OP_XOR);
pub const LOGIC_OP_OR = @enumToInt(enum_LogicOp.LOGIC_OP_OR);
pub const LOGIC_OP_NOR = @enumToInt(enum_LogicOp.LOGIC_OP_NOR);
pub const LOGIC_OP_EQUIVALENT = @enumToInt(enum_LogicOp.LOGIC_OP_EQUIVALENT);
pub const LOGIC_OP_INVERT = @enumToInt(enum_LogicOp.LOGIC_OP_INVERT);
pub const LOGIC_OP_OR_REVERSE = @enumToInt(enum_LogicOp.LOGIC_OP_OR_REVERSE);
pub const LOGIC_OP_COPY_INVERTED = @enumToInt(enum_LogicOp.LOGIC_OP_COPY_INVERTED);
pub const LOGIC_OP_OR_INVERTED = @enumToInt(enum_LogicOp.LOGIC_OP_OR_INVERTED);
pub const LOGIC_OP_NAND = @enumToInt(enum_LogicOp.LOGIC_OP_NAND);
pub const LOGIC_OP_SET = @enumToInt(enum_LogicOp.LOGIC_OP_SET);
pub const LOGIC_OP_MAX_ENUM = @enumToInt(enum_LogicOp.LOGIC_OP_MAX_ENUM);
pub const enum_LogicOp = extern enum(c_int) {
LOGIC_OP_CLEAR = 0,
LOGIC_OP_AND = 1,
LOGIC_OP_AND_REVERSE = 2,
LOGIC_OP_COPY = 3,
LOGIC_OP_AND_INVERTED = 4,
LOGIC_OP_NO_OP = 5,
LOGIC_OP_XOR = 6,
LOGIC_OP_OR = 7,
LOGIC_OP_NOR = 8,
LOGIC_OP_EQUIVALENT = 9,
LOGIC_OP_INVERT = 10,
LOGIC_OP_OR_REVERSE = 11,
LOGIC_OP_COPY_INVERTED = 12,
LOGIC_OP_OR_INVERTED = 13,
LOGIC_OP_NAND = 14,
LOGIC_OP_SET = 15,
LOGIC_OP_MAX_ENUM = 2147483647,
_,
};
pub const LogicOp = enum_LogicOp;
pub const BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = @enumToInt(enum_BorderColor.BORDER_COLOR_FLOAT_TRANSPARENT_BLACK);
pub const BORDER_COLOR_INT_TRANSPARENT_BLACK = @enumToInt(enum_BorderColor.BORDER_COLOR_INT_TRANSPARENT_BLACK);
pub const BORDER_COLOR_FLOAT_OPAQUE_BLACK = @enumToInt(enum_BorderColor.BORDER_COLOR_FLOAT_OPAQUE_BLACK);
pub const BORDER_COLOR_INT_OPAQUE_BLACK = @enumToInt(enum_BorderColor.BORDER_COLOR_INT_OPAQUE_BLACK);
pub const BORDER_COLOR_FLOAT_OPAQUE_WHITE = @enumToInt(enum_BorderColor.BORDER_COLOR_FLOAT_OPAQUE_WHITE);
pub const BORDER_COLOR_INT_OPAQUE_WHITE = @enumToInt(enum_BorderColor.BORDER_COLOR_INT_OPAQUE_WHITE);
pub const BORDER_COLOR_FLOAT_CUSTOM_EXT = @enumToInt(enum_BorderColor.BORDER_COLOR_FLOAT_CUSTOM_EXT);
pub const BORDER_COLOR_INT_CUSTOM_EXT = @enumToInt(enum_BorderColor.BORDER_COLOR_INT_CUSTOM_EXT);
pub const BORDER_COLOR_MAX_ENUM = @enumToInt(enum_BorderColor.BORDER_COLOR_MAX_ENUM);
pub const enum_BorderColor = extern enum(c_int) {
BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
BORDER_COLOR_INT_OPAQUE_BLACK = 3,
BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
BORDER_COLOR_INT_OPAQUE_WHITE = 5,
BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003,
BORDER_COLOR_INT_CUSTOM_EXT = 1000287004,
BORDER_COLOR_MAX_ENUM = 2147483647,
_,
};
pub const BorderColor = enum_BorderColor;
pub const FILTER_NEAREST = @enumToInt(enum_Filter.FILTER_NEAREST);
pub const FILTER_LINEAR = @enumToInt(enum_Filter.FILTER_LINEAR);
pub const FILTER_CUBIC_IMG = @enumToInt(enum_Filter.FILTER_CUBIC_IMG);
pub const FILTER_CUBIC_EXT = @enumToInt(enum_Filter.FILTER_CUBIC_EXT);
pub const FILTER_MAX_ENUM = @enumToInt(enum_Filter.FILTER_MAX_ENUM);
pub const enum_Filter = extern enum(c_int) {
FILTER_NEAREST = 0,
FILTER_LINEAR = 1,
FILTER_CUBIC_IMG = 1000015000,
FILTER_CUBIC_EXT = 1000015000,
FILTER_MAX_ENUM = 2147483647,
_,
};
pub const Filter = enum_Filter;
pub const SAMPLER_ADDRESS_MODE_REPEAT = @enumToInt(enum_SamplerAddressMode.SAMPLER_ADDRESS_MODE_REPEAT);
pub const SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = @enumToInt(enum_SamplerAddressMode.SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT);
pub const SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = @enumToInt(enum_SamplerAddressMode.SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
pub const SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = @enumToInt(enum_SamplerAddressMode.SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER);
pub const SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = @enumToInt(enum_SamplerAddressMode.SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE);
pub const SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = @enumToInt(enum_SamplerAddressMode.SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR);
pub const SAMPLER_ADDRESS_MODE_MAX_ENUM = @enumToInt(enum_SamplerAddressMode.SAMPLER_ADDRESS_MODE_MAX_ENUM);
pub const enum_SamplerAddressMode = extern enum(c_int) {
SAMPLER_ADDRESS_MODE_REPEAT = 0,
SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = 4,
SAMPLER_ADDRESS_MODE_MAX_ENUM = 2147483647,
_,
};
pub const SamplerAddressMode = enum_SamplerAddressMode;
pub const SAMPLER_MIPMAP_MODE_NEAREST = @enumToInt(enum_SamplerMipmapMode.SAMPLER_MIPMAP_MODE_NEAREST);
pub const SAMPLER_MIPMAP_MODE_LINEAR = @enumToInt(enum_SamplerMipmapMode.SAMPLER_MIPMAP_MODE_LINEAR);
pub const SAMPLER_MIPMAP_MODE_MAX_ENUM = @enumToInt(enum_SamplerMipmapMode.SAMPLER_MIPMAP_MODE_MAX_ENUM);
pub const enum_SamplerMipmapMode = extern enum(c_int) {
SAMPLER_MIPMAP_MODE_NEAREST = 0,
SAMPLER_MIPMAP_MODE_LINEAR = 1,
SAMPLER_MIPMAP_MODE_MAX_ENUM = 2147483647,
_,
};
pub const SamplerMipmapMode = enum_SamplerMipmapMode;
pub const DESCRIPTOR_TYPE_SAMPLER = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_SAMPLER);
pub const DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
pub const DESCRIPTOR_TYPE_SAMPLED_IMAGE = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_SAMPLED_IMAGE);
pub const DESCRIPTOR_TYPE_STORAGE_IMAGE = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_STORAGE_IMAGE);
pub const DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER);
pub const DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER);
pub const DESCRIPTOR_TYPE_UNIFORM_BUFFER = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_UNIFORM_BUFFER);
pub const DESCRIPTOR_TYPE_STORAGE_BUFFER = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_STORAGE_BUFFER);
pub const DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC);
pub const DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC);
pub const DESCRIPTOR_TYPE_INPUT_ATTACHMENT = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
pub const DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT);
pub const DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR);
pub const DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV);
pub const DESCRIPTOR_TYPE_MAX_ENUM = @enumToInt(enum_DescriptorType.DESCRIPTOR_TYPE_MAX_ENUM);
pub const enum_DescriptorType = extern enum(c_int) {
DESCRIPTOR_TYPE_SAMPLER = 0,
DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000165000,
DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
DESCRIPTOR_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const DescriptorType = enum_DescriptorType;
pub const ATTACHMENT_LOAD_OP_LOAD = @enumToInt(enum_AttachmentLoadOp.ATTACHMENT_LOAD_OP_LOAD);
pub const ATTACHMENT_LOAD_OP_CLEAR = @enumToInt(enum_AttachmentLoadOp.ATTACHMENT_LOAD_OP_CLEAR);
pub const ATTACHMENT_LOAD_OP_DONT_CARE = @enumToInt(enum_AttachmentLoadOp.ATTACHMENT_LOAD_OP_DONT_CARE);
pub const ATTACHMENT_LOAD_OP_MAX_ENUM = @enumToInt(enum_AttachmentLoadOp.ATTACHMENT_LOAD_OP_MAX_ENUM);
pub const enum_AttachmentLoadOp = extern enum(c_int) {
ATTACHMENT_LOAD_OP_LOAD = 0,
ATTACHMENT_LOAD_OP_CLEAR = 1,
ATTACHMENT_LOAD_OP_DONT_CARE = 2,
ATTACHMENT_LOAD_OP_MAX_ENUM = 2147483647,
_,
};
pub const AttachmentLoadOp = enum_AttachmentLoadOp;
pub const ATTACHMENT_STORE_OP_STORE = @enumToInt(enum_AttachmentStoreOp.ATTACHMENT_STORE_OP_STORE);
pub const ATTACHMENT_STORE_OP_DONT_CARE = @enumToInt(enum_AttachmentStoreOp.ATTACHMENT_STORE_OP_DONT_CARE);
pub const ATTACHMENT_STORE_OP_NONE_QCOM = @enumToInt(enum_AttachmentStoreOp.ATTACHMENT_STORE_OP_NONE_QCOM);
pub const ATTACHMENT_STORE_OP_MAX_ENUM = @enumToInt(enum_AttachmentStoreOp.ATTACHMENT_STORE_OP_MAX_ENUM);
pub const enum_AttachmentStoreOp = extern enum(c_int) {
ATTACHMENT_STORE_OP_STORE = 0,
ATTACHMENT_STORE_OP_DONT_CARE = 1,
ATTACHMENT_STORE_OP_NONE_QCOM = 1000301000,
ATTACHMENT_STORE_OP_MAX_ENUM = 2147483647,
_,
};
pub const AttachmentStoreOp = enum_AttachmentStoreOp;
pub const PIPELINE_BIND_POINT_GRAPHICS = @enumToInt(enum_PipelineBindPoint.PIPELINE_BIND_POINT_GRAPHICS);
pub const PIPELINE_BIND_POINT_COMPUTE = @enumToInt(enum_PipelineBindPoint.PIPELINE_BIND_POINT_COMPUTE);
pub const PIPELINE_BIND_POINT_RAY_TRACING_KHR = @enumToInt(enum_PipelineBindPoint.PIPELINE_BIND_POINT_RAY_TRACING_KHR);
pub const PIPELINE_BIND_POINT_RAY_TRACING_NV = @enumToInt(enum_PipelineBindPoint.PIPELINE_BIND_POINT_RAY_TRACING_NV);
pub const PIPELINE_BIND_POINT_MAX_ENUM = @enumToInt(enum_PipelineBindPoint.PIPELINE_BIND_POINT_MAX_ENUM);
pub const enum_PipelineBindPoint = extern enum(c_int) {
PIPELINE_BIND_POINT_GRAPHICS = 0,
PIPELINE_BIND_POINT_COMPUTE = 1,
PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000,
PIPELINE_BIND_POINT_RAY_TRACING_NV = 1000165000,
PIPELINE_BIND_POINT_MAX_ENUM = 2147483647,
_,
};
pub const PipelineBindPoint = enum_PipelineBindPoint;
pub const COMMAND_BUFFER_LEVEL_PRIMARY = @enumToInt(enum_CommandBufferLevel.COMMAND_BUFFER_LEVEL_PRIMARY);
pub const COMMAND_BUFFER_LEVEL_SECONDARY = @enumToInt(enum_CommandBufferLevel.COMMAND_BUFFER_LEVEL_SECONDARY);
pub const COMMAND_BUFFER_LEVEL_MAX_ENUM = @enumToInt(enum_CommandBufferLevel.COMMAND_BUFFER_LEVEL_MAX_ENUM);
pub const enum_CommandBufferLevel = extern enum(c_int) {
COMMAND_BUFFER_LEVEL_PRIMARY = 0,
COMMAND_BUFFER_LEVEL_SECONDARY = 1,
COMMAND_BUFFER_LEVEL_MAX_ENUM = 2147483647,
_,
};
pub const CommandBufferLevel = enum_CommandBufferLevel;
pub const INDEX_TYPE_UINT16 = @enumToInt(enum_IndexType.INDEX_TYPE_UINT16);
pub const INDEX_TYPE_UINT32 = @enumToInt(enum_IndexType.INDEX_TYPE_UINT32);
pub const INDEX_TYPE_NONE_KHR = @enumToInt(enum_IndexType.INDEX_TYPE_NONE_KHR);
pub const INDEX_TYPE_UINT8_EXT = @enumToInt(enum_IndexType.INDEX_TYPE_UINT8_EXT);
pub const INDEX_TYPE_NONE_NV = @enumToInt(enum_IndexType.INDEX_TYPE_NONE_NV);
pub const INDEX_TYPE_MAX_ENUM = @enumToInt(enum_IndexType.INDEX_TYPE_MAX_ENUM);
pub const enum_IndexType = extern enum(c_int) {
INDEX_TYPE_UINT16 = 0,
INDEX_TYPE_UINT32 = 1,
INDEX_TYPE_NONE_KHR = 1000165000,
INDEX_TYPE_UINT8_EXT = 1000265000,
INDEX_TYPE_NONE_NV = 1000165000,
INDEX_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const IndexType = enum_IndexType;
pub const SUBPASS_CONTENTS_INLINE = @enumToInt(enum_SubpassContents.SUBPASS_CONTENTS_INLINE);
pub const SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = @enumToInt(enum_SubpassContents.SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
pub const SUBPASS_CONTENTS_MAX_ENUM = @enumToInt(enum_SubpassContents.SUBPASS_CONTENTS_MAX_ENUM);
pub const enum_SubpassContents = extern enum(c_int) {
SUBPASS_CONTENTS_INLINE = 0,
SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
SUBPASS_CONTENTS_MAX_ENUM = 2147483647,
_,
};
pub const SubpassContents = enum_SubpassContents;
pub const ACCESS_INDIRECT_COMMAND_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_INDIRECT_COMMAND_READ_BIT);
pub const ACCESS_INDEX_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_INDEX_READ_BIT);
pub const ACCESS_VERTEX_ATTRIBUTE_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_VERTEX_ATTRIBUTE_READ_BIT);
pub const ACCESS_UNIFORM_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_UNIFORM_READ_BIT);
pub const ACCESS_INPUT_ATTACHMENT_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_INPUT_ATTACHMENT_READ_BIT);
pub const ACCESS_SHADER_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_SHADER_READ_BIT);
pub const ACCESS_SHADER_WRITE_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_SHADER_WRITE_BIT);
pub const ACCESS_COLOR_ATTACHMENT_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_COLOR_ATTACHMENT_READ_BIT);
pub const ACCESS_COLOR_ATTACHMENT_WRITE_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT);
pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
pub const ACCESS_TRANSFER_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_TRANSFER_READ_BIT);
pub const ACCESS_TRANSFER_WRITE_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_TRANSFER_WRITE_BIT);
pub const ACCESS_HOST_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_HOST_READ_BIT);
pub const ACCESS_HOST_WRITE_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_HOST_WRITE_BIT);
pub const ACCESS_MEMORY_READ_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_MEMORY_READ_BIT);
pub const ACCESS_MEMORY_WRITE_BIT = @enumToInt(enum_AccessFlagBits.ACCESS_MEMORY_WRITE_BIT);
pub const ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = @enumToInt(enum_AccessFlagBits.ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT);
pub const ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = @enumToInt(enum_AccessFlagBits.ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT);
pub const ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = @enumToInt(enum_AccessFlagBits.ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT);
pub const ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = @enumToInt(enum_AccessFlagBits.ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT);
pub const ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = @enumToInt(enum_AccessFlagBits.ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT);
pub const ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = @enumToInt(enum_AccessFlagBits.ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR);
pub const ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = @enumToInt(enum_AccessFlagBits.ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR);
pub const ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = @enumToInt(enum_AccessFlagBits.ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV);
pub const ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = @enumToInt(enum_AccessFlagBits.ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT);
pub const ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = @enumToInt(enum_AccessFlagBits.ACCESS_COMMAND_PREPROCESS_READ_BIT_NV);
pub const ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = @enumToInt(enum_AccessFlagBits.ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV);
pub const ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = @enumToInt(enum_AccessFlagBits.ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV);
pub const ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = @enumToInt(enum_AccessFlagBits.ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV);
pub const ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = @enumToInt(enum_AccessFlagBits.ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR);
pub const ACCESS_FLAG_BITS_MAX_ENUM = @enumToInt(enum_AccessFlagBits.ACCESS_FLAG_BITS_MAX_ENUM);
pub const enum_AccessFlagBits = extern enum(c_int) {
ACCESS_INDIRECT_COMMAND_READ_BIT = 1,
ACCESS_INDEX_READ_BIT = 2,
ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 4,
ACCESS_UNIFORM_READ_BIT = 8,
ACCESS_INPUT_ATTACHMENT_READ_BIT = 16,
ACCESS_SHADER_READ_BIT = 32,
ACCESS_SHADER_WRITE_BIT = 64,
ACCESS_COLOR_ATTACHMENT_READ_BIT = 128,
ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 256,
ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 512,
ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1024,
ACCESS_TRANSFER_READ_BIT = 2048,
ACCESS_TRANSFER_WRITE_BIT = 4096,
ACCESS_HOST_READ_BIT = 8192,
ACCESS_HOST_WRITE_BIT = 16384,
ACCESS_MEMORY_READ_BIT = 32768,
ACCESS_MEMORY_WRITE_BIT = 65536,
ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 33554432,
ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 67108864,
ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 134217728,
ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 1048576,
ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 524288,
ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 2097152,
ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 4194304,
ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 8388608,
ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 16777216,
ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 131072,
ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 262144,
ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 2097152,
ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 4194304,
ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 8388608,
ACCESS_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const AccessFlagBits = enum_AccessFlagBits;
pub const AccessFlags = Flags;
pub const IMAGE_ASPECT_COLOR_BIT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_COLOR_BIT);
pub const IMAGE_ASPECT_DEPTH_BIT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_DEPTH_BIT);
pub const IMAGE_ASPECT_STENCIL_BIT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_STENCIL_BIT);
pub const IMAGE_ASPECT_METADATA_BIT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_METADATA_BIT);
pub const IMAGE_ASPECT_PLANE_0_BIT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_PLANE_0_BIT);
pub const IMAGE_ASPECT_PLANE_1_BIT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_PLANE_1_BIT);
pub const IMAGE_ASPECT_PLANE_2_BIT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_PLANE_2_BIT);
pub const IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT);
pub const IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT);
pub const IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT);
pub const IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT);
pub const IMAGE_ASPECT_PLANE_0_BIT_KHR = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_PLANE_0_BIT_KHR);
pub const IMAGE_ASPECT_PLANE_1_BIT_KHR = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_PLANE_1_BIT_KHR);
pub const IMAGE_ASPECT_PLANE_2_BIT_KHR = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_PLANE_2_BIT_KHR);
pub const IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ImageAspectFlagBits.IMAGE_ASPECT_FLAG_BITS_MAX_ENUM);
pub const enum_ImageAspectFlagBits = extern enum(c_int) {
IMAGE_ASPECT_COLOR_BIT = 1,
IMAGE_ASPECT_DEPTH_BIT = 2,
IMAGE_ASPECT_STENCIL_BIT = 4,
IMAGE_ASPECT_METADATA_BIT = 8,
IMAGE_ASPECT_PLANE_0_BIT = 16,
IMAGE_ASPECT_PLANE_1_BIT = 32,
IMAGE_ASPECT_PLANE_2_BIT = 64,
IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 128,
IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 256,
IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 512,
IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 1024,
IMAGE_ASPECT_PLANE_0_BIT_KHR = 16,
IMAGE_ASPECT_PLANE_1_BIT_KHR = 32,
IMAGE_ASPECT_PLANE_2_BIT_KHR = 64,
IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ImageAspectFlagBits = enum_ImageAspectFlagBits;
pub const ImageAspectFlags = Flags;
pub const FORMAT_FEATURE_SAMPLED_IMAGE_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_BIT);
pub const FORMAT_FEATURE_STORAGE_IMAGE_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_STORAGE_IMAGE_BIT);
pub const FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT);
pub const FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT);
pub const FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT);
pub const FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT);
pub const FORMAT_FEATURE_VERTEX_BUFFER_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_VERTEX_BUFFER_BIT);
pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT);
pub const FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
pub const FORMAT_FEATURE_BLIT_SRC_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_BLIT_SRC_BIT);
pub const FORMAT_FEATURE_BLIT_DST_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_BLIT_DST_BIT);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT);
pub const FORMAT_FEATURE_TRANSFER_SRC_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_TRANSFER_SRC_BIT);
pub const FORMAT_FEATURE_TRANSFER_DST_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_TRANSFER_DST_BIT);
pub const FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT);
pub const FORMAT_FEATURE_DISJOINT_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_DISJOINT_BIT);
pub const FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG);
pub const FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR);
pub const FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT);
pub const FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR);
pub const FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR);
pub const FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_TRANSFER_DST_BIT_KHR);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT);
pub const FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR);
pub const FORMAT_FEATURE_DISJOINT_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_DISJOINT_BIT_KHR);
pub const FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR);
pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT);
pub const FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_FormatFeatureFlagBits.FORMAT_FEATURE_FLAG_BITS_MAX_ENUM);
pub const enum_FormatFeatureFlagBits = extern enum(c_int) {
FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1,
FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2,
FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 4,
FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 8,
FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 16,
FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 32,
FORMAT_FEATURE_VERTEX_BUFFER_BIT = 64,
FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 128,
FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 256,
FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 512,
FORMAT_FEATURE_BLIT_SRC_BIT = 1024,
FORMAT_FEATURE_BLIT_DST_BIT = 2048,
FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096,
FORMAT_FEATURE_TRANSFER_SRC_BIT = 16384,
FORMAT_FEATURE_TRANSFER_DST_BIT = 32768,
FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 131072,
FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 262144,
FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 524288,
FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 1048576,
FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 2097152,
FORMAT_FEATURE_DISJOINT_BIT = 4194304,
FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 8388608,
FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 65536,
FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 8192,
FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 536870912,
FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 16777216,
FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1073741824,
FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 16384,
FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 32768,
FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 65536,
FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 131072,
FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 262144,
FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 524288,
FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 1048576,
FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 2097152,
FORMAT_FEATURE_DISJOINT_BIT_KHR = 4194304,
FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = 8388608,
FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 8192,
FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const FormatFeatureFlagBits = enum_FormatFeatureFlagBits;
pub const FormatFeatureFlags = Flags;
pub const IMAGE_CREATE_SPARSE_BINDING_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_SPARSE_BINDING_BIT);
pub const IMAGE_CREATE_SPARSE_RESIDENCY_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_SPARSE_RESIDENCY_BIT);
pub const IMAGE_CREATE_SPARSE_ALIASED_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_SPARSE_ALIASED_BIT);
pub const IMAGE_CREATE_MUTABLE_FORMAT_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_MUTABLE_FORMAT_BIT);
pub const IMAGE_CREATE_CUBE_COMPATIBLE_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_CUBE_COMPATIBLE_BIT);
pub const IMAGE_CREATE_ALIAS_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_ALIAS_BIT);
pub const IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT);
pub const IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT);
pub const IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT);
pub const IMAGE_CREATE_EXTENDED_USAGE_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_EXTENDED_USAGE_BIT);
pub const IMAGE_CREATE_PROTECTED_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_PROTECTED_BIT);
pub const IMAGE_CREATE_DISJOINT_BIT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_DISJOINT_BIT);
pub const IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_CORNER_SAMPLED_BIT_NV);
pub const IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT);
pub const IMAGE_CREATE_SUBSAMPLED_BIT_EXT = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_SUBSAMPLED_BIT_EXT);
pub const IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR);
pub const IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR);
pub const IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR);
pub const IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR);
pub const IMAGE_CREATE_DISJOINT_BIT_KHR = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_DISJOINT_BIT_KHR);
pub const IMAGE_CREATE_ALIAS_BIT_KHR = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_ALIAS_BIT_KHR);
pub const IMAGE_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ImageCreateFlagBits.IMAGE_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_ImageCreateFlagBits = extern enum(c_int) {
IMAGE_CREATE_SPARSE_BINDING_BIT = 1,
IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2,
IMAGE_CREATE_SPARSE_ALIASED_BIT = 4,
IMAGE_CREATE_MUTABLE_FORMAT_BIT = 8,
IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 16,
IMAGE_CREATE_ALIAS_BIT = 1024,
IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 64,
IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 32,
IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 128,
IMAGE_CREATE_EXTENDED_USAGE_BIT = 256,
IMAGE_CREATE_PROTECTED_BIT = 2048,
IMAGE_CREATE_DISJOINT_BIT = 512,
IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 8192,
IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 4096,
IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 16384,
IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 64,
IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 32,
IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 128,
IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = 256,
IMAGE_CREATE_DISJOINT_BIT_KHR = 512,
IMAGE_CREATE_ALIAS_BIT_KHR = 1024,
IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ImageCreateFlagBits = enum_ImageCreateFlagBits;
pub const ImageCreateFlags = Flags;
pub const SAMPLE_COUNT_1_BIT = @enumToInt(enum_SampleCountFlagBits.SAMPLE_COUNT_1_BIT);
pub const SAMPLE_COUNT_2_BIT = @enumToInt(enum_SampleCountFlagBits.SAMPLE_COUNT_2_BIT);
pub const SAMPLE_COUNT_4_BIT = @enumToInt(enum_SampleCountFlagBits.SAMPLE_COUNT_4_BIT);
pub const SAMPLE_COUNT_8_BIT = @enumToInt(enum_SampleCountFlagBits.SAMPLE_COUNT_8_BIT);
pub const SAMPLE_COUNT_16_BIT = @enumToInt(enum_SampleCountFlagBits.SAMPLE_COUNT_16_BIT);
pub const SAMPLE_COUNT_32_BIT = @enumToInt(enum_SampleCountFlagBits.SAMPLE_COUNT_32_BIT);
pub const SAMPLE_COUNT_64_BIT = @enumToInt(enum_SampleCountFlagBits.SAMPLE_COUNT_64_BIT);
pub const SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = @enumToInt(enum_SampleCountFlagBits.SAMPLE_COUNT_FLAG_BITS_MAX_ENUM);
pub const enum_SampleCountFlagBits = extern enum(c_int) {
SAMPLE_COUNT_1_BIT = 1,
SAMPLE_COUNT_2_BIT = 2,
SAMPLE_COUNT_4_BIT = 4,
SAMPLE_COUNT_8_BIT = 8,
SAMPLE_COUNT_16_BIT = 16,
SAMPLE_COUNT_32_BIT = 32,
SAMPLE_COUNT_64_BIT = 64,
SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const SampleCountFlagBits = enum_SampleCountFlagBits;
pub const SampleCountFlags = Flags;
pub const IMAGE_USAGE_TRANSFER_SRC_BIT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_TRANSFER_SRC_BIT);
pub const IMAGE_USAGE_TRANSFER_DST_BIT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_TRANSFER_DST_BIT);
pub const IMAGE_USAGE_SAMPLED_BIT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_SAMPLED_BIT);
pub const IMAGE_USAGE_STORAGE_BIT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_STORAGE_BIT);
pub const IMAGE_USAGE_COLOR_ATTACHMENT_BIT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
pub const IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
pub const IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT);
pub const IMAGE_USAGE_INPUT_ATTACHMENT_BIT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
pub const IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV);
pub const IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT);
pub const IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR);
pub const IMAGE_USAGE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ImageUsageFlagBits.IMAGE_USAGE_FLAG_BITS_MAX_ENUM);
pub const enum_ImageUsageFlagBits = extern enum(c_int) {
IMAGE_USAGE_TRANSFER_SRC_BIT = 1,
IMAGE_USAGE_TRANSFER_DST_BIT = 2,
IMAGE_USAGE_SAMPLED_BIT = 4,
IMAGE_USAGE_STORAGE_BIT = 8,
IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 16,
IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 32,
IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 64,
IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128,
IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 256,
IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 512,
IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 256,
IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ImageUsageFlagBits = enum_ImageUsageFlagBits;
pub const ImageUsageFlags = Flags;
pub const InstanceCreateFlags = Flags;
pub const MEMORY_HEAP_DEVICE_LOCAL_BIT = @enumToInt(enum_MemoryHeapFlagBits.MEMORY_HEAP_DEVICE_LOCAL_BIT);
pub const MEMORY_HEAP_MULTI_INSTANCE_BIT = @enumToInt(enum_MemoryHeapFlagBits.MEMORY_HEAP_MULTI_INSTANCE_BIT);
pub const MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = @enumToInt(enum_MemoryHeapFlagBits.MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR);
pub const MEMORY_HEAP_FLAG_BITS_MAX_ENUM = @enumToInt(enum_MemoryHeapFlagBits.MEMORY_HEAP_FLAG_BITS_MAX_ENUM);
pub const enum_MemoryHeapFlagBits = extern enum(c_int) {
MEMORY_HEAP_DEVICE_LOCAL_BIT = 1,
MEMORY_HEAP_MULTI_INSTANCE_BIT = 2,
MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = 2,
MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const MemoryHeapFlagBits = enum_MemoryHeapFlagBits;
pub const MemoryHeapFlags = Flags;
pub const MEMORY_PROPERTY_DEVICE_LOCAL_BIT = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
pub const MEMORY_PROPERTY_HOST_VISIBLE_BIT = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_HOST_VISIBLE_BIT);
pub const MEMORY_PROPERTY_HOST_COHERENT_BIT = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_HOST_COHERENT_BIT);
pub const MEMORY_PROPERTY_HOST_CACHED_BIT = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_HOST_CACHED_BIT);
pub const MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT);
pub const MEMORY_PROPERTY_PROTECTED_BIT = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_PROTECTED_BIT);
pub const MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD);
pub const MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD);
pub const MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = @enumToInt(enum_MemoryPropertyFlagBits.MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM);
pub const enum_MemoryPropertyFlagBits = extern enum(c_int) {
MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1,
MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2,
MEMORY_PROPERTY_HOST_COHERENT_BIT = 4,
MEMORY_PROPERTY_HOST_CACHED_BIT = 8,
MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 16,
MEMORY_PROPERTY_PROTECTED_BIT = 32,
MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 64,
MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 128,
MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const MemoryPropertyFlagBits = enum_MemoryPropertyFlagBits;
pub const MemoryPropertyFlags = Flags;
pub const QUEUE_GRAPHICS_BIT = @enumToInt(enum_QueueFlagBits.QUEUE_GRAPHICS_BIT);
pub const QUEUE_COMPUTE_BIT = @enumToInt(enum_QueueFlagBits.QUEUE_COMPUTE_BIT);
pub const QUEUE_TRANSFER_BIT = @enumToInt(enum_QueueFlagBits.QUEUE_TRANSFER_BIT);
pub const QUEUE_SPARSE_BINDING_BIT = @enumToInt(enum_QueueFlagBits.QUEUE_SPARSE_BINDING_BIT);
pub const QUEUE_PROTECTED_BIT = @enumToInt(enum_QueueFlagBits.QUEUE_PROTECTED_BIT);
pub const QUEUE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_QueueFlagBits.QUEUE_FLAG_BITS_MAX_ENUM);
pub const enum_QueueFlagBits = extern enum(c_int) {
QUEUE_GRAPHICS_BIT = 1,
QUEUE_COMPUTE_BIT = 2,
QUEUE_TRANSFER_BIT = 4,
QUEUE_SPARSE_BINDING_BIT = 8,
QUEUE_PROTECTED_BIT = 16,
QUEUE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const QueueFlagBits = enum_QueueFlagBits;
pub const QueueFlags = Flags;
pub const DeviceCreateFlags = Flags;
pub const DEVICE_QUEUE_CREATE_PROTECTED_BIT = @enumToInt(enum_DeviceQueueCreateFlagBits.DEVICE_QUEUE_CREATE_PROTECTED_BIT);
pub const DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_DeviceQueueCreateFlagBits.DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_DeviceQueueCreateFlagBits = extern enum(c_int) {
DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1,
DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const DeviceQueueCreateFlagBits = enum_DeviceQueueCreateFlagBits;
pub const DeviceQueueCreateFlags = Flags;
pub const PIPELINE_STAGE_TOP_OF_PIPE_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_TOP_OF_PIPE_BIT);
pub const PIPELINE_STAGE_DRAW_INDIRECT_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_DRAW_INDIRECT_BIT);
pub const PIPELINE_STAGE_VERTEX_INPUT_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_VERTEX_INPUT_BIT);
pub const PIPELINE_STAGE_VERTEX_SHADER_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_VERTEX_SHADER_BIT);
pub const PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT);
pub const PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT);
pub const PIPELINE_STAGE_GEOMETRY_SHADER_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_GEOMETRY_SHADER_BIT);
pub const PIPELINE_STAGE_FRAGMENT_SHADER_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
pub const PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT);
pub const PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
pub const PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
pub const PIPELINE_STAGE_COMPUTE_SHADER_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_COMPUTE_SHADER_BIT);
pub const PIPELINE_STAGE_TRANSFER_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_TRANSFER_BIT);
pub const PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
pub const PIPELINE_STAGE_HOST_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_HOST_BIT);
pub const PIPELINE_STAGE_ALL_GRAPHICS_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_ALL_GRAPHICS_BIT);
pub const PIPELINE_STAGE_ALL_COMMANDS_BIT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_ALL_COMMANDS_BIT);
pub const PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT);
pub const PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT);
pub const PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
pub const PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR);
pub const PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV);
pub const PIPELINE_STAGE_TASK_SHADER_BIT_NV = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_TASK_SHADER_BIT_NV);
pub const PIPELINE_STAGE_MESH_SHADER_BIT_NV = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_MESH_SHADER_BIT_NV);
pub const PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT);
pub const PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV);
pub const PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV);
pub const PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV);
pub const PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR);
pub const PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_PipelineStageFlagBits.PIPELINE_STAGE_FLAG_BITS_MAX_ENUM);
pub const enum_PipelineStageFlagBits = extern enum(c_int) {
PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1,
PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2,
PIPELINE_STAGE_VERTEX_INPUT_BIT = 4,
PIPELINE_STAGE_VERTEX_SHADER_BIT = 8,
PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 16,
PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 32,
PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 64,
PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 128,
PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 256,
PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 512,
PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 1024,
PIPELINE_STAGE_COMPUTE_SHADER_BIT = 2048,
PIPELINE_STAGE_TRANSFER_BIT = 4096,
PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 8192,
PIPELINE_STAGE_HOST_BIT = 16384,
PIPELINE_STAGE_ALL_GRAPHICS_BIT = 32768,
PIPELINE_STAGE_ALL_COMMANDS_BIT = 65536,
PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 16777216,
PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 262144,
PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 2097152,
PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 33554432,
PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 4194304,
PIPELINE_STAGE_TASK_SHADER_BIT_NV = 524288,
PIPELINE_STAGE_MESH_SHADER_BIT_NV = 1048576,
PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 8388608,
PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 131072,
PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = 2097152,
PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 33554432,
PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 4194304,
PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const PipelineStageFlagBits = enum_PipelineStageFlagBits;
pub const PipelineStageFlags = Flags;
pub const MemoryMapFlags = Flags;
pub const SPARSE_MEMORY_BIND_METADATA_BIT = @enumToInt(enum_SparseMemoryBindFlagBits.SPARSE_MEMORY_BIND_METADATA_BIT);
pub const SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = @enumToInt(enum_SparseMemoryBindFlagBits.SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM);
pub const enum_SparseMemoryBindFlagBits = extern enum(c_int) {
SPARSE_MEMORY_BIND_METADATA_BIT = 1,
SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const SparseMemoryBindFlagBits = enum_SparseMemoryBindFlagBits;
pub const SparseMemoryBindFlags = Flags;
pub const SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = @enumToInt(enum_SparseImageFormatFlagBits.SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT);
pub const SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = @enumToInt(enum_SparseImageFormatFlagBits.SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT);
pub const SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = @enumToInt(enum_SparseImageFormatFlagBits.SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT);
pub const SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = @enumToInt(enum_SparseImageFormatFlagBits.SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM);
pub const enum_SparseImageFormatFlagBits = extern enum(c_int) {
SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1,
SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2,
SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4,
SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const SparseImageFormatFlagBits = enum_SparseImageFormatFlagBits;
pub const SparseImageFormatFlags = Flags;
pub const FENCE_CREATE_SIGNALED_BIT = @enumToInt(enum_FenceCreateFlagBits.FENCE_CREATE_SIGNALED_BIT);
pub const FENCE_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_FenceCreateFlagBits.FENCE_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_FenceCreateFlagBits = extern enum(c_int) {
FENCE_CREATE_SIGNALED_BIT = 1,
FENCE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const FenceCreateFlagBits = enum_FenceCreateFlagBits;
pub const FenceCreateFlags = Flags;
pub const SemaphoreCreateFlags = Flags;
pub const EventCreateFlags = Flags;
pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT);
pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT);
pub const QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT);
pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT);
pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT);
pub const QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT);
pub const QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT);
pub const QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT);
pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT);
pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT);
pub const QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT);
pub const QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = @enumToInt(enum_QueryPipelineStatisticFlagBits.QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM);
pub const enum_QueryPipelineStatisticFlagBits = extern enum(c_int) {
QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1,
QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2,
QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 4,
QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 8,
QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 16,
QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 32,
QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 64,
QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 128,
QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 256,
QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 512,
QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024,
QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const QueryPipelineStatisticFlagBits = enum_QueryPipelineStatisticFlagBits;
pub const QueryPipelineStatisticFlags = Flags;
pub const QueryPoolCreateFlags = Flags;
pub const QUERY_RESULT_64_BIT = @enumToInt(enum_QueryResultFlagBits.QUERY_RESULT_64_BIT);
pub const QUERY_RESULT_WAIT_BIT = @enumToInt(enum_QueryResultFlagBits.QUERY_RESULT_WAIT_BIT);
pub const QUERY_RESULT_WITH_AVAILABILITY_BIT = @enumToInt(enum_QueryResultFlagBits.QUERY_RESULT_WITH_AVAILABILITY_BIT);
pub const QUERY_RESULT_PARTIAL_BIT = @enumToInt(enum_QueryResultFlagBits.QUERY_RESULT_PARTIAL_BIT);
pub const QUERY_RESULT_FLAG_BITS_MAX_ENUM = @enumToInt(enum_QueryResultFlagBits.QUERY_RESULT_FLAG_BITS_MAX_ENUM);
pub const enum_QueryResultFlagBits = extern enum(c_int) {
QUERY_RESULT_64_BIT = 1,
QUERY_RESULT_WAIT_BIT = 2,
QUERY_RESULT_WITH_AVAILABILITY_BIT = 4,
QUERY_RESULT_PARTIAL_BIT = 8,
QUERY_RESULT_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const QueryResultFlagBits = enum_QueryResultFlagBits;
pub const QueryResultFlags = Flags;
pub const BUFFER_CREATE_SPARSE_BINDING_BIT = @enumToInt(enum_BufferCreateFlagBits.BUFFER_CREATE_SPARSE_BINDING_BIT);
pub const BUFFER_CREATE_SPARSE_RESIDENCY_BIT = @enumToInt(enum_BufferCreateFlagBits.BUFFER_CREATE_SPARSE_RESIDENCY_BIT);
pub const BUFFER_CREATE_SPARSE_ALIASED_BIT = @enumToInt(enum_BufferCreateFlagBits.BUFFER_CREATE_SPARSE_ALIASED_BIT);
pub const BUFFER_CREATE_PROTECTED_BIT = @enumToInt(enum_BufferCreateFlagBits.BUFFER_CREATE_PROTECTED_BIT);
pub const BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = @enumToInt(enum_BufferCreateFlagBits.BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT);
pub const BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = @enumToInt(enum_BufferCreateFlagBits.BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT);
pub const BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = @enumToInt(enum_BufferCreateFlagBits.BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR);
pub const BUFFER_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_BufferCreateFlagBits.BUFFER_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_BufferCreateFlagBits = extern enum(c_int) {
BUFFER_CREATE_SPARSE_BINDING_BIT = 1,
BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2,
BUFFER_CREATE_SPARSE_ALIASED_BIT = 4,
BUFFER_CREATE_PROTECTED_BIT = 8,
BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 16,
BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 16,
BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 16,
BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const BufferCreateFlagBits = enum_BufferCreateFlagBits;
pub const BufferCreateFlags = Flags;
pub const BUFFER_USAGE_TRANSFER_SRC_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_TRANSFER_SRC_BIT);
pub const BUFFER_USAGE_TRANSFER_DST_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_TRANSFER_DST_BIT);
pub const BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT);
pub const BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
pub const BUFFER_USAGE_UNIFORM_BUFFER_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_UNIFORM_BUFFER_BIT);
pub const BUFFER_USAGE_STORAGE_BUFFER_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_STORAGE_BUFFER_BIT);
pub const BUFFER_USAGE_INDEX_BUFFER_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_INDEX_BUFFER_BIT);
pub const BUFFER_USAGE_VERTEX_BUFFER_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_VERTEX_BUFFER_BIT);
pub const BUFFER_USAGE_INDIRECT_BUFFER_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_INDIRECT_BUFFER_BIT);
pub const BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT);
pub const BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT);
pub const BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT);
pub const BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT);
pub const BUFFER_USAGE_RAY_TRACING_BIT_KHR = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_RAY_TRACING_BIT_KHR);
pub const BUFFER_USAGE_RAY_TRACING_BIT_NV = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_RAY_TRACING_BIT_NV);
pub const BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT);
pub const BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR);
pub const BUFFER_USAGE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_BufferUsageFlagBits.BUFFER_USAGE_FLAG_BITS_MAX_ENUM);
pub const enum_BufferUsageFlagBits = extern enum(c_int) {
BUFFER_USAGE_TRANSFER_SRC_BIT = 1,
BUFFER_USAGE_TRANSFER_DST_BIT = 2,
BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 4,
BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 8,
BUFFER_USAGE_UNIFORM_BUFFER_BIT = 16,
BUFFER_USAGE_STORAGE_BUFFER_BIT = 32,
BUFFER_USAGE_INDEX_BUFFER_BIT = 64,
BUFFER_USAGE_VERTEX_BUFFER_BIT = 128,
BUFFER_USAGE_INDIRECT_BUFFER_BIT = 256,
BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 131072,
BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 2048,
BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 4096,
BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 512,
BUFFER_USAGE_RAY_TRACING_BIT_KHR = 1024,
BUFFER_USAGE_RAY_TRACING_BIT_NV = 1024,
BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 131072,
BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = 131072,
BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const BufferUsageFlagBits = enum_BufferUsageFlagBits;
pub const BufferUsageFlags = Flags;
pub const BufferViewCreateFlags = Flags;
pub const IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = @enumToInt(enum_ImageViewCreateFlagBits.IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT);
pub const IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = @enumToInt(enum_ImageViewCreateFlagBits.IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT);
pub const IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ImageViewCreateFlagBits.IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_ImageViewCreateFlagBits = extern enum(c_int) {
IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 1,
IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 2,
IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ImageViewCreateFlagBits = enum_ImageViewCreateFlagBits;
pub const ImageViewCreateFlags = Flags;
pub const SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ShaderModuleCreateFlagBits.SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_ShaderModuleCreateFlagBits = extern enum(c_int) {
SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ShaderModuleCreateFlagBits = enum_ShaderModuleCreateFlagBits;
pub const ShaderModuleCreateFlags = Flags;
pub const PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = @enumToInt(enum_PipelineCacheCreateFlagBits.PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT);
pub const PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_PipelineCacheCreateFlagBits.PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_PipelineCacheCreateFlagBits = extern enum(c_int) {
PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = 1,
PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const PipelineCacheCreateFlagBits = enum_PipelineCacheCreateFlagBits;
pub const PipelineCacheCreateFlags = Flags;
pub const COLOR_COMPONENT_R_BIT = @enumToInt(enum_ColorComponentFlagBits.COLOR_COMPONENT_R_BIT);
pub const COLOR_COMPONENT_G_BIT = @enumToInt(enum_ColorComponentFlagBits.COLOR_COMPONENT_G_BIT);
pub const COLOR_COMPONENT_B_BIT = @enumToInt(enum_ColorComponentFlagBits.COLOR_COMPONENT_B_BIT);
pub const COLOR_COMPONENT_A_BIT = @enumToInt(enum_ColorComponentFlagBits.COLOR_COMPONENT_A_BIT);
pub const COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ColorComponentFlagBits.COLOR_COMPONENT_FLAG_BITS_MAX_ENUM);
pub const enum_ColorComponentFlagBits = extern enum(c_int) {
COLOR_COMPONENT_R_BIT = 1,
COLOR_COMPONENT_G_BIT = 2,
COLOR_COMPONENT_B_BIT = 4,
COLOR_COMPONENT_A_BIT = 8,
COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ColorComponentFlagBits = enum_ColorComponentFlagBits;
pub const ColorComponentFlags = Flags;
pub const PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT);
pub const PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT);
pub const PIPELINE_CREATE_DERIVATIVE_BIT = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_DERIVATIVE_BIT);
pub const PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT);
pub const PIPELINE_CREATE_DISPATCH_BASE_BIT = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_DISPATCH_BASE_BIT);
pub const PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR);
pub const PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR);
pub const PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR);
pub const PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR);
pub const PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR);
pub const PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR);
pub const PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_DEFER_COMPILE_BIT_NV);
pub const PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR);
pub const PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
pub const PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV);
pub const PIPELINE_CREATE_LIBRARY_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_LIBRARY_BIT_KHR);
pub const PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT);
pub const PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT);
pub const PIPELINE_CREATE_DISPATCH_BASE = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_DISPATCH_BASE);
pub const PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR);
pub const PIPELINE_CREATE_DISPATCH_BASE_KHR = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_DISPATCH_BASE_KHR);
pub const PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_PipelineCreateFlagBits.PIPELINE_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_PipelineCreateFlagBits = extern enum(c_int) {
PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1,
PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2,
PIPELINE_CREATE_DERIVATIVE_BIT = 4,
PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 8,
PIPELINE_CREATE_DISPATCH_BASE_BIT = 16,
PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 16384,
PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 32768,
PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 65536,
PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 131072,
PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 4096,
PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 8192,
PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 32,
PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 64,
PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 128,
PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 262144,
PIPELINE_CREATE_LIBRARY_BIT_KHR = 2048,
PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = 256,
PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = 512,
PIPELINE_CREATE_DISPATCH_BASE = 16,
PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 8,
PIPELINE_CREATE_DISPATCH_BASE_KHR = 16,
PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const PipelineCreateFlagBits = enum_PipelineCreateFlagBits;
pub const PipelineCreateFlags = Flags;
pub const PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = @enumToInt(enum_PipelineShaderStageCreateFlagBits.PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT);
pub const PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = @enumToInt(enum_PipelineShaderStageCreateFlagBits.PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT);
pub const PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_PipelineShaderStageCreateFlagBits.PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_PipelineShaderStageCreateFlagBits = extern enum(c_int) {
PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 1,
PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 2,
PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const PipelineShaderStageCreateFlagBits = enum_PipelineShaderStageCreateFlagBits;
pub const PipelineShaderStageCreateFlags = Flags;
pub const SHADER_STAGE_VERTEX_BIT = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_VERTEX_BIT);
pub const SHADER_STAGE_TESSELLATION_CONTROL_BIT = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_TESSELLATION_CONTROL_BIT);
pub const SHADER_STAGE_TESSELLATION_EVALUATION_BIT = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
pub const SHADER_STAGE_GEOMETRY_BIT = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_GEOMETRY_BIT);
pub const SHADER_STAGE_FRAGMENT_BIT = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_FRAGMENT_BIT);
pub const SHADER_STAGE_COMPUTE_BIT = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_COMPUTE_BIT);
pub const SHADER_STAGE_ALL_GRAPHICS = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_ALL_GRAPHICS);
pub const SHADER_STAGE_ALL = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_ALL);
pub const SHADER_STAGE_RAYGEN_BIT_KHR = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_RAYGEN_BIT_KHR);
pub const SHADER_STAGE_ANY_HIT_BIT_KHR = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_ANY_HIT_BIT_KHR);
pub const SHADER_STAGE_CLOSEST_HIT_BIT_KHR = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_CLOSEST_HIT_BIT_KHR);
pub const SHADER_STAGE_MISS_BIT_KHR = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_MISS_BIT_KHR);
pub const SHADER_STAGE_INTERSECTION_BIT_KHR = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_INTERSECTION_BIT_KHR);
pub const SHADER_STAGE_CALLABLE_BIT_KHR = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_CALLABLE_BIT_KHR);
pub const SHADER_STAGE_TASK_BIT_NV = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_TASK_BIT_NV);
pub const SHADER_STAGE_MESH_BIT_NV = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_MESH_BIT_NV);
pub const SHADER_STAGE_RAYGEN_BIT_NV = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_RAYGEN_BIT_NV);
pub const SHADER_STAGE_ANY_HIT_BIT_NV = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_ANY_HIT_BIT_NV);
pub const SHADER_STAGE_CLOSEST_HIT_BIT_NV = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_CLOSEST_HIT_BIT_NV);
pub const SHADER_STAGE_MISS_BIT_NV = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_MISS_BIT_NV);
pub const SHADER_STAGE_INTERSECTION_BIT_NV = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_INTERSECTION_BIT_NV);
pub const SHADER_STAGE_CALLABLE_BIT_NV = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_CALLABLE_BIT_NV);
pub const SHADER_STAGE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ShaderStageFlagBits.SHADER_STAGE_FLAG_BITS_MAX_ENUM);
pub const enum_ShaderStageFlagBits = extern enum(c_int) {
SHADER_STAGE_VERTEX_BIT = 1,
SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2,
SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 4,
SHADER_STAGE_GEOMETRY_BIT = 8,
SHADER_STAGE_FRAGMENT_BIT = 16,
SHADER_STAGE_COMPUTE_BIT = 32,
SHADER_STAGE_ALL_GRAPHICS = 31,
SHADER_STAGE_ALL = 2147483647,
SHADER_STAGE_RAYGEN_BIT_KHR = 256,
SHADER_STAGE_ANY_HIT_BIT_KHR = 512,
SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 1024,
SHADER_STAGE_MISS_BIT_KHR = 2048,
SHADER_STAGE_INTERSECTION_BIT_KHR = 4096,
SHADER_STAGE_CALLABLE_BIT_KHR = 8192,
SHADER_STAGE_TASK_BIT_NV = 64,
SHADER_STAGE_MESH_BIT_NV = 128,
SHADER_STAGE_RAYGEN_BIT_NV = 256,
SHADER_STAGE_ANY_HIT_BIT_NV = 512,
SHADER_STAGE_CLOSEST_HIT_BIT_NV = 1024,
SHADER_STAGE_MISS_BIT_NV = 2048,
SHADER_STAGE_INTERSECTION_BIT_NV = 4096,
SHADER_STAGE_CALLABLE_BIT_NV = 8192,
SHADER_STAGE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ShaderStageFlagBits = enum_ShaderStageFlagBits;
pub const CULL_MODE_NONE = @enumToInt(enum_CullModeFlagBits.CULL_MODE_NONE);
pub const CULL_MODE_FRONT_BIT = @enumToInt(enum_CullModeFlagBits.CULL_MODE_FRONT_BIT);
pub const CULL_MODE_BACK_BIT = @enumToInt(enum_CullModeFlagBits.CULL_MODE_BACK_BIT);
pub const CULL_MODE_FRONT_AND_BACK = @enumToInt(enum_CullModeFlagBits.CULL_MODE_FRONT_AND_BACK);
pub const CULL_MODE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_CullModeFlagBits.CULL_MODE_FLAG_BITS_MAX_ENUM);
pub const enum_CullModeFlagBits = extern enum(c_int) {
CULL_MODE_NONE = 0,
CULL_MODE_FRONT_BIT = 1,
CULL_MODE_BACK_BIT = 2,
CULL_MODE_FRONT_AND_BACK = 3,
CULL_MODE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const CullModeFlagBits = enum_CullModeFlagBits;
pub const CullModeFlags = Flags;
pub const PipelineVertexInputStateCreateFlags = Flags;
pub const PipelineInputAssemblyStateCreateFlags = Flags;
pub const PipelineTessellationStateCreateFlags = Flags;
pub const PipelineViewportStateCreateFlags = Flags;
pub const PipelineRasterizationStateCreateFlags = Flags;
pub const PipelineMultisampleStateCreateFlags = Flags;
pub const PipelineDepthStencilStateCreateFlags = Flags;
pub const PipelineColorBlendStateCreateFlags = Flags;
pub const PipelineDynamicStateCreateFlags = Flags;
pub const PipelineLayoutCreateFlags = Flags;
pub const ShaderStageFlags = Flags;
pub const SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = @enumToInt(enum_SamplerCreateFlagBits.SAMPLER_CREATE_SUBSAMPLED_BIT_EXT);
pub const SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = @enumToInt(enum_SamplerCreateFlagBits.SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT);
pub const SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_SamplerCreateFlagBits.SAMPLER_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_SamplerCreateFlagBits = extern enum(c_int) {
SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 1,
SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 2,
SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const SamplerCreateFlagBits = enum_SamplerCreateFlagBits;
pub const SamplerCreateFlags = Flags;
pub const DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = @enumToInt(enum_DescriptorPoolCreateFlagBits.DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT);
pub const DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = @enumToInt(enum_DescriptorPoolCreateFlagBits.DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT);
pub const DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = @enumToInt(enum_DescriptorPoolCreateFlagBits.DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT);
pub const DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_DescriptorPoolCreateFlagBits.DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_DescriptorPoolCreateFlagBits = extern enum(c_int) {
DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1,
DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 2,
DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 2,
DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const DescriptorPoolCreateFlagBits = enum_DescriptorPoolCreateFlagBits;
pub const DescriptorPoolCreateFlags = Flags;
pub const DescriptorPoolResetFlags = Flags;
pub const DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = @enumToInt(enum_DescriptorSetLayoutCreateFlagBits.DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT);
pub const DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = @enumToInt(enum_DescriptorSetLayoutCreateFlagBits.DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
pub const DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = @enumToInt(enum_DescriptorSetLayoutCreateFlagBits.DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT);
pub const DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_DescriptorSetLayoutCreateFlagBits.DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_DescriptorSetLayoutCreateFlagBits = extern enum(c_int) {
DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 2,
DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 1,
DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 2,
DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const DescriptorSetLayoutCreateFlagBits = enum_DescriptorSetLayoutCreateFlagBits;
pub const DescriptorSetLayoutCreateFlags = Flags;
pub const ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = @enumToInt(enum_AttachmentDescriptionFlagBits.ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT);
pub const ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = @enumToInt(enum_AttachmentDescriptionFlagBits.ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM);
pub const enum_AttachmentDescriptionFlagBits = extern enum(c_int) {
ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1,
ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const AttachmentDescriptionFlagBits = enum_AttachmentDescriptionFlagBits;
pub const AttachmentDescriptionFlags = Flags;
pub const DEPENDENCY_BY_REGION_BIT = @enumToInt(enum_DependencyFlagBits.DEPENDENCY_BY_REGION_BIT);
pub const DEPENDENCY_DEVICE_GROUP_BIT = @enumToInt(enum_DependencyFlagBits.DEPENDENCY_DEVICE_GROUP_BIT);
pub const DEPENDENCY_VIEW_LOCAL_BIT = @enumToInt(enum_DependencyFlagBits.DEPENDENCY_VIEW_LOCAL_BIT);
pub const DEPENDENCY_VIEW_LOCAL_BIT_KHR = @enumToInt(enum_DependencyFlagBits.DEPENDENCY_VIEW_LOCAL_BIT_KHR);
pub const DEPENDENCY_DEVICE_GROUP_BIT_KHR = @enumToInt(enum_DependencyFlagBits.DEPENDENCY_DEVICE_GROUP_BIT_KHR);
pub const DEPENDENCY_FLAG_BITS_MAX_ENUM = @enumToInt(enum_DependencyFlagBits.DEPENDENCY_FLAG_BITS_MAX_ENUM);
pub const enum_DependencyFlagBits = extern enum(c_int) {
DEPENDENCY_BY_REGION_BIT = 1,
DEPENDENCY_DEVICE_GROUP_BIT = 4,
DEPENDENCY_VIEW_LOCAL_BIT = 2,
DEPENDENCY_VIEW_LOCAL_BIT_KHR = 2,
DEPENDENCY_DEVICE_GROUP_BIT_KHR = 4,
DEPENDENCY_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const DependencyFlagBits = enum_DependencyFlagBits;
pub const DependencyFlags = Flags;
pub const FRAMEBUFFER_CREATE_IMAGELESS_BIT = @enumToInt(enum_FramebufferCreateFlagBits.FRAMEBUFFER_CREATE_IMAGELESS_BIT);
pub const FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = @enumToInt(enum_FramebufferCreateFlagBits.FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR);
pub const FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_FramebufferCreateFlagBits.FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_FramebufferCreateFlagBits = extern enum(c_int) {
FRAMEBUFFER_CREATE_IMAGELESS_BIT = 1,
FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = 1,
FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const FramebufferCreateFlagBits = enum_FramebufferCreateFlagBits;
pub const FramebufferCreateFlags = Flags;
pub const RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = @enumToInt(enum_RenderPassCreateFlagBits.RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM);
pub const RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_RenderPassCreateFlagBits.RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_RenderPassCreateFlagBits = extern enum(c_int) {
RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 2,
RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const RenderPassCreateFlagBits = enum_RenderPassCreateFlagBits;
pub const RenderPassCreateFlags = Flags;
pub const SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = @enumToInt(enum_SubpassDescriptionFlagBits.SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX);
pub const SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = @enumToInt(enum_SubpassDescriptionFlagBits.SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX);
pub const SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = @enumToInt(enum_SubpassDescriptionFlagBits.SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM);
pub const SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = @enumToInt(enum_SubpassDescriptionFlagBits.SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM);
pub const SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = @enumToInt(enum_SubpassDescriptionFlagBits.SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM);
pub const enum_SubpassDescriptionFlagBits = extern enum(c_int) {
SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 1,
SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 2,
SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 4,
SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 8,
SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const SubpassDescriptionFlagBits = enum_SubpassDescriptionFlagBits;
pub const SubpassDescriptionFlags = Flags;
pub const COMMAND_POOL_CREATE_TRANSIENT_BIT = @enumToInt(enum_CommandPoolCreateFlagBits.COMMAND_POOL_CREATE_TRANSIENT_BIT);
pub const COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = @enumToInt(enum_CommandPoolCreateFlagBits.COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
pub const COMMAND_POOL_CREATE_PROTECTED_BIT = @enumToInt(enum_CommandPoolCreateFlagBits.COMMAND_POOL_CREATE_PROTECTED_BIT);
pub const COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_CommandPoolCreateFlagBits.COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM);
pub const enum_CommandPoolCreateFlagBits = extern enum(c_int) {
COMMAND_POOL_CREATE_TRANSIENT_BIT = 1,
COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2,
COMMAND_POOL_CREATE_PROTECTED_BIT = 4,
COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const CommandPoolCreateFlagBits = enum_CommandPoolCreateFlagBits;
pub const CommandPoolCreateFlags = Flags;
pub const COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = @enumToInt(enum_CommandPoolResetFlagBits.COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT);
pub const COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = @enumToInt(enum_CommandPoolResetFlagBits.COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM);
pub const enum_CommandPoolResetFlagBits = extern enum(c_int) {
COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1,
COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const CommandPoolResetFlagBits = enum_CommandPoolResetFlagBits;
pub const CommandPoolResetFlags = Flags;
pub const COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = @enumToInt(enum_CommandBufferUsageFlagBits.COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
pub const COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = @enumToInt(enum_CommandBufferUsageFlagBits.COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
pub const COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = @enumToInt(enum_CommandBufferUsageFlagBits.COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
pub const COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_CommandBufferUsageFlagBits.COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM);
pub const enum_CommandBufferUsageFlagBits = extern enum(c_int) {
COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1,
COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2,
COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4,
COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const CommandBufferUsageFlagBits = enum_CommandBufferUsageFlagBits;
pub const CommandBufferUsageFlags = Flags;
pub const QUERY_CONTROL_PRECISE_BIT = @enumToInt(enum_QueryControlFlagBits.QUERY_CONTROL_PRECISE_BIT);
pub const QUERY_CONTROL_FLAG_BITS_MAX_ENUM = @enumToInt(enum_QueryControlFlagBits.QUERY_CONTROL_FLAG_BITS_MAX_ENUM);
pub const enum_QueryControlFlagBits = extern enum(c_int) {
QUERY_CONTROL_PRECISE_BIT = 1,
QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const QueryControlFlagBits = enum_QueryControlFlagBits;
pub const QueryControlFlags = Flags;
pub const COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = @enumToInt(enum_CommandBufferResetFlagBits.COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
pub const COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = @enumToInt(enum_CommandBufferResetFlagBits.COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM);
pub const enum_CommandBufferResetFlagBits = extern enum(c_int) {
COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1,
COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const CommandBufferResetFlagBits = enum_CommandBufferResetFlagBits;
pub const CommandBufferResetFlags = Flags;
pub const STENCIL_FACE_FRONT_BIT = @enumToInt(enum_StencilFaceFlagBits.STENCIL_FACE_FRONT_BIT);
pub const STENCIL_FACE_BACK_BIT = @enumToInt(enum_StencilFaceFlagBits.STENCIL_FACE_BACK_BIT);
pub const STENCIL_FACE_FRONT_AND_BACK = @enumToInt(enum_StencilFaceFlagBits.STENCIL_FACE_FRONT_AND_BACK);
pub const STENCIL_FRONT_AND_BACK = @enumToInt(enum_StencilFaceFlagBits.STENCIL_FRONT_AND_BACK);
pub const STENCIL_FACE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_StencilFaceFlagBits.STENCIL_FACE_FLAG_BITS_MAX_ENUM);
pub const enum_StencilFaceFlagBits = extern enum(c_int) {
STENCIL_FACE_FRONT_BIT = 1,
STENCIL_FACE_BACK_BIT = 2,
STENCIL_FACE_FRONT_AND_BACK = 3,
STENCIL_FRONT_AND_BACK = 3,
STENCIL_FACE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const StencilFaceFlagBits = enum_StencilFaceFlagBits;
pub const StencilFaceFlags = Flags;
pub const struct_Extent2D = extern struct {
width: u32,
height: u32,
};
pub const Extent2D = struct_Extent2D;
pub const struct_Extent3D = extern struct {
width: u32,
height: u32,
depth: u32,
};
pub const Extent3D = struct_Extent3D;
pub const struct_Offset2D = extern struct {
x: i32 = 0,
y: i32 = 0,
};
pub const Offset2D = struct_Offset2D;
pub const struct_Offset3D = extern struct {
x: i32 = 0,
y: i32 = 0,
z: i32 = 0,
};
pub const Offset3D = struct_Offset3D;
pub const struct_Rect2D = extern struct {
offset: Offset2D = Offset2D{},
extent: Extent2D,
};
pub const Rect2D = struct_Rect2D;
pub const struct_BaseInStructure = extern struct {
sType: StructureType,
pNext: [*c]const struct_BaseInStructure,
};
pub const BaseInStructure = struct_BaseInStructure;
pub const struct_BaseOutStructure = extern struct {
sType: StructureType,
pNext: [*c]struct_BaseOutStructure,
};
pub const BaseOutStructure = struct_BaseOutStructure;
pub const struct_BufferMemoryBarrier = extern struct {
sType: StructureType = .BUFFER_MEMORY_BARRIER,
pNext: ?*const c_void = null,
srcAccessMask: AccessFlags,
dstAccessMask: AccessFlags,
srcQueueFamilyIndex: u32,
dstQueueFamilyIndex: u32,
buffer: Buffer,
offset: DeviceSize,
size: DeviceSize,
};
pub const BufferMemoryBarrier = struct_BufferMemoryBarrier;
pub const struct_DispatchIndirectCommand = extern struct {
x: u32,
y: u32,
z: u32,
};
pub const DispatchIndirectCommand = struct_DispatchIndirectCommand;
pub const struct_DrawIndexedIndirectCommand = extern struct {
indexCount: u32,
instanceCount: u32,
firstIndex: u32,
vertexOffset: i32,
firstInstance: u32,
};
pub const DrawIndexedIndirectCommand = struct_DrawIndexedIndirectCommand;
pub const struct_DrawIndirectCommand = extern struct {
vertexCount: u32,
instanceCount: u32,
firstVertex: u32,
firstInstance: u32,
};
pub const DrawIndirectCommand = struct_DrawIndirectCommand;
pub const struct_ImageSubresourceRange = extern struct {
aspectMask: ImageAspectFlags,
baseMipLevel: u32,
levelCount: u32,
baseArrayLayer: u32,
layerCount: u32,
};
pub const ImageSubresourceRange = struct_ImageSubresourceRange;
pub const struct_ImageMemoryBarrier = extern struct {
sType: StructureType = .IMAGE_MEMORY_BARRIER,
pNext: ?*const c_void = null,
srcAccessMask: AccessFlags,
dstAccessMask: AccessFlags,
oldLayout: ImageLayout,
newLayout: ImageLayout,
srcQueueFamilyIndex: u32,
dstQueueFamilyIndex: u32,
image: Image,
subresourceRange: ImageSubresourceRange,
};
pub const ImageMemoryBarrier = struct_ImageMemoryBarrier;
pub const struct_MemoryBarrier = extern struct {
sType: StructureType = .MEMORY_BARRIER,
pNext: ?*const c_void = null,
srcAccessMask: AccessFlags,
dstAccessMask: AccessFlags,
};
pub const MemoryBarrier = struct_MemoryBarrier;
pub const PFN_vkAllocationFunction = ?fn (?*c_void, usize, usize, SystemAllocationScope) callconv(.C) ?*c_void;
pub const PFN_vkFreeFunction = ?fn (?*c_void, ?*c_void) callconv(.C) void;
pub const PFN_vkInternalAllocationNotification = ?fn (?*c_void, usize, InternalAllocationType, SystemAllocationScope) callconv(.C) void;
pub const PFN_vkInternalFreeNotification = ?fn (?*c_void, usize, InternalAllocationType, SystemAllocationScope) callconv(.C) void;
pub const PFN_vkReallocationFunction = ?fn (?*c_void, ?*c_void, usize, usize, SystemAllocationScope) callconv(.C) ?*c_void;
pub const PFN_vkVoidFunction = ?fn () callconv(.C) void;
pub const struct_AllocationCallbacks = extern struct {
pUserData: ?*c_void,
pfnAllocation: PFN_vkAllocationFunction,
pfnReallocation: PFN_vkReallocationFunction,
pfnFree: PFN_vkFreeFunction,
pfnInternalAllocation: PFN_vkInternalAllocationNotification,
pfnInternalFree: PFN_vkInternalFreeNotification,
};
pub const AllocationCallbacks = struct_AllocationCallbacks;
pub const struct_ApplicationInfo = extern struct {
sType: StructureType = .APPLICATION_INFO,
pNext: ?*const c_void = null,
pApplicationName: [*c]const u8,
applicationVersion: u32,
pEngineName: [*c]const u8,
engineVersion: u32,
apiVersion: u32,
};
pub const ApplicationInfo = struct_ApplicationInfo;
pub const struct_FormatProperties = extern struct {
linearTilingFeatures: FormatFeatureFlags,
optimalTilingFeatures: FormatFeatureFlags,
bufferFeatures: FormatFeatureFlags,
};
pub const FormatProperties = struct_FormatProperties;
pub const struct_ImageFormatProperties = extern struct {
maxExtent: Extent3D,
maxMipLevels: u32,
maxArrayLayers: u32,
sampleCounts: SampleCountFlags,
maxResourceSize: DeviceSize,
};
pub const ImageFormatProperties = struct_ImageFormatProperties;
pub const struct_InstanceCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: InstanceCreateFlags,
pApplicationInfo: [*c]const ApplicationInfo,
enabledLayerCount: u32,
ppEnabledLayerNames: [*c]const [*c]const u8,
enabledExtensionCount: u32,
ppEnabledExtensionNames: [*c]const [*c]const u8,
};
pub const InstanceCreateInfo = struct_InstanceCreateInfo;
pub const struct_MemoryHeap = extern struct {
size: DeviceSize,
flags: MemoryHeapFlags,
};
pub const MemoryHeap = struct_MemoryHeap;
pub const struct_MemoryType = extern struct {
propertyFlags: MemoryPropertyFlags,
heapIndex: u32,
};
pub const MemoryType = struct_MemoryType;
pub const struct_PhysicalDeviceFeatures = extern struct {
robustBufferAccess: Bool32,
fullDrawIndexUint32: Bool32,
imageCubeArray: Bool32,
independentBlend: Bool32,
geometryShader: Bool32,
tessellationShader: Bool32,
sampleRateShading: Bool32,
dualSrcBlend: Bool32,
logicOp: Bool32,
multiDrawIndirect: Bool32,
drawIndirectFirstInstance: Bool32,
depthClamp: Bool32,
depthBiasClamp: Bool32,
fillModeNonSolid: Bool32,
depthBounds: Bool32,
wideLines: Bool32,
largePoints: Bool32,
alphaToOne: Bool32,
multiViewport: Bool32,
samplerAnisotropy: Bool32,
textureCompressionETC2: Bool32,
textureCompressionASTC_LDR: Bool32,
textureCompressionBC: Bool32,
occlusionQueryPrecise: Bool32,
pipelineStatisticsQuery: Bool32,
vertexPipelineStoresAndAtomics: Bool32,
fragmentStoresAndAtomics: Bool32,
shaderTessellationAndGeometryPointSize: Bool32,
shaderImageGatherExtended: Bool32,
shaderStorageImageExtendedFormats: Bool32,
shaderStorageImageMultisample: Bool32,
shaderStorageImageReadWithoutFormat: Bool32,
shaderStorageImageWriteWithoutFormat: Bool32,
shaderUniformBufferArrayDynamicIndexing: Bool32,
shaderSampledImageArrayDynamicIndexing: Bool32,
shaderStorageBufferArrayDynamicIndexing: Bool32,
shaderStorageImageArrayDynamicIndexing: Bool32,
shaderClipDistance: Bool32,
shaderCullDistance: Bool32,
shaderFloat64: Bool32,
shaderInt64: Bool32,
shaderInt16: Bool32,
shaderResourceResidency: Bool32,
shaderResourceMinLod: Bool32,
sparseBinding: Bool32,
sparseResidencyBuffer: Bool32,
sparseResidencyImage2D: Bool32,
sparseResidencyImage3D: Bool32,
sparseResidency2Samples: Bool32,
sparseResidency4Samples: Bool32,
sparseResidency8Samples: Bool32,
sparseResidency16Samples: Bool32,
sparseResidencyAliased: Bool32,
variableMultisampleRate: Bool32,
inheritedQueries: Bool32,
};
pub const PhysicalDeviceFeatures = struct_PhysicalDeviceFeatures;
pub const struct_PhysicalDeviceLimits = extern struct {
maxImageDimension1D: u32,
maxImageDimension2D: u32,
maxImageDimension3D: u32,
maxImageDimensionCube: u32,
maxImageArrayLayers: u32,
maxTexelBufferElements: u32,
maxUniformBufferRange: u32,
maxStorageBufferRange: u32,
maxPushConstantsSize: u32,
maxMemoryAllocationCount: u32,
maxSamplerAllocationCount: u32,
bufferImageGranularity: DeviceSize,
sparseAddressSpaceSize: DeviceSize,
maxBoundDescriptorSets: u32,
maxPerStageDescriptorSamplers: u32,
maxPerStageDescriptorUniformBuffers: u32,
maxPerStageDescriptorStorageBuffers: u32,
maxPerStageDescriptorSampledImages: u32,
maxPerStageDescriptorStorageImages: u32,
maxPerStageDescriptorInputAttachments: u32,
maxPerStageResources: u32,
maxDescriptorSetSamplers: u32,
maxDescriptorSetUniformBuffers: u32,
maxDescriptorSetUniformBuffersDynamic: u32,
maxDescriptorSetStorageBuffers: u32,
maxDescriptorSetStorageBuffersDynamic: u32,
maxDescriptorSetSampledImages: u32,
maxDescriptorSetStorageImages: u32,
maxDescriptorSetInputAttachments: u32,
maxVertexInputAttributes: u32,
maxVertexInputBindings: u32,
maxVertexInputAttributeOffset: u32,
maxVertexInputBindingStride: u32,
maxVertexOutputComponents: u32,
maxTessellationGenerationLevel: u32,
maxTessellationPatchSize: u32,
maxTessellationControlPerVertexInputComponents: u32,
maxTessellationControlPerVertexOutputComponents: u32,
maxTessellationControlPerPatchOutputComponents: u32,
maxTessellationControlTotalOutputComponents: u32,
maxTessellationEvaluationInputComponents: u32,
maxTessellationEvaluationOutputComponents: u32,
maxGeometryShaderInvocations: u32,
maxGeometryInputComponents: u32,
maxGeometryOutputComponents: u32,
maxGeometryOutputVertices: u32,
maxGeometryTotalOutputComponents: u32,
maxFragmentInputComponents: u32,
maxFragmentOutputAttachments: u32,
maxFragmentDualSrcAttachments: u32,
maxFragmentCombinedOutputResources: u32,
maxComputeSharedMemorySize: u32,
maxComputeWorkGroupCount: [3]u32,
maxComputeWorkGroupInvocations: u32,
maxComputeWorkGroupSize: [3]u32,
subPixelPrecisionBits: u32,
subTexelPrecisionBits: u32,
mipmapPrecisionBits: u32,
maxDrawIndexedIndexValue: u32,
maxDrawIndirectCount: u32,
maxSamplerLodBias: f32,
maxSamplerAnisotropy: f32,
maxViewports: u32,
maxViewportDimensions: [2]u32,
viewportBoundsRange: [2]f32,
viewportSubPixelBits: u32,
minMemoryMapAlignment: usize,
minTexelBufferOffsetAlignment: DeviceSize,
minUniformBufferOffsetAlignment: DeviceSize,
minStorageBufferOffsetAlignment: DeviceSize,
minTexelOffset: i32,
maxTexelOffset: u32,
minTexelGatherOffset: i32,
maxTexelGatherOffset: u32,
minInterpolationOffset: f32,
maxInterpolationOffset: f32,
subPixelInterpolationOffsetBits: u32,
maxFramebufferWidth: u32,
maxFramebufferHeight: u32,
maxFramebufferLayers: u32,
framebufferColorSampleCounts: SampleCountFlags,
framebufferDepthSampleCounts: SampleCountFlags,
framebufferStencilSampleCounts: SampleCountFlags,
framebufferNoAttachmentsSampleCounts: SampleCountFlags,
maxColorAttachments: u32,
sampledImageColorSampleCounts: SampleCountFlags,
sampledImageIntegerSampleCounts: SampleCountFlags,
sampledImageDepthSampleCounts: SampleCountFlags,
sampledImageStencilSampleCounts: SampleCountFlags,
storageImageSampleCounts: SampleCountFlags,
maxSampleMaskWords: u32,
timestampComputeAndGraphics: Bool32,
timestampPeriod: f32,
maxClipDistances: u32,
maxCullDistances: u32,
maxCombinedClipAndCullDistances: u32,
discreteQueuePriorities: u32,
pointSizeRange: [2]f32,
lineWidthRange: [2]f32,
pointSizeGranularity: f32,
lineWidthGranularity: f32,
strictLines: Bool32,
standardSampleLocations: Bool32,
optimalBufferCopyOffsetAlignment: DeviceSize,
optimalBufferCopyRowPitchAlignment: DeviceSize,
nonCoherentAtomSize: DeviceSize,
};
pub const PhysicalDeviceLimits = struct_PhysicalDeviceLimits;
pub const struct_PhysicalDeviceMemoryProperties = extern struct {
memoryTypeCount: u32,
memoryTypes: [32]MemoryType,
memoryHeapCount: u32,
memoryHeaps: [16]MemoryHeap,
};
pub const PhysicalDeviceMemoryProperties = struct_PhysicalDeviceMemoryProperties;
pub const struct_PhysicalDeviceSparseProperties = extern struct {
residencyStandard2DBlockShape: Bool32,
residencyStandard2DMultisampleBlockShape: Bool32,
residencyStandard3DBlockShape: Bool32,
residencyAlignedMipSize: Bool32,
residencyNonResidentStrict: Bool32,
};
pub const PhysicalDeviceSparseProperties = struct_PhysicalDeviceSparseProperties;
pub const struct_PhysicalDeviceProperties = extern struct {
apiVersion: u32,
driverVersion: u32,
vendorID: u32,
deviceID: u32,
deviceType: PhysicalDeviceType,
deviceName: [256]u8,
pipelineCacheUUID: [16]u8,
limits: PhysicalDeviceLimits,
sparseProperties: PhysicalDeviceSparseProperties,
};
pub const PhysicalDeviceProperties = struct_PhysicalDeviceProperties;
pub const struct_QueueFamilyProperties = extern struct {
queueFlags: QueueFlags,
queueCount: u32,
timestampValidBits: u32,
minImageTransferGranularity: Extent3D,
};
pub const QueueFamilyProperties = struct_QueueFamilyProperties;
pub const struct_DeviceQueueCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DeviceQueueCreateFlags,
queueFamilyIndex: u32,
queueCount: u32,
pQueuePriorities: [*c]const f32,
};
pub const DeviceQueueCreateInfo = struct_DeviceQueueCreateInfo;
pub const struct_DeviceCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DeviceCreateFlags,
queueCreateInfoCount: u32,
pQueueCreateInfos: [*c]const DeviceQueueCreateInfo,
enabledLayerCount: u32,
ppEnabledLayerNames: [*c]const [*c]const u8,
enabledExtensionCount: u32,
ppEnabledExtensionNames: [*c]const [*c]const u8,
pEnabledFeatures: [*c]const PhysicalDeviceFeatures,
};
pub const DeviceCreateInfo = struct_DeviceCreateInfo;
pub const struct_ExtensionProperties = extern struct {
extensionName: [256]u8,
specVersion: u32,
};
pub const ExtensionProperties = struct_ExtensionProperties;
pub const struct_LayerProperties = extern struct {
layerName: [256]u8,
specVersion: u32,
implementationVersion: u32,
description: [256]u8,
};
pub const LayerProperties = struct_LayerProperties;
pub const struct_SubmitInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
waitSemaphoreCount: u32,
pWaitSemaphores: [*c]const Semaphore,
pWaitDstStageMask: [*c]const PipelineStageFlags,
commandBufferCount: u32,
pCommandBuffers: [*c]const CommandBuffer,
signalSemaphoreCount: u32,
pSignalSemaphores: [*c]const Semaphore,
};
pub const SubmitInfo = struct_SubmitInfo;
pub const struct_MappedMemoryRange = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
memory: DeviceMemory,
offset: DeviceSize,
size: DeviceSize,
};
pub const MappedMemoryRange = struct_MappedMemoryRange;
pub const struct_MemoryAllocateInfo = extern struct {
sType: StructureType = .MEMORY_ALLOCATE_INFO,
pNext: ?*const c_void = null,
allocationSize: DeviceSize,
memoryTypeIndex: u32,
};
pub const MemoryAllocateInfo = struct_MemoryAllocateInfo;
pub const struct_MemoryRequirements = extern struct {
size: DeviceSize,
alignment: DeviceSize,
memoryTypeBits: u32,
};
pub const MemoryRequirements = struct_MemoryRequirements;
pub const struct_SparseMemoryBind = extern struct {
resourceOffset: DeviceSize,
size: DeviceSize,
memory: DeviceMemory,
memoryOffset: DeviceSize,
flags: SparseMemoryBindFlags,
};
pub const SparseMemoryBind = struct_SparseMemoryBind;
pub const struct_SparseBufferMemoryBindInfo = extern struct {
buffer: Buffer,
bindCount: u32,
pBinds: [*c]const SparseMemoryBind,
};
pub const SparseBufferMemoryBindInfo = struct_SparseBufferMemoryBindInfo;
pub const struct_SparseImageOpaqueMemoryBindInfo = extern struct {
image: Image,
bindCount: u32,
pBinds: [*c]const SparseMemoryBind,
};
pub const SparseImageOpaqueMemoryBindInfo = struct_SparseImageOpaqueMemoryBindInfo;
pub const struct_ImageSubresource = extern struct {
aspectMask: ImageAspectFlags,
mipLevel: u32,
arrayLayer: u32,
};
pub const ImageSubresource = struct_ImageSubresource;
pub const struct_SparseImageMemoryBind = extern struct {
subresource: ImageSubresource,
offset: Offset3D,
extent: Extent3D,
memory: DeviceMemory,
memoryOffset: DeviceSize,
flags: SparseMemoryBindFlags,
};
pub const SparseImageMemoryBind = struct_SparseImageMemoryBind;
pub const struct_SparseImageMemoryBindInfo = extern struct {
image: Image,
bindCount: u32,
pBinds: [*c]const SparseImageMemoryBind,
};
pub const SparseImageMemoryBindInfo = struct_SparseImageMemoryBindInfo;
pub const struct_BindSparseInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
waitSemaphoreCount: u32,
pWaitSemaphores: [*c]const Semaphore,
bufferBindCount: u32,
pBufferBinds: [*c]const SparseBufferMemoryBindInfo,
imageOpaqueBindCount: u32,
pImageOpaqueBinds: [*c]const SparseImageOpaqueMemoryBindInfo,
imageBindCount: u32,
pImageBinds: [*c]const SparseImageMemoryBindInfo,
signalSemaphoreCount: u32,
pSignalSemaphores: [*c]const Semaphore,
};
pub const BindSparseInfo = struct_BindSparseInfo;
pub const struct_SparseImageFormatProperties = extern struct {
aspectMask: ImageAspectFlags,
imageGranularity: Extent3D,
flags: SparseImageFormatFlags,
};
pub const SparseImageFormatProperties = struct_SparseImageFormatProperties;
pub const struct_SparseImageMemoryRequirements = extern struct {
formatProperties: SparseImageFormatProperties,
imageMipTailFirstLod: u32,
imageMipTailSize: DeviceSize,
imageMipTailOffset: DeviceSize,
imageMipTailStride: DeviceSize,
};
pub const SparseImageMemoryRequirements = struct_SparseImageMemoryRequirements;
pub const struct_FenceCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: FenceCreateFlags,
};
pub const FenceCreateInfo = struct_FenceCreateInfo;
pub const struct_SemaphoreCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: SemaphoreCreateFlags,
};
pub const SemaphoreCreateInfo = struct_SemaphoreCreateInfo;
pub const struct_EventCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: EventCreateFlags,
};
pub const EventCreateInfo = struct_EventCreateInfo;
pub const struct_QueryPoolCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: QueryPoolCreateFlags,
queryType: QueryType,
queryCount: u32,
pipelineStatistics: QueryPipelineStatisticFlags,
};
pub const QueryPoolCreateInfo = struct_QueryPoolCreateInfo;
pub const struct_BufferCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: BufferCreateFlags,
size: DeviceSize,
usage: BufferUsageFlags,
sharingMode: SharingMode,
queueFamilyIndexCount: u32,
pQueueFamilyIndices: [*c]const u32,
};
pub const BufferCreateInfo = struct_BufferCreateInfo;
pub const struct_BufferViewCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: BufferViewCreateFlags,
buffer: Buffer,
format: Format,
offset: DeviceSize,
range: DeviceSize,
};
pub const BufferViewCreateInfo = struct_BufferViewCreateInfo;
pub const struct_ImageCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: ImageCreateFlags,
imageType: ImageType,
format: Format,
extent: Extent3D,
mipLevels: u32,
arrayLayers: u32,
samples: SampleCountFlagBits,
tiling: ImageTiling,
usage: ImageUsageFlags,
sharingMode: SharingMode,
queueFamilyIndexCount: u32,
pQueueFamilyIndices: [*c]const u32,
initialLayout: ImageLayout,
};
pub const ImageCreateInfo = struct_ImageCreateInfo;
pub const struct_SubresourceLayout = extern struct {
offset: DeviceSize,
size: DeviceSize,
rowPitch: DeviceSize,
arrayPitch: DeviceSize,
depthPitch: DeviceSize,
};
pub const SubresourceLayout = struct_SubresourceLayout;
pub const struct_ComponentMapping = extern struct {
r: ComponentSwizzle = .COMPONENT_SWIZZLE_IDENTITY,
g: ComponentSwizzle = .COMPONENT_SWIZZLE_IDENTITY,
b: ComponentSwizzle = .COMPONENT_SWIZZLE_IDENTITY,
a: ComponentSwizzle = .COMPONENT_SWIZZLE_IDENTITY,
};
pub const ComponentMapping = struct_ComponentMapping;
pub const struct_ImageViewCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: ImageViewCreateFlags,
image: Image,
viewType: ImageViewType,
format: Format,
components: ComponentMapping = ComponentMapping{},
subresourceRange: ImageSubresourceRange,
};
pub const ImageViewCreateInfo = struct_ImageViewCreateInfo;
pub const struct_ShaderModuleCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: ShaderModuleCreateFlags,
codeSize: usize,
pCode: [*c]const u32,
};
pub const ShaderModuleCreateInfo = struct_ShaderModuleCreateInfo;
pub const struct_PipelineCacheCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineCacheCreateFlags,
initialDataSize: usize,
pInitialData: ?*const c_void,
};
pub const PipelineCacheCreateInfo = struct_PipelineCacheCreateInfo;
pub const struct_SpecializationMapEntry = extern struct {
constantID: u32,
offset: u32,
size: usize,
};
pub const SpecializationMapEntry = struct_SpecializationMapEntry;
pub const struct_SpecializationInfo = extern struct {
mapEntryCount: u32,
pMapEntries: [*c]const SpecializationMapEntry,
dataSize: usize,
pData: ?*const c_void,
};
pub const SpecializationInfo = struct_SpecializationInfo;
pub const struct_PipelineShaderStageCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineShaderStageCreateFlags,
stage: ShaderStageFlagBits,
module: ShaderModule,
pName: [*c]const u8,
pSpecializationInfo: [*c]const SpecializationInfo,
};
pub const PipelineShaderStageCreateInfo = struct_PipelineShaderStageCreateInfo;
pub const struct_ComputePipelineCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineCreateFlags,
stage: PipelineShaderStageCreateInfo,
layout: PipelineLayout,
basePipelineHandle: Pipeline,
basePipelineIndex: i32,
};
pub const ComputePipelineCreateInfo = struct_ComputePipelineCreateInfo;
pub const struct_VertexInputBindingDescription = extern struct {
binding: u32,
stride: u32,
inputRate: VertexInputRate,
};
pub const VertexInputBindingDescription = struct_VertexInputBindingDescription;
pub const struct_VertexInputAttributeDescription = extern struct {
location: u32,
binding: u32,
format: Format,
offset: u32,
};
pub const VertexInputAttributeDescription = struct_VertexInputAttributeDescription;
pub const struct_PipelineVertexInputStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineVertexInputStateCreateFlags,
vertexBindingDescriptionCount: u32,
pVertexBindingDescriptions: [*c]const VertexInputBindingDescription,
vertexAttributeDescriptionCount: u32,
pVertexAttributeDescriptions: [*c]const VertexInputAttributeDescription,
};
pub const PipelineVertexInputStateCreateInfo = struct_PipelineVertexInputStateCreateInfo;
pub const struct_PipelineInputAssemblyStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineInputAssemblyStateCreateFlags,
topology: PrimitiveTopology,
primitiveRestartEnable: Bool32,
};
pub const PipelineInputAssemblyStateCreateInfo = struct_PipelineInputAssemblyStateCreateInfo;
pub const struct_PipelineTessellationStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineTessellationStateCreateFlags,
patchControlPoints: u32,
};
pub const PipelineTessellationStateCreateInfo = struct_PipelineTessellationStateCreateInfo;
pub const struct_Viewport = extern struct {
x: f32 = 0,
y: f32 = 0,
width: f32,
height: f32,
minDepth: f32 = 0,
maxDepth: f32 = 1,
};
pub const Viewport = struct_Viewport;
pub const struct_PipelineViewportStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineViewportStateCreateFlags,
viewportCount: u32,
pViewports: [*c]const Viewport,
scissorCount: u32,
pScissors: [*c]const Rect2D,
};
pub const PipelineViewportStateCreateInfo = struct_PipelineViewportStateCreateInfo;
pub const struct_PipelineRasterizationStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineRasterizationStateCreateFlags,
depthClampEnable: Bool32,
rasterizerDiscardEnable: Bool32,
polygonMode: PolygonMode,
cullMode: CullModeFlags,
frontFace: FrontFace,
depthBiasEnable: Bool32,
depthBiasConstantFactor: f32,
depthBiasClamp: f32,
depthBiasSlopeFactor: f32,
lineWidth: f32,
};
pub const PipelineRasterizationStateCreateInfo = struct_PipelineRasterizationStateCreateInfo;
pub const struct_PipelineMultisampleStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineMultisampleStateCreateFlags,
rasterizationSamples: SampleCountFlagBits,
sampleShadingEnable: Bool32,
minSampleShading: f32,
pSampleMask: [*c]const SampleMask,
alphaToCoverageEnable: Bool32,
alphaToOneEnable: Bool32,
};
pub const PipelineMultisampleStateCreateInfo = struct_PipelineMultisampleStateCreateInfo;
pub const struct_StencilOpState = extern struct {
failOp: StencilOp,
passOp: StencilOp,
depthFailOp: StencilOp,
compareOp: CompareOp,
compareMask: u32,
writeMask: u32,
reference: u32,
};
pub const StencilOpState = struct_StencilOpState;
pub const struct_PipelineDepthStencilStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineDepthStencilStateCreateFlags,
depthTestEnable: Bool32,
depthWriteEnable: Bool32,
depthCompareOp: CompareOp,
depthBoundsTestEnable: Bool32,
stencilTestEnable: Bool32,
front: StencilOpState,
back: StencilOpState,
minDepthBounds: f32,
maxDepthBounds: f32,
};
pub const PipelineDepthStencilStateCreateInfo = struct_PipelineDepthStencilStateCreateInfo;
pub const struct_PipelineColorBlendAttachmentState = extern struct {
blendEnable: Bool32,
srcColorBlendFactor: BlendFactor,
dstColorBlendFactor: BlendFactor,
colorBlendOp: BlendOp,
srcAlphaBlendFactor: BlendFactor,
dstAlphaBlendFactor: BlendFactor,
alphaBlendOp: BlendOp,
colorWriteMask: ColorComponentFlags,
};
pub const PipelineColorBlendAttachmentState = struct_PipelineColorBlendAttachmentState;
pub const struct_PipelineColorBlendStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineColorBlendStateCreateFlags,
logicOpEnable: Bool32,
logicOp: LogicOp,
attachmentCount: u32,
pAttachments: [*c]const PipelineColorBlendAttachmentState,
blendConstants: [4]f32,
};
pub const PipelineColorBlendStateCreateInfo = struct_PipelineColorBlendStateCreateInfo;
pub const struct_PipelineDynamicStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineDynamicStateCreateFlags,
dynamicStateCount: u32,
pDynamicStates: [*c]const DynamicState,
};
pub const PipelineDynamicStateCreateInfo = struct_PipelineDynamicStateCreateInfo;
pub const struct_GraphicsPipelineCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineCreateFlags,
stageCount: u32,
pStages: [*c]const PipelineShaderStageCreateInfo,
pVertexInputState: [*c]const PipelineVertexInputStateCreateInfo,
pInputAssemblyState: [*c]const PipelineInputAssemblyStateCreateInfo,
pTessellationState: [*c]const PipelineTessellationStateCreateInfo,
pViewportState: [*c]const PipelineViewportStateCreateInfo,
pRasterizationState: [*c]const PipelineRasterizationStateCreateInfo,
pMultisampleState: [*c]const PipelineMultisampleStateCreateInfo,
pDepthStencilState: [*c]const PipelineDepthStencilStateCreateInfo,
pColorBlendState: [*c]const PipelineColorBlendStateCreateInfo,
pDynamicState: [*c]const PipelineDynamicStateCreateInfo,
layout: PipelineLayout,
renderPass: RenderPass,
subpass: u32,
basePipelineHandle: Pipeline,
basePipelineIndex: i32,
};
pub const GraphicsPipelineCreateInfo = struct_GraphicsPipelineCreateInfo;
pub const struct_PushConstantRange = extern struct {
stageFlags: ShaderStageFlags,
offset: u32,
size: u32,
};
pub const PushConstantRange = struct_PushConstantRange;
pub const struct_PipelineLayoutCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineLayoutCreateFlags,
setLayoutCount: u32,
pSetLayouts: [*c]const DescriptorSetLayout,
pushConstantRangeCount: u32,
pPushConstantRanges: [*c]const PushConstantRange,
};
pub const PipelineLayoutCreateInfo = struct_PipelineLayoutCreateInfo;
pub const struct_SamplerCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: SamplerCreateFlags,
magFilter: Filter,
minFilter: Filter,
mipmapMode: SamplerMipmapMode,
addressModeU: SamplerAddressMode,
addressModeV: SamplerAddressMode,
addressModeW: SamplerAddressMode,
mipLodBias: f32,
anisotropyEnable: Bool32,
maxAnisotropy: f32,
compareEnable: Bool32,
compareOp: CompareOp,
minLod: f32,
maxLod: f32,
borderColor: BorderColor,
unnormalizedCoordinates: Bool32,
};
pub const SamplerCreateInfo = struct_SamplerCreateInfo;
pub const struct_CopyDescriptorSet = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcSet: DescriptorSet,
srcBinding: u32,
srcArrayElement: u32,
dstSet: DescriptorSet,
dstBinding: u32,
dstArrayElement: u32,
descriptorCount: u32,
};
pub const CopyDescriptorSet = struct_CopyDescriptorSet;
pub const struct_DescriptorBufferInfo = extern struct {
buffer: Buffer,
offset: DeviceSize,
range: DeviceSize,
};
pub const DescriptorBufferInfo = struct_DescriptorBufferInfo;
pub const struct_DescriptorImageInfo = extern struct {
sampler: Sampler,
imageView: ImageView,
imageLayout: ImageLayout,
};
pub const DescriptorImageInfo = struct_DescriptorImageInfo;
pub const struct_DescriptorPoolSize = extern struct {
type: DescriptorType,
descriptorCount: u32,
};
pub const DescriptorPoolSize = struct_DescriptorPoolSize;
pub const struct_DescriptorPoolCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DescriptorPoolCreateFlags,
maxSets: u32,
poolSizeCount: u32,
pPoolSizes: [*c]const DescriptorPoolSize,
};
pub const DescriptorPoolCreateInfo = struct_DescriptorPoolCreateInfo;
pub const struct_DescriptorSetAllocateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
descriptorPool: DescriptorPool,
descriptorSetCount: u32,
pSetLayouts: [*c]const DescriptorSetLayout,
};
pub const DescriptorSetAllocateInfo = struct_DescriptorSetAllocateInfo;
pub const struct_DescriptorSetLayoutBinding = extern struct {
binding: u32,
descriptorType: DescriptorType,
descriptorCount: u32,
stageFlags: ShaderStageFlags,
pImmutableSamplers: [*c]const Sampler,
};
pub const DescriptorSetLayoutBinding = struct_DescriptorSetLayoutBinding;
pub const struct_DescriptorSetLayoutCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DescriptorSetLayoutCreateFlags,
bindingCount: u32,
pBindings: [*c]const DescriptorSetLayoutBinding,
};
pub const DescriptorSetLayoutCreateInfo = struct_DescriptorSetLayoutCreateInfo;
pub const struct_WriteDescriptorSet = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
dstSet: DescriptorSet,
dstBinding: u32,
dstArrayElement: u32,
descriptorCount: u32,
descriptorType: DescriptorType,
pImageInfo: [*c]const DescriptorImageInfo,
pBufferInfo: [*c]const DescriptorBufferInfo,
pTexelBufferView: [*c]const BufferView,
};
pub const WriteDescriptorSet = struct_WriteDescriptorSet;
pub const struct_AttachmentDescription = extern struct {
flags: AttachmentDescriptionFlags,
format: Format,
samples: SampleCountFlagBits,
loadOp: AttachmentLoadOp,
storeOp: AttachmentStoreOp,
stencilLoadOp: AttachmentLoadOp,
stencilStoreOp: AttachmentStoreOp,
initialLayout: ImageLayout,
finalLayout: ImageLayout,
};
pub const AttachmentDescription = struct_AttachmentDescription;
pub const struct_AttachmentReference = extern struct {
attachment: u32,
layout: ImageLayout,
};
pub const AttachmentReference = struct_AttachmentReference;
pub const struct_FramebufferCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: FramebufferCreateFlags,
renderPass: RenderPass,
attachmentCount: u32,
pAttachments: [*c]const ImageView,
width: u32,
height: u32,
layers: u32,
};
pub const FramebufferCreateInfo = struct_FramebufferCreateInfo;
pub const struct_SubpassDescription = extern struct {
flags: SubpassDescriptionFlags,
pipelineBindPoint: PipelineBindPoint,
inputAttachmentCount: u32,
pInputAttachments: [*c]const AttachmentReference,
colorAttachmentCount: u32,
pColorAttachments: [*c]const AttachmentReference,
pResolveAttachments: [*c]const AttachmentReference,
pDepthStencilAttachment: [*c]const AttachmentReference,
preserveAttachmentCount: u32,
pPreserveAttachments: [*c]const u32,
};
pub const SubpassDescription = struct_SubpassDescription;
pub const struct_SubpassDependency = extern struct {
srcSubpass: u32,
dstSubpass: u32,
srcStageMask: PipelineStageFlags,
dstStageMask: PipelineStageFlags,
srcAccessMask: AccessFlags,
dstAccessMask: AccessFlags,
dependencyFlags: DependencyFlags,
};
pub const SubpassDependency = struct_SubpassDependency;
pub const struct_RenderPassCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: RenderPassCreateFlags,
attachmentCount: u32,
pAttachments: [*c]const AttachmentDescription,
subpassCount: u32,
pSubpasses: [*c]const SubpassDescription,
dependencyCount: u32,
pDependencies: [*c]const SubpassDependency,
};
pub const RenderPassCreateInfo = struct_RenderPassCreateInfo;
pub const struct_CommandPoolCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: CommandPoolCreateFlags,
queueFamilyIndex: u32,
};
pub const CommandPoolCreateInfo = struct_CommandPoolCreateInfo;
pub const struct_CommandBufferAllocateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
commandPool: CommandPool,
level: CommandBufferLevel,
commandBufferCount: u32,
};
pub const CommandBufferAllocateInfo = struct_CommandBufferAllocateInfo;
pub const struct_CommandBufferInheritanceInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
renderPass: RenderPass,
subpass: u32,
framebuffer: Framebuffer,
occlusionQueryEnable: Bool32,
queryFlags: QueryControlFlags,
pipelineStatistics: QueryPipelineStatisticFlags,
};
pub const CommandBufferInheritanceInfo = struct_CommandBufferInheritanceInfo;
pub const struct_CommandBufferBeginInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: CommandBufferUsageFlags,
pInheritanceInfo: [*c]const CommandBufferInheritanceInfo,
};
pub const CommandBufferBeginInfo = struct_CommandBufferBeginInfo;
pub const struct_BufferCopy = extern struct {
srcOffset: DeviceSize,
dstOffset: DeviceSize,
size: DeviceSize,
};
pub const BufferCopy = struct_BufferCopy;
pub const struct_ImageSubresourceLayers = extern struct {
aspectMask: ImageAspectFlags,
mipLevel: u32,
baseArrayLayer: u32,
layerCount: u32,
};
pub const ImageSubresourceLayers = struct_ImageSubresourceLayers;
pub const struct_BufferImageCopy = extern struct {
bufferOffset: DeviceSize,
bufferRowLength: u32,
bufferImageHeight: u32,
imageSubresource: ImageSubresourceLayers,
imageOffset: Offset3D,
imageExtent: Extent3D,
};
pub const BufferImageCopy = struct_BufferImageCopy;
pub const union_ClearColorValue = extern union {
float32: [4]f32,
int32: [4]i32,
uint32: [4]u32,
};
pub const ClearColorValue = union_ClearColorValue;
pub const struct_ClearDepthStencilValue = extern struct {
depth: f32,
stencil: u32,
};
pub const ClearDepthStencilValue = struct_ClearDepthStencilValue;
pub const union_ClearValue = extern union {
color: ClearColorValue,
depthStencil: ClearDepthStencilValue,
};
pub const ClearValue = union_ClearValue;
pub const struct_ClearAttachment = extern struct {
aspectMask: ImageAspectFlags,
colorAttachment: u32,
clearValue: ClearValue,
};
pub const ClearAttachment = struct_ClearAttachment;
pub const struct_ClearRect = extern struct {
rect: Rect2D,
baseArrayLayer: u32,
layerCount: u32,
};
pub const ClearRect = struct_ClearRect;
pub const struct_ImageBlit = extern struct {
srcSubresource: ImageSubresourceLayers,
srcOffsets: [2]Offset3D,
dstSubresource: ImageSubresourceLayers,
dstOffsets: [2]Offset3D,
};
pub const ImageBlit = struct_ImageBlit;
pub const struct_ImageCopy = extern struct {
srcSubresource: ImageSubresourceLayers,
srcOffset: Offset3D,
dstSubresource: ImageSubresourceLayers,
dstOffset: Offset3D,
extent: Extent3D,
};
pub const ImageCopy = struct_ImageCopy;
pub const struct_ImageResolve = extern struct {
srcSubresource: ImageSubresourceLayers,
srcOffset: Offset3D,
dstSubresource: ImageSubresourceLayers,
dstOffset: Offset3D,
extent: Extent3D,
};
pub const ImageResolve = struct_ImageResolve;
pub const struct_RenderPassBeginInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
renderPass: RenderPass,
framebuffer: Framebuffer,
renderArea: Rect2D,
clearValueCount: u32,
pClearValues: [*c]const ClearValue,
};
pub const RenderPassBeginInfo = struct_RenderPassBeginInfo;
pub const PFN_vkCreateInstance = ?fn ([*c]const InstanceCreateInfo, [*c]const AllocationCallbacks, [*c]Instance) callconv(.C) Result;
pub const PFN_vkDestroyInstance = ?fn (Instance, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkEnumeratePhysicalDevices = ?fn (Instance, [*c]u32, [*c]PhysicalDevice) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceFeatures = ?fn (PhysicalDevice, [*c]PhysicalDeviceFeatures) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceFormatProperties = ?fn (PhysicalDevice, Format, [*c]FormatProperties) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceImageFormatProperties = ?fn (PhysicalDevice, Format, ImageType, ImageTiling, ImageUsageFlags, ImageCreateFlags, [*c]ImageFormatProperties) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceProperties = ?fn (PhysicalDevice, [*c]PhysicalDeviceProperties) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceQueueFamilyProperties = ?fn (PhysicalDevice, [*c]u32, [*c]QueueFamilyProperties) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceMemoryProperties = ?fn (PhysicalDevice, [*c]PhysicalDeviceMemoryProperties) callconv(.C) void;
pub const PFN_vkGetInstanceProcAddr = ?fn (Instance, [*c]const u8) callconv(.C) PFN_vkVoidFunction;
pub const PFN_vkGetDeviceProcAddr = ?fn (Device, [*c]const u8) callconv(.C) PFN_vkVoidFunction;
pub const PFN_vkCreateDevice = ?fn (PhysicalDevice, [*c]const DeviceCreateInfo, [*c]const AllocationCallbacks, [*c]Device) callconv(.C) Result;
pub const PFN_vkDestroyDevice = ?fn (Device, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkEnumerateInstanceExtensionProperties = ?fn ([*c]const u8, [*c]u32, [*c]ExtensionProperties) callconv(.C) Result;
pub const PFN_vkEnumerateDeviceExtensionProperties = ?fn (PhysicalDevice, [*c]const u8, [*c]u32, [*c]ExtensionProperties) callconv(.C) Result;
pub const PFN_vkEnumerateInstanceLayerProperties = ?fn ([*c]u32, [*c]LayerProperties) callconv(.C) Result;
pub const PFN_vkEnumerateDeviceLayerProperties = ?fn (PhysicalDevice, [*c]u32, [*c]LayerProperties) callconv(.C) Result;
pub const PFN_vkGetDeviceQueue = ?fn (Device, u32, u32, [*c]Queue) callconv(.C) void;
pub const PFN_vkQueueSubmit = ?fn (Queue, u32, [*c]const SubmitInfo, Fence) callconv(.C) Result;
pub const PFN_vkQueueWaitIdle = ?fn (Queue) callconv(.C) Result;
pub const PFN_vkDeviceWaitIdle = ?fn (Device) callconv(.C) Result;
pub const PFN_vkAllocateMemory = ?fn (Device, [*c]const MemoryAllocateInfo, [*c]const AllocationCallbacks, [*c]DeviceMemory) callconv(.C) Result;
pub const PFN_vkFreeMemory = ?fn (Device, DeviceMemory, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkMapMemory = ?fn (Device, DeviceMemory, DeviceSize, DeviceSize, MemoryMapFlags, [*c]?*c_void) callconv(.C) Result;
pub const PFN_vkUnmapMemory = ?fn (Device, DeviceMemory) callconv(.C) void;
pub const PFN_vkFlushMappedMemoryRanges = ?fn (Device, u32, [*c]const MappedMemoryRange) callconv(.C) Result;
pub const PFN_vkInvalidateMappedMemoryRanges = ?fn (Device, u32, [*c]const MappedMemoryRange) callconv(.C) Result;
pub const PFN_vkGetDeviceMemoryCommitment = ?fn (Device, DeviceMemory, [*c]DeviceSize) callconv(.C) void;
pub const PFN_vkBindBufferMemory = ?fn (Device, Buffer, DeviceMemory, DeviceSize) callconv(.C) Result;
pub const PFN_vkBindImageMemory = ?fn (Device, Image, DeviceMemory, DeviceSize) callconv(.C) Result;
pub const PFN_vkGetBufferMemoryRequirements = ?fn (Device, Buffer, [*c]MemoryRequirements) callconv(.C) void;
pub const PFN_vkGetImageMemoryRequirements = ?fn (Device, Image, [*c]MemoryRequirements) callconv(.C) void;
pub const PFN_vkGetImageSparseMemoryRequirements = ?fn (Device, Image, [*c]u32, [*c]SparseImageMemoryRequirements) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceSparseImageFormatProperties = ?fn (PhysicalDevice, Format, ImageType, SampleCountFlagBits, ImageUsageFlags, ImageTiling, [*c]u32, [*c]SparseImageFormatProperties) callconv(.C) void;
pub const PFN_vkQueueBindSparse = ?fn (Queue, u32, [*c]const BindSparseInfo, Fence) callconv(.C) Result;
pub const PFN_vkCreateFence = ?fn (Device, [*c]const FenceCreateInfo, [*c]const AllocationCallbacks, [*c]Fence) callconv(.C) Result;
pub const PFN_vkDestroyFence = ?fn (Device, Fence, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkResetFences = ?fn (Device, u32, [*c]const Fence) callconv(.C) Result;
pub const PFN_vkGetFenceStatus = ?fn (Device, Fence) callconv(.C) Result;
pub const PFN_vkWaitForFences = ?fn (Device, u32, [*c]const Fence, Bool32, u64) callconv(.C) Result;
pub const PFN_vkCreateSemaphore = ?fn (Device, [*c]const SemaphoreCreateInfo, [*c]const AllocationCallbacks, [*c]Semaphore) callconv(.C) Result;
pub const PFN_vkDestroySemaphore = ?fn (Device, Semaphore, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateEvent = ?fn (Device, [*c]const EventCreateInfo, [*c]const AllocationCallbacks, [*c]Event) callconv(.C) Result;
pub const PFN_vkDestroyEvent = ?fn (Device, Event, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkGetEventStatus = ?fn (Device, Event) callconv(.C) Result;
pub const PFN_vkSetEvent = ?fn (Device, Event) callconv(.C) Result;
pub const PFN_vkResetEvent = ?fn (Device, Event) callconv(.C) Result;
pub const PFN_vkCreateQueryPool = ?fn (Device, [*c]const QueryPoolCreateInfo, [*c]const AllocationCallbacks, [*c]QueryPool) callconv(.C) Result;
pub const PFN_vkDestroyQueryPool = ?fn (Device, QueryPool, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkGetQueryPoolResults = ?fn (Device, QueryPool, u32, u32, usize, ?*c_void, DeviceSize, QueryResultFlags) callconv(.C) Result;
pub const PFN_vkCreateBuffer = ?fn (Device, [*c]const BufferCreateInfo, [*c]const AllocationCallbacks, [*c]Buffer) callconv(.C) Result;
pub const PFN_vkDestroyBuffer = ?fn (Device, Buffer, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateBufferView = ?fn (Device, [*c]const BufferViewCreateInfo, [*c]const AllocationCallbacks, [*c]BufferView) callconv(.C) Result;
pub const PFN_vkDestroyBufferView = ?fn (Device, BufferView, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateImage = ?fn (Device, [*c]const ImageCreateInfo, [*c]const AllocationCallbacks, [*c]Image) callconv(.C) Result;
pub const PFN_vkDestroyImage = ?fn (Device, Image, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkGetImageSubresourceLayout = ?fn (Device, Image, [*c]const ImageSubresource, [*c]SubresourceLayout) callconv(.C) void;
pub const PFN_vkCreateImageView = ?fn (Device, [*c]const ImageViewCreateInfo, [*c]const AllocationCallbacks, [*c]ImageView) callconv(.C) Result;
pub const PFN_vkDestroyImageView = ?fn (Device, ImageView, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateShaderModule = ?fn (Device, [*c]const ShaderModuleCreateInfo, [*c]const AllocationCallbacks, [*c]ShaderModule) callconv(.C) Result;
pub const PFN_vkDestroyShaderModule = ?fn (Device, ShaderModule, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreatePipelineCache = ?fn (Device, [*c]const PipelineCacheCreateInfo, [*c]const AllocationCallbacks, [*c]PipelineCache) callconv(.C) Result;
pub const PFN_vkDestroyPipelineCache = ?fn (Device, PipelineCache, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkGetPipelineCacheData = ?fn (Device, PipelineCache, [*c]usize, ?*c_void) callconv(.C) Result;
pub const PFN_vkMergePipelineCaches = ?fn (Device, PipelineCache, u32, [*c]const PipelineCache) callconv(.C) Result;
pub const PFN_vkCreateGraphicsPipelines = ?fn (Device, PipelineCache, u32, [*c]const GraphicsPipelineCreateInfo, [*c]const AllocationCallbacks, [*c]Pipeline) callconv(.C) Result;
pub const PFN_vkCreateComputePipelines = ?fn (Device, PipelineCache, u32, [*c]const ComputePipelineCreateInfo, [*c]const AllocationCallbacks, [*c]Pipeline) callconv(.C) Result;
pub const PFN_vkDestroyPipeline = ?fn (Device, Pipeline, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreatePipelineLayout = ?fn (Device, [*c]const PipelineLayoutCreateInfo, [*c]const AllocationCallbacks, [*c]PipelineLayout) callconv(.C) Result;
pub const PFN_vkDestroyPipelineLayout = ?fn (Device, PipelineLayout, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateSampler = ?fn (Device, [*c]const SamplerCreateInfo, [*c]const AllocationCallbacks, [*c]Sampler) callconv(.C) Result;
pub const PFN_vkDestroySampler = ?fn (Device, Sampler, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateDescriptorSetLayout = ?fn (Device, [*c]const DescriptorSetLayoutCreateInfo, [*c]const AllocationCallbacks, [*c]DescriptorSetLayout) callconv(.C) Result;
pub const PFN_vkDestroyDescriptorSetLayout = ?fn (Device, DescriptorSetLayout, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateDescriptorPool = ?fn (Device, [*c]const DescriptorPoolCreateInfo, [*c]const AllocationCallbacks, [*c]DescriptorPool) callconv(.C) Result;
pub const PFN_vkDestroyDescriptorPool = ?fn (Device, DescriptorPool, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkResetDescriptorPool = ?fn (Device, DescriptorPool, DescriptorPoolResetFlags) callconv(.C) Result;
pub const PFN_vkAllocateDescriptorSets = ?fn (Device, [*c]const DescriptorSetAllocateInfo, [*c]DescriptorSet) callconv(.C) Result;
pub const PFN_vkFreeDescriptorSets = ?fn (Device, DescriptorPool, u32, [*c]const DescriptorSet) callconv(.C) Result;
pub const PFN_vkUpdateDescriptorSets = ?fn (Device, u32, [*c]const WriteDescriptorSet, u32, [*c]const CopyDescriptorSet) callconv(.C) void;
pub const PFN_vkCreateFramebuffer = ?fn (Device, [*c]const FramebufferCreateInfo, [*c]const AllocationCallbacks, [*c]Framebuffer) callconv(.C) Result;
pub const PFN_vkDestroyFramebuffer = ?fn (Device, Framebuffer, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateRenderPass = ?fn (Device, [*c]const RenderPassCreateInfo, [*c]const AllocationCallbacks, [*c]RenderPass) callconv(.C) Result;
pub const PFN_vkDestroyRenderPass = ?fn (Device, RenderPass, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkGetRenderAreaGranularity = ?fn (Device, RenderPass, [*c]Extent2D) callconv(.C) void;
pub const PFN_vkCreateCommandPool = ?fn (Device, [*c]const CommandPoolCreateInfo, [*c]const AllocationCallbacks, [*c]CommandPool) callconv(.C) Result;
pub const PFN_vkDestroyCommandPool = ?fn (Device, CommandPool, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkResetCommandPool = ?fn (Device, CommandPool, CommandPoolResetFlags) callconv(.C) Result;
pub const PFN_vkAllocateCommandBuffers = ?fn (Device, [*c]const CommandBufferAllocateInfo, [*c]CommandBuffer) callconv(.C) Result;
pub const PFN_vkFreeCommandBuffers = ?fn (Device, CommandPool, u32, [*c]const CommandBuffer) callconv(.C) void;
pub const PFN_vkBeginCommandBuffer = ?fn (CommandBuffer, [*c]const CommandBufferBeginInfo) callconv(.C) Result;
pub const PFN_vkEndCommandBuffer = ?fn (CommandBuffer) callconv(.C) Result;
pub const PFN_vkResetCommandBuffer = ?fn (CommandBuffer, CommandBufferResetFlags) callconv(.C) Result;
pub const PFN_vkCmdBindPipeline = ?fn (CommandBuffer, PipelineBindPoint, Pipeline) callconv(.C) void;
pub const PFN_vkCmdSetViewport = ?fn (CommandBuffer, u32, u32, [*c]const Viewport) callconv(.C) void;
pub const PFN_vkCmdSetScissor = ?fn (CommandBuffer, u32, u32, [*c]const Rect2D) callconv(.C) void;
pub const PFN_vkCmdSetLineWidth = ?fn (CommandBuffer, f32) callconv(.C) void;
pub const PFN_vkCmdSetDepthBias = ?fn (CommandBuffer, f32, f32, f32) callconv(.C) void;
pub const PFN_vkCmdSetBlendConstants = ?fn (CommandBuffer, [*c]const f32) callconv(.C) void;
pub const PFN_vkCmdSetDepthBounds = ?fn (CommandBuffer, f32, f32) callconv(.C) void;
pub const PFN_vkCmdSetStencilCompareMask = ?fn (CommandBuffer, StencilFaceFlags, u32) callconv(.C) void;
pub const PFN_vkCmdSetStencilWriteMask = ?fn (CommandBuffer, StencilFaceFlags, u32) callconv(.C) void;
pub const PFN_vkCmdSetStencilReference = ?fn (CommandBuffer, StencilFaceFlags, u32) callconv(.C) void;
pub const PFN_vkCmdBindDescriptorSets = ?fn (CommandBuffer, PipelineBindPoint, PipelineLayout, u32, u32, [*c]const DescriptorSet, u32, [*c]const u32) callconv(.C) void;
pub const PFN_vkCmdBindIndexBuffer = ?fn (CommandBuffer, Buffer, DeviceSize, IndexType) callconv(.C) void;
pub const PFN_vkCmdBindVertexBuffers = ?fn (CommandBuffer, u32, u32, [*c]const Buffer, [*c]const DeviceSize) callconv(.C) void;
pub const PFN_vkCmdDraw = ?fn (CommandBuffer, u32, u32, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawIndexed = ?fn (CommandBuffer, u32, u32, u32, i32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawIndirect = ?fn (CommandBuffer, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawIndexedIndirect = ?fn (CommandBuffer, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDispatch = ?fn (CommandBuffer, u32, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDispatchIndirect = ?fn (CommandBuffer, Buffer, DeviceSize) callconv(.C) void;
pub const PFN_vkCmdCopyBuffer = ?fn (CommandBuffer, Buffer, Buffer, u32, [*c]const BufferCopy) callconv(.C) void;
pub const PFN_vkCmdCopyImage = ?fn (CommandBuffer, Image, ImageLayout, Image, ImageLayout, u32, [*c]const ImageCopy) callconv(.C) void;
pub const PFN_vkCmdBlitImage = ?fn (CommandBuffer, Image, ImageLayout, Image, ImageLayout, u32, [*c]const ImageBlit, Filter) callconv(.C) void;
pub const PFN_vkCmdCopyBufferToImage = ?fn (CommandBuffer, Buffer, Image, ImageLayout, u32, [*c]const BufferImageCopy) callconv(.C) void;
pub const PFN_vkCmdCopyImageToBuffer = ?fn (CommandBuffer, Image, ImageLayout, Buffer, u32, [*c]const BufferImageCopy) callconv(.C) void;
pub const PFN_vkCmdUpdateBuffer = ?fn (CommandBuffer, Buffer, DeviceSize, DeviceSize, ?*const c_void) callconv(.C) void;
pub const PFN_vkCmdFillBuffer = ?fn (CommandBuffer, Buffer, DeviceSize, DeviceSize, u32) callconv(.C) void;
pub const PFN_vkCmdClearColorImage = ?fn (CommandBuffer, Image, ImageLayout, [*c]const ClearColorValue, u32, [*c]const ImageSubresourceRange) callconv(.C) void;
pub const PFN_vkCmdClearDepthStencilImage = ?fn (CommandBuffer, Image, ImageLayout, [*c]const ClearDepthStencilValue, u32, [*c]const ImageSubresourceRange) callconv(.C) void;
pub const PFN_vkCmdClearAttachments = ?fn (CommandBuffer, u32, [*c]const ClearAttachment, u32, [*c]const ClearRect) callconv(.C) void;
pub const PFN_vkCmdResolveImage = ?fn (CommandBuffer, Image, ImageLayout, Image, ImageLayout, u32, [*c]const ImageResolve) callconv(.C) void;
pub const PFN_vkCmdSetEvent = ?fn (CommandBuffer, Event, PipelineStageFlags) callconv(.C) void;
pub const PFN_vkCmdResetEvent = ?fn (CommandBuffer, Event, PipelineStageFlags) callconv(.C) void;
pub const PFN_vkCmdWaitEvents = ?fn (CommandBuffer, u32, [*c]const Event, PipelineStageFlags, PipelineStageFlags, u32, [*c]const MemoryBarrier, u32, [*c]const BufferMemoryBarrier, u32, [*c]const ImageMemoryBarrier) callconv(.C) void;
pub const PFN_vkCmdPipelineBarrier = ?fn (CommandBuffer, PipelineStageFlags, PipelineStageFlags, DependencyFlags, u32, [*c]const MemoryBarrier, u32, [*c]const BufferMemoryBarrier, u32, [*c]const ImageMemoryBarrier) callconv(.C) void;
pub const PFN_vkCmdBeginQuery = ?fn (CommandBuffer, QueryPool, u32, QueryControlFlags) callconv(.C) void;
pub const PFN_vkCmdEndQuery = ?fn (CommandBuffer, QueryPool, u32) callconv(.C) void;
pub const PFN_vkCmdResetQueryPool = ?fn (CommandBuffer, QueryPool, u32, u32) callconv(.C) void;
pub const PFN_vkCmdWriteTimestamp = ?fn (CommandBuffer, PipelineStageFlagBits, QueryPool, u32) callconv(.C) void;
pub const PFN_vkCmdCopyQueryPoolResults = ?fn (CommandBuffer, QueryPool, u32, u32, Buffer, DeviceSize, DeviceSize, QueryResultFlags) callconv(.C) void;
pub const PFN_vkCmdPushConstants = ?fn (CommandBuffer, PipelineLayout, ShaderStageFlags, u32, u32, ?*const c_void) callconv(.C) void;
pub const PFN_vkCmdBeginRenderPass = ?fn (CommandBuffer, [*c]const RenderPassBeginInfo, SubpassContents) callconv(.C) void;
pub const PFN_vkCmdNextSubpass = ?fn (CommandBuffer, SubpassContents) callconv(.C) void;
pub const PFN_vkCmdEndRenderPass = ?fn (CommandBuffer) callconv(.C) void;
pub const PFN_vkCmdExecuteCommands = ?fn (CommandBuffer, u32, [*c]const CommandBuffer) callconv(.C) void;
pub extern fn vkCreateInstance(pCreateInfo: [*c]const InstanceCreateInfo, pAllocator: [*c]const AllocationCallbacks, pInstance: [*c]Instance) Result;
pub extern fn vkDestroyInstance(instance: Instance, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkEnumeratePhysicalDevices(instance: Instance, pPhysicalDeviceCount: [*c]u32, pPhysicalDevices: [*c]PhysicalDevice) Result;
pub extern fn vkGetPhysicalDeviceFeatures(physicalDevice: PhysicalDevice, pFeatures: [*c]PhysicalDeviceFeatures) void;
pub extern fn vkGetPhysicalDeviceFormatProperties(physicalDevice: PhysicalDevice, format: Format, pFormatProperties: [*c]FormatProperties) void;
pub extern fn vkGetPhysicalDeviceImageFormatProperties(physicalDevice: PhysicalDevice, format: Format, type: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, pImageFormatProperties: [*c]ImageFormatProperties) Result;
pub extern fn vkGetPhysicalDeviceProperties(physicalDevice: PhysicalDevice, pProperties: [*c]PhysicalDeviceProperties) void;
pub extern fn vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: [*c]u32, pQueueFamilyProperties: [*c]QueueFamilyProperties) void;
pub extern fn vkGetPhysicalDeviceMemoryProperties(physicalDevice: PhysicalDevice, pMemoryProperties: [*c]PhysicalDeviceMemoryProperties) void;
pub extern fn vkGetInstanceProcAddr(instance: Instance, pName: [*c]const u8) PFN_vkVoidFunction;
pub extern fn vkGetDeviceProcAddr(device: Device, pName: [*c]const u8) PFN_vkVoidFunction;
pub extern fn vkCreateDevice(physicalDevice: PhysicalDevice, pCreateInfo: [*c]const DeviceCreateInfo, pAllocator: [*c]const AllocationCallbacks, pDevice: [*c]Device) Result;
pub extern fn vkDestroyDevice(device: Device, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkEnumerateInstanceExtensionProperties(pLayerName: [*c]const u8, pPropertyCount: [*c]u32, pProperties: [*c]ExtensionProperties) Result;
pub extern fn vkEnumerateDeviceExtensionProperties(physicalDevice: PhysicalDevice, pLayerName: [*c]const u8, pPropertyCount: [*c]u32, pProperties: [*c]ExtensionProperties) Result;
pub extern fn vkEnumerateInstanceLayerProperties(pPropertyCount: [*c]u32, pProperties: [*c]LayerProperties) Result;
pub extern fn vkEnumerateDeviceLayerProperties(physicalDevice: PhysicalDevice, pPropertyCount: [*c]u32, pProperties: [*c]LayerProperties) Result;
pub extern fn vkGetDeviceQueue(device: Device, queueFamilyIndex: u32, queueIndex: u32, pQueue: [*c]Queue) void;
pub extern fn vkQueueSubmit(queue: Queue, submitCount: u32, pSubmits: [*c]const SubmitInfo, fence: Fence) Result;
pub extern fn vkQueueWaitIdle(queue: Queue) Result;
pub extern fn vkDeviceWaitIdle(device: Device) Result;
pub extern fn vkAllocateMemory(device: Device, pAllocateInfo: [*c]const MemoryAllocateInfo, pAllocator: [*c]const AllocationCallbacks, pMemory: [*c]DeviceMemory) Result;
pub extern fn vkFreeMemory(device: Device, memory: DeviceMemory, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkMapMemory(device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, ppData: [*c]?*c_void) Result;
pub extern fn vkUnmapMemory(device: Device, memory: DeviceMemory) void;
pub extern fn vkFlushMappedMemoryRanges(device: Device, memoryRangeCount: u32, pMemoryRanges: [*c]const MappedMemoryRange) Result;
pub extern fn vkInvalidateMappedMemoryRanges(device: Device, memoryRangeCount: u32, pMemoryRanges: [*c]const MappedMemoryRange) Result;
pub extern fn vkGetDeviceMemoryCommitment(device: Device, memory: DeviceMemory, pCommittedMemoryInBytes: [*c]DeviceSize) void;
pub extern fn vkBindBufferMemory(device: Device, buffer: Buffer, memory: DeviceMemory, memoryOffset: DeviceSize) Result;
pub extern fn vkBindImageMemory(device: Device, image: Image, memory: DeviceMemory, memoryOffset: DeviceSize) Result;
pub extern fn vkGetBufferMemoryRequirements(device: Device, buffer: Buffer, pMemoryRequirements: [*c]MemoryRequirements) void;
pub extern fn vkGetImageMemoryRequirements(device: Device, image: Image, pMemoryRequirements: [*c]MemoryRequirements) void;
pub extern fn vkGetImageSparseMemoryRequirements(device: Device, image: Image, pSparseMemoryRequirementCount: [*c]u32, pSparseMemoryRequirements: [*c]SparseImageMemoryRequirements) void;
pub extern fn vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice: PhysicalDevice, format: Format, type: ImageType, samples: SampleCountFlagBits, usage: ImageUsageFlags, tiling: ImageTiling, pPropertyCount: [*c]u32, pProperties: [*c]SparseImageFormatProperties) void;
pub extern fn vkQueueBindSparse(queue: Queue, bindInfoCount: u32, pBindInfo: [*c]const BindSparseInfo, fence: Fence) Result;
pub extern fn vkCreateFence(device: Device, pCreateInfo: [*c]const FenceCreateInfo, pAllocator: [*c]const AllocationCallbacks, pFence: [*c]Fence) Result;
pub extern fn vkDestroyFence(device: Device, fence: Fence, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkResetFences(device: Device, fenceCount: u32, pFences: [*c]const Fence) Result;
pub extern fn vkGetFenceStatus(device: Device, fence: Fence) Result;
pub extern fn vkWaitForFences(device: Device, fenceCount: u32, pFences: [*c]const Fence, waitAll: Bool32, timeout: u64) Result;
pub extern fn vkCreateSemaphore(device: Device, pCreateInfo: [*c]const SemaphoreCreateInfo, pAllocator: [*c]const AllocationCallbacks, pSemaphore: [*c]Semaphore) Result;
pub extern fn vkDestroySemaphore(device: Device, semaphore: Semaphore, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateEvent(device: Device, pCreateInfo: [*c]const EventCreateInfo, pAllocator: [*c]const AllocationCallbacks, pEvent: [*c]Event) Result;
pub extern fn vkDestroyEvent(device: Device, event: Event, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkGetEventStatus(device: Device, event: Event) Result;
pub extern fn vkSetEvent(device: Device, event: Event) Result;
pub extern fn vkResetEvent(device: Device, event: Event) Result;
pub extern fn vkCreateQueryPool(device: Device, pCreateInfo: [*c]const QueryPoolCreateInfo, pAllocator: [*c]const AllocationCallbacks, pQueryPool: [*c]QueryPool) Result;
pub extern fn vkDestroyQueryPool(device: Device, queryPool: QueryPool, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkGetQueryPoolResults(device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: ?*c_void, stride: DeviceSize, flags: QueryResultFlags) Result;
pub extern fn vkCreateBuffer(device: Device, pCreateInfo: [*c]const BufferCreateInfo, pAllocator: [*c]const AllocationCallbacks, pBuffer: [*c]Buffer) Result;
pub extern fn vkDestroyBuffer(device: Device, buffer: Buffer, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateBufferView(device: Device, pCreateInfo: [*c]const BufferViewCreateInfo, pAllocator: [*c]const AllocationCallbacks, pView: [*c]BufferView) Result;
pub extern fn vkDestroyBufferView(device: Device, bufferView: BufferView, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateImage(device: Device, pCreateInfo: [*c]const ImageCreateInfo, pAllocator: [*c]const AllocationCallbacks, pImage: [*c]Image) Result;
pub extern fn vkDestroyImage(device: Device, image: Image, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkGetImageSubresourceLayout(device: Device, image: Image, pSubresource: [*c]const ImageSubresource, pLayout: [*c]SubresourceLayout) void;
pub extern fn vkCreateImageView(device: Device, pCreateInfo: [*c]const ImageViewCreateInfo, pAllocator: [*c]const AllocationCallbacks, pView: [*c]ImageView) Result;
pub extern fn vkDestroyImageView(device: Device, imageView: ImageView, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateShaderModule(device: Device, pCreateInfo: [*c]const ShaderModuleCreateInfo, pAllocator: [*c]const AllocationCallbacks, pShaderModule: [*c]ShaderModule) Result;
pub extern fn vkDestroyShaderModule(device: Device, shaderModule: ShaderModule, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreatePipelineCache(device: Device, pCreateInfo: [*c]const PipelineCacheCreateInfo, pAllocator: [*c]const AllocationCallbacks, pPipelineCache: [*c]PipelineCache) Result;
pub extern fn vkDestroyPipelineCache(device: Device, pipelineCache: PipelineCache, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkGetPipelineCacheData(device: Device, pipelineCache: PipelineCache, pDataSize: [*c]usize, pData: ?*c_void) Result;
pub extern fn vkMergePipelineCaches(device: Device, dstCache: PipelineCache, srcCacheCount: u32, pSrcCaches: [*c]const PipelineCache) Result;
pub extern fn vkCreateGraphicsPipelines(device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [*c]const GraphicsPipelineCreateInfo, pAllocator: [*c]const AllocationCallbacks, pPipelines: [*c]Pipeline) Result;
pub extern fn vkCreateComputePipelines(device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [*c]const ComputePipelineCreateInfo, pAllocator: [*c]const AllocationCallbacks, pPipelines: [*c]Pipeline) Result;
pub extern fn vkDestroyPipeline(device: Device, pipeline: Pipeline, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreatePipelineLayout(device: Device, pCreateInfo: [*c]const PipelineLayoutCreateInfo, pAllocator: [*c]const AllocationCallbacks, pPipelineLayout: [*c]PipelineLayout) Result;
pub extern fn vkDestroyPipelineLayout(device: Device, pipelineLayout: PipelineLayout, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateSampler(device: Device, pCreateInfo: [*c]const SamplerCreateInfo, pAllocator: [*c]const AllocationCallbacks, pSampler: [*c]Sampler) Result;
pub extern fn vkDestroySampler(device: Device, sampler: Sampler, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateDescriptorSetLayout(device: Device, pCreateInfo: [*c]const DescriptorSetLayoutCreateInfo, pAllocator: [*c]const AllocationCallbacks, pSetLayout: [*c]DescriptorSetLayout) Result;
pub extern fn vkDestroyDescriptorSetLayout(device: Device, descriptorSetLayout: DescriptorSetLayout, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateDescriptorPool(device: Device, pCreateInfo: [*c]const DescriptorPoolCreateInfo, pAllocator: [*c]const AllocationCallbacks, pDescriptorPool: [*c]DescriptorPool) Result;
pub extern fn vkDestroyDescriptorPool(device: Device, descriptorPool: DescriptorPool, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkResetDescriptorPool(device: Device, descriptorPool: DescriptorPool, flags: DescriptorPoolResetFlags) Result;
pub extern fn vkAllocateDescriptorSets(device: Device, pAllocateInfo: [*c]const DescriptorSetAllocateInfo, pDescriptorSets: [*c]DescriptorSet) Result;
pub extern fn vkFreeDescriptorSets(device: Device, descriptorPool: DescriptorPool, descriptorSetCount: u32, pDescriptorSets: [*c]const DescriptorSet) Result;
pub extern fn vkUpdateDescriptorSets(device: Device, descriptorWriteCount: u32, pDescriptorWrites: [*c]const WriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: [*c]const CopyDescriptorSet) void;
pub extern fn vkCreateFramebuffer(device: Device, pCreateInfo: [*c]const FramebufferCreateInfo, pAllocator: [*c]const AllocationCallbacks, pFramebuffer: [*c]Framebuffer) Result;
pub extern fn vkDestroyFramebuffer(device: Device, framebuffer: Framebuffer, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateRenderPass(device: Device, pCreateInfo: [*c]const RenderPassCreateInfo, pAllocator: [*c]const AllocationCallbacks, pRenderPass: [*c]RenderPass) Result;
pub extern fn vkDestroyRenderPass(device: Device, renderPass: RenderPass, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkGetRenderAreaGranularity(device: Device, renderPass: RenderPass, pGranularity: [*c]Extent2D) void;
pub extern fn vkCreateCommandPool(device: Device, pCreateInfo: [*c]const CommandPoolCreateInfo, pAllocator: [*c]const AllocationCallbacks, pCommandPool: [*c]CommandPool) Result;
pub extern fn vkDestroyCommandPool(device: Device, commandPool: CommandPool, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkResetCommandPool(device: Device, commandPool: CommandPool, flags: CommandPoolResetFlags) Result;
pub extern fn vkAllocateCommandBuffers(device: Device, pAllocateInfo: [*c]const CommandBufferAllocateInfo, pCommandBuffers: [*c]CommandBuffer) Result;
pub extern fn vkFreeCommandBuffers(device: Device, commandPool: CommandPool, commandBufferCount: u32, pCommandBuffers: [*c]const CommandBuffer) void;
pub extern fn vkBeginCommandBuffer(commandBuffer: CommandBuffer, pBeginInfo: [*c]const CommandBufferBeginInfo) Result;
pub extern fn vkEndCommandBuffer(commandBuffer: CommandBuffer) Result;
pub extern fn vkResetCommandBuffer(commandBuffer: CommandBuffer, flags: CommandBufferResetFlags) Result;
pub extern fn vkCmdBindPipeline(commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline) void;
pub extern fn vkCmdSetViewport(commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: [*c]const Viewport) void;
pub extern fn vkCmdSetScissor(commandBuffer: CommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: [*c]const Rect2D) void;
pub extern fn vkCmdSetLineWidth(commandBuffer: CommandBuffer, lineWidth: f32) void;
pub extern fn vkCmdSetDepthBias(commandBuffer: CommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32) void;
pub extern fn vkCmdSetBlendConstants(commandBuffer: CommandBuffer, blendConstants: [*c]const f32) void;
pub extern fn vkCmdSetDepthBounds(commandBuffer: CommandBuffer, minDepthBounds: f32, maxDepthBounds: f32) void;
pub extern fn vkCmdSetStencilCompareMask(commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, compareMask: u32) void;
pub extern fn vkCmdSetStencilWriteMask(commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, writeMask: u32) void;
pub extern fn vkCmdSetStencilReference(commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, reference: u32) void;
pub extern fn vkCmdBindDescriptorSets(commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: [*c]const DescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: [*c]const u32) void;
pub extern fn vkCmdBindIndexBuffer(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, indexType: IndexType) void;
pub extern fn vkCmdBindVertexBuffers(commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [*c]const Buffer, pOffsets: [*c]const DeviceSize) void;
pub extern fn vkCmdDraw(commandBuffer: CommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32) void;
pub extern fn vkCmdDrawIndexed(commandBuffer: CommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32) void;
pub extern fn vkCmdDrawIndirect(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) void;
pub extern fn vkCmdDrawIndexedIndirect(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) void;
pub extern fn vkCmdDispatch(commandBuffer: CommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32) void;
pub extern fn vkCmdDispatchIndirect(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize) void;
pub extern fn vkCmdCopyBuffer(commandBuffer: CommandBuffer, srcBuffer: Buffer, dstBuffer: Buffer, regionCount: u32, pRegions: [*c]const BufferCopy) void;
pub extern fn vkCmdCopyImage(commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [*c]const ImageCopy) void;
pub extern fn vkCmdBlitImage(commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [*c]const ImageBlit, filter: Filter) void;
pub extern fn vkCmdCopyBufferToImage(commandBuffer: CommandBuffer, srcBuffer: Buffer, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [*c]const BufferImageCopy) void;
pub extern fn vkCmdCopyImageToBuffer(commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstBuffer: Buffer, regionCount: u32, pRegions: [*c]const BufferImageCopy) void;
pub extern fn vkCmdUpdateBuffer(commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, dataSize: DeviceSize, pData: ?*const c_void) void;
pub extern fn vkCmdFillBuffer(commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, size: DeviceSize, data: u32) void;
pub extern fn vkCmdClearColorImage(commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pColor: [*c]const ClearColorValue, rangeCount: u32, pRanges: [*c]const ImageSubresourceRange) void;
pub extern fn vkCmdClearDepthStencilImage(commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pDepthStencil: [*c]const ClearDepthStencilValue, rangeCount: u32, pRanges: [*c]const ImageSubresourceRange) void;
pub extern fn vkCmdClearAttachments(commandBuffer: CommandBuffer, attachmentCount: u32, pAttachments: [*c]const ClearAttachment, rectCount: u32, pRects: [*c]const ClearRect) void;
pub extern fn vkCmdResolveImage(commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [*c]const ImageResolve) void;
pub extern fn vkCmdSetEvent(commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags) void;
pub extern fn vkCmdResetEvent(commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags) void;
pub extern fn vkCmdWaitEvents(commandBuffer: CommandBuffer, eventCount: u32, pEvents: [*c]const Event, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: [*c]const MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: [*c]const BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: [*c]const ImageMemoryBarrier) void;
pub extern fn vkCmdPipelineBarrier(commandBuffer: CommandBuffer, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, dependencyFlags: DependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: [*c]const MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: [*c]const BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: [*c]const ImageMemoryBarrier) void;
pub extern fn vkCmdBeginQuery(commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags) void;
pub extern fn vkCmdEndQuery(commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32) void;
pub extern fn vkCmdResetQueryPool(commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32) void;
pub extern fn vkCmdWriteTimestamp(commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlagBits, queryPool: QueryPool, query: u32) void;
pub extern fn vkCmdCopyQueryPoolResults(commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dstBuffer: Buffer, dstOffset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags) void;
pub extern fn vkCmdPushConstants(commandBuffer: CommandBuffer, layout: PipelineLayout, stageFlags: ShaderStageFlags, offset: u32, size: u32, pValues: ?*const c_void) void;
pub extern fn vkCmdBeginRenderPass(commandBuffer: CommandBuffer, pRenderPassBegin: [*c]const RenderPassBeginInfo, contents: SubpassContents) void;
pub extern fn vkCmdNextSubpass(commandBuffer: CommandBuffer, contents: SubpassContents) void;
pub extern fn vkCmdEndRenderPass(commandBuffer: CommandBuffer) void;
pub extern fn vkCmdExecuteCommands(commandBuffer: CommandBuffer, commandBufferCount: u32, pCommandBuffers: [*c]const CommandBuffer) void;
pub const struct_SamplerYcbcrConversion_T = opaque {};
pub const SamplerYcbcrConversion = ?*struct_SamplerYcbcrConversion_T;
pub const struct_DescriptorUpdateTemplate_T = opaque {};
pub const DescriptorUpdateTemplate = ?*struct_DescriptorUpdateTemplate_T;
pub const POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = @enumToInt(enum_PointClippingBehavior.POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES);
pub const POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = @enumToInt(enum_PointClippingBehavior.POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY);
pub const POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = @enumToInt(enum_PointClippingBehavior.POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR);
pub const POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = @enumToInt(enum_PointClippingBehavior.POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR);
pub const POINT_CLIPPING_BEHAVIOR_MAX_ENUM = @enumToInt(enum_PointClippingBehavior.POINT_CLIPPING_BEHAVIOR_MAX_ENUM);
pub const enum_PointClippingBehavior = extern enum(c_int) {
POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = 0,
POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = 1,
POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 2147483647,
_,
};
pub const PointClippingBehavior = enum_PointClippingBehavior;
pub const TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = @enumToInt(enum_TessellationDomainOrigin.TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT);
pub const TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = @enumToInt(enum_TessellationDomainOrigin.TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT);
pub const TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = @enumToInt(enum_TessellationDomainOrigin.TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR);
pub const TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = @enumToInt(enum_TessellationDomainOrigin.TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR);
pub const TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = @enumToInt(enum_TessellationDomainOrigin.TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM);
pub const enum_TessellationDomainOrigin = extern enum(c_int) {
TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = 0,
TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = 1,
TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 2147483647,
_,
};
pub const TessellationDomainOrigin = enum_TessellationDomainOrigin;
pub const SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR);
pub const SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = @enumToInt(enum_SamplerYcbcrModelConversion.SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM);
pub const enum_SamplerYcbcrModelConversion = extern enum(c_int) {
SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = 0,
SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = 1,
SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = 2,
SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = 3,
SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = 4,
SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 2147483647,
_,
};
pub const SamplerYcbcrModelConversion = enum_SamplerYcbcrModelConversion;
pub const SAMPLER_YCBCR_RANGE_ITU_FULL = @enumToInt(enum_SamplerYcbcrRange.SAMPLER_YCBCR_RANGE_ITU_FULL);
pub const SAMPLER_YCBCR_RANGE_ITU_NARROW = @enumToInt(enum_SamplerYcbcrRange.SAMPLER_YCBCR_RANGE_ITU_NARROW);
pub const SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = @enumToInt(enum_SamplerYcbcrRange.SAMPLER_YCBCR_RANGE_ITU_FULL_KHR);
pub const SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = @enumToInt(enum_SamplerYcbcrRange.SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR);
pub const SAMPLER_YCBCR_RANGE_MAX_ENUM = @enumToInt(enum_SamplerYcbcrRange.SAMPLER_YCBCR_RANGE_MAX_ENUM);
pub const enum_SamplerYcbcrRange = extern enum(c_int) {
SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = 0,
SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = 1,
SAMPLER_YCBCR_RANGE_MAX_ENUM = 2147483647,
_,
};
pub const SamplerYcbcrRange = enum_SamplerYcbcrRange;
pub const CHROMA_LOCATION_COSITED_EVEN = @enumToInt(enum_ChromaLocation.CHROMA_LOCATION_COSITED_EVEN);
pub const CHROMA_LOCATION_MIDPOINT = @enumToInt(enum_ChromaLocation.CHROMA_LOCATION_MIDPOINT);
pub const CHROMA_LOCATION_COSITED_EVEN_KHR = @enumToInt(enum_ChromaLocation.CHROMA_LOCATION_COSITED_EVEN_KHR);
pub const CHROMA_LOCATION_MIDPOINT_KHR = @enumToInt(enum_ChromaLocation.CHROMA_LOCATION_MIDPOINT_KHR);
pub const CHROMA_LOCATION_MAX_ENUM = @enumToInt(enum_ChromaLocation.CHROMA_LOCATION_MAX_ENUM);
pub const enum_ChromaLocation = extern enum(c_int) {
CHROMA_LOCATION_COSITED_EVEN = 0,
CHROMA_LOCATION_MIDPOINT = 1,
CHROMA_LOCATION_COSITED_EVEN_KHR = 0,
CHROMA_LOCATION_MIDPOINT_KHR = 1,
CHROMA_LOCATION_MAX_ENUM = 2147483647,
_,
};
pub const ChromaLocation = enum_ChromaLocation;
pub const DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = @enumToInt(enum_DescriptorUpdateTemplateType.DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET);
pub const DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = @enumToInt(enum_DescriptorUpdateTemplateType.DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR);
pub const DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = @enumToInt(enum_DescriptorUpdateTemplateType.DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR);
pub const DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = @enumToInt(enum_DescriptorUpdateTemplateType.DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM);
pub const enum_DescriptorUpdateTemplateType = extern enum(c_int) {
DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0,
DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const DescriptorUpdateTemplateType = enum_DescriptorUpdateTemplateType;
pub const SUBGROUP_FEATURE_BASIC_BIT = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_BASIC_BIT);
pub const SUBGROUP_FEATURE_VOTE_BIT = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_VOTE_BIT);
pub const SUBGROUP_FEATURE_ARITHMETIC_BIT = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_ARITHMETIC_BIT);
pub const SUBGROUP_FEATURE_BALLOT_BIT = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_BALLOT_BIT);
pub const SUBGROUP_FEATURE_SHUFFLE_BIT = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_SHUFFLE_BIT);
pub const SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT);
pub const SUBGROUP_FEATURE_CLUSTERED_BIT = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_CLUSTERED_BIT);
pub const SUBGROUP_FEATURE_QUAD_BIT = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_QUAD_BIT);
pub const SUBGROUP_FEATURE_PARTITIONED_BIT_NV = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_PARTITIONED_BIT_NV);
pub const SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_SubgroupFeatureFlagBits.SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM);
pub const enum_SubgroupFeatureFlagBits = extern enum(c_int) {
SUBGROUP_FEATURE_BASIC_BIT = 1,
SUBGROUP_FEATURE_VOTE_BIT = 2,
SUBGROUP_FEATURE_ARITHMETIC_BIT = 4,
SUBGROUP_FEATURE_BALLOT_BIT = 8,
SUBGROUP_FEATURE_SHUFFLE_BIT = 16,
SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 32,
SUBGROUP_FEATURE_CLUSTERED_BIT = 64,
SUBGROUP_FEATURE_QUAD_BIT = 128,
SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 256,
SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const SubgroupFeatureFlagBits = enum_SubgroupFeatureFlagBits;
pub const SubgroupFeatureFlags = Flags;
pub const PEER_MEMORY_FEATURE_COPY_SRC_BIT = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_COPY_SRC_BIT);
pub const PEER_MEMORY_FEATURE_COPY_DST_BIT = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_COPY_DST_BIT);
pub const PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_GENERIC_SRC_BIT);
pub const PEER_MEMORY_FEATURE_GENERIC_DST_BIT = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_GENERIC_DST_BIT);
pub const PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR);
pub const PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR);
pub const PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR);
pub const PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR);
pub const PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_PeerMemoryFeatureFlagBits.PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM);
pub const enum_PeerMemoryFeatureFlagBits = extern enum(c_int) {
PEER_MEMORY_FEATURE_COPY_SRC_BIT = 1,
PEER_MEMORY_FEATURE_COPY_DST_BIT = 2,
PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 4,
PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 8,
PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = 1,
PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = 2,
PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = 4,
PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = 8,
PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const PeerMemoryFeatureFlagBits = enum_PeerMemoryFeatureFlagBits;
pub const PeerMemoryFeatureFlags = Flags;
pub const MEMORY_ALLOCATE_DEVICE_MASK_BIT = @enumToInt(enum_MemoryAllocateFlagBits.MEMORY_ALLOCATE_DEVICE_MASK_BIT);
pub const MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = @enumToInt(enum_MemoryAllocateFlagBits.MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT);
pub const MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = @enumToInt(enum_MemoryAllocateFlagBits.MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT);
pub const MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = @enumToInt(enum_MemoryAllocateFlagBits.MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR);
pub const MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = @enumToInt(enum_MemoryAllocateFlagBits.MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR);
pub const MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = @enumToInt(enum_MemoryAllocateFlagBits.MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR);
pub const MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_MemoryAllocateFlagBits.MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM);
pub const enum_MemoryAllocateFlagBits = extern enum(c_int) {
MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1,
MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 2,
MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 4,
MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = 1,
MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = 2,
MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 4,
MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const MemoryAllocateFlagBits = enum_MemoryAllocateFlagBits;
pub const MemoryAllocateFlags = Flags;
pub const CommandPoolTrimFlags = Flags;
pub const DescriptorUpdateTemplateCreateFlags = Flags;
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ExternalMemoryHandleTypeFlagBits.EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM);
pub const enum_ExternalMemoryHandleTypeFlagBits = extern enum(c_int) {
EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 8,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 16,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 32,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 64,
EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 512,
EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 1024,
EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 128,
EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 256,
EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 1,
EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 2,
EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 4,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 8,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 16,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 32,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 64,
EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ExternalMemoryHandleTypeFlagBits = enum_ExternalMemoryHandleTypeFlagBits;
pub const ExternalMemoryHandleTypeFlags = Flags;
pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = @enumToInt(enum_ExternalMemoryFeatureFlagBits.EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT);
pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = @enumToInt(enum_ExternalMemoryFeatureFlagBits.EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT);
pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = @enumToInt(enum_ExternalMemoryFeatureFlagBits.EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT);
pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = @enumToInt(enum_ExternalMemoryFeatureFlagBits.EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR);
pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = @enumToInt(enum_ExternalMemoryFeatureFlagBits.EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR);
pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = @enumToInt(enum_ExternalMemoryFeatureFlagBits.EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR);
pub const EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ExternalMemoryFeatureFlagBits.EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM);
pub const enum_ExternalMemoryFeatureFlagBits = extern enum(c_int) {
EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1,
EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2,
EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4,
EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 1,
EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 2,
EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 4,
EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ExternalMemoryFeatureFlagBits = enum_ExternalMemoryFeatureFlagBits;
pub const ExternalMemoryFeatureFlags = Flags;
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT);
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT);
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT);
pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT);
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR);
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR);
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR);
pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR);
pub const EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ExternalFenceHandleTypeFlagBits.EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM);
pub const enum_ExternalFenceHandleTypeFlagBits = extern enum(c_int) {
EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4,
EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 8,
EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 1,
EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 2,
EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 4,
EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 8,
EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ExternalFenceHandleTypeFlagBits = enum_ExternalFenceHandleTypeFlagBits;
pub const ExternalFenceHandleTypeFlags = Flags;
pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = @enumToInt(enum_ExternalFenceFeatureFlagBits.EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT);
pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = @enumToInt(enum_ExternalFenceFeatureFlagBits.EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT);
pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = @enumToInt(enum_ExternalFenceFeatureFlagBits.EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR);
pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = @enumToInt(enum_ExternalFenceFeatureFlagBits.EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR);
pub const EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ExternalFenceFeatureFlagBits.EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM);
pub const enum_ExternalFenceFeatureFlagBits = extern enum(c_int) {
EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1,
EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2,
EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 1,
EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 2,
EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ExternalFenceFeatureFlagBits = enum_ExternalFenceFeatureFlagBits;
pub const ExternalFenceFeatureFlags = Flags;
pub const FENCE_IMPORT_TEMPORARY_BIT = @enumToInt(enum_FenceImportFlagBits.FENCE_IMPORT_TEMPORARY_BIT);
pub const FENCE_IMPORT_TEMPORARY_BIT_KHR = @enumToInt(enum_FenceImportFlagBits.FENCE_IMPORT_TEMPORARY_BIT_KHR);
pub const FENCE_IMPORT_FLAG_BITS_MAX_ENUM = @enumToInt(enum_FenceImportFlagBits.FENCE_IMPORT_FLAG_BITS_MAX_ENUM);
pub const enum_FenceImportFlagBits = extern enum(c_int) {
FENCE_IMPORT_TEMPORARY_BIT = 1,
FENCE_IMPORT_TEMPORARY_BIT_KHR = 1,
FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const FenceImportFlagBits = enum_FenceImportFlagBits;
pub const FenceImportFlags = Flags;
pub const SEMAPHORE_IMPORT_TEMPORARY_BIT = @enumToInt(enum_SemaphoreImportFlagBits.SEMAPHORE_IMPORT_TEMPORARY_BIT);
pub const SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = @enumToInt(enum_SemaphoreImportFlagBits.SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR);
pub const SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = @enumToInt(enum_SemaphoreImportFlagBits.SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM);
pub const enum_SemaphoreImportFlagBits = extern enum(c_int) {
SEMAPHORE_IMPORT_TEMPORARY_BIT = 1,
SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 1,
SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const SemaphoreImportFlagBits = enum_SemaphoreImportFlagBits;
pub const SemaphoreImportFlags = Flags;
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR);
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ExternalSemaphoreHandleTypeFlagBits.EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM);
pub const enum_ExternalSemaphoreHandleTypeFlagBits = extern enum(c_int) {
EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 8,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = 8,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 1,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 2,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 4,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 8,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 16,
EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ExternalSemaphoreHandleTypeFlagBits = enum_ExternalSemaphoreHandleTypeFlagBits;
pub const ExternalSemaphoreHandleTypeFlags = Flags;
pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = @enumToInt(enum_ExternalSemaphoreFeatureFlagBits.EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT);
pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = @enumToInt(enum_ExternalSemaphoreFeatureFlagBits.EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT);
pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = @enumToInt(enum_ExternalSemaphoreFeatureFlagBits.EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR);
pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = @enumToInt(enum_ExternalSemaphoreFeatureFlagBits.EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR);
pub const EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ExternalSemaphoreFeatureFlagBits.EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM);
pub const enum_ExternalSemaphoreFeatureFlagBits = extern enum(c_int) {
EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1,
EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2,
EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 1,
EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 2,
EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ExternalSemaphoreFeatureFlagBits = enum_ExternalSemaphoreFeatureFlagBits;
pub const ExternalSemaphoreFeatureFlags = Flags;
pub const struct_PhysicalDeviceSubgroupProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
subgroupSize: u32,
supportedStages: ShaderStageFlags,
supportedOperations: SubgroupFeatureFlags,
quadOperationsInAllStages: Bool32,
};
pub const PhysicalDeviceSubgroupProperties = struct_PhysicalDeviceSubgroupProperties;
pub const struct_BindBufferMemoryInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
buffer: Buffer,
memory: DeviceMemory,
memoryOffset: DeviceSize,
};
pub const BindBufferMemoryInfo = struct_BindBufferMemoryInfo;
pub const struct_BindImageMemoryInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
image: Image,
memory: DeviceMemory,
memoryOffset: DeviceSize,
};
pub const BindImageMemoryInfo = struct_BindImageMemoryInfo;
pub const struct_PhysicalDevice16BitStorageFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
storageBuffer16BitAccess: Bool32,
uniformAndStorageBuffer16BitAccess: Bool32,
storagePushConstant16: Bool32,
storageInputOutput16: Bool32,
};
pub const PhysicalDevice16BitStorageFeatures = struct_PhysicalDevice16BitStorageFeatures;
pub const struct_MemoryDedicatedRequirements = extern struct {
sType: StructureType,
pNext: ?*c_void,
prefersDedicatedAllocation: Bool32,
requiresDedicatedAllocation: Bool32,
};
pub const MemoryDedicatedRequirements = struct_MemoryDedicatedRequirements;
pub const struct_MemoryDedicatedAllocateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
image: Image,
buffer: Buffer,
};
pub const MemoryDedicatedAllocateInfo = struct_MemoryDedicatedAllocateInfo;
pub const struct_MemoryAllocateFlagsInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: MemoryAllocateFlags,
deviceMask: u32,
};
pub const MemoryAllocateFlagsInfo = struct_MemoryAllocateFlagsInfo;
pub const struct_DeviceGroupRenderPassBeginInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
deviceMask: u32,
deviceRenderAreaCount: u32,
pDeviceRenderAreas: [*c]const Rect2D,
};
pub const DeviceGroupRenderPassBeginInfo = struct_DeviceGroupRenderPassBeginInfo;
pub const struct_DeviceGroupCommandBufferBeginInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
deviceMask: u32,
};
pub const DeviceGroupCommandBufferBeginInfo = struct_DeviceGroupCommandBufferBeginInfo;
pub const struct_DeviceGroupSubmitInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
waitSemaphoreCount: u32,
pWaitSemaphoreDeviceIndices: [*c]const u32,
commandBufferCount: u32,
pCommandBufferDeviceMasks: [*c]const u32,
signalSemaphoreCount: u32,
pSignalSemaphoreDeviceIndices: [*c]const u32,
};
pub const DeviceGroupSubmitInfo = struct_DeviceGroupSubmitInfo;
pub const struct_DeviceGroupBindSparseInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
resourceDeviceIndex: u32,
memoryDeviceIndex: u32,
};
pub const DeviceGroupBindSparseInfo = struct_DeviceGroupBindSparseInfo;
pub const struct_BindBufferMemoryDeviceGroupInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
deviceIndexCount: u32,
pDeviceIndices: [*c]const u32,
};
pub const BindBufferMemoryDeviceGroupInfo = struct_BindBufferMemoryDeviceGroupInfo;
pub const struct_BindImageMemoryDeviceGroupInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
deviceIndexCount: u32,
pDeviceIndices: [*c]const u32,
splitInstanceBindRegionCount: u32,
pSplitInstanceBindRegions: [*c]const Rect2D,
};
pub const BindImageMemoryDeviceGroupInfo = struct_BindImageMemoryDeviceGroupInfo;
pub const struct_PhysicalDeviceGroupProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
physicalDeviceCount: u32,
physicalDevices: [32]PhysicalDevice,
subsetAllocation: Bool32,
};
pub const PhysicalDeviceGroupProperties = struct_PhysicalDeviceGroupProperties;
pub const struct_DeviceGroupDeviceCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
physicalDeviceCount: u32,
pPhysicalDevices: [*c]const PhysicalDevice,
};
pub const DeviceGroupDeviceCreateInfo = struct_DeviceGroupDeviceCreateInfo;
pub const struct_BufferMemoryRequirementsInfo2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
buffer: Buffer,
};
pub const BufferMemoryRequirementsInfo2 = struct_BufferMemoryRequirementsInfo2;
pub const struct_ImageMemoryRequirementsInfo2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
image: Image,
};
pub const ImageMemoryRequirementsInfo2 = struct_ImageMemoryRequirementsInfo2;
pub const struct_ImageSparseMemoryRequirementsInfo2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
image: Image,
};
pub const ImageSparseMemoryRequirementsInfo2 = struct_ImageSparseMemoryRequirementsInfo2;
pub const struct_MemoryRequirements2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
memoryRequirements: MemoryRequirements,
};
pub const MemoryRequirements2 = struct_MemoryRequirements2;
pub const struct_SparseImageMemoryRequirements2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
memoryRequirements: SparseImageMemoryRequirements,
};
pub const SparseImageMemoryRequirements2 = struct_SparseImageMemoryRequirements2;
pub const struct_PhysicalDeviceFeatures2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
features: PhysicalDeviceFeatures,
};
pub const PhysicalDeviceFeatures2 = struct_PhysicalDeviceFeatures2;
pub const struct_PhysicalDeviceProperties2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
properties: PhysicalDeviceProperties,
};
pub const PhysicalDeviceProperties2 = struct_PhysicalDeviceProperties2;
pub const struct_FormatProperties2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
formatProperties: FormatProperties,
};
pub const FormatProperties2 = struct_FormatProperties2;
pub const struct_ImageFormatProperties2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
imageFormatProperties: ImageFormatProperties,
};
pub const ImageFormatProperties2 = struct_ImageFormatProperties2;
pub const struct_PhysicalDeviceImageFormatInfo2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
format: Format,
type: ImageType,
tiling: ImageTiling,
usage: ImageUsageFlags,
flags: ImageCreateFlags,
};
pub const PhysicalDeviceImageFormatInfo2 = struct_PhysicalDeviceImageFormatInfo2;
pub const struct_QueueFamilyProperties2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
queueFamilyProperties: QueueFamilyProperties,
};
pub const QueueFamilyProperties2 = struct_QueueFamilyProperties2;
pub const struct_PhysicalDeviceMemoryProperties2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
memoryProperties: PhysicalDeviceMemoryProperties,
};
pub const PhysicalDeviceMemoryProperties2 = struct_PhysicalDeviceMemoryProperties2;
pub const struct_SparseImageFormatProperties2 = extern struct {
sType: StructureType,
pNext: ?*c_void,
properties: SparseImageFormatProperties,
};
pub const SparseImageFormatProperties2 = struct_SparseImageFormatProperties2;
pub const struct_PhysicalDeviceSparseImageFormatInfo2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
format: Format,
type: ImageType,
samples: SampleCountFlagBits,
usage: ImageUsageFlags,
tiling: ImageTiling,
};
pub const PhysicalDeviceSparseImageFormatInfo2 = struct_PhysicalDeviceSparseImageFormatInfo2;
pub const struct_PhysicalDevicePointClippingProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
pointClippingBehavior: PointClippingBehavior,
};
pub const PhysicalDevicePointClippingProperties = struct_PhysicalDevicePointClippingProperties;
pub const struct_InputAttachmentAspectReference = extern struct {
subpass: u32,
inputAttachmentIndex: u32,
aspectMask: ImageAspectFlags,
};
pub const InputAttachmentAspectReference = struct_InputAttachmentAspectReference;
pub const struct_RenderPassInputAttachmentAspectCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
aspectReferenceCount: u32,
pAspectReferences: [*c]const InputAttachmentAspectReference,
};
pub const RenderPassInputAttachmentAspectCreateInfo = struct_RenderPassInputAttachmentAspectCreateInfo;
pub const struct_ImageViewUsageCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
usage: ImageUsageFlags,
};
pub const ImageViewUsageCreateInfo = struct_ImageViewUsageCreateInfo;
pub const struct_PipelineTessellationDomainOriginStateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
domainOrigin: TessellationDomainOrigin,
};
pub const PipelineTessellationDomainOriginStateCreateInfo = struct_PipelineTessellationDomainOriginStateCreateInfo;
pub const struct_RenderPassMultiviewCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
subpassCount: u32,
pViewMasks: [*c]const u32,
dependencyCount: u32,
pViewOffsets: [*c]const i32,
correlationMaskCount: u32,
pCorrelationMasks: [*c]const u32,
};
pub const RenderPassMultiviewCreateInfo = struct_RenderPassMultiviewCreateInfo;
pub const struct_PhysicalDeviceMultiviewFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
multiview: Bool32,
multiviewGeometryShader: Bool32,
multiviewTessellationShader: Bool32,
};
pub const PhysicalDeviceMultiviewFeatures = struct_PhysicalDeviceMultiviewFeatures;
pub const struct_PhysicalDeviceMultiviewProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxMultiviewViewCount: u32,
maxMultiviewInstanceIndex: u32,
};
pub const PhysicalDeviceMultiviewProperties = struct_PhysicalDeviceMultiviewProperties;
pub const struct_PhysicalDeviceVariablePointersFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
variablePointersStorageBuffer: Bool32,
variablePointers: Bool32,
};
pub const PhysicalDeviceVariablePointersFeatures = struct_PhysicalDeviceVariablePointersFeatures;
pub const PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
pub const struct_PhysicalDeviceProtectedMemoryFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
protectedMemory: Bool32,
};
pub const PhysicalDeviceProtectedMemoryFeatures = struct_PhysicalDeviceProtectedMemoryFeatures;
pub const struct_PhysicalDeviceProtectedMemoryProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
protectedNoFault: Bool32,
};
pub const PhysicalDeviceProtectedMemoryProperties = struct_PhysicalDeviceProtectedMemoryProperties;
pub const struct_DeviceQueueInfo2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DeviceQueueCreateFlags,
queueFamilyIndex: u32,
queueIndex: u32,
};
pub const DeviceQueueInfo2 = struct_DeviceQueueInfo2;
pub const struct_ProtectedSubmitInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
protectedSubmit: Bool32,
};
pub const ProtectedSubmitInfo = struct_ProtectedSubmitInfo;
pub const struct_SamplerYcbcrConversionCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
format: Format,
ycbcrModel: SamplerYcbcrModelConversion,
ycbcrRange: SamplerYcbcrRange,
components: ComponentMapping = ComponentMapping{},
xChromaOffset: ChromaLocation,
yChromaOffset: ChromaLocation,
chromaFilter: Filter,
forceExplicitReconstruction: Bool32,
};
pub const SamplerYcbcrConversionCreateInfo = struct_SamplerYcbcrConversionCreateInfo;
pub const struct_SamplerYcbcrConversionInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
conversion: SamplerYcbcrConversion,
};
pub const SamplerYcbcrConversionInfo = struct_SamplerYcbcrConversionInfo;
pub const struct_BindImagePlaneMemoryInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
planeAspect: ImageAspectFlagBits,
};
pub const BindImagePlaneMemoryInfo = struct_BindImagePlaneMemoryInfo;
pub const struct_ImagePlaneMemoryRequirementsInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
planeAspect: ImageAspectFlagBits,
};
pub const ImagePlaneMemoryRequirementsInfo = struct_ImagePlaneMemoryRequirementsInfo;
pub const struct_PhysicalDeviceSamplerYcbcrConversionFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
samplerYcbcrConversion: Bool32,
};
pub const PhysicalDeviceSamplerYcbcrConversionFeatures = struct_PhysicalDeviceSamplerYcbcrConversionFeatures;
pub const struct_SamplerYcbcrConversionImageFormatProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
combinedImageSamplerDescriptorCount: u32,
};
pub const SamplerYcbcrConversionImageFormatProperties = struct_SamplerYcbcrConversionImageFormatProperties;
pub const struct_DescriptorUpdateTemplateEntry = extern struct {
dstBinding: u32,
dstArrayElement: u32,
descriptorCount: u32,
descriptorType: DescriptorType,
offset: usize,
stride: usize,
};
pub const DescriptorUpdateTemplateEntry = struct_DescriptorUpdateTemplateEntry;
pub const struct_DescriptorUpdateTemplateCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DescriptorUpdateTemplateCreateFlags,
descriptorUpdateEntryCount: u32,
pDescriptorUpdateEntries: [*c]const DescriptorUpdateTemplateEntry,
templateType: DescriptorUpdateTemplateType,
descriptorSetLayout: DescriptorSetLayout,
pipelineBindPoint: PipelineBindPoint,
pipelineLayout: PipelineLayout,
set: u32,
};
pub const DescriptorUpdateTemplateCreateInfo = struct_DescriptorUpdateTemplateCreateInfo;
pub const struct_ExternalMemoryProperties = extern struct {
externalMemoryFeatures: ExternalMemoryFeatureFlags,
exportFromImportedHandleTypes: ExternalMemoryHandleTypeFlags,
compatibleHandleTypes: ExternalMemoryHandleTypeFlags,
};
pub const ExternalMemoryProperties = struct_ExternalMemoryProperties;
pub const struct_PhysicalDeviceExternalImageFormatInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleType: ExternalMemoryHandleTypeFlagBits,
};
pub const PhysicalDeviceExternalImageFormatInfo = struct_PhysicalDeviceExternalImageFormatInfo;
pub const struct_ExternalImageFormatProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
externalMemoryProperties: ExternalMemoryProperties,
};
pub const ExternalImageFormatProperties = struct_ExternalImageFormatProperties;
pub const struct_PhysicalDeviceExternalBufferInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: BufferCreateFlags,
usage: BufferUsageFlags,
handleType: ExternalMemoryHandleTypeFlagBits,
};
pub const PhysicalDeviceExternalBufferInfo = struct_PhysicalDeviceExternalBufferInfo;
pub const struct_ExternalBufferProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
externalMemoryProperties: ExternalMemoryProperties,
};
pub const ExternalBufferProperties = struct_ExternalBufferProperties;
pub const struct_PhysicalDeviceIDProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
deviceUUID: [16]u8,
driverUUID: [16]u8,
deviceLUID: [8]u8,
deviceNodeMask: u32,
deviceLUIDValid: Bool32,
};
pub const PhysicalDeviceIDProperties = struct_PhysicalDeviceIDProperties;
pub const struct_ExternalMemoryImageCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleTypes: ExternalMemoryHandleTypeFlags,
};
pub const ExternalMemoryImageCreateInfo = struct_ExternalMemoryImageCreateInfo;
pub const struct_ExternalMemoryBufferCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleTypes: ExternalMemoryHandleTypeFlags,
};
pub const ExternalMemoryBufferCreateInfo = struct_ExternalMemoryBufferCreateInfo;
pub const struct_ExportMemoryAllocateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleTypes: ExternalMemoryHandleTypeFlags,
};
pub const ExportMemoryAllocateInfo = struct_ExportMemoryAllocateInfo;
pub const struct_PhysicalDeviceExternalFenceInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleType: ExternalFenceHandleTypeFlagBits,
};
pub const PhysicalDeviceExternalFenceInfo = struct_PhysicalDeviceExternalFenceInfo;
pub const struct_ExternalFenceProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
exportFromImportedHandleTypes: ExternalFenceHandleTypeFlags,
compatibleHandleTypes: ExternalFenceHandleTypeFlags,
externalFenceFeatures: ExternalFenceFeatureFlags,
};
pub const ExternalFenceProperties = struct_ExternalFenceProperties;
pub const struct_ExportFenceCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleTypes: ExternalFenceHandleTypeFlags,
};
pub const ExportFenceCreateInfo = struct_ExportFenceCreateInfo;
pub const struct_ExportSemaphoreCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleTypes: ExternalSemaphoreHandleTypeFlags,
};
pub const ExportSemaphoreCreateInfo = struct_ExportSemaphoreCreateInfo;
pub const struct_PhysicalDeviceExternalSemaphoreInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleType: ExternalSemaphoreHandleTypeFlagBits,
};
pub const PhysicalDeviceExternalSemaphoreInfo = struct_PhysicalDeviceExternalSemaphoreInfo;
pub const struct_ExternalSemaphoreProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
exportFromImportedHandleTypes: ExternalSemaphoreHandleTypeFlags,
compatibleHandleTypes: ExternalSemaphoreHandleTypeFlags,
externalSemaphoreFeatures: ExternalSemaphoreFeatureFlags,
};
pub const ExternalSemaphoreProperties = struct_ExternalSemaphoreProperties;
pub const struct_PhysicalDeviceMaintenance3Properties = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxPerSetDescriptors: u32,
maxMemoryAllocationSize: DeviceSize,
};
pub const PhysicalDeviceMaintenance3Properties = struct_PhysicalDeviceMaintenance3Properties;
pub const struct_DescriptorSetLayoutSupport = extern struct {
sType: StructureType,
pNext: ?*c_void,
supported: Bool32,
};
pub const DescriptorSetLayoutSupport = struct_DescriptorSetLayoutSupport;
pub const struct_PhysicalDeviceShaderDrawParametersFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderDrawParameters: Bool32,
};
pub const PhysicalDeviceShaderDrawParametersFeatures = struct_PhysicalDeviceShaderDrawParametersFeatures;
pub const PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
pub const PFN_vkEnumerateInstanceVersion = ?fn ([*c]u32) callconv(.C) Result;
pub const PFN_vkBindBufferMemory2 = ?fn (Device, u32, [*c]const BindBufferMemoryInfo) callconv(.C) Result;
pub const PFN_vkBindImageMemory2 = ?fn (Device, u32, [*c]const BindImageMemoryInfo) callconv(.C) Result;
pub const PFN_vkGetDeviceGroupPeerMemoryFeatures = ?fn (Device, u32, u32, u32, [*c]PeerMemoryFeatureFlags) callconv(.C) void;
pub const PFN_vkCmdSetDeviceMask = ?fn (CommandBuffer, u32) callconv(.C) void;
pub const PFN_vkCmdDispatchBase = ?fn (CommandBuffer, u32, u32, u32, u32, u32, u32) callconv(.C) void;
pub const PFN_vkEnumeratePhysicalDeviceGroups = ?fn (Instance, [*c]u32, [*c]PhysicalDeviceGroupProperties) callconv(.C) Result;
pub const PFN_vkGetImageMemoryRequirements2 = ?fn (Device, [*c]const ImageMemoryRequirementsInfo2, [*c]MemoryRequirements2) callconv(.C) void;
pub const PFN_vkGetBufferMemoryRequirements2 = ?fn (Device, [*c]const BufferMemoryRequirementsInfo2, [*c]MemoryRequirements2) callconv(.C) void;
pub const PFN_vkGetImageSparseMemoryRequirements2 = ?fn (Device, [*c]const ImageSparseMemoryRequirementsInfo2, [*c]u32, [*c]SparseImageMemoryRequirements2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceFeatures2 = ?fn (PhysicalDevice, [*c]PhysicalDeviceFeatures2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceProperties2 = ?fn (PhysicalDevice, [*c]PhysicalDeviceProperties2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceFormatProperties2 = ?fn (PhysicalDevice, Format, [*c]FormatProperties2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceImageFormatProperties2 = ?fn (PhysicalDevice, [*c]const PhysicalDeviceImageFormatInfo2, [*c]ImageFormatProperties2) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = ?fn (PhysicalDevice, [*c]u32, [*c]QueueFamilyProperties2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceMemoryProperties2 = ?fn (PhysicalDevice, [*c]PhysicalDeviceMemoryProperties2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = ?fn (PhysicalDevice, [*c]const PhysicalDeviceSparseImageFormatInfo2, [*c]u32, [*c]SparseImageFormatProperties2) callconv(.C) void;
pub const PFN_vkTrimCommandPool = ?fn (Device, CommandPool, CommandPoolTrimFlags) callconv(.C) void;
pub const PFN_vkGetDeviceQueue2 = ?fn (Device, [*c]const DeviceQueueInfo2, [*c]Queue) callconv(.C) void;
pub const PFN_vkCreateSamplerYcbcrConversion = ?fn (Device, [*c]const SamplerYcbcrConversionCreateInfo, [*c]const AllocationCallbacks, [*c]SamplerYcbcrConversion) callconv(.C) Result;
pub const PFN_vkDestroySamplerYcbcrConversion = ?fn (Device, SamplerYcbcrConversion, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkCreateDescriptorUpdateTemplate = ?fn (Device, [*c]const DescriptorUpdateTemplateCreateInfo, [*c]const AllocationCallbacks, [*c]DescriptorUpdateTemplate) callconv(.C) Result;
pub const PFN_vkDestroyDescriptorUpdateTemplate = ?fn (Device, DescriptorUpdateTemplate, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkUpdateDescriptorSetWithTemplate = ?fn (Device, DescriptorSet, DescriptorUpdateTemplate, ?*const c_void) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceExternalBufferProperties = ?fn (PhysicalDevice, [*c]const PhysicalDeviceExternalBufferInfo, [*c]ExternalBufferProperties) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceExternalFenceProperties = ?fn (PhysicalDevice, [*c]const PhysicalDeviceExternalFenceInfo, [*c]ExternalFenceProperties) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = ?fn (PhysicalDevice, [*c]const PhysicalDeviceExternalSemaphoreInfo, [*c]ExternalSemaphoreProperties) callconv(.C) void;
pub const PFN_vkGetDescriptorSetLayoutSupport = ?fn (Device, [*c]const DescriptorSetLayoutCreateInfo, [*c]DescriptorSetLayoutSupport) callconv(.C) void;
pub extern fn vkEnumerateInstanceVersion(pApiVersion: [*c]u32) Result;
pub extern fn vkBindBufferMemory2(device: Device, bindInfoCount: u32, pBindInfos: [*c]const BindBufferMemoryInfo) Result;
pub extern fn vkBindImageMemory2(device: Device, bindInfoCount: u32, pBindInfos: [*c]const BindImageMemoryInfo) Result;
pub extern fn vkGetDeviceGroupPeerMemoryFeatures(device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: [*c]PeerMemoryFeatureFlags) void;
pub extern fn vkCmdSetDeviceMask(commandBuffer: CommandBuffer, deviceMask: u32) void;
pub extern fn vkCmdDispatchBase(commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32) void;
pub extern fn vkEnumeratePhysicalDeviceGroups(instance: Instance, pPhysicalDeviceGroupCount: [*c]u32, pPhysicalDeviceGroupProperties: [*c]PhysicalDeviceGroupProperties) Result;
pub extern fn vkGetImageMemoryRequirements2(device: Device, pInfo: [*c]const ImageMemoryRequirementsInfo2, pMemoryRequirements: [*c]MemoryRequirements2) void;
pub extern fn vkGetBufferMemoryRequirements2(device: Device, pInfo: [*c]const BufferMemoryRequirementsInfo2, pMemoryRequirements: [*c]MemoryRequirements2) void;
pub extern fn vkGetImageSparseMemoryRequirements2(device: Device, pInfo: [*c]const ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: [*c]u32, pSparseMemoryRequirements: [*c]SparseImageMemoryRequirements2) void;
pub extern fn vkGetPhysicalDeviceFeatures2(physicalDevice: PhysicalDevice, pFeatures: [*c]PhysicalDeviceFeatures2) void;
pub extern fn vkGetPhysicalDeviceProperties2(physicalDevice: PhysicalDevice, pProperties: [*c]PhysicalDeviceProperties2) void;
pub extern fn vkGetPhysicalDeviceFormatProperties2(physicalDevice: PhysicalDevice, format: Format, pFormatProperties: [*c]FormatProperties2) void;
pub extern fn vkGetPhysicalDeviceImageFormatProperties2(physicalDevice: PhysicalDevice, pImageFormatInfo: [*c]const PhysicalDeviceImageFormatInfo2, pImageFormatProperties: [*c]ImageFormatProperties2) Result;
pub extern fn vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: [*c]u32, pQueueFamilyProperties: [*c]QueueFamilyProperties2) void;
pub extern fn vkGetPhysicalDeviceMemoryProperties2(physicalDevice: PhysicalDevice, pMemoryProperties: [*c]PhysicalDeviceMemoryProperties2) void;
pub extern fn vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice: PhysicalDevice, pFormatInfo: [*c]const PhysicalDeviceSparseImageFormatInfo2, pPropertyCount: [*c]u32, pProperties: [*c]SparseImageFormatProperties2) void;
pub extern fn vkTrimCommandPool(device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags) void;
pub extern fn vkGetDeviceQueue2(device: Device, pQueueInfo: [*c]const DeviceQueueInfo2, pQueue: [*c]Queue) void;
pub extern fn vkCreateSamplerYcbcrConversion(device: Device, pCreateInfo: [*c]const SamplerYcbcrConversionCreateInfo, pAllocator: [*c]const AllocationCallbacks, pYcbcrConversion: [*c]SamplerYcbcrConversion) Result;
pub extern fn vkDestroySamplerYcbcrConversion(device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkCreateDescriptorUpdateTemplate(device: Device, pCreateInfo: [*c]const DescriptorUpdateTemplateCreateInfo, pAllocator: [*c]const AllocationCallbacks, pDescriptorUpdateTemplate: [*c]DescriptorUpdateTemplate) Result;
pub extern fn vkDestroyDescriptorUpdateTemplate(device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkUpdateDescriptorSetWithTemplate(device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: ?*const c_void) void;
pub extern fn vkGetPhysicalDeviceExternalBufferProperties(physicalDevice: PhysicalDevice, pExternalBufferInfo: [*c]const PhysicalDeviceExternalBufferInfo, pExternalBufferProperties: [*c]ExternalBufferProperties) void;
pub extern fn vkGetPhysicalDeviceExternalFenceProperties(physicalDevice: PhysicalDevice, pExternalFenceInfo: [*c]const PhysicalDeviceExternalFenceInfo, pExternalFenceProperties: [*c]ExternalFenceProperties) void;
pub extern fn vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice: PhysicalDevice, pExternalSemaphoreInfo: [*c]const PhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: [*c]ExternalSemaphoreProperties) void;
pub extern fn vkGetDescriptorSetLayoutSupport(device: Device, pCreateInfo: [*c]const DescriptorSetLayoutCreateInfo, pSupport: [*c]DescriptorSetLayoutSupport) void;
pub const DRIVER_ID_AMD_PROPRIETARY = @enumToInt(enum_DriverId.DRIVER_ID_AMD_PROPRIETARY);
pub const DRIVER_ID_AMD_OPEN_SOURCE = @enumToInt(enum_DriverId.DRIVER_ID_AMD_OPEN_SOURCE);
pub const DRIVER_ID_MESA_RADV = @enumToInt(enum_DriverId.DRIVER_ID_MESA_RADV);
pub const DRIVER_ID_NVIDIA_PROPRIETARY = @enumToInt(enum_DriverId.DRIVER_ID_NVIDIA_PROPRIETARY);
pub const DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = @enumToInt(enum_DriverId.DRIVER_ID_INTEL_PROPRIETARY_WINDOWS);
pub const DRIVER_ID_INTEL_OPEN_SOURCE_MESA = @enumToInt(enum_DriverId.DRIVER_ID_INTEL_OPEN_SOURCE_MESA);
pub const DRIVER_ID_IMAGINATION_PROPRIETARY = @enumToInt(enum_DriverId.DRIVER_ID_IMAGINATION_PROPRIETARY);
pub const DRIVER_ID_QUALCOMM_PROPRIETARY = @enumToInt(enum_DriverId.DRIVER_ID_QUALCOMM_PROPRIETARY);
pub const DRIVER_ID_ARM_PROPRIETARY = @enumToInt(enum_DriverId.DRIVER_ID_ARM_PROPRIETARY);
pub const DRIVER_ID_GOOGLE_SWIFTSHADER = @enumToInt(enum_DriverId.DRIVER_ID_GOOGLE_SWIFTSHADER);
pub const DRIVER_ID_GGP_PROPRIETARY = @enumToInt(enum_DriverId.DRIVER_ID_GGP_PROPRIETARY);
pub const DRIVER_ID_BROADCOM_PROPRIETARY = @enumToInt(enum_DriverId.DRIVER_ID_BROADCOM_PROPRIETARY);
pub const DRIVER_ID_MESA_LLVMPIPE = @enumToInt(enum_DriverId.DRIVER_ID_MESA_LLVMPIPE);
pub const DRIVER_ID_MOLTENVK = @enumToInt(enum_DriverId.DRIVER_ID_MOLTENVK);
pub const DRIVER_ID_AMD_PROPRIETARY_KHR = @enumToInt(enum_DriverId.DRIVER_ID_AMD_PROPRIETARY_KHR);
pub const DRIVER_ID_AMD_OPEN_SOURCE_KHR = @enumToInt(enum_DriverId.DRIVER_ID_AMD_OPEN_SOURCE_KHR);
pub const DRIVER_ID_MESA_RADV_KHR = @enumToInt(enum_DriverId.DRIVER_ID_MESA_RADV_KHR);
pub const DRIVER_ID_NVIDIA_PROPRIETARY_KHR = @enumToInt(enum_DriverId.DRIVER_ID_NVIDIA_PROPRIETARY_KHR);
pub const DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = @enumToInt(enum_DriverId.DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR);
pub const DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = @enumToInt(enum_DriverId.DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR);
pub const DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = @enumToInt(enum_DriverId.DRIVER_ID_IMAGINATION_PROPRIETARY_KHR);
pub const DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = @enumToInt(enum_DriverId.DRIVER_ID_QUALCOMM_PROPRIETARY_KHR);
pub const DRIVER_ID_ARM_PROPRIETARY_KHR = @enumToInt(enum_DriverId.DRIVER_ID_ARM_PROPRIETARY_KHR);
pub const DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = @enumToInt(enum_DriverId.DRIVER_ID_GOOGLE_SWIFTSHADER_KHR);
pub const DRIVER_ID_GGP_PROPRIETARY_KHR = @enumToInt(enum_DriverId.DRIVER_ID_GGP_PROPRIETARY_KHR);
pub const DRIVER_ID_BROADCOM_PROPRIETARY_KHR = @enumToInt(enum_DriverId.DRIVER_ID_BROADCOM_PROPRIETARY_KHR);
pub const DRIVER_ID_MAX_ENUM = @enumToInt(enum_DriverId.DRIVER_ID_MAX_ENUM);
pub const enum_DriverId = extern enum(c_int) {
DRIVER_ID_AMD_PROPRIETARY = 1,
DRIVER_ID_AMD_OPEN_SOURCE = 2,
DRIVER_ID_MESA_RADV = 3,
DRIVER_ID_NVIDIA_PROPRIETARY = 4,
DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5,
DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6,
DRIVER_ID_IMAGINATION_PROPRIETARY = 7,
DRIVER_ID_QUALCOMM_PROPRIETARY = 8,
DRIVER_ID_ARM_PROPRIETARY = 9,
DRIVER_ID_GOOGLE_SWIFTSHADER = 10,
DRIVER_ID_GGP_PROPRIETARY = 11,
DRIVER_ID_BROADCOM_PROPRIETARY = 12,
DRIVER_ID_MESA_LLVMPIPE = 13,
DRIVER_ID_MOLTENVK = 14,
DRIVER_ID_AMD_PROPRIETARY_KHR = 1,
DRIVER_ID_AMD_OPEN_SOURCE_KHR = 2,
DRIVER_ID_MESA_RADV_KHR = 3,
DRIVER_ID_NVIDIA_PROPRIETARY_KHR = 4,
DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = 5,
DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = 6,
DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = 7,
DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = 8,
DRIVER_ID_ARM_PROPRIETARY_KHR = 9,
DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = 10,
DRIVER_ID_GGP_PROPRIETARY_KHR = 11,
DRIVER_ID_BROADCOM_PROPRIETARY_KHR = 12,
DRIVER_ID_MAX_ENUM = 2147483647,
_,
};
pub const DriverId = enum_DriverId;
pub const SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = @enumToInt(enum_ShaderFloatControlsIndependence.SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY);
pub const SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = @enumToInt(enum_ShaderFloatControlsIndependence.SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL);
pub const SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = @enumToInt(enum_ShaderFloatControlsIndependence.SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE);
pub const SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = @enumToInt(enum_ShaderFloatControlsIndependence.SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR);
pub const SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = @enumToInt(enum_ShaderFloatControlsIndependence.SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR);
pub const SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = @enumToInt(enum_ShaderFloatControlsIndependence.SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR);
pub const SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = @enumToInt(enum_ShaderFloatControlsIndependence.SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM);
pub const enum_ShaderFloatControlsIndependence = extern enum(c_int) {
SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = 0,
SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = 1,
SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = 2,
SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 2147483647,
_,
};
pub const ShaderFloatControlsIndependence = enum_ShaderFloatControlsIndependence;
pub const SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = @enumToInt(enum_SamplerReductionMode.SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE);
pub const SAMPLER_REDUCTION_MODE_MIN = @enumToInt(enum_SamplerReductionMode.SAMPLER_REDUCTION_MODE_MIN);
pub const SAMPLER_REDUCTION_MODE_MAX = @enumToInt(enum_SamplerReductionMode.SAMPLER_REDUCTION_MODE_MAX);
pub const SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = @enumToInt(enum_SamplerReductionMode.SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT);
pub const SAMPLER_REDUCTION_MODE_MIN_EXT = @enumToInt(enum_SamplerReductionMode.SAMPLER_REDUCTION_MODE_MIN_EXT);
pub const SAMPLER_REDUCTION_MODE_MAX_EXT = @enumToInt(enum_SamplerReductionMode.SAMPLER_REDUCTION_MODE_MAX_EXT);
pub const SAMPLER_REDUCTION_MODE_MAX_ENUM = @enumToInt(enum_SamplerReductionMode.SAMPLER_REDUCTION_MODE_MAX_ENUM);
pub const enum_SamplerReductionMode = extern enum(c_int) {
SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,
SAMPLER_REDUCTION_MODE_MIN = 1,
SAMPLER_REDUCTION_MODE_MAX = 2,
SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0,
SAMPLER_REDUCTION_MODE_MIN_EXT = 1,
SAMPLER_REDUCTION_MODE_MAX_EXT = 2,
SAMPLER_REDUCTION_MODE_MAX_ENUM = 2147483647,
_,
};
pub const SamplerReductionMode = enum_SamplerReductionMode;
pub const SEMAPHORE_TYPE_BINARY = @enumToInt(enum_SemaphoreType.SEMAPHORE_TYPE_BINARY);
pub const SEMAPHORE_TYPE_TIMELINE = @enumToInt(enum_SemaphoreType.SEMAPHORE_TYPE_TIMELINE);
pub const SEMAPHORE_TYPE_BINARY_KHR = @enumToInt(enum_SemaphoreType.SEMAPHORE_TYPE_BINARY_KHR);
pub const SEMAPHORE_TYPE_TIMELINE_KHR = @enumToInt(enum_SemaphoreType.SEMAPHORE_TYPE_TIMELINE_KHR);
pub const SEMAPHORE_TYPE_MAX_ENUM = @enumToInt(enum_SemaphoreType.SEMAPHORE_TYPE_MAX_ENUM);
pub const enum_SemaphoreType = extern enum(c_int) {
SEMAPHORE_TYPE_BINARY = 0,
SEMAPHORE_TYPE_TIMELINE = 1,
SEMAPHORE_TYPE_BINARY_KHR = 0,
SEMAPHORE_TYPE_TIMELINE_KHR = 1,
SEMAPHORE_TYPE_MAX_ENUM = 2147483647,
_,
};
pub const SemaphoreType = enum_SemaphoreType;
pub const RESOLVE_MODE_NONE = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_NONE);
pub const RESOLVE_MODE_SAMPLE_ZERO_BIT = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_SAMPLE_ZERO_BIT);
pub const RESOLVE_MODE_AVERAGE_BIT = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_AVERAGE_BIT);
pub const RESOLVE_MODE_MIN_BIT = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_MIN_BIT);
pub const RESOLVE_MODE_MAX_BIT = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_MAX_BIT);
pub const RESOLVE_MODE_NONE_KHR = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_NONE_KHR);
pub const RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR);
pub const RESOLVE_MODE_AVERAGE_BIT_KHR = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_AVERAGE_BIT_KHR);
pub const RESOLVE_MODE_MIN_BIT_KHR = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_MIN_BIT_KHR);
pub const RESOLVE_MODE_MAX_BIT_KHR = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_MAX_BIT_KHR);
pub const RESOLVE_MODE_FLAG_BITS_MAX_ENUM = @enumToInt(enum_ResolveModeFlagBits.RESOLVE_MODE_FLAG_BITS_MAX_ENUM);
pub const enum_ResolveModeFlagBits = extern enum(c_int) {
RESOLVE_MODE_NONE = 0,
RESOLVE_MODE_SAMPLE_ZERO_BIT = 1,
RESOLVE_MODE_AVERAGE_BIT = 2,
RESOLVE_MODE_MIN_BIT = 4,
RESOLVE_MODE_MAX_BIT = 8,
RESOLVE_MODE_NONE_KHR = 0,
RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = 1,
RESOLVE_MODE_AVERAGE_BIT_KHR = 2,
RESOLVE_MODE_MIN_BIT_KHR = 4,
RESOLVE_MODE_MAX_BIT_KHR = 8,
RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const ResolveModeFlagBits = enum_ResolveModeFlagBits;
pub const ResolveModeFlags = Flags;
pub const DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT);
pub const DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT);
pub const DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT);
pub const DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT);
pub const DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT);
pub const DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT);
pub const DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT);
pub const DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT);
pub const DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = @enumToInt(enum_DescriptorBindingFlagBits.DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM);
pub const enum_DescriptorBindingFlagBits = extern enum(c_int) {
DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 1,
DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 2,
DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 4,
DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 8,
DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = 1,
DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = 2,
DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = 4,
DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = 8,
DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const DescriptorBindingFlagBits = enum_DescriptorBindingFlagBits;
pub const DescriptorBindingFlags = Flags;
pub const SEMAPHORE_WAIT_ANY_BIT = @enumToInt(enum_SemaphoreWaitFlagBits.SEMAPHORE_WAIT_ANY_BIT);
pub const SEMAPHORE_WAIT_ANY_BIT_KHR = @enumToInt(enum_SemaphoreWaitFlagBits.SEMAPHORE_WAIT_ANY_BIT_KHR);
pub const SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = @enumToInt(enum_SemaphoreWaitFlagBits.SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM);
pub const enum_SemaphoreWaitFlagBits = extern enum(c_int) {
SEMAPHORE_WAIT_ANY_BIT = 1,
SEMAPHORE_WAIT_ANY_BIT_KHR = 1,
SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 2147483647,
_,
};
pub const SemaphoreWaitFlagBits = enum_SemaphoreWaitFlagBits;
pub const SemaphoreWaitFlags = Flags;
pub const struct_PhysicalDeviceVulkan11Features = extern struct {
sType: StructureType,
pNext: ?*c_void,
storageBuffer16BitAccess: Bool32,
uniformAndStorageBuffer16BitAccess: Bool32,
storagePushConstant16: Bool32,
storageInputOutput16: Bool32,
multiview: Bool32,
multiviewGeometryShader: Bool32,
multiviewTessellationShader: Bool32,
variablePointersStorageBuffer: Bool32,
variablePointers: Bool32,
protectedMemory: Bool32,
samplerYcbcrConversion: Bool32,
shaderDrawParameters: Bool32,
};
pub const PhysicalDeviceVulkan11Features = struct_PhysicalDeviceVulkan11Features;
pub const struct_PhysicalDeviceVulkan11Properties = extern struct {
sType: StructureType,
pNext: ?*c_void,
deviceUUID: [16]u8,
driverUUID: [16]u8,
deviceLUID: [8]u8,
deviceNodeMask: u32,
deviceLUIDValid: Bool32,
subgroupSize: u32,
subgroupSupportedStages: ShaderStageFlags,
subgroupSupportedOperations: SubgroupFeatureFlags,
subgroupQuadOperationsInAllStages: Bool32,
pointClippingBehavior: PointClippingBehavior,
maxMultiviewViewCount: u32,
maxMultiviewInstanceIndex: u32,
protectedNoFault: Bool32,
maxPerSetDescriptors: u32,
maxMemoryAllocationSize: DeviceSize,
};
pub const PhysicalDeviceVulkan11Properties = struct_PhysicalDeviceVulkan11Properties;
pub const struct_PhysicalDeviceVulkan12Features = extern struct {
sType: StructureType,
pNext: ?*c_void,
samplerMirrorClampToEdge: Bool32,
drawIndirectCount: Bool32,
storageBuffer8BitAccess: Bool32,
uniformAndStorageBuffer8BitAccess: Bool32,
storagePushConstant8: Bool32,
shaderBufferInt64Atomics: Bool32,
shaderSharedInt64Atomics: Bool32,
shaderFloat16: Bool32,
shaderInt8: Bool32,
descriptorIndexing: Bool32,
shaderInputAttachmentArrayDynamicIndexing: Bool32,
shaderUniformTexelBufferArrayDynamicIndexing: Bool32,
shaderStorageTexelBufferArrayDynamicIndexing: Bool32,
shaderUniformBufferArrayNonUniformIndexing: Bool32,
shaderSampledImageArrayNonUniformIndexing: Bool32,
shaderStorageBufferArrayNonUniformIndexing: Bool32,
shaderStorageImageArrayNonUniformIndexing: Bool32,
shaderInputAttachmentArrayNonUniformIndexing: Bool32,
shaderUniformTexelBufferArrayNonUniformIndexing: Bool32,
shaderStorageTexelBufferArrayNonUniformIndexing: Bool32,
descriptorBindingUniformBufferUpdateAfterBind: Bool32,
descriptorBindingSampledImageUpdateAfterBind: Bool32,
descriptorBindingStorageImageUpdateAfterBind: Bool32,
descriptorBindingStorageBufferUpdateAfterBind: Bool32,
descriptorBindingUniformTexelBufferUpdateAfterBind: Bool32,
descriptorBindingStorageTexelBufferUpdateAfterBind: Bool32,
descriptorBindingUpdateUnusedWhilePending: Bool32,
descriptorBindingPartiallyBound: Bool32,
descriptorBindingVariableDescriptorCount: Bool32,
runtimeDescriptorArray: Bool32,
samplerFilterMinmax: Bool32,
scalarBlockLayout: Bool32,
imagelessFramebuffer: Bool32,
uniformBufferStandardLayout: Bool32,
shaderSubgroupExtendedTypes: Bool32,
separateDepthStencilLayouts: Bool32,
hostQueryReset: Bool32,
timelineSemaphore: Bool32,
bufferDeviceAddress: Bool32,
bufferDeviceAddressCaptureReplay: Bool32,
bufferDeviceAddressMultiDevice: Bool32,
vulkanMemoryModel: Bool32,
vulkanMemoryModelDeviceScope: Bool32,
vulkanMemoryModelAvailabilityVisibilityChains: Bool32,
shaderOutputViewportIndex: Bool32,
shaderOutputLayer: Bool32,
subgroupBroadcastDynamicId: Bool32,
};
pub const PhysicalDeviceVulkan12Features = struct_PhysicalDeviceVulkan12Features;
pub const struct_ConformanceVersion = extern struct {
major: u8,
minor: u8,
subminor: u8,
patch: u8,
};
pub const ConformanceVersion = struct_ConformanceVersion;
pub const struct_PhysicalDeviceVulkan12Properties = extern struct {
sType: StructureType,
pNext: ?*c_void,
driverID: DriverId,
driverName: [256]u8,
driverInfo: [256]u8,
conformanceVersion: ConformanceVersion,
denormBehaviorIndependence: ShaderFloatControlsIndependence,
roundingModeIndependence: ShaderFloatControlsIndependence,
shaderSignedZeroInfNanPreserveFloat16: Bool32,
shaderSignedZeroInfNanPreserveFloat32: Bool32,
shaderSignedZeroInfNanPreserveFloat64: Bool32,
shaderDenormPreserveFloat16: Bool32,
shaderDenormPreserveFloat32: Bool32,
shaderDenormPreserveFloat64: Bool32,
shaderDenormFlushToZeroFloat16: Bool32,
shaderDenormFlushToZeroFloat32: Bool32,
shaderDenormFlushToZeroFloat64: Bool32,
shaderRoundingModeRTEFloat16: Bool32,
shaderRoundingModeRTEFloat32: Bool32,
shaderRoundingModeRTEFloat64: Bool32,
shaderRoundingModeRTZFloat16: Bool32,
shaderRoundingModeRTZFloat32: Bool32,
shaderRoundingModeRTZFloat64: Bool32,
maxUpdateAfterBindDescriptorsInAllPools: u32,
shaderUniformBufferArrayNonUniformIndexingNative: Bool32,
shaderSampledImageArrayNonUniformIndexingNative: Bool32,
shaderStorageBufferArrayNonUniformIndexingNative: Bool32,
shaderStorageImageArrayNonUniformIndexingNative: Bool32,
shaderInputAttachmentArrayNonUniformIndexingNative: Bool32,
robustBufferAccessUpdateAfterBind: Bool32,
quadDivergentImplicitLod: Bool32,
maxPerStageDescriptorUpdateAfterBindSamplers: u32,
maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32,
maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32,
maxPerStageDescriptorUpdateAfterBindSampledImages: u32,
maxPerStageDescriptorUpdateAfterBindStorageImages: u32,
maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
maxPerStageUpdateAfterBindResources: u32,
maxDescriptorSetUpdateAfterBindSamplers: u32,
maxDescriptorSetUpdateAfterBindUniformBuffers: u32,
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
maxDescriptorSetUpdateAfterBindStorageBuffers: u32,
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
maxDescriptorSetUpdateAfterBindSampledImages: u32,
maxDescriptorSetUpdateAfterBindStorageImages: u32,
maxDescriptorSetUpdateAfterBindInputAttachments: u32,
supportedDepthResolveModes: ResolveModeFlags,
supportedStencilResolveModes: ResolveModeFlags,
independentResolveNone: Bool32,
independentResolve: Bool32,
filterMinmaxSingleComponentFormats: Bool32,
filterMinmaxImageComponentMapping: Bool32,
maxTimelineSemaphoreValueDifference: u64,
framebufferIntegerColorSampleCounts: SampleCountFlags,
};
pub const PhysicalDeviceVulkan12Properties = struct_PhysicalDeviceVulkan12Properties;
pub const struct_ImageFormatListCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
viewFormatCount: u32,
pViewFormats: [*c]const Format,
};
pub const ImageFormatListCreateInfo = struct_ImageFormatListCreateInfo;
pub const struct_AttachmentDescription2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: AttachmentDescriptionFlags,
format: Format,
samples: SampleCountFlagBits,
loadOp: AttachmentLoadOp,
storeOp: AttachmentStoreOp,
stencilLoadOp: AttachmentLoadOp,
stencilStoreOp: AttachmentStoreOp,
initialLayout: ImageLayout,
finalLayout: ImageLayout,
};
pub const AttachmentDescription2 = struct_AttachmentDescription2;
pub const struct_AttachmentReference2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
attachment: u32,
layout: ImageLayout,
aspectMask: ImageAspectFlags,
};
pub const AttachmentReference2 = struct_AttachmentReference2;
pub const struct_SubpassDescription2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: SubpassDescriptionFlags,
pipelineBindPoint: PipelineBindPoint,
viewMask: u32,
inputAttachmentCount: u32,
pInputAttachments: [*c]const AttachmentReference2,
colorAttachmentCount: u32,
pColorAttachments: [*c]const AttachmentReference2,
pResolveAttachments: [*c]const AttachmentReference2,
pDepthStencilAttachment: [*c]const AttachmentReference2,
preserveAttachmentCount: u32,
pPreserveAttachments: [*c]const u32,
};
pub const SubpassDescription2 = struct_SubpassDescription2;
pub const struct_SubpassDependency2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcSubpass: u32,
dstSubpass: u32,
srcStageMask: PipelineStageFlags,
dstStageMask: PipelineStageFlags,
srcAccessMask: AccessFlags,
dstAccessMask: AccessFlags,
dependencyFlags: DependencyFlags,
viewOffset: i32,
};
pub const SubpassDependency2 = struct_SubpassDependency2;
pub const struct_RenderPassCreateInfo2 = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: RenderPassCreateFlags,
attachmentCount: u32,
pAttachments: [*c]const AttachmentDescription2,
subpassCount: u32,
pSubpasses: [*c]const SubpassDescription2,
dependencyCount: u32,
pDependencies: [*c]const SubpassDependency2,
correlatedViewMaskCount: u32,
pCorrelatedViewMasks: [*c]const u32,
};
pub const RenderPassCreateInfo2 = struct_RenderPassCreateInfo2;
pub const struct_SubpassBeginInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
contents: SubpassContents,
};
pub const SubpassBeginInfo = struct_SubpassBeginInfo;
pub const struct_SubpassEndInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
};
pub const SubpassEndInfo = struct_SubpassEndInfo;
pub const struct_PhysicalDevice8BitStorageFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
storageBuffer8BitAccess: Bool32,
uniformAndStorageBuffer8BitAccess: Bool32,
storagePushConstant8: Bool32,
};
pub const PhysicalDevice8BitStorageFeatures = struct_PhysicalDevice8BitStorageFeatures;
pub const struct_PhysicalDeviceDriverProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
driverID: DriverId,
driverName: [256]u8,
driverInfo: [256]u8,
conformanceVersion: ConformanceVersion,
};
pub const PhysicalDeviceDriverProperties = struct_PhysicalDeviceDriverProperties;
pub const struct_PhysicalDeviceShaderAtomicInt64Features = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderBufferInt64Atomics: Bool32,
shaderSharedInt64Atomics: Bool32,
};
pub const PhysicalDeviceShaderAtomicInt64Features = struct_PhysicalDeviceShaderAtomicInt64Features;
pub const struct_PhysicalDeviceShaderFloat16Int8Features = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderFloat16: Bool32,
shaderInt8: Bool32,
};
pub const PhysicalDeviceShaderFloat16Int8Features = struct_PhysicalDeviceShaderFloat16Int8Features;
pub const struct_PhysicalDeviceFloatControlsProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
denormBehaviorIndependence: ShaderFloatControlsIndependence,
roundingModeIndependence: ShaderFloatControlsIndependence,
shaderSignedZeroInfNanPreserveFloat16: Bool32,
shaderSignedZeroInfNanPreserveFloat32: Bool32,
shaderSignedZeroInfNanPreserveFloat64: Bool32,
shaderDenormPreserveFloat16: Bool32,
shaderDenormPreserveFloat32: Bool32,
shaderDenormPreserveFloat64: Bool32,
shaderDenormFlushToZeroFloat16: Bool32,
shaderDenormFlushToZeroFloat32: Bool32,
shaderDenormFlushToZeroFloat64: Bool32,
shaderRoundingModeRTEFloat16: Bool32,
shaderRoundingModeRTEFloat32: Bool32,
shaderRoundingModeRTEFloat64: Bool32,
shaderRoundingModeRTZFloat16: Bool32,
shaderRoundingModeRTZFloat32: Bool32,
shaderRoundingModeRTZFloat64: Bool32,
};
pub const PhysicalDeviceFloatControlsProperties = struct_PhysicalDeviceFloatControlsProperties;
pub const struct_DescriptorSetLayoutBindingFlagsCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
bindingCount: u32,
pBindingFlags: [*c]const DescriptorBindingFlags,
};
pub const DescriptorSetLayoutBindingFlagsCreateInfo = struct_DescriptorSetLayoutBindingFlagsCreateInfo;
pub const struct_PhysicalDeviceDescriptorIndexingFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderInputAttachmentArrayDynamicIndexing: Bool32,
shaderUniformTexelBufferArrayDynamicIndexing: Bool32,
shaderStorageTexelBufferArrayDynamicIndexing: Bool32,
shaderUniformBufferArrayNonUniformIndexing: Bool32,
shaderSampledImageArrayNonUniformIndexing: Bool32,
shaderStorageBufferArrayNonUniformIndexing: Bool32,
shaderStorageImageArrayNonUniformIndexing: Bool32,
shaderInputAttachmentArrayNonUniformIndexing: Bool32,
shaderUniformTexelBufferArrayNonUniformIndexing: Bool32,
shaderStorageTexelBufferArrayNonUniformIndexing: Bool32,
descriptorBindingUniformBufferUpdateAfterBind: Bool32,
descriptorBindingSampledImageUpdateAfterBind: Bool32,
descriptorBindingStorageImageUpdateAfterBind: Bool32,
descriptorBindingStorageBufferUpdateAfterBind: Bool32,
descriptorBindingUniformTexelBufferUpdateAfterBind: Bool32,
descriptorBindingStorageTexelBufferUpdateAfterBind: Bool32,
descriptorBindingUpdateUnusedWhilePending: Bool32,
descriptorBindingPartiallyBound: Bool32,
descriptorBindingVariableDescriptorCount: Bool32,
runtimeDescriptorArray: Bool32,
};
pub const PhysicalDeviceDescriptorIndexingFeatures = struct_PhysicalDeviceDescriptorIndexingFeatures;
pub const struct_PhysicalDeviceDescriptorIndexingProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxUpdateAfterBindDescriptorsInAllPools: u32,
shaderUniformBufferArrayNonUniformIndexingNative: Bool32,
shaderSampledImageArrayNonUniformIndexingNative: Bool32,
shaderStorageBufferArrayNonUniformIndexingNative: Bool32,
shaderStorageImageArrayNonUniformIndexingNative: Bool32,
shaderInputAttachmentArrayNonUniformIndexingNative: Bool32,
robustBufferAccessUpdateAfterBind: Bool32,
quadDivergentImplicitLod: Bool32,
maxPerStageDescriptorUpdateAfterBindSamplers: u32,
maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32,
maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32,
maxPerStageDescriptorUpdateAfterBindSampledImages: u32,
maxPerStageDescriptorUpdateAfterBindStorageImages: u32,
maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
maxPerStageUpdateAfterBindResources: u32,
maxDescriptorSetUpdateAfterBindSamplers: u32,
maxDescriptorSetUpdateAfterBindUniformBuffers: u32,
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
maxDescriptorSetUpdateAfterBindStorageBuffers: u32,
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
maxDescriptorSetUpdateAfterBindSampledImages: u32,
maxDescriptorSetUpdateAfterBindStorageImages: u32,
maxDescriptorSetUpdateAfterBindInputAttachments: u32,
};
pub const PhysicalDeviceDescriptorIndexingProperties = struct_PhysicalDeviceDescriptorIndexingProperties;
pub const struct_DescriptorSetVariableDescriptorCountAllocateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
descriptorSetCount: u32,
pDescriptorCounts: [*c]const u32,
};
pub const DescriptorSetVariableDescriptorCountAllocateInfo = struct_DescriptorSetVariableDescriptorCountAllocateInfo;
pub const struct_DescriptorSetVariableDescriptorCountLayoutSupport = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxVariableDescriptorCount: u32,
};
pub const DescriptorSetVariableDescriptorCountLayoutSupport = struct_DescriptorSetVariableDescriptorCountLayoutSupport;
pub const struct_SubpassDescriptionDepthStencilResolve = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
depthResolveMode: ResolveModeFlagBits,
stencilResolveMode: ResolveModeFlagBits,
pDepthStencilResolveAttachment: [*c]const AttachmentReference2,
};
pub const SubpassDescriptionDepthStencilResolve = struct_SubpassDescriptionDepthStencilResolve;
pub const struct_PhysicalDeviceDepthStencilResolveProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
supportedDepthResolveModes: ResolveModeFlags,
supportedStencilResolveModes: ResolveModeFlags,
independentResolveNone: Bool32,
independentResolve: Bool32,
};
pub const PhysicalDeviceDepthStencilResolveProperties = struct_PhysicalDeviceDepthStencilResolveProperties;
pub const struct_PhysicalDeviceScalarBlockLayoutFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
scalarBlockLayout: Bool32,
};
pub const PhysicalDeviceScalarBlockLayoutFeatures = struct_PhysicalDeviceScalarBlockLayoutFeatures;
pub const struct_ImageStencilUsageCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
stencilUsage: ImageUsageFlags,
};
pub const ImageStencilUsageCreateInfo = struct_ImageStencilUsageCreateInfo;
pub const struct_SamplerReductionModeCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
reductionMode: SamplerReductionMode,
};
pub const SamplerReductionModeCreateInfo = struct_SamplerReductionModeCreateInfo;
pub const struct_PhysicalDeviceSamplerFilterMinmaxProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
filterMinmaxSingleComponentFormats: Bool32,
filterMinmaxImageComponentMapping: Bool32,
};
pub const PhysicalDeviceSamplerFilterMinmaxProperties = struct_PhysicalDeviceSamplerFilterMinmaxProperties;
pub const struct_PhysicalDeviceVulkanMemoryModelFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
vulkanMemoryModel: Bool32,
vulkanMemoryModelDeviceScope: Bool32,
vulkanMemoryModelAvailabilityVisibilityChains: Bool32,
};
pub const PhysicalDeviceVulkanMemoryModelFeatures = struct_PhysicalDeviceVulkanMemoryModelFeatures;
pub const struct_PhysicalDeviceImagelessFramebufferFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
imagelessFramebuffer: Bool32,
};
pub const PhysicalDeviceImagelessFramebufferFeatures = struct_PhysicalDeviceImagelessFramebufferFeatures;
pub const struct_FramebufferAttachmentImageInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: ImageCreateFlags,
usage: ImageUsageFlags,
width: u32,
height: u32,
layerCount: u32,
viewFormatCount: u32,
pViewFormats: [*c]const Format,
};
pub const FramebufferAttachmentImageInfo = struct_FramebufferAttachmentImageInfo;
pub const struct_FramebufferAttachmentsCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
attachmentImageInfoCount: u32,
pAttachmentImageInfos: [*c]const FramebufferAttachmentImageInfo,
};
pub const FramebufferAttachmentsCreateInfo = struct_FramebufferAttachmentsCreateInfo;
pub const struct_RenderPassAttachmentBeginInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
attachmentCount: u32,
pAttachments: [*c]const ImageView,
};
pub const RenderPassAttachmentBeginInfo = struct_RenderPassAttachmentBeginInfo;
pub const struct_PhysicalDeviceUniformBufferStandardLayoutFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
uniformBufferStandardLayout: Bool32,
};
pub const PhysicalDeviceUniformBufferStandardLayoutFeatures = struct_PhysicalDeviceUniformBufferStandardLayoutFeatures;
pub const struct_PhysicalDeviceShaderSubgroupExtendedTypesFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderSubgroupExtendedTypes: Bool32,
};
pub const PhysicalDeviceShaderSubgroupExtendedTypesFeatures = struct_PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
pub const struct_PhysicalDeviceSeparateDepthStencilLayoutsFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
separateDepthStencilLayouts: Bool32,
};
pub const PhysicalDeviceSeparateDepthStencilLayoutsFeatures = struct_PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
pub const struct_AttachmentReferenceStencilLayout = extern struct {
sType: StructureType,
pNext: ?*c_void,
stencilLayout: ImageLayout,
};
pub const AttachmentReferenceStencilLayout = struct_AttachmentReferenceStencilLayout;
pub const struct_AttachmentDescriptionStencilLayout = extern struct {
sType: StructureType,
pNext: ?*c_void,
stencilInitialLayout: ImageLayout,
stencilFinalLayout: ImageLayout,
};
pub const AttachmentDescriptionStencilLayout = struct_AttachmentDescriptionStencilLayout;
pub const struct_PhysicalDeviceHostQueryResetFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
hostQueryReset: Bool32,
};
pub const PhysicalDeviceHostQueryResetFeatures = struct_PhysicalDeviceHostQueryResetFeatures;
pub const struct_PhysicalDeviceTimelineSemaphoreFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
timelineSemaphore: Bool32,
};
pub const PhysicalDeviceTimelineSemaphoreFeatures = struct_PhysicalDeviceTimelineSemaphoreFeatures;
pub const struct_PhysicalDeviceTimelineSemaphoreProperties = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxTimelineSemaphoreValueDifference: u64,
};
pub const PhysicalDeviceTimelineSemaphoreProperties = struct_PhysicalDeviceTimelineSemaphoreProperties;
pub const struct_SemaphoreTypeCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
semaphoreType: SemaphoreType,
initialValue: u64,
};
pub const SemaphoreTypeCreateInfo = struct_SemaphoreTypeCreateInfo;
pub const struct_TimelineSemaphoreSubmitInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
waitSemaphoreValueCount: u32,
pWaitSemaphoreValues: [*c]const u64,
signalSemaphoreValueCount: u32,
pSignalSemaphoreValues: [*c]const u64,
};
pub const TimelineSemaphoreSubmitInfo = struct_TimelineSemaphoreSubmitInfo;
pub const struct_SemaphoreWaitInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: SemaphoreWaitFlags,
semaphoreCount: u32,
pSemaphores: [*c]const Semaphore,
pValues: [*c]const u64,
};
pub const SemaphoreWaitInfo = struct_SemaphoreWaitInfo;
pub const struct_SemaphoreSignalInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
semaphore: Semaphore,
value: u64,
};
pub const SemaphoreSignalInfo = struct_SemaphoreSignalInfo;
pub const struct_PhysicalDeviceBufferDeviceAddressFeatures = extern struct {
sType: StructureType,
pNext: ?*c_void,
bufferDeviceAddress: Bool32,
bufferDeviceAddressCaptureReplay: Bool32,
bufferDeviceAddressMultiDevice: Bool32,
};
pub const PhysicalDeviceBufferDeviceAddressFeatures = struct_PhysicalDeviceBufferDeviceAddressFeatures;
pub const struct_BufferDeviceAddressInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
buffer: Buffer,
};
pub const BufferDeviceAddressInfo = struct_BufferDeviceAddressInfo;
pub const struct_BufferOpaqueCaptureAddressCreateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
opaqueCaptureAddress: u64,
};
pub const BufferOpaqueCaptureAddressCreateInfo = struct_BufferOpaqueCaptureAddressCreateInfo;
pub const struct_MemoryOpaqueCaptureAddressAllocateInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
opaqueCaptureAddress: u64,
};
pub const MemoryOpaqueCaptureAddressAllocateInfo = struct_MemoryOpaqueCaptureAddressAllocateInfo;
pub const struct_DeviceMemoryOpaqueCaptureAddressInfo = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
memory: DeviceMemory,
};
pub const DeviceMemoryOpaqueCaptureAddressInfo = struct_DeviceMemoryOpaqueCaptureAddressInfo;
pub const PFN_vkCmdDrawIndirectCount = ?fn (CommandBuffer, Buffer, DeviceSize, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawIndexedIndirectCount = ?fn (CommandBuffer, Buffer, DeviceSize, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub const PFN_vkCreateRenderPass2 = ?fn (Device, [*c]const RenderPassCreateInfo2, [*c]const AllocationCallbacks, [*c]RenderPass) callconv(.C) Result;
pub const PFN_vkCmdBeginRenderPass2 = ?fn (CommandBuffer, [*c]const RenderPassBeginInfo, [*c]const SubpassBeginInfo) callconv(.C) void;
pub const PFN_vkCmdNextSubpass2 = ?fn (CommandBuffer, [*c]const SubpassBeginInfo, [*c]const SubpassEndInfo) callconv(.C) void;
pub const PFN_vkCmdEndRenderPass2 = ?fn (CommandBuffer, [*c]const SubpassEndInfo) callconv(.C) void;
pub const PFN_vkResetQueryPool = ?fn (Device, QueryPool, u32, u32) callconv(.C) void;
pub const PFN_vkGetSemaphoreCounterValue = ?fn (Device, Semaphore, [*c]u64) callconv(.C) Result;
pub const PFN_vkWaitSemaphores = ?fn (Device, [*c]const SemaphoreWaitInfo, u64) callconv(.C) Result;
pub const PFN_vkSignalSemaphore = ?fn (Device, [*c]const SemaphoreSignalInfo) callconv(.C) Result;
pub const PFN_vkGetBufferDeviceAddress = ?fn (Device, [*c]const BufferDeviceAddressInfo) callconv(.C) DeviceAddress;
pub const PFN_vkGetBufferOpaqueCaptureAddress = ?fn (Device, [*c]const BufferDeviceAddressInfo) callconv(.C) u64;
pub const PFN_vkGetDeviceMemoryOpaqueCaptureAddress = ?fn (Device, [*c]const DeviceMemoryOpaqueCaptureAddressInfo) callconv(.C) u64;
pub extern fn vkCmdDrawIndirectCount(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) void;
pub extern fn vkCmdDrawIndexedIndirectCount(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) void;
pub extern fn vkCreateRenderPass2(device: Device, pCreateInfo: [*c]const RenderPassCreateInfo2, pAllocator: [*c]const AllocationCallbacks, pRenderPass: [*c]RenderPass) Result;
pub extern fn vkCmdBeginRenderPass2(commandBuffer: CommandBuffer, pRenderPassBegin: [*c]const RenderPassBeginInfo, pSubpassBeginInfo: [*c]const SubpassBeginInfo) void;
pub extern fn vkCmdNextSubpass2(commandBuffer: CommandBuffer, pSubpassBeginInfo: [*c]const SubpassBeginInfo, pSubpassEndInfo: [*c]const SubpassEndInfo) void;
pub extern fn vkCmdEndRenderPass2(commandBuffer: CommandBuffer, pSubpassEndInfo: [*c]const SubpassEndInfo) void;
pub extern fn vkResetQueryPool(device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32) void;
pub extern fn vkGetSemaphoreCounterValue(device: Device, semaphore: Semaphore, pValue: [*c]u64) Result;
pub extern fn vkWaitSemaphores(device: Device, pWaitInfo: [*c]const SemaphoreWaitInfo, timeout: u64) Result;
pub extern fn vkSignalSemaphore(device: Device, pSignalInfo: [*c]const SemaphoreSignalInfo) Result;
pub extern fn vkGetBufferDeviceAddress(device: Device, pInfo: [*c]const BufferDeviceAddressInfo) DeviceAddress;
pub extern fn vkGetBufferOpaqueCaptureAddress(device: Device, pInfo: [*c]const BufferDeviceAddressInfo) u64;
pub extern fn vkGetDeviceMemoryOpaqueCaptureAddress(device: Device, pInfo: [*c]const DeviceMemoryOpaqueCaptureAddressInfo) u64;
pub const struct_SurfaceKHR_T = opaque {};
pub const SurfaceKHR = ?*struct_SurfaceKHR_T;
pub const PRESENT_MODE_IMMEDIATE_KHR = @enumToInt(enum_PresentModeKHR.PRESENT_MODE_IMMEDIATE_KHR);
pub const PRESENT_MODE_MAILBOX_KHR = @enumToInt(enum_PresentModeKHR.PRESENT_MODE_MAILBOX_KHR);
pub const PRESENT_MODE_FIFO_KHR = @enumToInt(enum_PresentModeKHR.PRESENT_MODE_FIFO_KHR);
pub const PRESENT_MODE_FIFO_RELAXED_KHR = @enumToInt(enum_PresentModeKHR.PRESENT_MODE_FIFO_RELAXED_KHR);
pub const PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = @enumToInt(enum_PresentModeKHR.PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
pub const PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = @enumToInt(enum_PresentModeKHR.PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
pub const PRESENT_MODE_MAX_ENUM_KHR = @enumToInt(enum_PresentModeKHR.PRESENT_MODE_MAX_ENUM_KHR);
pub const enum_PresentModeKHR = extern enum(c_int) {
PRESENT_MODE_IMMEDIATE_KHR = 0,
PRESENT_MODE_MAILBOX_KHR = 1,
PRESENT_MODE_FIFO_KHR = 2,
PRESENT_MODE_FIFO_RELAXED_KHR = 3,
PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
PRESENT_MODE_MAX_ENUM_KHR = 2147483647,
_,
};
pub const PresentModeKHR = enum_PresentModeKHR;
pub const COLOR_SPACE_SRGB_NONLINEAR_KHR = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_SRGB_NONLINEAR_KHR);
pub const COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT);
pub const COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT);
pub const COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_DISPLAY_P3_LINEAR_EXT);
pub const COLOR_SPACE_DCI_P3_NONLINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_DCI_P3_NONLINEAR_EXT);
pub const COLOR_SPACE_BT709_LINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_BT709_LINEAR_EXT);
pub const COLOR_SPACE_BT709_NONLINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_BT709_NONLINEAR_EXT);
pub const COLOR_SPACE_BT2020_LINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_BT2020_LINEAR_EXT);
pub const COLOR_SPACE_HDR10_ST2084_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_HDR10_ST2084_EXT);
pub const COLOR_SPACE_DOLBYVISION_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_DOLBYVISION_EXT);
pub const COLOR_SPACE_HDR10_HLG_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_HDR10_HLG_EXT);
pub const COLOR_SPACE_ADOBERGB_LINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_ADOBERGB_LINEAR_EXT);
pub const COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_ADOBERGB_NONLINEAR_EXT);
pub const COLOR_SPACE_PASS_THROUGH_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_PASS_THROUGH_EXT);
pub const COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT);
pub const COLOR_SPACE_DISPLAY_NATIVE_AMD = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_DISPLAY_NATIVE_AMD);
pub const COLORSPACE_SRGB_NONLINEAR_KHR = @enumToInt(enum_ColorSpaceKHR.COLORSPACE_SRGB_NONLINEAR_KHR);
pub const COLOR_SPACE_DCI_P3_LINEAR_EXT = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_DCI_P3_LINEAR_EXT);
pub const COLOR_SPACE_MAX_ENUM_KHR = @enumToInt(enum_ColorSpaceKHR.COLOR_SPACE_MAX_ENUM_KHR);
pub const enum_ColorSpaceKHR = extern enum(c_int) {
COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003,
COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000,
COLORSPACE_SRGB_NONLINEAR_KHR = 0,
COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003,
COLOR_SPACE_MAX_ENUM_KHR = 2147483647,
_,
};
pub const ColorSpaceKHR = enum_ColorSpaceKHR;
pub const SURFACE_TRANSFORM_IDENTITY_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_IDENTITY_BIT_KHR);
pub const SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_ROTATE_90_BIT_KHR);
pub const SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_ROTATE_180_BIT_KHR);
pub const SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_ROTATE_270_BIT_KHR);
pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR);
pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR);
pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR);
pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR);
pub const SURFACE_TRANSFORM_INHERIT_BIT_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_INHERIT_BIT_KHR);
pub const SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_SurfaceTransformFlagBitsKHR.SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_SurfaceTransformFlagBitsKHR = extern enum(c_int) {
SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 1,
SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 2,
SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 4,
SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 8,
SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 16,
SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 32,
SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 64,
SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 128,
SURFACE_TRANSFORM_INHERIT_BIT_KHR = 256,
SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const SurfaceTransformFlagBitsKHR = enum_SurfaceTransformFlagBitsKHR;
pub const COMPOSITE_ALPHA_OPAQUE_BIT_KHR = @enumToInt(enum_CompositeAlphaFlagBitsKHR.COMPOSITE_ALPHA_OPAQUE_BIT_KHR);
pub const COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = @enumToInt(enum_CompositeAlphaFlagBitsKHR.COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR);
pub const COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = @enumToInt(enum_CompositeAlphaFlagBitsKHR.COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR);
pub const COMPOSITE_ALPHA_INHERIT_BIT_KHR = @enumToInt(enum_CompositeAlphaFlagBitsKHR.COMPOSITE_ALPHA_INHERIT_BIT_KHR);
pub const COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_CompositeAlphaFlagBitsKHR.COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_CompositeAlphaFlagBitsKHR = extern enum(c_int) {
COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 1,
COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 2,
COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 4,
COMPOSITE_ALPHA_INHERIT_BIT_KHR = 8,
COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const CompositeAlphaFlagBitsKHR = enum_CompositeAlphaFlagBitsKHR;
pub const CompositeAlphaFlagsKHR = Flags;
pub const SurfaceTransformFlagsKHR = Flags;
pub const struct_SurfaceCapabilitiesKHR = extern struct {
minImageCount: u32,
maxImageCount: u32,
currentExtent: Extent2D,
minImageExtent: Extent2D,
maxImageExtent: Extent2D,
maxImageArrayLayers: u32,
supportedTransforms: SurfaceTransformFlagsKHR,
currentTransform: SurfaceTransformFlagBitsKHR,
supportedCompositeAlpha: CompositeAlphaFlagsKHR,
supportedUsageFlags: ImageUsageFlags,
};
pub const SurfaceCapabilitiesKHR = struct_SurfaceCapabilitiesKHR;
pub const struct_SurfaceFormatKHR = extern struct {
format: Format,
colorSpace: ColorSpaceKHR,
};
pub const SurfaceFormatKHR = struct_SurfaceFormatKHR;
pub const PFN_vkDestroySurfaceKHR = ?fn (Instance, SurfaceKHR, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceSurfaceSupportKHR = ?fn (PhysicalDevice, u32, SurfaceKHR, [*c]Bool32) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = ?fn (PhysicalDevice, SurfaceKHR, [*c]SurfaceCapabilitiesKHR) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = ?fn (PhysicalDevice, SurfaceKHR, [*c]u32, [*c]SurfaceFormatKHR) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = ?fn (PhysicalDevice, SurfaceKHR, [*c]u32, [*c]PresentModeKHR) callconv(.C) Result;
pub extern fn vkDestroySurfaceKHR(instance: Instance, surface: SurfaceKHR, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice: PhysicalDevice, queueFamilyIndex: u32, surface: SurfaceKHR, pSupported: [*c]Bool32) Result;
pub extern fn vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceCapabilities: [*c]SurfaceCapabilitiesKHR) Result;
pub extern fn vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceFormatCount: [*c]u32, pSurfaceFormats: [*c]SurfaceFormatKHR) Result;
pub extern fn vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice: PhysicalDevice, surface: SurfaceKHR, pPresentModeCount: [*c]u32, pPresentModes: [*c]PresentModeKHR) Result;
pub const struct_SwapchainKHR_T = opaque {};
pub const SwapchainKHR = ?*struct_SwapchainKHR_T;
pub const SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = @enumToInt(enum_SwapchainCreateFlagBitsKHR.SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR);
pub const SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = @enumToInt(enum_SwapchainCreateFlagBitsKHR.SWAPCHAIN_CREATE_PROTECTED_BIT_KHR);
pub const SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = @enumToInt(enum_SwapchainCreateFlagBitsKHR.SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR);
pub const SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_SwapchainCreateFlagBitsKHR.SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_SwapchainCreateFlagBitsKHR = extern enum(c_int) {
SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 1,
SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 2,
SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 4,
SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const SwapchainCreateFlagBitsKHR = enum_SwapchainCreateFlagBitsKHR;
pub const SwapchainCreateFlagsKHR = Flags;
pub const DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = @enumToInt(enum_DeviceGroupPresentModeFlagBitsKHR.DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR);
pub const DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = @enumToInt(enum_DeviceGroupPresentModeFlagBitsKHR.DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR);
pub const DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = @enumToInt(enum_DeviceGroupPresentModeFlagBitsKHR.DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR);
pub const DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = @enumToInt(enum_DeviceGroupPresentModeFlagBitsKHR.DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR);
pub const DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_DeviceGroupPresentModeFlagBitsKHR.DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_DeviceGroupPresentModeFlagBitsKHR = extern enum(c_int) {
DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 1,
DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 2,
DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 4,
DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 8,
DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const DeviceGroupPresentModeFlagBitsKHR = enum_DeviceGroupPresentModeFlagBitsKHR;
pub const DeviceGroupPresentModeFlagsKHR = Flags;
pub const struct_SwapchainCreateInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: SwapchainCreateFlagsKHR,
surface: SurfaceKHR,
minImageCount: u32,
imageFormat: Format,
imageColorSpace: ColorSpaceKHR,
imageExtent: Extent2D,
imageArrayLayers: u32,
imageUsage: ImageUsageFlags,
imageSharingMode: SharingMode,
queueFamilyIndexCount: u32,
pQueueFamilyIndices: [*c]const u32,
preTransform: SurfaceTransformFlagBitsKHR,
compositeAlpha: CompositeAlphaFlagBitsKHR,
presentMode: PresentModeKHR,
clipped: Bool32,
oldSwapchain: SwapchainKHR,
};
pub const SwapchainCreateInfoKHR = struct_SwapchainCreateInfoKHR;
pub const struct_PresentInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
waitSemaphoreCount: u32,
pWaitSemaphores: [*c]const Semaphore,
swapchainCount: u32,
pSwapchains: [*c]const SwapchainKHR,
pImageIndices: [*c]const u32,
pResults: [*c]Result,
};
pub const PresentInfoKHR = struct_PresentInfoKHR;
pub const struct_ImageSwapchainCreateInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
swapchain: SwapchainKHR,
};
pub const ImageSwapchainCreateInfoKHR = struct_ImageSwapchainCreateInfoKHR;
pub const struct_BindImageMemorySwapchainInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
swapchain: SwapchainKHR,
imageIndex: u32,
};
pub const BindImageMemorySwapchainInfoKHR = struct_BindImageMemorySwapchainInfoKHR;
pub const struct_AcquireNextImageInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
swapchain: SwapchainKHR,
timeout: u64,
semaphore: Semaphore,
fence: Fence,
deviceMask: u32,
};
pub const AcquireNextImageInfoKHR = struct_AcquireNextImageInfoKHR;
pub const struct_DeviceGroupPresentCapabilitiesKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
presentMask: [32]u32,
modes: DeviceGroupPresentModeFlagsKHR,
};
pub const DeviceGroupPresentCapabilitiesKHR = struct_DeviceGroupPresentCapabilitiesKHR;
pub const struct_DeviceGroupPresentInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
swapchainCount: u32,
pDeviceMasks: [*c]const u32,
mode: DeviceGroupPresentModeFlagBitsKHR,
};
pub const DeviceGroupPresentInfoKHR = struct_DeviceGroupPresentInfoKHR;
pub const struct_DeviceGroupSwapchainCreateInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
modes: DeviceGroupPresentModeFlagsKHR,
};
pub const DeviceGroupSwapchainCreateInfoKHR = struct_DeviceGroupSwapchainCreateInfoKHR;
pub const PFN_vkCreateSwapchainKHR = ?fn (Device, [*c]const SwapchainCreateInfoKHR, [*c]const AllocationCallbacks, [*c]SwapchainKHR) callconv(.C) Result;
pub const PFN_vkDestroySwapchainKHR = ?fn (Device, SwapchainKHR, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkGetSwapchainImagesKHR = ?fn (Device, SwapchainKHR, [*c]u32, [*c]Image) callconv(.C) Result;
pub const PFN_vkAcquireNextImageKHR = ?fn (Device, SwapchainKHR, u64, Semaphore, Fence, [*c]u32) callconv(.C) Result;
pub const PFN_vkQueuePresentKHR = ?fn (Queue, [*c]const PresentInfoKHR) callconv(.C) Result;
pub const PFN_vkGetDeviceGroupPresentCapabilitiesKHR = ?fn (Device, [*c]DeviceGroupPresentCapabilitiesKHR) callconv(.C) Result;
pub const PFN_vkGetDeviceGroupSurfacePresentModesKHR = ?fn (Device, SurfaceKHR, [*c]DeviceGroupPresentModeFlagsKHR) callconv(.C) Result;
pub const PFN_vkGetPhysicalDevicePresentRectanglesKHR = ?fn (PhysicalDevice, SurfaceKHR, [*c]u32, [*c]Rect2D) callconv(.C) Result;
pub const PFN_vkAcquireNextImage2KHR = ?fn (Device, [*c]const AcquireNextImageInfoKHR, [*c]u32) callconv(.C) Result;
pub extern fn vkCreateSwapchainKHR(device: Device, pCreateInfo: [*c]const SwapchainCreateInfoKHR, pAllocator: [*c]const AllocationCallbacks, pSwapchain: [*c]SwapchainKHR) Result;
pub extern fn vkDestroySwapchainKHR(device: Device, swapchain: SwapchainKHR, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkGetSwapchainImagesKHR(device: Device, swapchain: SwapchainKHR, pSwapchainImageCount: [*c]u32, pSwapchainImages: [*c]Image) Result;
pub extern fn vkAcquireNextImageKHR(device: Device, swapchain: SwapchainKHR, timeout: u64, semaphore: Semaphore, fence: Fence, pImageIndex: [*c]u32) Result;
pub extern fn vkQueuePresentKHR(queue: Queue, pPresentInfo: [*c]const PresentInfoKHR) Result;
pub extern fn vkGetDeviceGroupPresentCapabilitiesKHR(device: Device, pDeviceGroupPresentCapabilities: [*c]DeviceGroupPresentCapabilitiesKHR) Result;
pub extern fn vkGetDeviceGroupSurfacePresentModesKHR(device: Device, surface: SurfaceKHR, pModes: [*c]DeviceGroupPresentModeFlagsKHR) Result;
pub extern fn vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice: PhysicalDevice, surface: SurfaceKHR, pRectCount: [*c]u32, pRects: [*c]Rect2D) Result;
pub extern fn vkAcquireNextImage2KHR(device: Device, pAcquireInfo: [*c]const AcquireNextImageInfoKHR, pImageIndex: [*c]u32) Result;
pub const struct_DisplayKHR_T = opaque {};
pub const DisplayKHR = ?*struct_DisplayKHR_T;
pub const struct_DisplayModeKHR_T = opaque {};
pub const DisplayModeKHR = ?*struct_DisplayModeKHR_T;
pub const DisplayModeCreateFlagsKHR = Flags;
pub const DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = @enumToInt(enum_DisplayPlaneAlphaFlagBitsKHR.DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR);
pub const DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = @enumToInt(enum_DisplayPlaneAlphaFlagBitsKHR.DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR);
pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = @enumToInt(enum_DisplayPlaneAlphaFlagBitsKHR.DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR);
pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = @enumToInt(enum_DisplayPlaneAlphaFlagBitsKHR.DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR);
pub const DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_DisplayPlaneAlphaFlagBitsKHR.DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_DisplayPlaneAlphaFlagBitsKHR = extern enum(c_int) {
DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 1,
DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 2,
DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 4,
DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 8,
DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const DisplayPlaneAlphaFlagBitsKHR = enum_DisplayPlaneAlphaFlagBitsKHR;
pub const DisplayPlaneAlphaFlagsKHR = Flags;
pub const DisplaySurfaceCreateFlagsKHR = Flags;
pub const struct_DisplayModeParametersKHR = extern struct {
visibleRegion: Extent2D,
refreshRate: u32,
};
pub const DisplayModeParametersKHR = struct_DisplayModeParametersKHR;
pub const struct_DisplayModeCreateInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DisplayModeCreateFlagsKHR,
parameters: DisplayModeParametersKHR,
};
pub const DisplayModeCreateInfoKHR = struct_DisplayModeCreateInfoKHR;
pub const struct_DisplayModePropertiesKHR = extern struct {
displayMode: DisplayModeKHR,
parameters: DisplayModeParametersKHR,
};
pub const DisplayModePropertiesKHR = struct_DisplayModePropertiesKHR;
pub const struct_DisplayPlaneCapabilitiesKHR = extern struct {
supportedAlpha: DisplayPlaneAlphaFlagsKHR,
minSrcPosition: Offset2D,
maxSrcPosition: Offset2D,
minSrcExtent: Extent2D,
maxSrcExtent: Extent2D,
minDstPosition: Offset2D,
maxDstPosition: Offset2D,
minDstExtent: Extent2D,
maxDstExtent: Extent2D,
};
pub const DisplayPlaneCapabilitiesKHR = struct_DisplayPlaneCapabilitiesKHR;
pub const struct_DisplayPlanePropertiesKHR = extern struct {
currentDisplay: DisplayKHR,
currentStackIndex: u32,
};
pub const DisplayPlanePropertiesKHR = struct_DisplayPlanePropertiesKHR;
pub const struct_DisplayPropertiesKHR = extern struct {
display: DisplayKHR,
displayName: [*c]const u8,
physicalDimensions: Extent2D,
physicalResolution: Extent2D,
supportedTransforms: SurfaceTransformFlagsKHR,
planeReorderPossible: Bool32,
persistentContent: Bool32,
};
pub const DisplayPropertiesKHR = struct_DisplayPropertiesKHR;
pub const struct_DisplaySurfaceCreateInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DisplaySurfaceCreateFlagsKHR,
displayMode: DisplayModeKHR,
planeIndex: u32,
planeStackIndex: u32,
transform: SurfaceTransformFlagBitsKHR,
globalAlpha: f32,
alphaMode: DisplayPlaneAlphaFlagBitsKHR,
imageExtent: Extent2D,
};
pub const DisplaySurfaceCreateInfoKHR = struct_DisplaySurfaceCreateInfoKHR;
pub const PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = ?fn (PhysicalDevice, [*c]u32, [*c]DisplayPropertiesKHR) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = ?fn (PhysicalDevice, [*c]u32, [*c]DisplayPlanePropertiesKHR) callconv(.C) Result;
pub const PFN_vkGetDisplayPlaneSupportedDisplaysKHR = ?fn (PhysicalDevice, u32, [*c]u32, [*c]DisplayKHR) callconv(.C) Result;
pub const PFN_vkGetDisplayModePropertiesKHR = ?fn (PhysicalDevice, DisplayKHR, [*c]u32, [*c]DisplayModePropertiesKHR) callconv(.C) Result;
pub const PFN_vkCreateDisplayModeKHR = ?fn (PhysicalDevice, DisplayKHR, [*c]const DisplayModeCreateInfoKHR, [*c]const AllocationCallbacks, [*c]DisplayModeKHR) callconv(.C) Result;
pub const PFN_vkGetDisplayPlaneCapabilitiesKHR = ?fn (PhysicalDevice, DisplayModeKHR, u32, [*c]DisplayPlaneCapabilitiesKHR) callconv(.C) Result;
pub const PFN_vkCreateDisplayPlaneSurfaceKHR = ?fn (Instance, [*c]const DisplaySurfaceCreateInfoKHR, [*c]const AllocationCallbacks, [*c]SurfaceKHR) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice: PhysicalDevice, pPropertyCount: [*c]u32, pProperties: [*c]DisplayPropertiesKHR) Result;
pub extern fn vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice: PhysicalDevice, pPropertyCount: [*c]u32, pProperties: [*c]DisplayPlanePropertiesKHR) Result;
pub extern fn vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice: PhysicalDevice, planeIndex: u32, pDisplayCount: [*c]u32, pDisplays: [*c]DisplayKHR) Result;
pub extern fn vkGetDisplayModePropertiesKHR(physicalDevice: PhysicalDevice, display: DisplayKHR, pPropertyCount: [*c]u32, pProperties: [*c]DisplayModePropertiesKHR) Result;
pub extern fn vkCreateDisplayModeKHR(physicalDevice: PhysicalDevice, display: DisplayKHR, pCreateInfo: [*c]const DisplayModeCreateInfoKHR, pAllocator: [*c]const AllocationCallbacks, pMode: [*c]DisplayModeKHR) Result;
pub extern fn vkGetDisplayPlaneCapabilitiesKHR(physicalDevice: PhysicalDevice, mode: DisplayModeKHR, planeIndex: u32, pCapabilities: [*c]DisplayPlaneCapabilitiesKHR) Result;
pub extern fn vkCreateDisplayPlaneSurfaceKHR(instance: Instance, pCreateInfo: [*c]const DisplaySurfaceCreateInfoKHR, pAllocator: [*c]const AllocationCallbacks, pSurface: [*c]SurfaceKHR) Result;
pub const struct_DisplayPresentInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcRect: Rect2D,
dstRect: Rect2D,
persistent: Bool32,
};
pub const DisplayPresentInfoKHR = struct_DisplayPresentInfoKHR;
pub const PFN_vkCreateSharedSwapchainsKHR = ?fn (Device, u32, [*c]const SwapchainCreateInfoKHR, [*c]const AllocationCallbacks, [*c]SwapchainKHR) callconv(.C) Result;
pub extern fn vkCreateSharedSwapchainsKHR(device: Device, swapchainCount: u32, pCreateInfos: [*c]const SwapchainCreateInfoKHR, pAllocator: [*c]const AllocationCallbacks, pSwapchains: [*c]SwapchainKHR) Result;
pub const RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
pub const PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
pub const PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
pub const PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
pub const PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
pub const FormatProperties2KHR = FormatProperties2;
pub const ImageFormatProperties2KHR = ImageFormatProperties2;
pub const PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
pub const QueueFamilyProperties2KHR = QueueFamilyProperties2;
pub const PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
pub const SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
pub const PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
pub const PFN_vkGetPhysicalDeviceFeatures2KHR = ?fn (PhysicalDevice, [*c]PhysicalDeviceFeatures2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceProperties2KHR = ?fn (PhysicalDevice, [*c]PhysicalDeviceProperties2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceFormatProperties2KHR = ?fn (PhysicalDevice, Format, [*c]FormatProperties2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceImageFormatProperties2KHR = ?fn (PhysicalDevice, [*c]const PhysicalDeviceImageFormatInfo2, [*c]ImageFormatProperties2) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = ?fn (PhysicalDevice, [*c]u32, [*c]QueueFamilyProperties2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceMemoryProperties2KHR = ?fn (PhysicalDevice, [*c]PhysicalDeviceMemoryProperties2) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = ?fn (PhysicalDevice, [*c]const PhysicalDeviceSparseImageFormatInfo2, [*c]u32, [*c]SparseImageFormatProperties2) callconv(.C) void;
pub extern fn vkGetPhysicalDeviceFeatures2KHR(physicalDevice: PhysicalDevice, pFeatures: [*c]PhysicalDeviceFeatures2) void;
pub extern fn vkGetPhysicalDeviceProperties2KHR(physicalDevice: PhysicalDevice, pProperties: [*c]PhysicalDeviceProperties2) void;
pub extern fn vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice: PhysicalDevice, format: Format, pFormatProperties: [*c]FormatProperties2) void;
pub extern fn vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice: PhysicalDevice, pImageFormatInfo: [*c]const PhysicalDeviceImageFormatInfo2, pImageFormatProperties: [*c]ImageFormatProperties2) Result;
pub extern fn vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: [*c]u32, pQueueFamilyProperties: [*c]QueueFamilyProperties2) void;
pub extern fn vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice: PhysicalDevice, pMemoryProperties: [*c]PhysicalDeviceMemoryProperties2) void;
pub extern fn vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice: PhysicalDevice, pFormatInfo: [*c]const PhysicalDeviceSparseImageFormatInfo2, pPropertyCount: [*c]u32, pProperties: [*c]SparseImageFormatProperties2) void;
pub const PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
pub const PeerMemoryFeatureFlagBitsKHR = PeerMemoryFeatureFlagBits;
pub const MemoryAllocateFlagsKHR = MemoryAllocateFlags;
pub const MemoryAllocateFlagBitsKHR = MemoryAllocateFlagBits;
pub const MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
pub const DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
pub const DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
pub const DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
pub const DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
pub const BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
pub const BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
pub const PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = ?fn (Device, u32, u32, u32, [*c]PeerMemoryFeatureFlags) callconv(.C) void;
pub const PFN_vkCmdSetDeviceMaskKHR = ?fn (CommandBuffer, u32) callconv(.C) void;
pub const PFN_vkCmdDispatchBaseKHR = ?fn (CommandBuffer, u32, u32, u32, u32, u32, u32) callconv(.C) void;
pub extern fn vkGetDeviceGroupPeerMemoryFeaturesKHR(device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: [*c]PeerMemoryFeatureFlags) void;
pub extern fn vkCmdSetDeviceMaskKHR(commandBuffer: CommandBuffer, deviceMask: u32) void;
pub extern fn vkCmdDispatchBaseKHR(commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32) void;
pub const CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
pub const PFN_vkTrimCommandPoolKHR = ?fn (Device, CommandPool, CommandPoolTrimFlags) callconv(.C) void;
pub extern fn vkTrimCommandPoolKHR(device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags) void;
pub const PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
pub const DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
pub const PFN_vkEnumeratePhysicalDeviceGroupsKHR = ?fn (Instance, [*c]u32, [*c]PhysicalDeviceGroupProperties) callconv(.C) Result;
pub extern fn vkEnumeratePhysicalDeviceGroupsKHR(instance: Instance, pPhysicalDeviceGroupCount: [*c]u32, pPhysicalDeviceGroupProperties: [*c]PhysicalDeviceGroupProperties) Result;
pub const ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
pub const ExternalMemoryHandleTypeFlagBitsKHR = ExternalMemoryHandleTypeFlagBits;
pub const ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
pub const ExternalMemoryFeatureFlagBitsKHR = ExternalMemoryFeatureFlagBits;
pub const ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
pub const PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
pub const ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
pub const PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
pub const ExternalBufferPropertiesKHR = ExternalBufferProperties;
pub const PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
pub const PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = ?fn (PhysicalDevice, [*c]const PhysicalDeviceExternalBufferInfo, [*c]ExternalBufferProperties) callconv(.C) void;
pub extern fn vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice: PhysicalDevice, pExternalBufferInfo: [*c]const PhysicalDeviceExternalBufferInfo, pExternalBufferProperties: [*c]ExternalBufferProperties) void;
pub const ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
pub const ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
pub const ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
pub const struct_ImportMemoryFdInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleType: ExternalMemoryHandleTypeFlagBits,
fd: c_int,
};
pub const ImportMemoryFdInfoKHR = struct_ImportMemoryFdInfoKHR;
pub const struct_MemoryFdPropertiesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
memoryTypeBits: u32,
};
pub const MemoryFdPropertiesKHR = struct_MemoryFdPropertiesKHR;
pub const struct_MemoryGetFdInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
memory: DeviceMemory,
handleType: ExternalMemoryHandleTypeFlagBits,
};
pub const MemoryGetFdInfoKHR = struct_MemoryGetFdInfoKHR;
pub const PFN_vkGetMemoryFdKHR = ?fn (Device, [*c]const MemoryGetFdInfoKHR, [*c]c_int) callconv(.C) Result;
pub const PFN_vkGetMemoryFdPropertiesKHR = ?fn (Device, ExternalMemoryHandleTypeFlagBits, c_int, [*c]MemoryFdPropertiesKHR) callconv(.C) Result;
pub extern fn vkGetMemoryFdKHR(device: Device, pGetFdInfo: [*c]const MemoryGetFdInfoKHR, pFd: [*c]c_int) Result;
pub extern fn vkGetMemoryFdPropertiesKHR(device: Device, handleType: ExternalMemoryHandleTypeFlagBits, fd: c_int, pMemoryFdProperties: [*c]MemoryFdPropertiesKHR) Result;
pub const ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
pub const ExternalSemaphoreHandleTypeFlagBitsKHR = ExternalSemaphoreHandleTypeFlagBits;
pub const ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
pub const ExternalSemaphoreFeatureFlagBitsKHR = ExternalSemaphoreFeatureFlagBits;
pub const PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
pub const ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
pub const PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = ?fn (PhysicalDevice, [*c]const PhysicalDeviceExternalSemaphoreInfo, [*c]ExternalSemaphoreProperties) callconv(.C) void;
pub extern fn vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice: PhysicalDevice, pExternalSemaphoreInfo: [*c]const PhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: [*c]ExternalSemaphoreProperties) void;
pub const SemaphoreImportFlagsKHR = SemaphoreImportFlags;
pub const SemaphoreImportFlagBitsKHR = SemaphoreImportFlagBits;
pub const ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
pub const struct_ImportSemaphoreFdInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
semaphore: Semaphore,
flags: SemaphoreImportFlags,
handleType: ExternalSemaphoreHandleTypeFlagBits,
fd: c_int,
};
pub const ImportSemaphoreFdInfoKHR = struct_ImportSemaphoreFdInfoKHR;
pub const struct_SemaphoreGetFdInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
semaphore: Semaphore,
handleType: ExternalSemaphoreHandleTypeFlagBits,
};
pub const SemaphoreGetFdInfoKHR = struct_SemaphoreGetFdInfoKHR;
pub const PFN_vkImportSemaphoreFdKHR = ?fn (Device, [*c]const ImportSemaphoreFdInfoKHR) callconv(.C) Result;
pub const PFN_vkGetSemaphoreFdKHR = ?fn (Device, [*c]const SemaphoreGetFdInfoKHR, [*c]c_int) callconv(.C) Result;
pub extern fn vkImportSemaphoreFdKHR(device: Device, pImportSemaphoreFdInfo: [*c]const ImportSemaphoreFdInfoKHR) Result;
pub extern fn vkGetSemaphoreFdKHR(device: Device, pGetFdInfo: [*c]const SemaphoreGetFdInfoKHR, pFd: [*c]c_int) Result;
pub const struct_PhysicalDevicePushDescriptorPropertiesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxPushDescriptors: u32,
};
pub const PhysicalDevicePushDescriptorPropertiesKHR = struct_PhysicalDevicePushDescriptorPropertiesKHR;
pub const PFN_vkCmdPushDescriptorSetKHR = ?fn (CommandBuffer, PipelineBindPoint, PipelineLayout, u32, u32, [*c]const WriteDescriptorSet) callconv(.C) void;
pub const PFN_vkCmdPushDescriptorSetWithTemplateKHR = ?fn (CommandBuffer, DescriptorUpdateTemplate, PipelineLayout, u32, ?*const c_void) callconv(.C) void;
pub extern fn vkCmdPushDescriptorSetKHR(commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: [*c]const WriteDescriptorSet) void;
pub extern fn vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer: CommandBuffer, descriptorUpdateTemplate: DescriptorUpdateTemplate, layout: PipelineLayout, set: u32, pData: ?*const c_void) void;
pub const PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
pub const PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
pub const PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
pub const struct_RectLayerKHR = extern struct {
offset: Offset2D,
extent: Extent2D,
layer: u32,
};
pub const RectLayerKHR = struct_RectLayerKHR;
pub const struct_PresentRegionKHR = extern struct {
rectangleCount: u32,
pRectangles: [*c]const RectLayerKHR,
};
pub const PresentRegionKHR = struct_PresentRegionKHR;
pub const struct_PresentRegionsKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
swapchainCount: u32,
pRegions: [*c]const PresentRegionKHR,
};
pub const PresentRegionsKHR = struct_PresentRegionsKHR;
pub const DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
pub const DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType;
pub const DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
pub const DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
pub const DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
pub const PFN_vkCreateDescriptorUpdateTemplateKHR = ?fn (Device, [*c]const DescriptorUpdateTemplateCreateInfo, [*c]const AllocationCallbacks, [*c]DescriptorUpdateTemplate) callconv(.C) Result;
pub const PFN_vkDestroyDescriptorUpdateTemplateKHR = ?fn (Device, DescriptorUpdateTemplate, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkUpdateDescriptorSetWithTemplateKHR = ?fn (Device, DescriptorSet, DescriptorUpdateTemplate, ?*const c_void) callconv(.C) void;
pub extern fn vkCreateDescriptorUpdateTemplateKHR(device: Device, pCreateInfo: [*c]const DescriptorUpdateTemplateCreateInfo, pAllocator: [*c]const AllocationCallbacks, pDescriptorUpdateTemplate: [*c]DescriptorUpdateTemplate) Result;
pub extern fn vkDestroyDescriptorUpdateTemplateKHR(device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkUpdateDescriptorSetWithTemplateKHR(device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: ?*const c_void) void;
pub const PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
pub const FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
pub const FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
pub const RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
pub const RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
pub const AttachmentDescription2KHR = AttachmentDescription2;
pub const AttachmentReference2KHR = AttachmentReference2;
pub const SubpassDescription2KHR = SubpassDescription2;
pub const SubpassDependency2KHR = SubpassDependency2;
pub const SubpassBeginInfoKHR = SubpassBeginInfo;
pub const SubpassEndInfoKHR = SubpassEndInfo;
pub const PFN_vkCreateRenderPass2KHR = ?fn (Device, [*c]const RenderPassCreateInfo2, [*c]const AllocationCallbacks, [*c]RenderPass) callconv(.C) Result;
pub const PFN_vkCmdBeginRenderPass2KHR = ?fn (CommandBuffer, [*c]const RenderPassBeginInfo, [*c]const SubpassBeginInfo) callconv(.C) void;
pub const PFN_vkCmdNextSubpass2KHR = ?fn (CommandBuffer, [*c]const SubpassBeginInfo, [*c]const SubpassEndInfo) callconv(.C) void;
pub const PFN_vkCmdEndRenderPass2KHR = ?fn (CommandBuffer, [*c]const SubpassEndInfo) callconv(.C) void;
pub extern fn vkCreateRenderPass2KHR(device: Device, pCreateInfo: [*c]const RenderPassCreateInfo2, pAllocator: [*c]const AllocationCallbacks, pRenderPass: [*c]RenderPass) Result;
pub extern fn vkCmdBeginRenderPass2KHR(commandBuffer: CommandBuffer, pRenderPassBegin: [*c]const RenderPassBeginInfo, pSubpassBeginInfo: [*c]const SubpassBeginInfo) void;
pub extern fn vkCmdNextSubpass2KHR(commandBuffer: CommandBuffer, pSubpassBeginInfo: [*c]const SubpassBeginInfo, pSubpassEndInfo: [*c]const SubpassEndInfo) void;
pub extern fn vkCmdEndRenderPass2KHR(commandBuffer: CommandBuffer, pSubpassEndInfo: [*c]const SubpassEndInfo) void;
pub const struct_SharedPresentSurfaceCapabilitiesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
sharedPresentSupportedUsageFlags: ImageUsageFlags,
};
pub const SharedPresentSurfaceCapabilitiesKHR = struct_SharedPresentSurfaceCapabilitiesKHR;
pub const PFN_vkGetSwapchainStatusKHR = ?fn (Device, SwapchainKHR) callconv(.C) Result;
pub extern fn vkGetSwapchainStatusKHR(device: Device, swapchain: SwapchainKHR) Result;
pub const ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
pub const ExternalFenceHandleTypeFlagBitsKHR = ExternalFenceHandleTypeFlagBits;
pub const ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
pub const ExternalFenceFeatureFlagBitsKHR = ExternalFenceFeatureFlagBits;
pub const PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
pub const ExternalFencePropertiesKHR = ExternalFenceProperties;
pub const PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = ?fn (PhysicalDevice, [*c]const PhysicalDeviceExternalFenceInfo, [*c]ExternalFenceProperties) callconv(.C) void;
pub extern fn vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice: PhysicalDevice, pExternalFenceInfo: [*c]const PhysicalDeviceExternalFenceInfo, pExternalFenceProperties: [*c]ExternalFenceProperties) void;
pub const FenceImportFlagsKHR = FenceImportFlags;
pub const FenceImportFlagBitsKHR = FenceImportFlagBits;
pub const ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
pub const struct_ImportFenceFdInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
fence: Fence,
flags: FenceImportFlags,
handleType: ExternalFenceHandleTypeFlagBits,
fd: c_int,
};
pub const ImportFenceFdInfoKHR = struct_ImportFenceFdInfoKHR;
pub const struct_FenceGetFdInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
fence: Fence,
handleType: ExternalFenceHandleTypeFlagBits,
};
pub const FenceGetFdInfoKHR = struct_FenceGetFdInfoKHR;
pub const PFN_vkImportFenceFdKHR = ?fn (Device, [*c]const ImportFenceFdInfoKHR) callconv(.C) Result;
pub const PFN_vkGetFenceFdKHR = ?fn (Device, [*c]const FenceGetFdInfoKHR, [*c]c_int) callconv(.C) Result;
pub extern fn vkImportFenceFdKHR(device: Device, pImportFenceFdInfo: [*c]const ImportFenceFdInfoKHR) Result;
pub extern fn vkGetFenceFdKHR(device: Device, pGetFdInfo: [*c]const FenceGetFdInfoKHR, pFd: [*c]c_int) Result;
pub const PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_GENERIC_KHR);
pub const PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR);
pub const PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR);
pub const PERFORMANCE_COUNTER_UNIT_BYTES_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_BYTES_KHR);
pub const PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR);
pub const PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_KELVIN_KHR);
pub const PERFORMANCE_COUNTER_UNIT_WATTS_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_WATTS_KHR);
pub const PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_VOLTS_KHR);
pub const PERFORMANCE_COUNTER_UNIT_AMPS_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_AMPS_KHR);
pub const PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_HERTZ_KHR);
pub const PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_CYCLES_KHR);
pub const PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = @enumToInt(enum_PerformanceCounterUnitKHR.PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR);
pub const enum_PerformanceCounterUnitKHR = extern enum(c_int) {
PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 2147483647,
_,
};
pub const PerformanceCounterUnitKHR = enum_PerformanceCounterUnitKHR;
pub const PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = @enumToInt(enum_PerformanceCounterScopeKHR.PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR);
pub const PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = @enumToInt(enum_PerformanceCounterScopeKHR.PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR);
pub const PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = @enumToInt(enum_PerformanceCounterScopeKHR.PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR);
pub const QUERY_SCOPE_COMMAND_BUFFER_KHR = @enumToInt(enum_PerformanceCounterScopeKHR.QUERY_SCOPE_COMMAND_BUFFER_KHR);
pub const QUERY_SCOPE_RENDER_PASS_KHR = @enumToInt(enum_PerformanceCounterScopeKHR.QUERY_SCOPE_RENDER_PASS_KHR);
pub const QUERY_SCOPE_COMMAND_KHR = @enumToInt(enum_PerformanceCounterScopeKHR.QUERY_SCOPE_COMMAND_KHR);
pub const PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = @enumToInt(enum_PerformanceCounterScopeKHR.PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR);
pub const enum_PerformanceCounterScopeKHR = extern enum(c_int) {
PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0,
PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1,
PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2,
QUERY_SCOPE_COMMAND_BUFFER_KHR = 0,
QUERY_SCOPE_RENDER_PASS_KHR = 1,
QUERY_SCOPE_COMMAND_KHR = 2,
PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 2147483647,
_,
};
pub const PerformanceCounterScopeKHR = enum_PerformanceCounterScopeKHR;
pub const PERFORMANCE_COUNTER_STORAGE_INT32_KHR = @enumToInt(enum_PerformanceCounterStorageKHR.PERFORMANCE_COUNTER_STORAGE_INT32_KHR);
pub const PERFORMANCE_COUNTER_STORAGE_INT64_KHR = @enumToInt(enum_PerformanceCounterStorageKHR.PERFORMANCE_COUNTER_STORAGE_INT64_KHR);
pub const PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = @enumToInt(enum_PerformanceCounterStorageKHR.PERFORMANCE_COUNTER_STORAGE_UINT32_KHR);
pub const PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = @enumToInt(enum_PerformanceCounterStorageKHR.PERFORMANCE_COUNTER_STORAGE_UINT64_KHR);
pub const PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = @enumToInt(enum_PerformanceCounterStorageKHR.PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR);
pub const PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = @enumToInt(enum_PerformanceCounterStorageKHR.PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR);
pub const PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = @enumToInt(enum_PerformanceCounterStorageKHR.PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR);
pub const enum_PerformanceCounterStorageKHR = extern enum(c_int) {
PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 2147483647,
_,
};
pub const PerformanceCounterStorageKHR = enum_PerformanceCounterStorageKHR;
pub const PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = @enumToInt(enum_PerformanceCounterDescriptionFlagBitsKHR.PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR);
pub const PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = @enumToInt(enum_PerformanceCounterDescriptionFlagBitsKHR.PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR);
pub const PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = @enumToInt(enum_PerformanceCounterDescriptionFlagBitsKHR.PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR);
pub const PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = @enumToInt(enum_PerformanceCounterDescriptionFlagBitsKHR.PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR);
pub const PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_PerformanceCounterDescriptionFlagBitsKHR.PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_PerformanceCounterDescriptionFlagBitsKHR = extern enum(c_int) {
PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 1,
PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 2,
PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 1,
PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 2,
PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const PerformanceCounterDescriptionFlagBitsKHR = enum_PerformanceCounterDescriptionFlagBitsKHR;
pub const PerformanceCounterDescriptionFlagsKHR = Flags;
pub const ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_AcquireProfilingLockFlagBitsKHR.ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_AcquireProfilingLockFlagBitsKHR = extern enum(c_int) {
ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const AcquireProfilingLockFlagBitsKHR = enum_AcquireProfilingLockFlagBitsKHR;
pub const AcquireProfilingLockFlagsKHR = Flags;
pub const struct_PhysicalDevicePerformanceQueryFeaturesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
performanceCounterQueryPools: Bool32,
performanceCounterMultipleQueryPools: Bool32,
};
pub const PhysicalDevicePerformanceQueryFeaturesKHR = struct_PhysicalDevicePerformanceQueryFeaturesKHR;
pub const struct_PhysicalDevicePerformanceQueryPropertiesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
allowCommandBufferQueryCopies: Bool32,
};
pub const PhysicalDevicePerformanceQueryPropertiesKHR = struct_PhysicalDevicePerformanceQueryPropertiesKHR;
pub const struct_PerformanceCounterKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
unit: PerformanceCounterUnitKHR,
scope: PerformanceCounterScopeKHR,
storage: PerformanceCounterStorageKHR,
uuid: [16]u8,
};
pub const PerformanceCounterKHR = struct_PerformanceCounterKHR;
pub const struct_PerformanceCounterDescriptionKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PerformanceCounterDescriptionFlagsKHR,
name: [256]u8,
category: [256]u8,
description: [256]u8,
};
pub const PerformanceCounterDescriptionKHR = struct_PerformanceCounterDescriptionKHR;
pub const struct_QueryPoolPerformanceCreateInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
queueFamilyIndex: u32,
counterIndexCount: u32,
pCounterIndices: [*c]const u32,
};
pub const QueryPoolPerformanceCreateInfoKHR = struct_QueryPoolPerformanceCreateInfoKHR;
pub const union_PerformanceCounterResultKHR = extern union {
int32: i32,
int64: i64,
uint32: u32,
uint64: u64,
float32: f32,
float64: f64,
};
pub const PerformanceCounterResultKHR = union_PerformanceCounterResultKHR;
pub const struct_AcquireProfilingLockInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: AcquireProfilingLockFlagsKHR,
timeout: u64,
};
pub const AcquireProfilingLockInfoKHR = struct_AcquireProfilingLockInfoKHR;
pub const struct_PerformanceQuerySubmitInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
counterPassIndex: u32,
};
pub const PerformanceQuerySubmitInfoKHR = struct_PerformanceQuerySubmitInfoKHR;
pub const PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = ?fn (PhysicalDevice, u32, [*c]u32, [*c]PerformanceCounterKHR, [*c]PerformanceCounterDescriptionKHR) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = ?fn (PhysicalDevice, [*c]const QueryPoolPerformanceCreateInfoKHR, [*c]u32) callconv(.C) void;
pub const PFN_vkAcquireProfilingLockKHR = ?fn (Device, [*c]const AcquireProfilingLockInfoKHR) callconv(.C) Result;
pub const PFN_vkReleaseProfilingLockKHR = ?fn (Device) callconv(.C) void;
pub extern fn vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice: PhysicalDevice, queueFamilyIndex: u32, pCounterCount: [*c]u32, pCounters: [*c]PerformanceCounterKHR, pCounterDescriptions: [*c]PerformanceCounterDescriptionKHR) Result;
pub extern fn vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice: PhysicalDevice, pPerformanceQueryCreateInfo: [*c]const QueryPoolPerformanceCreateInfoKHR, pNumPasses: [*c]u32) void;
pub extern fn vkAcquireProfilingLockKHR(device: Device, pInfo: [*c]const AcquireProfilingLockInfoKHR) Result;
pub extern fn vkReleaseProfilingLockKHR(device: Device) void;
pub const PointClippingBehaviorKHR = PointClippingBehavior;
pub const TessellationDomainOriginKHR = TessellationDomainOrigin;
pub const PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
pub const RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
pub const InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
pub const ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
pub const PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
pub const struct_PhysicalDeviceSurfaceInfo2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
surface: SurfaceKHR,
};
pub const PhysicalDeviceSurfaceInfo2KHR = struct_PhysicalDeviceSurfaceInfo2KHR;
pub const struct_SurfaceCapabilities2KHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
surfaceCapabilities: SurfaceCapabilitiesKHR,
};
pub const SurfaceCapabilities2KHR = struct_SurfaceCapabilities2KHR;
pub const struct_SurfaceFormat2KHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
surfaceFormat: SurfaceFormatKHR,
};
pub const SurfaceFormat2KHR = struct_SurfaceFormat2KHR;
pub const PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = ?fn (PhysicalDevice, [*c]const PhysicalDeviceSurfaceInfo2KHR, [*c]SurfaceCapabilities2KHR) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = ?fn (PhysicalDevice, [*c]const PhysicalDeviceSurfaceInfo2KHR, [*c]u32, [*c]SurfaceFormat2KHR) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice: PhysicalDevice, pSurfaceInfo: [*c]const PhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: [*c]SurfaceCapabilities2KHR) Result;
pub extern fn vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice: PhysicalDevice, pSurfaceInfo: [*c]const PhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: [*c]u32, pSurfaceFormats: [*c]SurfaceFormat2KHR) Result;
pub const PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
pub const PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
pub const struct_DisplayProperties2KHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
displayProperties: DisplayPropertiesKHR,
};
pub const DisplayProperties2KHR = struct_DisplayProperties2KHR;
pub const struct_DisplayPlaneProperties2KHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
displayPlaneProperties: DisplayPlanePropertiesKHR,
};
pub const DisplayPlaneProperties2KHR = struct_DisplayPlaneProperties2KHR;
pub const struct_DisplayModeProperties2KHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
displayModeProperties: DisplayModePropertiesKHR,
};
pub const DisplayModeProperties2KHR = struct_DisplayModeProperties2KHR;
pub const struct_DisplayPlaneInfo2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
mode: DisplayModeKHR,
planeIndex: u32,
};
pub const DisplayPlaneInfo2KHR = struct_DisplayPlaneInfo2KHR;
pub const struct_DisplayPlaneCapabilities2KHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
capabilities: DisplayPlaneCapabilitiesKHR,
};
pub const DisplayPlaneCapabilities2KHR = struct_DisplayPlaneCapabilities2KHR;
pub const PFN_vkGetPhysicalDeviceDisplayProperties2KHR = ?fn (PhysicalDevice, [*c]u32, [*c]DisplayProperties2KHR) callconv(.C) Result;
pub const PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = ?fn (PhysicalDevice, [*c]u32, [*c]DisplayPlaneProperties2KHR) callconv(.C) Result;
pub const PFN_vkGetDisplayModeProperties2KHR = ?fn (PhysicalDevice, DisplayKHR, [*c]u32, [*c]DisplayModeProperties2KHR) callconv(.C) Result;
pub const PFN_vkGetDisplayPlaneCapabilities2KHR = ?fn (PhysicalDevice, [*c]const DisplayPlaneInfo2KHR, [*c]DisplayPlaneCapabilities2KHR) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice: PhysicalDevice, pPropertyCount: [*c]u32, pProperties: [*c]DisplayProperties2KHR) Result;
pub extern fn vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice: PhysicalDevice, pPropertyCount: [*c]u32, pProperties: [*c]DisplayPlaneProperties2KHR) Result;
pub extern fn vkGetDisplayModeProperties2KHR(physicalDevice: PhysicalDevice, display: DisplayKHR, pPropertyCount: [*c]u32, pProperties: [*c]DisplayModeProperties2KHR) Result;
pub extern fn vkGetDisplayPlaneCapabilities2KHR(physicalDevice: PhysicalDevice, pDisplayPlaneInfo: [*c]const DisplayPlaneInfo2KHR, pCapabilities: [*c]DisplayPlaneCapabilities2KHR) Result;
pub const MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
pub const MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
pub const BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
pub const ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
pub const ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
pub const MemoryRequirements2KHR = MemoryRequirements2;
pub const SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
pub const PFN_vkGetImageMemoryRequirements2KHR = ?fn (Device, [*c]const ImageMemoryRequirementsInfo2, [*c]MemoryRequirements2) callconv(.C) void;
pub const PFN_vkGetBufferMemoryRequirements2KHR = ?fn (Device, [*c]const BufferMemoryRequirementsInfo2, [*c]MemoryRequirements2) callconv(.C) void;
pub const PFN_vkGetImageSparseMemoryRequirements2KHR = ?fn (Device, [*c]const ImageSparseMemoryRequirementsInfo2, [*c]u32, [*c]SparseImageMemoryRequirements2) callconv(.C) void;
pub extern fn vkGetImageMemoryRequirements2KHR(device: Device, pInfo: [*c]const ImageMemoryRequirementsInfo2, pMemoryRequirements: [*c]MemoryRequirements2) void;
pub extern fn vkGetBufferMemoryRequirements2KHR(device: Device, pInfo: [*c]const BufferMemoryRequirementsInfo2, pMemoryRequirements: [*c]MemoryRequirements2) void;
pub extern fn vkGetImageSparseMemoryRequirements2KHR(device: Device, pInfo: [*c]const ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: [*c]u32, pSparseMemoryRequirements: [*c]SparseImageMemoryRequirements2) void;
pub const ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
pub const SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
pub const SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion;
pub const SamplerYcbcrRangeKHR = SamplerYcbcrRange;
pub const ChromaLocationKHR = ChromaLocation;
pub const SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
pub const SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
pub const BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
pub const ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
pub const PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
pub const SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
pub const PFN_vkCreateSamplerYcbcrConversionKHR = ?fn (Device, [*c]const SamplerYcbcrConversionCreateInfo, [*c]const AllocationCallbacks, [*c]SamplerYcbcrConversion) callconv(.C) Result;
pub const PFN_vkDestroySamplerYcbcrConversionKHR = ?fn (Device, SamplerYcbcrConversion, [*c]const AllocationCallbacks) callconv(.C) void;
pub extern fn vkCreateSamplerYcbcrConversionKHR(device: Device, pCreateInfo: [*c]const SamplerYcbcrConversionCreateInfo, pAllocator: [*c]const AllocationCallbacks, pYcbcrConversion: [*c]SamplerYcbcrConversion) Result;
pub extern fn vkDestroySamplerYcbcrConversionKHR(device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: [*c]const AllocationCallbacks) void;
pub const BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
pub const BindImageMemoryInfoKHR = BindImageMemoryInfo;
pub const PFN_vkBindBufferMemory2KHR = ?fn (Device, u32, [*c]const BindBufferMemoryInfo) callconv(.C) Result;
pub const PFN_vkBindImageMemory2KHR = ?fn (Device, u32, [*c]const BindImageMemoryInfo) callconv(.C) Result;
pub extern fn vkBindBufferMemory2KHR(device: Device, bindInfoCount: u32, pBindInfos: [*c]const BindBufferMemoryInfo) Result;
pub extern fn vkBindImageMemory2KHR(device: Device, bindInfoCount: u32, pBindInfos: [*c]const BindImageMemoryInfo) Result;
pub const PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
pub const DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
pub const PFN_vkGetDescriptorSetLayoutSupportKHR = ?fn (Device, [*c]const DescriptorSetLayoutCreateInfo, [*c]DescriptorSetLayoutSupport) callconv(.C) void;
pub extern fn vkGetDescriptorSetLayoutSupportKHR(device: Device, pCreateInfo: [*c]const DescriptorSetLayoutCreateInfo, pSupport: [*c]DescriptorSetLayoutSupport) void;
pub const PFN_vkCmdDrawIndirectCountKHR = ?fn (CommandBuffer, Buffer, DeviceSize, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawIndexedIndirectCountKHR = ?fn (CommandBuffer, Buffer, DeviceSize, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub extern fn vkCmdDrawIndirectCountKHR(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) void;
pub extern fn vkCmdDrawIndexedIndirectCountKHR(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) void;
pub const PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
pub const PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
pub const PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
pub const struct_PhysicalDeviceShaderClockFeaturesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderSubgroupClock: Bool32,
shaderDeviceClock: Bool32,
};
pub const PhysicalDeviceShaderClockFeaturesKHR = struct_PhysicalDeviceShaderClockFeaturesKHR;
pub const DriverIdKHR = DriverId;
pub const ConformanceVersionKHR = ConformanceVersion;
pub const PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
pub const ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence;
pub const PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
pub const ResolveModeFlagBitsKHR = ResolveModeFlagBits;
pub const ResolveModeFlagsKHR = ResolveModeFlags;
pub const SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
pub const PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
pub const SemaphoreTypeKHR = SemaphoreType;
pub const SemaphoreWaitFlagBitsKHR = SemaphoreWaitFlagBits;
pub const SemaphoreWaitFlagsKHR = SemaphoreWaitFlags;
pub const PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
pub const PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
pub const SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
pub const TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
pub const SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
pub const SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
pub const PFN_vkGetSemaphoreCounterValueKHR = ?fn (Device, Semaphore, [*c]u64) callconv(.C) Result;
pub const PFN_vkWaitSemaphoresKHR = ?fn (Device, [*c]const SemaphoreWaitInfo, u64) callconv(.C) Result;
pub const PFN_vkSignalSemaphoreKHR = ?fn (Device, [*c]const SemaphoreSignalInfo) callconv(.C) Result;
pub extern fn vkGetSemaphoreCounterValueKHR(device: Device, semaphore: Semaphore, pValue: [*c]u64) Result;
pub extern fn vkWaitSemaphoresKHR(device: Device, pWaitInfo: [*c]const SemaphoreWaitInfo, timeout: u64) Result;
pub extern fn vkSignalSemaphoreKHR(device: Device, pSignalInfo: [*c]const SemaphoreSignalInfo) Result;
pub const PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
pub const struct_PhysicalDeviceShaderTerminateInvocationFeaturesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderTerminateInvocation: Bool32,
};
pub const PhysicalDeviceShaderTerminateInvocationFeaturesKHR = struct_PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
pub const FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = @enumToInt(enum_FragmentShadingRateCombinerOpKHR.FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR);
pub const FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = @enumToInt(enum_FragmentShadingRateCombinerOpKHR.FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR);
pub const FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = @enumToInt(enum_FragmentShadingRateCombinerOpKHR.FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR);
pub const FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = @enumToInt(enum_FragmentShadingRateCombinerOpKHR.FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR);
pub const FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = @enumToInt(enum_FragmentShadingRateCombinerOpKHR.FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR);
pub const FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = @enumToInt(enum_FragmentShadingRateCombinerOpKHR.FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR);
pub const enum_FragmentShadingRateCombinerOpKHR = extern enum(c_int) {
FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0,
FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1,
FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2,
FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3,
FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4,
FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 2147483647,
_,
};
pub const FragmentShadingRateCombinerOpKHR = enum_FragmentShadingRateCombinerOpKHR;
pub const struct_FragmentShadingRateAttachmentInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pFragmentShadingRateAttachment: [*c]const AttachmentReference2,
shadingRateAttachmentTexelSize: Extent2D,
};
pub const FragmentShadingRateAttachmentInfoKHR = struct_FragmentShadingRateAttachmentInfoKHR;
pub const struct_PipelineFragmentShadingRateStateCreateInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
fragmentSize: Extent2D,
combinerOps: [2]FragmentShadingRateCombinerOpKHR,
};
pub const PipelineFragmentShadingRateStateCreateInfoKHR = struct_PipelineFragmentShadingRateStateCreateInfoKHR;
pub const struct_PhysicalDeviceFragmentShadingRateFeaturesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
pipelineFragmentShadingRate: Bool32,
primitiveFragmentShadingRate: Bool32,
attachmentFragmentShadingRate: Bool32,
};
pub const PhysicalDeviceFragmentShadingRateFeaturesKHR = struct_PhysicalDeviceFragmentShadingRateFeaturesKHR;
pub const struct_PhysicalDeviceFragmentShadingRatePropertiesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
minFragmentShadingRateAttachmentTexelSize: Extent2D,
maxFragmentShadingRateAttachmentTexelSize: Extent2D,
maxFragmentShadingRateAttachmentTexelSizeAspectRatio: u32,
primitiveFragmentShadingRateWithMultipleViewports: Bool32,
layeredShadingRateAttachments: Bool32,
fragmentShadingRateNonTrivialCombinerOps: Bool32,
maxFragmentSize: Extent2D,
maxFragmentSizeAspectRatio: u32,
maxFragmentShadingRateCoverageSamples: u32,
maxFragmentShadingRateRasterizationSamples: SampleCountFlagBits,
fragmentShadingRateWithShaderDepthStencilWrites: Bool32,
fragmentShadingRateWithSampleMask: Bool32,
fragmentShadingRateWithShaderSampleMask: Bool32,
fragmentShadingRateWithConservativeRasterization: Bool32,
fragmentShadingRateWithFragmentShaderInterlock: Bool32,
fragmentShadingRateWithCustomSampleLocations: Bool32,
fragmentShadingRateStrictMultiplyCombiner: Bool32,
};
pub const PhysicalDeviceFragmentShadingRatePropertiesKHR = struct_PhysicalDeviceFragmentShadingRatePropertiesKHR;
pub const struct_PhysicalDeviceFragmentShadingRateKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
sampleCounts: SampleCountFlags,
fragmentSize: Extent2D,
};
pub const PhysicalDeviceFragmentShadingRateKHR = struct_PhysicalDeviceFragmentShadingRateKHR;
pub const PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = ?fn (PhysicalDevice, [*c]u32, [*c]PhysicalDeviceFragmentShadingRateKHR) callconv(.C) Result;
pub const PFN_vkCmdSetFragmentShadingRateKHR = ?fn (CommandBuffer, [*c]const Extent2D, [*c]const FragmentShadingRateCombinerOpKHR) callconv(.C) void;
pub extern fn vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice: PhysicalDevice, pFragmentShadingRateCount: [*c]u32, pFragmentShadingRates: [*c]PhysicalDeviceFragmentShadingRateKHR) Result;
pub extern fn vkCmdSetFragmentShadingRateKHR(commandBuffer: CommandBuffer, pFragmentSize: [*c]const Extent2D, combinerOps: [*c]const FragmentShadingRateCombinerOpKHR) void;
pub const struct_SurfaceProtectedCapabilitiesKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
supportsProtected: Bool32,
};
pub const SurfaceProtectedCapabilitiesKHR = struct_SurfaceProtectedCapabilitiesKHR;
pub const PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
pub const AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
pub const AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
pub const PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
pub const PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
pub const BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
pub const BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
pub const MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
pub const DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
pub const PFN_vkGetBufferDeviceAddressKHR = ?fn (Device, [*c]const BufferDeviceAddressInfo) callconv(.C) DeviceAddress;
pub const PFN_vkGetBufferOpaqueCaptureAddressKHR = ?fn (Device, [*c]const BufferDeviceAddressInfo) callconv(.C) u64;
pub const PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = ?fn (Device, [*c]const DeviceMemoryOpaqueCaptureAddressInfo) callconv(.C) u64;
pub extern fn vkGetBufferDeviceAddressKHR(device: Device, pInfo: [*c]const BufferDeviceAddressInfo) DeviceAddress;
pub extern fn vkGetBufferOpaqueCaptureAddressKHR(device: Device, pInfo: [*c]const BufferDeviceAddressInfo) u64;
pub extern fn vkGetDeviceMemoryOpaqueCaptureAddressKHR(device: Device, pInfo: [*c]const DeviceMemoryOpaqueCaptureAddressInfo) u64;
pub const PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = @enumToInt(enum_PipelineExecutableStatisticFormatKHR.PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR);
pub const PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = @enumToInt(enum_PipelineExecutableStatisticFormatKHR.PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR);
pub const PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = @enumToInt(enum_PipelineExecutableStatisticFormatKHR.PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR);
pub const PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = @enumToInt(enum_PipelineExecutableStatisticFormatKHR.PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR);
pub const PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = @enumToInt(enum_PipelineExecutableStatisticFormatKHR.PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR);
pub const enum_PipelineExecutableStatisticFormatKHR = extern enum(c_int) {
PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 2147483647,
_,
};
pub const PipelineExecutableStatisticFormatKHR = enum_PipelineExecutableStatisticFormatKHR;
pub const struct_PhysicalDevicePipelineExecutablePropertiesFeaturesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
pipelineExecutableInfo: Bool32,
};
pub const PhysicalDevicePipelineExecutablePropertiesFeaturesKHR = struct_PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
pub const struct_PipelineInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pipeline: Pipeline,
};
pub const PipelineInfoKHR = struct_PipelineInfoKHR;
pub const struct_PipelineExecutablePropertiesKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
stages: ShaderStageFlags,
name: [256]u8,
description: [256]u8,
subgroupSize: u32,
};
pub const PipelineExecutablePropertiesKHR = struct_PipelineExecutablePropertiesKHR;
pub const struct_PipelineExecutableInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pipeline: Pipeline,
executableIndex: u32,
};
pub const PipelineExecutableInfoKHR = struct_PipelineExecutableInfoKHR;
pub const union_PipelineExecutableStatisticValueKHR = extern union {
b32: Bool32,
i64: i64,
u64: u64,
f64: f64,
};
pub const PipelineExecutableStatisticValueKHR = union_PipelineExecutableStatisticValueKHR;
pub const struct_PipelineExecutableStatisticKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
name: [256]u8,
description: [256]u8,
format: PipelineExecutableStatisticFormatKHR,
value: PipelineExecutableStatisticValueKHR,
};
pub const PipelineExecutableStatisticKHR = struct_PipelineExecutableStatisticKHR;
pub const struct_PipelineExecutableInternalRepresentationKHR = extern struct {
sType: StructureType,
pNext: ?*c_void,
name: [256]u8,
description: [256]u8,
isText: Bool32,
dataSize: usize,
pData: ?*c_void,
};
pub const PipelineExecutableInternalRepresentationKHR = struct_PipelineExecutableInternalRepresentationKHR;
pub const PFN_vkGetPipelineExecutablePropertiesKHR = ?fn (Device, [*c]const PipelineInfoKHR, [*c]u32, [*c]PipelineExecutablePropertiesKHR) callconv(.C) Result;
pub const PFN_vkGetPipelineExecutableStatisticsKHR = ?fn (Device, [*c]const PipelineExecutableInfoKHR, [*c]u32, [*c]PipelineExecutableStatisticKHR) callconv(.C) Result;
pub const PFN_vkGetPipelineExecutableInternalRepresentationsKHR = ?fn (Device, [*c]const PipelineExecutableInfoKHR, [*c]u32, [*c]PipelineExecutableInternalRepresentationKHR) callconv(.C) Result;
pub extern fn vkGetPipelineExecutablePropertiesKHR(device: Device, pPipelineInfo: [*c]const PipelineInfoKHR, pExecutableCount: [*c]u32, pProperties: [*c]PipelineExecutablePropertiesKHR) Result;
pub extern fn vkGetPipelineExecutableStatisticsKHR(device: Device, pExecutableInfo: [*c]const PipelineExecutableInfoKHR, pStatisticCount: [*c]u32, pStatistics: [*c]PipelineExecutableStatisticKHR) Result;
pub extern fn vkGetPipelineExecutableInternalRepresentationsKHR(device: Device, pExecutableInfo: [*c]const PipelineExecutableInfoKHR, pInternalRepresentationCount: [*c]u32, pInternalRepresentations: [*c]PipelineExecutableInternalRepresentationKHR) Result;
pub const struct_BufferCopy2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcOffset: DeviceSize,
dstOffset: DeviceSize,
size: DeviceSize,
};
pub const BufferCopy2KHR = struct_BufferCopy2KHR;
pub const struct_CopyBufferInfo2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcBuffer: Buffer,
dstBuffer: Buffer,
regionCount: u32,
pRegions: [*c]const BufferCopy2KHR,
};
pub const CopyBufferInfo2KHR = struct_CopyBufferInfo2KHR;
pub const struct_ImageCopy2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcSubresource: ImageSubresourceLayers,
srcOffset: Offset3D,
dstSubresource: ImageSubresourceLayers,
dstOffset: Offset3D,
extent: Extent3D,
};
pub const ImageCopy2KHR = struct_ImageCopy2KHR;
pub const struct_CopyImageInfo2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcImage: Image,
srcImageLayout: ImageLayout,
dstImage: Image,
dstImageLayout: ImageLayout,
regionCount: u32,
pRegions: [*c]const ImageCopy2KHR,
};
pub const CopyImageInfo2KHR = struct_CopyImageInfo2KHR;
pub const struct_BufferImageCopy2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
bufferOffset: DeviceSize,
bufferRowLength: u32,
bufferImageHeight: u32,
imageSubresource: ImageSubresourceLayers,
imageOffset: Offset3D,
imageExtent: Extent3D,
};
pub const BufferImageCopy2KHR = struct_BufferImageCopy2KHR;
pub const struct_CopyBufferToImageInfo2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcBuffer: Buffer,
dstImage: Image,
dstImageLayout: ImageLayout,
regionCount: u32,
pRegions: [*c]const BufferImageCopy2KHR,
};
pub const CopyBufferToImageInfo2KHR = struct_CopyBufferToImageInfo2KHR;
pub const struct_CopyImageToBufferInfo2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcImage: Image,
srcImageLayout: ImageLayout,
dstBuffer: Buffer,
regionCount: u32,
pRegions: [*c]const BufferImageCopy2KHR,
};
pub const CopyImageToBufferInfo2KHR = struct_CopyImageToBufferInfo2KHR;
pub const struct_ImageBlit2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcSubresource: ImageSubresourceLayers,
srcOffsets: [2]Offset3D,
dstSubresource: ImageSubresourceLayers,
dstOffsets: [2]Offset3D,
};
pub const ImageBlit2KHR = struct_ImageBlit2KHR;
pub const struct_BlitImageInfo2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcImage: Image,
srcImageLayout: ImageLayout,
dstImage: Image,
dstImageLayout: ImageLayout,
regionCount: u32,
pRegions: [*c]const ImageBlit2KHR,
filter: Filter,
};
pub const BlitImageInfo2KHR = struct_BlitImageInfo2KHR;
pub const struct_ImageResolve2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcSubresource: ImageSubresourceLayers,
srcOffset: Offset3D,
dstSubresource: ImageSubresourceLayers,
dstOffset: Offset3D,
extent: Extent3D,
};
pub const ImageResolve2KHR = struct_ImageResolve2KHR;
pub const struct_ResolveImageInfo2KHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcImage: Image,
srcImageLayout: ImageLayout,
dstImage: Image,
dstImageLayout: ImageLayout,
regionCount: u32,
pRegions: [*c]const ImageResolve2KHR,
};
pub const ResolveImageInfo2KHR = struct_ResolveImageInfo2KHR;
pub const PFN_vkCmdCopyBuffer2KHR = ?fn (CommandBuffer, [*c]const CopyBufferInfo2KHR) callconv(.C) void;
pub const PFN_vkCmdCopyImage2KHR = ?fn (CommandBuffer, [*c]const CopyImageInfo2KHR) callconv(.C) void;
pub const PFN_vkCmdCopyBufferToImage2KHR = ?fn (CommandBuffer, [*c]const CopyBufferToImageInfo2KHR) callconv(.C) void;
pub const PFN_vkCmdCopyImageToBuffer2KHR = ?fn (CommandBuffer, [*c]const CopyImageToBufferInfo2KHR) callconv(.C) void;
pub const PFN_vkCmdBlitImage2KHR = ?fn (CommandBuffer, [*c]const BlitImageInfo2KHR) callconv(.C) void;
pub const PFN_vkCmdResolveImage2KHR = ?fn (CommandBuffer, [*c]const ResolveImageInfo2KHR) callconv(.C) void;
pub extern fn vkCmdCopyBuffer2KHR(commandBuffer: CommandBuffer, pCopyBufferInfo: [*c]const CopyBufferInfo2KHR) void;
pub extern fn vkCmdCopyImage2KHR(commandBuffer: CommandBuffer, pCopyImageInfo: [*c]const CopyImageInfo2KHR) void;
pub extern fn vkCmdCopyBufferToImage2KHR(commandBuffer: CommandBuffer, pCopyBufferToImageInfo: [*c]const CopyBufferToImageInfo2KHR) void;
pub extern fn vkCmdCopyImageToBuffer2KHR(commandBuffer: CommandBuffer, pCopyImageToBufferInfo: [*c]const CopyImageToBufferInfo2KHR) void;
pub extern fn vkCmdBlitImage2KHR(commandBuffer: CommandBuffer, pBlitImageInfo: [*c]const BlitImageInfo2KHR) void;
pub extern fn vkCmdResolveImage2KHR(commandBuffer: CommandBuffer, pResolveImageInfo: [*c]const ResolveImageInfo2KHR) void;
pub const struct_DebugReportCallbackEXT_T = opaque {};
pub const DebugReportCallbackEXT = ?*struct_DebugReportCallbackEXT_T;
pub const DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT);
pub const DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = @enumToInt(enum_DebugReportObjectTypeEXT.DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT);
pub const enum_DebugReportObjectTypeEXT = extern enum(c_int) {
DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,
DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000165000,
DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28,
DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = 33,
DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000,
DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DebugReportObjectTypeEXT = enum_DebugReportObjectTypeEXT;
pub const DEBUG_REPORT_INFORMATION_BIT_EXT = @enumToInt(enum_DebugReportFlagBitsEXT.DEBUG_REPORT_INFORMATION_BIT_EXT);
pub const DEBUG_REPORT_WARNING_BIT_EXT = @enumToInt(enum_DebugReportFlagBitsEXT.DEBUG_REPORT_WARNING_BIT_EXT);
pub const DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = @enumToInt(enum_DebugReportFlagBitsEXT.DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT);
pub const DEBUG_REPORT_ERROR_BIT_EXT = @enumToInt(enum_DebugReportFlagBitsEXT.DEBUG_REPORT_ERROR_BIT_EXT);
pub const DEBUG_REPORT_DEBUG_BIT_EXT = @enumToInt(enum_DebugReportFlagBitsEXT.DEBUG_REPORT_DEBUG_BIT_EXT);
pub const DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = @enumToInt(enum_DebugReportFlagBitsEXT.DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT);
pub const enum_DebugReportFlagBitsEXT = extern enum(c_int) {
DEBUG_REPORT_INFORMATION_BIT_EXT = 1,
DEBUG_REPORT_WARNING_BIT_EXT = 2,
DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 4,
DEBUG_REPORT_ERROR_BIT_EXT = 8,
DEBUG_REPORT_DEBUG_BIT_EXT = 16,
DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DebugReportFlagBitsEXT = enum_DebugReportFlagBitsEXT;
pub const DebugReportFlagsEXT = Flags;
pub const PFN_vkDebugReportCallbackEXT = ?fn (DebugReportFlagsEXT, DebugReportObjectTypeEXT, u64, usize, i32, [*c]const u8, [*c]const u8, ?*c_void) callconv(.C) Bool32;
pub const struct_DebugReportCallbackCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DebugReportFlagsEXT,
pfnCallback: PFN_vkDebugReportCallbackEXT,
pUserData: ?*c_void,
};
pub const DebugReportCallbackCreateInfoEXT = struct_DebugReportCallbackCreateInfoEXT;
pub const PFN_vkCreateDebugReportCallbackEXT = ?fn (Instance, [*c]const DebugReportCallbackCreateInfoEXT, [*c]const AllocationCallbacks, [*c]DebugReportCallbackEXT) callconv(.C) Result;
pub const PFN_vkDestroyDebugReportCallbackEXT = ?fn (Instance, DebugReportCallbackEXT, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkDebugReportMessageEXT = ?fn (Instance, DebugReportFlagsEXT, DebugReportObjectTypeEXT, u64, usize, i32, [*c]const u8, [*c]const u8) callconv(.C) void;
pub extern fn vkCreateDebugReportCallbackEXT(instance: Instance, pCreateInfo: [*c]const DebugReportCallbackCreateInfoEXT, pAllocator: [*c]const AllocationCallbacks, pCallback: [*c]DebugReportCallbackEXT) Result;
pub extern fn vkDestroyDebugReportCallbackEXT(instance: Instance, callback: DebugReportCallbackEXT, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkDebugReportMessageEXT(instance: Instance, flags: DebugReportFlagsEXT, objectType: DebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: [*c]const u8, pMessage: [*c]const u8) void;
pub const RASTERIZATION_ORDER_STRICT_AMD = @enumToInt(enum_RasterizationOrderAMD.RASTERIZATION_ORDER_STRICT_AMD);
pub const RASTERIZATION_ORDER_RELAXED_AMD = @enumToInt(enum_RasterizationOrderAMD.RASTERIZATION_ORDER_RELAXED_AMD);
pub const RASTERIZATION_ORDER_MAX_ENUM_AMD = @enumToInt(enum_RasterizationOrderAMD.RASTERIZATION_ORDER_MAX_ENUM_AMD);
pub const enum_RasterizationOrderAMD = extern enum(c_int) {
RASTERIZATION_ORDER_STRICT_AMD = 0,
RASTERIZATION_ORDER_RELAXED_AMD = 1,
RASTERIZATION_ORDER_MAX_ENUM_AMD = 2147483647,
_,
};
pub const RasterizationOrderAMD = enum_RasterizationOrderAMD;
pub const struct_PipelineRasterizationStateRasterizationOrderAMD = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
rasterizationOrder: RasterizationOrderAMD,
};
pub const PipelineRasterizationStateRasterizationOrderAMD = struct_PipelineRasterizationStateRasterizationOrderAMD;
pub const struct_DebugMarkerObjectNameInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
objectType: DebugReportObjectTypeEXT,
object: u64,
pObjectName: [*c]const u8,
};
pub const DebugMarkerObjectNameInfoEXT = struct_DebugMarkerObjectNameInfoEXT;
pub const struct_DebugMarkerObjectTagInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
objectType: DebugReportObjectTypeEXT,
object: u64,
tagName: u64,
tagSize: usize,
pTag: ?*const c_void,
};
pub const DebugMarkerObjectTagInfoEXT = struct_DebugMarkerObjectTagInfoEXT;
pub const struct_DebugMarkerMarkerInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pMarkerName: [*c]const u8,
color: [4]f32,
};
pub const DebugMarkerMarkerInfoEXT = struct_DebugMarkerMarkerInfoEXT;
pub const PFN_vkDebugMarkerSetObjectTagEXT = ?fn (Device, [*c]const DebugMarkerObjectTagInfoEXT) callconv(.C) Result;
pub const PFN_vkDebugMarkerSetObjectNameEXT = ?fn (Device, [*c]const DebugMarkerObjectNameInfoEXT) callconv(.C) Result;
pub const PFN_vkCmdDebugMarkerBeginEXT = ?fn (CommandBuffer, [*c]const DebugMarkerMarkerInfoEXT) callconv(.C) void;
pub const PFN_vkCmdDebugMarkerEndEXT = ?fn (CommandBuffer) callconv(.C) void;
pub const PFN_vkCmdDebugMarkerInsertEXT = ?fn (CommandBuffer, [*c]const DebugMarkerMarkerInfoEXT) callconv(.C) void;
pub extern fn vkDebugMarkerSetObjectTagEXT(device: Device, pTagInfo: [*c]const DebugMarkerObjectTagInfoEXT) Result;
pub extern fn vkDebugMarkerSetObjectNameEXT(device: Device, pNameInfo: [*c]const DebugMarkerObjectNameInfoEXT) Result;
pub extern fn vkCmdDebugMarkerBeginEXT(commandBuffer: CommandBuffer, pMarkerInfo: [*c]const DebugMarkerMarkerInfoEXT) void;
pub extern fn vkCmdDebugMarkerEndEXT(commandBuffer: CommandBuffer) void;
pub extern fn vkCmdDebugMarkerInsertEXT(commandBuffer: CommandBuffer, pMarkerInfo: [*c]const DebugMarkerMarkerInfoEXT) void;
pub const struct_DedicatedAllocationImageCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
dedicatedAllocation: Bool32,
};
pub const DedicatedAllocationImageCreateInfoNV = struct_DedicatedAllocationImageCreateInfoNV;
pub const struct_DedicatedAllocationBufferCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
dedicatedAllocation: Bool32,
};
pub const DedicatedAllocationBufferCreateInfoNV = struct_DedicatedAllocationBufferCreateInfoNV;
pub const struct_DedicatedAllocationMemoryAllocateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
image: Image,
buffer: Buffer,
};
pub const DedicatedAllocationMemoryAllocateInfoNV = struct_DedicatedAllocationMemoryAllocateInfoNV;
pub const PipelineRasterizationStateStreamCreateFlagsEXT = Flags;
pub const struct_PhysicalDeviceTransformFeedbackFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
transformFeedback: Bool32,
geometryStreams: Bool32,
};
pub const PhysicalDeviceTransformFeedbackFeaturesEXT = struct_PhysicalDeviceTransformFeedbackFeaturesEXT;
pub const struct_PhysicalDeviceTransformFeedbackPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxTransformFeedbackStreams: u32,
maxTransformFeedbackBuffers: u32,
maxTransformFeedbackBufferSize: DeviceSize,
maxTransformFeedbackStreamDataSize: u32,
maxTransformFeedbackBufferDataSize: u32,
maxTransformFeedbackBufferDataStride: u32,
transformFeedbackQueries: Bool32,
transformFeedbackStreamsLinesTriangles: Bool32,
transformFeedbackRasterizationStreamSelect: Bool32,
transformFeedbackDraw: Bool32,
};
pub const PhysicalDeviceTransformFeedbackPropertiesEXT = struct_PhysicalDeviceTransformFeedbackPropertiesEXT;
pub const struct_PipelineRasterizationStateStreamCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineRasterizationStateStreamCreateFlagsEXT,
rasterizationStream: u32,
};
pub const PipelineRasterizationStateStreamCreateInfoEXT = struct_PipelineRasterizationStateStreamCreateInfoEXT;
pub const PFN_vkCmdBindTransformFeedbackBuffersEXT = ?fn (CommandBuffer, u32, u32, [*c]const Buffer, [*c]const DeviceSize, [*c]const DeviceSize) callconv(.C) void;
pub const PFN_vkCmdBeginTransformFeedbackEXT = ?fn (CommandBuffer, u32, u32, [*c]const Buffer, [*c]const DeviceSize) callconv(.C) void;
pub const PFN_vkCmdEndTransformFeedbackEXT = ?fn (CommandBuffer, u32, u32, [*c]const Buffer, [*c]const DeviceSize) callconv(.C) void;
pub const PFN_vkCmdBeginQueryIndexedEXT = ?fn (CommandBuffer, QueryPool, u32, QueryControlFlags, u32) callconv(.C) void;
pub const PFN_vkCmdEndQueryIndexedEXT = ?fn (CommandBuffer, QueryPool, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawIndirectByteCountEXT = ?fn (CommandBuffer, u32, u32, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub extern fn vkCmdBindTransformFeedbackBuffersEXT(commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [*c]const Buffer, pOffsets: [*c]const DeviceSize, pSizes: [*c]const DeviceSize) void;
pub extern fn vkCmdBeginTransformFeedbackEXT(commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: [*c]const Buffer, pCounterBufferOffsets: [*c]const DeviceSize) void;
pub extern fn vkCmdEndTransformFeedbackEXT(commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: [*c]const Buffer, pCounterBufferOffsets: [*c]const DeviceSize) void;
pub extern fn vkCmdBeginQueryIndexedEXT(commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags, index: u32) void;
pub extern fn vkCmdEndQueryIndexedEXT(commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, index: u32) void;
pub extern fn vkCmdDrawIndirectByteCountEXT(commandBuffer: CommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: Buffer, counterBufferOffset: DeviceSize, counterOffset: u32, vertexStride: u32) void;
pub const struct_ImageViewHandleInfoNVX = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
imageView: ImageView,
descriptorType: DescriptorType,
sampler: Sampler,
};
pub const ImageViewHandleInfoNVX = struct_ImageViewHandleInfoNVX;
pub const struct_ImageViewAddressPropertiesNVX = extern struct {
sType: StructureType,
pNext: ?*c_void,
deviceAddress: DeviceAddress,
size: DeviceSize,
};
pub const ImageViewAddressPropertiesNVX = struct_ImageViewAddressPropertiesNVX;
pub const PFN_vkGetImageViewHandleNVX = ?fn (Device, [*c]const ImageViewHandleInfoNVX) callconv(.C) u32;
pub const PFN_vkGetImageViewAddressNVX = ?fn (Device, ImageView, [*c]ImageViewAddressPropertiesNVX) callconv(.C) Result;
pub extern fn vkGetImageViewHandleNVX(device: Device, pInfo: [*c]const ImageViewHandleInfoNVX) u32;
pub extern fn vkGetImageViewAddressNVX(device: Device, imageView: ImageView, pProperties: [*c]ImageViewAddressPropertiesNVX) Result;
pub const PFN_vkCmdDrawIndirectCountAMD = ?fn (CommandBuffer, Buffer, DeviceSize, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawIndexedIndirectCountAMD = ?fn (CommandBuffer, Buffer, DeviceSize, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub extern fn vkCmdDrawIndirectCountAMD(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) void;
pub extern fn vkCmdDrawIndexedIndirectCountAMD(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) void;
pub const struct_TextureLODGatherFormatPropertiesAMD = extern struct {
sType: StructureType,
pNext: ?*c_void,
supportsTextureGatherLODBiasAMD: Bool32,
};
pub const TextureLODGatherFormatPropertiesAMD = struct_TextureLODGatherFormatPropertiesAMD;
pub const SHADER_INFO_TYPE_STATISTICS_AMD = @enumToInt(enum_ShaderInfoTypeAMD.SHADER_INFO_TYPE_STATISTICS_AMD);
pub const SHADER_INFO_TYPE_BINARY_AMD = @enumToInt(enum_ShaderInfoTypeAMD.SHADER_INFO_TYPE_BINARY_AMD);
pub const SHADER_INFO_TYPE_DISASSEMBLY_AMD = @enumToInt(enum_ShaderInfoTypeAMD.SHADER_INFO_TYPE_DISASSEMBLY_AMD);
pub const SHADER_INFO_TYPE_MAX_ENUM_AMD = @enumToInt(enum_ShaderInfoTypeAMD.SHADER_INFO_TYPE_MAX_ENUM_AMD);
pub const enum_ShaderInfoTypeAMD = extern enum(c_int) {
SHADER_INFO_TYPE_STATISTICS_AMD = 0,
SHADER_INFO_TYPE_BINARY_AMD = 1,
SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
SHADER_INFO_TYPE_MAX_ENUM_AMD = 2147483647,
_,
};
pub const ShaderInfoTypeAMD = enum_ShaderInfoTypeAMD;
pub const struct_ShaderResourceUsageAMD = extern struct {
numUsedVgprs: u32,
numUsedSgprs: u32,
ldsSizePerLocalWorkGroup: u32,
ldsUsageSizeInBytes: usize,
scratchMemUsageInBytes: usize,
};
pub const ShaderResourceUsageAMD = struct_ShaderResourceUsageAMD;
pub const struct_ShaderStatisticsInfoAMD = extern struct {
shaderStageMask: ShaderStageFlags,
resourceUsage: ShaderResourceUsageAMD,
numPhysicalVgprs: u32,
numPhysicalSgprs: u32,
numAvailableVgprs: u32,
numAvailableSgprs: u32,
computeWorkGroupSize: [3]u32,
};
pub const ShaderStatisticsInfoAMD = struct_ShaderStatisticsInfoAMD;
pub const PFN_vkGetShaderInfoAMD = ?fn (Device, Pipeline, ShaderStageFlagBits, ShaderInfoTypeAMD, [*c]usize, ?*c_void) callconv(.C) Result;
pub extern fn vkGetShaderInfoAMD(device: Device, pipeline: Pipeline, shaderStage: ShaderStageFlagBits, infoType: ShaderInfoTypeAMD, pInfoSize: [*c]usize, pInfo: ?*c_void) Result;
pub const struct_PhysicalDeviceCornerSampledImageFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
cornerSampledImage: Bool32,
};
pub const PhysicalDeviceCornerSampledImageFeaturesNV = struct_PhysicalDeviceCornerSampledImageFeaturesNV;
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = @enumToInt(enum_ExternalMemoryHandleTypeFlagBitsNV.EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = @enumToInt(enum_ExternalMemoryHandleTypeFlagBitsNV.EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = @enumToInt(enum_ExternalMemoryHandleTypeFlagBitsNV.EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = @enumToInt(enum_ExternalMemoryHandleTypeFlagBitsNV.EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV);
pub const EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = @enumToInt(enum_ExternalMemoryHandleTypeFlagBitsNV.EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV);
pub const enum_ExternalMemoryHandleTypeFlagBitsNV = extern enum(c_int) {
EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 1,
EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 2,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 4,
EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 8,
EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 2147483647,
_,
};
pub const ExternalMemoryHandleTypeFlagBitsNV = enum_ExternalMemoryHandleTypeFlagBitsNV;
pub const ExternalMemoryHandleTypeFlagsNV = Flags;
pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = @enumToInt(enum_ExternalMemoryFeatureFlagBitsNV.EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV);
pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = @enumToInt(enum_ExternalMemoryFeatureFlagBitsNV.EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV);
pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = @enumToInt(enum_ExternalMemoryFeatureFlagBitsNV.EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV);
pub const EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = @enumToInt(enum_ExternalMemoryFeatureFlagBitsNV.EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV);
pub const enum_ExternalMemoryFeatureFlagBitsNV = extern enum(c_int) {
EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 1,
EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 2,
EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 4,
EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 2147483647,
_,
};
pub const ExternalMemoryFeatureFlagBitsNV = enum_ExternalMemoryFeatureFlagBitsNV;
pub const ExternalMemoryFeatureFlagsNV = Flags;
pub const struct_ExternalImageFormatPropertiesNV = extern struct {
imageFormatProperties: ImageFormatProperties,
externalMemoryFeatures: ExternalMemoryFeatureFlagsNV,
exportFromImportedHandleTypes: ExternalMemoryHandleTypeFlagsNV,
compatibleHandleTypes: ExternalMemoryHandleTypeFlagsNV,
};
pub const ExternalImageFormatPropertiesNV = struct_ExternalImageFormatPropertiesNV;
pub const PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = ?fn (PhysicalDevice, Format, ImageType, ImageTiling, ImageUsageFlags, ImageCreateFlags, ExternalMemoryHandleTypeFlagsNV, [*c]ExternalImageFormatPropertiesNV) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice: PhysicalDevice, format: Format, type: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, externalHandleType: ExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: [*c]ExternalImageFormatPropertiesNV) Result;
pub const struct_ExternalMemoryImageCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleTypes: ExternalMemoryHandleTypeFlagsNV,
};
pub const ExternalMemoryImageCreateInfoNV = struct_ExternalMemoryImageCreateInfoNV;
pub const struct_ExportMemoryAllocateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleTypes: ExternalMemoryHandleTypeFlagsNV,
};
pub const ExportMemoryAllocateInfoNV = struct_ExportMemoryAllocateInfoNV;
pub const VALIDATION_CHECK_ALL_EXT = @enumToInt(enum_ValidationCheckEXT.VALIDATION_CHECK_ALL_EXT);
pub const VALIDATION_CHECK_SHADERS_EXT = @enumToInt(enum_ValidationCheckEXT.VALIDATION_CHECK_SHADERS_EXT);
pub const VALIDATION_CHECK_MAX_ENUM_EXT = @enumToInt(enum_ValidationCheckEXT.VALIDATION_CHECK_MAX_ENUM_EXT);
pub const enum_ValidationCheckEXT = extern enum(c_int) {
VALIDATION_CHECK_ALL_EXT = 0,
VALIDATION_CHECK_SHADERS_EXT = 1,
VALIDATION_CHECK_MAX_ENUM_EXT = 2147483647,
_,
};
pub const ValidationCheckEXT = enum_ValidationCheckEXT;
pub const struct_ValidationFlagsEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
disabledValidationCheckCount: u32,
pDisabledValidationChecks: [*c]const ValidationCheckEXT,
};
pub const ValidationFlagsEXT = struct_ValidationFlagsEXT;
pub const struct_PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
textureCompressionASTC_HDR: Bool32,
};
pub const PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = struct_PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
pub const struct_ImageViewASTCDecodeModeEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
decodeMode: Format,
};
pub const ImageViewASTCDecodeModeEXT = struct_ImageViewASTCDecodeModeEXT;
pub const struct_PhysicalDeviceASTCDecodeFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
decodeModeSharedExponent: Bool32,
};
pub const PhysicalDeviceASTCDecodeFeaturesEXT = struct_PhysicalDeviceASTCDecodeFeaturesEXT;
pub const CONDITIONAL_RENDERING_INVERTED_BIT_EXT = @enumToInt(enum_ConditionalRenderingFlagBitsEXT.CONDITIONAL_RENDERING_INVERTED_BIT_EXT);
pub const CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = @enumToInt(enum_ConditionalRenderingFlagBitsEXT.CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT);
pub const enum_ConditionalRenderingFlagBitsEXT = extern enum(c_int) {
CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 1,
CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 2147483647,
_,
};
pub const ConditionalRenderingFlagBitsEXT = enum_ConditionalRenderingFlagBitsEXT;
pub const ConditionalRenderingFlagsEXT = Flags;
pub const struct_ConditionalRenderingBeginInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
buffer: Buffer,
offset: DeviceSize,
flags: ConditionalRenderingFlagsEXT,
};
pub const ConditionalRenderingBeginInfoEXT = struct_ConditionalRenderingBeginInfoEXT;
pub const struct_PhysicalDeviceConditionalRenderingFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
conditionalRendering: Bool32,
inheritedConditionalRendering: Bool32,
};
pub const PhysicalDeviceConditionalRenderingFeaturesEXT = struct_PhysicalDeviceConditionalRenderingFeaturesEXT;
pub const struct_CommandBufferInheritanceConditionalRenderingInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
conditionalRenderingEnable: Bool32,
};
pub const CommandBufferInheritanceConditionalRenderingInfoEXT = struct_CommandBufferInheritanceConditionalRenderingInfoEXT;
pub const PFN_vkCmdBeginConditionalRenderingEXT = ?fn (CommandBuffer, [*c]const ConditionalRenderingBeginInfoEXT) callconv(.C) void;
pub const PFN_vkCmdEndConditionalRenderingEXT = ?fn (CommandBuffer) callconv(.C) void;
pub extern fn vkCmdBeginConditionalRenderingEXT(commandBuffer: CommandBuffer, pConditionalRenderingBegin: [*c]const ConditionalRenderingBeginInfoEXT) void;
pub extern fn vkCmdEndConditionalRenderingEXT(commandBuffer: CommandBuffer) void;
pub const struct_ViewportWScalingNV = extern struct {
xcoeff: f32,
ycoeff: f32,
};
pub const ViewportWScalingNV = struct_ViewportWScalingNV;
pub const struct_PipelineViewportWScalingStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
viewportWScalingEnable: Bool32,
viewportCount: u32,
pViewportWScalings: [*c]const ViewportWScalingNV,
};
pub const PipelineViewportWScalingStateCreateInfoNV = struct_PipelineViewportWScalingStateCreateInfoNV;
pub const PFN_vkCmdSetViewportWScalingNV = ?fn (CommandBuffer, u32, u32, [*c]const ViewportWScalingNV) callconv(.C) void;
pub extern fn vkCmdSetViewportWScalingNV(commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: [*c]const ViewportWScalingNV) void;
pub const PFN_vkReleaseDisplayEXT = ?fn (PhysicalDevice, DisplayKHR) callconv(.C) Result;
pub extern fn vkReleaseDisplayEXT(physicalDevice: PhysicalDevice, display: DisplayKHR) Result;
pub const SURFACE_COUNTER_VBLANK_BIT_EXT = @enumToInt(enum_SurfaceCounterFlagBitsEXT.SURFACE_COUNTER_VBLANK_BIT_EXT);
pub const SURFACE_COUNTER_VBLANK_EXT = @enumToInt(enum_SurfaceCounterFlagBitsEXT.SURFACE_COUNTER_VBLANK_EXT);
pub const SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = @enumToInt(enum_SurfaceCounterFlagBitsEXT.SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT);
pub const enum_SurfaceCounterFlagBitsEXT = extern enum(c_int) {
SURFACE_COUNTER_VBLANK_BIT_EXT = 1,
SURFACE_COUNTER_VBLANK_EXT = 1,
SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 2147483647,
_,
};
pub const SurfaceCounterFlagBitsEXT = enum_SurfaceCounterFlagBitsEXT;
pub const SurfaceCounterFlagsEXT = Flags;
pub const struct_SurfaceCapabilities2EXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
minImageCount: u32,
maxImageCount: u32,
currentExtent: Extent2D,
minImageExtent: Extent2D,
maxImageExtent: Extent2D,
maxImageArrayLayers: u32,
supportedTransforms: SurfaceTransformFlagsKHR,
currentTransform: SurfaceTransformFlagBitsKHR,
supportedCompositeAlpha: CompositeAlphaFlagsKHR,
supportedUsageFlags: ImageUsageFlags,
supportedSurfaceCounters: SurfaceCounterFlagsEXT,
};
pub const SurfaceCapabilities2EXT = struct_SurfaceCapabilities2EXT;
pub const PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = ?fn (PhysicalDevice, SurfaceKHR, [*c]SurfaceCapabilities2EXT) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceCapabilities: [*c]SurfaceCapabilities2EXT) Result;
pub const DISPLAY_POWER_STATE_OFF_EXT = @enumToInt(enum_DisplayPowerStateEXT.DISPLAY_POWER_STATE_OFF_EXT);
pub const DISPLAY_POWER_STATE_SUSPEND_EXT = @enumToInt(enum_DisplayPowerStateEXT.DISPLAY_POWER_STATE_SUSPEND_EXT);
pub const DISPLAY_POWER_STATE_ON_EXT = @enumToInt(enum_DisplayPowerStateEXT.DISPLAY_POWER_STATE_ON_EXT);
pub const DISPLAY_POWER_STATE_MAX_ENUM_EXT = @enumToInt(enum_DisplayPowerStateEXT.DISPLAY_POWER_STATE_MAX_ENUM_EXT);
pub const enum_DisplayPowerStateEXT = extern enum(c_int) {
DISPLAY_POWER_STATE_OFF_EXT = 0,
DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
DISPLAY_POWER_STATE_ON_EXT = 2,
DISPLAY_POWER_STATE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DisplayPowerStateEXT = enum_DisplayPowerStateEXT;
pub const DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = @enumToInt(enum_DeviceEventTypeEXT.DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT);
pub const DEVICE_EVENT_TYPE_MAX_ENUM_EXT = @enumToInt(enum_DeviceEventTypeEXT.DEVICE_EVENT_TYPE_MAX_ENUM_EXT);
pub const enum_DeviceEventTypeEXT = extern enum(c_int) {
DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DeviceEventTypeEXT = enum_DeviceEventTypeEXT;
pub const DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = @enumToInt(enum_DisplayEventTypeEXT.DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT);
pub const DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = @enumToInt(enum_DisplayEventTypeEXT.DISPLAY_EVENT_TYPE_MAX_ENUM_EXT);
pub const enum_DisplayEventTypeEXT = extern enum(c_int) {
DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DisplayEventTypeEXT = enum_DisplayEventTypeEXT;
pub const struct_DisplayPowerInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
powerState: DisplayPowerStateEXT,
};
pub const DisplayPowerInfoEXT = struct_DisplayPowerInfoEXT;
pub const struct_DeviceEventInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
deviceEvent: DeviceEventTypeEXT,
};
pub const DeviceEventInfoEXT = struct_DeviceEventInfoEXT;
pub const struct_DisplayEventInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
displayEvent: DisplayEventTypeEXT,
};
pub const DisplayEventInfoEXT = struct_DisplayEventInfoEXT;
pub const struct_SwapchainCounterCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
surfaceCounters: SurfaceCounterFlagsEXT,
};
pub const SwapchainCounterCreateInfoEXT = struct_SwapchainCounterCreateInfoEXT;
pub const PFN_vkDisplayPowerControlEXT = ?fn (Device, DisplayKHR, [*c]const DisplayPowerInfoEXT) callconv(.C) Result;
pub const PFN_vkRegisterDeviceEventEXT = ?fn (Device, [*c]const DeviceEventInfoEXT, [*c]const AllocationCallbacks, [*c]Fence) callconv(.C) Result;
pub const PFN_vkRegisterDisplayEventEXT = ?fn (Device, DisplayKHR, [*c]const DisplayEventInfoEXT, [*c]const AllocationCallbacks, [*c]Fence) callconv(.C) Result;
pub const PFN_vkGetSwapchainCounterEXT = ?fn (Device, SwapchainKHR, SurfaceCounterFlagBitsEXT, [*c]u64) callconv(.C) Result;
pub extern fn vkDisplayPowerControlEXT(device: Device, display: DisplayKHR, pDisplayPowerInfo: [*c]const DisplayPowerInfoEXT) Result;
pub extern fn vkRegisterDeviceEventEXT(device: Device, pDeviceEventInfo: [*c]const DeviceEventInfoEXT, pAllocator: [*c]const AllocationCallbacks, pFence: [*c]Fence) Result;
pub extern fn vkRegisterDisplayEventEXT(device: Device, display: DisplayKHR, pDisplayEventInfo: [*c]const DisplayEventInfoEXT, pAllocator: [*c]const AllocationCallbacks, pFence: [*c]Fence) Result;
pub extern fn vkGetSwapchainCounterEXT(device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagBitsEXT, pCounterValue: [*c]u64) Result;
pub const struct_RefreshCycleDurationGOOGLE = extern struct {
refreshDuration: u64,
};
pub const RefreshCycleDurationGOOGLE = struct_RefreshCycleDurationGOOGLE;
pub const struct_PastPresentationTimingGOOGLE = extern struct {
presentID: u32,
desiredPresentTime: u64,
actualPresentTime: u64,
earliestPresentTime: u64,
presentMargin: u64,
};
pub const PastPresentationTimingGOOGLE = struct_PastPresentationTimingGOOGLE;
pub const struct_PresentTimeGOOGLE = extern struct {
presentID: u32,
desiredPresentTime: u64,
};
pub const PresentTimeGOOGLE = struct_PresentTimeGOOGLE;
pub const struct_PresentTimesInfoGOOGLE = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
swapchainCount: u32,
pTimes: [*c]const PresentTimeGOOGLE,
};
pub const PresentTimesInfoGOOGLE = struct_PresentTimesInfoGOOGLE;
pub const PFN_vkGetRefreshCycleDurationGOOGLE = ?fn (Device, SwapchainKHR, [*c]RefreshCycleDurationGOOGLE) callconv(.C) Result;
pub const PFN_vkGetPastPresentationTimingGOOGLE = ?fn (Device, SwapchainKHR, [*c]u32, [*c]PastPresentationTimingGOOGLE) callconv(.C) Result;
pub extern fn vkGetRefreshCycleDurationGOOGLE(device: Device, swapchain: SwapchainKHR, pDisplayTimingProperties: [*c]RefreshCycleDurationGOOGLE) Result;
pub extern fn vkGetPastPresentationTimingGOOGLE(device: Device, swapchain: SwapchainKHR, pPresentationTimingCount: [*c]u32, pPresentationTimings: [*c]PastPresentationTimingGOOGLE) Result;
pub const struct_PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = extern struct {
sType: StructureType,
pNext: ?*c_void,
perViewPositionAllComponents: Bool32,
};
pub const PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = struct_PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV);
pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV);
pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV);
pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV);
pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV);
pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV);
pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV);
pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV);
pub const VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = @enumToInt(enum_ViewportCoordinateSwizzleNV.VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV);
pub const enum_ViewportCoordinateSwizzleNV = extern enum(c_int) {
VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 2147483647,
_,
};
pub const ViewportCoordinateSwizzleNV = enum_ViewportCoordinateSwizzleNV;
pub const PipelineViewportSwizzleStateCreateFlagsNV = Flags;
pub const struct_ViewportSwizzleNV = extern struct {
x: ViewportCoordinateSwizzleNV,
y: ViewportCoordinateSwizzleNV,
z: ViewportCoordinateSwizzleNV,
w: ViewportCoordinateSwizzleNV,
};
pub const ViewportSwizzleNV = struct_ViewportSwizzleNV;
pub const struct_PipelineViewportSwizzleStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineViewportSwizzleStateCreateFlagsNV,
viewportCount: u32,
pViewportSwizzles: [*c]const ViewportSwizzleNV,
};
pub const PipelineViewportSwizzleStateCreateInfoNV = struct_PipelineViewportSwizzleStateCreateInfoNV;
pub const DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = @enumToInt(enum_DiscardRectangleModeEXT.DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT);
pub const DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = @enumToInt(enum_DiscardRectangleModeEXT.DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT);
pub const DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = @enumToInt(enum_DiscardRectangleModeEXT.DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT);
pub const enum_DiscardRectangleModeEXT = extern enum(c_int) {
DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DiscardRectangleModeEXT = enum_DiscardRectangleModeEXT;
pub const PipelineDiscardRectangleStateCreateFlagsEXT = Flags;
pub const struct_PhysicalDeviceDiscardRectanglePropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxDiscardRectangles: u32,
};
pub const PhysicalDeviceDiscardRectanglePropertiesEXT = struct_PhysicalDeviceDiscardRectanglePropertiesEXT;
pub const struct_PipelineDiscardRectangleStateCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineDiscardRectangleStateCreateFlagsEXT,
discardRectangleMode: DiscardRectangleModeEXT,
discardRectangleCount: u32,
pDiscardRectangles: [*c]const Rect2D,
};
pub const PipelineDiscardRectangleStateCreateInfoEXT = struct_PipelineDiscardRectangleStateCreateInfoEXT;
pub const PFN_vkCmdSetDiscardRectangleEXT = ?fn (CommandBuffer, u32, u32, [*c]const Rect2D) callconv(.C) void;
pub extern fn vkCmdSetDiscardRectangleEXT(commandBuffer: CommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: [*c]const Rect2D) void;
pub const CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = @enumToInt(enum_ConservativeRasterizationModeEXT.CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT);
pub const CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = @enumToInt(enum_ConservativeRasterizationModeEXT.CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT);
pub const CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = @enumToInt(enum_ConservativeRasterizationModeEXT.CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT);
pub const CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = @enumToInt(enum_ConservativeRasterizationModeEXT.CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT);
pub const enum_ConservativeRasterizationModeEXT = extern enum(c_int) {
CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const ConservativeRasterizationModeEXT = enum_ConservativeRasterizationModeEXT;
pub const PipelineRasterizationConservativeStateCreateFlagsEXT = Flags;
pub const struct_PhysicalDeviceConservativeRasterizationPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
primitiveOverestimationSize: f32,
maxExtraPrimitiveOverestimationSize: f32,
extraPrimitiveOverestimationSizeGranularity: f32,
primitiveUnderestimation: Bool32,
conservativePointAndLineRasterization: Bool32,
degenerateTrianglesRasterized: Bool32,
degenerateLinesRasterized: Bool32,
fullyCoveredFragmentShaderInputVariable: Bool32,
conservativeRasterizationPostDepthCoverage: Bool32,
};
pub const PhysicalDeviceConservativeRasterizationPropertiesEXT = struct_PhysicalDeviceConservativeRasterizationPropertiesEXT;
pub const struct_PipelineRasterizationConservativeStateCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
conservativeRasterizationMode: ConservativeRasterizationModeEXT,
extraPrimitiveOverestimationSize: f32,
};
pub const PipelineRasterizationConservativeStateCreateInfoEXT = struct_PipelineRasterizationConservativeStateCreateInfoEXT;
pub const PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags;
pub const struct_PhysicalDeviceDepthClipEnableFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
depthClipEnable: Bool32,
};
pub const PhysicalDeviceDepthClipEnableFeaturesEXT = struct_PhysicalDeviceDepthClipEnableFeaturesEXT;
pub const struct_PipelineRasterizationDepthClipStateCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
depthClipEnable: Bool32,
};
pub const PipelineRasterizationDepthClipStateCreateInfoEXT = struct_PipelineRasterizationDepthClipStateCreateInfoEXT;
pub const struct_XYColorEXT = extern struct {
x: f32,
y: f32,
};
pub const XYColorEXT = struct_XYColorEXT;
pub const struct_HdrMetadataEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
displayPrimaryRed: XYColorEXT,
displayPrimaryGreen: XYColorEXT,
displayPrimaryBlue: XYColorEXT,
whitePoint: XYColorEXT,
maxLuminance: f32,
minLuminance: f32,
maxContentLightLevel: f32,
maxFrameAverageLightLevel: f32,
};
pub const HdrMetadataEXT = struct_HdrMetadataEXT;
pub const PFN_vkSetHdrMetadataEXT = ?fn (Device, u32, [*c]const SwapchainKHR, [*c]const HdrMetadataEXT) callconv(.C) void;
pub extern fn vkSetHdrMetadataEXT(device: Device, swapchainCount: u32, pSwapchains: [*c]const SwapchainKHR, pMetadata: [*c]const HdrMetadataEXT) void;
pub const struct_DebugUtilsMessengerEXT_T = opaque {};
pub const DebugUtilsMessengerEXT = ?*struct_DebugUtilsMessengerEXT_T;
pub const DebugUtilsMessengerCallbackDataFlagsEXT = Flags;
pub const DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = @enumToInt(enum_DebugUtilsMessageSeverityFlagBitsEXT.DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT);
pub const DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = @enumToInt(enum_DebugUtilsMessageSeverityFlagBitsEXT.DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT);
pub const DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = @enumToInt(enum_DebugUtilsMessageSeverityFlagBitsEXT.DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT);
pub const DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = @enumToInt(enum_DebugUtilsMessageSeverityFlagBitsEXT.DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT);
pub const DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = @enumToInt(enum_DebugUtilsMessageSeverityFlagBitsEXT.DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT);
pub const enum_DebugUtilsMessageSeverityFlagBitsEXT = extern enum(c_int) {
DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 1,
DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 16,
DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 256,
DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 4096,
DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DebugUtilsMessageSeverityFlagBitsEXT = enum_DebugUtilsMessageSeverityFlagBitsEXT;
pub const DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = @enumToInt(enum_DebugUtilsMessageTypeFlagBitsEXT.DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT);
pub const DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = @enumToInt(enum_DebugUtilsMessageTypeFlagBitsEXT.DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT);
pub const DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = @enumToInt(enum_DebugUtilsMessageTypeFlagBitsEXT.DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT);
pub const DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = @enumToInt(enum_DebugUtilsMessageTypeFlagBitsEXT.DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT);
pub const enum_DebugUtilsMessageTypeFlagBitsEXT = extern enum(c_int) {
DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 1,
DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 2,
DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 4,
DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DebugUtilsMessageTypeFlagBitsEXT = enum_DebugUtilsMessageTypeFlagBitsEXT;
pub const DebugUtilsMessageTypeFlagsEXT = Flags;
pub const DebugUtilsMessageSeverityFlagsEXT = Flags;
pub const DebugUtilsMessengerCreateFlagsEXT = Flags;
pub const struct_DebugUtilsLabelEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pLabelName: [*c]const u8,
color: [4]f32,
};
pub const DebugUtilsLabelEXT = struct_DebugUtilsLabelEXT;
pub const struct_DebugUtilsObjectNameInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
objectType: ObjectType,
objectHandle: u64,
pObjectName: [*c]const u8,
};
pub const DebugUtilsObjectNameInfoEXT = struct_DebugUtilsObjectNameInfoEXT;
pub const struct_DebugUtilsMessengerCallbackDataEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DebugUtilsMessengerCallbackDataFlagsEXT,
pMessageIdName: [*c]const u8,
messageIdNumber: i32,
pMessage: [*c]const u8,
queueLabelCount: u32,
pQueueLabels: [*c]const DebugUtilsLabelEXT,
cmdBufLabelCount: u32,
pCmdBufLabels: [*c]const DebugUtilsLabelEXT,
objectCount: u32,
pObjects: [*c]const DebugUtilsObjectNameInfoEXT,
};
pub const DebugUtilsMessengerCallbackDataEXT = struct_DebugUtilsMessengerCallbackDataEXT;
pub const PFN_vkDebugUtilsMessengerCallbackEXT = ?fn (DebugUtilsMessageSeverityFlagBitsEXT, DebugUtilsMessageTypeFlagsEXT, [*c]const DebugUtilsMessengerCallbackDataEXT, ?*c_void) callconv(.C) Bool32;
pub const struct_DebugUtilsMessengerCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DebugUtilsMessengerCreateFlagsEXT,
messageSeverity: DebugUtilsMessageSeverityFlagsEXT,
messageType: DebugUtilsMessageTypeFlagsEXT,
pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT,
pUserData: ?*c_void,
};
pub const DebugUtilsMessengerCreateInfoEXT = struct_DebugUtilsMessengerCreateInfoEXT;
pub const struct_DebugUtilsObjectTagInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
objectType: ObjectType,
objectHandle: u64,
tagName: u64,
tagSize: usize,
pTag: ?*const c_void,
};
pub const DebugUtilsObjectTagInfoEXT = struct_DebugUtilsObjectTagInfoEXT;
pub const PFN_vkSetDebugUtilsObjectNameEXT = ?fn (Device, [*c]const DebugUtilsObjectNameInfoEXT) callconv(.C) Result;
pub const PFN_vkSetDebugUtilsObjectTagEXT = ?fn (Device, [*c]const DebugUtilsObjectTagInfoEXT) callconv(.C) Result;
pub const PFN_vkQueueBeginDebugUtilsLabelEXT = ?fn (Queue, [*c]const DebugUtilsLabelEXT) callconv(.C) void;
pub const PFN_vkQueueEndDebugUtilsLabelEXT = ?fn (Queue) callconv(.C) void;
pub const PFN_vkQueueInsertDebugUtilsLabelEXT = ?fn (Queue, [*c]const DebugUtilsLabelEXT) callconv(.C) void;
pub const PFN_vkCmdBeginDebugUtilsLabelEXT = ?fn (CommandBuffer, [*c]const DebugUtilsLabelEXT) callconv(.C) void;
pub const PFN_vkCmdEndDebugUtilsLabelEXT = ?fn (CommandBuffer) callconv(.C) void;
pub const PFN_vkCmdInsertDebugUtilsLabelEXT = ?fn (CommandBuffer, [*c]const DebugUtilsLabelEXT) callconv(.C) void;
pub const PFN_vkCreateDebugUtilsMessengerEXT = ?fn (Instance, [*c]const DebugUtilsMessengerCreateInfoEXT, [*c]const AllocationCallbacks, [*c]DebugUtilsMessengerEXT) callconv(.C) Result;
pub const PFN_vkDestroyDebugUtilsMessengerEXT = ?fn (Instance, DebugUtilsMessengerEXT, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkSubmitDebugUtilsMessageEXT = ?fn (Instance, DebugUtilsMessageSeverityFlagBitsEXT, DebugUtilsMessageTypeFlagsEXT, [*c]const DebugUtilsMessengerCallbackDataEXT) callconv(.C) void;
pub extern fn vkSetDebugUtilsObjectNameEXT(device: Device, pNameInfo: [*c]const DebugUtilsObjectNameInfoEXT) Result;
pub extern fn vkSetDebugUtilsObjectTagEXT(device: Device, pTagInfo: [*c]const DebugUtilsObjectTagInfoEXT) Result;
pub extern fn vkQueueBeginDebugUtilsLabelEXT(queue: Queue, pLabelInfo: [*c]const DebugUtilsLabelEXT) void;
pub extern fn vkQueueEndDebugUtilsLabelEXT(queue: Queue) void;
pub extern fn vkQueueInsertDebugUtilsLabelEXT(queue: Queue, pLabelInfo: [*c]const DebugUtilsLabelEXT) void;
pub extern fn vkCmdBeginDebugUtilsLabelEXT(commandBuffer: CommandBuffer, pLabelInfo: [*c]const DebugUtilsLabelEXT) void;
pub extern fn vkCmdEndDebugUtilsLabelEXT(commandBuffer: CommandBuffer) void;
pub extern fn vkCmdInsertDebugUtilsLabelEXT(commandBuffer: CommandBuffer, pLabelInfo: [*c]const DebugUtilsLabelEXT) void;
pub extern fn vkCreateDebugUtilsMessengerEXT(instance: Instance, pCreateInfo: [*c]const DebugUtilsMessengerCreateInfoEXT, pAllocator: [*c]const AllocationCallbacks, pMessenger: [*c]DebugUtilsMessengerEXT) Result;
pub extern fn vkDestroyDebugUtilsMessengerEXT(instance: Instance, messenger: DebugUtilsMessengerEXT, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkSubmitDebugUtilsMessageEXT(instance: Instance, messageSeverity: DebugUtilsMessageSeverityFlagBitsEXT, messageTypes: DebugUtilsMessageTypeFlagsEXT, pCallbackData: [*c]const DebugUtilsMessengerCallbackDataEXT) void;
pub const SamplerReductionModeEXT = SamplerReductionMode;
pub const SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
pub const PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
pub const struct_PhysicalDeviceInlineUniformBlockFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
inlineUniformBlock: Bool32,
descriptorBindingInlineUniformBlockUpdateAfterBind: Bool32,
};
pub const PhysicalDeviceInlineUniformBlockFeaturesEXT = struct_PhysicalDeviceInlineUniformBlockFeaturesEXT;
pub const struct_PhysicalDeviceInlineUniformBlockPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxInlineUniformBlockSize: u32,
maxPerStageDescriptorInlineUniformBlocks: u32,
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
maxDescriptorSetInlineUniformBlocks: u32,
maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32,
};
pub const PhysicalDeviceInlineUniformBlockPropertiesEXT = struct_PhysicalDeviceInlineUniformBlockPropertiesEXT;
pub const struct_WriteDescriptorSetInlineUniformBlockEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
dataSize: u32,
pData: ?*const c_void,
};
pub const WriteDescriptorSetInlineUniformBlockEXT = struct_WriteDescriptorSetInlineUniformBlockEXT;
pub const struct_DescriptorPoolInlineUniformBlockCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
maxInlineUniformBlockBindings: u32,
};
pub const DescriptorPoolInlineUniformBlockCreateInfoEXT = struct_DescriptorPoolInlineUniformBlockCreateInfoEXT;
pub const struct_SampleLocationEXT = extern struct {
x: f32,
y: f32,
};
pub const SampleLocationEXT = struct_SampleLocationEXT;
pub const struct_SampleLocationsInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
sampleLocationsPerPixel: SampleCountFlagBits,
sampleLocationGridSize: Extent2D,
sampleLocationsCount: u32,
pSampleLocations: [*c]const SampleLocationEXT,
};
pub const SampleLocationsInfoEXT = struct_SampleLocationsInfoEXT;
pub const struct_AttachmentSampleLocationsEXT = extern struct {
attachmentIndex: u32,
sampleLocationsInfo: SampleLocationsInfoEXT,
};
pub const AttachmentSampleLocationsEXT = struct_AttachmentSampleLocationsEXT;
pub const struct_SubpassSampleLocationsEXT = extern struct {
subpassIndex: u32,
sampleLocationsInfo: SampleLocationsInfoEXT,
};
pub const SubpassSampleLocationsEXT = struct_SubpassSampleLocationsEXT;
pub const struct_RenderPassSampleLocationsBeginInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
attachmentInitialSampleLocationsCount: u32,
pAttachmentInitialSampleLocations: [*c]const AttachmentSampleLocationsEXT,
postSubpassSampleLocationsCount: u32,
pPostSubpassSampleLocations: [*c]const SubpassSampleLocationsEXT,
};
pub const RenderPassSampleLocationsBeginInfoEXT = struct_RenderPassSampleLocationsBeginInfoEXT;
pub const struct_PipelineSampleLocationsStateCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
sampleLocationsEnable: Bool32,
sampleLocationsInfo: SampleLocationsInfoEXT,
};
pub const PipelineSampleLocationsStateCreateInfoEXT = struct_PipelineSampleLocationsStateCreateInfoEXT;
pub const struct_PhysicalDeviceSampleLocationsPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
sampleLocationSampleCounts: SampleCountFlags,
maxSampleLocationGridSize: Extent2D,
sampleLocationCoordinateRange: [2]f32,
sampleLocationSubPixelBits: u32,
variableSampleLocations: Bool32,
};
pub const PhysicalDeviceSampleLocationsPropertiesEXT = struct_PhysicalDeviceSampleLocationsPropertiesEXT;
pub const struct_MultisamplePropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxSampleLocationGridSize: Extent2D,
};
pub const MultisamplePropertiesEXT = struct_MultisamplePropertiesEXT;
pub const PFN_vkCmdSetSampleLocationsEXT = ?fn (CommandBuffer, [*c]const SampleLocationsInfoEXT) callconv(.C) void;
pub const PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = ?fn (PhysicalDevice, SampleCountFlagBits, [*c]MultisamplePropertiesEXT) callconv(.C) void;
pub extern fn vkCmdSetSampleLocationsEXT(commandBuffer: CommandBuffer, pSampleLocationsInfo: [*c]const SampleLocationsInfoEXT) void;
pub extern fn vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice: PhysicalDevice, samples: SampleCountFlagBits, pMultisampleProperties: [*c]MultisamplePropertiesEXT) void;
pub const BLEND_OVERLAP_UNCORRELATED_EXT = @enumToInt(enum_BlendOverlapEXT.BLEND_OVERLAP_UNCORRELATED_EXT);
pub const BLEND_OVERLAP_DISJOINT_EXT = @enumToInt(enum_BlendOverlapEXT.BLEND_OVERLAP_DISJOINT_EXT);
pub const BLEND_OVERLAP_CONJOINT_EXT = @enumToInt(enum_BlendOverlapEXT.BLEND_OVERLAP_CONJOINT_EXT);
pub const BLEND_OVERLAP_MAX_ENUM_EXT = @enumToInt(enum_BlendOverlapEXT.BLEND_OVERLAP_MAX_ENUM_EXT);
pub const enum_BlendOverlapEXT = extern enum(c_int) {
BLEND_OVERLAP_UNCORRELATED_EXT = 0,
BLEND_OVERLAP_DISJOINT_EXT = 1,
BLEND_OVERLAP_CONJOINT_EXT = 2,
BLEND_OVERLAP_MAX_ENUM_EXT = 2147483647,
_,
};
pub const BlendOverlapEXT = enum_BlendOverlapEXT;
pub const struct_PhysicalDeviceBlendOperationAdvancedFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
advancedBlendCoherentOperations: Bool32,
};
pub const PhysicalDeviceBlendOperationAdvancedFeaturesEXT = struct_PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
pub const struct_PhysicalDeviceBlendOperationAdvancedPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
advancedBlendMaxColorAttachments: u32,
advancedBlendIndependentBlend: Bool32,
advancedBlendNonPremultipliedSrcColor: Bool32,
advancedBlendNonPremultipliedDstColor: Bool32,
advancedBlendCorrelatedOverlap: Bool32,
advancedBlendAllOperations: Bool32,
};
pub const PhysicalDeviceBlendOperationAdvancedPropertiesEXT = struct_PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
pub const struct_PipelineColorBlendAdvancedStateCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
srcPremultiplied: Bool32,
dstPremultiplied: Bool32,
blendOverlap: BlendOverlapEXT,
};
pub const PipelineColorBlendAdvancedStateCreateInfoEXT = struct_PipelineColorBlendAdvancedStateCreateInfoEXT;
pub const PipelineCoverageToColorStateCreateFlagsNV = Flags;
pub const struct_PipelineCoverageToColorStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineCoverageToColorStateCreateFlagsNV,
coverageToColorEnable: Bool32,
coverageToColorLocation: u32,
};
pub const PipelineCoverageToColorStateCreateInfoNV = struct_PipelineCoverageToColorStateCreateInfoNV;
pub const COVERAGE_MODULATION_MODE_NONE_NV = @enumToInt(enum_CoverageModulationModeNV.COVERAGE_MODULATION_MODE_NONE_NV);
pub const COVERAGE_MODULATION_MODE_RGB_NV = @enumToInt(enum_CoverageModulationModeNV.COVERAGE_MODULATION_MODE_RGB_NV);
pub const COVERAGE_MODULATION_MODE_ALPHA_NV = @enumToInt(enum_CoverageModulationModeNV.COVERAGE_MODULATION_MODE_ALPHA_NV);
pub const COVERAGE_MODULATION_MODE_RGBA_NV = @enumToInt(enum_CoverageModulationModeNV.COVERAGE_MODULATION_MODE_RGBA_NV);
pub const COVERAGE_MODULATION_MODE_MAX_ENUM_NV = @enumToInt(enum_CoverageModulationModeNV.COVERAGE_MODULATION_MODE_MAX_ENUM_NV);
pub const enum_CoverageModulationModeNV = extern enum(c_int) {
COVERAGE_MODULATION_MODE_NONE_NV = 0,
COVERAGE_MODULATION_MODE_RGB_NV = 1,
COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
COVERAGE_MODULATION_MODE_RGBA_NV = 3,
COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 2147483647,
_,
};
pub const CoverageModulationModeNV = enum_CoverageModulationModeNV;
pub const PipelineCoverageModulationStateCreateFlagsNV = Flags;
pub const struct_PipelineCoverageModulationStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineCoverageModulationStateCreateFlagsNV,
coverageModulationMode: CoverageModulationModeNV,
coverageModulationTableEnable: Bool32,
coverageModulationTableCount: u32,
pCoverageModulationTable: [*c]const f32,
};
pub const PipelineCoverageModulationStateCreateInfoNV = struct_PipelineCoverageModulationStateCreateInfoNV;
pub const struct_PhysicalDeviceShaderSMBuiltinsPropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderSMCount: u32,
shaderWarpsPerSM: u32,
};
pub const PhysicalDeviceShaderSMBuiltinsPropertiesNV = struct_PhysicalDeviceShaderSMBuiltinsPropertiesNV;
pub const struct_PhysicalDeviceShaderSMBuiltinsFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderSMBuiltins: Bool32,
};
pub const PhysicalDeviceShaderSMBuiltinsFeaturesNV = struct_PhysicalDeviceShaderSMBuiltinsFeaturesNV;
pub const struct_DrmFormatModifierPropertiesEXT = extern struct {
drmFormatModifier: u64,
drmFormatModifierPlaneCount: u32,
drmFormatModifierTilingFeatures: FormatFeatureFlags,
};
pub const DrmFormatModifierPropertiesEXT = struct_DrmFormatModifierPropertiesEXT;
pub const struct_DrmFormatModifierPropertiesListEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
drmFormatModifierCount: u32,
pDrmFormatModifierProperties: [*c]DrmFormatModifierPropertiesEXT,
};
pub const DrmFormatModifierPropertiesListEXT = struct_DrmFormatModifierPropertiesListEXT;
pub const struct_PhysicalDeviceImageDrmFormatModifierInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
drmFormatModifier: u64,
sharingMode: SharingMode,
queueFamilyIndexCount: u32,
pQueueFamilyIndices: [*c]const u32,
};
pub const PhysicalDeviceImageDrmFormatModifierInfoEXT = struct_PhysicalDeviceImageDrmFormatModifierInfoEXT;
pub const struct_ImageDrmFormatModifierListCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
drmFormatModifierCount: u32,
pDrmFormatModifiers: [*c]const u64,
};
pub const ImageDrmFormatModifierListCreateInfoEXT = struct_ImageDrmFormatModifierListCreateInfoEXT;
pub const struct_ImageDrmFormatModifierExplicitCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
drmFormatModifier: u64,
drmFormatModifierPlaneCount: u32,
pPlaneLayouts: [*c]const SubresourceLayout,
};
pub const ImageDrmFormatModifierExplicitCreateInfoEXT = struct_ImageDrmFormatModifierExplicitCreateInfoEXT;
pub const struct_ImageDrmFormatModifierPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
drmFormatModifier: u64,
};
pub const ImageDrmFormatModifierPropertiesEXT = struct_ImageDrmFormatModifierPropertiesEXT;
pub const PFN_vkGetImageDrmFormatModifierPropertiesEXT = ?fn (Device, Image, [*c]ImageDrmFormatModifierPropertiesEXT) callconv(.C) Result;
pub extern fn vkGetImageDrmFormatModifierPropertiesEXT(device: Device, image: Image, pProperties: [*c]ImageDrmFormatModifierPropertiesEXT) Result;
pub const struct_ValidationCacheEXT_T = opaque {};
pub const ValidationCacheEXT = ?*struct_ValidationCacheEXT_T;
pub const VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = @enumToInt(enum_ValidationCacheHeaderVersionEXT.VALIDATION_CACHE_HEADER_VERSION_ONE_EXT);
pub const VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = @enumToInt(enum_ValidationCacheHeaderVersionEXT.VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT);
pub const enum_ValidationCacheHeaderVersionEXT = extern enum(c_int) {
VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 2147483647,
_,
};
pub const ValidationCacheHeaderVersionEXT = enum_ValidationCacheHeaderVersionEXT;
pub const ValidationCacheCreateFlagsEXT = Flags;
pub const struct_ValidationCacheCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: ValidationCacheCreateFlagsEXT,
initialDataSize: usize,
pInitialData: ?*const c_void,
};
pub const ValidationCacheCreateInfoEXT = struct_ValidationCacheCreateInfoEXT;
pub const struct_ShaderModuleValidationCacheCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
validationCache: ValidationCacheEXT,
};
pub const ShaderModuleValidationCacheCreateInfoEXT = struct_ShaderModuleValidationCacheCreateInfoEXT;
pub const PFN_vkCreateValidationCacheEXT = ?fn (Device, [*c]const ValidationCacheCreateInfoEXT, [*c]const AllocationCallbacks, [*c]ValidationCacheEXT) callconv(.C) Result;
pub const PFN_vkDestroyValidationCacheEXT = ?fn (Device, ValidationCacheEXT, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkMergeValidationCachesEXT = ?fn (Device, ValidationCacheEXT, u32, [*c]const ValidationCacheEXT) callconv(.C) Result;
pub const PFN_vkGetValidationCacheDataEXT = ?fn (Device, ValidationCacheEXT, [*c]usize, ?*c_void) callconv(.C) Result;
pub extern fn vkCreateValidationCacheEXT(device: Device, pCreateInfo: [*c]const ValidationCacheCreateInfoEXT, pAllocator: [*c]const AllocationCallbacks, pValidationCache: [*c]ValidationCacheEXT) Result;
pub extern fn vkDestroyValidationCacheEXT(device: Device, validationCache: ValidationCacheEXT, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkMergeValidationCachesEXT(device: Device, dstCache: ValidationCacheEXT, srcCacheCount: u32, pSrcCaches: [*c]const ValidationCacheEXT) Result;
pub extern fn vkGetValidationCacheDataEXT(device: Device, validationCache: ValidationCacheEXT, pDataSize: [*c]usize, pData: ?*c_void) Result;
pub const DescriptorBindingFlagBitsEXT = DescriptorBindingFlagBits;
pub const DescriptorBindingFlagsEXT = DescriptorBindingFlags;
pub const DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
pub const PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
pub const PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
pub const DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
pub const DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
pub const SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV);
pub const SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV);
pub const SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV);
pub const SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV);
pub const SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV);
pub const SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV);
pub const SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV);
pub const SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV);
pub const SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV);
pub const SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV);
pub const SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV);
pub const SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV);
pub const SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = @enumToInt(enum_ShadingRatePaletteEntryNV.SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV);
pub const enum_ShadingRatePaletteEntryNV = extern enum(c_int) {
SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,
SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,
SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,
SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,
SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,
SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,
SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,
SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 2147483647,
_,
};
pub const ShadingRatePaletteEntryNV = enum_ShadingRatePaletteEntryNV;
pub const COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = @enumToInt(enum_CoarseSampleOrderTypeNV.COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV);
pub const COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = @enumToInt(enum_CoarseSampleOrderTypeNV.COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV);
pub const COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = @enumToInt(enum_CoarseSampleOrderTypeNV.COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV);
pub const COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = @enumToInt(enum_CoarseSampleOrderTypeNV.COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV);
pub const COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = @enumToInt(enum_CoarseSampleOrderTypeNV.COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV);
pub const enum_CoarseSampleOrderTypeNV = extern enum(c_int) {
COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,
COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,
COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,
COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,
COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 2147483647,
_,
};
pub const CoarseSampleOrderTypeNV = enum_CoarseSampleOrderTypeNV;
pub const struct_ShadingRatePaletteNV = extern struct {
shadingRatePaletteEntryCount: u32,
pShadingRatePaletteEntries: [*c]const ShadingRatePaletteEntryNV,
};
pub const ShadingRatePaletteNV = struct_ShadingRatePaletteNV;
pub const struct_PipelineViewportShadingRateImageStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
shadingRateImageEnable: Bool32,
viewportCount: u32,
pShadingRatePalettes: [*c]const ShadingRatePaletteNV,
};
pub const PipelineViewportShadingRateImageStateCreateInfoNV = struct_PipelineViewportShadingRateImageStateCreateInfoNV;
pub const struct_PhysicalDeviceShadingRateImageFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
shadingRateImage: Bool32,
shadingRateCoarseSampleOrder: Bool32,
};
pub const PhysicalDeviceShadingRateImageFeaturesNV = struct_PhysicalDeviceShadingRateImageFeaturesNV;
pub const struct_PhysicalDeviceShadingRateImagePropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
shadingRateTexelSize: Extent2D,
shadingRatePaletteSize: u32,
shadingRateMaxCoarseSamples: u32,
};
pub const PhysicalDeviceShadingRateImagePropertiesNV = struct_PhysicalDeviceShadingRateImagePropertiesNV;
pub const struct_CoarseSampleLocationNV = extern struct {
pixelX: u32,
pixelY: u32,
sample: u32,
};
pub const CoarseSampleLocationNV = struct_CoarseSampleLocationNV;
pub const struct_CoarseSampleOrderCustomNV = extern struct {
shadingRate: ShadingRatePaletteEntryNV,
sampleCount: u32,
sampleLocationCount: u32,
pSampleLocations: [*c]const CoarseSampleLocationNV,
};
pub const CoarseSampleOrderCustomNV = struct_CoarseSampleOrderCustomNV;
pub const struct_PipelineViewportCoarseSampleOrderStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
sampleOrderType: CoarseSampleOrderTypeNV,
customSampleOrderCount: u32,
pCustomSampleOrders: [*c]const CoarseSampleOrderCustomNV,
};
pub const PipelineViewportCoarseSampleOrderStateCreateInfoNV = struct_PipelineViewportCoarseSampleOrderStateCreateInfoNV;
pub const PFN_vkCmdBindShadingRateImageNV = ?fn (CommandBuffer, ImageView, ImageLayout) callconv(.C) void;
pub const PFN_vkCmdSetViewportShadingRatePaletteNV = ?fn (CommandBuffer, u32, u32, [*c]const ShadingRatePaletteNV) callconv(.C) void;
pub const PFN_vkCmdSetCoarseSampleOrderNV = ?fn (CommandBuffer, CoarseSampleOrderTypeNV, u32, [*c]const CoarseSampleOrderCustomNV) callconv(.C) void;
pub extern fn vkCmdBindShadingRateImageNV(commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout) void;
pub extern fn vkCmdSetViewportShadingRatePaletteNV(commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: [*c]const ShadingRatePaletteNV) void;
pub extern fn vkCmdSetCoarseSampleOrderNV(commandBuffer: CommandBuffer, sampleOrderType: CoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: [*c]const CoarseSampleOrderCustomNV) void;
pub const struct_AccelerationStructureKHR_T = opaque {};
pub const AccelerationStructureKHR = ?*struct_AccelerationStructureKHR_T;
pub const AccelerationStructureNV = AccelerationStructureKHR;
pub const RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = @enumToInt(enum_RayTracingShaderGroupTypeKHR.RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR);
pub const RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = @enumToInt(enum_RayTracingShaderGroupTypeKHR.RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR);
pub const RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = @enumToInt(enum_RayTracingShaderGroupTypeKHR.RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR);
pub const RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = @enumToInt(enum_RayTracingShaderGroupTypeKHR.RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV);
pub const RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = @enumToInt(enum_RayTracingShaderGroupTypeKHR.RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV);
pub const RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = @enumToInt(enum_RayTracingShaderGroupTypeKHR.RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV);
pub const RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = @enumToInt(enum_RayTracingShaderGroupTypeKHR.RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR);
pub const enum_RayTracingShaderGroupTypeKHR = extern enum(c_int) {
RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0,
RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1,
RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2,
RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0,
RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1,
RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = 2,
RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 2147483647,
_,
};
pub const RayTracingShaderGroupTypeKHR = enum_RayTracingShaderGroupTypeKHR;
pub const RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR;
pub const GEOMETRY_TYPE_TRIANGLES_KHR = @enumToInt(enum_GeometryTypeKHR.GEOMETRY_TYPE_TRIANGLES_KHR);
pub const GEOMETRY_TYPE_AABBS_KHR = @enumToInt(enum_GeometryTypeKHR.GEOMETRY_TYPE_AABBS_KHR);
pub const GEOMETRY_TYPE_INSTANCES_KHR = @enumToInt(enum_GeometryTypeKHR.GEOMETRY_TYPE_INSTANCES_KHR);
pub const GEOMETRY_TYPE_TRIANGLES_NV = @enumToInt(enum_GeometryTypeKHR.GEOMETRY_TYPE_TRIANGLES_NV);
pub const GEOMETRY_TYPE_AABBS_NV = @enumToInt(enum_GeometryTypeKHR.GEOMETRY_TYPE_AABBS_NV);
pub const GEOMETRY_TYPE_MAX_ENUM_KHR = @enumToInt(enum_GeometryTypeKHR.GEOMETRY_TYPE_MAX_ENUM_KHR);
pub const enum_GeometryTypeKHR = extern enum(c_int) {
GEOMETRY_TYPE_TRIANGLES_KHR = 0,
GEOMETRY_TYPE_AABBS_KHR = 1,
GEOMETRY_TYPE_INSTANCES_KHR = 1000150000,
GEOMETRY_TYPE_TRIANGLES_NV = 0,
GEOMETRY_TYPE_AABBS_NV = 1,
GEOMETRY_TYPE_MAX_ENUM_KHR = 2147483647,
_,
};
pub const GeometryTypeKHR = enum_GeometryTypeKHR;
pub const GeometryTypeNV = GeometryTypeKHR;
pub const ACCELERATION_TOP_LEVEL_KHR = @enumToInt(enum_AccelerationStructureTypeKHR.ACCELERATION_TOP_LEVEL_KHR);
pub const ACCELERATION_BOTTOM_LEVEL_KHR = @enumToInt(enum_AccelerationStructureTypeKHR.ACCELERATION_BOTTOM_LEVEL_KHR);
pub const ACCELERATION_TOP_LEVEL_NV = @enumToInt(enum_AccelerationStructureTypeKHR.ACCELERATION_TOP_LEVEL_NV);
pub const ACCELERATION_BOTTOM_LEVEL_NV = @enumToInt(enum_AccelerationStructureTypeKHR.ACCELERATION_BOTTOM_LEVEL_NV);
pub const ACCELERATION_MAX_ENUM_KHR = @enumToInt(enum_AccelerationStructureTypeKHR.ACCELERATION_MAX_ENUM_KHR);
pub const enum_AccelerationStructureTypeKHR = extern enum(c_int) {
ACCELERATION_TOP_LEVEL_KHR = 0,
ACCELERATION_BOTTOM_LEVEL_KHR = 1,
ACCELERATION_TOP_LEVEL_NV = 0,
ACCELERATION_BOTTOM_LEVEL_NV = 1,
ACCELERATION_MAX_ENUM_KHR = 2147483647,
_,
};
pub const AccelerationStructureTypeKHR = enum_AccelerationStructureTypeKHR;
pub const AccelerationStructureTypeNV = AccelerationStructureTypeKHR;
pub const COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = @enumToInt(enum_CopyAccelerationStructureModeKHR.COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR);
pub const COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = @enumToInt(enum_CopyAccelerationStructureModeKHR.COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR);
pub const COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = @enumToInt(enum_CopyAccelerationStructureModeKHR.COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR);
pub const COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = @enumToInt(enum_CopyAccelerationStructureModeKHR.COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR);
pub const COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = @enumToInt(enum_CopyAccelerationStructureModeKHR.COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV);
pub const COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = @enumToInt(enum_CopyAccelerationStructureModeKHR.COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV);
pub const COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = @enumToInt(enum_CopyAccelerationStructureModeKHR.COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR);
pub const enum_CopyAccelerationStructureModeKHR = extern enum(c_int) {
COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0,
COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1,
COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2,
COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3,
COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0,
COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1,
COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 2147483647,
_,
};
pub const CopyAccelerationStructureModeKHR = enum_CopyAccelerationStructureModeKHR;
pub const CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR;
pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_KHR = @enumToInt(enum_AccelerationStructureMemoryRequirementsTypeKHR.ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_KHR);
pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_KHR = @enumToInt(enum_AccelerationStructureMemoryRequirementsTypeKHR.ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_KHR);
pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_KHR = @enumToInt(enum_AccelerationStructureMemoryRequirementsTypeKHR.ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_KHR);
pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = @enumToInt(enum_AccelerationStructureMemoryRequirementsTypeKHR.ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV);
pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = @enumToInt(enum_AccelerationStructureMemoryRequirementsTypeKHR.ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV);
pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = @enumToInt(enum_AccelerationStructureMemoryRequirementsTypeKHR.ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV);
pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_KHR = @enumToInt(enum_AccelerationStructureMemoryRequirementsTypeKHR.ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_KHR);
pub const enum_AccelerationStructureMemoryRequirementsTypeKHR = extern enum(c_int) {
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_KHR = 0,
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_KHR = 1,
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_KHR = 2,
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0,
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1,
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2,
ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_KHR = 2147483647,
_,
};
pub const AccelerationStructureMemoryRequirementsTypeKHR = enum_AccelerationStructureMemoryRequirementsTypeKHR;
pub const AccelerationStructureMemoryRequirementsTypeNV = AccelerationStructureMemoryRequirementsTypeKHR;
pub const GEOMETRY_OPAQUE_BIT_KHR = @enumToInt(enum_GeometryFlagBitsKHR.GEOMETRY_OPAQUE_BIT_KHR);
pub const GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = @enumToInt(enum_GeometryFlagBitsKHR.GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR);
pub const GEOMETRY_OPAQUE_BIT_NV = @enumToInt(enum_GeometryFlagBitsKHR.GEOMETRY_OPAQUE_BIT_NV);
pub const GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = @enumToInt(enum_GeometryFlagBitsKHR.GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV);
pub const GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_GeometryFlagBitsKHR.GEOMETRY_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_GeometryFlagBitsKHR = extern enum(c_int) {
GEOMETRY_OPAQUE_BIT_KHR = 1,
GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 2,
GEOMETRY_OPAQUE_BIT_NV = 1,
GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = 2,
GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const GeometryFlagBitsKHR = enum_GeometryFlagBitsKHR;
pub const GeometryFlagsKHR = Flags;
pub const GeometryFlagsNV = GeometryFlagsKHR;
pub const GeometryFlagBitsNV = GeometryFlagBitsKHR;
pub const GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR);
pub const GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR);
pub const GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR);
pub const GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR);
pub const GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV);
pub const GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV);
pub const GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV);
pub const GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV);
pub const GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_GeometryInstanceFlagBitsKHR.GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_GeometryInstanceFlagBitsKHR = extern enum(c_int) {
GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 1,
GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = 2,
GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 4,
GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 8,
GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = 1,
GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = 2,
GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = 4,
GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = 8,
GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const GeometryInstanceFlagBitsKHR = enum_GeometryInstanceFlagBitsKHR;
pub const GeometryInstanceFlagsKHR = Flags;
pub const GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR;
pub const GeometryInstanceFlagBitsNV = GeometryInstanceFlagBitsKHR;
pub const BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR);
pub const BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR);
pub const BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR);
pub const BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR);
pub const BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR);
pub const BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV);
pub const BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV);
pub const BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV);
pub const BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV);
pub const BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV);
pub const BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = @enumToInt(enum_BuildAccelerationStructureFlagBitsKHR.BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR);
pub const enum_BuildAccelerationStructureFlagBitsKHR = extern enum(c_int) {
BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 1,
BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 2,
BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 4,
BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 8,
BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 16,
BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = 1,
BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = 2,
BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = 4,
BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = 8,
BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = 16,
BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 2147483647,
_,
};
pub const BuildAccelerationStructureFlagBitsKHR = enum_BuildAccelerationStructureFlagBitsKHR;
pub const BuildAccelerationStructureFlagsKHR = Flags;
pub const BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR;
pub const BuildAccelerationStructureFlagBitsNV = BuildAccelerationStructureFlagBitsKHR;
pub const struct_RayTracingShaderGroupCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
type: RayTracingShaderGroupTypeKHR,
generalShader: u32,
closestHitShader: u32,
anyHitShader: u32,
intersectionShader: u32,
};
pub const RayTracingShaderGroupCreateInfoNV = struct_RayTracingShaderGroupCreateInfoNV;
pub const struct_RayTracingPipelineCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineCreateFlags,
stageCount: u32,
pStages: [*c]const PipelineShaderStageCreateInfo,
groupCount: u32,
pGroups: [*c]const RayTracingShaderGroupCreateInfoNV,
maxRecursionDepth: u32,
layout: PipelineLayout,
basePipelineHandle: Pipeline,
basePipelineIndex: i32,
};
pub const RayTracingPipelineCreateInfoNV = struct_RayTracingPipelineCreateInfoNV;
pub const struct_GeometryTrianglesNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
vertexData: Buffer,
vertexOffset: DeviceSize,
vertexCount: u32,
vertexStride: DeviceSize,
vertexFormat: Format,
indexData: Buffer,
indexOffset: DeviceSize,
indexCount: u32,
indexType: IndexType,
transformData: Buffer,
transformOffset: DeviceSize,
};
pub const GeometryTrianglesNV = struct_GeometryTrianglesNV;
pub const struct_GeometryAABBNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
aabbData: Buffer,
numAABBs: u32,
stride: u32,
offset: DeviceSize,
};
pub const GeometryAABBNV = struct_GeometryAABBNV;
pub const struct_GeometryDataNV = extern struct {
triangles: GeometryTrianglesNV,
aabbs: GeometryAABBNV,
};
pub const GeometryDataNV = struct_GeometryDataNV;
pub const struct_GeometryNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
geometryType: GeometryTypeKHR,
geometry: GeometryDataNV,
flags: GeometryFlagsKHR,
};
pub const GeometryNV = struct_GeometryNV;
pub const struct_AccelerationStructureInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
type: AccelerationStructureTypeNV,
flags: BuildAccelerationStructureFlagsNV,
instanceCount: u32,
geometryCount: u32,
pGeometries: [*c]const GeometryNV,
};
pub const AccelerationStructureInfoNV = struct_AccelerationStructureInfoNV;
pub const struct_AccelerationStructureCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
compactedSize: DeviceSize,
info: AccelerationStructureInfoNV,
};
pub const AccelerationStructureCreateInfoNV = struct_AccelerationStructureCreateInfoNV;
pub const struct_BindAccelerationStructureMemoryInfoKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
accelerationStructure: AccelerationStructureKHR,
memory: DeviceMemory,
memoryOffset: DeviceSize,
deviceIndexCount: u32,
pDeviceIndices: [*c]const u32,
};
pub const BindAccelerationStructureMemoryInfoKHR = struct_BindAccelerationStructureMemoryInfoKHR;
pub const BindAccelerationStructureMemoryInfoNV = BindAccelerationStructureMemoryInfoKHR;
pub const struct_WriteDescriptorSetAccelerationStructureKHR = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
accelerationStructureCount: u32,
pAccelerationStructures: [*c]const AccelerationStructureKHR,
};
pub const WriteDescriptorSetAccelerationStructureKHR = struct_WriteDescriptorSetAccelerationStructureKHR;
pub const WriteDescriptorSetAccelerationStructureNV = WriteDescriptorSetAccelerationStructureKHR;
pub const struct_AccelerationStructureMemoryRequirementsInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
type: AccelerationStructureMemoryRequirementsTypeNV,
accelerationStructure: AccelerationStructureNV,
};
pub const AccelerationStructureMemoryRequirementsInfoNV = struct_AccelerationStructureMemoryRequirementsInfoNV;
pub const struct_PhysicalDeviceRayTracingPropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderGroupHandleSize: u32,
maxRecursionDepth: u32,
maxShaderGroupStride: u32,
shaderGroupBaseAlignment: u32,
maxGeometryCount: u64,
maxInstanceCount: u64,
maxTriangleCount: u64,
maxDescriptorSetAccelerationStructures: u32,
};
pub const PhysicalDeviceRayTracingPropertiesNV = struct_PhysicalDeviceRayTracingPropertiesNV;
pub const struct_TransformMatrixKHR = extern struct {
matrix: [3][4]f32,
};
pub const TransformMatrixKHR = struct_TransformMatrixKHR;
pub const TransformMatrixNV = TransformMatrixKHR;
pub const struct_AabbPositionsKHR = extern struct {
minX: f32,
minY: f32,
minZ: f32,
maxX: f32,
maxY: f32,
maxZ: f32,
};
pub const AabbPositionsKHR = struct_AabbPositionsKHR;
pub const AabbPositionsNV = AabbPositionsKHR;
pub const struct_AccelerationStructureInstanceKHR = opaque {}; // /usr/include/vulkan/vulkan_core.h:9502:35: warning: struct demoted to opaque type - has bitfield
pub const AccelerationStructureInstanceKHR = struct_AccelerationStructureInstanceKHR;
pub const AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
pub const PFN_vkCreateAccelerationStructureNV = ?fn (Device, [*c]const AccelerationStructureCreateInfoNV, [*c]const AllocationCallbacks, [*c]AccelerationStructureNV) callconv(.C) Result;
pub const PFN_vkDestroyAccelerationStructureKHR = ?fn (Device, AccelerationStructureKHR, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkDestroyAccelerationStructureNV = ?fn (Device, AccelerationStructureKHR, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkGetAccelerationStructureMemoryRequirementsNV = ?fn (Device, [*c]const AccelerationStructureMemoryRequirementsInfoNV, [*c]MemoryRequirements2KHR) callconv(.C) void;
pub const PFN_vkBindAccelerationStructureMemoryKHR = ?fn (Device, u32, [*c]const BindAccelerationStructureMemoryInfoKHR) callconv(.C) Result;
pub const PFN_vkBindAccelerationStructureMemoryNV = ?fn (Device, u32, [*c]const BindAccelerationStructureMemoryInfoKHR) callconv(.C) Result;
pub const PFN_vkCmdBuildAccelerationStructureNV = ?fn (CommandBuffer, [*c]const AccelerationStructureInfoNV, Buffer, DeviceSize, Bool32, AccelerationStructureKHR, AccelerationStructureKHR, Buffer, DeviceSize) callconv(.C) void;
pub const PFN_vkCmdCopyAccelerationStructureNV = ?fn (CommandBuffer, AccelerationStructureKHR, AccelerationStructureKHR, CopyAccelerationStructureModeKHR) callconv(.C) void;
pub const PFN_vkCmdTraceRaysNV = ?fn (CommandBuffer, Buffer, DeviceSize, Buffer, DeviceSize, DeviceSize, Buffer, DeviceSize, DeviceSize, Buffer, DeviceSize, DeviceSize, u32, u32, u32) callconv(.C) void;
pub const PFN_vkCreateRayTracingPipelinesNV = ?fn (Device, PipelineCache, u32, [*c]const RayTracingPipelineCreateInfoNV, [*c]const AllocationCallbacks, [*c]Pipeline) callconv(.C) Result;
pub const PFN_vkGetRayTracingShaderGroupHandlesKHR = ?fn (Device, Pipeline, u32, u32, usize, ?*c_void) callconv(.C) Result;
pub const PFN_vkGetRayTracingShaderGroupHandlesNV = ?fn (Device, Pipeline, u32, u32, usize, ?*c_void) callconv(.C) Result;
pub const PFN_vkGetAccelerationStructureHandleNV = ?fn (Device, AccelerationStructureKHR, usize, ?*c_void) callconv(.C) Result;
pub const PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = ?fn (CommandBuffer, u32, [*c]const AccelerationStructureKHR, QueryType, QueryPool, u32) callconv(.C) void;
pub const PFN_vkCmdWriteAccelerationStructuresPropertiesNV = ?fn (CommandBuffer, u32, [*c]const AccelerationStructureKHR, QueryType, QueryPool, u32) callconv(.C) void;
pub const PFN_vkCompileDeferredNV = ?fn (Device, Pipeline, u32) callconv(.C) Result;
pub extern fn vkCreateAccelerationStructureNV(device: Device, pCreateInfo: [*c]const AccelerationStructureCreateInfoNV, pAllocator: [*c]const AllocationCallbacks, pAccelerationStructure: [*c]AccelerationStructureNV) Result;
pub extern fn vkDestroyAccelerationStructureKHR(device: Device, accelerationStructure: AccelerationStructureKHR, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkDestroyAccelerationStructureNV(device: Device, accelerationStructure: AccelerationStructureKHR, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkGetAccelerationStructureMemoryRequirementsNV(device: Device, pInfo: [*c]const AccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: [*c]MemoryRequirements2KHR) void;
pub extern fn vkBindAccelerationStructureMemoryKHR(device: Device, bindInfoCount: u32, pBindInfos: [*c]const BindAccelerationStructureMemoryInfoKHR) Result;
pub extern fn vkBindAccelerationStructureMemoryNV(device: Device, bindInfoCount: u32, pBindInfos: [*c]const BindAccelerationStructureMemoryInfoKHR) Result;
pub extern fn vkCmdBuildAccelerationStructureNV(commandBuffer: CommandBuffer, pInfo: [*c]const AccelerationStructureInfoNV, instanceData: Buffer, instanceOffset: DeviceSize, update: Bool32, dst: AccelerationStructureKHR, src: AccelerationStructureKHR, scratch: Buffer, scratchOffset: DeviceSize) void;
pub extern fn vkCmdCopyAccelerationStructureNV(commandBuffer: CommandBuffer, dst: AccelerationStructureKHR, src: AccelerationStructureKHR, mode: CopyAccelerationStructureModeKHR) void;
pub extern fn vkCmdTraceRaysNV(commandBuffer: CommandBuffer, raygenShaderBindingTableBuffer: Buffer, raygenShaderBindingOffset: DeviceSize, missShaderBindingTableBuffer: Buffer, missShaderBindingOffset: DeviceSize, missShaderBindingStride: DeviceSize, hitShaderBindingTableBuffer: Buffer, hitShaderBindingOffset: DeviceSize, hitShaderBindingStride: DeviceSize, callableShaderBindingTableBuffer: Buffer, callableShaderBindingOffset: DeviceSize, callableShaderBindingStride: DeviceSize, width: u32, height: u32, depth: u32) void;
pub extern fn vkCreateRayTracingPipelinesNV(device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [*c]const RayTracingPipelineCreateInfoNV, pAllocator: [*c]const AllocationCallbacks, pPipelines: [*c]Pipeline) Result;
pub extern fn vkGetRayTracingShaderGroupHandlesKHR(device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: ?*c_void) Result;
pub extern fn vkGetRayTracingShaderGroupHandlesNV(device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: ?*c_void) Result;
pub extern fn vkGetAccelerationStructureHandleNV(device: Device, accelerationStructure: AccelerationStructureKHR, dataSize: usize, pData: ?*c_void) Result;
pub extern fn vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: [*c]const AccelerationStructureKHR, queryType: QueryType, queryPool: QueryPool, firstQuery: u32) void;
pub extern fn vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: [*c]const AccelerationStructureKHR, queryType: QueryType, queryPool: QueryPool, firstQuery: u32) void;
pub extern fn vkCompileDeferredNV(device: Device, pipeline: Pipeline, shader: u32) Result;
pub const struct_PhysicalDeviceRepresentativeFragmentTestFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
representativeFragmentTest: Bool32,
};
pub const PhysicalDeviceRepresentativeFragmentTestFeaturesNV = struct_PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
pub const struct_PipelineRepresentativeFragmentTestStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
representativeFragmentTestEnable: Bool32,
};
pub const PipelineRepresentativeFragmentTestStateCreateInfoNV = struct_PipelineRepresentativeFragmentTestStateCreateInfoNV;
pub const struct_PhysicalDeviceImageViewImageFormatInfoEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
imageViewType: ImageViewType,
};
pub const PhysicalDeviceImageViewImageFormatInfoEXT = struct_PhysicalDeviceImageViewImageFormatInfoEXT;
pub const struct_FilterCubicImageViewImageFormatPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
filterCubic: Bool32,
filterCubicMinmax: Bool32,
};
pub const FilterCubicImageViewImageFormatPropertiesEXT = struct_FilterCubicImageViewImageFormatPropertiesEXT;
pub const QUEUE_GLOBAL_PRIORITY_LOW_EXT = @enumToInt(enum_QueueGlobalPriorityEXT.QUEUE_GLOBAL_PRIORITY_LOW_EXT);
pub const QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = @enumToInt(enum_QueueGlobalPriorityEXT.QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT);
pub const QUEUE_GLOBAL_PRIORITY_HIGH_EXT = @enumToInt(enum_QueueGlobalPriorityEXT.QUEUE_GLOBAL_PRIORITY_HIGH_EXT);
pub const QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = @enumToInt(enum_QueueGlobalPriorityEXT.QUEUE_GLOBAL_PRIORITY_REALTIME_EXT);
pub const QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = @enumToInt(enum_QueueGlobalPriorityEXT.QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT);
pub const enum_QueueGlobalPriorityEXT = extern enum(c_int) {
QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 2147483647,
_,
};
pub const QueueGlobalPriorityEXT = enum_QueueGlobalPriorityEXT;
pub const struct_DeviceQueueGlobalPriorityCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
globalPriority: QueueGlobalPriorityEXT,
};
pub const DeviceQueueGlobalPriorityCreateInfoEXT = struct_DeviceQueueGlobalPriorityCreateInfoEXT;
pub const struct_ImportMemoryHostPointerInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
handleType: ExternalMemoryHandleTypeFlagBits,
pHostPointer: ?*c_void,
};
pub const ImportMemoryHostPointerInfoEXT = struct_ImportMemoryHostPointerInfoEXT;
pub const struct_MemoryHostPointerPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
memoryTypeBits: u32,
};
pub const MemoryHostPointerPropertiesEXT = struct_MemoryHostPointerPropertiesEXT;
pub const struct_PhysicalDeviceExternalMemoryHostPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
minImportedHostPointerAlignment: DeviceSize,
};
pub const PhysicalDeviceExternalMemoryHostPropertiesEXT = struct_PhysicalDeviceExternalMemoryHostPropertiesEXT;
pub const PFN_vkGetMemoryHostPointerPropertiesEXT = ?fn (Device, ExternalMemoryHandleTypeFlagBits, ?*const c_void, [*c]MemoryHostPointerPropertiesEXT) callconv(.C) Result;
pub extern fn vkGetMemoryHostPointerPropertiesEXT(device: Device, handleType: ExternalMemoryHandleTypeFlagBits, pHostPointer: ?*const c_void, pMemoryHostPointerProperties: [*c]MemoryHostPointerPropertiesEXT) Result;
pub const PFN_vkCmdWriteBufferMarkerAMD = ?fn (CommandBuffer, PipelineStageFlagBits, Buffer, DeviceSize, u32) callconv(.C) void;
pub extern fn vkCmdWriteBufferMarkerAMD(commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlagBits, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32) void;
pub const PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = @enumToInt(enum_PipelineCompilerControlFlagBitsAMD.PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD);
pub const enum_PipelineCompilerControlFlagBitsAMD = extern enum(c_int) {
PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 2147483647,
_,
};
pub const PipelineCompilerControlFlagBitsAMD = enum_PipelineCompilerControlFlagBitsAMD;
pub const PipelineCompilerControlFlagsAMD = Flags;
pub const struct_PipelineCompilerControlCreateInfoAMD = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
compilerControlFlags: PipelineCompilerControlFlagsAMD,
};
pub const PipelineCompilerControlCreateInfoAMD = struct_PipelineCompilerControlCreateInfoAMD;
pub const TIME_DOMAIN_DEVICE_EXT = @enumToInt(enum_TimeDomainEXT.TIME_DOMAIN_DEVICE_EXT);
pub const TIME_DOMAIN_CLOCK_MONOTONIC_EXT = @enumToInt(enum_TimeDomainEXT.TIME_DOMAIN_CLOCK_MONOTONIC_EXT);
pub const TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = @enumToInt(enum_TimeDomainEXT.TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT);
pub const TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = @enumToInt(enum_TimeDomainEXT.TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT);
pub const TIME_DOMAIN_MAX_ENUM_EXT = @enumToInt(enum_TimeDomainEXT.TIME_DOMAIN_MAX_ENUM_EXT);
pub const enum_TimeDomainEXT = extern enum(c_int) {
TIME_DOMAIN_DEVICE_EXT = 0,
TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
TIME_DOMAIN_MAX_ENUM_EXT = 2147483647,
_,
};
pub const TimeDomainEXT = enum_TimeDomainEXT;
pub const struct_CalibratedTimestampInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
timeDomain: TimeDomainEXT,
};
pub const CalibratedTimestampInfoEXT = struct_CalibratedTimestampInfoEXT;
pub const PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = ?fn (PhysicalDevice, [*c]u32, [*c]TimeDomainEXT) callconv(.C) Result;
pub const PFN_vkGetCalibratedTimestampsEXT = ?fn (Device, u32, [*c]const CalibratedTimestampInfoEXT, [*c]u64, [*c]u64) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice: PhysicalDevice, pTimeDomainCount: [*c]u32, pTimeDomains: [*c]TimeDomainEXT) Result;
pub extern fn vkGetCalibratedTimestampsEXT(device: Device, timestampCount: u32, pTimestampInfos: [*c]const CalibratedTimestampInfoEXT, pTimestamps: [*c]u64, pMaxDeviation: [*c]u64) Result;
pub const struct_PhysicalDeviceShaderCorePropertiesAMD = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderEngineCount: u32,
shaderArraysPerEngineCount: u32,
computeUnitsPerShaderArray: u32,
simdPerComputeUnit: u32,
wavefrontsPerSimd: u32,
wavefrontSize: u32,
sgprsPerSimd: u32,
minSgprAllocation: u32,
maxSgprAllocation: u32,
sgprAllocationGranularity: u32,
vgprsPerSimd: u32,
minVgprAllocation: u32,
maxVgprAllocation: u32,
vgprAllocationGranularity: u32,
};
pub const PhysicalDeviceShaderCorePropertiesAMD = struct_PhysicalDeviceShaderCorePropertiesAMD;
pub const MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = @enumToInt(enum_MemoryOverallocationBehaviorAMD.MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD);
pub const MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = @enumToInt(enum_MemoryOverallocationBehaviorAMD.MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD);
pub const MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = @enumToInt(enum_MemoryOverallocationBehaviorAMD.MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD);
pub const MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = @enumToInt(enum_MemoryOverallocationBehaviorAMD.MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD);
pub const enum_MemoryOverallocationBehaviorAMD = extern enum(c_int) {
MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0,
MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1,
MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2,
MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 2147483647,
_,
};
pub const MemoryOverallocationBehaviorAMD = enum_MemoryOverallocationBehaviorAMD;
pub const struct_DeviceMemoryOverallocationCreateInfoAMD = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
overallocationBehavior: MemoryOverallocationBehaviorAMD,
};
pub const DeviceMemoryOverallocationCreateInfoAMD = struct_DeviceMemoryOverallocationCreateInfoAMD;
pub const struct_PhysicalDeviceVertexAttributeDivisorPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxVertexAttribDivisor: u32,
};
pub const PhysicalDeviceVertexAttributeDivisorPropertiesEXT = struct_PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
pub const struct_VertexInputBindingDivisorDescriptionEXT = extern struct {
binding: u32,
divisor: u32,
};
pub const VertexInputBindingDivisorDescriptionEXT = struct_VertexInputBindingDivisorDescriptionEXT;
pub const struct_PipelineVertexInputDivisorStateCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
vertexBindingDivisorCount: u32,
pVertexBindingDivisors: [*c]const VertexInputBindingDivisorDescriptionEXT,
};
pub const PipelineVertexInputDivisorStateCreateInfoEXT = struct_PipelineVertexInputDivisorStateCreateInfoEXT;
pub const struct_PhysicalDeviceVertexAttributeDivisorFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
vertexAttributeInstanceRateDivisor: Bool32,
vertexAttributeInstanceRateZeroDivisor: Bool32,
};
pub const PhysicalDeviceVertexAttributeDivisorFeaturesEXT = struct_PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
pub const PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = @enumToInt(enum_PipelineCreationFeedbackFlagBitsEXT.PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT);
pub const PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = @enumToInt(enum_PipelineCreationFeedbackFlagBitsEXT.PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT);
pub const PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = @enumToInt(enum_PipelineCreationFeedbackFlagBitsEXT.PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT);
pub const PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = @enumToInt(enum_PipelineCreationFeedbackFlagBitsEXT.PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT);
pub const enum_PipelineCreationFeedbackFlagBitsEXT = extern enum(c_int) {
PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 1,
PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 2,
PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 4,
PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = 2147483647,
_,
};
pub const PipelineCreationFeedbackFlagBitsEXT = enum_PipelineCreationFeedbackFlagBitsEXT;
pub const PipelineCreationFeedbackFlagsEXT = Flags;
pub const struct_PipelineCreationFeedbackEXT = extern struct {
flags: PipelineCreationFeedbackFlagsEXT,
duration: u64,
};
pub const PipelineCreationFeedbackEXT = struct_PipelineCreationFeedbackEXT;
pub const struct_PipelineCreationFeedbackCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pPipelineCreationFeedback: [*c]PipelineCreationFeedbackEXT,
pipelineStageCreationFeedbackCount: u32,
pPipelineStageCreationFeedbacks: [*c]PipelineCreationFeedbackEXT,
};
pub const PipelineCreationFeedbackCreateInfoEXT = struct_PipelineCreationFeedbackCreateInfoEXT;
pub const struct_PhysicalDeviceComputeShaderDerivativesFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
computeDerivativeGroupQuads: Bool32,
computeDerivativeGroupLinear: Bool32,
};
pub const PhysicalDeviceComputeShaderDerivativesFeaturesNV = struct_PhysicalDeviceComputeShaderDerivativesFeaturesNV;
pub const struct_PhysicalDeviceMeshShaderFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
taskShader: Bool32,
meshShader: Bool32,
};
pub const PhysicalDeviceMeshShaderFeaturesNV = struct_PhysicalDeviceMeshShaderFeaturesNV;
pub const struct_PhysicalDeviceMeshShaderPropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxDrawMeshTasksCount: u32,
maxTaskWorkGroupInvocations: u32,
maxTaskWorkGroupSize: [3]u32,
maxTaskTotalMemorySize: u32,
maxTaskOutputCount: u32,
maxMeshWorkGroupInvocations: u32,
maxMeshWorkGroupSize: [3]u32,
maxMeshTotalMemorySize: u32,
maxMeshOutputVertices: u32,
maxMeshOutputPrimitives: u32,
maxMeshMultiviewViewCount: u32,
meshOutputPerVertexGranularity: u32,
meshOutputPerPrimitiveGranularity: u32,
};
pub const PhysicalDeviceMeshShaderPropertiesNV = struct_PhysicalDeviceMeshShaderPropertiesNV;
pub const struct_DrawMeshTasksIndirectCommandNV = extern struct {
taskCount: u32,
firstTask: u32,
};
pub const DrawMeshTasksIndirectCommandNV = struct_DrawMeshTasksIndirectCommandNV;
pub const PFN_vkCmdDrawMeshTasksNV = ?fn (CommandBuffer, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawMeshTasksIndirectNV = ?fn (CommandBuffer, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub const PFN_vkCmdDrawMeshTasksIndirectCountNV = ?fn (CommandBuffer, Buffer, DeviceSize, Buffer, DeviceSize, u32, u32) callconv(.C) void;
pub extern fn vkCmdDrawMeshTasksNV(commandBuffer: CommandBuffer, taskCount: u32, firstTask: u32) void;
pub extern fn vkCmdDrawMeshTasksIndirectNV(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) void;
pub extern fn vkCmdDrawMeshTasksIndirectCountNV(commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) void;
pub const struct_PhysicalDeviceFragmentShaderBarycentricFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
fragmentShaderBarycentric: Bool32,
};
pub const PhysicalDeviceFragmentShaderBarycentricFeaturesNV = struct_PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
pub const struct_PhysicalDeviceShaderImageFootprintFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
imageFootprint: Bool32,
};
pub const PhysicalDeviceShaderImageFootprintFeaturesNV = struct_PhysicalDeviceShaderImageFootprintFeaturesNV;
pub const struct_PipelineViewportExclusiveScissorStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
exclusiveScissorCount: u32,
pExclusiveScissors: [*c]const Rect2D,
};
pub const PipelineViewportExclusiveScissorStateCreateInfoNV = struct_PipelineViewportExclusiveScissorStateCreateInfoNV;
pub const struct_PhysicalDeviceExclusiveScissorFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
exclusiveScissor: Bool32,
};
pub const PhysicalDeviceExclusiveScissorFeaturesNV = struct_PhysicalDeviceExclusiveScissorFeaturesNV;
pub const PFN_vkCmdSetExclusiveScissorNV = ?fn (CommandBuffer, u32, u32, [*c]const Rect2D) callconv(.C) void;
pub extern fn vkCmdSetExclusiveScissorNV(commandBuffer: CommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: [*c]const Rect2D) void;
pub const struct_QueueFamilyCheckpointPropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
checkpointExecutionStageMask: PipelineStageFlags,
};
pub const QueueFamilyCheckpointPropertiesNV = struct_QueueFamilyCheckpointPropertiesNV;
pub const struct_CheckpointDataNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
stage: PipelineStageFlagBits,
pCheckpointMarker: ?*c_void,
};
pub const CheckpointDataNV = struct_CheckpointDataNV;
pub const PFN_vkCmdSetCheckpointNV = ?fn (CommandBuffer, ?*const c_void) callconv(.C) void;
pub const PFN_vkGetQueueCheckpointDataNV = ?fn (Queue, [*c]u32, [*c]CheckpointDataNV) callconv(.C) void;
pub extern fn vkCmdSetCheckpointNV(commandBuffer: CommandBuffer, pCheckpointMarker: ?*const c_void) void;
pub extern fn vkGetQueueCheckpointDataNV(queue: Queue, pCheckpointDataCount: [*c]u32, pCheckpointData: [*c]CheckpointDataNV) void;
pub const struct_PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderIntegerFunctions2: Bool32,
};
pub const PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = struct_PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
pub const struct_PerformanceConfigurationINTEL_T = opaque {};
pub const PerformanceConfigurationINTEL = ?*struct_PerformanceConfigurationINTEL_T;
pub const PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = @enumToInt(enum_PerformanceConfigurationTypeINTEL.PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL);
pub const PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = @enumToInt(enum_PerformanceConfigurationTypeINTEL.PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL);
pub const enum_PerformanceConfigurationTypeINTEL = extern enum(c_int) {
PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,
PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 2147483647,
_,
};
pub const PerformanceConfigurationTypeINTEL = enum_PerformanceConfigurationTypeINTEL;
pub const QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = @enumToInt(enum_QueryPoolSamplingModeINTEL.QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL);
pub const QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = @enumToInt(enum_QueryPoolSamplingModeINTEL.QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL);
pub const enum_QueryPoolSamplingModeINTEL = extern enum(c_int) {
QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,
QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 2147483647,
_,
};
pub const QueryPoolSamplingModeINTEL = enum_QueryPoolSamplingModeINTEL;
pub const PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = @enumToInt(enum_PerformanceOverrideTypeINTEL.PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL);
pub const PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = @enumToInt(enum_PerformanceOverrideTypeINTEL.PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL);
pub const PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = @enumToInt(enum_PerformanceOverrideTypeINTEL.PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL);
pub const enum_PerformanceOverrideTypeINTEL = extern enum(c_int) {
PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0,
PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,
PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 2147483647,
_,
};
pub const PerformanceOverrideTypeINTEL = enum_PerformanceOverrideTypeINTEL;
pub const PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = @enumToInt(enum_PerformanceParameterTypeINTEL.PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL);
pub const PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = @enumToInt(enum_PerformanceParameterTypeINTEL.PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL);
pub const PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = @enumToInt(enum_PerformanceParameterTypeINTEL.PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL);
pub const enum_PerformanceParameterTypeINTEL = extern enum(c_int) {
PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0,
PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,
PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 2147483647,
_,
};
pub const PerformanceParameterTypeINTEL = enum_PerformanceParameterTypeINTEL;
pub const PERFORMANCE_VALUE_TYPE_UINT32_INTEL = @enumToInt(enum_PerformanceValueTypeINTEL.PERFORMANCE_VALUE_TYPE_UINT32_INTEL);
pub const PERFORMANCE_VALUE_TYPE_UINT64_INTEL = @enumToInt(enum_PerformanceValueTypeINTEL.PERFORMANCE_VALUE_TYPE_UINT64_INTEL);
pub const PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = @enumToInt(enum_PerformanceValueTypeINTEL.PERFORMANCE_VALUE_TYPE_FLOAT_INTEL);
pub const PERFORMANCE_VALUE_TYPE_BOOL_INTEL = @enumToInt(enum_PerformanceValueTypeINTEL.PERFORMANCE_VALUE_TYPE_BOOL_INTEL);
pub const PERFORMANCE_VALUE_TYPE_STRING_INTEL = @enumToInt(enum_PerformanceValueTypeINTEL.PERFORMANCE_VALUE_TYPE_STRING_INTEL);
pub const PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = @enumToInt(enum_PerformanceValueTypeINTEL.PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL);
pub const enum_PerformanceValueTypeINTEL = extern enum(c_int) {
PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2,
PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3,
PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 2147483647,
_,
};
pub const PerformanceValueTypeINTEL = enum_PerformanceValueTypeINTEL;
pub const union_PerformanceValueDataINTEL = extern union {
value32: u32,
value64: u64,
valueFloat: f32,
valueBool: Bool32,
valueString: [*c]const u8,
};
pub const PerformanceValueDataINTEL = union_PerformanceValueDataINTEL;
pub const struct_PerformanceValueINTEL = extern struct {
type: PerformanceValueTypeINTEL,
data: PerformanceValueDataINTEL,
};
pub const PerformanceValueINTEL = struct_PerformanceValueINTEL;
pub const struct_InitializePerformanceApiInfoINTEL = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pUserData: ?*c_void,
};
pub const InitializePerformanceApiInfoINTEL = struct_InitializePerformanceApiInfoINTEL;
pub const struct_QueryPoolPerformanceQueryCreateInfoINTEL = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
performanceCountersSampling: QueryPoolSamplingModeINTEL,
};
pub const QueryPoolPerformanceQueryCreateInfoINTEL = struct_QueryPoolPerformanceQueryCreateInfoINTEL;
pub const QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
pub const struct_PerformanceMarkerInfoINTEL = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
marker: u64,
};
pub const PerformanceMarkerInfoINTEL = struct_PerformanceMarkerInfoINTEL;
pub const struct_PerformanceStreamMarkerInfoINTEL = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
marker: u32,
};
pub const PerformanceStreamMarkerInfoINTEL = struct_PerformanceStreamMarkerInfoINTEL;
pub const struct_PerformanceOverrideInfoINTEL = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
type: PerformanceOverrideTypeINTEL,
enable: Bool32,
parameter: u64,
};
pub const PerformanceOverrideInfoINTEL = struct_PerformanceOverrideInfoINTEL;
pub const struct_PerformanceConfigurationAcquireInfoINTEL = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
type: PerformanceConfigurationTypeINTEL,
};
pub const PerformanceConfigurationAcquireInfoINTEL = struct_PerformanceConfigurationAcquireInfoINTEL;
pub const PFN_vkInitializePerformanceApiINTEL = ?fn (Device, [*c]const InitializePerformanceApiInfoINTEL) callconv(.C) Result;
pub const PFN_vkUninitializePerformanceApiINTEL = ?fn (Device) callconv(.C) void;
pub const PFN_vkCmdSetPerformanceMarkerINTEL = ?fn (CommandBuffer, [*c]const PerformanceMarkerInfoINTEL) callconv(.C) Result;
pub const PFN_vkCmdSetPerformanceStreamMarkerINTEL = ?fn (CommandBuffer, [*c]const PerformanceStreamMarkerInfoINTEL) callconv(.C) Result;
pub const PFN_vkCmdSetPerformanceOverrideINTEL = ?fn (CommandBuffer, [*c]const PerformanceOverrideInfoINTEL) callconv(.C) Result;
pub const PFN_vkAcquirePerformanceConfigurationINTEL = ?fn (Device, [*c]const PerformanceConfigurationAcquireInfoINTEL, [*c]PerformanceConfigurationINTEL) callconv(.C) Result;
pub const PFN_vkReleasePerformanceConfigurationINTEL = ?fn (Device, PerformanceConfigurationINTEL) callconv(.C) Result;
pub const PFN_vkQueueSetPerformanceConfigurationINTEL = ?fn (Queue, PerformanceConfigurationINTEL) callconv(.C) Result;
pub const PFN_vkGetPerformanceParameterINTEL = ?fn (Device, PerformanceParameterTypeINTEL, [*c]PerformanceValueINTEL) callconv(.C) Result;
pub extern fn vkInitializePerformanceApiINTEL(device: Device, pInitializeInfo: [*c]const InitializePerformanceApiInfoINTEL) Result;
pub extern fn vkUninitializePerformanceApiINTEL(device: Device) void;
pub extern fn vkCmdSetPerformanceMarkerINTEL(commandBuffer: CommandBuffer, pMarkerInfo: [*c]const PerformanceMarkerInfoINTEL) Result;
pub extern fn vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer: CommandBuffer, pMarkerInfo: [*c]const PerformanceStreamMarkerInfoINTEL) Result;
pub extern fn vkCmdSetPerformanceOverrideINTEL(commandBuffer: CommandBuffer, pOverrideInfo: [*c]const PerformanceOverrideInfoINTEL) Result;
pub extern fn vkAcquirePerformanceConfigurationINTEL(device: Device, pAcquireInfo: [*c]const PerformanceConfigurationAcquireInfoINTEL, pConfiguration: [*c]PerformanceConfigurationINTEL) Result;
pub extern fn vkReleasePerformanceConfigurationINTEL(device: Device, configuration: PerformanceConfigurationINTEL) Result;
pub extern fn vkQueueSetPerformanceConfigurationINTEL(queue: Queue, configuration: PerformanceConfigurationINTEL) Result;
pub extern fn vkGetPerformanceParameterINTEL(device: Device, parameter: PerformanceParameterTypeINTEL, pValue: [*c]PerformanceValueINTEL) Result;
pub const struct_PhysicalDevicePCIBusInfoPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
pciDomain: u32,
pciBus: u32,
pciDevice: u32,
pciFunction: u32,
};
pub const PhysicalDevicePCIBusInfoPropertiesEXT = struct_PhysicalDevicePCIBusInfoPropertiesEXT;
pub const struct_DisplayNativeHdrSurfaceCapabilitiesAMD = extern struct {
sType: StructureType,
pNext: ?*c_void,
localDimmingSupport: Bool32,
};
pub const DisplayNativeHdrSurfaceCapabilitiesAMD = struct_DisplayNativeHdrSurfaceCapabilitiesAMD;
pub const struct_SwapchainDisplayNativeHdrCreateInfoAMD = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
localDimmingEnable: Bool32,
};
pub const SwapchainDisplayNativeHdrCreateInfoAMD = struct_SwapchainDisplayNativeHdrCreateInfoAMD;
pub const PFN_vkSetLocalDimmingAMD = ?fn (Device, SwapchainKHR, Bool32) callconv(.C) void;
pub extern fn vkSetLocalDimmingAMD(device: Device, swapChain: SwapchainKHR, localDimmingEnable: Bool32) void;
pub const struct_PhysicalDeviceFragmentDensityMapFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
fragmentDensityMap: Bool32,
fragmentDensityMapDynamic: Bool32,
fragmentDensityMapNonSubsampledImages: Bool32,
};
pub const PhysicalDeviceFragmentDensityMapFeaturesEXT = struct_PhysicalDeviceFragmentDensityMapFeaturesEXT;
pub const struct_PhysicalDeviceFragmentDensityMapPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
minFragmentDensityTexelSize: Extent2D,
maxFragmentDensityTexelSize: Extent2D,
fragmentDensityInvocations: Bool32,
};
pub const PhysicalDeviceFragmentDensityMapPropertiesEXT = struct_PhysicalDeviceFragmentDensityMapPropertiesEXT;
pub const struct_RenderPassFragmentDensityMapCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
fragmentDensityMapAttachment: AttachmentReference,
};
pub const RenderPassFragmentDensityMapCreateInfoEXT = struct_RenderPassFragmentDensityMapCreateInfoEXT;
pub const PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
pub const struct_PhysicalDeviceSubgroupSizeControlFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
subgroupSizeControl: Bool32,
computeFullSubgroups: Bool32,
};
pub const PhysicalDeviceSubgroupSizeControlFeaturesEXT = struct_PhysicalDeviceSubgroupSizeControlFeaturesEXT;
pub const struct_PhysicalDeviceSubgroupSizeControlPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
minSubgroupSize: u32,
maxSubgroupSize: u32,
maxComputeWorkgroupSubgroups: u32,
requiredSubgroupSizeStages: ShaderStageFlags,
};
pub const PhysicalDeviceSubgroupSizeControlPropertiesEXT = struct_PhysicalDeviceSubgroupSizeControlPropertiesEXT;
pub const struct_PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
requiredSubgroupSize: u32,
};
pub const PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = struct_PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
pub const SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = @enumToInt(enum_ShaderCorePropertiesFlagBitsAMD.SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD);
pub const enum_ShaderCorePropertiesFlagBitsAMD = extern enum(c_int) {
SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 2147483647,
_,
};
pub const ShaderCorePropertiesFlagBitsAMD = enum_ShaderCorePropertiesFlagBitsAMD;
pub const ShaderCorePropertiesFlagsAMD = Flags;
pub const struct_PhysicalDeviceShaderCoreProperties2AMD = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderCoreFeatures: ShaderCorePropertiesFlagsAMD,
activeComputeUnitCount: u32,
};
pub const PhysicalDeviceShaderCoreProperties2AMD = struct_PhysicalDeviceShaderCoreProperties2AMD;
pub const struct_PhysicalDeviceCoherentMemoryFeaturesAMD = extern struct {
sType: StructureType,
pNext: ?*c_void,
deviceCoherentMemory: Bool32,
};
pub const PhysicalDeviceCoherentMemoryFeaturesAMD = struct_PhysicalDeviceCoherentMemoryFeaturesAMD;
pub const struct_PhysicalDeviceShaderImageAtomicInt64FeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderImageInt64Atomics: Bool32,
sparseImageInt64Atomics: Bool32,
};
pub const PhysicalDeviceShaderImageAtomicInt64FeaturesEXT = struct_PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
pub const struct_PhysicalDeviceMemoryBudgetPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
heapBudget: [16]DeviceSize,
heapUsage: [16]DeviceSize,
};
pub const PhysicalDeviceMemoryBudgetPropertiesEXT = struct_PhysicalDeviceMemoryBudgetPropertiesEXT;
pub const struct_PhysicalDeviceMemoryPriorityFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
memoryPriority: Bool32,
};
pub const PhysicalDeviceMemoryPriorityFeaturesEXT = struct_PhysicalDeviceMemoryPriorityFeaturesEXT;
pub const struct_MemoryPriorityAllocateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
priority: f32,
};
pub const MemoryPriorityAllocateInfoEXT = struct_MemoryPriorityAllocateInfoEXT;
pub const struct_PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
dedicatedAllocationImageAliasing: Bool32,
};
pub const PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = struct_PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
pub const struct_PhysicalDeviceBufferDeviceAddressFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
bufferDeviceAddress: Bool32,
bufferDeviceAddressCaptureReplay: Bool32,
bufferDeviceAddressMultiDevice: Bool32,
};
pub const PhysicalDeviceBufferDeviceAddressFeaturesEXT = struct_PhysicalDeviceBufferDeviceAddressFeaturesEXT;
pub const PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
pub const BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
pub const struct_BufferDeviceAddressCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
deviceAddress: DeviceAddress,
};
pub const BufferDeviceAddressCreateInfoEXT = struct_BufferDeviceAddressCreateInfoEXT;
pub const PFN_vkGetBufferDeviceAddressEXT = ?fn (Device, [*c]const BufferDeviceAddressInfo) callconv(.C) DeviceAddress;
pub extern fn vkGetBufferDeviceAddressEXT(device: Device, pInfo: [*c]const BufferDeviceAddressInfo) DeviceAddress;
pub const TOOL_PURPOSE_VALIDATION_BIT_EXT = @enumToInt(enum_ToolPurposeFlagBitsEXT.TOOL_PURPOSE_VALIDATION_BIT_EXT);
pub const TOOL_PURPOSE_PROFILING_BIT_EXT = @enumToInt(enum_ToolPurposeFlagBitsEXT.TOOL_PURPOSE_PROFILING_BIT_EXT);
pub const TOOL_PURPOSE_TRACING_BIT_EXT = @enumToInt(enum_ToolPurposeFlagBitsEXT.TOOL_PURPOSE_TRACING_BIT_EXT);
pub const TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = @enumToInt(enum_ToolPurposeFlagBitsEXT.TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT);
pub const TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = @enumToInt(enum_ToolPurposeFlagBitsEXT.TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT);
pub const TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = @enumToInt(enum_ToolPurposeFlagBitsEXT.TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT);
pub const TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = @enumToInt(enum_ToolPurposeFlagBitsEXT.TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT);
pub const TOOL_PURPOSE_FLAG_BITS_MAX_ENUM_EXT = @enumToInt(enum_ToolPurposeFlagBitsEXT.TOOL_PURPOSE_FLAG_BITS_MAX_ENUM_EXT);
pub const enum_ToolPurposeFlagBitsEXT = extern enum(c_int) {
TOOL_PURPOSE_VALIDATION_BIT_EXT = 1,
TOOL_PURPOSE_PROFILING_BIT_EXT = 2,
TOOL_PURPOSE_TRACING_BIT_EXT = 4,
TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 8,
TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 16,
TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 32,
TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 64,
TOOL_PURPOSE_FLAG_BITS_MAX_ENUM_EXT = 2147483647,
_,
};
pub const ToolPurposeFlagBitsEXT = enum_ToolPurposeFlagBitsEXT;
pub const ToolPurposeFlagsEXT = Flags;
pub const struct_PhysicalDeviceToolPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
name: [256]u8,
version: [256]u8,
purposes: ToolPurposeFlagsEXT,
description: [256]u8,
layer: [256]u8,
};
pub const PhysicalDeviceToolPropertiesEXT = struct_PhysicalDeviceToolPropertiesEXT;
pub const PFN_vkGetPhysicalDeviceToolPropertiesEXT = ?fn (PhysicalDevice, [*c]u32, [*c]PhysicalDeviceToolPropertiesEXT) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice: PhysicalDevice, pToolCount: [*c]u32, pToolProperties: [*c]PhysicalDeviceToolPropertiesEXT) Result;
pub const ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
pub const VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = @enumToInt(enum_ValidationFeatureEnableEXT.VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT);
pub const VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = @enumToInt(enum_ValidationFeatureEnableEXT.VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT);
pub const VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = @enumToInt(enum_ValidationFeatureEnableEXT.VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT);
pub const VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = @enumToInt(enum_ValidationFeatureEnableEXT.VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT);
pub const VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = @enumToInt(enum_ValidationFeatureEnableEXT.VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT);
pub const VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = @enumToInt(enum_ValidationFeatureEnableEXT.VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT);
pub const enum_ValidationFeatureEnableEXT = extern enum(c_int) {
VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,
VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3,
VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4,
VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const ValidationFeatureEnableEXT = enum_ValidationFeatureEnableEXT;
pub const VALIDATION_FEATURE_DISABLE_ALL_EXT = @enumToInt(enum_ValidationFeatureDisableEXT.VALIDATION_FEATURE_DISABLE_ALL_EXT);
pub const VALIDATION_FEATURE_DISABLE_SHADERS_EXT = @enumToInt(enum_ValidationFeatureDisableEXT.VALIDATION_FEATURE_DISABLE_SHADERS_EXT);
pub const VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = @enumToInt(enum_ValidationFeatureDisableEXT.VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT);
pub const VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = @enumToInt(enum_ValidationFeatureDisableEXT.VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT);
pub const VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = @enumToInt(enum_ValidationFeatureDisableEXT.VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT);
pub const VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = @enumToInt(enum_ValidationFeatureDisableEXT.VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT);
pub const VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = @enumToInt(enum_ValidationFeatureDisableEXT.VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT);
pub const VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = @enumToInt(enum_ValidationFeatureDisableEXT.VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT);
pub const enum_ValidationFeatureDisableEXT = extern enum(c_int) {
VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,
VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,
VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,
VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,
VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,
VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,
VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,
VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const ValidationFeatureDisableEXT = enum_ValidationFeatureDisableEXT;
pub const struct_ValidationFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
enabledValidationFeatureCount: u32,
pEnabledValidationFeatures: [*c]const ValidationFeatureEnableEXT,
disabledValidationFeatureCount: u32,
pDisabledValidationFeatures: [*c]const ValidationFeatureDisableEXT,
};
pub const ValidationFeaturesEXT = struct_ValidationFeaturesEXT;
pub const COMPONENT_TYPE_FLOAT16_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_FLOAT16_NV);
pub const COMPONENT_TYPE_FLOAT32_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_FLOAT32_NV);
pub const COMPONENT_TYPE_FLOAT64_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_FLOAT64_NV);
pub const COMPONENT_TYPE_SINT8_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_SINT8_NV);
pub const COMPONENT_TYPE_SINT16_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_SINT16_NV);
pub const COMPONENT_TYPE_SINT32_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_SINT32_NV);
pub const COMPONENT_TYPE_SINT64_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_SINT64_NV);
pub const COMPONENT_TYPE_UINT8_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_UINT8_NV);
pub const COMPONENT_TYPE_UINT16_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_UINT16_NV);
pub const COMPONENT_TYPE_UINT32_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_UINT32_NV);
pub const COMPONENT_TYPE_UINT64_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_UINT64_NV);
pub const COMPONENT_TYPE_MAX_ENUM_NV = @enumToInt(enum_ComponentTypeNV.COMPONENT_TYPE_MAX_ENUM_NV);
pub const enum_ComponentTypeNV = extern enum(c_int) {
COMPONENT_TYPE_FLOAT16_NV = 0,
COMPONENT_TYPE_FLOAT32_NV = 1,
COMPONENT_TYPE_FLOAT64_NV = 2,
COMPONENT_TYPE_SINT8_NV = 3,
COMPONENT_TYPE_SINT16_NV = 4,
COMPONENT_TYPE_SINT32_NV = 5,
COMPONENT_TYPE_SINT64_NV = 6,
COMPONENT_TYPE_UINT8_NV = 7,
COMPONENT_TYPE_UINT16_NV = 8,
COMPONENT_TYPE_UINT32_NV = 9,
COMPONENT_TYPE_UINT64_NV = 10,
COMPONENT_TYPE_MAX_ENUM_NV = 2147483647,
_,
};
pub const ComponentTypeNV = enum_ComponentTypeNV;
pub const SCOPE_DEVICE_NV = @enumToInt(enum_ScopeNV.SCOPE_DEVICE_NV);
pub const SCOPE_WORKGROUP_NV = @enumToInt(enum_ScopeNV.SCOPE_WORKGROUP_NV);
pub const SCOPE_SUBGROUP_NV = @enumToInt(enum_ScopeNV.SCOPE_SUBGROUP_NV);
pub const SCOPE_QUEUE_FAMILY_NV = @enumToInt(enum_ScopeNV.SCOPE_QUEUE_FAMILY_NV);
pub const SCOPE_MAX_ENUM_NV = @enumToInt(enum_ScopeNV.SCOPE_MAX_ENUM_NV);
pub const enum_ScopeNV = extern enum(c_int) {
SCOPE_DEVICE_NV = 1,
SCOPE_WORKGROUP_NV = 2,
SCOPE_SUBGROUP_NV = 3,
SCOPE_QUEUE_FAMILY_NV = 5,
SCOPE_MAX_ENUM_NV = 2147483647,
_,
};
pub const ScopeNV = enum_ScopeNV;
pub const struct_CooperativeMatrixPropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
MSize: u32,
NSize: u32,
KSize: u32,
AType: ComponentTypeNV,
BType: ComponentTypeNV,
CType: ComponentTypeNV,
DType: ComponentTypeNV,
scope: ScopeNV,
};
pub const CooperativeMatrixPropertiesNV = struct_CooperativeMatrixPropertiesNV;
pub const struct_PhysicalDeviceCooperativeMatrixFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
cooperativeMatrix: Bool32,
cooperativeMatrixRobustBufferAccess: Bool32,
};
pub const PhysicalDeviceCooperativeMatrixFeaturesNV = struct_PhysicalDeviceCooperativeMatrixFeaturesNV;
pub const struct_PhysicalDeviceCooperativeMatrixPropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
cooperativeMatrixSupportedStages: ShaderStageFlags,
};
pub const PhysicalDeviceCooperativeMatrixPropertiesNV = struct_PhysicalDeviceCooperativeMatrixPropertiesNV;
pub const PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = ?fn (PhysicalDevice, [*c]u32, [*c]CooperativeMatrixPropertiesNV) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice: PhysicalDevice, pPropertyCount: [*c]u32, pProperties: [*c]CooperativeMatrixPropertiesNV) Result;
pub const COVERAGE_REDUCTION_MODE_MERGE_NV = @enumToInt(enum_CoverageReductionModeNV.COVERAGE_REDUCTION_MODE_MERGE_NV);
pub const COVERAGE_REDUCTION_MODE_TRUNCATE_NV = @enumToInt(enum_CoverageReductionModeNV.COVERAGE_REDUCTION_MODE_TRUNCATE_NV);
pub const COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = @enumToInt(enum_CoverageReductionModeNV.COVERAGE_REDUCTION_MODE_MAX_ENUM_NV);
pub const enum_CoverageReductionModeNV = extern enum(c_int) {
COVERAGE_REDUCTION_MODE_MERGE_NV = 0,
COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1,
COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 2147483647,
_,
};
pub const CoverageReductionModeNV = enum_CoverageReductionModeNV;
pub const PipelineCoverageReductionStateCreateFlagsNV = Flags;
pub const struct_PhysicalDeviceCoverageReductionModeFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
coverageReductionMode: Bool32,
};
pub const PhysicalDeviceCoverageReductionModeFeaturesNV = struct_PhysicalDeviceCoverageReductionModeFeaturesNV;
pub const struct_PipelineCoverageReductionStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PipelineCoverageReductionStateCreateFlagsNV,
coverageReductionMode: CoverageReductionModeNV,
};
pub const PipelineCoverageReductionStateCreateInfoNV = struct_PipelineCoverageReductionStateCreateInfoNV;
pub const struct_FramebufferMixedSamplesCombinationNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
coverageReductionMode: CoverageReductionModeNV,
rasterizationSamples: SampleCountFlagBits,
depthStencilSamples: SampleCountFlags,
colorSamples: SampleCountFlags,
};
pub const FramebufferMixedSamplesCombinationNV = struct_FramebufferMixedSamplesCombinationNV;
pub const PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = ?fn (PhysicalDevice, [*c]u32, [*c]FramebufferMixedSamplesCombinationNV) callconv(.C) Result;
pub extern fn vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice: PhysicalDevice, pCombinationCount: [*c]u32, pCombinations: [*c]FramebufferMixedSamplesCombinationNV) Result;
pub const struct_PhysicalDeviceFragmentShaderInterlockFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
fragmentShaderSampleInterlock: Bool32,
fragmentShaderPixelInterlock: Bool32,
fragmentShaderShadingRateInterlock: Bool32,
};
pub const PhysicalDeviceFragmentShaderInterlockFeaturesEXT = struct_PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
pub const struct_PhysicalDeviceYcbcrImageArraysFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
ycbcrImageArrays: Bool32,
};
pub const PhysicalDeviceYcbcrImageArraysFeaturesEXT = struct_PhysicalDeviceYcbcrImageArraysFeaturesEXT;
pub const HeadlessSurfaceCreateFlagsEXT = Flags;
pub const struct_HeadlessSurfaceCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: HeadlessSurfaceCreateFlagsEXT,
};
pub const HeadlessSurfaceCreateInfoEXT = struct_HeadlessSurfaceCreateInfoEXT;
pub const PFN_vkCreateHeadlessSurfaceEXT = ?fn (Instance, [*c]const HeadlessSurfaceCreateInfoEXT, [*c]const AllocationCallbacks, [*c]SurfaceKHR) callconv(.C) Result;
pub extern fn vkCreateHeadlessSurfaceEXT(instance: Instance, pCreateInfo: [*c]const HeadlessSurfaceCreateInfoEXT, pAllocator: [*c]const AllocationCallbacks, pSurface: [*c]SurfaceKHR) Result;
pub const LINE_RASTERIZATION_MODE_DEFAULT_EXT = @enumToInt(enum_LineRasterizationModeEXT.LINE_RASTERIZATION_MODE_DEFAULT_EXT);
pub const LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = @enumToInt(enum_LineRasterizationModeEXT.LINE_RASTERIZATION_MODE_RECTANGULAR_EXT);
pub const LINE_RASTERIZATION_MODE_BRESENHAM_EXT = @enumToInt(enum_LineRasterizationModeEXT.LINE_RASTERIZATION_MODE_BRESENHAM_EXT);
pub const LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = @enumToInt(enum_LineRasterizationModeEXT.LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT);
pub const LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = @enumToInt(enum_LineRasterizationModeEXT.LINE_RASTERIZATION_MODE_MAX_ENUM_EXT);
pub const enum_LineRasterizationModeEXT = extern enum(c_int) {
LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const LineRasterizationModeEXT = enum_LineRasterizationModeEXT;
pub const struct_PhysicalDeviceLineRasterizationFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
rectangularLines: Bool32,
bresenhamLines: Bool32,
smoothLines: Bool32,
stippledRectangularLines: Bool32,
stippledBresenhamLines: Bool32,
stippledSmoothLines: Bool32,
};
pub const PhysicalDeviceLineRasterizationFeaturesEXT = struct_PhysicalDeviceLineRasterizationFeaturesEXT;
pub const struct_PhysicalDeviceLineRasterizationPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
lineSubPixelPrecisionBits: u32,
};
pub const PhysicalDeviceLineRasterizationPropertiesEXT = struct_PhysicalDeviceLineRasterizationPropertiesEXT;
pub const struct_PipelineRasterizationLineStateCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
lineRasterizationMode: LineRasterizationModeEXT,
stippledLineEnable: Bool32,
lineStippleFactor: u32,
lineStipplePattern: u16,
};
pub const PipelineRasterizationLineStateCreateInfoEXT = struct_PipelineRasterizationLineStateCreateInfoEXT;
pub const PFN_vkCmdSetLineStippleEXT = ?fn (CommandBuffer, u32, u16) callconv(.C) void;
pub extern fn vkCmdSetLineStippleEXT(commandBuffer: CommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16) void;
pub const struct_PhysicalDeviceShaderAtomicFloatFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderBufferFloat32Atomics: Bool32,
shaderBufferFloat32AtomicAdd: Bool32,
shaderBufferFloat64Atomics: Bool32,
shaderBufferFloat64AtomicAdd: Bool32,
shaderSharedFloat32Atomics: Bool32,
shaderSharedFloat32AtomicAdd: Bool32,
shaderSharedFloat64Atomics: Bool32,
shaderSharedFloat64AtomicAdd: Bool32,
shaderImageFloat32Atomics: Bool32,
shaderImageFloat32AtomicAdd: Bool32,
sparseImageFloat32Atomics: Bool32,
sparseImageFloat32AtomicAdd: Bool32,
};
pub const PhysicalDeviceShaderAtomicFloatFeaturesEXT = struct_PhysicalDeviceShaderAtomicFloatFeaturesEXT;
pub const PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
pub const PFN_vkResetQueryPoolEXT = ?fn (Device, QueryPool, u32, u32) callconv(.C) void;
pub extern fn vkResetQueryPoolEXT(device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32) void;
pub const struct_PhysicalDeviceIndexTypeUint8FeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
indexTypeUint8: Bool32,
};
pub const PhysicalDeviceIndexTypeUint8FeaturesEXT = struct_PhysicalDeviceIndexTypeUint8FeaturesEXT;
pub const struct_PhysicalDeviceExtendedDynamicStateFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
extendedDynamicState: Bool32,
};
pub const PhysicalDeviceExtendedDynamicStateFeaturesEXT = struct_PhysicalDeviceExtendedDynamicStateFeaturesEXT;
pub const PFN_vkCmdSetCullModeEXT = ?fn (CommandBuffer, CullModeFlags) callconv(.C) void;
pub const PFN_vkCmdSetFrontFaceEXT = ?fn (CommandBuffer, FrontFace) callconv(.C) void;
pub const PFN_vkCmdSetPrimitiveTopologyEXT = ?fn (CommandBuffer, PrimitiveTopology) callconv(.C) void;
pub const PFN_vkCmdSetViewportWithCountEXT = ?fn (CommandBuffer, u32, [*c]const Viewport) callconv(.C) void;
pub const PFN_vkCmdSetScissorWithCountEXT = ?fn (CommandBuffer, u32, [*c]const Rect2D) callconv(.C) void;
pub const PFN_vkCmdBindVertexBuffers2EXT = ?fn (CommandBuffer, u32, u32, [*c]const Buffer, [*c]const DeviceSize, [*c]const DeviceSize, [*c]const DeviceSize) callconv(.C) void;
pub const PFN_vkCmdSetDepthTestEnableEXT = ?fn (CommandBuffer, Bool32) callconv(.C) void;
pub const PFN_vkCmdSetDepthWriteEnableEXT = ?fn (CommandBuffer, Bool32) callconv(.C) void;
pub const PFN_vkCmdSetDepthCompareOpEXT = ?fn (CommandBuffer, CompareOp) callconv(.C) void;
pub const PFN_vkCmdSetDepthBoundsTestEnableEXT = ?fn (CommandBuffer, Bool32) callconv(.C) void;
pub const PFN_vkCmdSetStencilTestEnableEXT = ?fn (CommandBuffer, Bool32) callconv(.C) void;
pub const PFN_vkCmdSetStencilOpEXT = ?fn (CommandBuffer, StencilFaceFlags, StencilOp, StencilOp, StencilOp, CompareOp) callconv(.C) void;
pub extern fn vkCmdSetCullModeEXT(commandBuffer: CommandBuffer, cullMode: CullModeFlags) void;
pub extern fn vkCmdSetFrontFaceEXT(commandBuffer: CommandBuffer, frontFace: FrontFace) void;
pub extern fn vkCmdSetPrimitiveTopologyEXT(commandBuffer: CommandBuffer, primitiveTopology: PrimitiveTopology) void;
pub extern fn vkCmdSetViewportWithCountEXT(commandBuffer: CommandBuffer, viewportCount: u32, pViewports: [*c]const Viewport) void;
pub extern fn vkCmdSetScissorWithCountEXT(commandBuffer: CommandBuffer, scissorCount: u32, pScissors: [*c]const Rect2D) void;
pub extern fn vkCmdBindVertexBuffers2EXT(commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [*c]const Buffer, pOffsets: [*c]const DeviceSize, pSizes: [*c]const DeviceSize, pStrides: [*c]const DeviceSize) void;
pub extern fn vkCmdSetDepthTestEnableEXT(commandBuffer: CommandBuffer, depthTestEnable: Bool32) void;
pub extern fn vkCmdSetDepthWriteEnableEXT(commandBuffer: CommandBuffer, depthWriteEnable: Bool32) void;
pub extern fn vkCmdSetDepthCompareOpEXT(commandBuffer: CommandBuffer, depthCompareOp: CompareOp) void;
pub extern fn vkCmdSetDepthBoundsTestEnableEXT(commandBuffer: CommandBuffer, depthBoundsTestEnable: Bool32) void;
pub extern fn vkCmdSetStencilTestEnableEXT(commandBuffer: CommandBuffer, stencilTestEnable: Bool32) void;
pub extern fn vkCmdSetStencilOpEXT(commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, failOp: StencilOp, passOp: StencilOp, depthFailOp: StencilOp, compareOp: CompareOp) void;
pub const struct_PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
shaderDemoteToHelperInvocation: Bool32,
};
pub const PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = struct_PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
pub const struct_IndirectCommandsLayoutNV_T = opaque {};
pub const IndirectCommandsLayoutNV = ?*struct_IndirectCommandsLayoutNV_T;
pub const INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV);
pub const INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV);
pub const INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV);
pub const INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV);
pub const INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV);
pub const INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV);
pub const INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV);
pub const INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV);
pub const INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = @enumToInt(enum_IndirectCommandsTokenTypeNV.INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV);
pub const enum_IndirectCommandsTokenTypeNV = extern enum(c_int) {
INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0,
INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1,
INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2,
INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3,
INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4,
INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5,
INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6,
INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7,
INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 2147483647,
_,
};
pub const IndirectCommandsTokenTypeNV = enum_IndirectCommandsTokenTypeNV;
pub const INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = @enumToInt(enum_IndirectStateFlagBitsNV.INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV);
pub const INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = @enumToInt(enum_IndirectStateFlagBitsNV.INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV);
pub const enum_IndirectStateFlagBitsNV = extern enum(c_int) {
INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 1,
INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 2147483647,
_,
};
pub const IndirectStateFlagBitsNV = enum_IndirectStateFlagBitsNV;
pub const IndirectStateFlagsNV = Flags;
pub const INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = @enumToInt(enum_IndirectCommandsLayoutUsageFlagBitsNV.INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV);
pub const INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = @enumToInt(enum_IndirectCommandsLayoutUsageFlagBitsNV.INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV);
pub const INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = @enumToInt(enum_IndirectCommandsLayoutUsageFlagBitsNV.INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV);
pub const INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = @enumToInt(enum_IndirectCommandsLayoutUsageFlagBitsNV.INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV);
pub const enum_IndirectCommandsLayoutUsageFlagBitsNV = extern enum(c_int) {
INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 1,
INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 2,
INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 4,
INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 2147483647,
_,
};
pub const IndirectCommandsLayoutUsageFlagBitsNV = enum_IndirectCommandsLayoutUsageFlagBitsNV;
pub const IndirectCommandsLayoutUsageFlagsNV = Flags;
pub const struct_PhysicalDeviceDeviceGeneratedCommandsPropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxGraphicsShaderGroupCount: u32,
maxIndirectSequenceCount: u32,
maxIndirectCommandsTokenCount: u32,
maxIndirectCommandsStreamCount: u32,
maxIndirectCommandsTokenOffset: u32,
maxIndirectCommandsStreamStride: u32,
minSequencesCountBufferOffsetAlignment: u32,
minSequencesIndexBufferOffsetAlignment: u32,
minIndirectCommandsBufferOffsetAlignment: u32,
};
pub const PhysicalDeviceDeviceGeneratedCommandsPropertiesNV = struct_PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
pub const struct_PhysicalDeviceDeviceGeneratedCommandsFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
deviceGeneratedCommands: Bool32,
};
pub const PhysicalDeviceDeviceGeneratedCommandsFeaturesNV = struct_PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
pub const struct_GraphicsShaderGroupCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
stageCount: u32,
pStages: [*c]const PipelineShaderStageCreateInfo,
pVertexInputState: [*c]const PipelineVertexInputStateCreateInfo,
pTessellationState: [*c]const PipelineTessellationStateCreateInfo,
};
pub const GraphicsShaderGroupCreateInfoNV = struct_GraphicsShaderGroupCreateInfoNV;
pub const struct_GraphicsPipelineShaderGroupsCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
groupCount: u32,
pGroups: [*c]const GraphicsShaderGroupCreateInfoNV,
pipelineCount: u32,
pPipelines: [*c]const Pipeline,
};
pub const GraphicsPipelineShaderGroupsCreateInfoNV = struct_GraphicsPipelineShaderGroupsCreateInfoNV;
pub const struct_BindShaderGroupIndirectCommandNV = extern struct {
groupIndex: u32,
};
pub const BindShaderGroupIndirectCommandNV = struct_BindShaderGroupIndirectCommandNV;
pub const struct_BindIndexBufferIndirectCommandNV = extern struct {
bufferAddress: DeviceAddress,
size: u32,
indexType: IndexType,
};
pub const BindIndexBufferIndirectCommandNV = struct_BindIndexBufferIndirectCommandNV;
pub const struct_BindVertexBufferIndirectCommandNV = extern struct {
bufferAddress: DeviceAddress,
size: u32,
stride: u32,
};
pub const BindVertexBufferIndirectCommandNV = struct_BindVertexBufferIndirectCommandNV;
pub const struct_SetStateFlagsIndirectCommandNV = extern struct {
data: u32,
};
pub const SetStateFlagsIndirectCommandNV = struct_SetStateFlagsIndirectCommandNV;
pub const struct_IndirectCommandsStreamNV = extern struct {
buffer: Buffer,
offset: DeviceSize,
};
pub const IndirectCommandsStreamNV = struct_IndirectCommandsStreamNV;
pub const struct_IndirectCommandsLayoutTokenNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
tokenType: IndirectCommandsTokenTypeNV,
stream: u32,
offset: u32,
vertexBindingUnit: u32,
vertexDynamicStride: Bool32,
pushconstantPipelineLayout: PipelineLayout,
pushconstantShaderStageFlags: ShaderStageFlags,
pushconstantOffset: u32,
pushconstantSize: u32,
indirectStateFlags: IndirectStateFlagsNV,
indexTypeCount: u32,
pIndexTypes: [*c]const IndexType,
pIndexTypeValues: [*c]const u32,
};
pub const IndirectCommandsLayoutTokenNV = struct_IndirectCommandsLayoutTokenNV;
pub const struct_IndirectCommandsLayoutCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: IndirectCommandsLayoutUsageFlagsNV,
pipelineBindPoint: PipelineBindPoint,
tokenCount: u32,
pTokens: [*c]const IndirectCommandsLayoutTokenNV,
streamCount: u32,
pStreamStrides: [*c]const u32,
};
pub const IndirectCommandsLayoutCreateInfoNV = struct_IndirectCommandsLayoutCreateInfoNV;
pub const struct_GeneratedCommandsInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pipelineBindPoint: PipelineBindPoint,
pipeline: Pipeline,
indirectCommandsLayout: IndirectCommandsLayoutNV,
streamCount: u32,
pStreams: [*c]const IndirectCommandsStreamNV,
sequencesCount: u32,
preprocessBuffer: Buffer,
preprocessOffset: DeviceSize,
preprocessSize: DeviceSize,
sequencesCountBuffer: Buffer,
sequencesCountOffset: DeviceSize,
sequencesIndexBuffer: Buffer,
sequencesIndexOffset: DeviceSize,
};
pub const GeneratedCommandsInfoNV = struct_GeneratedCommandsInfoNV;
pub const struct_GeneratedCommandsMemoryRequirementsInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
pipelineBindPoint: PipelineBindPoint,
pipeline: Pipeline,
indirectCommandsLayout: IndirectCommandsLayoutNV,
maxSequencesCount: u32,
};
pub const GeneratedCommandsMemoryRequirementsInfoNV = struct_GeneratedCommandsMemoryRequirementsInfoNV;
pub const PFN_vkGetGeneratedCommandsMemoryRequirementsNV = ?fn (Device, [*c]const GeneratedCommandsMemoryRequirementsInfoNV, [*c]MemoryRequirements2) callconv(.C) void;
pub const PFN_vkCmdPreprocessGeneratedCommandsNV = ?fn (CommandBuffer, [*c]const GeneratedCommandsInfoNV) callconv(.C) void;
pub const PFN_vkCmdExecuteGeneratedCommandsNV = ?fn (CommandBuffer, Bool32, [*c]const GeneratedCommandsInfoNV) callconv(.C) void;
pub const PFN_vkCmdBindPipelineShaderGroupNV = ?fn (CommandBuffer, PipelineBindPoint, Pipeline, u32) callconv(.C) void;
pub const PFN_vkCreateIndirectCommandsLayoutNV = ?fn (Device, [*c]const IndirectCommandsLayoutCreateInfoNV, [*c]const AllocationCallbacks, [*c]IndirectCommandsLayoutNV) callconv(.C) Result;
pub const PFN_vkDestroyIndirectCommandsLayoutNV = ?fn (Device, IndirectCommandsLayoutNV, [*c]const AllocationCallbacks) callconv(.C) void;
pub extern fn vkGetGeneratedCommandsMemoryRequirementsNV(device: Device, pInfo: [*c]const GeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: [*c]MemoryRequirements2) void;
pub extern fn vkCmdPreprocessGeneratedCommandsNV(commandBuffer: CommandBuffer, pGeneratedCommandsInfo: [*c]const GeneratedCommandsInfoNV) void;
pub extern fn vkCmdExecuteGeneratedCommandsNV(commandBuffer: CommandBuffer, isPreprocessed: Bool32, pGeneratedCommandsInfo: [*c]const GeneratedCommandsInfoNV) void;
pub extern fn vkCmdBindPipelineShaderGroupNV(commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline, groupIndex: u32) void;
pub extern fn vkCreateIndirectCommandsLayoutNV(device: Device, pCreateInfo: [*c]const IndirectCommandsLayoutCreateInfoNV, pAllocator: [*c]const AllocationCallbacks, pIndirectCommandsLayout: [*c]IndirectCommandsLayoutNV) Result;
pub extern fn vkDestroyIndirectCommandsLayoutNV(device: Device, indirectCommandsLayout: IndirectCommandsLayoutNV, pAllocator: [*c]const AllocationCallbacks) void;
pub const struct_PhysicalDeviceTexelBufferAlignmentFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
texelBufferAlignment: Bool32,
};
pub const PhysicalDeviceTexelBufferAlignmentFeaturesEXT = struct_PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
pub const struct_PhysicalDeviceTexelBufferAlignmentPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
storageTexelBufferOffsetAlignmentBytes: DeviceSize,
storageTexelBufferOffsetSingleTexelAlignment: Bool32,
uniformTexelBufferOffsetAlignmentBytes: DeviceSize,
uniformTexelBufferOffsetSingleTexelAlignment: Bool32,
};
pub const PhysicalDeviceTexelBufferAlignmentPropertiesEXT = struct_PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
pub const struct_RenderPassTransformBeginInfoQCOM = extern struct {
sType: StructureType,
pNext: ?*c_void,
transform: SurfaceTransformFlagBitsKHR,
};
pub const RenderPassTransformBeginInfoQCOM = struct_RenderPassTransformBeginInfoQCOM;
pub const struct_CommandBufferInheritanceRenderPassTransformInfoQCOM = extern struct {
sType: StructureType,
pNext: ?*c_void,
transform: SurfaceTransformFlagBitsKHR,
renderArea: Rect2D,
};
pub const CommandBufferInheritanceRenderPassTransformInfoQCOM = struct_CommandBufferInheritanceRenderPassTransformInfoQCOM;
pub const DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = @enumToInt(enum_DeviceMemoryReportEventTypeEXT.DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT);
pub const DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = @enumToInt(enum_DeviceMemoryReportEventTypeEXT.DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT);
pub const DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = @enumToInt(enum_DeviceMemoryReportEventTypeEXT.DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT);
pub const DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = @enumToInt(enum_DeviceMemoryReportEventTypeEXT.DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT);
pub const DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = @enumToInt(enum_DeviceMemoryReportEventTypeEXT.DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT);
pub const DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = @enumToInt(enum_DeviceMemoryReportEventTypeEXT.DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT);
pub const enum_DeviceMemoryReportEventTypeEXT = extern enum(c_int) {
DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0,
DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1,
DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2,
DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3,
DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4,
DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 2147483647,
_,
};
pub const DeviceMemoryReportEventTypeEXT = enum_DeviceMemoryReportEventTypeEXT;
pub const DeviceMemoryReportFlagsEXT = Flags;
pub const struct_PhysicalDeviceDeviceMemoryReportFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
deviceMemoryReport: Bool32,
};
pub const PhysicalDeviceDeviceMemoryReportFeaturesEXT = struct_PhysicalDeviceDeviceMemoryReportFeaturesEXT;
pub const struct_DeviceMemoryReportCallbackDataEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DeviceMemoryReportFlagsEXT,
type: DeviceMemoryReportEventTypeEXT,
memoryObjectId: u64,
size: DeviceSize,
objectType: ObjectType,
objectHandle: u64,
heapIndex: u32,
};
pub const DeviceMemoryReportCallbackDataEXT = struct_DeviceMemoryReportCallbackDataEXT;
pub const PFN_vkDeviceMemoryReportCallbackEXT = ?fn ([*c]const DeviceMemoryReportCallbackDataEXT, ?*c_void) callconv(.C) void;
pub const struct_DeviceDeviceMemoryReportCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DeviceMemoryReportFlagsEXT,
pfnUserCallback: PFN_vkDeviceMemoryReportCallbackEXT,
pUserData: ?*c_void,
};
pub const DeviceDeviceMemoryReportCreateInfoEXT = struct_DeviceDeviceMemoryReportCreateInfoEXT;
pub const struct_PhysicalDeviceRobustness2FeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
robustBufferAccess2: Bool32,
robustImageAccess2: Bool32,
nullDescriptor: Bool32,
};
pub const PhysicalDeviceRobustness2FeaturesEXT = struct_PhysicalDeviceRobustness2FeaturesEXT;
pub const struct_PhysicalDeviceRobustness2PropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
robustStorageBufferAccessSizeAlignment: DeviceSize,
robustUniformBufferAccessSizeAlignment: DeviceSize,
};
pub const PhysicalDeviceRobustness2PropertiesEXT = struct_PhysicalDeviceRobustness2PropertiesEXT;
pub const struct_SamplerCustomBorderColorCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
customBorderColor: ClearColorValue,
format: Format,
};
pub const SamplerCustomBorderColorCreateInfoEXT = struct_SamplerCustomBorderColorCreateInfoEXT;
pub const struct_PhysicalDeviceCustomBorderColorPropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxCustomBorderColorSamplers: u32,
};
pub const PhysicalDeviceCustomBorderColorPropertiesEXT = struct_PhysicalDeviceCustomBorderColorPropertiesEXT;
pub const struct_PhysicalDeviceCustomBorderColorFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
customBorderColors: Bool32,
customBorderColorWithoutFormat: Bool32,
};
pub const PhysicalDeviceCustomBorderColorFeaturesEXT = struct_PhysicalDeviceCustomBorderColorFeaturesEXT;
pub const struct_PrivateDataSlotEXT_T = opaque {};
pub const PrivateDataSlotEXT = ?*struct_PrivateDataSlotEXT_T;
pub const PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM_EXT = @enumToInt(enum_PrivateDataSlotCreateFlagBitsEXT.PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM_EXT);
pub const enum_PrivateDataSlotCreateFlagBitsEXT = extern enum(c_int) {
PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM_EXT = 2147483647,
_,
};
pub const PrivateDataSlotCreateFlagBitsEXT = enum_PrivateDataSlotCreateFlagBitsEXT;
pub const PrivateDataSlotCreateFlagsEXT = Flags;
pub const struct_PhysicalDevicePrivateDataFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
privateData: Bool32,
};
pub const PhysicalDevicePrivateDataFeaturesEXT = struct_PhysicalDevicePrivateDataFeaturesEXT;
pub const struct_DevicePrivateDataCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
privateDataSlotRequestCount: u32,
};
pub const DevicePrivateDataCreateInfoEXT = struct_DevicePrivateDataCreateInfoEXT;
pub const struct_PrivateDataSlotCreateInfoEXT = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: PrivateDataSlotCreateFlagsEXT,
};
pub const PrivateDataSlotCreateInfoEXT = struct_PrivateDataSlotCreateInfoEXT;
pub const PFN_vkCreatePrivateDataSlotEXT = ?fn (Device, [*c]const PrivateDataSlotCreateInfoEXT, [*c]const AllocationCallbacks, [*c]PrivateDataSlotEXT) callconv(.C) Result;
pub const PFN_vkDestroyPrivateDataSlotEXT = ?fn (Device, PrivateDataSlotEXT, [*c]const AllocationCallbacks) callconv(.C) void;
pub const PFN_vkSetPrivateDataEXT = ?fn (Device, ObjectType, u64, PrivateDataSlotEXT, u64) callconv(.C) Result;
pub const PFN_vkGetPrivateDataEXT = ?fn (Device, ObjectType, u64, PrivateDataSlotEXT, [*c]u64) callconv(.C) void;
pub extern fn vkCreatePrivateDataSlotEXT(device: Device, pCreateInfo: [*c]const PrivateDataSlotCreateInfoEXT, pAllocator: [*c]const AllocationCallbacks, pPrivateDataSlot: [*c]PrivateDataSlotEXT) Result;
pub extern fn vkDestroyPrivateDataSlotEXT(device: Device, privateDataSlot: PrivateDataSlotEXT, pAllocator: [*c]const AllocationCallbacks) void;
pub extern fn vkSetPrivateDataEXT(device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlotEXT, data: u64) Result;
pub extern fn vkGetPrivateDataEXT(device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlotEXT, pData: [*c]u64) void;
pub const struct_PhysicalDevicePipelineCreationCacheControlFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
pipelineCreationCacheControl: Bool32,
};
pub const PhysicalDevicePipelineCreationCacheControlFeaturesEXT = struct_PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
pub const DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = @enumToInt(enum_DeviceDiagnosticsConfigFlagBitsNV.DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV);
pub const DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = @enumToInt(enum_DeviceDiagnosticsConfigFlagBitsNV.DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV);
pub const DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = @enumToInt(enum_DeviceDiagnosticsConfigFlagBitsNV.DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV);
pub const DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = @enumToInt(enum_DeviceDiagnosticsConfigFlagBitsNV.DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV);
pub const enum_DeviceDiagnosticsConfigFlagBitsNV = extern enum(c_int) {
DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 1,
DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 2,
DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 4,
DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 2147483647,
_,
};
pub const DeviceDiagnosticsConfigFlagBitsNV = enum_DeviceDiagnosticsConfigFlagBitsNV;
pub const DeviceDiagnosticsConfigFlagsNV = Flags;
pub const struct_PhysicalDeviceDiagnosticsConfigFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
diagnosticsConfig: Bool32,
};
pub const PhysicalDeviceDiagnosticsConfigFeaturesNV = struct_PhysicalDeviceDiagnosticsConfigFeaturesNV;
pub const struct_DeviceDiagnosticsConfigCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
flags: DeviceDiagnosticsConfigFlagsNV,
};
pub const DeviceDiagnosticsConfigCreateInfoNV = struct_DeviceDiagnosticsConfigCreateInfoNV;
pub const FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = @enumToInt(enum_FragmentShadingRateTypeNV.FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV);
pub const FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = @enumToInt(enum_FragmentShadingRateTypeNV.FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV);
pub const FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = @enumToInt(enum_FragmentShadingRateTypeNV.FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV);
pub const enum_FragmentShadingRateTypeNV = extern enum(c_int) {
FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0,
FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1,
FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 2147483647,
_,
};
pub const FragmentShadingRateTypeNV = enum_FragmentShadingRateTypeNV;
pub const FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV);
pub const FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV);
pub const FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV);
pub const FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV);
pub const FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV);
pub const FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV);
pub const FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV);
pub const FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV);
pub const FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV);
pub const FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV);
pub const FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV);
pub const FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV);
pub const FRAGMENT_SHADING_RATE_MAX_ENUM_NV = @enumToInt(enum_FragmentShadingRateNV.FRAGMENT_SHADING_RATE_MAX_ENUM_NV);
pub const enum_FragmentShadingRateNV = extern enum(c_int) {
FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0,
FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1,
FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4,
FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5,
FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6,
FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10,
FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11,
FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12,
FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13,
FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14,
FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15,
FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 2147483647,
_,
};
pub const FragmentShadingRateNV = enum_FragmentShadingRateNV;
pub const struct_PhysicalDeviceFragmentShadingRateEnumsFeaturesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
fragmentShadingRateEnums: Bool32,
supersampleFragmentShadingRates: Bool32,
noInvocationFragmentShadingRates: Bool32,
};
pub const PhysicalDeviceFragmentShadingRateEnumsFeaturesNV = struct_PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
pub const struct_PhysicalDeviceFragmentShadingRateEnumsPropertiesNV = extern struct {
sType: StructureType,
pNext: ?*c_void,
maxFragmentShadingRateInvocationCount: SampleCountFlagBits,
};
pub const PhysicalDeviceFragmentShadingRateEnumsPropertiesNV = struct_PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
pub const struct_PipelineFragmentShadingRateEnumStateCreateInfoNV = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
shadingRateType: FragmentShadingRateTypeNV,
shadingRate: FragmentShadingRateNV,
combinerOps: [2]FragmentShadingRateCombinerOpKHR,
};
pub const PipelineFragmentShadingRateEnumStateCreateInfoNV = struct_PipelineFragmentShadingRateEnumStateCreateInfoNV;
pub const PFN_vkCmdSetFragmentShadingRateEnumNV = ?fn (CommandBuffer, FragmentShadingRateNV, [*c]const FragmentShadingRateCombinerOpKHR) callconv(.C) void;
pub extern fn vkCmdSetFragmentShadingRateEnumNV(commandBuffer: CommandBuffer, shadingRate: FragmentShadingRateNV, combinerOps: [*c]const FragmentShadingRateCombinerOpKHR) void;
pub const struct_PhysicalDeviceFragmentDensityMap2FeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
fragmentDensityMapDeferred: Bool32,
};
pub const PhysicalDeviceFragmentDensityMap2FeaturesEXT = struct_PhysicalDeviceFragmentDensityMap2FeaturesEXT;
pub const struct_PhysicalDeviceFragmentDensityMap2PropertiesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
subsampledLoads: Bool32,
subsampledCoarseReconstructionEarlyAccess: Bool32,
maxSubsampledArrayLayers: u32,
maxDescriptorSetSubsampledSamplers: u32,
};
pub const PhysicalDeviceFragmentDensityMap2PropertiesEXT = struct_PhysicalDeviceFragmentDensityMap2PropertiesEXT;
pub const struct_CopyCommandTransformInfoQCOM = extern struct {
sType: StructureType,
pNext: ?*const c_void = null,
transform: SurfaceTransformFlagBitsKHR,
};
pub const CopyCommandTransformInfoQCOM = struct_CopyCommandTransformInfoQCOM;
pub const struct_PhysicalDeviceImageRobustnessFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
robustImageAccess: Bool32,
};
pub const PhysicalDeviceImageRobustnessFeaturesEXT = struct_PhysicalDeviceImageRobustnessFeaturesEXT;
pub const struct_PhysicalDevice4444FormatsFeaturesEXT = extern struct {
sType: StructureType,
pNext: ?*c_void,
formatA4R4G4B4: Bool32,
formatA4B4G4R4: Bool32,
};
pub const PhysicalDevice4444FormatsFeaturesEXT = struct_PhysicalDevice4444FormatsFeaturesEXT;
pub const __INTMAX_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // (no file):62:9
pub const __UINTMAX_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_unsigned"); // (no file):66:9
pub const __PTRDIFF_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // (no file):73:9
pub const __INTPTR_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // (no file):77:9
pub const __SIZE_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_unsigned"); // (no file):81:9
pub const __UINTPTR_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_unsigned"); // (no file):96:9
pub const __INT64_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // (no file):159:9
pub const __UINT64_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_unsigned"); // (no file):187:9
pub const __INT_LEAST64_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // (no file):225:9
pub const __UINT_LEAST64_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_unsigned"); // (no file):229:9
pub const __INT_FAST64_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // (no file):265:9
pub const __UINT_FAST64_TYPE__ = @compileError("unable to translate C expr: unexpected token .Keyword_unsigned"); // (no file):269:9
pub const __GLIBC_USE = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/features.h:179:9
pub const __NTH = @compileError("unable to translate C expr: unexpected token .Identifier"); // /usr/include/sys/cdefs.h:57:11
pub const __NTHNL = @compileError("unable to translate C expr: unexpected token .Identifier"); // /usr/include/sys/cdefs.h:58:11
pub const __CONCAT = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/sys/cdefs.h:105:9
pub const __STRING = @compileError("unable to translate C expr: unexpected token .Hash"); // /usr/include/sys/cdefs.h:106:9
pub const __ptr_t = @compileError("unable to translate C expr: unexpected token .Nl"); // /usr/include/sys/cdefs.h:109:9
pub const __warndecl = @compileError("unable to translate C expr: unexpected token .Keyword_extern"); // /usr/include/sys/cdefs.h:133:10
pub const __warnattr = @compileError("unable to translate C expr: unexpected token .Nl"); // /usr/include/sys/cdefs.h:134:10
pub const __errordecl = @compileError("unable to translate C expr: unexpected token .Keyword_extern"); // /usr/include/sys/cdefs.h:135:10
pub const __flexarr = @compileError("unable to translate C expr: unexpected token .LBracket"); // /usr/include/sys/cdefs.h:143:10
pub const __REDIRECT = @compileError("unable to translate C expr: unexpected token .Hash"); // /usr/include/sys/cdefs.h:174:10
pub const __REDIRECT_NTH = @compileError("unable to translate C expr: unexpected token .Hash"); // /usr/include/sys/cdefs.h:181:11
pub const __REDIRECT_NTHNL = @compileError("unable to translate C expr: unexpected token .Hash"); // /usr/include/sys/cdefs.h:183:11
pub const __ASMNAME2 = @compileError("unable to translate C expr: unexpected token .Identifier"); // /usr/include/sys/cdefs.h:187:10
pub const __attribute_alloc_size__ = @compileError("unable to translate C expr: unexpected token .Nl"); // /usr/include/sys/cdefs.h:219:10
pub const __extern_inline = @compileError("unable to translate C expr: unexpected token .Keyword_extern"); // /usr/include/sys/cdefs.h:346:11
pub const __extern_always_inline = @compileError("unable to translate C expr: unexpected token .Keyword_extern"); // /usr/include/sys/cdefs.h:347:11
pub const __attribute_copy__ = @compileError("unable to translate C expr: unexpected token .Nl"); // /usr/include/sys/cdefs.h:441:10
pub const __LDBL_REDIR2_DECL = @compileError("unable to translate C expr: unexpected token .Nl"); // /usr/include/sys/cdefs.h:512:10
pub const __LDBL_REDIR_DECL = @compileError("unable to translate C expr: unexpected token .Nl"); // /usr/include/sys/cdefs.h:513:10
pub const __glibc_macro_warning1 = @compileError("unable to translate C expr: unexpected token .Hash"); // /usr/include/sys/cdefs.h:527:10
pub const __attr_access = @compileError("unable to translate C expr: unexpected token .Nl"); // /usr/include/sys/cdefs.h:559:11
pub const __S16_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:109:9
pub const __U16_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:110:9
pub const __SLONGWORD_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:113:9
pub const __ULONGWORD_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:114:9
pub const __SQUAD_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:128:10
pub const __UQUAD_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:129:10
pub const __SWORD_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:130:10
pub const __UWORD_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:131:10
pub const __S64_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:134:10
pub const __U64_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_int"); // /usr/include/bits/types.h:135:10
pub const __STD_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_typedef"); // /usr/include/bits/types.h:137:10
pub const __TIMER_T_TYPE = @compileError("unable to translate C expr: unexpected token .Nl"); // /usr/include/bits/typesizes.h:71:9
pub const __FSID_T_TYPE = @compileError("unable to translate C expr: unexpected token .Keyword_struct"); // /usr/include/bits/typesizes.h:73:9
pub const __INT64_C = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/stdint.h:106:11
pub const __UINT64_C = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/stdint.h:107:11
pub const INT64_C = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/stdint.h:252:11
pub const UINT32_C = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/stdint.h:260:10
pub const UINT64_C = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/stdint.h:262:11
pub const INTMAX_C = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/stdint.h:269:11
pub const UINTMAX_C = @compileError("unable to translate C expr: unexpected token .HashHash"); // /usr/include/stdint.h:270:11
pub const DEFINE_HANDLE = @compileError("unable to translate C expr: unexpected token .Keyword_typedef"); // /usr/include/vulkan/vulkan_core.h:25:9
pub const DEFINE_NON_DISPATCHABLE_HANDLE = @compileError("unable to translate C expr: unexpected token .Keyword_typedef"); // /usr/include/vulkan/vulkan_core.h:30:17
pub const __llvm__ = 1;
pub const __clang__ = 1;
pub const __clang_major__ = 11;
pub const __clang_minor__ = 0;
pub const __clang_patchlevel__ = 0;
pub const __clang_version__ = "11.0.0 ";
pub const __GNUC__ = 4;
pub const __GNUC_MINOR__ = 2;
pub const __GNUC_PATCHLEVEL__ = 1;
pub const __GXX_ABI_VERSION = 1002;
pub const __ATOMIC_RELAXED = 0;
pub const __ATOMIC_CONSUME = 1;
pub const __ATOMIC_ACQUIRE = 2;
pub const __ATOMIC_RELEASE = 3;
pub const __ATOMIC_ACQ_REL = 4;
pub const __ATOMIC_SEQ_CST = 5;
pub const __OPENCL_MEMORY_SCOPE_WORK_ITEM = 0;
pub const __OPENCL_MEMORY_SCOPE_WORK_GROUP = 1;
pub const __OPENCL_MEMORY_SCOPE_DEVICE = 2;
pub const __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES = 3;
pub const __OPENCL_MEMORY_SCOPE_SUB_GROUP = 4;
pub const __PRAGMA_REDEFINE_EXTNAME = 1;
pub const __VERSION__ = "Clang 11.0.0";
pub const __OBJC_BOOL_IS_BOOL = 0;
pub const __CONSTANT_CFSTRINGS__ = 1;
pub const __OPTIMIZE__ = 1;
pub const __ORDER_LITTLE_ENDIAN__ = 1234;
pub const __ORDER_BIG_ENDIAN__ = 4321;
pub const __ORDER_PDP_ENDIAN__ = 3412;
pub const __BYTE_ORDER__ = __ORDER_LITTLE_ENDIAN__;
pub const __LITTLE_ENDIAN__ = 1;
pub const _LP64 = 1;
pub const __LP64__ = 1;
pub const __CHAR_BIT__ = 8;
pub const __SCHAR_MAX__ = 127;
pub const __SHRT_MAX__ = 32767;
pub const __INT_MAX__ = 2147483647;
pub const __LONG_MAX__ = @as(c_long, 9223372036854775807);
pub const __LONG_LONG_MAX__ = @as(c_longlong, 9223372036854775807);
pub const __WCHAR_MAX__ = 2147483647;
pub const __WINT_MAX__ = @as(c_uint, 4294967295);
pub const __INTMAX_MAX__ = @as(c_long, 9223372036854775807);
pub const __SIZE_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __UINTMAX_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __PTRDIFF_MAX__ = @as(c_long, 9223372036854775807);
pub const __INTPTR_MAX__ = @as(c_long, 9223372036854775807);
pub const __UINTPTR_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __SIZEOF_DOUBLE__ = 8;
pub const __SIZEOF_FLOAT__ = 4;
pub const __SIZEOF_INT__ = 4;
pub const __SIZEOF_LONG__ = 8;
pub const __SIZEOF_LONG_DOUBLE__ = 16;
pub const __SIZEOF_LONG_LONG__ = 8;
pub const __SIZEOF_POINTER__ = 8;
pub const __SIZEOF_SHORT__ = 2;
pub const __SIZEOF_PTRDIFF_T__ = 8;
pub const __SIZEOF_SIZE_T__ = 8;
pub const __SIZEOF_WCHAR_T__ = 4;
pub const __SIZEOF_WINT_T__ = 4;
pub const __SIZEOF_INT128__ = 16;
pub const __INTMAX_FMTd__ = "ld";
pub const __INTMAX_FMTi__ = "li";
pub const __INTMAX_C_SUFFIX__ = L;
pub const __UINTMAX_FMTo__ = "lo";
pub const __UINTMAX_FMTu__ = "lu";
pub const __UINTMAX_FMTx__ = "lx";
pub const __UINTMAX_FMTX__ = "lX";
pub const __UINTMAX_C_SUFFIX__ = UL;
pub const __INTMAX_WIDTH__ = 64;
pub const __PTRDIFF_FMTd__ = "ld";
pub const __PTRDIFF_FMTi__ = "li";
pub const __PTRDIFF_WIDTH__ = 64;
pub const __INTPTR_FMTd__ = "ld";
pub const __INTPTR_FMTi__ = "li";
pub const __INTPTR_WIDTH__ = 64;
pub const __SIZE_FMTo__ = "lo";
pub const __SIZE_FMTu__ = "lu";
pub const __SIZE_FMTx__ = "lx";
pub const __SIZE_FMTX__ = "lX";
pub const __SIZE_WIDTH__ = 64;
pub const __WCHAR_TYPE__ = c_int;
pub const __WCHAR_WIDTH__ = 32;
pub const __WINT_TYPE__ = c_uint;
pub const __WINT_WIDTH__ = 32;
pub const __SIG_ATOMIC_WIDTH__ = 32;
pub const __SIG_ATOMIC_MAX__ = 2147483647;
pub const __CHAR16_TYPE__ = c_ushort;
pub const __CHAR32_TYPE__ = c_uint;
pub const __UINTMAX_WIDTH__ = 64;
pub const __UINTPTR_FMTo__ = "lo";
pub const __UINTPTR_FMTu__ = "lu";
pub const __UINTPTR_FMTx__ = "lx";
pub const __UINTPTR_FMTX__ = "lX";
pub const __UINTPTR_WIDTH__ = 64;
pub const __FLT_DENORM_MIN__ = @as(f32, 1.40129846e-45);
pub const __FLT_HAS_DENORM__ = 1;
pub const __FLT_DIG__ = 6;
pub const __FLT_DECIMAL_DIG__ = 9;
pub const __FLT_EPSILON__ = @as(f32, 1.19209290e-7);
pub const __FLT_HAS_INFINITY__ = 1;
pub const __FLT_HAS_QUIET_NAN__ = 1;
pub const __FLT_MANT_DIG__ = 24;
pub const __FLT_MAX_10_EXP__ = 38;
pub const __FLT_MAX_EXP__ = 128;
pub const __FLT_MAX__ = @as(f32, 3.40282347e+38);
pub const __FLT_MIN_10_EXP__ = -37;
pub const __FLT_MIN_EXP__ = -125;
pub const __FLT_MIN__ = @as(f32, 1.17549435e-38);
pub const __DBL_DENORM_MIN__ = 4.9406564584124654e-324;
pub const __DBL_HAS_DENORM__ = 1;
pub const __DBL_DIG__ = 15;
pub const __DBL_DECIMAL_DIG__ = 17;
pub const __DBL_EPSILON__ = 2.2204460492503131e-16;
pub const __DBL_HAS_INFINITY__ = 1;
pub const __DBL_HAS_QUIET_NAN__ = 1;
pub const __DBL_MANT_DIG__ = 53;
pub const __DBL_MAX_10_EXP__ = 308;
pub const __DBL_MAX_EXP__ = 1024;
pub const __DBL_MAX__ = 1.7976931348623157e+308;
pub const __DBL_MIN_10_EXP__ = -307;
pub const __DBL_MIN_EXP__ = -1021;
pub const __DBL_MIN__ = 2.2250738585072014e-308;
pub const __LDBL_DENORM_MIN__ = @as(c_longdouble, 3.64519953188247460253e-4951);
pub const __LDBL_HAS_DENORM__ = 1;
pub const __LDBL_DIG__ = 18;
pub const __LDBL_DECIMAL_DIG__ = 21;
pub const __LDBL_EPSILON__ = @as(c_longdouble, 1.08420217248550443401e-19);
pub const __LDBL_HAS_INFINITY__ = 1;
pub const __LDBL_HAS_QUIET_NAN__ = 1;
pub const __LDBL_MANT_DIG__ = 64;
pub const __LDBL_MAX_10_EXP__ = 4932;
pub const __LDBL_MAX_EXP__ = 16384;
pub const __LDBL_MAX__ = @as(c_longdouble, 1.18973149535723176502e+4932);
pub const __LDBL_MIN_10_EXP__ = -4931;
pub const __LDBL_MIN_EXP__ = -16381;
pub const __LDBL_MIN__ = @as(c_longdouble, 3.36210314311209350626e-4932);
pub const __POINTER_WIDTH__ = 64;
pub const __BIGGEST_ALIGNMENT__ = 16;
pub const __WINT_UNSIGNED__ = 1;
pub const __INT8_TYPE__ = i8;
pub const __INT8_FMTd__ = "hhd";
pub const __INT8_FMTi__ = "hhi";
pub const __INT16_TYPE__ = c_short;
pub const __INT16_FMTd__ = "hd";
pub const __INT16_FMTi__ = "hi";
pub const __INT32_TYPE__ = c_int;
pub const __INT32_FMTd__ = "d";
pub const __INT32_FMTi__ = "i";
pub const __INT64_FMTd__ = "ld";
pub const __INT64_FMTi__ = "li";
pub const __INT64_C_SUFFIX__ = L;
pub const __UINT8_TYPE__ = u8;
pub const __UINT8_FMTo__ = "hho";
pub const __UINT8_FMTu__ = "hhu";
pub const __UINT8_FMTx__ = "hhx";
pub const __UINT8_FMTX__ = "hhX";
pub const __UINT8_MAX__ = 255;
pub const __INT8_MAX__ = 127;
pub const __UINT16_TYPE__ = c_ushort;
pub const __UINT16_FMTo__ = "ho";
pub const __UINT16_FMTu__ = "hu";
pub const __UINT16_FMTx__ = "hx";
pub const __UINT16_FMTX__ = "hX";
pub const __UINT16_MAX__ = 65535;
pub const __INT16_MAX__ = 32767;
pub const __UINT32_TYPE__ = c_uint;
pub const __UINT32_FMTo__ = "o";
pub const __UINT32_FMTu__ = "u";
pub const __UINT32_FMTx__ = "x";
pub const __UINT32_FMTX__ = "X";
pub const __UINT32_C_SUFFIX__ = U;
pub const __UINT32_MAX__ = @as(c_uint, 4294967295);
pub const __INT32_MAX__ = 2147483647;
pub const __UINT64_FMTo__ = "lo";
pub const __UINT64_FMTu__ = "lu";
pub const __UINT64_FMTx__ = "lx";
pub const __UINT64_FMTX__ = "lX";
pub const __UINT64_C_SUFFIX__ = UL;
pub const __UINT64_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __INT64_MAX__ = @as(c_long, 9223372036854775807);
pub const __INT_LEAST8_TYPE__ = i8;
pub const __INT_LEAST8_MAX__ = 127;
pub const __INT_LEAST8_FMTd__ = "hhd";
pub const __INT_LEAST8_FMTi__ = "hhi";
pub const __UINT_LEAST8_TYPE__ = u8;
pub const __UINT_LEAST8_MAX__ = 255;
pub const __UINT_LEAST8_FMTo__ = "hho";
pub const __UINT_LEAST8_FMTu__ = "hhu";
pub const __UINT_LEAST8_FMTx__ = "hhx";
pub const __UINT_LEAST8_FMTX__ = "hhX";
pub const __INT_LEAST16_TYPE__ = c_short;
pub const __INT_LEAST16_MAX__ = 32767;
pub const __INT_LEAST16_FMTd__ = "hd";
pub const __INT_LEAST16_FMTi__ = "hi";
pub const __UINT_LEAST16_TYPE__ = c_ushort;
pub const __UINT_LEAST16_MAX__ = 65535;
pub const __UINT_LEAST16_FMTo__ = "ho";
pub const __UINT_LEAST16_FMTu__ = "hu";
pub const __UINT_LEAST16_FMTx__ = "hx";
pub const __UINT_LEAST16_FMTX__ = "hX";
pub const __INT_LEAST32_TYPE__ = c_int;
pub const __INT_LEAST32_MAX__ = 2147483647;
pub const __INT_LEAST32_FMTd__ = "d";
pub const __INT_LEAST32_FMTi__ = "i";
pub const __UINT_LEAST32_TYPE__ = c_uint;
pub const __UINT_LEAST32_MAX__ = @as(c_uint, 4294967295);
pub const __UINT_LEAST32_FMTo__ = "o";
pub const __UINT_LEAST32_FMTu__ = "u";
pub const __UINT_LEAST32_FMTx__ = "x";
pub const __UINT_LEAST32_FMTX__ = "X";
pub const __INT_LEAST64_MAX__ = @as(c_long, 9223372036854775807);
pub const __INT_LEAST64_FMTd__ = "ld";
pub const __INT_LEAST64_FMTi__ = "li";
pub const __UINT_LEAST64_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __UINT_LEAST64_FMTo__ = "lo";
pub const __UINT_LEAST64_FMTu__ = "lu";
pub const __UINT_LEAST64_FMTx__ = "lx";
pub const __UINT_LEAST64_FMTX__ = "lX";
pub const __INT_FAST8_TYPE__ = i8;
pub const __INT_FAST8_MAX__ = 127;
pub const __INT_FAST8_FMTd__ = "hhd";
pub const __INT_FAST8_FMTi__ = "hhi";
pub const __UINT_FAST8_TYPE__ = u8;
pub const __UINT_FAST8_MAX__ = 255;
pub const __UINT_FAST8_FMTo__ = "hho";
pub const __UINT_FAST8_FMTu__ = "hhu";
pub const __UINT_FAST8_FMTx__ = "hhx";
pub const __UINT_FAST8_FMTX__ = "hhX";
pub const __INT_FAST16_TYPE__ = c_short;
pub const __INT_FAST16_MAX__ = 32767;
pub const __INT_FAST16_FMTd__ = "hd";
pub const __INT_FAST16_FMTi__ = "hi";
pub const __UINT_FAST16_TYPE__ = c_ushort;
pub const __UINT_FAST16_MAX__ = 65535;
pub const __UINT_FAST16_FMTo__ = "ho";
pub const __UINT_FAST16_FMTu__ = "hu";
pub const __UINT_FAST16_FMTx__ = "hx";
pub const __UINT_FAST16_FMTX__ = "hX";
pub const __INT_FAST32_TYPE__ = c_int;
pub const __INT_FAST32_MAX__ = 2147483647;
pub const __INT_FAST32_FMTd__ = "d";
pub const __INT_FAST32_FMTi__ = "i";
pub const __UINT_FAST32_TYPE__ = c_uint;
pub const __UINT_FAST32_MAX__ = @as(c_uint, 4294967295);
pub const __UINT_FAST32_FMTo__ = "o";
pub const __UINT_FAST32_FMTu__ = "u";
pub const __UINT_FAST32_FMTx__ = "x";
pub const __UINT_FAST32_FMTX__ = "X";
pub const __INT_FAST64_MAX__ = @as(c_long, 9223372036854775807);
pub const __INT_FAST64_FMTd__ = "ld";
pub const __INT_FAST64_FMTi__ = "li";
pub const __UINT_FAST64_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __UINT_FAST64_FMTo__ = "lo";
pub const __UINT_FAST64_FMTu__ = "lu";
pub const __UINT_FAST64_FMTx__ = "lx";
pub const __UINT_FAST64_FMTX__ = "lX";
pub const __FINITE_MATH_ONLY__ = 0;
pub const __GNUC_STDC_INLINE__ = 1;
pub const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = 1;
pub const __CLANG_ATOMIC_BOOL_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_CHAR_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_CHAR16_T_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_CHAR32_T_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_WCHAR_T_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_SHORT_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_INT_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_LONG_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_LLONG_LOCK_FREE = 2;
pub const __CLANG_ATOMIC_POINTER_LOCK_FREE = 2;
pub const __GCC_ATOMIC_BOOL_LOCK_FREE = 2;
pub const __GCC_ATOMIC_CHAR_LOCK_FREE = 2;
pub const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = 2;
pub const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = 2;
pub const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = 2;
pub const __GCC_ATOMIC_SHORT_LOCK_FREE = 2;
pub const __GCC_ATOMIC_INT_LOCK_FREE = 2;
pub const __GCC_ATOMIC_LONG_LOCK_FREE = 2;
pub const __GCC_ATOMIC_LLONG_LOCK_FREE = 2;
pub const __GCC_ATOMIC_POINTER_LOCK_FREE = 2;
pub const __PIC__ = 2;
pub const __pic__ = 2;
pub const __PIE__ = 2;
pub const __pie__ = 2;
pub const __FLT_EVAL_METHOD__ = 0;
pub const __FLT_RADIX__ = 2;
pub const __DECIMAL_DIG__ = __LDBL_DECIMAL_DIG__;
pub const __GCC_ASM_FLAG_OUTPUTS__ = 1;
pub const __code_model_small__ = 1;
pub const __amd64__ = 1;
pub const __amd64 = 1;
pub const __x86_64 = 1;
pub const __x86_64__ = 1;
pub const __SEG_GS = 1;
pub const __SEG_FS = 1;
pub const __seg_gs = __attribute__(address_space(256));
pub const __seg_fs = __attribute__(address_space(257));
pub const __znver1 = 1;
pub const __znver1__ = 1;
pub const __tune_znver1__ = 1;
pub const __NO_MATH_INLINES = 1;
pub const __AES__ = 1;
pub const __PCLMUL__ = 1;
pub const __LZCNT__ = 1;
pub const __RDRND__ = 1;
pub const __FSGSBASE__ = 1;
pub const __BMI__ = 1;
pub const __BMI2__ = 1;
pub const __POPCNT__ = 1;
pub const __PRFCHW__ = 1;
pub const __RDSEED__ = 1;
pub const __ADX__ = 1;
pub const __MWAITX__ = 1;
pub const __MOVBE__ = 1;
pub const __SSE4A__ = 1;
pub const __FMA__ = 1;
pub const __F16C__ = 1;
pub const __SHA__ = 1;
pub const __FXSR__ = 1;
pub const __XSAVE__ = 1;
pub const __XSAVEOPT__ = 1;
pub const __XSAVEC__ = 1;
pub const __XSAVES__ = 1;
pub const __CLFLUSHOPT__ = 1;
pub const __CLZERO__ = 1;
pub const __AVX2__ = 1;
pub const __AVX__ = 1;
pub const __SSE4_2__ = 1;
pub const __SSE4_1__ = 1;
pub const __SSSE3__ = 1;
pub const __SSE3__ = 1;
pub const __SSE2__ = 1;
pub const __SSE2_MATH__ = 1;
pub const __SSE__ = 1;
pub const __SSE_MATH__ = 1;
pub const __MMX__ = 1;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = 1;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = 1;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = 1;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = 1;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 = 1;
pub const __SIZEOF_FLOAT128__ = 16;
pub const unix = 1;
pub const __unix = 1;
pub const __unix__ = 1;
pub const linux = 1;
pub const __linux = 1;
pub const __linux__ = 1;
pub const __ELF__ = 1;
pub const __gnu_linux__ = 1;
pub const __FLOAT128__ = 1;
pub const __STDC__ = 1;
pub const __STDC_HOSTED__ = 1;
pub const __STDC_VERSION__ = @as(c_long, 201710);
pub const __STDC_UTF_16__ = 1;
pub const __STDC_UTF_32__ = 1;
pub const _DEBUG = 1;
pub const VULKAN_H_ = 1;
pub const NULL = (@import("std").meta.cast(?*c_void, 0));
pub inline fn offsetof(t: anytype, d: anytype) @TypeOf(__builtin_offsetof(t, d)) {
return __builtin_offsetof(t, d);
}
pub const _STDINT_H = 1;
pub const _FEATURES_H = 1;
pub inline fn __GNUC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GNUC__ << 16) + __GNUC_MINOR__) >= ((maj << 16) + min)) {
return ((__GNUC__ << 16) + __GNUC_MINOR__) >= ((maj << 16) + min);
}
pub inline fn __glibc_clang_prereq(maj: anytype, min: anytype) @TypeOf(((__clang_major__ << 16) + __clang_minor__) >= ((maj << 16) + min)) {
return ((__clang_major__ << 16) + __clang_minor__) >= ((maj << 16) + min);
}
pub const _DEFAULT_SOURCE = 1;
pub const __GLIBC_USE_ISOC2X = 0;
pub const __USE_ISOC11 = 1;
pub const __USE_ISOC99 = 1;
pub const __USE_ISOC95 = 1;
pub const __USE_POSIX_IMPLICITLY = 1;
pub const _POSIX_SOURCE = 1;
pub const _POSIX_C_SOURCE = @as(c_long, 200809);
pub const __USE_POSIX = 1;
pub const __USE_POSIX2 = 1;
pub const __USE_POSIX199309 = 1;
pub const __USE_POSIX199506 = 1;
pub const __USE_XOPEN2K = 1;
pub const __USE_XOPEN2K8 = 1;
pub const _ATFILE_SOURCE = 1;
pub const __USE_MISC = 1;
pub const __USE_ATFILE = 1;
pub const __USE_FORTIFY_LEVEL = 0;
pub const __GLIBC_USE_DEPRECATED_GETS = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF = 0;
pub const _STDC_PREDEF_H = 1;
pub const __STDC_IEC_559__ = 1;
pub const __STDC_IEC_559_COMPLEX__ = 1;
pub const __STDC_ISO_10646__ = @as(c_long, 201706);
pub const __GNU_LIBRARY__ = 6;
pub const __GLIBC__ = 2;
pub const __GLIBC_MINOR__ = 32;
pub inline fn __GLIBC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GLIBC__ << 16) + __GLIBC_MINOR__) >= ((maj << 16) + min)) {
return ((__GLIBC__ << 16) + __GLIBC_MINOR__) >= ((maj << 16) + min);
}
pub const _SYS_CDEFS_H = 1;
pub const __THROW = __attribute__(__nothrow__ ++ __LEAF);
pub const __THROWNL = __attribute__(__nothrow__);
pub inline fn __glibc_clang_has_extension(ext: anytype) @TypeOf(__has_extension(ext)) {
return __has_extension(ext);
}
pub inline fn __P(args: anytype) @TypeOf(args) {
return args;
}
pub inline fn __PMT(args: anytype) @TypeOf(args) {
return args;
}
pub inline fn __bos(ptr: anytype) @TypeOf(__builtin_object_size(ptr, __USE_FORTIFY_LEVEL > 1)) {
return __builtin_object_size(ptr, __USE_FORTIFY_LEVEL > 1);
}
pub inline fn __bos0(ptr: anytype) @TypeOf(__builtin_object_size(ptr, 0)) {
return __builtin_object_size(ptr, 0);
}
pub const __glibc_c99_flexarr_available = 1;
pub inline fn __ASMNAME(cname: anytype) @TypeOf(__ASMNAME2(__USER_LABEL_PREFIX__, cname)) {
return __ASMNAME2(__USER_LABEL_PREFIX__, cname);
}
pub const __attribute_malloc__ = __attribute__(__malloc__);
pub const __attribute_pure__ = __attribute__(__pure__);
pub const __attribute_const__ = __attribute__(__const__);
pub const __attribute_used__ = __attribute__(__used__);
pub const __attribute_noinline__ = __attribute__(__noinline__);
pub const __attribute_deprecated__ = __attribute__(__deprecated__);
pub inline fn __attribute_deprecated_msg__(msg: anytype) @TypeOf(__attribute__(__deprecated__(msg))) {
return __attribute__(__deprecated__(msg));
}
pub inline fn __attribute_format_arg__(x: anytype) @TypeOf(__attribute__(__format_arg__(x))) {
return __attribute__(__format_arg__(x));
}
pub inline fn __attribute_format_strfmon__(a: anytype, b: anytype) @TypeOf(__attribute__(__format__(__strfmon__, a, b))) {
return __attribute__(__format__(__strfmon__, a, b));
}
pub inline fn __nonnull(params: anytype) @TypeOf(__attribute__(__nonnull__ ++ params)) {
return __attribute__(__nonnull__ ++ params);
}
pub const __attribute_warn_unused_result__ = __attribute__(__warn_unused_result__);
pub const __always_inline = __inline ++ __attribute__(__always_inline__);
pub const __fortify_function = __extern_always_inline ++ __attribute_artificial__;
pub const __restrict_arr = __restrict;
pub inline fn __glibc_unlikely(cond: anytype) @TypeOf(__builtin_expect(cond, 0)) {
return __builtin_expect(cond, 0);
}
pub inline fn __glibc_likely(cond: anytype) @TypeOf(__builtin_expect(cond, 1)) {
return __builtin_expect(cond, 1);
}
pub inline fn __glibc_has_attribute(attr: anytype) @TypeOf(__has_attribute(attr)) {
return __has_attribute(attr);
}
pub const __WORDSIZE = 64;
pub const __WORDSIZE_TIME64_COMPAT32 = 1;
pub const __SYSCALL_WORDSIZE = 64;
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI = 0;
pub inline fn __LDBL_REDIR1(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto) {
return name ++ proto;
}
pub inline fn __LDBL_REDIR(name: anytype, proto: anytype) @TypeOf(name ++ proto) {
return name ++ proto;
}
pub inline fn __LDBL_REDIR1_NTH(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto ++ __THROW) {
return name ++ proto ++ __THROW;
}
pub inline fn __LDBL_REDIR_NTH(name: anytype, proto: anytype) @TypeOf(name ++ proto ++ __THROW) {
return name ++ proto ++ __THROW;
}
pub inline fn __REDIRECT_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT(name, proto, alias)) {
return __REDIRECT(name, proto, alias);
}
pub inline fn __REDIRECT_NTH_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT_NTH(name, proto, alias)) {
return __REDIRECT_NTH(name, proto, alias);
}
pub inline fn __glibc_macro_warning(message: anytype) @TypeOf(__glibc_macro_warning1(GCC ++ warning ++ message)) {
return __glibc_macro_warning1(GCC ++ warning ++ message);
}
pub const __HAVE_GENERIC_SELECTION = 1;
pub const __USE_EXTERN_INLINES = 1;
pub const __GLIBC_USE_LIB_EXT2 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT = 0;
pub const _BITS_TYPES_H = 1;
pub const __TIMESIZE = __WORDSIZE;
pub const __S32_TYPE = c_int;
pub const __U32_TYPE = c_uint;
pub const __SLONG32_TYPE = c_int;
pub const __ULONG32_TYPE = c_uint;
pub const _BITS_TYPESIZES_H = 1;
pub const __SYSCALL_SLONG_TYPE = __SLONGWORD_TYPE;
pub const __SYSCALL_ULONG_TYPE = __ULONGWORD_TYPE;
pub const __DEV_T_TYPE = __UQUAD_TYPE;
pub const __UID_T_TYPE = __U32_TYPE;
pub const __GID_T_TYPE = __U32_TYPE;
pub const __INO_T_TYPE = __SYSCALL_ULONG_TYPE;
pub const __INO64_T_TYPE = __UQUAD_TYPE;
pub const __MODE_T_TYPE = __U32_TYPE;
pub const __NLINK_T_TYPE = __SYSCALL_ULONG_TYPE;
pub const __FSWORD_T_TYPE = __SYSCALL_SLONG_TYPE;
pub const __OFF_T_TYPE = __SYSCALL_SLONG_TYPE;
pub const __OFF64_T_TYPE = __SQUAD_TYPE;
pub const __PID_T_TYPE = __S32_TYPE;
pub const __RLIM_T_TYPE = __SYSCALL_ULONG_TYPE;
pub const __RLIM64_T_TYPE = __UQUAD_TYPE;
pub const __BLKCNT_T_TYPE = __SYSCALL_SLONG_TYPE;
pub const __BLKCNT64_T_TYPE = __SQUAD_TYPE;
pub const __FSBLKCNT_T_TYPE = __SYSCALL_ULONG_TYPE;
pub const __FSBLKCNT64_T_TYPE = __UQUAD_TYPE;
pub const __FSFILCNT_T_TYPE = __SYSCALL_ULONG_TYPE;
pub const __FSFILCNT64_T_TYPE = __UQUAD_TYPE;
pub const __ID_T_TYPE = __U32_TYPE;
pub const __CLOCK_T_TYPE = __SYSCALL_SLONG_TYPE;
pub const __TIME_T_TYPE = __SYSCALL_SLONG_TYPE;
pub const __USECONDS_T_TYPE = __U32_TYPE;
pub const __SUSECONDS_T_TYPE = __SYSCALL_SLONG_TYPE;
pub const __SUSECONDS64_T_TYPE = __SQUAD_TYPE;
pub const __DADDR_T_TYPE = __S32_TYPE;
pub const __KEY_T_TYPE = __S32_TYPE;
pub const __CLOCKID_T_TYPE = __S32_TYPE;
pub const __BLKSIZE_T_TYPE = __SYSCALL_SLONG_TYPE;
pub const __SSIZE_T_TYPE = __SWORD_TYPE;
pub const __CPU_MASK_TYPE = __SYSCALL_ULONG_TYPE;
pub const __OFF_T_MATCHES_OFF64_T = 1;
pub const __INO_T_MATCHES_INO64_T = 1;
pub const __RLIM_T_MATCHES_RLIM64_T = 1;
pub const __STATFS_MATCHES_STATFS64 = 1;
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 = 1;
pub const __FD_SETSIZE = 1024;
pub const _BITS_TIME64_H = 1;
pub const __TIME64_T_TYPE = __TIME_T_TYPE;
pub const _BITS_WCHAR_H = 1;
pub const __WCHAR_MAX = __WCHAR_MAX__;
pub const __WCHAR_MIN = -__WCHAR_MAX - 1;
pub const _BITS_STDINT_INTN_H = 1;
pub const _BITS_STDINT_UINTN_H = 1;
pub const INT8_MIN = -128;
pub const INT16_MIN = -32767 - 1;
pub const INT32_MIN = -2147483647 - 1;
pub const INT64_MIN = -__INT64_C(9223372036854775807) - 1;
pub const INT8_MAX = 127;
pub const INT16_MAX = 32767;
pub const INT32_MAX = 2147483647;
pub const INT64_MAX = __INT64_C(9223372036854775807);
pub const UINT8_MAX = 255;
pub const UINT16_MAX = 65535;
pub const UINT32_MAX = @as(c_uint, 4294967295);
pub const UINT64_MAX = __UINT64_C(18446744073709551615);
pub const INT_LEAST8_MIN = -128;
pub const INT_LEAST16_MIN = -32767 - 1;
pub const INT_LEAST32_MIN = -2147483647 - 1;
pub const INT_LEAST64_MIN = -__INT64_C(9223372036854775807) - 1;
pub const INT_LEAST8_MAX = 127;
pub const INT_LEAST16_MAX = 32767;
pub const INT_LEAST32_MAX = 2147483647;
pub const INT_LEAST64_MAX = __INT64_C(9223372036854775807);
pub const UINT_LEAST8_MAX = 255;
pub const UINT_LEAST16_MAX = 65535;
pub const UINT_LEAST32_MAX = @as(c_uint, 4294967295);
pub const UINT_LEAST64_MAX = __UINT64_C(18446744073709551615);
pub const INT_FAST8_MIN = -128;
pub const INT_FAST16_MIN = -@as(c_long, 9223372036854775807) - 1;
pub const INT_FAST32_MIN = -@as(c_long, 9223372036854775807) - 1;
pub const INT_FAST64_MIN = -__INT64_C(9223372036854775807) - 1;
pub const INT_FAST8_MAX = 127;
pub const INT_FAST16_MAX = @as(c_long, 9223372036854775807);
pub const INT_FAST32_MAX = @as(c_long, 9223372036854775807);
pub const INT_FAST64_MAX = __INT64_C(9223372036854775807);
pub const UINT_FAST8_MAX = 255;
pub const UINT_FAST16_MAX = @as(c_ulong, 18446744073709551615);
pub const UINT_FAST32_MAX = @as(c_ulong, 18446744073709551615);
pub const UINT_FAST64_MAX = __UINT64_C(18446744073709551615);
pub const INTPTR_MIN = -@as(c_long, 9223372036854775807) - 1;
pub const INTPTR_MAX = @as(c_long, 9223372036854775807);
pub const UINTPTR_MAX = @as(c_ulong, 18446744073709551615);
pub const INTMAX_MIN = -__INT64_C(9223372036854775807) - 1;
pub const INTMAX_MAX = __INT64_C(9223372036854775807);
pub const UINTMAX_MAX = __UINT64_C(18446744073709551615);
pub const PTRDIFF_MIN = -@as(c_long, 9223372036854775807) - 1;
pub const PTRDIFF_MAX = @as(c_long, 9223372036854775807);
pub const SIG_ATOMIC_MIN = -2147483647 - 1;
pub const SIG_ATOMIC_MAX = 2147483647;
pub const SIZE_MAX = @as(c_ulong, 18446744073709551615);
pub const WCHAR_MIN = __WCHAR_MIN;
pub const WCHAR_MAX = __WCHAR_MAX;
pub const WINT_MIN = @as(c_uint, 0);
pub const WINT_MAX = @as(c_uint, 4294967295);
pub inline fn INT8_C(c: anytype) @TypeOf(c) {
return c;
}
pub inline fn INT16_C(c: anytype) @TypeOf(c) {
return c;
}
pub inline fn INT32_C(c: anytype) @TypeOf(c) {
return c;
}
pub inline fn UINT8_C(c: anytype) @TypeOf(c) {
return c;
}
pub inline fn UINT16_C(c: anytype) @TypeOf(c) {
return c;
}
pub const VULKAN_CORE_H_ = 1;
pub const VERSION_1_0 = 1;
pub inline fn MAKE_VERSION(major: anytype, minor: anytype, patch: anytype) @TypeOf((((@import("std").meta.cast(u32, major)) << 22) | ((@import("std").meta.cast(u32, minor)) << 12)) | (@import("std").meta.cast(u32, patch))) {
return (((@import("std").meta.cast(u32, major)) << 22) | ((@import("std").meta.cast(u32, minor)) << 12)) | (@import("std").meta.cast(u32, patch));
}
pub const API_VERSION_1_0 = MAKE_VERSION(1, 0, 0);
pub const HEADER_VERSION = 160;
pub const HEADER_VERSION_COMPLETE = MAKE_VERSION(1, 2, HEADER_VERSION);
pub inline fn VERSION_MAJOR(version: anytype) @TypeOf((@import("std").meta.cast(u32, version)) >> 22) {
return (@import("std").meta.cast(u32, version)) >> 22;
}
pub inline fn VERSION_MINOR(version: anytype) @TypeOf(((@import("std").meta.cast(u32, version)) >> 12) & 0x3ff) {
return ((@import("std").meta.cast(u32, version)) >> 12) & 0x3ff;
}
pub inline fn VERSION_PATCH(version: anytype) @TypeOf((@import("std").meta.cast(u32, version)) & 0xfff) {
return (@import("std").meta.cast(u32, version)) & 0xfff;
}
pub const NULL_HANDLE = 0;
pub const ATTACHMENT_UNUSED = ~@as(c_uint, 0);
pub const FALSE = 0;
pub const LOD_CLAMP_NONE = @as(f32, 1000.0);
pub const QUEUE_FAMILY_IGNORED = ~@as(c_uint, 0);
pub const REMAINING_ARRAY_LAYERS = ~@as(c_uint, 0);
pub const REMAINING_MIP_LEVELS = ~@as(c_uint, 0);
pub const SUBPASS_EXTERNAL = ~@as(c_uint, 0);
pub const TRUE = 1;
pub const WHOLE_SIZE = ~@as(c_ulonglong, 0);
pub const MAX_MEMORY_TYPES = 32;
pub const MAX_MEMORY_HEAPS = 16;
pub const MAX_PHYSICAL_DEVICE_NAME_SIZE = 256;
pub const UUID_SIZE = 16;
pub const MAX_EXTENSION_NAME_SIZE = 256;
pub const MAX_DESCRIPTION_SIZE = 256;
pub const VERSION_1_1 = 1;
pub const API_VERSION_1_1 = MAKE_VERSION(1, 1, 0);
pub const MAX_DEVICE_GROUP_SIZE = 32;
pub const LUID_SIZE = 8;
pub const QUEUE_FAMILY_EXTERNAL = ~@as(c_uint, 0) - 1;
pub const VERSION_1_2 = 1;
pub const API_VERSION_1_2 = MAKE_VERSION(1, 2, 0);
pub const MAX_DRIVER_NAME_SIZE = 256;
pub const MAX_DRIVER_INFO_SIZE = 256;
pub const KHR_surface = 1;
pub const KHR_SURFACE_SPEC_VERSION = 25;
pub const KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface";
pub const KHR_swapchain = 1;
pub const KHR_SWAPCHAIN_SPEC_VERSION = 70;
pub const KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain";
pub const KHR_display = 1;
pub const KHR_DISPLAY_SPEC_VERSION = 23;
pub const KHR_DISPLAY_EXTENSION_NAME = "VK_KHR_display";
pub const KHR_display_swapchain = 1;
pub const KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION = 10;
pub const KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_display_swapchain";
pub const KHR_sampler_mirror_clamp_to_edge = 1;
pub const KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION = 3;
pub const KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME = "VK_KHR_sampler_mirror_clamp_to_edge";
pub const KHR_multiview = 1;
pub const KHR_MULTIVIEW_SPEC_VERSION = 1;
pub const KHR_MULTIVIEW_EXTENSION_NAME = "VK_KHR_multiview";
pub const KHR_get_physical_device_properties2 = 1;
pub const KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION = 2;
pub const KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME = "VK_KHR_get_physical_device_properties2";
pub const KHR_device_group = 1;
pub const KHR_DEVICE_GROUP_SPEC_VERSION = 4;
pub const KHR_DEVICE_GROUP_EXTENSION_NAME = "VK_KHR_device_group";
pub const KHR_shader_draw_parameters = 1;
pub const KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION = 1;
pub const KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME = "VK_KHR_shader_draw_parameters";
pub const KHR_maintenance1 = 1;
pub const KHR_MAINTENANCE1_SPEC_VERSION = 2;
pub const KHR_MAINTENANCE1_EXTENSION_NAME = "VK_KHR_maintenance1";
pub const KHR_device_group_creation = 1;
pub const KHR_DEVICE_GROUP_CREATION_SPEC_VERSION = 1;
pub const KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME = "VK_KHR_device_group_creation";
pub const MAX_DEVICE_GROUP_SIZE_KHR = MAX_DEVICE_GROUP_SIZE;
pub const KHR_external_memory_capabilities = 1;
pub const KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = "VK_KHR_external_memory_capabilities";
pub const LUID_SIZE_KHR = LUID_SIZE;
pub const KHR_external_memory = 1;
pub const KHR_EXTERNAL_MEMORY_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_KHR_external_memory";
pub const QUEUE_FAMILY_EXTERNAL_KHR = QUEUE_FAMILY_EXTERNAL;
pub const KHR_external_memory_fd = 1;
pub const KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME = "VK_KHR_external_memory_fd";
pub const KHR_external_semaphore_capabilities = 1;
pub const KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME = "VK_KHR_external_semaphore_capabilities";
pub const KHR_external_semaphore = 1;
pub const KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME = "VK_KHR_external_semaphore";
pub const KHR_external_semaphore_fd = 1;
pub const KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME = "VK_KHR_external_semaphore_fd";
pub const KHR_push_descriptor = 1;
pub const KHR_PUSH_DESCRIPTOR_SPEC_VERSION = 2;
pub const KHR_PUSH_DESCRIPTOR_EXTENSION_NAME = "VK_KHR_push_descriptor";
pub const KHR_shader_float16_int8 = 1;
pub const KHR_SHADER_FLOAT16_INT8_SPEC_VERSION = 1;
pub const KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME = "VK_KHR_shader_float16_int8";
pub const KHR_16bit_storage = 1;
pub const KHR_16BIT_STORAGE_SPEC_VERSION = 1;
pub const KHR_16BIT_STORAGE_EXTENSION_NAME = "VK_KHR_16bit_storage";
pub const KHR_incremental_present = 1;
pub const KHR_INCREMENTAL_PRESENT_SPEC_VERSION = 1;
pub const KHR_INCREMENTAL_PRESENT_EXTENSION_NAME = "VK_KHR_incremental_present";
pub const KHR_descriptor_update_template = 1;
pub const KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION = 1;
pub const KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME = "VK_KHR_descriptor_update_template";
pub const KHR_imageless_framebuffer = 1;
pub const KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION = 1;
pub const KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME = "VK_KHR_imageless_framebuffer";
pub const KHR_create_renderpass2 = 1;
pub const KHR_CREATE_RENDERPASS_2_SPEC_VERSION = 1;
pub const KHR_CREATE_RENDERPASS_2_EXTENSION_NAME = "VK_KHR_create_renderpass2";
pub const KHR_shared_presentable_image = 1;
pub const KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION = 1;
pub const KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME = "VK_KHR_shared_presentable_image";
pub const KHR_external_fence_capabilities = 1;
pub const KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME = "VK_KHR_external_fence_capabilities";
pub const KHR_external_fence = 1;
pub const KHR_EXTERNAL_FENCE_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_FENCE_EXTENSION_NAME = "VK_KHR_external_fence";
pub const KHR_external_fence_fd = 1;
pub const KHR_EXTERNAL_FENCE_FD_SPEC_VERSION = 1;
pub const KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME = "VK_KHR_external_fence_fd";
pub const KHR_performance_query = 1;
pub const KHR_PERFORMANCE_QUERY_SPEC_VERSION = 1;
pub const KHR_PERFORMANCE_QUERY_EXTENSION_NAME = "VK_KHR_performance_query";
pub const KHR_maintenance2 = 1;
pub const KHR_MAINTENANCE2_SPEC_VERSION = 1;
pub const KHR_MAINTENANCE2_EXTENSION_NAME = "VK_KHR_maintenance2";
pub const KHR_get_surface_capabilities2 = 1;
pub const KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION = 1;
pub const KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME = "VK_KHR_get_surface_capabilities2";
pub const KHR_variable_pointers = 1;
pub const KHR_VARIABLE_POINTERS_SPEC_VERSION = 1;
pub const KHR_VARIABLE_POINTERS_EXTENSION_NAME = "VK_KHR_variable_pointers";
pub const KHR_get_display_properties2 = 1;
pub const KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION = 1;
pub const KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME = "VK_KHR_get_display_properties2";
pub const KHR_dedicated_allocation = 1;
pub const KHR_DEDICATED_ALLOCATION_SPEC_VERSION = 3;
pub const KHR_DEDICATED_ALLOCATION_EXTENSION_NAME = "VK_KHR_dedicated_allocation";
pub const KHR_storage_buffer_storage_class = 1;
pub const KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION = 1;
pub const KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME = "VK_KHR_storage_buffer_storage_class";
pub const KHR_relaxed_block_layout = 1;
pub const KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION = 1;
pub const KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME = "VK_KHR_relaxed_block_layout";
pub const KHR_get_memory_requirements2 = 1;
pub const KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION = 1;
pub const KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME = "VK_KHR_get_memory_requirements2";
pub const KHR_image_format_list = 1;
pub const KHR_IMAGE_FORMAT_LIST_SPEC_VERSION = 1;
pub const KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME = "VK_KHR_image_format_list";
pub const KHR_sampler_ycbcr_conversion = 1;
pub const KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION = 14;
pub const KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME = "VK_KHR_sampler_ycbcr_conversion";
pub const KHR_bind_memory2 = 1;
pub const KHR_BIND_MEMORY_2_SPEC_VERSION = 1;
pub const KHR_BIND_MEMORY_2_EXTENSION_NAME = "VK_KHR_bind_memory2";
pub const KHR_maintenance3 = 1;
pub const KHR_MAINTENANCE3_SPEC_VERSION = 1;
pub const KHR_MAINTENANCE3_EXTENSION_NAME = "VK_KHR_maintenance3";
pub const KHR_draw_indirect_count = 1;
pub const KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION = 1;
pub const KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME = "VK_KHR_draw_indirect_count";
pub const KHR_shader_subgroup_extended_types = 1;
pub const KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION = 1;
pub const KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME = "VK_KHR_shader_subgroup_extended_types";
pub const KHR_8bit_storage = 1;
pub const KHR_8BIT_STORAGE_SPEC_VERSION = 1;
pub const KHR_8BIT_STORAGE_EXTENSION_NAME = "VK_KHR_8bit_storage";
pub const KHR_shader_atomic_int64 = 1;
pub const KHR_SHADER_ATOMIC_INT64_SPEC_VERSION = 1;
pub const KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME = "VK_KHR_shader_atomic_int64";
pub const KHR_shader_clock = 1;
pub const KHR_SHADER_CLOCK_SPEC_VERSION = 1;
pub const KHR_SHADER_CLOCK_EXTENSION_NAME = "VK_KHR_shader_clock";
pub const KHR_driver_properties = 1;
pub const KHR_DRIVER_PROPERTIES_SPEC_VERSION = 1;
pub const KHR_DRIVER_PROPERTIES_EXTENSION_NAME = "VK_KHR_driver_properties";
pub const MAX_DRIVER_NAME_SIZE_KHR = MAX_DRIVER_NAME_SIZE;
pub const MAX_DRIVER_INFO_SIZE_KHR = MAX_DRIVER_INFO_SIZE;
pub const KHR_shader_float_controls = 1;
pub const KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION = 4;
pub const KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME = "VK_KHR_shader_float_controls";
pub const KHR_depth_stencil_resolve = 1;
pub const KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION = 1;
pub const KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME = "VK_KHR_depth_stencil_resolve";
pub const KHR_swapchain_mutable_format = 1;
pub const KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION = 1;
pub const KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME = "VK_KHR_swapchain_mutable_format";
pub const KHR_timeline_semaphore = 1;
pub const KHR_TIMELINE_SEMAPHORE_SPEC_VERSION = 2;
pub const KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME = "VK_KHR_timeline_semaphore";
pub const KHR_vulkan_memory_model = 1;
pub const KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION = 3;
pub const KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME = "VK_KHR_vulkan_memory_model";
pub const KHR_shader_terminate_invocation = 1;
pub const KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION = 1;
pub const KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME = "VK_KHR_shader_terminate_invocation";
pub const KHR_fragment_shading_rate = 1;
pub const KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION = 1;
pub const KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME = "VK_KHR_fragment_shading_rate";
pub const KHR_spirv_1_4 = 1;
pub const KHR_SPIRV_1_4_SPEC_VERSION = 1;
pub const KHR_SPIRV_1_4_EXTENSION_NAME = "VK_KHR_spirv_1_4";
pub const KHR_surface_protected_capabilities = 1;
pub const KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION = 1;
pub const KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME = "VK_KHR_surface_protected_capabilities";
pub const KHR_separate_depth_stencil_layouts = 1;
pub const KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION = 1;
pub const KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME = "VK_KHR_separate_depth_stencil_layouts";
pub const KHR_uniform_buffer_standard_layout = 1;
pub const KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION = 1;
pub const KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME = "VK_KHR_uniform_buffer_standard_layout";
pub const KHR_buffer_device_address = 1;
pub const KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION = 1;
pub const KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME = "VK_KHR_buffer_device_address";
pub const KHR_pipeline_executable_properties = 1;
pub const KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION = 1;
pub const KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME = "VK_KHR_pipeline_executable_properties";
pub const KHR_shader_non_semantic_info = 1;
pub const KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION = 1;
pub const KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME = "VK_KHR_shader_non_semantic_info";
pub const KHR_copy_commands2 = 1;
pub const KHR_COPY_COMMANDS_2_SPEC_VERSION = 1;
pub const KHR_COPY_COMMANDS_2_EXTENSION_NAME = "VK_KHR_copy_commands2";
pub const EXT_debug_report = 1;
pub const EXT_DEBUG_REPORT_SPEC_VERSION = 9;
pub const EXT_DEBUG_REPORT_EXTENSION_NAME = "VK_EXT_debug_report";
pub const NV_glsl_shader = 1;
pub const NV_GLSL_SHADER_SPEC_VERSION = 1;
pub const NV_GLSL_SHADER_EXTENSION_NAME = "VK_NV_glsl_shader";
pub const EXT_depth_range_unrestricted = 1;
pub const EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION = 1;
pub const EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME = "VK_EXT_depth_range_unrestricted";
pub const IMG_filter_cubic = 1;
pub const IMG_FILTER_CUBIC_SPEC_VERSION = 1;
pub const IMG_FILTER_CUBIC_EXTENSION_NAME = "VK_IMG_filter_cubic";
pub const AMD_rasterization_order = 1;
pub const AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1;
pub const AMD_RASTERIZATION_ORDER_EXTENSION_NAME = "VK_AMD_rasterization_order";
pub const AMD_shader_trinary_minmax = 1;
pub const AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION = 1;
pub const AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME = "VK_AMD_shader_trinary_minmax";
pub const AMD_shader_explicit_vertex_parameter = 1;
pub const AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION = 1;
pub const AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME = "VK_AMD_shader_explicit_vertex_parameter";
pub const EXT_debug_marker = 1;
pub const EXT_DEBUG_MARKER_SPEC_VERSION = 4;
pub const EXT_DEBUG_MARKER_EXTENSION_NAME = "VK_EXT_debug_marker";
pub const AMD_gcn_shader = 1;
pub const AMD_GCN_SHADER_SPEC_VERSION = 1;
pub const AMD_GCN_SHADER_EXTENSION_NAME = "VK_AMD_gcn_shader";
pub const NV_dedicated_allocation = 1;
pub const NV_DEDICATED_ALLOCATION_SPEC_VERSION = 1;
pub const NV_DEDICATED_ALLOCATION_EXTENSION_NAME = "VK_NV_dedicated_allocation";
pub const EXT_transform_feedback = 1;
pub const EXT_TRANSFORM_FEEDBACK_SPEC_VERSION = 1;
pub const EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME = "VK_EXT_transform_feedback";
pub const NVX_image_view_handle = 1;
pub const NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION = 2;
pub const NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME = "VK_NVX_image_view_handle";
pub const AMD_draw_indirect_count = 1;
pub const AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION = 2;
pub const AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME = "VK_AMD_draw_indirect_count";
pub const AMD_negative_viewport_height = 1;
pub const AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION = 1;
pub const AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME = "VK_AMD_negative_viewport_height";
pub const AMD_gpu_shader_half_float = 1;
pub const AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION = 2;
pub const AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME = "VK_AMD_gpu_shader_half_float";
pub const AMD_shader_ballot = 1;
pub const AMD_SHADER_BALLOT_SPEC_VERSION = 1;
pub const AMD_SHADER_BALLOT_EXTENSION_NAME = "VK_AMD_shader_ballot";
pub const AMD_texture_gather_bias_lod = 1;
pub const AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION = 1;
pub const AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME = "VK_AMD_texture_gather_bias_lod";
pub const AMD_shader_info = 1;
pub const AMD_SHADER_INFO_SPEC_VERSION = 1;
pub const AMD_SHADER_INFO_EXTENSION_NAME = "VK_AMD_shader_info";
pub const AMD_shader_image_load_store_lod = 1;
pub const AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION = 1;
pub const AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME = "VK_AMD_shader_image_load_store_lod";
pub const NV_corner_sampled_image = 1;
pub const NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION = 2;
pub const NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME = "VK_NV_corner_sampled_image";
pub const IMG_format_pvrtc = 1;
pub const IMG_FORMAT_PVRTC_SPEC_VERSION = 1;
pub const IMG_FORMAT_PVRTC_EXTENSION_NAME = "VK_IMG_format_pvrtc";
pub const NV_external_memory_capabilities = 1;
pub const NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1;
pub const NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = "VK_NV_external_memory_capabilities";
pub const NV_external_memory = 1;
pub const NV_EXTERNAL_MEMORY_SPEC_VERSION = 1;
pub const NV_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_NV_external_memory";
pub const EXT_validation_flags = 1;
pub const EXT_VALIDATION_FLAGS_SPEC_VERSION = 2;
pub const EXT_VALIDATION_FLAGS_EXTENSION_NAME = "VK_EXT_validation_flags";
pub const EXT_shader_subgroup_ballot = 1;
pub const EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION = 1;
pub const EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME = "VK_EXT_shader_subgroup_ballot";
pub const EXT_shader_subgroup_vote = 1;
pub const EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION = 1;
pub const EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME = "VK_EXT_shader_subgroup_vote";
pub const EXT_texture_compression_astc_hdr = 1;
pub const EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION = 1;
pub const EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME = "VK_EXT_texture_compression_astc_hdr";
pub const EXT_astc_decode_mode = 1;
pub const EXT_ASTC_DECODE_MODE_SPEC_VERSION = 1;
pub const EXT_ASTC_DECODE_MODE_EXTENSION_NAME = "VK_EXT_astc_decode_mode";
pub const EXT_conditional_rendering = 1;
pub const EXT_CONDITIONAL_RENDERING_SPEC_VERSION = 2;
pub const EXT_CONDITIONAL_RENDERING_EXTENSION_NAME = "VK_EXT_conditional_rendering";
pub const NV_clip_space_w_scaling = 1;
pub const NV_CLIP_SPACE_W_SCALING_SPEC_VERSION = 1;
pub const NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME = "VK_NV_clip_space_w_scaling";
pub const EXT_direct_mode_display = 1;
pub const EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION = 1;
pub const EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME = "VK_EXT_direct_mode_display";
pub const EXT_display_surface_counter = 1;
pub const EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION = 1;
pub const EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME = "VK_EXT_display_surface_counter";
pub const EXT_display_control = 1;
pub const EXT_DISPLAY_CONTROL_SPEC_VERSION = 1;
pub const EXT_DISPLAY_CONTROL_EXTENSION_NAME = "VK_EXT_display_control";
pub const GOOGLE_display_timing = 1;
pub const GOOGLE_DISPLAY_TIMING_SPEC_VERSION = 1;
pub const GOOGLE_DISPLAY_TIMING_EXTENSION_NAME = "VK_GOOGLE_display_timing";
pub const NV_sample_mask_override_coverage = 1;
pub const NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION = 1;
pub const NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME = "VK_NV_sample_mask_override_coverage";
pub const NV_geometry_shader_passthrough = 1;
pub const NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION = 1;
pub const NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME = "VK_NV_geometry_shader_passthrough";
pub const NV_viewport_array2 = 1;
pub const NV_VIEWPORT_ARRAY2_SPEC_VERSION = 1;
pub const NV_VIEWPORT_ARRAY2_EXTENSION_NAME = "VK_NV_viewport_array2";
pub const NVX_multiview_per_view_attributes = 1;
pub const NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION = 1;
pub const NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME = "VK_NVX_multiview_per_view_attributes";
pub const NV_viewport_swizzle = 1;
pub const NV_VIEWPORT_SWIZZLE_SPEC_VERSION = 1;
pub const NV_VIEWPORT_SWIZZLE_EXTENSION_NAME = "VK_NV_viewport_swizzle";
pub const EXT_discard_rectangles = 1;
pub const EXT_DISCARD_RECTANGLES_SPEC_VERSION = 1;
pub const EXT_DISCARD_RECTANGLES_EXTENSION_NAME = "VK_EXT_discard_rectangles";
pub const EXT_conservative_rasterization = 1;
pub const EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION = 1;
pub const EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME = "VK_EXT_conservative_rasterization";
pub const EXT_depth_clip_enable = 1;
pub const EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION = 1;
pub const EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME = "VK_EXT_depth_clip_enable";
pub const EXT_swapchain_colorspace = 1;
pub const EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION = 4;
pub const EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME = "VK_EXT_swapchain_colorspace";
pub const EXT_hdr_metadata = 1;
pub const EXT_HDR_METADATA_SPEC_VERSION = 2;
pub const EXT_HDR_METADATA_EXTENSION_NAME = "VK_EXT_hdr_metadata";
pub const EXT_external_memory_dma_buf = 1;
pub const EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION = 1;
pub const EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME = "VK_EXT_external_memory_dma_buf";
pub const EXT_queue_family_foreign = 1;
pub const EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION = 1;
pub const EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME = "VK_EXT_queue_family_foreign";
pub const QUEUE_FAMILY_FOREIGN_EXT = ~@as(c_uint, 0) - 2;
pub const EXT_debug_utils = 1;
pub const EXT_DEBUG_UTILS_SPEC_VERSION = 2;
pub const EXT_DEBUG_UTILS_EXTENSION_NAME = "VK_EXT_debug_utils";
pub const EXT_sampler_filter_minmax = 1;
pub const EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION = 2;
pub const EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME = "VK_EXT_sampler_filter_minmax";
pub const AMD_gpu_shader_int16 = 1;
pub const AMD_GPU_SHADER_INT16_SPEC_VERSION = 2;
pub const AMD_GPU_SHADER_INT16_EXTENSION_NAME = "VK_AMD_gpu_shader_int16";
pub const AMD_mixed_attachment_samples = 1;
pub const AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION = 1;
pub const AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME = "VK_AMD_mixed_attachment_samples";
pub const AMD_shader_fragment_mask = 1;
pub const AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION = 1;
pub const AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME = "VK_AMD_shader_fragment_mask";
pub const EXT_inline_uniform_block = 1;
pub const EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION = 1;
pub const EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME = "VK_EXT_inline_uniform_block";
pub const EXT_shader_stencil_export = 1;
pub const EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION = 1;
pub const EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME = "VK_EXT_shader_stencil_export";
pub const EXT_sample_locations = 1;
pub const EXT_SAMPLE_LOCATIONS_SPEC_VERSION = 1;
pub const EXT_SAMPLE_LOCATIONS_EXTENSION_NAME = "VK_EXT_sample_locations";
pub const EXT_blend_operation_advanced = 1;
pub const EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION = 2;
pub const EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME = "VK_EXT_blend_operation_advanced";
pub const NV_fragment_coverage_to_color = 1;
pub const NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION = 1;
pub const NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME = "VK_NV_fragment_coverage_to_color";
pub const NV_framebuffer_mixed_samples = 1;
pub const NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION = 1;
pub const NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME = "VK_NV_framebuffer_mixed_samples";
pub const NV_fill_rectangle = 1;
pub const NV_FILL_RECTANGLE_SPEC_VERSION = 1;
pub const NV_FILL_RECTANGLE_EXTENSION_NAME = "VK_NV_fill_rectangle";
pub const NV_shader_sm_builtins = 1;
pub const NV_SHADER_SM_BUILTINS_SPEC_VERSION = 1;
pub const NV_SHADER_SM_BUILTINS_EXTENSION_NAME = "VK_NV_shader_sm_builtins";
pub const EXT_post_depth_coverage = 1;
pub const EXT_POST_DEPTH_COVERAGE_SPEC_VERSION = 1;
pub const EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME = "VK_EXT_post_depth_coverage";
pub const EXT_image_drm_format_modifier = 1;
pub const EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION = 1;
pub const EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME = "VK_EXT_image_drm_format_modifier";
pub const EXT_validation_cache = 1;
pub const EXT_VALIDATION_CACHE_SPEC_VERSION = 1;
pub const EXT_VALIDATION_CACHE_EXTENSION_NAME = "VK_EXT_validation_cache";
pub const EXT_descriptor_indexing = 1;
pub const EXT_DESCRIPTOR_INDEXING_SPEC_VERSION = 2;
pub const EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME = "VK_EXT_descriptor_indexing";
pub const EXT_shader_viewport_index_layer = 1;
pub const EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION = 1;
pub const EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME = "VK_EXT_shader_viewport_index_layer";
pub const NV_shading_rate_image = 1;
pub const NV_SHADING_RATE_IMAGE_SPEC_VERSION = 3;
pub const NV_SHADING_RATE_IMAGE_EXTENSION_NAME = "VK_NV_shading_rate_image";
pub const NV_ray_tracing = 1;
pub const NV_RAY_TRACING_SPEC_VERSION = 3;
pub const NV_RAY_TRACING_EXTENSION_NAME = "VK_NV_ray_tracing";
pub const SHADER_UNUSED_KHR = ~@as(c_uint, 0);
pub const SHADER_UNUSED_NV = SHADER_UNUSED_KHR;
pub const NV_representative_fragment_test = 1;
pub const NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION = 2;
pub const NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME = "VK_NV_representative_fragment_test";
pub const EXT_filter_cubic = 1;
pub const EXT_FILTER_CUBIC_SPEC_VERSION = 3;
pub const EXT_FILTER_CUBIC_EXTENSION_NAME = "VK_EXT_filter_cubic";
pub const QCOM_render_pass_shader_resolve = 1;
pub const QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION = 4;
pub const QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME = "VK_QCOM_render_pass_shader_resolve";
pub const EXT_global_priority = 1;
pub const EXT_GLOBAL_PRIORITY_SPEC_VERSION = 2;
pub const EXT_GLOBAL_PRIORITY_EXTENSION_NAME = "VK_EXT_global_priority";
pub const EXT_external_memory_host = 1;
pub const EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION = 1;
pub const EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME = "VK_EXT_external_memory_host";
pub const AMD_buffer_marker = 1;
pub const AMD_BUFFER_MARKER_SPEC_VERSION = 1;
pub const AMD_BUFFER_MARKER_EXTENSION_NAME = "VK_AMD_buffer_marker";
pub const AMD_pipeline_compiler_control = 1;
pub const AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION = 1;
pub const AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME = "VK_AMD_pipeline_compiler_control";
pub const EXT_calibrated_timestamps = 1;
pub const EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION = 1;
pub const EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME = "VK_EXT_calibrated_timestamps";
pub const AMD_shader_core_properties = 1;
pub const AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION = 2;
pub const AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME = "VK_AMD_shader_core_properties";
pub const AMD_memory_overallocation_behavior = 1;
pub const AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION = 1;
pub const AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME = "VK_AMD_memory_overallocation_behavior";
pub const EXT_vertex_attribute_divisor = 1;
pub const EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION = 3;
pub const EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME = "VK_EXT_vertex_attribute_divisor";
pub const EXT_pipeline_creation_feedback = 1;
pub const EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION = 1;
pub const EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME = "VK_EXT_pipeline_creation_feedback";
pub const NV_shader_subgroup_partitioned = 1;
pub const NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION = 1;
pub const NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME = "VK_NV_shader_subgroup_partitioned";
pub const NV_compute_shader_derivatives = 1;
pub const NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION = 1;
pub const NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME = "VK_NV_compute_shader_derivatives";
pub const NV_mesh_shader = 1;
pub const NV_MESH_SHADER_SPEC_VERSION = 1;
pub const NV_MESH_SHADER_EXTENSION_NAME = "VK_NV_mesh_shader";
pub const NV_fragment_shader_barycentric = 1;
pub const NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION = 1;
pub const NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME = "VK_NV_fragment_shader_barycentric";
pub const NV_shader_image_footprint = 1;
pub const NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION = 2;
pub const NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME = "VK_NV_shader_image_footprint";
pub const NV_scissor_exclusive = 1;
pub const NV_SCISSOR_EXCLUSIVE_SPEC_VERSION = 1;
pub const NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME = "VK_NV_scissor_exclusive";
pub const NV_device_diagnostic_checkpoints = 1;
pub const NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION = 2;
pub const NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME = "VK_NV_device_diagnostic_checkpoints";
pub const INTEL_shader_integer_functions2 = 1;
pub const INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION = 1;
pub const INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME = "VK_INTEL_shader_integer_functions2";
pub const INTEL_performance_query = 1;
pub const INTEL_PERFORMANCE_QUERY_SPEC_VERSION = 2;
pub const INTEL_PERFORMANCE_QUERY_EXTENSION_NAME = "VK_INTEL_performance_query";
pub const EXT_pci_bus_info = 1;
pub const EXT_PCI_BUS_INFO_SPEC_VERSION = 2;
pub const EXT_PCI_BUS_INFO_EXTENSION_NAME = "VK_EXT_pci_bus_info";
pub const AMD_display_native_hdr = 1;
pub const AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION = 1;
pub const AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME = "VK_AMD_display_native_hdr";
pub const EXT_fragment_density_map = 1;
pub const EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION = 1;
pub const EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME = "VK_EXT_fragment_density_map";
pub const EXT_scalar_block_layout = 1;
pub const EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION = 1;
pub const EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME = "VK_EXT_scalar_block_layout";
pub const GOOGLE_hlsl_functionality1 = 1;
pub const GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION = 1;
pub const GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME = "VK_GOOGLE_hlsl_functionality1";
pub const GOOGLE_decorate_string = 1;
pub const GOOGLE_DECORATE_STRING_SPEC_VERSION = 1;
pub const GOOGLE_DECORATE_STRING_EXTENSION_NAME = "VK_GOOGLE_decorate_string";
pub const EXT_subgroup_size_control = 1;
pub const EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION = 2;
pub const EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME = "VK_EXT_subgroup_size_control";
pub const AMD_shader_core_properties2 = 1;
pub const AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION = 1;
pub const AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME = "VK_AMD_shader_core_properties2";
pub const AMD_device_coherent_memory = 1;
pub const AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION = 1;
pub const AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME = "VK_AMD_device_coherent_memory";
pub const EXT_shader_image_atomic_int64 = 1;
pub const EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION = 1;
pub const EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME = "VK_EXT_shader_image_atomic_int64";
pub const EXT_memory_budget = 1;
pub const EXT_MEMORY_BUDGET_SPEC_VERSION = 1;
pub const EXT_MEMORY_BUDGET_EXTENSION_NAME = "VK_EXT_memory_budget";
pub const EXT_memory_priority = 1;
pub const EXT_MEMORY_PRIORITY_SPEC_VERSION = 1;
pub const EXT_MEMORY_PRIORITY_EXTENSION_NAME = "VK_EXT_memory_priority";
pub const NV_dedicated_allocation_image_aliasing = 1;
pub const NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION = 1;
pub const NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME = "VK_NV_dedicated_allocation_image_aliasing";
pub const EXT_buffer_device_address = 1;
pub const EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION = 2;
pub const EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME = "VK_EXT_buffer_device_address";
pub const EXT_tooling_info = 1;
pub const EXT_TOOLING_INFO_SPEC_VERSION = 1;
pub const EXT_TOOLING_INFO_EXTENSION_NAME = "VK_EXT_tooling_info";
pub const EXT_separate_stencil_usage = 1;
pub const EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION = 1;
pub const EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME = "VK_EXT_separate_stencil_usage";
pub const EXT_validation_features = 1;
pub const EXT_VALIDATION_FEATURES_SPEC_VERSION = 4;
pub const EXT_VALIDATION_FEATURES_EXTENSION_NAME = "VK_EXT_validation_features";
pub const NV_cooperative_matrix = 1;
pub const NV_COOPERATIVE_MATRIX_SPEC_VERSION = 1;
pub const NV_COOPERATIVE_MATRIX_EXTENSION_NAME = "VK_NV_cooperative_matrix";
pub const NV_coverage_reduction_mode = 1;
pub const NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION = 1;
pub const NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME = "VK_NV_coverage_reduction_mode";
pub const EXT_fragment_shader_interlock = 1;
pub const EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION = 1;
pub const EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME = "VK_EXT_fragment_shader_interlock";
pub const EXT_ycbcr_image_arrays = 1;
pub const EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION = 1;
pub const EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME = "VK_EXT_ycbcr_image_arrays";
pub const EXT_headless_surface = 1;
pub const EXT_HEADLESS_SURFACE_SPEC_VERSION = 1;
pub const EXT_HEADLESS_SURFACE_EXTENSION_NAME = "VK_EXT_headless_surface";
pub const EXT_line_rasterization = 1;
pub const EXT_LINE_RASTERIZATION_SPEC_VERSION = 1;
pub const EXT_LINE_RASTERIZATION_EXTENSION_NAME = "VK_EXT_line_rasterization";
pub const EXT_shader_atomic_float = 1;
pub const EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION = 1;
pub const EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME = "VK_EXT_shader_atomic_float";
pub const EXT_host_query_reset = 1;
pub const EXT_HOST_QUERY_RESET_SPEC_VERSION = 1;
pub const EXT_HOST_QUERY_RESET_EXTENSION_NAME = "VK_EXT_host_query_reset";
pub const EXT_index_type_uint8 = 1;
pub const EXT_INDEX_TYPE_UINT8_SPEC_VERSION = 1;
pub const EXT_INDEX_TYPE_UINT8_EXTENSION_NAME = "VK_EXT_index_type_uint8";
pub const EXT_extended_dynamic_state = 1;
pub const EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION = 1;
pub const EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME = "VK_EXT_extended_dynamic_state";
pub const EXT_shader_demote_to_helper_invocation = 1;
pub const EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION = 1;
pub const EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME = "VK_EXT_shader_demote_to_helper_invocation";
pub const NV_device_generated_commands = 1;
pub const NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION = 3;
pub const NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME = "VK_NV_device_generated_commands";
pub const EXT_texel_buffer_alignment = 1;
pub const EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION = 1;
pub const EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME = "VK_EXT_texel_buffer_alignment";
pub const QCOM_render_pass_transform = 1;
pub const QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION = 1;
pub const QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME = "VK_QCOM_render_pass_transform";
pub const EXT_device_memory_report = 1;
pub const EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION = 1;
pub const EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME = "VK_EXT_device_memory_report";
pub const EXT_robustness2 = 1;
pub const EXT_ROBUSTNESS_2_SPEC_VERSION = 1;
pub const EXT_ROBUSTNESS_2_EXTENSION_NAME = "VK_EXT_robustness2";
pub const EXT_custom_border_color = 1;
pub const EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION = 12;
pub const EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME = "VK_EXT_custom_border_color";
pub const GOOGLE_user_type = 1;
pub const GOOGLE_USER_TYPE_SPEC_VERSION = 1;
pub const GOOGLE_USER_TYPE_EXTENSION_NAME = "VK_GOOGLE_user_type";
pub const EXT_private_data = 1;
pub const EXT_PRIVATE_DATA_SPEC_VERSION = 1;
pub const EXT_PRIVATE_DATA_EXTENSION_NAME = "VK_EXT_private_data";
pub const EXT_pipeline_creation_cache_control = 1;
pub const EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION = 3;
pub const EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME = "VK_EXT_pipeline_creation_cache_control";
pub const NV_device_diagnostics_config = 1;
pub const NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION = 1;
pub const NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME = "VK_NV_device_diagnostics_config";
pub const QCOM_render_pass_store_ops = 1;
pub const QCOM_render_pass_store_ops_SPEC_VERSION = 2;
pub const QCOM_render_pass_store_ops_EXTENSION_NAME = "VK_QCOM_render_pass_store_ops";
pub const NV_fragment_shading_rate_enums = 1;
pub const NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION = 1;
pub const NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME = "VK_NV_fragment_shading_rate_enums";
pub const EXT_fragment_density_map2 = 1;
pub const EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION = 1;
pub const EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME = "VK_EXT_fragment_density_map2";
pub const QCOM_rotated_copy_commands = 1;
pub const QCOM_rotated_copy_commands_SPEC_VERSION = 0;
pub const QCOM_rotated_copy_commands_EXTENSION_NAME = "VK_QCOM_rotated_copy_commands";
pub const EXT_image_robustness = 1;
pub const EXT_IMAGE_ROBUSTNESS_SPEC_VERSION = 1;
pub const EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME = "VK_EXT_image_robustness";
pub const EXT_4444_formats = 1;
pub const EXT_4444_FORMATS_SPEC_VERSION = 1;
pub const EXT_4444_FORMATS_EXTENSION_NAME = "VK_EXT_4444_formats";
pub const Buffer_T = struct_Buffer_T;
pub const Image_T = struct_Image_T;
pub const Instance_T = struct_Instance_T;
pub const PhysicalDevice_T = struct_PhysicalDevice_T;
pub const Device_T = struct_Device_T;
pub const Queue_T = struct_Queue_T;
pub const Semaphore_T = struct_Semaphore_T;
pub const CommandBuffer_T = struct_CommandBuffer_T;
pub const Fence_T = struct_Fence_T;
pub const DeviceMemory_T = struct_DeviceMemory_T;
pub const Event_T = struct_Event_T;
pub const QueryPool_T = struct_QueryPool_T;
pub const BufferView_T = struct_BufferView_T;
pub const ImageView_T = struct_ImageView_T;
pub const ShaderModule_T = struct_ShaderModule_T;
pub const PipelineCache_T = struct_PipelineCache_T;
pub const PipelineLayout_T = struct_PipelineLayout_T;
pub const Pipeline_T = struct_Pipeline_T;
pub const RenderPass_T = struct_RenderPass_T;
pub const DescriptorSetLayout_T = struct_DescriptorSetLayout_T;
pub const Sampler_T = struct_Sampler_T;
pub const DescriptorSet_T = struct_DescriptorSet_T;
pub const DescriptorPool_T = struct_DescriptorPool_T;
pub const Framebuffer_T = struct_Framebuffer_T;
pub const CommandPool_T = struct_CommandPool_T;
pub const SamplerYcbcrConversion_T = struct_SamplerYcbcrConversion_T;
pub const DescriptorUpdateTemplate_T = struct_DescriptorUpdateTemplate_T;
pub const SurfaceKHR_T = struct_SurfaceKHR_T;
pub const SwapchainKHR_T = struct_SwapchainKHR_T;
pub const DisplayKHR_T = struct_DisplayKHR_T;
pub const DisplayModeKHR_T = struct_DisplayModeKHR_T;
pub const DebugReportCallbackEXT_T = struct_DebugReportCallbackEXT_T;
pub const DebugUtilsMessengerEXT_T = struct_DebugUtilsMessengerEXT_T;
pub const ValidationCacheEXT_T = struct_ValidationCacheEXT_T;
pub const AccelerationStructureKHR_T = struct_AccelerationStructureKHR_T;
pub const PerformanceConfigurationINTEL_T = struct_PerformanceConfigurationINTEL_T;
pub const IndirectCommandsLayoutNV_T = struct_IndirectCommandsLayoutNV_T;
pub const PrivateDataSlotEXT_T = struct_PrivateDataSlotEXT_T;
|
src/lib/vulkan.zig
|
const std = @import("std");
const Allocator = std.mem.Allocator;
const INITIAL_BUFFER_LEN = 2*1024;
pub const LineReader = struct {
const Self = @This();
buffer: []u8,
reader: std.fs.File.Reader,
allocator: *Allocator,
nextLineStart: usize,
len: usize,
pub fn init(allocator: *Allocator, reader: std.fs.File.Reader) !Self {
return Self {
.buffer = try allocator.alloc(u8, INITIAL_BUFFER_LEN),
.reader = reader,
.allocator = allocator,
.nextLineStart = 0,
.len = 0,
};
}
pub fn deinit(self: Self) void {
self.allocator.free(self.buffer);
}
pub fn readLine(self: *Self) !?[]const u8 {
var newlineIndex = self.nextLineStart;
while (true) : (newlineIndex += 1) {
if (newlineIndex >= self.len) {
if (self.len == self.buffer.len) {
if (self.nextLineStart==0) {
self.buffer = try self.allocator.realloc(self.buffer, self.buffer.len*2);
} else {
std.mem.copy(u8, self.buffer, self.buffer[self.nextLineStart..self.len]);
self.len -= self.nextLineStart;
newlineIndex -= self.nextLineStart;
self.nextLineStart = 0;
}
}
self.len += try self.reader.read(self.buffer[self.len..]);
}
if (self.len == self.nextLineStart) {
return null;
}
if (newlineIndex >= self.len) {
const line = self.buffer[self.nextLineStart..newlineIndex];
self.nextLineStart = newlineIndex;
return line;
} else if (self.buffer[newlineIndex]=='\n') {
const line = self.buffer[self.nextLineStart..newlineIndex];
self.nextLineStart = newlineIndex+1;
return line;
}
}
}
};
|
src/LineReader.zig
|
const std = @import("std");
usingnamespace @import("kira").log;
const kira_utils = @import("kira").utils;
const kira_glfw = @import("kira").glfw;
const kira_gl = @import("kira").gl;
const kira_window = @import("kira").window;
var window_running = false;
var targetfps: f64 = 1.0 / 60.0;
const vertex_source =
\\#version 330 core
\\layout(location = 0) in vec2 vPos;
\\layout(location = 1) in vec3 vCol;
\\out vec4 outCol;
\\void main() {
\\ gl_Position = vec4(vPos, 0.0, 1.0);
\\ outCol = vec4(vCol, 1.0);
\\}
;
const fragment_source =
\\#version 330 core
\\in vec4 outCol;
\\void main() {
\\ gl_FragColor = outCol;
\\}
;
fn closeCallback(handle: ?*c_void) void {
window_running = false;
}
fn resizeCallback(handle: ?*c_void, w: i32, h: i32) void {
kira_gl.viewport(0, 0, w, h);
}
pub fn main() !void {
try kira_glfw.init();
defer kira_glfw.deinit();
kira_glfw.resizable(false);
kira_glfw.initGLProfile();
var window = kira_window.Info{};
var frametime = kira_window.FrameTime{};
var fps = kira_window.FpsDirect{};
window.title = "Primitive Triangle Example";
window.callbacks.close = closeCallback;
window.callbacks.resize = resizeCallback;
const sw = kira_glfw.getScreenWidth();
const sh = kira_glfw.getScreenHeight();
window.position.x = @divTrunc((sw - window.size.width), 2);
window.position.y = @divTrunc((sh - window.size.height), 2);
try window.create(false);
defer window.destroy() catch unreachable;
kira_glfw.makeContext(window.handle);
kira_glfw.vsync(true);
kira_gl.init();
defer kira_gl.deinit();
var program = try kira_gl.shaderProgramCreate(std.heap.page_allocator, vertex_source, fragment_source);
defer kira_gl.shaderProgramDelete(program);
const vertices = [_]f32{
-0.5, -00.5, 0.0, 1.0, 0.0, 0.0,
00.5, -00.5, 0.0, 0.0, 1.0, 0.0,
00.0, 00.5, 0.0, 0.0, 0.0, 1.0,
};
var vbo: u32 = 0;
var vao: u32 = 0;
kira_gl.vertexArraysGen(1, @ptrCast([*]u32, &vao));
kira_gl.buffersGen(1, @ptrCast([*]u32, &vbo));
{
kira_gl.vertexArrayBind(vao);
kira_gl.bufferBind(kira_gl.BufferType.array, vbo);
defer kira_gl.vertexArrayBind(0);
defer kira_gl.bufferBind(kira_gl.BufferType.array, 0);
kira_gl.bufferData(kira_gl.BufferType.array, @sizeOf(f32) * vertices.len, @ptrCast(?*const c_void, &vertices), kira_gl.DrawType.static);
kira_gl.shaderProgramUse(program);
defer kira_gl.shaderProgramUse(0);
var offset: usize = @sizeOf(f32) * 3;
kira_gl.shaderProgramSetVertexAttribArray(0, true);
kira_gl.shaderProgramSetVertexAttribPointer(0, 3, f32, false, @sizeOf(f32) * 6, null);
kira_gl.shaderProgramSetVertexAttribArray(1, true);
kira_gl.shaderProgramSetVertexAttribPointer(1, 3, f32, false, @sizeOf(f32) * 6, @intToPtr(?*const c_void, offset));
}
window_running = true;
while (window_running) {
frametime.start();
defer {
kira_glfw.sync(window.handle);
kira_glfw.processEvents();
frametime.stop();
frametime.sleep(targetfps);
fps = fps.calculate(frametime);
std.log.notice("FPS: {}", .{fps.fps});
}
kira_gl.clearColour(0.1, 0.1, 0.1, 1.0);
kira_gl.clearBuffers(kira_gl.BufferBit.colour);
kira_gl.shaderProgramUse(program);
kira_gl.vertexArrayBind(vao);
kira_gl.drawArrays(kira_gl.DrawMode.triangles, 0, 3);
}
}
|
examples/primitive-triangle.zig
|
const std = @import("std");
var sqlite3: ?*std.build.LibExeObjStep = null;
fn linkSqlite(b: *std.build.LibExeObjStep) void {
b.linkLibC();
if (sqlite3) |lib| {
b.linkLibrary(lib);
} else {
b.linkSystemLibrary("sqlite3");
}
}
fn getTarget(original_target: std.zig.CrossTarget, bundled: bool) std.zig.CrossTarget {
if (bundled) {
var tmp = original_target;
if (tmp.isGnuLibC()) {
const min_glibc_version = std.builtin.Version{
.major = 2,
.minor = 28,
.patch = 0,
};
if (tmp.glibc_version) |ver| {
if (ver.order(min_glibc_version) == .lt) {
std.debug.panic("sqlite requires glibc version >= 2.28", .{});
}
} else {
tmp.setGnuLibCVersion(2, 28, 0);
}
}
return tmp;
}
return original_target;
}
const TestTarget = struct {
target: std.zig.CrossTarget = @as(std.zig.CrossTarget, .{}),
mode: std.builtin.Mode = .Debug,
single_threaded: bool = false,
bundled: bool,
};
const all_test_targets = switch (std.Target.current.cpu.arch) {
.x86_64 => switch (std.Target.current.os.tag) {
.linux => [_]TestTarget{
TestTarget{
.target = .{},
.bundled = false,
},
TestTarget{
.target = .{
.cpu_arch = .x86_64,
.abi = .musl,
},
.bundled = true,
},
TestTarget{
.target = .{
.cpu_arch = .i386,
.abi = .musl,
},
.bundled = true,
},
TestTarget{
.target = .{
.cpu_arch = .aarch64,
.abi = .musl,
},
.bundled = true,
},
TestTarget{
.target = .{
.cpu_arch = .riscv64,
.abi = .musl,
},
.bundled = true,
},
TestTarget{
.target = .{
.cpu_arch = .mips,
.abi = .musl,
},
.bundled = true,
},
TestTarget{
.target = .{
.cpu_arch = .arm,
.abi = .musleabihf,
},
.bundled = true,
},
},
.windows => [_]TestTarget{
TestTarget{
.target = .{
.cpu_arch = .x86_64,
.abi = .gnu,
},
.bundled = true,
},
TestTarget{
.target = .{
.cpu_arch = .i386,
.abi = .gnu,
},
.bundled = true,
},
},
.freebsd => [_]TestTarget{
TestTarget{
.target = .{},
.bundled = false,
},
TestTarget{
.target = .{
.cpu_arch = .x86_64,
},
.bundled = true,
},
},
.macos => [_]TestTarget{
TestTarget{
.target = .{
.cpu_arch = .x86_64,
},
.bundled = true,
},
},
else => [_]TestTarget{
TestTarget{
.target = .{},
.bundled = false,
},
},
},
else => [_]TestTarget{
TestTarget{
.target = .{},
.bundled = false,
},
},
};
pub fn build(b: *std.build.Builder) void {
const in_memory = b.option(bool, "in_memory", "Should the tests run with sqlite in memory (default true)") orelse true;
const dbfile = b.option([]const u8, "dbfile", "Always use this database file instead of a temporary one");
const use_bundled = b.option(bool, "use_bundled", "Use the bundled sqlite3 source instead of linking the system library (default false)");
const enable_qemu = b.option(bool, "enable_qemu", "Enable qemu for running tests (default false)") orelse false;
const target = b.standardTargetOptions(.{});
const test_targets = if (target.isNative())
&all_test_targets
else
&[_]TestTarget{.{
.target = target,
.bundled = use_bundled orelse false,
}};
const test_step = b.step("test", "Run library tests");
for (test_targets) |test_target| {
const bundled = use_bundled orelse test_target.bundled;
const cross_target = getTarget(test_target.target, bundled);
const tests = b.addTest("sqlite.zig");
if (bundled) {
const lib = b.addStaticLibrary("sqlite", null);
lib.addCSourceFile("c/sqlite3.c", &[_][]const u8{"-std=c99"});
lib.linkLibC();
lib.setTarget(cross_target);
lib.setBuildMode(test_target.mode);
sqlite3 = lib;
}
const lib = b.addStaticLibrary("zig-sqlite", "sqlite.zig");
lib.addIncludeDir("c");
linkSqlite(lib);
lib.setTarget(cross_target);
lib.setBuildMode(test_target.mode);
const single_threaded_txt = if (test_target.single_threaded) "single" else "multi";
tests.setNamePrefix(b.fmt("{s}-{s}-{s} ", .{
cross_target.zigTriple(b.allocator),
@tagName(test_target.mode),
single_threaded_txt,
}));
tests.single_threaded = test_target.single_threaded;
tests.setBuildMode(test_target.mode);
tests.setTarget(cross_target);
tests.addIncludeDir("c");
linkSqlite(tests);
tests.enable_qemu = enable_qemu;
const tests_options = b.addOptions();
tests.addOptions("build_options", tests_options);
tests_options.addOption(bool, "in_memory", in_memory);
tests_options.addOption(?[]const u8, "dbfile", dbfile);
test_step.dependOn(&tests.step);
}
}
|
build.zig
|
bytes: []const u8,
index: usize = 0,
line: usize = 0,
column: usize = 0,
state: State = .start,
/// This field is populated when `next` returns a `Token` with `Token.Tag.invalid`.
error_note: ErrorNote = undefined,
pub const Token = struct {
tag: Tag,
bytes: []const u8,
pub const Tag = enum {
/// Error tokenizing the XML. Details can be found at the line, column,
/// and error_note field.
invalid,
/// Example: "xml".
/// Possible next tags:
/// * `attr_key`
/// * `attr_value`
/// * `tag_open`
doctype,
/// Example: "<head>"
/// Possible next tags:
/// * `attr_key`
/// * `tag_open`
/// * `tag_close`
/// * `content`
tag_open,
/// Example: "</head>"
/// Possible next tags:
/// * `tag_open`
/// * `tag_close`
/// * `content`
tag_close,
/// Emitted for empty nodes such as "<head/>".
/// `bytes` will contain the "/".
/// Possible next tags:
/// * `tag_open`
/// * `tag_close`
/// * `content`
tag_close_empty,
/// Only the name of the key, does not include the '=' or the value.
/// Possible next tags:
/// * `attr_value`
attr_key,
/// Exactly the bytes of the string, including the quotes. Does no decoding.
/// Possible next tags:
/// * `attr_key`
/// * `tag_open`
/// * `tag_close`
/// * `content`
attr_value,
/// The data between tags. Exactly the bytes, does no decoding.
/// Possible next tags:
/// * `tag_open`
/// * `tag_close`
content,
/// End of file was reached.
eof,
};
};
pub const ErrorNote = enum {
invalid_byte,
};
pub fn next(xml: *Xml) Token {
var tok_start: usize = undefined;
while (xml.index < xml.bytes.len) {
const byte = xml.bytes[xml.index];
switch (xml.state) {
.start => switch (byte) {
' ', '\t', '\r', '\n' => {},
'<' => xml.state = .doctype_q,
else => return xml.fail(.invalid_byte),
},
.doctype_q => switch (byte) {
' ', '\t', '\r', '\n' => {},
'?' => xml.state = .doctype_name_start,
else => return xml.fail(.invalid_byte),
},
.doctype_name_start => switch (byte) {
' ', '\t', '\r', '\n' => {},
'>', '<' => return xml.fail(.invalid_byte),
else => {
tok_start = xml.index;
xml.state = .doctype_name;
},
},
.doctype_name => switch (byte) {
' ', '\t', '\r', '\n' => return xml.emit(.doctype, .{
.tag = .doctype,
.bytes = xml.bytes[tok_start..xml.index],
}),
'?' => return xml.emit(.doctype_end, .{
.tag = .doctype,
.bytes = xml.bytes[tok_start..xml.index],
}),
'>', '<' => return xml.fail(.invalid_byte),
else => {},
},
.doctype => switch (byte) {
' ', '\t', '\r', '\n' => {},
'?' => xml.state = .doctype_end,
'<', '>' => return xml.fail(.invalid_byte),
else => {
tok_start = xml.index;
xml.state = .doctype_attr_key;
},
},
.doctype_attr_key => switch (byte) {
'=' => return xml.emit(.doctype_attr_value_q, .{
.tag = .attr_key,
.bytes = xml.bytes[tok_start..xml.index],
}),
'?', '<', '>' => return xml.fail(.invalid_byte),
else => {},
},
.doctype_attr_value_q => switch (byte) {
'"' => {
xml.state = .doctype_attr_value;
tok_start = xml.index;
},
else => return xml.fail(.invalid_byte),
},
.doctype_attr_value => switch (byte) {
'"' => return xml.emit(.doctype, .{
.tag = .attr_value,
.bytes = xml.bytes[tok_start .. xml.index + 1],
}),
'\n' => return xml.fail(.invalid_byte),
else => {},
},
.doctype_end => switch (byte) {
'>' => xml.state = .body,
else => return xml.fail(.invalid_byte),
},
.body => switch (byte) {
' ', '\t', '\r', '\n' => {},
'<' => xml.state = .tag_name_start,
else => {
xml.state = .content;
tok_start = xml.index;
},
},
.content => switch (byte) {
'<' => return xml.emit(.tag_name_start, .{
.tag = .content,
.bytes = xml.bytes[tok_start..xml.index],
}),
else => {},
},
.tag_name_start => switch (byte) {
' ', '\t', '\r', '\n' => {},
'>', '<' => return xml.fail(.invalid_byte),
'/' => xml.state = .tag_close_start,
else => {
tok_start = xml.index;
xml.state = .tag_name;
},
},
.tag_close_start => switch (byte) {
' ', '\t', '\r', '\n' => {},
'>', '<' => return xml.fail(.invalid_byte),
else => {
tok_start = xml.index;
xml.state = .tag_close_name;
},
},
.tag_close_name => switch (byte) {
' ', '\t', '\r', '\n' => return xml.emit(.tag_close_b, .{
.tag = .tag_open,
.bytes = xml.bytes[tok_start..xml.index],
}),
'>' => return xml.emit(.body, .{
.tag = .tag_close,
.bytes = xml.bytes[tok_start..xml.index],
}),
'<' => return xml.fail(.invalid_byte),
else => {},
},
.tag_close_b => switch (byte) {
' ', '\t', '\r', '\n' => {},
'>' => xml.state = .body,
else => return xml.fail(.invalid_byte),
},
.tag_name => switch (byte) {
' ', '\t', '\r', '\n' => return xml.emit(.tag, .{
.tag = .tag_open,
.bytes = xml.bytes[tok_start..xml.index],
}),
'>' => return xml.emit(.body, .{
.tag = .tag_open,
.bytes = xml.bytes[tok_start..xml.index],
}),
'<' => return xml.fail(.invalid_byte),
else => {},
},
.tag => switch (byte) {
' ', '\t', '\r', '\n' => {},
'<' => return xml.fail(.invalid_byte),
'>' => xml.state = .body,
'/' => {
tok_start = xml.index;
xml.state = .tag_end_empty;
},
else => {
tok_start = xml.index;
xml.state = .tag_attr_key;
},
},
.tag_end_empty => switch (byte) {
'>' => return xml.emit(.body, .{
.tag = .tag_close_empty,
.bytes = xml.bytes[tok_start..xml.index],
}),
else => return xml.fail(.invalid_byte),
},
.tag_attr_key => switch (byte) {
'=' => return xml.emit(.tag_attr_value_q, .{
.tag = .attr_key,
.bytes = xml.bytes[tok_start..xml.index],
}),
'<', '>' => return xml.fail(.invalid_byte),
else => {},
},
.tag_attr_value_q => switch (byte) {
'"' => {
xml.state = .tag_attr_value;
tok_start = xml.index;
},
else => return xml.fail(.invalid_byte),
},
.tag_attr_value => switch (byte) {
'"' => return xml.emit(.tag, .{
.tag = .attr_value,
.bytes = xml.bytes[tok_start .. xml.index + 1],
}),
'\n' => return xml.fail(.invalid_byte),
else => {},
},
}
xml.advanceCursor();
}
return .{
.tag = .eof,
.bytes = xml.bytes[xml.bytes.len..],
};
}
const Xml = @This();
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const State = enum {
start,
doctype_q,
doctype_name,
doctype_name_start,
doctype,
doctype_attr_key,
doctype_attr_value_q,
doctype_attr_value,
doctype_end,
body,
content,
tag_name_start,
tag_name,
tag,
tag_attr_key,
tag_attr_value_q,
tag_attr_value,
tag_close_start,
tag_close_name,
tag_close_b,
tag_end_empty,
};
fn fail(xml: *Xml, note: ErrorNote) Token {
xml.error_note = note;
return .{ .tag = .invalid, .bytes = xml.bytes[xml.index..][0..0] };
}
fn emit(xml: *Xml, next_state: State, token: Token) Token {
xml.state = next_state;
xml.advanceCursor();
return token;
}
fn advanceCursor(xml: *Xml) void {
const byte = xml.bytes[xml.index];
xml.index += 1;
if (byte == '\n') {
xml.line += 1;
xml.column = 0;
} else {
xml.column += 1;
}
}
test "hello world xml" {
const bytes =
\\<?xml version="1.0" encoding="UTF-8"?>
\\<map></map>
;
var xml: Xml = .{ .bytes = bytes };
try testExpect(&xml, .doctype, "xml");
try testExpect(&xml, .attr_key, "version");
try testExpect(&xml, .attr_value, "\"1.0\"");
try testExpect(&xml, .attr_key, "encoding");
try testExpect(&xml, .attr_value, "\"UTF-8\"");
try testExpect(&xml, .tag_open, "map");
try testExpect(&xml, .tag_close, "map");
try testExpect(&xml, .eof, "");
try testExpect(&xml, .eof, "");
}
test "some props" {
const bytes =
\\<?xml?>
\\<map>
\\ <properties>
\\ <property name="gravity" type="float" value="12.34"/>
\\ <property name="never gonna give you up" type="bool" value="true"/>
\\ <property name="never gonna let you down" type="bool" value="true"/>
\\ </properties>
\\</map>
;
var xml: Xml = .{ .bytes = bytes };
try testExpect(&xml, .doctype, "xml");
try testExpect(&xml, .tag_open, "map");
try testExpect(&xml, .tag_open, "properties");
try testExpect(&xml, .tag_open, "property");
try testExpect(&xml, .attr_key, "name");
try testExpect(&xml, .attr_value, "\"gravity\"");
try testExpect(&xml, .attr_key, "type");
try testExpect(&xml, .attr_value, "\"float\"");
try testExpect(&xml, .attr_key, "value");
try testExpect(&xml, .attr_value, "\"12.34\"");
try testExpect(&xml, .tag_close_empty, "/");
try testExpect(&xml, .tag_open, "property");
try testExpect(&xml, .attr_key, "name");
try testExpect(&xml, .attr_value, "\"never gonna give you up\"");
try testExpect(&xml, .attr_key, "type");
try testExpect(&xml, .attr_value, "\"bool\"");
try testExpect(&xml, .attr_key, "value");
try testExpect(&xml, .attr_value, "\"true\"");
try testExpect(&xml, .tag_close_empty, "/");
try testExpect(&xml, .tag_open, "property");
try testExpect(&xml, .attr_key, "name");
try testExpect(&xml, .attr_value, "\"never gonna let you down\"");
try testExpect(&xml, .attr_key, "type");
try testExpect(&xml, .attr_value, "\"bool\"");
try testExpect(&xml, .attr_key, "value");
try testExpect(&xml, .attr_value, "\"true\"");
try testExpect(&xml, .tag_close_empty, "/");
try testExpect(&xml, .tag_close, "properties");
try testExpect(&xml, .tag_close, "map");
try testExpect(&xml, .eof, "");
}
fn testExpect(xml: *Xml, tag: Token.Tag, bytes: []const u8) !void {
const tok = xml.next();
try testing.expectEqual(tag, tok.tag);
try testing.expectEqualStrings(bytes, tok.bytes);
}
pub fn main() !void {
var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_state.deinit();
const arena = arena_state.allocator();
const args = try std.process.argsAlloc(arena);
const input_file = args[1];
const max_bytes = std.math.maxInt(u32);
var xml: Xml = .{ .bytes = try std.fs.cwd().readFileAlloc(arena, input_file, max_bytes) };
var bw = std.io.bufferedWriter(std.io.getStdOut().writer());
const writer = bw.writer();
while (true) {
const token = xml.next();
try writer.print("{s}: {s}\n", .{ @tagName(token.tag), token.bytes });
if (token.tag == .eof) break;
}
try bw.flush();
}
|
Xml.zig
|
const FMS = @This();
const std = @import("std");
const mem = std.mem;
const testing = std.testing;
const Allocator = std.mem.Allocator;
const format = @import("../format.zig");
const testutil = @import("../test.zig");
const time = @import("../time.zig");
const FlightPlan = @import("../FlightPlan.zig");
const Route = @import("../Route.zig");
const Waypoint = @import("../Waypoint.zig");
const Error = @import("../Error.zig");
const ErrorSet = Error.Set;
test {
_ = Binding;
_ = Reader;
_ = Writer;
}
/// The Format type that can be used with the generic functions on FlightPlan.
/// You can also call the direct functions in this file.
pub const Format = format.Format(FMS);
/// Binding are the C bindings for this format.
pub const Binding = struct {
const binding = @import("../binding.zig");
const c_allocator = std.heap.c_allocator;
export fn fpl_xplane11_write_to_file(raw: ?*FlightPlan, path: [*:0]const u8) c_int {
const fpl = raw orelse return -1;
Format.writeToFile(mem.sliceTo(path, 0), fpl) catch return -1;
return 0;
}
};
/// Reader implementation (see format.zig)
/// TODO
pub const Reader = struct {
pub fn initFromFile(alloc: Allocator, path: [:0]const u8) !FlightPlan {
_ = alloc;
_ = path;
return ErrorSet.Unimplemented;
}
};
/// Writer implementation (see format.zig)
pub const Writer = struct {
pub fn writeTo(writer: anytype, fpl: *const FlightPlan) !void {
// Buffer that might be used for string operations.
// Ensure this is always big enough.
var buf: [8]u8 = undefined;
// Header
try writer.writeAll("I\n");
try writer.writeAll("1100 Version\n");
// Determine our AIRAC cycle. We try to use the airac cycle
// on the flight plan. If that's not set, we just make
// one up based on the current year. Waypoints don't change
// often and flightplan validation will find this error so
// if the user got here they are okay with defaults.
if (fpl.airac) |v| {
try writer.print("CYCLE {s}\n", .{v});
} else {
const t = time.c.time(null);
const tm = time.c.localtime(&t).*;
const v = try std.fmt.bufPrintZ(&buf, "{d}01", .{
// we want years since 2000
tm.tm_year - 100,
});
try writer.print("CYCLE {s}\n", .{v});
}
// Departure
if (fpl.departure) |dep| {
// Departure airport. If we have departure info set then we use that.
try writeDeparture(writer, fpl, dep.identifier);
// Write additional departure info
try writeDepartureProc(writer, fpl);
} else if (fpl.route.points.items.len > 0) {
// No departure info set, we just try to use the first route.
const point = &fpl.route.points.items[0];
try writeDeparture(writer, fpl, point.identifier);
} else {
// No route
return ErrorSet.RequiredValueMissing;
}
// Destination
if (fpl.destination) |des| {
// Departure airport. If we have departure info set then we use that.
try writeDestination(writer, fpl, des.identifier);
// Write additional departure info
try writeDestinationProc(writer, fpl);
} else if (fpl.route.points.items.len > 0) {
// No departure info set, we just try to use the first route.
const point = &fpl.route.points.items[fpl.route.points.items.len - 1];
try writeDestination(writer, fpl, point.identifier);
} else {
// No route
return ErrorSet.RequiredValueMissing;
}
// Route
try writeRoute(writer, fpl);
}
fn writeDeparture(writer: anytype, fpl: *const FlightPlan, id: []const u8) !void {
// Get the waypoint associated with the departure ID so we can
// determine the type.
const wp = fpl.waypoints.get(id) orelse
return ErrorSet.RouteMissingWaypoint;
// Prefix we use depends if departure is an airport or not.
const prefix = switch (wp.type) {
.airport => "ADEP",
else => "DEP",
};
try writer.print("{s} {s}\n", .{ prefix, wp.identifier });
}
fn writeDepartureProc(writer: anytype, fpl: *const FlightPlan) !void {
var buf: [8]u8 = undefined;
const dep = fpl.departure.?;
if (dep.runway) |rwy| try writer.print("DEPRWY RW{s}\n", .{
try rwy.toString(&buf),
});
if (dep.sid) |v| {
try writer.print("SID {s}\n", .{v});
if (dep.transition) |transition|
try writer.print("SIDTRANS {s}\n", .{transition});
}
}
fn writeDestination(writer: anytype, fpl: *const FlightPlan, id: []const u8) !void {
// Get the waypoint associated with the ID so we can determine the type.
const wp = fpl.waypoints.get(id) orelse
return ErrorSet.RouteMissingWaypoint;
// Prefix we use depends if departure is an airport or not.
const prefix = switch (wp.type) {
.airport => "ADES",
else => "DES",
};
try writer.print("{s} {s}\n", .{ prefix, wp.identifier });
}
fn writeDestinationProc(writer: anytype, fpl: *const FlightPlan) !void {
var buf: [8]u8 = undefined;
const des = fpl.destination.?;
if (des.runway) |rwy| try writer.print("DESRWY RW{s}\n", .{
try rwy.toString(&buf),
});
if (des.star) |v| {
try writer.print("STAR {s}\n", .{v});
if (des.star_transition) |transition|
try writer.print("STARTRANS {s}\n", .{transition});
}
if (des.approach) |v| {
try writer.print("APP {s}\n", .{v});
if (des.approach_transition) |transition|
try writer.print("APPTRANS {s}\n", .{transition});
}
}
fn writeRoute(writer: anytype, fpl: *const FlightPlan) !void {
try writer.print("NUMENR {d}\n", .{fpl.route.points.items.len});
for (fpl.route.points.items) |point, i| {
const wp = fpl.waypoints.get(point.identifier) orelse return ErrorSet.RouteMissingWaypoint;
const typeCode: u8 = switch (wp.type) {
.airport => 1,
.ndb => 2,
.vor => 3,
.int => 11,
.int_vrp => 11,
.user_waypoint => 28,
};
// Get our "via" value for XPlane. If this isn't set, we try to
// determine it based on what kind of route point this is.
const via = point.via orelse blk: {
if (i == 0 and wp.type == .airport) {
// First route, airport => departure airport
break :blk Route.Point.Via{ .airport_departure = {} };
} else if (i == fpl.route.points.items.len - 1 and wp.type == .airport) {
// Last route, airport => destination airport
break :blk Route.Point.Via{ .airport_destination = {} };
} else {
// Anything else, we go direct
break :blk Route.Point.Via{ .direct = {} };
}
};
// Convert the Via tagged union to the string value xplane expects
const viaString = switch (via) {
.airport_departure => "ADEP",
.airport_destination => "ADES",
.direct => "DRCT",
.airway => |v| v,
};
try writer.print("{d} {s} {s} {d} {d} {d}\n", .{
typeCode,
wp.identifier,
viaString,
point.altitude,
wp.lat,
wp.lon,
});
}
}
test "read Garmin FPL, write X-Plane" {
const Garmin = @import("garmin.zig");
const testPath = try testutil.testFile("basic.fpl");
var plan = try Garmin.Format.initFromFile(testing.allocator, testPath);
defer plan.deinit();
// Write the plan and compare
var output = std.ArrayList(u8).init(testing.allocator);
defer output.deinit();
// Write
try Writer.writeTo(output.writer(), &plan);
// Debug, write output to compare
// std.debug.print("write:\n\n{s}\n", .{output.items});
// TODO: re-read to verify it parses
}
};
|
src/format/xplane_fms_11.zig
|
const std = @import("std");
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const Value = @import("./value.zig").Value;
pub const OpCode = enum(u8) {
Return,
Pop,
GetLocal,
SetLocal,
GetGlobal,
DefineGlobal,
SetGlobal,
GetUpvalue,
SetUpvalue,
GetProperty,
SetProperty,
GetSuper,
Print,
Jump,
JumpIfFalse,
Loop,
Call,
Invoke,
SuperInvoke,
Closure,
CloseUpvalue,
Class,
Inherit,
Method,
Constant,
Nil,
True,
False,
Equal,
Greater,
Less,
Negate,
Add,
Subtract,
Multiply,
Divide,
Not,
};
pub const Chunk = struct {
code: ArrayList(u8),
constants: ArrayList(Value),
lines: ArrayList(usize),
pub fn init(allocator: *Allocator) Chunk {
return Chunk{
.code = ArrayList(u8).init(allocator),
.constants = ArrayList(Value).init(allocator),
.lines = ArrayList(usize).init(allocator),
};
}
pub fn deinit(self: *Chunk) void {
self.code.deinit();
self.constants.deinit();
self.lines.deinit();
}
pub fn write(self: *Chunk, byte: u8, line: usize) !void {
try self.code.append(byte);
try self.lines.append(line);
}
pub fn writeOp(self: *Chunk, op: OpCode, line: usize) !void {
try self.write(@enumToInt(op), line);
}
pub fn addConstant(self: *Chunk, value: Value) !u9 {
const index = @intCast(u9, self.constants.items.len);
try self.constants.append(value);
return index;
}
pub fn disassemble(self: *Chunk, name: []const u8) void {
std.debug.warn("== {} ==\n", .{name});
var i: usize = 0;
while (i < self.code.items.len) {
i = self.disassembleInstruction(i);
}
}
pub fn disassembleInstruction(self: *Chunk, offset: usize) usize {
// Print offset
std.debug.warn("{:0>4} ", .{offset});
// Print line
if (offset > 0 and self.lines.items[offset] == self.lines.items[offset - 1]) {
std.debug.warn(" | ", .{});
} else {
std.debug.warn("{: >4} ", .{self.lines.items[offset]});
}
// Print instruction
const instruction = @intToEnum(OpCode, self.code.items[offset]);
return switch (instruction) {
.Return => self.simpleInstruction("OP_RETURN", offset),
.Pop => self.simpleInstruction("OP_POP", offset),
.GetLocal => self.byteInstruction("OP_GET_LOCAl", offset),
.SetLocal => self.byteInstruction("OP_SET_LOCAL", offset),
.GetGlobal => self.constantInstruction("OP_GET_GLOBAL", offset),
.DefineGlobal => self.constantInstruction("OP_DEFINE_GLOBAL", offset),
.SetGlobal => self.constantInstruction("OP_SET_GLOBAL", offset),
.GetUpvalue => self.byteInstruction("OP_GET_UPVALUE", offset),
.SetUpvalue => self.byteInstruction("OP_SET_UPVALUE", offset),
.GetProperty => self.constantInstruction("OP_GET_PROPERTY", offset),
.SetProperty => self.constantInstruction("OP_SET_PROPERTY", offset),
.GetSuper => self.constantInstruction("OP_GET_SUPER", offset),
.Print => self.simpleInstruction("OP_PRINT", offset),
.Jump => self.jumpInstruction("OP_JUMP", 1, offset),
.JumpIfFalse => self.jumpInstruction("OP_JUMP_IF_FALSE", 1, offset),
.Loop => self.jumpInstruction("OP_LOOP", -1, offset),
.Call => self.byteInstruction("OP_CALL", offset),
.Invoke => self.invokeInstruction("OP_INVOKE", offset),
.SuperInvoke => self.invokeInstruction("OP_SUPER_INVOKE", offset),
.Closure => self.closureInstruction("OP_CLOSURE", offset),
.CloseUpvalue => self.simpleInstruction("OP_CLOSE_UPVALUE", offset),
.Class => self.constantInstruction("OP_CLASS", offset),
.Inherit => self.constantInstruction("OP_INHERIT", offset),
.Method => self.constantInstruction("OP_METHOD", offset),
.Constant => self.constantInstruction("OP_CONSTANT", offset),
.Nil => self.simpleInstruction("OP_NIL", offset),
.True => self.simpleInstruction("OP_TRUE", offset),
.False => self.simpleInstruction("OP_FALSE", offset),
.Equal => self.simpleInstruction("OP_EQUAL", offset),
.Greater => self.simpleInstruction("OP_GREATER", offset),
.Less => self.simpleInstruction("OP_LESS", offset),
.Negate => self.simpleInstruction("OP_NEGATE", offset),
.Add => self.simpleInstruction("OP_ADD", offset),
.Subtract => self.simpleInstruction("OP_SUBTRACT", offset),
.Multiply => self.simpleInstruction("OP_MULTIPLY", offset),
.Divide => self.simpleInstruction("OP_DIVIDE", offset),
.Not => self.simpleInstruction("OP_NOT", offset),
};
}
fn simpleInstruction(self: *Chunk, name: []const u8, offset: usize) usize {
std.debug.warn("{}\n", .{name});
return offset + 1;
}
fn constantInstruction(self: *Chunk, name: []const u8, offset: usize) usize {
const constant = self.code.items[offset + 1];
std.debug.warn("{} {} {}\n", .{ name, constant, self.constants.items[constant]});
std.debug.warn("\n", .{});
return offset + 2;
}
fn byteInstruction(self: *Chunk, name: []const u8, offset: usize) usize {
const slot: u8 = self.code.items[offset + 1];
// TODO, book makes more effort on formatting here, see Chap 22.4
std.debug.warn("{} {}\n", .{ name, slot });
return offset + 2;
}
fn jumpInstruction(self: *Chunk, name: []const u8, sign: isize, offset: usize) usize {
var jump = @intCast(u16, self.code.items[offset + 1]) << 8;
jump |= self.code.items[offset + 2];
const target = @intCast(isize, offset) + 3 + sign * @intCast(isize, jump);
std.debug.warn("{} {} -> {}\n", .{ name, offset, target });
return offset + 3;
}
fn closureInstruction(self: *Chunk, name: []const u8, initialOffset: usize) usize {
var offset = initialOffset + 1;
const constant = self.code.items[offset];
offset += 1;
std.debug.warn("{} {} {}\n", .{ name, constant, self.constants.items[constant] });
// Disassemble upvalues
const function = self.constants.items[constant].asObj().asFunction();
var i: usize = 0;
while (i < function.upvalueCount) : (i += 1) {
const isLocal = self.code.items[offset] != 1;
const valueType = if (isLocal) "local" else "upvalue";
offset += 1;
const index = self.code.items[offset];
offset += 1;
std.debug.warn("{} | {} {}\n", .{ offset - 2, valueType, index });
}
return offset;
}
fn invokeInstruction(self: *Chunk, name: []const u8, offset: usize) usize {
const constant = self.code.items[offset + 1];
const argCount = self.code.items[offset + 2];
std.debug.warn("{} ({} args) {} '{}'\n'", .{ name, argCount, constant, self.constants.items[constant] });
return offset + 3;
}
};
|
src/chunk.zig
|
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const print = stdout.print;
const prompt = @import("prompt.zig");
const os = std.os;
const fmt = std.fmt;
const repo_status = @import("repo_status/repo_status.zig");
const C = prompt.C;
fn is_remote() bool {
var tty = os.getenv("SSH_TTY");
var client = os.getenv("SSH_CLIENT");
return tty != null or client != null;
}
fn access(pth: []const u8, flags: std.fs.File.OpenFlags) !void {
try std.fs.cwd().access(pth, flags);
}
fn fileExists(pth: []const u8) bool {
access(pth, .{}) catch return false;
return true;
}
fn is_writeable(pth: []const u8) bool {
access(pth, .{ .write = true }) catch return false;
return true;
}
fn is_docker() bool {
return fileExists("/.dockerenv");
}
fn is_not_local() bool {
return is_remote() or is_docker();
}
pub fn is_local() bool {
return !is_not_local();
}
pub fn is_su() bool {
var usr = os.getenv("USER") orelse "";
var logname = os.getenv("LOGNAME") orelse "";
return !std.mem.eql(u8, usr, logname);
}
pub fn is_root() bool {
var euid_str = os.getenv("EUID") orelse "1000";
var euid = fmt.parseInt(u32, euid_str, 10) catch 1000;
return euid == 0;
}
fn run(argv: []const []const u8) ![]const u8 {
const result = try std.ChildProcess.exec(.{
.allocator = prompt.A,
.argv = argv,
});
return std.mem.trim(u8, result.stdout, " \n");
}
pub fn prefix() !void {
var p = os.getenv("PROMPT_PREFIX") orelse "";
try print("{s}", .{p});
}
// report if the session is being recorded
pub fn script() !void {
const E = prompt.E;
if (os.getenv("SCRIPT")) |s| {
try print("{s}{s}{s}{s}{s}{s}{s}", .{ E.o, C.white, E.c, s, E.o, C.reset, E.c });
}
}
// tab - https://github.com/austinjones/tab-rs
pub fn tab() !void {
const E = prompt.E;
if (os.getenv("TAB")) |t| {
try print("[{s}{s}{s}{s}{s}{s}{s}]", .{ E.o, C.green, E.c, t, E.o, C.reset, E.c });
}
}
// screen/tmux status
pub fn screen() !void {
const E = prompt.E;
const term = os.getenv("TERM") orelse "";
const tmux = os.getenv("TMUX") orelse "";
var scr: []const u8 = undefined;
var name: []const u8 = undefined;
var window: []const u8 = undefined;
if (!std.mem.eql(u8, term, "") and std.mem.eql(u8, term[0..6], "screen")) {
// figure out whether 'screen' or 'tmux'
if (!std.mem.eql(u8, tmux, "")) {
scr = "tmux";
name = try run(&[_][]const u8{ "tmux", "display-message", "-p", "#S" });
window = try run(&[_][]const u8{ "tmux", "display-message", "-p", "#I" });
} else { // screen
scr = "screen";
name = os.getenv("STY") orelse "";
window = os.getenv("WINDOW") orelse "";
}
try print("[{s}{s}{s}{s}{s}{s}{s}:{s}{s}{s}{s}{s}{s}{s}:{s}{s}{s}{s}{s}{s}{s}]", .{
E.o, C.green, E.c, scr, E.o, C.reset, E.c,
E.o, C.blue, E.c, name, E.o, C.reset, E.c,
E.o, C.magenta, E.c, window, E.o, C.reset, E.c,
});
}
}
pub inline fn is_env_true(env_name: []const u8) bool {
return parseZero(os.getenv(env_name)) != 0;
}
// virtual env
pub fn venv() !void {
// example environment variable set in a venv:
// VIRTUAL_ENV=/Users/kbd/.local/share/virtualenvs/pipenvtest-vxNzUMMM
const E = prompt.E;
if (os.getenv("VIRTUAL_ENV")) |v| {
if (is_env_true("PROMPT_FULL_VENV")) {
var name = std.fs.path.basename(v);
try print("[{s}{s}{s}{s}{s}{s}{s}{s}]", .{ E.o, C.green, E.c, "🐍", name, E.o, C.reset, E.c });
} else {
try print("🐍", .{});
}
}
}
pub fn date() !void {} // eh, seems unnecessary bc iterm2 timestamps
pub fn user() !void {
const E = prompt.E;
var color: []const u8 = C.green;
if (is_root()) {
color = C.red;
} else if (is_su()) {
color = try fmt.allocPrint(prompt.A, "{s}{s}", .{ C.bold, C.yellow });
}
var u = os.getenv("USER");
try print("{s}{s}{s}{s}{s}{s}{s}", .{ E.o, color, E.c, u, E.o, C.reset, E.c });
}
pub fn at() !void {
const E = prompt.E;
// show the @ in red if not local
if (is_remote()) {
try print("{s}{s}{s}{s}{s}{s}{s}{s}", .{ E.o, C.red, C.bold, E.c, "@", E.o, C.reset, E.c });
} else {
try print("@", .{});
}
}
pub fn host() !void {
const E = prompt.E;
var buf: [os.HOST_NAME_MAX]u8 = undefined;
_ = std.heap.FixedBufferAllocator.init(&buf);
var h: []const u8 = try os.gethostname(&buf);
if (!is_env_true("PROMPT_FULL_HOST")) {
h = std.mem.split(h, ".").next().?;
}
try print("{s}{s}{s}{s}{s}{s}{s}", .{ E.o, C.blue, E.c, h, E.o, C.reset, E.c });
}
/// separator - C.red if cwd unwritable
pub fn sep() !void {
try print(":", .{});
}
/// horizortal rule
pub fn hr() !void {
var columns = parseZero(os.getenv("PROMPT_HR"));
while (columns > 0) {
try print("─", .{});
columns -= 1;
}
}
pub fn path() !void {
const E = prompt.E;
const cwd = prompt.CWD;
var color = try fmt.allocPrint(prompt.A, "{s}{s}", .{ C.bright_magenta, C.bold });
if (!is_writeable(cwd)) {
color = try fmt.allocPrint(prompt.A, "{s}{s}", .{ color, C.underline });
}
const p = os.getenv("PROMPT_PATH") orelse cwd;
try print("{s}{s}{s}{s}{s}{s}{s}", .{ E.o, color, E.c, p, E.o, C.reset, E.c });
}
// source control information
pub fn repo() !void {
const E = prompt.E;
const cwd = prompt.CWD;
repo_status.A = prompt.A; // use my allocator
if (!repo_status.isGitRepo(cwd))
return;
try print("[", .{});
var status = try repo_status.getFullRepoStatus(cwd);
// convert to repo_status's version of Escapes, unify in library later
var escapes = repo_status.Escapes.init(E.o, E.c);
try repo_status.writeStatusStr(escapes, status);
try print("]", .{});
}
pub inline fn parseZero(val: ?[]const u8) u32 {
// get an int value out of the string, one way or another, defaulting to 0
return fmt.parseInt(u32, val orelse "0", 10) catch 0;
}
// running and stopped jobs
pub fn jobs() !void {
const A = prompt.A;
const E = prompt.E;
const prompt_jobs = os.getenv("PROMPT_JOBS") orelse "0 0";
var iter = std.mem.split(prompt_jobs, " ");
const running = parseZero(iter.next());
const suspended = parseZero(iter.next());
var j: []u8 = "";
if (running > 0) {
// '&'' for "background"
j = try fmt.allocPrint(A, "{s}{s}{s}{}&{s}{s}{s}", .{ E.o, C.green, E.c, running, E.o, C.reset, E.c });
}
if (suspended > 0) {
if (!std.mem.eql(u8, j, "")) {
// separate running/suspended jobs with colon
j = try fmt.allocPrint(A, "{s}:", .{j});
}
// 'z' for 'ctrl+z' to indicate "suspended"
j = try fmt.allocPrint(A, "{s}{s}{s}{s}{}z{s}{s}{s}", .{ j, E.o, C.red, E.c, suspended, E.o, C.reset, E.c });
}
if (!std.mem.eql(u8, j, "")) {
try print("[{s}]", .{j});
}
}
pub fn direnv() !void {
const E = prompt.E;
if (os.getenv("DIRENV_DIR")) |d| {
try print("{s}{s}{s}{s}{s}{s}{s}", .{ E.o, C.blue, E.c, "‡", E.o, C.reset, E.c });
}
}
pub fn char() !void {
const E = prompt.E;
var code = parseZero(os.getenv("PROMPT_RETURN_CODE"));
var c = if (is_root()) "#" else "$";
if (code == 0) {
try print("{s}{s}{s}{s}", .{ E.o, C.green, E.c, c });
} else {
try print("{s}{s}{s}{s}:{}", .{ E.o, C.red, E.c, c, code });
}
try print("{s}{s}{s} ", .{ E.o, C.reset, E.c });
}
pub fn newline_if(env_name: []const u8) !void {
if (is_env_true(env_name)) {
try print("\n", .{});
}
}
|
funcs.zig
|
const std = @import("std");
const print = std.debug.print;
pub fn showType(comptime T: type, only_pub: bool) void {
const info = @typeInfo(T);
switch (info) {
.Type => print("type \n\r", .{}),
.Void => print("void \n\r", .{}),
.Bool => print("bool \n\r", .{}),
.NoReturn => print("noReturn\n\r", .{}),
.Int => print("int \n\r", .{}),
.Float => print("float\n\r", .{}),
.Pointer => print("pointer \n\r", .{}),
.Array => print("array \n\r", .{}),
.Struct => {
print("{s} = struct {{\n\r", .{@typeName(T)});
if (info.Struct.fields.len > 0) {
print(" fields {s}\n\r", .{ @TypeOf(info.Struct.fields) });
inline for (info.Struct.fields) |field| {
print(" {s}: {s}\n\r", .{ field.name, @typeName(field.field_type) });
}
}
if (info.Struct.decls.len > 0) {
inline for (info.Struct.decls) |decl| {
switch (decl.data) {
.Type => if (only_pub and decl.is_pub) print(" {s} {s}\n\r", .{ if (decl.is_pub) "pub" else " ", decl.name }),
.Var => if (only_pub and decl.is_pub) print(" {s} {s}\n\r", .{ if (decl.is_pub) "pub" else " ", decl.name }),
.Fn => if (only_pub and decl.is_pub) {
print(" {s} {s} {s}\n\r", .{ if (decl.is_pub) "pub" else " ", decl.name , decl.data.Fn.fn_type });
if (decl.data.Fn.is_noinline) print(" noinline\n\r", .{});
if (decl.data.Fn.is_var_args) print(" var args\n\r", .{});
if (decl.data.Fn.is_extern) print(" extern\n\r", .{});
if (decl.data.Fn.is_export) print(" export\n\r", .{});
//print(" return_type: {s}\n\r", .{ decl.data.Fn.return_type });
if(decl.data.Fn.arg_names.len > 0) {
print(" arg_names(", .{});
inline for (decl.data.Fn.arg_names) |arg_name, index| {
print("{s}{s}", .{ arg_name, if (index < decl.data.Fn.arg_names.len - 1) ", " else "" });
}
print(")\n\r", .{});
}
},
}
}
}
if (info.Struct.is_tuple) print(" is_tuple\n\r", .{});
if (!only_pub) print(" layout: {s}\n\r", .{ info.Struct.layout });
print("}}\n\r", .{});
},
.ComptimeFloat => print("ComptimeFloat \n\r", .{}),
.ComptimeInt => print("ComptimeInt \n\r", .{}),
.Undefined => print("Undefined \n\r", .{}),
.Null => print("Null \n\r", .{}),
.Optional => print("Optional \n\r", .{}),
.ErrorUnion => print("ErrorUnion \n\r", .{}),
.ErrorSet => print("ErrorSet\n\r", .{}),
.Enum => print("Enum \n\r", .{}),
.Union => print("Union \n\r", .{}),
.Fn => print("Fn \n\r", .{}),
.BoundFn => print("BoundFn \n\r", .{}),
.Opaque => print("Opaque \n\r", .{}),
.Frame => print("Frame \n\r", .{}),
.AnyFrame => print("AnyFrame\n\r", .{}),
.Vector => print("Vector \n\r", .{}),
.EnumLiteral => print("\n\r", .{}),
}
}
test "reflect" {
showType(std.build, true);
}
|
libs/reflect.zig
|
const std = @import("std");
usingnamespace @import("compile-unit.zig");
usingnamespace @import("decoder.zig");
usingnamespace @import("ir.zig");
pub const DisassemblerOptions = struct {
/// Prefix each line of the disassembly with the hexadecimal address.
addressPrefix: bool = false,
/// If set, a hexdump with both hex- and ascii display will be emitted.
/// Each line of text will contain `hexwidth` number of bytes.
hexwidth: ?usize = null,
/// If set to `true`, the output will contain a line with the
/// name of function that starts at this offset. This option
/// is set by default.
labelOutput: bool = true,
/// If set to `true`, the disassembled instruction will be emitted.
/// This is set by default.
instructionOutput: bool = true,
};
/// Disassembles a given compile unit into a text stream.
/// The output of the disassembler is adjustable to different formats.
/// If all output is disabled in the config, this function can also be used
/// to verify that a compile unit can be parsed completly without any problems.
pub fn disassemble(stream: anytype, cu: CompileUnit, options: DisassemblerOptions) !void {
var decoder = Decoder.init(cu.code);
const anyOutput = options.addressPrefix or options.labelOutput or options.instructionOutput or (options.hexwidth != null);
if (options.addressPrefix)
try stream.print("{X:0>6}\t", .{decoder.offset});
if (options.labelOutput)
try stream.writeAll("<main>:\n");
while (!decoder.isEof()) {
if (options.labelOutput) {
for (cu.functions) |fun| {
if (fun.entryPoint == decoder.offset) {
if (options.addressPrefix)
try stream.print("{X:0>6}\t", .{decoder.offset});
try stream.print("{}:\n", .{fun.name});
}
}
}
if (options.addressPrefix)
try stream.print("{X:0>6}\t", .{decoder.offset});
const start = decoder.offset;
const instr = try decoder.read(Instruction);
const end = decoder.offset;
if (options.hexwidth) |hw| {
try writeHexDump(stream, decoder.data, start, end, hw);
}
if (options.instructionOutput) {
try stream.writeAll("\t");
try stream.writeAll(@tagName(@as(InstructionName, instr)));
inline for (std.meta.fields(Instruction)) |fld| {
if (instr == @field(InstructionName, fld.name)) {
if (fld.field_type == Instruction.Deprecated) {
// no-op
} else if (fld.field_type == Instruction.NoArg) {
// no-op
} else if (fld.field_type == Instruction.CallArg) {
const args = @field(instr, fld.name);
try stream.print(" {} {}", .{ args.function, args.argc });
} else {
if (@TypeOf(@field(instr, fld.name).value) == f64) {
try stream.print(" {d}", .{@field(instr, fld.name).value});
} else if (instr == .jif or instr == .jmp or instr == .jnf) {
try stream.print(" 0x{X}", .{@field(instr, fld.name).value});
} else {
try stream.print(" {}", .{@field(instr, fld.name).value});
}
}
}
}
}
if (anyOutput)
try stream.writeAll("\n");
if (options.hexwidth) |hw| {
var cursor = start + hw;
var paddedEnd = start + 2 * hw;
while (paddedEnd < end + hw) : (paddedEnd += hw) {
if (options.addressPrefix)
try stream.print("{X:0>6}\t", .{cursor});
try writeHexDump(stream, decoder.data, cursor, end, hw);
cursor += hw;
try stream.writeAll("\n");
}
}
}
}
fn writeHexDump(stream: anytype, data: []const u8, begin: usize, end: usize, width: usize) !void {
var offset_hex = begin;
while (offset_hex < begin + width) : (offset_hex += 1) {
if (offset_hex < end) {
try stream.print("{X:0>2} ", .{data[offset_hex]});
} else {
try stream.writeAll(" ");
}
}
try stream.writeAll("|");
var offset_bin = begin;
while (offset_bin < begin + width) : (offset_bin += 1) {
if (offset_bin < end) {
if (std.ascii.isPrint(data[offset_bin])) {
try stream.print("{c}", .{data[offset_bin]});
} else {
try stream.writeAll(".");
}
} else {
try stream.writeAll(" ");
}
}
try stream.writeAll("|");
}
test "disassemble" {
// dummy test
_ = disassemble;
}
|
src/library/common/disassembler.zig
|
usingnamespace @import("common.zig");
const mesh_vert_shader = @embedFile("shader_data/mesh_vert.spv");
const mesh_frag_shader = @embedFile("shader_data/mesh_frag.spv");
const fractal_vert_shader = @embedFile("shader_data/fractal_vert.spv");
const fractal_frag_shader = @embedFile("shader_data/fractal_frag.spv");
pub fn createMeshPipeline(
device: vk.Device,
cache: vk.PipelineCache,
pass: vk.RenderPass,
w: u32,
h: u32,
layout: vk.PipelineLayout,
) !vk.Pipeline {
const vert_bindings = [_]vk.VertexInputBindingDescription{
.{ .binding = 0, .stride = @sizeOf(Float3), .inputRate = .VERTEX },
.{ .binding = 1, .stride = @sizeOf(Float3), .inputRate = .VERTEX },
.{ .binding = 2, .stride = @sizeOf(Float3), .inputRate = .VERTEX },
};
const vert_attrs = [_]vk.VertexInputAttributeDescription{
.{ .location = 0, .binding = 0, .format = .R32G32B32_SFLOAT, .offset = 0 },
.{ .location = 1, .binding = 1, .format = .R32G32B32_SFLOAT, .offset = 0 },
.{ .location = 2, .binding = 2, .format = .R32G32B32_SFLOAT, .offset = 0 },
};
const vert_input_state: vk.PipelineVertexInputStateCreateInfo = .{
.vertexBindingDescriptionCount = vert_bindings.len,
.pVertexBindingDescriptions = &vert_bindings,
.vertexAttributeDescriptionCount = vert_attrs.len,
.pVertexAttributeDescriptions = &vert_attrs,
};
return try createPipeline(
device,
cache,
pass,
w,
h,
layout,
mesh_vert_shader,
mesh_frag_shader,
vert_input_state,
);
}
pub fn createFractalPipeline(
device: vk.Device,
cache: vk.PipelineCache,
pass: vk.RenderPass,
w: u32,
h: u32,
layout: vk.PipelineLayout,
) !vk.Pipeline {
return try createPipeline(
device,
cache,
pass,
w,
h,
layout,
fractal_vert_shader,
fractal_frag_shader,
.{}, // vertex format, no verts here
);
}
fn createPipeline(
device: vk.Device,
cache: vk.PipelineCache,
pass: vk.RenderPass,
w: u32,
h: u32,
layout: vk.PipelineLayout,
vert_spv: []const u8,
frag_spv: []const u8,
vertex_format: vk.PipelineVertexInputStateCreateInfo,
) !vk.Pipeline {
const vert_mod = try vk.CreateShaderModule(device, .{
.codeSize = vert_spv.len,
.pCode = @ptrCast([*]const u32, @alignCast(4, vert_spv)),
}, null);
defer vk.DestroyShaderModule(device, vert_mod, null);
const frag_mod = try vk.CreateShaderModule(device, .{
.codeSize = frag_spv.len,
.pCode = @ptrCast([*]const u32, @alignCast(4, frag_spv)),
}, null);
defer vk.DestroyShaderModule(device, frag_mod, null);
const shader_stages = [_]vk.PipelineShaderStageCreateInfo{
.{ .stage = .{ .vertex = true }, .module = vert_mod, .pName = "vert" },
.{ .stage = .{ .fragment = true }, .module = frag_mod, .pName = "frag" },
};
const input_assembly_state: vk.PipelineInputAssemblyStateCreateInfo = .{
.topology = .TRIANGLE_LIST,
.primitiveRestartEnable = 0,
};
const fw = @intToFloat(f32, w);
const fh = @intToFloat(f32, h);
const viewports = [_]vk.Viewport{ .{
.x = 0,
.y = fh,
.width = fw,
.height = -fh,
.minDepth = 0,
.maxDepth = 1,
} };
const scissors = [_]vk.Rect2D{ .{
.offset = .{ .x = 0, .y = 0 },
.extent = .{ .width = w, .height = h },
} };
const viewport_state: vk.PipelineViewportStateCreateInfo = .{
.viewportCount = viewports.len,
.pViewports = &viewports,
.scissorCount = scissors.len,
.pScissors = &scissors,
};
const raster_state = std.mem.zeroInit(vk.PipelineRasterizationStateCreateInfo, .{
.polygonMode = .FILL,
.cullMode = .{ .back = true },
.frontFace = .COUNTER_CLOCKWISE,
.lineWidth = 1,
});
const multisample_state = std.mem.zeroInit(vk.PipelineMultisampleStateCreateInfo, .{
.rasterizationSamples = .{ .t1 = true },
});
const depth_state = std.mem.zeroInit(vk.PipelineDepthStencilStateCreateInfo, .{
.maxDepthBounds = 1,
});
const attachment_states = [_]vk.PipelineColorBlendAttachmentState{
std.mem.zeroInit(vk.PipelineColorBlendAttachmentState, .{
.colorWriteMask = .{ .r=true, .g=true, .b=true, .a=true },
}),
};
const color_blend_state = std.mem.zeroInit(vk.PipelineColorBlendStateCreateInfo, .{
.attachmentCount = attachment_states.len,
.pAttachments = &attachment_states,
});
const dyn_states = [_]vk.DynamicState{ .VIEWPORT, .SCISSOR };
const dynamic_state: vk.PipelineDynamicStateCreateInfo = .{
.dynamicStateCount = dyn_states.len,
.pDynamicStates = &dyn_states,
};
const create_infos = [_]vk.GraphicsPipelineCreateInfo{ .{
.stageCount = shader_stages.len,
.pStages = &shader_stages,
.pVertexInputState = &vertex_format,
.pInputAssemblyState = &input_assembly_state,
.pViewportState = &viewport_state,
.pRasterizationState = &raster_state,
.pMultisampleState = &multisample_state,
.pDepthStencilState = &depth_state,
.pColorBlendState = &color_blend_state,
.pDynamicState = &dynamic_state,
.layout = layout,
.renderPass = pass,
.subpass = 0,
.basePipelineHandle = .Null,
.basePipelineIndex = 0,
} };
var pipelines = [_]vk.Pipeline{ .Null };
try vk.CreateGraphicsPipelines(device, cache, &create_infos, null, &pipelines);
return pipelines[0];
}
|
src/pipelines.zig
|
const std = @import("std");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const debug = std.debug;
const parser = @import("parse.zig");
const Parser = parser.Parser;
const ByteClass = parser.ByteClass;
const Expr = parser.Expr;
const Assertion = parser.Assertion;
pub const InstructionData = union(enum) {
// Match the specified character.
Char: u8,
// Match the specified character ranges.
ByteClass: ByteClass,
// Matches the AnyChar special cases
AnyCharNotNL,
// Empty match (\w assertion)
EmptyMatch: Assertion,
// Stop the thread, found a match
Match,
// Jump to the instruction at address x
Jump,
// Split execution, spawing a new thread and continuing in lockstep
Split: usize,
// Slot to save position in
Save: usize,
};
// Represents instructions for the VM.
pub const Instruction = struct {
// Next instruction to execute
out: usize,
// Associated data with this
data: InstructionData,
pub fn new(out: usize, data: InstructionData) Instruction {
return Instruction{
.out = out,
.data = data,
};
}
};
// Represents an instruction with unpatched holes.
const InstHole = union(enum) {
// Match with an unfilled output
Char: u8,
// Match a character class range
ByteClass: ByteClass,
// Empty Match assertion
EmptyMatch: Assertion,
// Match any character
AnyCharNotNL,
// Split with no unfilled branch
Split,
// Split with a filled first branch
Split1: usize,
// Split with a filled second branch
Split2: usize,
// Save capture
Save: usize,
};
// Represents a partial instruction. During compilation the instructions will be a mix of compiled
// and un-compiled. All instructions must be in the compiled state when we finish processing.
const PartialInst = union(enum) {
// A completely compiled instruction
Compiled: Instruction,
// A partially compiled instruction, the back-links are not yet filled
Uncompiled: InstHole,
// Modify the current instruction to point to the specified instruction.
pub fn fill(s: *PartialInst, i: usize) void {
switch (s.*) {
PartialInst.Uncompiled => |ih| {
var comp: Instruction = undefined;
// Generate the corresponding compiled instruction. All simply goto the specified
// instruction, except for the dual split case, in which both outgoing pointers
// go to the same place.
const compiled = switch (ih) {
InstHole.Char => |ch| Instruction.new(i, InstructionData{ .Char = ch }),
InstHole.EmptyMatch => |assertion| Instruction.new(i, InstructionData{ .EmptyMatch = assertion }),
InstHole.AnyCharNotNL => Instruction.new(i, InstructionData.AnyCharNotNL),
InstHole.ByteClass => |class| Instruction.new(i, InstructionData{ .ByteClass = class }),
InstHole.Split =>
// If we both point to the same output, we can encode as a jump
Instruction.new(i, InstructionData.Jump),
// 1st was already filled
InstHole.Split1 => |split| Instruction.new(split, InstructionData{ .Split = i }),
// 2nd was already filled
InstHole.Split2 => |split| Instruction.new(i, InstructionData{ .Split = split }),
InstHole.Save => |slot| Instruction.new(i, InstructionData{ .Save = slot }),
};
s.* = PartialInst{ .Compiled = compiled };
},
PartialInst.Compiled => {
// nothing to do, already filled
},
}
}
};
// A program represents the compiled bytecode of an NFA.
pub const Program = struct {
// Sequence of instructions representing an NFA
insts: []Instruction,
// Start instruction
start: usize,
// Find Start instruction
find_start: usize,
// Max number of slots required
slot_count: usize,
// Allocator which owns the instructions
allocator: *Allocator,
pub fn init(allocator: *Allocator, a: []Instruction, find_start: usize, slot_count: usize) Program {
return Program{
.allocator = allocator,
.insts = a,
.start = 0,
.find_start = find_start,
.slot_count = slot_count,
};
}
pub fn deinit(p: *Program) void {
for (p.insts) |*inst| {
switch (inst.data) {
.ByteClass => |*bc| {
bc.deinit();
},
else => {},
}
}
p.allocator.free(p.insts);
}
};
// A Hole represents the outgoing node of a partially compiled Fragment.
//
// If None, the Hole needs to be back-patched as we do not yet know which instruction this
// points to yet.
const Hole = union(enum) {
None,
One: usize,
Many: ArrayList(Hole),
};
// A patch represents an unpatched output for a contigious sequence of instructions.
const Patch = struct {
// The address of the first instruction
entry: usize,
// The output hole of this instruction (to be filled to an actual address/es)
hole: Hole,
};
// A Compiler compiles a regex expression into a bytecode representation of the NFA.
pub const Compiler = struct {
// Stores all partial instructions
insts: ArrayList(PartialInst),
allocator: *Allocator,
// Capture state
capture_index: usize,
pub fn init(a: *Allocator) Compiler {
return Compiler{
.insts = ArrayList(PartialInst).init(a),
.allocator = a,
.capture_index = 0,
};
}
pub fn deinit(c: *Compiler) void {
c.insts.deinit();
}
fn nextCaptureIndex(c: *Compiler) usize {
const s = c.capture_index;
c.capture_index += 2;
return s;
}
// Compile the regex expression
pub fn compile(c: *Compiler, expr: *const Expr) !Program {
// surround in a full program match
const entry = c.insts.items.len;
const index = c.nextCaptureIndex();
try c.pushCompiled(Instruction.new(entry + 1, InstructionData{ .Save = index }));
// compile the main expression
const patch = try c.compileInternal(expr);
// not iterating over an empty correctly in backtrack
c.fillToNext(patch.hole);
const h = try c.pushHole(InstHole{ .Save = index + 1 });
// fill any holes to end at the next instruction which will be a match
c.fillToNext(h);
try c.pushCompiled(Instruction.new(0, InstructionData.Match));
var p = ArrayList(Instruction).init(c.allocator);
defer p.deinit();
for (c.insts.items) |e| {
switch (e) {
PartialInst.Compiled => |x| {
try p.append(x);
},
else => |inner| {
@panic("uncompiled instruction encountered during compilation");
},
}
}
// To facilitate fast finding (matching non-anchored to the start) we simply append a
// .*? to the start of our instructions. We push the fragment with this set of instructions
// at the end of the compiled set. We perform an anchored search by entering normally and
// a non-anchored by jumping to this patch before starting.
//
// 1: compiled instructions
// 2: match
// ... # We add the following
// 3: split 1, 4
// 4: any 3
const fragment_start = c.insts.items.len;
const fragment = [_]Instruction{
Instruction.new(0, InstructionData{ .Split = fragment_start + 1 }),
Instruction.new(fragment_start, InstructionData.AnyCharNotNL),
};
try p.appendSlice(&fragment);
return Program.init(p.allocator, p.toOwnedSlice(), fragment_start, c.capture_index);
}
fn compileInternal(c: *Compiler, expr: *const Expr) Allocator.Error!Patch {
switch (expr.*) {
Expr.Literal => |lit| {
const h = try c.pushHole(InstHole{ .Char = lit });
return Patch{ .hole = h, .entry = c.insts.items.len - 1 };
},
Expr.ByteClass => |classes| {
// Similar, we use a special instruction.
const h = try c.pushHole(InstHole{ .ByteClass = classes });
return Patch{ .hole = h, .entry = c.insts.items.len - 1 };
},
Expr.AnyCharNotNL => {
const h = try c.pushHole(InstHole.AnyCharNotNL);
return Patch{ .hole = h, .entry = c.insts.items.len - 1 };
},
Expr.EmptyMatch => |assertion| {
const h = try c.pushHole(InstHole{ .EmptyMatch = assertion });
return Patch{ .hole = h, .entry = c.insts.items.len - 1 };
},
Expr.Repeat => |repeat| {
// Case 1: *
if (repeat.min == 0 and repeat.max == null) {
return c.compileStar(repeat.subexpr, repeat.greedy);
}
// Case 2: +
else if (repeat.min == 1 and repeat.max == null) {
return c.compilePlus(repeat.subexpr, repeat.greedy);
}
// Case 3: ?
else if (repeat.min == 0 and repeat.max != null and repeat.max.? == 1) {
return c.compileQuestion(repeat.subexpr, repeat.greedy);
}
// Case 4: {m,}
else if (repeat.max == null) {
// e{2,} => eee*
// fixed min concatenation
const p = try c.compileInternal(repeat.subexpr);
var hole = p.hole;
const entry = p.entry;
var i: usize = 1;
while (i < repeat.min) : (i += 1) {
const ep = try c.compileInternal(repeat.subexpr);
c.fill(hole, ep.entry);
hole = ep.hole;
}
// add final e* infinite capture
const st = try c.compileStar(repeat.subexpr, repeat.greedy);
c.fill(hole, st.entry);
return Patch{ .hole = st.hole, .entry = entry };
}
// Case 5: {m,n} and {m}
else {
// e{3,6} => eee?e?e?e?
const p = try c.compileInternal(repeat.subexpr);
var hole = p.hole;
const entry = p.entry;
var i: usize = 1;
while (i < repeat.min) : (i += 1) {
const ep = try c.compileInternal(repeat.subexpr);
c.fill(hole, ep.entry);
hole = ep.hole;
}
// repeated optional concatenations
while (i < repeat.max.?) : (i += 1) {
const ep = try c.compileQuestion(repeat.subexpr, repeat.greedy);
c.fill(hole, ep.entry);
hole = ep.hole;
}
return Patch{ .hole = hole, .entry = entry };
}
},
Expr.Concat => |subexprs| {
// Compile each item in the sub-expression
var f = subexprs.items[0];
// First patch
const p = try c.compileInternal(f);
var hole = p.hole;
const entry = p.entry;
// tie together patches from concat arguments
for (subexprs.items[1..]) |e| {
const ep = try c.compileInternal(e);
// fill the previous patch hole to the current entry
c.fill(hole, ep.entry);
// current hole is now the next fragment
hole = ep.hole;
}
return Patch{ .hole = hole, .entry = entry };
},
Expr.Capture => |subexpr| {
// 1: save 1, 2
// 2: subexpr
// 3: restore 1, 4
// ...
// Create a partial instruction with a hole outgoing at the current location.
const entry = c.insts.items.len;
const index = c.nextCaptureIndex();
try c.pushCompiled(Instruction.new(entry + 1, InstructionData{ .Save = index }));
const p = try c.compileInternal(subexpr);
c.fillToNext(p.hole);
const h = try c.pushHole(InstHole{ .Save = index + 1 });
return Patch{ .hole = h, .entry = entry };
},
Expr.Alternate => |subexprs| {
// Alternation with one path does not make sense
debug.assert(subexprs.items.len >= 2);
// Alternates are simply a series of splits into the sub-expressions, with each
// subexpr having the same output hole (after the final subexpr).
//
// 1: split 2, 4
// 2: subexpr1
// 3: jmp 8
// 4: split 5, 7
// 5: subexpr2
// 6: jmp 8
// 7: subexpr3
// 8: ...
const entry = c.insts.items.len;
var holes = ArrayList(Hole).init(c.allocator);
errdefer holes.deinit();
// TODO: Doees this need to be dynamically allocated?
var last_hole = try c.allocator.create(Hole);
defer c.allocator.destroy(last_hole);
last_hole.* = .None;
// This compiles one branch of the split at a time.
for (subexprs.items[0 .. subexprs.items.len - 1]) |subexpr| {
c.fillToNext(last_hole.*);
// next entry will be a sub-expression
//
// We fill the second part of this hole on the next sub-expression.
last_hole.* = try c.pushHole(InstHole{ .Split1 = c.insts.items.len + 1 });
// compile the subexpression
const p = try c.compileInternal(subexpr);
// store outgoing hole for the subexpression
try holes.append(p.hole);
}
// one entry left, push a sub-expression so we end with a double-subexpression.
const p = try c.compileInternal(subexprs.items[subexprs.items.len - 1]);
c.fill(last_hole.*, p.entry);
// push the last sub-expression hole
try holes.append(p.hole);
// return many holes which are all to be filled to the next instruction
return Patch{ .hole = Hole{ .Many = holes }, .entry = entry };
},
Expr.PseudoLeftParen => {
@panic("internal error, encountered PseudoLeftParen");
},
}
return Patch{ .hole = Hole.None, .entry = c.insts.items.len };
}
fn compileStar(c: *Compiler, expr: *Expr, greedy: bool) !Patch {
// 1: split 2, 4
// 2: subexpr
// 3: jmp 1
// 4: ...
// We do not know where the second branch in this split will go (unsure yet of
// the length of the following subexpr. Need a hole.
// Create a partial instruction with a hole outgoing at the current location.
const entry = c.insts.items.len;
// * or *? variant, simply switch the branches, the matcher manages precedence
// of the executing threads.
const partial_inst = if (greedy)
InstHole{ .Split1 = c.insts.items.len + 1 }
else
InstHole{ .Split2 = c.insts.items.len + 1 };
const h = try c.pushHole(partial_inst);
// compile the subexpression
const p = try c.compileInternal(expr);
// sub-expression to jump
c.fillToNext(p.hole);
// Jump back to the entry split
try c.pushCompiled(Instruction.new(entry, InstructionData.Jump));
// Return a filled patch set to the first split instruction.
return Patch{ .hole = h, .entry = entry };
}
fn compilePlus(c: *Compiler, expr: *Expr, greedy: bool) !Patch {
// 1: subexpr
// 2: split 1, 3
// 3: ...
//
// NOTE: We can do a lookahead on non-greedy here to improve performance.
const p = try c.compileInternal(expr);
// Create the next expression in place
c.fillToNext(p.hole);
// split 3, 1 (non-greedy)
// Point back to the upcoming next instruction (will always be filled).
const partial_inst = if (greedy)
InstHole{ .Split1 = p.entry }
else
InstHole{ .Split2 = p.entry };
const h = try c.pushHole(partial_inst);
// split to the next instruction
return Patch{ .hole = h, .entry = p.entry };
}
fn compileQuestion(c: *Compiler, expr: *Expr, greedy: bool) !Patch {
// 1: split 2, 3
// 2: subexpr
// 3: ...
// Create a partial instruction with a hole outgoing at the current location.
const partial_inst = if (greedy)
InstHole{ .Split1 = c.insts.items.len + 1 }
else
InstHole{ .Split2 = c.insts.items.len + 1 };
const h = try c.pushHole(partial_inst);
// compile the subexpression
const p = try c.compileInternal(expr);
var holes = ArrayList(Hole).init(c.allocator);
errdefer holes.deinit();
try holes.append(h);
try holes.append(p.hole);
// Return a filled patch set to the first split instruction.
return Patch{ .hole = Hole{ .Many = holes }, .entry = p.entry - 1 };
}
// Push a compiled instruction directly onto the stack.
fn pushCompiled(c: *Compiler, i: Instruction) !void {
try c.insts.append(PartialInst{ .Compiled = i });
}
// Push a instruction with a hole onto the set
fn pushHole(c: *Compiler, i: InstHole) !Hole {
const h = c.insts.items.len;
try c.insts.append(PartialInst{ .Uncompiled = i });
return Hole{ .One = h };
}
// Patch an individual hole with the specified output address.
fn fill(c: *Compiler, hole: Hole, goto1: usize) void {
switch (hole) {
Hole.None => {},
Hole.One => |pc| c.insts.items[pc].fill(goto1),
Hole.Many => |holes| {
for (holes.items) |hole1|
c.fill(hole1, goto1);
},
}
}
// Patch a hole to point to the next instruction
fn fillToNext(c: *Compiler, hole: Hole) void {
c.fill(hole, c.insts.items.len);
}
};
|
src/compile.zig
|
//--------------------------------------------------------------------------------
// Section: Types (1)
//--------------------------------------------------------------------------------
const IID_IDirect3DDxgiInterfaceAccess_Value = Guid.initString("a9b3d012-3df2-4ee3-b8d1-8695f457d3c1");
pub const IID_IDirect3DDxgiInterfaceAccess = &IID_IDirect3DDxgiInterfaceAccess_Value;
pub const IDirect3DDxgiInterfaceAccess = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetInterface: fn(
self: *const IDirect3DDxgiInterfaceAccess,
iid: ?*const Guid,
p: ?*?*anyopaque,
) 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 IDirect3DDxgiInterfaceAccess_GetInterface(self: *const T, iid: ?*const Guid, p: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirect3DDxgiInterfaceAccess.VTable, self.vtable).GetInterface(@ptrCast(*const IDirect3DDxgiInterfaceAccess, self), iid, p);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (2)
//--------------------------------------------------------------------------------
pub extern "d3d11" fn CreateDirect3D11DeviceFromDXGIDevice(
dxgiDevice: ?*IDXGIDevice,
graphicsDevice: ?*?*IInspectable,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d3d11" fn CreateDirect3D11SurfaceFromDXGISurface(
dgxiSurface: ?*IDXGISurface,
graphicsSurface: ?*?*IInspectable,
) 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 (6)
//--------------------------------------------------------------------------------
const Guid = @import("../../zig.zig").Guid;
const HRESULT = @import("../../foundation.zig").HRESULT;
const IDXGIDevice = @import("../../graphics/dxgi.zig").IDXGIDevice;
const IDXGISurface = @import("../../graphics/dxgi.zig").IDXGISurface;
const IInspectable = @import("../../system/win_rt.zig").IInspectable;
const IUnknown = @import("../../system/com.zig").IUnknown;
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/win_rt/direct3d11.zig
|
//--------------------------------------------------------------------------------
// Section: Types (5)
//--------------------------------------------------------------------------------
const IID_ILearningModelOperatorProviderNative_Value = Guid.initString("1adaa23a-eb67-41f3-aad8-5d984e9bacd4");
pub const IID_ILearningModelOperatorProviderNative = &IID_ILearningModelOperatorProviderNative_Value;
pub const ILearningModelOperatorProviderNative = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetRegistry: fn(
self: *const ILearningModelOperatorProviderNative,
ppOperatorRegistry: ?*?*IMLOperatorRegistry,
) 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 ILearningModelOperatorProviderNative_GetRegistry(self: *const T, ppOperatorRegistry: ?*?*IMLOperatorRegistry) callconv(.Inline) HRESULT {
return @ptrCast(*const ILearningModelOperatorProviderNative.VTable, self.vtable).GetRegistry(@ptrCast(*const ILearningModelOperatorProviderNative, self), ppOperatorRegistry);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ITensorNative_Value = Guid.initString("52f547ef-5b03-49b5-82d6-565f1ee0dd49");
pub const IID_ITensorNative = &IID_ITensorNative_Value;
pub const ITensorNative = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetBuffer: fn(
self: *const ITensorNative,
value: [*]?*u8,
capacity: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetD3D12Resource: fn(
self: *const ITensorNative,
result: ?*?*ID3D12Resource,
) 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 ITensorNative_GetBuffer(self: *const T, value: [*]?*u8, capacity: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ITensorNative.VTable, self.vtable).GetBuffer(@ptrCast(*const ITensorNative, self), value, capacity);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ITensorNative_GetD3D12Resource(self: *const T, result: ?*?*ID3D12Resource) callconv(.Inline) HRESULT {
return @ptrCast(*const ITensorNative.VTable, self.vtable).GetD3D12Resource(@ptrCast(*const ITensorNative, self), result);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ITensorStaticsNative_Value = Guid.initString("39d055a4-66f6-4ebc-95d9-7a29ebe7690a");
pub const IID_ITensorStaticsNative = &IID_ITensorStaticsNative_Value;
pub const ITensorStaticsNative = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
CreateFromD3D12Resource: fn(
self: *const ITensorStaticsNative,
value: ?*ID3D12Resource,
shape: ?*i64,
shapeCount: i32,
result: ?*?*IUnknown,
) 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 ITensorStaticsNative_CreateFromD3D12Resource(self: *const T, value: ?*ID3D12Resource, shape: ?*i64, shapeCount: i32, result: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ITensorStaticsNative.VTable, self.vtable).CreateFromD3D12Resource(@ptrCast(*const ITensorStaticsNative, self), value, shape, shapeCount, result);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ILearningModelDeviceFactoryNative_Value = Guid.initString("1e9b31a1-662e-4ae0-af67-f63bb337e634");
pub const IID_ILearningModelDeviceFactoryNative = &IID_ILearningModelDeviceFactoryNative_Value;
pub const ILearningModelDeviceFactoryNative = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
CreateFromD3D12CommandQueue: fn(
self: *const ILearningModelDeviceFactoryNative,
value: ?*ID3D12CommandQueue,
result: ?*?*IUnknown,
) 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 ILearningModelDeviceFactoryNative_CreateFromD3D12CommandQueue(self: *const T, value: ?*ID3D12CommandQueue, result: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ILearningModelDeviceFactoryNative.VTable, self.vtable).CreateFromD3D12CommandQueue(@ptrCast(*const ILearningModelDeviceFactoryNative, self), value, result);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ILearningModelSessionOptionsNative_Value = Guid.initString("c71e953f-37b4-4564-8658-d8396866db0d");
pub const IID_ILearningModelSessionOptionsNative = &IID_ILearningModelSessionOptionsNative_Value;
pub const ILearningModelSessionOptionsNative = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetIntraOpNumThreadsOverride: fn(
self: *const ILearningModelSessionOptionsNative,
intraOpNumThreads: 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 ILearningModelSessionOptionsNative_SetIntraOpNumThreadsOverride(self: *const T, intraOpNumThreads: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ILearningModelSessionOptionsNative.VTable, self.vtable).SetIntraOpNumThreadsOverride(@ptrCast(*const ILearningModelSessionOptionsNative, self), intraOpNumThreads);
}
};}
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 (6)
//--------------------------------------------------------------------------------
const Guid = @import("../../zig.zig").Guid;
const HRESULT = @import("../../foundation.zig").HRESULT;
const ID3D12CommandQueue = @import("../../graphics/direct3d12.zig").ID3D12CommandQueue;
const ID3D12Resource = @import("../../graphics/direct3d12.zig").ID3D12Resource;
const IMLOperatorRegistry = @import("../../ai/machine_learning/win_ml.zig").IMLOperatorRegistry;
const IUnknown = @import("../../system/com.zig").IUnknown;
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/win_rt/ml.zig
|
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Octopus = struct {
const SIZE = 10;
width: usize,
height: usize,
cur: usize,
grid: [2][SIZE][SIZE]usize,
pub fn init() Octopus {
var self = Octopus{
.width = 0,
.height = 0,
.cur = 0,
.grid = undefined,
};
return self;
}
pub fn deinit(_: *Octopus) void {}
pub fn process_line(self: *Octopus, data: []const u8) !void {
if (self.width == 0) self.width = data.len;
if (self.width != data.len) unreachable;
for (data) |c, x| {
const n = c - '0';
self.grid[self.cur][x][self.height] = n;
}
self.height += 1;
}
pub fn count_total_flashes_after_n_steps(self: *Octopus, n: usize) usize {
var flashes: usize = 0;
var step: usize = 0;
while (step < n) : (step += 1) {
flashes += self.run_step();
}
return flashes;
}
pub fn count_steps_until_simultaneous_flash(self: *Octopus) usize {
var step: usize = 0;
while (!self.all_flashed()) : (step += 1) {
_ = self.run_step();
}
return step;
}
fn show(self: Octopus, pos: usize) void {
var y: usize = 0;
while (y < SIZE) : (y += 1) {
var x: usize = 0;
while (x < SIZE) : (x += 1) {
const n = @intCast(u8, self.grid[pos][x][y]);
const c = if (n == 0) '*' else (n + '0');
std.debug.warn("{c}", .{c});
}
std.debug.warn("\n", .{});
}
std.debug.warn("\n", .{});
}
fn increment_energy(self: *Octopus, delta: usize) usize {
var flashes: usize = 0;
var x: usize = 0;
while (x < SIZE) : (x += 1) {
var y: usize = 0;
while (y < SIZE) : (y += 1) {
self.grid[self.cur][x][y] += delta;
if (self.grid[self.cur][x][y] == 10) {
flashes += 1;
}
}
}
return flashes;
}
fn count_neighbors(self: Octopus, cur: usize, x: usize, y: usize, n: usize) usize {
var delta: usize = 0;
var dx: isize = -1;
while (dx <= 1) : (dx += 1) {
var dy: isize = -1;
while (dy <= 1) : (dy += 1) {
if (dx == 0 and dy == 0) continue;
var sx = @intCast(isize, x) + dx;
if (sx < 0 or sx >= SIZE) continue;
var sy = @intCast(isize, y) + dy;
if (sy < 0 or sy >= SIZE) continue;
var nx = @intCast(usize, sx);
var ny = @intCast(usize, sy);
if (self.grid[cur][nx][ny] == n) delta += 1;
}
}
return delta;
}
fn reset_energy(self: *Octopus) void {
var x: usize = 0;
while (x < SIZE) : (x += 1) {
var y: usize = 0;
while (y < SIZE) : (y += 1) {
if (self.grid[self.cur][x][y] >= 10) {
self.grid[self.cur][x][y] = 0;
}
}
}
}
fn run_step(self: *Octopus) usize {
var total_flashes: usize = self.increment_energy(1);
var cur: usize = self.cur;
var nxt: usize = 1 - cur;
while (true) {
var flashes: usize = 0;
var x: usize = 0;
while (x < SIZE) : (x += 1) {
var y: usize = 0;
while (y < SIZE) : (y += 1) {
const delta = self.count_neighbors(cur, x, y, 10);
var new: usize = self.grid[cur][x][y] + delta;
if (new >= 10) {
if (self.grid[cur][x][y] < 10) {
flashes += 1;
self.grid[nxt][x][y] = 10;
} else {
self.grid[nxt][x][y] = 11;
}
} else {
self.grid[nxt][x][y] = new;
}
}
}
cur = 1 - cur;
nxt = 1 - nxt;
if (flashes == 0) break;
total_flashes += flashes;
}
self.cur = cur;
self.reset_energy();
return total_flashes;
}
fn all_flashed(self: Octopus) bool {
var x: usize = 0;
while (x < SIZE) : (x += 1) {
var y: usize = 0;
while (y < SIZE) : (y += 1) {
if (self.grid[self.cur][x][y] > 0) return false;
}
}
return true;
}
};
test "sample part a" {
const data: []const u8 =
\\5483143223
\\2745854711
\\5264556173
\\6141336146
\\6357385478
\\4167524645
\\2176841721
\\6882881134
\\4846848554
\\5283751526
;
var octopus = Octopus.init();
defer octopus.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try octopus.process_line(line);
}
const total_flashes = octopus.count_total_flashes_after_n_steps(100);
try testing.expect(total_flashes == 1656);
}
test "sample part b" {
const data: []const u8 =
\\5483143223
\\2745854711
\\5264556173
\\6141336146
\\6357385478
\\4167524645
\\2176841721
\\6882881134
\\4846848554
\\5283751526
;
var octopus = Octopus.init();
defer octopus.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try octopus.process_line(line);
}
const steps = octopus.count_steps_until_simultaneous_flash();
try testing.expect(steps == 195);
}
|
2021/p11/octopus.zig
|
const builtin = @import("builtin");
const std = @import("std");
const print = std.debug.print;
const VA_Errors = error{
CountUninitialized,
NoMoreArgs,
};
pub const VAFunc = *const opaque {};
pub const VAList = struct {
first_arg: bool = true,
count: ?usize = null,
gp_offset: u8 = 0,
fp_offset: u8 = 0,
gp_regs: [6]u64 = undefined,
fp_regs: [8]f64 = undefined,
overflow: [*]const u64 = undefined,
const Self = @This();
/// This needs to be done first thing by the function that uses it
pub inline fn init() Self {
//if (builtin.link_libc and builtin.mode == .Debug)
//@compileError("Cannot use this build mode for var args");
// Get all gen purpose registers one at a time because initializing
// any var(even set as undefined) would cause register mutation.
// You can see this by adding any var above these and seeing rdi+ changing
const fp_count: usize = asm volatile (""
: [ret] "={rax}" (-> usize),
);
const rdi = asm volatile (""
: [ret] "={rdi}" (-> usize),
);
const rsi = asm volatile (""
: [ret] "={rsi}" (-> usize),
);
const rdx = asm volatile (""
: [ret] "={rdx}" (-> usize),
);
const rcx = asm volatile (""
: [ret] "={rcx}" (-> usize),
);
const r8 = asm volatile (""
: [ret] "={r8}" (-> usize),
);
const r9 = asm volatile (""
: [ret] "={r9}" (-> usize),
);
var self = VAList{};
self.gp_regs[0] = rdi;
self.gp_regs[1] = rsi;
self.gp_regs[2] = rdx;
self.gp_regs[3] = rcx;
self.gp_regs[4] = r8;
self.gp_regs[5] = r9;
// save fp registers if fp_count != 0
if (fp_count != 0) {
self.fp_regs[0] = asm volatile (""
: [ret] "={xmm0}" (-> f64),
);
self.fp_regs[1] = asm volatile (""
: [ret] "={xmm1}" (-> f64),
);
self.fp_regs[2] = asm volatile (""
: [ret] "={xmm2}" (-> f64),
);
self.fp_regs[3] = asm volatile (""
: [ret] "={xmm3}" (-> f64),
);
self.fp_regs[4] = asm volatile (""
: [ret] "={xmm4}" (-> f64),
);
self.fp_regs[5] = asm volatile (""
: [ret] "={xmm5}" (-> f64),
);
self.fp_regs[6] = asm volatile (""
: [ret] "={xmm6}" (-> f64),
);
self.fp_regs[7] = asm volatile (""
: [ret] "={xmm7}" (-> f64),
);
}
// ----find stack area of overflow args
// use ret addr as an aligned reference point
var ret_addr: usize = rdi;
ret_addr = @returnAddress();
var stack_addr = @ptrCast([*]const u64, &ret_addr);
stack_addr += 1;
// iterate aligned values off of the stack until we find the return address
while (stack_addr[0] != ret_addr) {
stack_addr += 1;
} else {
self.overflow = stack_addr + 1;
}
// Debug stuff
//print("\n", .{});
//print("fpcount: {}\n", .{fpcount});
//for (self.gp_regs) |r, i| {
//print("GReg {}: {}\n", .{ i, r });
//}
//for (self.fp_regs) |r, i| {
//print("FReg {}: {}\n", .{ i, r });
//}
return self;
}
pub fn next(self: *Self, comptime T: type) VA_Errors!T {
// Getting the first argument is always successful per spec
// Any further args need a proper count
if (self.first_arg) {
self.first_arg = false;
const ret = self.handleType(T);
return ret;
} else if (self.count == null) {
return error.CountUninitialized;
} else if (self.count.? == 0) {
return error.NoMoreArgs;
}
self.count.? -= 1;
return self.handleType(T);
}
fn handleType(self: *Self, comptime T: type) T {
const info = @typeInfo(T);
// switch on type; need to adjust for float, int <= 64, and structs
switch (info) {
.Int => {
if (@bitSizeOf(T) > @bitSizeOf(usize))
@compileError("Arg type is bigger than usize: " ++ @typeName(T));
var ret: T = undefined;
if (self.gp_offset < self.gp_regs.len) {
ret = self.gp_regs[self.gp_offset];
} else {
ret = self.overflow[self.gp_offset - self.gp_regs.len];
}
self.gp_offset += 1;
return ret;
},
.Optional => {
const child = info.Optional.child;
const opinfo = @typeInfo(child);
switch (opinfo) {
.Pointer => {
var ret: T = null;
if (self.gp_offset < self.gp_regs.len) {
ret = @intToPtr(T, self.gp_regs[self.gp_offset]);
} else {
ret = @intToPtr(T, self.overflow[self.gp_offset - self.gp_regs.len]);
}
self.gp_offset += 1;
return ret;
},
else => @compileError("Unsupported optional type: " ++ @typeName(child)),
}
},
.Float => {
var ret: f64 = undefined;
if (self.fp_offset < self.fp_regs.len) {
ret = self.fp_regs[self.fp_offset];
} else {
@panic("TODO: stack floats");
}
self.fp_offset += 1;
return @floatCast(T, ret);
},
.Struct => @compileError("Todo"),
.Pointer => @compileError("Pointers need to be optional"),
else => @compileError("Unsupported next arg type: " ++ @typeName(T)),
}
}
};
// TODO: try anytype for func argument
// might be able to do comptime checks on comptime known fns
// AND still be able to take runtime fn pointers
pub inline fn callVarArgs(comptime T: type, func: VAFunc, args: anytype) T {
// comptime: validate args
comptime {
if (@bitSizeOf(T) > @bitSizeOf(usize)) {
@compileError("Return type is larger than usize: " ++ @typeName(T));
}
const args_info = @typeInfo(@TypeOf(args));
if (args_info != .Struct or args_info.Struct.is_tuple == false) {
@compileError("Expected args to be a tuple");
}
if (args.len == 0) {
@compileError("Tuple needs to have at least one arg");
}
}
// comptime: accounting
// count number of fp and gp args so we can push them on the stack
// if needed and in reverse order
// also do type checking
comptime var gp_args = 0;
comptime var fp_args = 0;
comptime {
var index = args.len;
while (index > 0) : (index -= 1) {
const arg_type = @TypeOf(args[index - 1]);
const arg_info = @typeInfo(arg_type);
switch (arg_info) {
.Int, .ComptimeInt, .Optional, .Pointer => {
if (@bitSizeOf(arg_type) > @bitSizeOf(usize)) {
@compileError("Arg type is larger than usize: " ++ @typeName(arg_type));
} else if (arg_info == .Optional) {
const child = arg_info.Optional.child;
const child_info = @typeInfo(child);
if (child_info != .Pointer) {
@compileError("Optional args should only be pointers");
}
}
gp_args += 1;
},
.Float => fp_args += 1,
else => @compileError("Unsupported arg type: " ++ @typeName(arg_type)),
}
}
}
const fp_total: usize = fp_args;
comptime var stack_growth: usize = 0;
comptime var index = args.len;
// reverse loop of args so you can push later args onto the stack in order
inline while (index > 0) : (index -= 1) {
const varg = args[index - 1];
const arg_info = @typeInfo(@TypeOf(varg));
switch (arg_info) {
.Int, .ComptimeInt, .Optional, .Pointer => {
const arg: usize = if (arg_info == .Optional or arg_info == .Pointer)
@as(usize, @ptrToInt(varg))
else
@as(usize, varg);
pushInt(gp_args, arg);
if (gp_args > 6)
stack_growth += @sizeOf(usize);
gp_args -= 1;
},
.Float => {
const arg = @floatCast(f64, varg);
pushFloat(fp_args, arg);
fp_args -= 1;
},
else => @compileError("Unsupported arg type: " ++ @typeName(varg)),
}
}
// call fn
asm volatile ("call *(%%r10)"
:
: [func] "{r10}" (func),
[fp_total] "{rax}" (fp_total),
);
// realign stack
if (stack_growth > 0) {
asm volatile ("add %%r10, %%rsp"
:
: [stack_growth] "{r10}" (stack_growth),
);
}
// handle return type
if (T == void) {
return;
}
const ret = asm volatile (""
: [ret] "={rax}" (-> T),
);
return ret;
}
inline fn pushInt(comptime index: usize, arg: usize) void {
switch (index) {
1 => asm volatile (""
:
: [arg] "{rdi}" (arg),
),
2 => asm volatile (""
:
: [arg] "{rsi}" (arg),
),
3 => asm volatile (""
:
: [arg] "{rdx}" (arg),
),
4 => asm volatile (""
:
: [arg] "{rcx}" (arg),
),
5 => asm volatile (""
:
: [arg] "{r8}" (arg),
),
6 => asm volatile (""
:
: [arg] "{r9}" (arg),
),
else => {
asm volatile ("push %%r10"
:
: [arg] "{r10}" (arg),
);
},
}
}
inline fn pushFloat(comptime index: usize, arg: f64) void {
switch (index) {
1 => asm volatile (""
:
: [arg] "{xmm0}" (arg),
),
2 => asm volatile (""
:
: [arg] "{xmm1}" (arg),
),
3 => asm volatile (""
:
: [arg] "{xmm2}" (arg),
),
4 => asm volatile (""
:
: [arg] "{xmm3}" (arg),
),
5 => asm volatile (""
:
: [arg] "{xmm4}" (arg),
),
6 => asm volatile (""
:
: [arg] "{xmm5}" (arg),
),
7 => asm volatile (""
:
: [arg] "{xmm6}" (arg),
),
8 => asm volatile (""
:
: [arg] "{xmm7}" (arg),
),
else => @panic("TODO: stack floats"),
}
}
|
src/x86_64.zig
|
const std = @import("std");
const mem = std.mem;
const Allocator = std.mem.Allocator;
name: []const u8,
fh: std.fs.File,
allocator: *Allocator,
objects: std.ArrayList(ObjectFile),
const Header = extern struct {
name: [16]u8,
mtime: [12]u8,
ownerid: [6]u8,
groupid: [6]u8,
mode: [8]u8,
size: [10]u8,
end: [2]u8,
};
const ObjectFile = struct {
header: Header,
contents: []u8,
};
const Self = @This();
pub fn create(name: []const u8, allocator: *Allocator) !Self {
var self = Self{
.name = name,
.fh = try std.fs.cwd().createFile(name, .{}),
.allocator = allocator,
.objects = std.ArrayList(ObjectFile).init(allocator),
};
return self;
}
pub fn open(name: []const u8, allocator: *Allocator) !Self {
var self = Self{
.name = name,
.fh = try std.fs.cwd().openFile(name, .{ .write = true }),
.allocator = allocator,
.objects = std.ArrayList(ObjectFile).init(allocator),
};
try self.parse();
return self;
}
pub fn close(self: *Self) void {
for (self.objects.items) |item| {
self.allocator.free(item.contents);
}
self.objects.deinit();
self.fh.close();
}
pub fn addMod(self: *Self, file_names: ?[][]u8) !void {
if (file_names) |names| {
for (names) |file_name| {
const obj_file = try std.fs.cwd().openFile(file_name, .{ .read = true });
defer obj_file.close();
const data = try obj_file.readToEndAlloc(self.allocator, std.math.maxInt(usize));
const stat = try obj_file.stat();
const name = try mem.concat(self.allocator, u8, &.{ file_name, "/" });
defer self.allocator.free(name);
var buf = [_]u8{0} ** @sizeOf(Header);
_ = try std.fmt.bufPrint(
&buf,
"{s: <16}{: <12}{: <6}{: <6}{o: <8}{: <10}`\n",
.{ name, 0, 0, 0, stat.mode, stat.size },
);
const object = ObjectFile{
.header = @ptrCast(*Header, &buf).*,
.contents = data,
};
try self.objects.append(object);
}
}
}
pub fn deleteMod(self: *Self, file_names: ?[][]u8) !void {
if (file_names) |names| {
for (names) |file_name| {
for (self.objects.items) |item, index| {
if (std.mem.eql(u8, std.mem.trim(u8, &item.header.name, " /"), file_name)) {
_ = self.objects.orderedRemove(index);
break;
}
}
}
}
}
pub fn finalize(self: *Self) !void {
try self.fh.seekTo(0);
const writer = self.fh.writer();
try writer.writeAll("!<arch>\n");
for (self.objects.items) |item| {
try writer.writeStruct(item.header);
try writer.writeAll(item.contents);
}
try self.fh.setEndPos(try self.fh.getPos());
}
fn parse(self: *Self) !void {
var reader = self.fh.reader();
var magic = try reader.readBytesNoEof(8);
if (!std.mem.eql(u8, &magic, "!<arch>\n"))
return error.InvalidArchive;
while (true) {
var obj_file: ObjectFile = undefined;
obj_file.header = reader.readStruct(Header) catch |err| switch (err) {
error.EndOfStream => break,
else => |e| return e,
};
const size = try std.fmt.parseUnsigned(u32, std.mem.trimRight(u8, &obj_file.header.size, " "), 10);
obj_file.contents = try self.allocator.alloc(u8, size);
try reader.readNoEof(obj_file.contents);
try self.objects.append(obj_file);
}
}
const OperationErrorSet = Allocator.Error || std.fmt.ParseIntError;
fn massOperation(self: *Self, file_names: ?[][]u8, data: anytype, cb: fn (item: ObjectFile, index: usize, data: anytype) OperationErrorSet!void) !void {
if (file_names) |names| {
for (self.objects.items) |item, index| {
for (names) |name| {
if (std.mem.eql(u8, std.mem.trim(u8, &item.header.name, " /"), name)) {
try cb(item, index, data);
break;
}
}
}
} else {
for (self.objects.items) |item, index| {
try cb(item, index, data);
}
}
}
fn printOperation(item: ObjectFile, index: usize, data: anytype) !void {
_ = index;
const writer = data;
try writer.print("{s}", .{item.contents});
}
pub fn print(self: *Self, file_names: ?[][]u8, writer: std.fs.File.Writer) !void {
try self.massOperation(file_names, writer, printOperation);
}
fn extractOperation(item: ObjectFile, index: usize, data: anytype) !void {
_ = index;
_ = data;
const file = try std.fs.cwd().createFile(std.mem.trim(u8, &item.header.name, " /"), .{});
defer file.close();
try file.writeAll(item.contents);
}
pub fn extract(self: *Self, file_names: ?[][]u8) !void {
try self.massOperation(file_names, null, extractOperation);
}
|
src/Archive.zig
|
const std = @import("std");
const hzzp = @import("hzzp");
const iguanatls = @import("iguanatls");
const wz = @import("wz");
const TLS = iguanatls.Client(std.net.Stream.Reader, std.net.Stream.Writer, iguanatls.ciphersuites.all, false);
const WSS = wz.base.client.BaseClient(TLS.Reader, TLS.Writer);
const HTTPS = hzzp.base.client.BaseClient(TLS.Reader, TLS.Writer);
pub const Intents = packed struct {
guilds: bool = false,
guild_members: bool = false,
guild_bans: bool = false,
guild_emojis: bool = false,
guild_integrations: bool = false,
guild_webhooks: bool = false,
guild_invites: bool = false,
guild_voice_Contexts: bool = false,
guild_presences: bool = false,
guild_messages: bool = false,
guild_message_reactions: bool = false,
guild_message_typing: bool = false,
direct_messages: bool = false,
direct_message_reactions: bool = false,
direct_message_typing: bool = false,
};
fn heartbeatThread(self: *Conn) void {
while (true) {
std.time.sleep(self.ns_heartbeat_interval - std.time.ms_per_s * 500);
const heartbeat =
\\{
\\ "op": 1,
\\ "d": null
\\}
;
self.wss_client.writeHeader(.{ .opcode = .Text, .length = heartbeat.len }) catch return;
self.wss_client.writeChunk(heartbeat) catch return;
}
}
pub const Conn = struct {
allocator: *std.mem.Allocator,
prng: std.rand.DefaultPrng,
gateway_url: []u8,
intents: Intents,
https_client: HTTPS,
https_client_buf: [256]u8, //arbitrarily chosen; TODO: audit
wss_client: WSS,
wss_client_buf: [256]u8, //arbitrarily chosen; TODO: audit
ns_heartbeat_interval: u64,
last_sequence: std.atomic.Int(u64),
session_id: ?[]u8,
pub fn create(allocator: *std.mem.Allocator, token: []const u8, intents: Intents, handler: fn (*Conn, Event) void) !void {
const self = try allocator.create(Conn);
defer allocator.destroy(self);
self.allocator = allocator;
self.prng = std.rand.DefaultPrng.init(0);
self.intents = intents;
self.last_sequence = std.atomic.Int(u64).init(0);
var prng = std.rand.DefaultPrng.init(0);
const rand = &prng.random;
//init https connection
const http_sock = try std.net.tcpConnectToHost(self.allocator, domains.main, 443);
var http_sock_TLS = try iguanatls.client_connect(.{
.cert_verifier = .none,
.reader = http_sock.reader(),
.writer = http_sock.writer(),
.rand = rand,
.temp_allocator = self.allocator,
}, domains.main);
self.https_client = hzzp.base.client.create(
&self.https_client_buf,
http_sock_TLS.reader(),
http_sock_TLS.writer(),
);
//ask discord for ws gateway URL
self.gateway_url = try getGatewayURL(&self.https_client, self.allocator);
defer self.allocator.free(self.gateway_url);
//initialise wss connection
const ws_sock = try std.net.tcpConnectToHost(allocator, self.gateway_url["wss://".len..], 443);
var ws_socket_TLS = try iguanatls.client_connect(.{
.cert_verifier = .none,
.reader = ws_sock.reader(),
.writer = ws_sock.writer(),
.rand = rand,
.temp_allocator = allocator,
}, self.gateway_url["wss://".len..]);
self.wss_client = wz.base.client.create(
&self.wss_client_buf,
ws_socket_TLS.reader(),
ws_socket_TLS.writer(),
);
try self.wss_client.handshakeStart("/?v=8&encoding=json");
try self.wss_client.handshakeAddHeaderValue("Host", self.gateway_url["wss://".len..]);
try self.wss_client.handshakeAddHeaderValue("authorization", token);
try self.wss_client.handshakeAddHeaderValue("User-Agent", user_agent);
try self.wss_client.handshakeFinish();
//skips the first header, parses the discord hello payload
_ = (try self.wss_client.next()) orelse return error.NoHelloReceived;
self.ns_heartbeat_interval = if (try self.wss_client.next()) |event| blk: {
var parser = std.json.Parser.init(self.allocator, true);
defer parser.deinit();
var tree = try parser.parse(event.chunk.data);
defer tree.deinit();
const err = error.InvalidGatewayHello;
const root_obj = switch (tree.root) {
.Object => |root_obj| root_obj,
else => return err,
};
switch (root_obj.get("op") orelse return err) {
.Integer => |opcode| {
if (opcode != 10) return err;
},
else => return err,
}
break :blk switch (root_obj.get("d") orelse return err) {
.Object => |d_obj| switch (d_obj.get("heartbeat_interval") orelse return err) {
.Integer => |x| @intCast(u32, x),
else => return err,
},
else => return err,
} * @intCast(u64, std.time.ns_per_ms);
} else return error.NoHelloReceived;
//send identify payload
var tmp = std.ArrayList(u8).init(allocator);
defer tmp.deinit();
try tmp.writer().print(
\\{{
\\ "op":2,
\\ "d":{{
\\ "token":"{s}",
\\ "intents":{d},
\\ "properties":{{
\\ "$os":"{s}",
\\ "$browser":"{s}",
\\ "$device":"{s}"
\\ }}
\\ }}
\\}}
,
.{
token,
@bitCast(std.meta.Int(.unsigned, @bitSizeOf(Intents)), intents),
@tagName(std.builtin.Target.current.os.tag),
user_agent,
user_agent,
},
);
try self.wss_client.writeHeader(.{ .opcode = .Text, .length = tmp.items.len });
try self.wss_client.writeChunk(tmp.items);
_ = try std.Thread.spawn(self, heartbeatThread);
defer if (self.session_id) |s| self.allocator.free(s);
//pass each discord event to handler
var discord_event_buffer = std.ArrayList(u8).init(allocator);
defer discord_event_buffer.deinit();
var last_header: ?wz.base.client.MessageHeader = null;
while (try self.wss_client.next()) |event| switch (event) {
.header => |h| last_header = h,
.chunk => |c| {
try discord_event_buffer.appendSlice(c.data);
if (!c.final) continue;
defer discord_event_buffer.shrinkAndFree(0);
if (last_header.opcode == .Close) {
const x =
\\{
\\ "op": {d},
\\ "d": {
\\ "token": "{s}",
\\ "session_id": "{s}",
\\ "seq": {d}
\\ }
\\}
;
}
var parser = std.json.Parser.init(self.allocator, true);
defer parser.deinit();
std.debug.print("{s}\n", .{discord_event_buffer.items});
var tree = try parser.parse(discord_event_buffer.items);
defer tree.deinit();
const root_obj = switch (tree.root) {
.Object => |root_obj| root_obj,
else => return Event.err,
};
if (root_obj.get("s")) |s| switch (s) {
.Integer => |i| self.last_sequence.set(@intCast(u64, i)),
.Null => {},
else => {
return Event.err;
},
};
switch (switch (root_obj.get("op") orelse return Event.err) {
.Integer => |i| i,
else => return Event.err,
}) {
0 => {
const ev = try Event.fromRaw(root_obj);
switch (ev) {
.ready => |r| {
self.session_id = try self.allocator.dupe(u8, r.session_id);
},
else => {},
}
handler(self, ev);
},
else => {},
}
},
};
}
};
/// caller must free returned memory
fn getGatewayURL(https: *HTTPS, allocator: *std.mem.Allocator) ![]u8 {
try https.writeStatusLine("GET", endpoints.gateway);
try https.writeHeader(.{ .name = "Host", .value = domains.main });
try https.finishHeaders();
try https.writePayload(null);
while (try https.next()) |event| switch (event) {
.payload => |pl| {
var parser = std.json.Parser.init(allocator, true);
defer parser.deinit();
var tree = try parser.parse(pl.data);
defer tree.deinit();
if (tree.root != .Object) return error.InvalidGatewayResponse;
if (tree.root.Object.get("url")) |url| {
if (url != .String) return error.InvalidGatewayResponse;
return allocator.dupe(u8, url.String);
} else return error.InvalidGatewayResponse;
},
.end => break,
else => continue,
};
return error.NoGatewayResponse;
}
pub const Event = union(enum) {
const err = error.InvalidEvent;
message_create: MessageCreate,
ready: Ready,
unknown: std.json.ObjectMap,
pub const MessageCreate = struct {
id: []const u8,
channel_id: []const u8,
guild_id: []const u8,
content: []const u8,
author: struct {
username: []const u8,
id: []const u8,
},
pub fn format(
self: MessageCreate,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
try writer.print(
\\MessageCreate{{
\\ .id = "{s}",
\\ .channel_id = "{s}",
\\ .guild_id = "{s}",
\\ .content = "{s}",
\\ .author = {{
\\ .username = "{s}",
\\ .id = "{s}",
\\ }}
\\}}
, .{ self.id, self.channel_id, self.guild_id, self.content, self.author.username, self.author.id });
}
fn parse(d: std.json.ObjectMap) !MessageCreate {
const author = switch (d.get("author") orelse return err) {
.Object => |o| o,
else => return err,
};
return MessageCreate{
.id = switch (d.get("id") orelse return err) {
.String => |s| s,
else => return err,
},
.channel_id = switch (d.get("channel_id") orelse return err) {
.String => |s| s,
else => return err,
},
.guild_id = switch (d.get("guild_id") orelse return err) {
.String => |s| s,
else => return err,
},
.content = switch (d.get("content") orelse return err) {
.String => |s| s,
else => return err,
},
.author = .{
.username = switch (author.get("username") orelse return err) {
.String => |s| s,
else => return err,
},
.id = switch (author.get("id") orelse return err) {
.String => |s| s,
else => return err,
},
},
};
}
};
pub const Ready = struct {
v: i64,
session_id: []const u8,
user: struct {
username: []const u8,
id: []const u8,
},
fn parse(d: std.json.ObjectMap) !Ready {
const user = switch (d.get("user") orelse return err) {
.Object => |o| o,
else => return err,
};
return Ready{
.v = switch (d.get("v") orelse return err) {
.Integer => |i| i,
else => return err,
},
.session_id = switch (d.get("session_id") orelse return err) {
.String => |s| s,
else => return err,
},
.user = .{
.username = switch (user.get("username") orelse return err) {
.String => |s| s,
else => return err,
},
.id = switch (user.get("id") orelse return err) {
.String => |s| s,
else => return err,
},
},
};
}
pub fn format(
self: Ready,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
try writer.print(
\\Ready{{
\\ .v = "{s}",
\\ .session_id = "{s}",
\\ .user = {{
\\ .username = "{s}",
\\ .id = "{s}",
\\ }}
\\}}
, .{ self.v, self.session_id, self.user.username, self.user.id });
}
};
fn fromRaw(root_obj: std.json.ObjectMap) !Event {
const payload_string = switch (root_obj.get("t") orelse return err) {
.String => |s| s,
else => return err,
};
const d = switch (root_obj.get("d") orelse return err) {
.Object => |o| o,
else => return err,
};
if (std.mem.eql(u8, payload_string, "MESSAGE_CREATE"))
return Event{ .message_create = try Event.MessageCreate.parse(d) };
if (std.mem.eql(u8, payload_string, "READY"))
return Event{ .ready = try Event.Ready.parse(d) };
return Event{ .unknown = d };
}
};
const domains = struct {
const main = "discordapp.com";
};
const user_agent = "zigcord/0.0.1";
const endpoints = struct {
const api = "/api";
const gateway = api ++ "/gateway";
};
|
zigcord.zig
|
const std = @import("std");
const c_locale = @cImport(@cInclude("locale.h"));
const argparser = @import("argparser.zig");
const core = @import("core.zig");
const curses = @import("curses.zig");
const cursesui = @import("cursesui.zig");
const help = @import("help.zig");
pub fn main() anyerror!void {
const allocator = std.heap.c_allocator;
// displaying unicode characters in curses needs this and cursesw in build.zig
_ = c_locale.setlocale(c_locale.LC_ALL, "");
var args = try argparser.parse(allocator);
var buf: [8]u8 = undefined;
try std.os.getrandom(buf[0..]);
var default_prng = std.rand.DefaultPrng.init(std.mem.readIntSliceLittle(u64, buf[0..]));
const rnd = &default_prng.random;
var game = try core.Game.init(allocator, args.width, args.height, args.nmines, rnd);
defer game.deinit();
const stdscr = try curses.initscr(allocator);
var endwin_called: bool = false;
defer {
if (!endwin_called) {
curses.endwin() catch {}; // failures are ignored because not much can be done to them
}
}
_ = try curses.curs_set(0);
_ = try stdscr.keypad(true);
var ui = try cursesui.Ui.init(&game, stdscr, args.characters, args.color);
if (!try ui.onResize()) {
endwin_called = true;
return;
}
// FIXME: the help doesn't fit in 80x24 terminal
const key_bindings = comptime[_]help.KeyBinding{
help.KeyBinding{ .key = "q", .help = "quit the game" },
help.KeyBinding{ .key = "h", .help = "show this help" },
help.KeyBinding{ .key = "n", .help = "new game" },
help.KeyBinding{ .key = "arrow keys", .help = "move the selection" },
help.KeyBinding{ .key = "enter", .help = "open the selected square" },
help.KeyBinding{ .key = "f", .help = "flag or unflag the selected square" },
help.KeyBinding{ .key = "d", .help = "open all non-flagged neighbors if the correct number of them are flagged" },
help.KeyBinding{ .key = "e", .help = "like pressing d in all the squares" },
};
ui.setStatusMessage("Press h for help.");
while (true) {
try stdscr.erase();
try ui.draw(allocator);
switch (try stdscr.getch()) {
'Q', 'q' => return,
'N', 'n' => game = try core.Game.init(allocator, args.width, args.height, args.nmines, rnd),
'H', 'h' => {
const help_fit_on_terminal = try help.show(stdscr, key_bindings[0..], allocator);
// terminal may have been resized while looking at help
if (!try ui.onResize()) {
endwin_called = true;
return;
}
if (!help_fit_on_terminal) {
ui.setStatusMessage("Please make your terminal bigger to read the help message.");
}
},
curses.KEY_RESIZE => {
if (!try ui.onResize()) {
endwin_called = true;
return;
}
},
curses.KEY_LEFT => ui.moveSelection(-1, 0),
curses.KEY_RIGHT => ui.moveSelection(1, 0),
curses.KEY_UP => ui.moveSelection(0, -1),
curses.KEY_DOWN => ui.moveSelection(0, 1),
'\n' => ui.openSelected(),
'F', 'f' => ui.toggleFlagSelected(),
'D', 'd' => ui.openAroundIfSafe(),
'E', 'e' => ui.openAroundEverythingSafe(),
else => {},
}
}
}
|
src/main.zig
|
const std = @import("std");
const assert = std.debug.assert;
const c = @import("c.zig");
pub const Mat4x4 = struct {
data: [4][4]f32,
pub const identity = Mat4x4{
.data = [_][4]f32{
[_]f32{ 1.0, 0.0, 0.0, 0.0 },
[_]f32{ 0.0, 1.0, 0.0, 0.0 },
[_]f32{ 0.0, 0.0, 1.0, 0.0 },
[_]f32{ 0.0, 0.0, 0.0, 1.0 },
},
};
/// matrix multiplication
pub fn mult(m: Mat4x4, other: Mat4x4) Mat4x4 {
return Mat4x4{
.data = [_][4]f32{
[_]f32{
m.data[0][0] * other.data[0][0] + m.data[0][1] * other.data[1][0] + m.data[0][2] * other.data[2][0] + m.data[0][3] * other.data[3][0],
m.data[0][0] * other.data[0][1] + m.data[0][1] * other.data[1][1] + m.data[0][2] * other.data[2][1] + m.data[0][3] * other.data[3][1],
m.data[0][0] * other.data[0][2] + m.data[0][1] * other.data[1][2] + m.data[0][2] * other.data[2][2] + m.data[0][3] * other.data[3][2],
m.data[0][0] * other.data[0][3] + m.data[0][1] * other.data[1][3] + m.data[0][2] * other.data[2][3] + m.data[0][3] * other.data[3][3],
},
[_]f32{
m.data[1][0] * other.data[0][0] + m.data[1][1] * other.data[1][0] + m.data[1][2] * other.data[2][0] + m.data[1][3] * other.data[3][0],
m.data[1][0] * other.data[0][1] + m.data[1][1] * other.data[1][1] + m.data[1][2] * other.data[2][1] + m.data[1][3] * other.data[3][1],
m.data[1][0] * other.data[0][2] + m.data[1][1] * other.data[1][2] + m.data[1][2] * other.data[2][2] + m.data[1][3] * other.data[3][2],
m.data[1][0] * other.data[0][3] + m.data[1][1] * other.data[1][3] + m.data[1][2] * other.data[2][3] + m.data[1][3] * other.data[3][3],
},
[_]f32{
m.data[2][0] * other.data[0][0] + m.data[2][1] * other.data[1][0] + m.data[2][2] * other.data[2][0] + m.data[2][3] * other.data[3][0],
m.data[2][0] * other.data[0][1] + m.data[2][1] * other.data[1][1] + m.data[2][2] * other.data[2][1] + m.data[2][3] * other.data[3][1],
m.data[2][0] * other.data[0][2] + m.data[2][1] * other.data[1][2] + m.data[2][2] * other.data[2][2] + m.data[2][3] * other.data[3][2],
m.data[2][0] * other.data[0][3] + m.data[2][1] * other.data[1][3] + m.data[2][2] * other.data[2][3] + m.data[2][3] * other.data[3][3],
},
[_]f32{
m.data[3][0] * other.data[0][0] + m.data[3][1] * other.data[1][0] + m.data[3][2] * other.data[2][0] + m.data[3][3] * other.data[3][0],
m.data[3][0] * other.data[0][1] + m.data[3][1] * other.data[1][1] + m.data[3][2] * other.data[2][1] + m.data[3][3] * other.data[3][1],
m.data[3][0] * other.data[0][2] + m.data[3][1] * other.data[1][2] + m.data[3][2] * other.data[2][2] + m.data[3][3] * other.data[3][2],
m.data[3][0] * other.data[0][3] + m.data[3][1] * other.data[1][3] + m.data[3][2] * other.data[2][3] + m.data[3][3] * other.data[3][3],
},
},
};
}
/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
/// Input matrix multiplied by this rotation matrix.
/// angle: Rotation angle expressed in radians.
/// axis: Rotation axis, recommended to be normalized.
pub fn rotate(m: Mat4x4, angle: f32, axis_unnormalized: Vec3) Mat4x4 {
const cos = c.cosf(angle);
const s = c.sinf(angle);
const axis = axis_unnormalized.normalize();
const temp = axis.scale(1.0 - cos);
const rot = Mat4x4{
.data = [_][4]f32{
[_]f32{ cos + temp.data[0] * axis.data[0], 0.0 + temp.data[1] * axis.data[0] - s * axis.data[2], 0.0 + temp.data[2] * axis.data[0] + s * axis.data[1], 0.0 },
[_]f32{ 0.0 + temp.data[0] * axis.data[1] + s * axis.data[2], cos + temp.data[1] * axis.data[1], 0.0 + temp.data[2] * axis.data[1] - s * axis.data[0], 0.0 },
[_]f32{ 0.0 + temp.data[0] * axis.data[2] - s * axis.data[1], 0.0 + temp.data[1] * axis.data[2] + s * axis.data[0], cos + temp.data[2] * axis.data[2], 0.0 },
[_]f32{ 0.0, 0.0, 0.0, 0.0 },
},
};
return Mat4x4{
.data = [_][4]f32{
[_]f32{
m.data[0][0] * rot.data[0][0] + m.data[0][1] * rot.data[1][0] + m.data[0][2] * rot.data[2][0],
m.data[0][0] * rot.data[0][1] + m.data[0][1] * rot.data[1][1] + m.data[0][2] * rot.data[2][1],
m.data[0][0] * rot.data[0][2] + m.data[0][1] * rot.data[1][2] + m.data[0][2] * rot.data[2][2],
m.data[0][3],
},
[_]f32{
m.data[1][0] * rot.data[0][0] + m.data[1][1] * rot.data[1][0] + m.data[1][2] * rot.data[2][0],
m.data[1][0] * rot.data[0][1] + m.data[1][1] * rot.data[1][1] + m.data[1][2] * rot.data[2][1],
m.data[1][0] * rot.data[0][2] + m.data[1][1] * rot.data[1][2] + m.data[1][2] * rot.data[2][2],
m.data[1][3],
},
[_]f32{
m.data[2][0] * rot.data[0][0] + m.data[2][1] * rot.data[1][0] + m.data[2][2] * rot.data[2][0],
m.data[2][0] * rot.data[0][1] + m.data[2][1] * rot.data[1][1] + m.data[2][2] * rot.data[2][1],
m.data[2][0] * rot.data[0][2] + m.data[2][1] * rot.data[1][2] + m.data[2][2] * rot.data[2][2],
m.data[2][3],
},
[_]f32{
m.data[3][0] * rot.data[0][0] + m.data[3][1] * rot.data[1][0] + m.data[3][2] * rot.data[2][0],
m.data[3][0] * rot.data[0][1] + m.data[3][1] * rot.data[1][1] + m.data[3][2] * rot.data[2][1],
m.data[3][0] * rot.data[0][2] + m.data[3][1] * rot.data[1][2] + m.data[3][2] * rot.data[2][2],
m.data[3][3],
},
},
};
}
/// Builds a translation 4 * 4 matrix created from a vector of 3 components.
/// Input matrix multiplied by this translation matrix.
pub fn translate(m: Mat4x4, x: f32, y: f32, z: f32) Mat4x4 {
return Mat4x4{
.data = [_][4]f32{
[_]f32{ m.data[0][0], m.data[0][1], m.data[0][2], m.data[0][3] + m.data[0][0] * x + m.data[0][1] * y + m.data[0][2] * z },
[_]f32{ m.data[1][0], m.data[1][1], m.data[1][2], m.data[1][3] + m.data[1][0] * x + m.data[1][1] * y + m.data[1][2] * z },
[_]f32{ m.data[2][0], m.data[2][1], m.data[2][2], m.data[2][3] + m.data[2][0] * x + m.data[2][1] * y + m.data[2][2] * z },
[_]f32{ m.data[3][0], m.data[3][1], m.data[3][2], m.data[3][3] },
},
};
}
pub fn translateByVec(m: Mat4x4, v: Vec3) Mat4x4 {
return m.translate(v.data[0], v.data[1], v.data[2]);
}
/// Builds a scale 4 * 4 matrix created from 3 scalars.
/// Input matrix multiplied by this scale matrix.
pub fn scale(m: Mat4x4, x: f32, y: f32, z: f32) Mat4x4 {
return Mat4x4{
.data = [_][4]f32{
[_]f32{ m.data[0][0] * x, m.data[0][1] * y, m.data[0][2] * z, m.data[0][3] },
[_]f32{ m.data[1][0] * x, m.data[1][1] * y, m.data[1][2] * z, m.data[1][3] },
[_]f32{ m.data[2][0] * x, m.data[2][1] * y, m.data[2][2] * z, m.data[2][3] },
[_]f32{ m.data[3][0] * x, m.data[3][1] * y, m.data[3][2] * z, m.data[3][3] },
},
};
}
pub fn transpose(m: Mat4x4) Mat4x4 {
return Mat4x4{
.data = [_][4]f32{
[_]f32{ m.data[0][0], m.data[1][0], m.data[2][0], m.data[3][0] },
[_]f32{ m.data[0][1], m.data[1][1], m.data[2][1], m.data[3][1] },
[_]f32{ m.data[0][2], m.data[1][2], m.data[2][2], m.data[3][2] },
[_]f32{ m.data[0][3], m.data[1][3], m.data[2][3], m.data[3][3] },
},
};
}
/// Creates a matrix for an orthographic parallel viewing volume.
pub fn ortho(left: f32, right: f32, bottom: f32, top: f32) Mat4x4 {
var m = identity;
m.data[0][0] = 2.0 / (right - left);
m.data[1][1] = 2.0 / (top - bottom);
m.data[2][2] = -1.0;
m.data[0][3] = -(right + left) / (right - left);
m.data[1][3] = -(top + bottom) / (top - bottom);
return m;
}
};
pub const Vec3 = struct {
data: [3]f32,
pub fn init(x: f32, y: f32, z: f32) Vec3 {
return Vec3{
.data = [_]f32{ x, y, z },
};
}
pub fn normalize(v: Vec3) Vec3 {
return v.scale(1.0 / c.sqrtf(v.dot(v)));
}
pub fn scale(v: Vec3, scalar: f32) Vec3 {
return Vec3{
.data = [_]f32{
v.data[0] * scalar,
v.data[1] * scalar,
v.data[2] * scalar,
},
};
}
pub fn dot(v: Vec3, other: Vec3) f32 {
return v.data[0] * other.data[0] +
v.data[1] * other.data[1] +
v.data[2] * other.data[2];
}
pub fn length(v: Vec3) f32 {
return c.sqrtf(v.dot(v));
}
/// returns the cross product
pub fn cross(v: Vec3, other: Vec3) Vec3 {
return Vec3{
.data = [_]f32{
v.data[1] * other.data[2] - other.data[1] * v.data[2],
v.data[2] * other.data[0] - other.data[2] * v.data[0],
v.data[0] * other.data[1] - other.data[0] * v.data[1],
},
};
}
pub fn add(v: Vec3, other: Vec3) Vec3 {
return Vec3{
.data = [_]f32{
v.data[0] + other.data[0],
v.data[1] + other.data[1],
v.data[2] + other.data[2],
},
};
}
};
pub const Vec4 = struct {
data: [4]f32,
pub fn init(xa: f32, xb: f32, xc: f32, xd: f32) Vec4 {
return Vec4{
.data = [_]f32{ xa, xb, xc, xd },
};
}
};
test "scale" {
const m = Mat4x4{
.data = [_][4]f32{
[_]f32{ 0.840188, 0.911647, 0.277775, 0.364784 },
[_]f32{ 0.394383, 0.197551, 0.55397, 0.513401 },
[_]f32{ 0.783099, 0.335223, 0.477397, 0.95223 },
[_]f32{ 0.79844, 0.76823, 0.628871, 0.916195 },
},
};
const expected = Mat4x4{
.data = [_][4]f32{
[_]f32{ 0.118973, 0.653922, 0.176585, 0.364784 },
[_]f32{ 0.0558456, 0.141703, 0.352165, 0.513401 },
[_]f32{ 0.110889, 0.240454, 0.303487, 0.95223 },
[_]f32{ 0.113061, 0.551049, 0.399781, 0.916195 },
},
};
const answer = m.scale(0.141603, 0.717297, 0.635712);
assert_matrix_eq(answer, expected);
}
test "translate" {
const m = Mat4x4{
.data = [_][4]f32{
[_]f32{ 0.840188, 0.911647, 0.277775, 0.364784 },
[_]f32{ 0.394383, 0.197551, 0.55397, 0.513401 },
[_]f32{ 0.783099, 0.335223, 0.477397, 0.95223 },
[_]f32{ 0.79844, 0.76823, 0.628871, 1.0 },
},
};
const expected = Mat4x4{
.data = [_][4]f32{
[_]f32{ 0.840188, 0.911647, 0.277775, 1.31426 },
[_]f32{ 0.394383, 0.197551, 0.55397, 1.06311 },
[_]f32{ 0.783099, 0.335223, 0.477397, 1.60706 },
[_]f32{ 0.79844, 0.76823, 0.628871, 1.0 },
},
};
const answer = m.translate(0.141603, 0.717297, 0.635712);
assert_matrix_eq(answer, expected);
}
test "ortho" {
const m = Mat4x4.ortho(0.840188, 0.394383, 0.783099, 0.79844);
const expected = Mat4x4{
.data = [_][4]f32{
[_]f32{ -4.48627, 0.0, 0.0, 2.76931 },
[_]f32{ 0.0, 130.371, 0.0, -103.094 },
[_]f32{ 0.0, 0.0, -1.0, 0.0 },
[_]f32{ 0.0, 0.0, 0.0, 1.0 },
},
};
assert_matrix_eq(m, expected);
}
fn assert_f_eq(left: f32, right: f32) void {
const diff = c.fabsf(left - right);
assert(diff < 0.01);
}
fn assert_matrix_eq(left: Mat4x4, right: Mat4x4) void {
assert_f_eq(left.data[0][0], right.data[0][0]);
assert_f_eq(left.data[0][1], right.data[0][1]);
assert_f_eq(left.data[0][2], right.data[0][2]);
assert_f_eq(left.data[0][3], right.data[0][3]);
assert_f_eq(left.data[1][0], right.data[1][0]);
assert_f_eq(left.data[1][1], right.data[1][1]);
assert_f_eq(left.data[1][2], right.data[1][2]);
assert_f_eq(left.data[1][3], right.data[1][3]);
assert_f_eq(left.data[2][0], right.data[2][0]);
assert_f_eq(left.data[2][1], right.data[2][1]);
assert_f_eq(left.data[2][2], right.data[2][2]);
assert_f_eq(left.data[2][3], right.data[2][3]);
assert_f_eq(left.data[3][0], right.data[3][0]);
assert_f_eq(left.data[3][1], right.data[3][1]);
assert_f_eq(left.data[3][2], right.data[3][2]);
assert_f_eq(left.data[3][3], right.data[3][3]);
}
test "mult" {
const m1 = Mat4x4{
.data = [_][4]f32{
[_]f32{ 0.635712, 0.717297, 0.141603, 0.606969 },
[_]f32{ 0.0163006, 0.242887, 0.137232, 0.804177 },
[_]f32{ 0.156679, 0.400944, 0.12979, 0.108809 },
[_]f32{ 0.998924, 0.218257, 0.512932, 0.839112 },
},
};
const m2 = Mat4x4{
.data = [_][4]f32{
[_]f32{ 0.840188, 0.394383, 0.783099, 0.79844 },
[_]f32{ 0.911647, 0.197551, 0.335223, 0.76823 },
[_]f32{ 0.277775, 0.55397, 0.477397, 0.628871 },
[_]f32{ 0.364784, 0.513401, 0.95223, 0.916195 },
},
};
const answer = Mat4x4{
.data = [_][4]f32{
[_]f32{ 1.44879, 0.782479, 1.38385, 1.70378 },
[_]f32{ 0.566593, 0.543299, 0.925461, 1.02269 },
[_]f32{ 0.572904, 0.268761, 0.422673, 0.614428 },
[_]f32{ 1.48683, 1.15203, 1.89932, 2.05661 },
},
};
const tmp = m1.mult(m2);
assert_matrix_eq(tmp, answer);
}
test "rotate" {
const m1 = Mat4x4{
.data = [_][4]f32{
[_]f32{ 0.840188, 0.911647, 0.277775, 0.364784 },
[_]f32{ 0.394383, 0.197551, 0.55397, 0.513401 },
[_]f32{ 0.783099, 0.335223, 0.477397, 0.95223 },
[_]f32{ 0.79844, 0.76823, 0.628871, 0.916195 },
},
};
const angle = 0.635712;
const axis = Vec3.init(0.606969, 0.141603, 0.717297);
const expected = Mat4x4{
.data = [_][4]f32{
[_]f32{ 1.17015, 0.488019, 0.0821911, 0.364784 },
[_]f32{ 0.444151, 0.212659, 0.508874, 0.513401 },
[_]f32{ 0.851739, 0.126319, 0.460555, 0.95223 },
[_]f32{ 1.06829, 0.530801, 0.447396, 0.916195 },
},
};
const actual = m1.rotate(angle, axis);
assert_matrix_eq(actual, expected);
}
|
src/math3d.zig
|
const std = @import("std");
const iup = @import("iup.zig");
var dlg_id: i32 = 0;
var allocator: std.mem.Allocator = undefined;
const MainLoop = iup.MainLoop;
const Dialog = iup.Dialog;
const Button = iup.Button;
const MessageDlg = iup.MessageDlg;
const Multiline = iup.Multiline;
const Label = iup.Label;
const Text = iup.Text;
const VBox = iup.VBox;
const HBox = iup.HBox;
const Menu = iup.Menu;
const SubMenu = iup.SubMenu;
const Separator = iup.Separator;
const Fill = iup.Fill;
const Item = iup.Item;
const FileDlg = iup.FileDlg;
const Toggle = iup.Toggle;
const List = iup.List;
const Frame = iup.Frame;
const Radio = iup.Radio;
const Canvas = iup.Canvas;
const ScreenSize = iup.ScreenSize;
const Image = iup.Image;
const ImageRgb = iup.ImageRgb;
const ImageRgba = iup.ImageRgba;
const Rgb = iup.Rgb;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
allocator = gpa.allocator();
try MainLoop.open();
defer MainLoop.close();
var dlg = try createParentMdi();
defer dlg.deinit();
try dlg.showXY(.Center, .Center);
try MainLoop.beginLoop();
}
fn createParentMdi() !*Dialog {
var win_menu = try (Menu.init()
.setChildren(
.{
Item.init()
.setActionCallback(onTileHorizontal)
.setTitle("Tile Horizontal"),
Item.init()
.setActionCallback(onTileVertical)
.setTitle("Tile Vertical"),
Item.init()
.setActionCallback(onCascade)
.setTitle("Cascade"),
Item.init()
.setActionCallback(onIconArrange)
.setTitle("Icon Arrange"),
Item.init()
.setActionCallback(onCloseAll)
.setTitle("Close All"),
Separator.init(),
Item.init()
.setActionCallback(onNext)
.setTitle("Next"),
Item.init()
.setActionCallback(onPrevious)
.setTitle("Previous"),
},
).unwrap());
var menu = try (Menu.init().setChildren(
.{
SubMenu.init()
.setTitle("MDI")
.setChildren(
.{
Item.init()
.setTitle("New")
.setActionCallback(onNewChild),
},
),
SubMenu.init()
.setTitle("Window")
.setChildren(
.{
win_menu,
},
),
},
).unwrap());
return try (Dialog.init()
.setMdiFrame(true)
.setRasterSize(800, 600)
.setTitle("MDI Frame")
.setMenu(menu)
.setChildren(
.{
Canvas.init()
.setMdiMenu(win_menu)
.setMdiClient(true),
},
).unwrap());
}
fn createDialog(parent: *Dialog, id: i32) !*Dialog {
const title = try std.fmt.allocPrintZ(allocator, "MDI Child ({})", .{id});
defer allocator.free(title);
var img1 = try images.getImg1();
var img2 = try images.getImg2();
var frame1 = Frame.init()
.setTitle("IupButton")
.setChildren(
.{
VBox.init()
.setChildren(
.{
Button.init()
.setTitle("Button Text"),
Button.init()
.setBgColor(.{ .r = 255, .g = 128, .b = 0 })
.setRasterSize(30, 30),
Button.init()
.setImage(img1),
Button.init()
.setImage(img1)
.setFlat(true),
Button.init()
.setImage(img1)
.setImPress(img2),
},
),
},
);
var frame2 = Frame.init()
.setTitle("IupLabel")
.setChildren(
.{
VBox.init()
.setChildren(
.{
Label.init()
.setTitle("Label Text\nLine 2\nLine 3"),
Label.init()
.setSeparator(.Horizontal),
Label.init()
.setImage(img1),
},
),
},
);
var frame3 = Frame.init()
.setTitle("IupToggle")
.setChildren(
.{
VBox.init()
.setChildren(
.{
Toggle.init()
.setTitle("Toggle Text")
.setValue(.On),
Toggle.init()
.setTitle("3State Text")
.set3State(true)
.setValue(.NotDef),
Toggle.init()
.setImage(img1)
.setImPress(img2),
Frame.init()
.setTitle("IupRadio")
.setChildren(
.{
Radio.init()
.setChildren(
.{
VBox.init().setChildren(
.{
Toggle.init()
.setTitle("Toggle Text"),
Toggle.init()
.setTitle("Toggle Text"),
},
),
},
),
},
),
},
),
},
);
var frame4 = Frame.init()
.setTitle("IupText/IupMultiline")
.setChildren(
.{
VBox.init()
.setChildren(
.{
Text.init()
.setSize(80, null)
.setValue("IupText Text"),
Multiline.init()
.setSize(80, 60)
.setExpand(.Yes)
.setValue(
\\IupMultiline Text
\\Second Line
\\Third Line
),
},
),
},
);
var frame5 = Frame.init()
.setTitle("IupList")
.setChildren(
.{
VBox.init()
.setChildren(
.{
List.init()
.setExpand(.Yes)
.setMultiple(true)
.setValue("1")
.setItems(1, "Item 1 Text")
.setItems(2, "Item 2 Text")
.setItems(3, "Item 3 Text Big Item")
.setItems(4, "Item 4 Text")
.setItems(5, "Item 5 Text")
.setItems(6, "Item 6 Text"),
List.init()
.setDropDown(true)
.setExpand(.Yes)
.setVisibleItems(3)
.setValue("2")
.setItems(1, "Item 1 Text")
.setItems(2, "Item 2 Text")
.setItems(3, "Item 3 Text Big Item")
.setItems(4, "Item 4 Text")
.setItems(5, "Item 5 Text")
.setItems(6, "Item 6 Text"),
List.init()
.setEditBox(true)
.setExpand(.Yes)
.setValue("Test Value")
.setItems(1, "Item 1 Text")
.setItems(2, "Item 2 Text")
.setItems(3, "Item 3 Text Big Item")
.setItems(4, "Item 4 Text")
.setItems(5, "Item 5 Text")
.setItems(6, "Item 6 Text"),
},
),
},
);
return try (Dialog.init()
.setTitle(title)
.setParentDialog(parent)
.setMdiChild(true)
.setChildren(
.{
VBox.init()
.setMargin(5, 5)
.setAlignment(.ARight)
.setGap(5)
.setChildren(
.{
HBox.init().setChildren(
.{
frame1,
frame2,
frame3,
frame4,
frame5,
},
),
Canvas.init(),
},
),
},
)
.unwrap());
}
fn onNewChild(item: *Item) !void {
var parent = item.getDialog() orelse unreachable;
dlg_id += 1;
var dlg = try createDialog(parent, dlg_id);
try dlg.show();
}
fn onTileHorizontal(item: *Item) !void {
var dlg = item.getDialog() orelse unreachable;
_ = dlg;
//dlg.mdiArrange(.TileHorizontal);
}
fn onTileVertical(item: *Item) !void {
var dlg = item.getDialog() orelse unreachable;
_ = dlg;
//dlg.mdiArrange(.TileVertical);
}
fn onCascade(item: *Item) !void {
var dlg = item.getDialog() orelse unreachable;
_ = dlg;
//dlg.mdiArrange(.Cascade);
}
fn onIconArrange(item: *Item) !void {
var dlg = item.getDialog() orelse unreachable;
_ = dlg;
//dlg.mdiArrange(.Icon);
}
fn onCloseAll(item: *Item) !void {
var dlg = item.getDialog() orelse unreachable;
_ = dlg;
//dlg.mdiCloseAll();
}
fn onNext(item: *Item) !void {
_ = item;
}
fn onPrevious(item: *Item) !void {
_ = item;
}
const images = struct {
const bits_1 = [_]u8{ // zig fmt: off
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1
,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1
,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1
,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1
,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1
,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1
,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1
,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,0,2,0,2,0,2,2,0,2,2,2,0,0,0,2,2,2,0,0,2,0,2,2,0,0,0,2,2,2
,2,2,2,0,2,0,0,2,0,0,2,0,2,0,2,2,2,0,2,0,2,2,0,0,2,0,2,2,2,0,2,2
,2,2,2,0,2,0,2,2,0,2,2,0,2,2,2,2,2,0,2,0,2,2,2,0,2,0,2,2,2,0,2,2
,2,2,2,0,2,0,2,2,0,2,2,0,2,2,0,0,0,0,2,0,2,2,2,0,2,0,0,0,0,0,2,2
,2,2,2,0,2,0,2,2,0,2,2,0,2,0,2,2,2,0,2,0,2,2,2,0,2,0,2,2,2,2,2,2
,2,2,2,0,2,0,2,2,0,2,2,0,2,0,2,2,2,0,2,0,2,2,0,0,2,0,2,2,2,0,2,2
,2,2,2,0,2,0,2,2,0,2,2,0,2,2,0,0,0,0,2,2,0,0,2,0,2,2,0,0,0,2,2,2
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,0,2,2,2,2,2,2,2,2
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,0,2,2,2,2,2,2,2,2,2
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1
,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1
,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1
,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1
,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
}; // zig fmt: on
const bits_2 = [_]u8{ // zig fmt: off
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2
,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2
,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2
,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2
,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2
,2,2,2,2,2,2,2,2,2,2,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2
,2,2,2,2,2,2,2,2,2,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2
,2,2,2,2,2,2,2,2,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2
,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
,3,3,3,0,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
,3,3,3,0,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
,3,3,3,0,3,0,3,0,3,3,0,3,3,3,1,1,0,3,3,3,0,0,3,0,3,3,0,0,0,3,3,3
,3,3,3,0,3,0,0,3,0,0,3,0,3,0,1,1,3,0,3,0,3,3,0,0,3,0,3,3,3,0,3,3
,3,3,3,0,3,0,3,3,0,3,3,0,3,3,1,1,3,0,3,0,3,3,3,0,3,0,3,3,3,0,3,3
,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
,3,3,3,0,3,0,3,3,0,3,3,0,3,0,1,1,3,0,3,0,3,3,0,0,3,0,3,3,3,0,3,3
,3,3,3,0,3,0,3,3,0,3,3,0,3,3,1,1,0,0,3,3,0,0,3,0,3,3,0,0,0,3,3,3
,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,0,3,3,3,3,3,3,3,3
,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,0,3,3,3,0,3,3,3,3,3,3,3,3
,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,0,0,0,3,3,3,3,3,3,3,3,3
,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
,2,2,2,2,2,2,2,3,3,3,3,3,3,3,1,1,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,2,2,2,3,3,3,3,3,3,3,3,1,1,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
}; // zig fmt: on
pub fn getImg1() !*Image {
return try (Image.init(32, 32, bits_1[0..])
.setHandle("img1")
.setColors(0, .{ .r = 0, .g = 0, .b = 0 })
.setColors(1, Rgb.BG_COLOR)
.setColors(2, .{ .r = 255, .g = 0, .b = 0 })
.unwrap());
}
pub fn getImg2() !*Image {
return try (Image.init(32, 32, bits_2[0..])
.setHandle("img2")
.setColors(0, .{ .r = 0, .g = 0, .b = 0 })
.setColors(1, .{ .r = 0, .g = 255, .b = 0 })
.setColors(2, Rgb.BG_COLOR)
.setColors(3, .{ .r = 255, .g = 0, .b = 0 })
.unwrap());
}
};
|
src/mdi_example.zig
|
const std = @import("std");
const stdx = @import("stdx");
const gl = @import("gl");
const log = stdx.log.scoped(.shader);
pub const Shader = struct {
const Self = @This();
vert_id: gl.GLuint,
frag_id: gl.GLuint,
prog_id: gl.GLuint,
// Vertex array object used to record vbo layout.
vao_id: gl.GLuint,
pub fn init(vert_src: []const u8, frag_src: []const u8) !Self {
const vert_id = gl.createShader(gl.GL_VERTEX_SHADER);
var src_len = @intCast(c_int, vert_src.len);
var srcs = [_][]const u8{vert_src};
gl.shaderSource(vert_id, 1, @ptrCast(*[*c]const u8, &srcs), &src_len);
gl.compileShader(vert_id);
var res: i32 = 0;
gl.getShaderiv(vert_id, gl.GL_COMPILE_STATUS, &res);
if (res == gl.GL_FALSE) {
log.warn("failed to load vertex shader: {s}", .{vert_src});
var res_len: i32 = 0;
var buf = std.mem.zeroes([100]u8);
gl.getShaderInfoLog(vert_id, buf.len, &res_len, &buf);
log.warn("shader log: {s}", .{buf});
gl.deleteShader(vert_id);
return error.Failed;
}
const frag_id = gl.createShader(gl.GL_FRAGMENT_SHADER);
src_len = @intCast(c_int, frag_src.len);
srcs = [_][]const u8{frag_src};
gl.shaderSource(frag_id, 1, @ptrCast(*[*c]const u8, &srcs), &src_len);
gl.compileShader(frag_id);
gl.getShaderiv(frag_id, gl.GL_COMPILE_STATUS, &res);
if (res == gl.GL_FALSE) {
log.warn("failed to load fragment shader: {s}", .{frag_src});
var res_len: i32 = 0;
var buf = std.mem.zeroes([100]u8);
gl.getShaderInfoLog(frag_id, buf.len, &res_len, &buf);
log.warn("shader log: {s}", .{buf});
gl.deleteShader(frag_id);
return error.Failed;
}
const prog_id = gl.createProgram();
gl.attachShader(prog_id, vert_id);
gl.attachShader(prog_id, frag_id);
gl.linkProgram(prog_id);
gl.getProgramiv(prog_id, gl.GL_LINK_STATUS, &res);
if (res == gl.GL_FALSE) {
log.warn("failed to link shader program: {}", .{prog_id});
var res_len: i32 = undefined;
var buf: [100]u8 = undefined;
gl.getProgramInfoLog(prog_id, buf.len, &res_len, &buf);
log.warn("program log: {s}", .{buf});
gl.deleteProgram(prog_id);
return error.Failed;
}
// Cleanup.
gl.detachShader(prog_id, vert_id);
gl.deleteShader(vert_id);
gl.detachShader(prog_id, frag_id);
gl.deleteShader(frag_id);
var ids: [1]gl.GLuint = undefined;
gl.genVertexArrays(1, &ids);
return Shader{
.vao_id = ids[0],
.vert_id = vert_id,
.frag_id = frag_id,
.prog_id = prog_id,
};
}
pub fn deinit(self: Self) void {
gl.deleteVertexArrays(1, &self.vao_id);
gl.deleteProgram(self.prog_id);
gl.deleteShader(self.frag_id);
gl.deleteShader(self.vert_id);
}
pub fn getUniformLocation(self: Self, name: [:0]const u8) gl.GLint {
return gl.getUniformLocation(self.prog_id, name);
}
};
|
graphics/src/backend/gl/shader.zig
|
const std = @import("std");
const helper = @import("helper.zig");
const Allocator = std.mem.Allocator;
const input = @embedFile("../inputs/day08.txt");
const digits: [10][7]bool = .{
.{ true, true, true, false, true, true, true },
.{ false, false, true, false, false, true, false },
.{ true, false, true, true, true, false, true },
.{ true, false, true, true, false, true, true },
.{ false, true, true, true, false, true, false },
.{ true, true, false, true, false, true, true },
.{ true, true, false, true, true, true, true },
.{ true, false, true, false, false, true, false },
.{ true, true, true, true, true, true, true },
.{ true, true, true, true, false, true, true },
};
pub fn run(alloc: Allocator, stdout_: anytype) !void {
const parsed = try parseInput(alloc);
defer alloc.free(parsed);
const res1 = part1(parsed);
const res2 = part2(parsed);
if (stdout_) |stdout| {
try stdout.print("Part 1: {}\n", .{res1});
try stdout.print("Part 2: {}\n", .{res2});
}
}
const Entry = struct {
input: [10][]const u8,
output: [4][]const u8,
const Self = @This();
pub fn fromLine(line: []const u8) Self {
var sections = split(u8, line, "|");
const section1 = sections.next().?;
const section2 = sections.next().?;
var input_arr: [10][]u8 = undefined;
Self.populateHelper(section1, &input_arr);
var output_arr: [4][]u8 = undefined;
Self.populateHelper(section2, &output_arr);
return Self{ .input = input_arr, .output = output_arr };
}
fn populateHelper(section: []const u8, arr: [][]const u8) void {
var tokens = tokenize(u8, section, " ");
for (arr) |*elem| {
elem.* = tokens.next().?;
}
if (tokens.next() != null) unreachable;
}
};
fn part1(parsed: []Entry) i32 {
var counter: i32 = 0;
for (parsed) |*entry| {
for (entry.output) |output| {
const len = output.len;
if (len == 2 or len == 4 or len == 3 or len == 7) {
counter += 1;
}
}
}
return counter;
}
fn part2(parsed: []Entry) i32 {
var sum: i32 = 0;
for (parsed) |*entry| {
sum += solveEntry(entry);
}
return sum;
}
fn solveEntry(entry: *const Entry) i32 {
var letter_opts: [7][7]bool = .{.{true} ** 7} ** 7;
eliminateEasy(entry, &letter_opts);
// bruteforce is okay because there's exactly 8 possibilities to check
const letter_maps = bruteforceOpts(entry, &letter_opts);
return decipherEntry(entry, letter_maps);
}
fn eliminateEasy(entry: *const Entry, opts: *[7][7]bool) void {
for (entry.input) |inp| {
const digit: usize = switch (inp.len) {
2 => 1,
3 => 7,
4 => 4,
else => continue,
};
applyDigit(digit, inp, opts);
}
}
fn applyDigit(digit: usize, inp: []const u8, opts: *[7][7]bool) void {
for (opts) |*opt, i| {
const letter = @intCast(u8, i) + 'a';
const contained = std.mem.indexOfScalar(u8, inp, letter) != null;
applyDigitToOpt(digit, opt, contained);
}
}
fn applyDigitToOpt(digit: usize, opt: *[7]bool, contained: bool) void {
const digit_arr: []const bool = &digits[digit];
for (opt) |*field, i| {
if (digit_arr[i] != contained) {
field.* = false;
}
}
// optimized from:
//if (contained) {
// // only conserve stuff that's `true` in the digit's array
// for (opt) |*field, i| {
// if (!digit_arr[i]) {
// field.* = false;
// }
// }
//} else {
// // only conserve stuff that's `false` in the digit's array
// for (opt) |*field, i| {
// if (digit_arr[i]) {
// field.* = false;
// }
// }
//}
}
fn bruteforceOpts(entry: *const Entry, letter_opts: *const [7][7]bool) [7]usize {
// 8 because exactly 8 possibilities
const possible_meanings: [8][7]usize = getPossibleMeanings(letter_opts);
for (possible_meanings) |meaning| {
if (isConsistent(entry, &meaning)) return meaning;
}
unreachable; // the loop must find a consistent option
}
// this is so ugly
fn getPossibleMeanings(letter_opts: *const [7][7]bool) [8][7]usize {
var meanings: [8][7]usize = undefined;
for (meanings) |*meaning, i| {
const choices: [3]bool = getChoices(i);
var choice_idx: usize = 0;
var occupied: [7]bool = .{false} ** 7;
for (letter_opts) |*letter, letter_num| {
var available: i32 = 0;
for (letter) |opt, idx| {
if (!opt) continue;
if (occupied[idx]) continue;
available += 1;
}
const needs_choice = available == 2;
var chosen: bool = false;
for (letter) |opt, idx| {
if (!opt) continue;
if (occupied[idx]) continue;
if (!needs_choice or chosen) {
meaning[letter_num] = idx;
occupied[idx] = true;
break;
}
if (!choices[choice_idx]) {
choice_idx += 1;
meaning[letter_num] = idx;
occupied[idx] = true;
break;
} else {
choice_idx += 1;
chosen = true;
continue;
}
}
}
}
return meanings;
}
fn getChoices(x: usize) [3]bool {
return .{
x & 0b001 != 0,
x & 0b010 != 0,
x & 0b100 != 0,
};
}
fn isConsistent(entry: *const Entry, meaning: *const [7]usize) bool {
for (entry.input) |inp| {
switch (inp.len) {
2, 3, 4, 7 => continue, // these will always be consistent
else => {},
}
if (getDigit(inp, meaning) == null) return false;
}
return true;
}
fn getDigit(inp: []const u8, meaning: *const [7]usize) ?usize {
const digit = generateDigit(inp, meaning);
return findDigit(&digit);
}
fn generateDigit(inp: []const u8, meaning: *const [7]usize) [7]bool {
var digit: [7]bool = .{false} ** 7;
for (inp) |letter| {
const meaning_idx = @intCast(usize, letter - 'a');
const idx = meaning[meaning_idx];
digit[idx] = true;
}
return digit;
}
fn findDigit(digit_arr: *const [7]bool) ?usize {
for (digits) |*digit, i| {
if (std.mem.eql(bool, digit, digit_arr)) return i;
}
return null;
}
fn decipherEntry(entry: *const Entry, letter_maps: [7]usize) i32 {
var result: i32 = 0;
for (entry.output) |output| {
const digit = getDigit(output, &letter_maps).?;
result *= 10;
result += @intCast(i32, digit);
}
return result;
}
fn parseInput(alloc: Allocator) ![]Entry {
const num_lines = count(u8, input, "\n");
var entries = try alloc.alloc(Entry, num_lines);
var lines = tokenize(u8, input, "\r\n");
for (entries) |*entry| {
entry.* = Entry.fromLine(lines.next().?);
}
if (lines.next() != null) unreachable;
return entries;
}
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const count = std.mem.count;
const parseUnsigned = std.fmt.parseUnsigned;
const parseInt = std.fmt.parseInt;
const sort = std.sort.sort;
|
src/day08.zig
|
const messageNs = @import("message.zig");
const Message = messageNs.Message;
const MessageHeader = messageNs.MessageHeader;
const messageQueueNs = @import("message_queue.zig");
const MessageQueue = messageQueueNs.MessageQueue;
const SignalContext = messageQueueNs.SignalContext;
//const futex_wait = @import("futex.zig").futex_wait;
//const futex_wake = @import("futex.zig").futex_wake;
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const mem = std.mem;
const Allocator = mem.Allocator;
const DirectAllocator = std.heap.DirectAllocator;
//const AtomicOrder = builtin.AtomicOrder;
//const AtomicRmwOp = builtin.AtomicRmwOp;
/// A Message allocator messages which are preallocated and stored on
/// a MessageQueue which is a multi-producer single-consumer queue.
///
/// We assume one thread will be using get but many threads can use
/// put to return the messages.
///
/// TODO: 0) Not sure the signalFn is the best way to handle being
/// notified that there are now messages available. Although
/// I think having some way of knowing that could be useful.
///
/// 1) For performance using a Stack rather than a Queue would be
/// better as reusing a message that's recently been use could
/// have better performance.
///
/// 2) Using an array rather than a link list would probably
/// improve performance.
pub fn MessageAllocator() type {
return struct {
pub const Self = @This();
direct_allocator: DirectAllocator,
allocator: Allocator,
signalContext: SignalContext,
queue: MessageQueue(),
// Make sure message size is a multiple alignment
const alignment: u29 = 64;
msg_count: usize,
max_msg_size: usize,
buffer: [] align(alignment) u8,
pub fn init(pSelf: *Self, msg_count: usize, max_msg_body_size: usize) !void {
if (msg_count == 0) return error.MsgCountMustBeGreaterThanZero;
pSelf.direct_allocator = DirectAllocator.init();
pSelf.allocator = pSelf.direct_allocator.allocator;
pSelf.signalContext = 0;
pSelf.queue = MessageQueue().init(signalFn, &pSelf.signalContext);
// Allocate the buffer
pSelf.msg_count = msg_count;
pSelf.max_msg_size =
((@sizeOf(MessageHeader) + max_msg_body_size + alignment - 1) / alignment) * alignment;
pSelf.buffer = try pSelf.allocator.alignedAlloc(u8, alignment, msg_count * pSelf.max_msg_size);
// Carve up the buffer placing the messages on the queue
var i: usize = 0;
while (i < msg_count) {
assert(@byteOffsetOf(Message(packed struct {}), "header") == 0);
var pMh = @ptrCast(*MessageHeader, &pSelf.buffer[i * pSelf.max_msg_size]);
pMh.initEmpty();
pMh.cmd = 0xDeadbeef;
pSelf.put(pMh);
i += 1;
}
//warn("MessageAllocator.init: pSelf={*}\n", pSelf);
}
pub fn deinit(pSelf: *Self) void {
// TODO: On a test build, at lease, detect that all
// messages have been returned before deallocating.
//warn("MessageAllocator.deinit: pSelf={*}\n", pSelf);
pSelf.direct_allocator.deinit();
}
/// Put the message back, ignoring null pointers
pub fn put(pSelf: *Self, pMessageHeader: ?*MessageHeader) void {
if (pMessageHeader) |pMh| {
pSelf.queue.put(pMh);
}
}
/// Get a message initializing only MessageType.allocator
pub fn get(pSelf: *Self, comptime MessageType: type) ?*MessageType {
//warn("MessageAllocator.get: sizeOf(MessageType)={} max_msg_size={}\n",
// usize(@sizeOf(MessageType)), pSelf.max_msg_size);
if (@sizeOf(MessageType) > pSelf.max_msg_size) return null;
var pMh: *MessageHeader = pSelf.queue.get() orelse return null;
pMh.pAllocator = pSelf;
return MessageType.getMessagePtr(pMh);
}
// Maybe we want this signal to go to the entity (Actor) that owns
// this allocator so they do what need to do directly.
fn signalFn(pSignalContext: *SignalContext) void {
//warn("MessageAllocator.signalFn: {*}\n", pSignalContext);
//futex_wake(pSignalContext, 1);
}
};
}
test "MessageAllocator.1" {
var direct_allocator = DirectAllocator.init();
defer direct_allocator.deinit();
var allocator = direct_allocator.allocator;
// Test that we know how to use allocator.createOne
var pU32: *u32 = try allocator.createOne(u32);
defer allocator.destroy(pU32);
pU32.* = 123;
assert(pU32.* == 123);
// Create MyMa on the stack
var myMa1: MessageAllocator() = undefined;
try myMa1.init(2, 2048);
defer myMa1.deinit();
// Create a Msg type and an array of messages
const Msg = Message(packed struct {
const Self = @This();
buffer: [2048]u8,
pub fn init(pSelf: *Self) void {
mem.set(u8, pSelf.buffer[0..], 123);
}
});
var msgs: [2] *Msg = undefined;
// Get first 2 messages and be sure there is no overlap.
// We're assuming msgs[0] is adjacent and before msgs[1]
// which is the case now, but may not be in the future,
// for instance is we change to use a stack rather than
// a queue.
msgs[0] = myMa1.get(Msg) orelse return error.badmsgs0;
msgs[1] = myMa1.get(Msg) orelse return error.badmsgs1;
assert(@ptrToInt(&msgs[0].body.buffer[2047]) < @ptrToInt(&msgs[1]));
assert(myMa1.get(Msg) == null);
msgs[0].init(1);
assert(msgs[0].body.buffer[0] == 123);
// Put them back via header.allocator
if (msgs[0].header.pAllocator) |pA| pA.put(&msgs[0].header) else return error.HeaderAllocatorNotInitialized;
if (msgs[1].header.pAllocator) |pA| pA.put(&msgs[1].header) else return error.HeaderAllocatorNotInitialized;
// Verify we can get them again and this time we'll put them back directly
msgs[0] = myMa1.get(Msg) orelse return error.badmsgs0;
msgs[1] = myMa1.get(Msg) orelse return error.badmsgs1;
assert(myMa1.get(Msg) == null);
myMa1.put(&msgs[0].header);
myMa1.put(&msgs[1].header);
// Create MyMa using allocator
var myMa2 = try allocator.createOne(MessageAllocator());
defer allocator.destroy(myMa2);
try myMa2.init(10, 204);
defer myMa2.deinit();
}
|
message_allocator.zig
|
const std = @import("std");
const print = std.debug.print;
const fs = std.fs;
const c = @cImport({
@cInclude("linux/i2c.h");
@cInclude("linux/i2c-dev.h");
@cInclude("sys/ioctl.h");
@cInclude("sys/errno.h");
});
const i2c_msg = extern struct {
addr: u16,
flags: u16,
len: u16,
buf: *u8,
};
const i2c_rdwr_ioctl_data = extern struct {
msgs: *i2c_msg,
nmsgs: u32,
};
// TODO : fix lifetime issue on result without introducing a global
var result = [_]u8{0x0} ** c.I2C_SMBUS_BLOCK_MAX;
fn i2c_transfer(fd: fs.File, addr: u8, write_buffer: []u8, write_length: u8, read_length: u8) ?[]u8 {
if (write_length > c.I2C_SMBUS_BLOCK_MAX) {
print("i2c_transfer with write length greater than I2C_SMBUS_BLOCK_MAX", .{});
return null;
}
if (read_length > c.I2C_SMBUS_BLOCK_MAX) {
print("i2c_transfer with read length greater than I2C_SMBUS_BLOCK_MAX", .{});
return null;
}
var messages: [2]i2c_msg = undefined;
var num_messages: u8 = 1;
var write_msg = i2c_msg{ .addr = addr, .flags = 0, .len = write_length, .buf = &write_buffer[0] };
var read_msg = i2c_msg{ .addr = addr, .flags = c.I2C_M_RD, .len = read_length, .buf = &result[0] };
if (write_length > 0) {
messages[0] = write_msg;
if (read_length > 0) {
messages[1] = read_msg;
num_messages = 2;
}
} else {
messages[0] = read_msg;
}
const request = i2c_rdwr_ioctl_data{ .msgs = &messages[0], .nmsgs = num_messages };
var rv = c.ioctl(fd.handle, c.I2C_RDWR, &request);
// print("MSG[0] {}\n", .{messages[0]});
// print("MSG[1] {}\n", .{messages[1]});
// print("RET {any}\n", .{rv});
// print("CMD {any}\n", .{write_buffer});
//
// if (read_length > 0) {
// print("RSLT {any}\n", .{result[0..read_length]});
// }
if (rv > 0) {
if (read_length == 0) {
return &[_]u8{write_length};
} else {
return result[0..read_length];
}
} else {
return null;
}
}
pub fn read_block(fd: fs.File, addr: u8, register: u8, length: u8) ?[]u8 {
return i2c_transfer(fd, addr, &[_]u8{register}, 1, length);
}
pub fn write_block(fd: fs.File, addr: u8, buffer: []u8) u8 {
if (i2c_transfer(fd, addr, buffer, @truncate(u8, buffer.len), 0)) |value| {
// print("i2c_write {} {} {any}\n", .{ addr, value[0], buffer });
return value[0];
}
return 0;
}
|
src/bus/i2c.zig
|
// SPDX-License-Identifier: MIT
// This file is part of the `termcon` project under the MIT license.
const std = @import("std");
pub const key = @import("event/key.zig");
pub const mouse = @import("event/mouse.zig");
const view = @import("view.zig");
pub const Size = view.Size;
pub const KeyCallback = fn (e: key.Event) void;
pub const MouseCallback = fn (e: mouse.Event) void;
pub const ResizeCallback = fn (e: Size) void;
const Thread = std.thread.Thread;
pub const Handler = struct {
screen: *view.Screen,
key_callbacks: std.ArrayList(KeyCallback),
mouse_callbacks: std.ArrayList(MouseCallback),
resize_callbacks: std.ArrayList(ResizeCallback),
main_loop: std.Thread,
running: bool,
const Self = @This();
pub fn init(
allocator: *std.mem.Allocator,
screen: *view.Screen,
) Handler {
return Handler{
.screen = screen,
.key_callbacks = std.ArrayList(KeyCallback).init(allocator),
.mouse_callbacks = std.ArrayList(MouseCallback).init(allocator),
.resize_callbacks = std.ArrayList(ResizeCallback).init(allocator),
.main_loop = undefined,
.running = false,
};
}
pub fn deinit(self: *Self) void {
if (self.running) self.end();
self.key_callbacks.deinit();
self.mouse_callbacks.deinit();
self.resize_callbacks.deinit();
}
pub fn start(self: *Self, poll_rate: u8) !void {
// Note: This should start an infinite loop
// in another thread and immediately return
self.running = true;
self.main_loop = std.Thread.spawn(
MainLoopContext{
.poll_rate = poll_rate,
.screen = self.screen,
.run_flag = &self.running,
.key_callbacks = &self.key_callbacks,
.mouse_callbacks = &self.mouse_callbacks,
.resize_callbacks = &self.resize_callbacks,
},
mainLoop,
) catch |err| {
self.running = false;
return err;
};
}
pub fn end(self: *Self) void {
self.running = false;
self.main_loop.wait();
}
pub fn registerKeyCallback(self: *Self, function: KeyCallback) !void {
try self.key_callbacks.append(function);
}
pub fn registerMouseCallback(self: *Self, function: MouseCallback) !void {
try self.mouse_callbacks.append(function);
}
pub fn registerResizeCallback(
self: *Self,
function: ResizeCallback,
) !void {
try self.resize_callbacks.append(function);
}
const MainLoopContext = struct {
poll_rate: u8,
screen: *view.Screen,
run_flag: *bool,
key_callbacks: *std.ArrayList(KeyCallback),
mouse_callbacks: *std.ArrayList(MouseCallback),
resize_callbacks: *std.ArrayList(ResizeCallback),
};
fn mainLoop(context: MainLoopContext) void {
while (context.run_flag.*) {
std.time.sleep(@as(u64, poll_rate) * 1000000);
if (key.Event.poll() catch null) |keyevent| {
for (context.key_callbacks.*.items) |callback| {
callback(keyevent);
}
}
if (mouse.Event.poll() catch null) |mouseevent| {
for (context.mouse_callbacks.*.items) |callback| {
callback(mouseevent);
}
}
const orig_size: Size = context.screen.getSize();
context.screen.updateSize() catch {};
const new_size = context.screen.getSize();
if (orig_size != new_size) {
for (context.resize_callbacks.*.items) |callback| {
callback(new_size);
}
}
}
}
};
|
src/event.zig
|
const std = @import("std");
/// replace characters in fmt to implement ansi sgr escape sequences
/// any instance of `%(?)` with `\x1b[?m`, where `?` is any sequence of
/// specifiers. any sequence matching `/[0-9 ;]*/` is allowed.
/// specifier reference:
/// https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters
pub fn esc(comptime fmt: []const u8) []const u8 {
comptime {
var result: [fmt.len]u8 = undefined;
var i: usize = 0;
while (i < fmt.len) : (i += 1) {
if ((i + 1 < fmt.len) and std.mem.eql(u8, fmt[i..(i + 2)], "%(")) {
result[i] = '\x1b';
result[i+1] = '[';
i += 2;
while (i < fmt.len) : (i += 1) {
switch (fmt[i]) {
')' => {
result[i] = 'm';
break;
},
'0'...'9', ' ', ';' => |char| result[i] = char,
else => |char| @compileError("invalid character '" ++ &[1]u8{char} ++ "'"),
}
}
else @compileError("missing closing '')' in ansi escape format string");
}
else {
result[i] = fmt[i];
}
}
return &result;
}
}
pub fn writerSupportsEscapes(writer: anytype) bool {
if (@TypeOf(writer) == std.fs.File.Writer) {
const handle = writer.context.handle;
return (
// on windows, supportsAnsiEscapeCodes is unreliabled
// so we assume escapes are valid if we are printing to stderr
handle == std.io.getStdErr().handle or
writer.context.supportsAnsiEscapeCodes()
);
}
else {
return false;
}
}
/// removes ansi escapes from a format string
pub fn cleanEsc(comptime fmt: []const u8) []const u8 {
comptime {
var result: [fmt.len]u8 = undefined;
var len: usize = 0;
var i: usize = 0;
while (i < fmt.len) : (i += 1) {
if ((i + 1 < fmt.len) and std.mem.eql(u8, fmt[i..(i + 2)], "%(")) {
i += 2;
while (i < fmt.len) : (i += 1) {
switch (fmt[i]) {
')' => {
break;
},
'0'...'9', ' ', ';' => {},
else => |char| @compileError("invalid character '" ++ &[1]u8{char} ++ "'"),
}
}
else @compileError("missing closing '')' in ansi escape format string");
}
else {
result[len] = fmt[i];
len += 1;
}
}
return result[0..len];
}
}
pub fn printEscaped(writer: anytype, comptime style: []const u8, comptime fmt: []const u8, args: anytype) !void {
if (writerSupportsEscapes(writer)) {
try writer.print(comptime esc("%(" ++ style ++ ")" ++ fmt ++ "%(0)"), args);
}
else {
try writer.print(comptime cleanEsc(fmt), args);
}
}
pub const Style = enum(u8) {
none = 0,
bold = 1,
italic = 3,
underline = 4,
invert = 7,
strike = 9,
no_bold = 22,
no_italic = 23,
no_underline = 24,
no_invert = 27,
no_strike = 29,
};
pub const Color = enum(u8) {
default = 39,
black = 30,
red = 31,
green = 32,
yellow = 33,
blue = 34,
magenta = 35,
cyan = 36,
white = 37,
black_light = 90,
red_light = 91,
green_light = 92,
yellow_light = 93,
blue_light = 94,
magenta_light = 95,
cyan_light = 96,
white_light = 97,
};
pub fn StyledWriter(comptime writer_type: type) type {
return struct {
writer: Writer,
pub const Writer = writer_type;
const Self = @This();
fn esc(self: Self, numbers: []const u8) !void {
try self.write("\x1b[");
for (numbers) |number, i| {
if (i > 0) {
try self.write(";");
}
try self.print("{d}", .{number});
}
try self.write("m");
}
pub fn write(self: Self, text: []const u8) !void {
try self.writer.writeAll(text);
}
pub fn print(self: Self, comptime fmt: []const u8, args: anytype) !void {
try self.writer.print(fmt, args);
}
pub fn style(self: Self, s: Style) !void { try self.esc(&.{ @enumToInt(s) }); }
pub fn styles(self: Self, ss: []const Style) !void {
for (ss) |s| {
try self.style(s);
}
}
pub fn none(self: Self) !void { try self.style(.none); }
pub fn bold(self: Self) !void { try self.style(.bold); }
pub fn italic(self: Self) !void { try self.style(.italic); }
pub fn underline(self: Self) !void { try self.style(.underline); }
pub fn invert(self: Self) !void { try self.style(.invert); }
pub fn strike(self: Self) !void { try self.style(.strike); }
pub fn noBold(self: Self) !void { try self.style(.no_bold); }
pub fn noItalic(self: Self) !void { try self.style(.no_italic); }
pub fn noUnderline(self: Self) !void { try self.style(.no_underline); }
pub fn noInvert(self: Self) !void { try self.style(.no_invert); }
pub fn noStrike(self: Self) !void { try self.style(.no_strike); }
pub fn colors(self: Self, fore: ?Color, back: ?Color) !void {
if (fore) |fg| {
try self.esc(&.{@enumToInt(fg)});
}
if (back) |bg| {
try self.esc(&.{@enumToInt(bg) + 10});
}
}
pub fn noColors(self: Self) !void { try self.colors(.default, .default); }
pub fn foreground(self: Self, col: Color) !void { try self.colors(col, null); }
pub fn background(self: Self, col: Color) !void { try self.colors(null, col); }
pub fn noForeground(self: Self) !void { try self.colors(.default, null); }
pub fn noBackground(self: Self) !void { try self.colors(null, .default); }
};
}
pub fn styledWriter(writer: anytype) StyledWriter(@TypeOf(writer)) {
return StyledWriter(@TypeOf(writer)){ .writer = writer };
}
pub const StyledFileWriter = StyledWriter(std.fs.File.Writer);
pub fn styledStdErr() StyledFileWriter {
return styledWriter(std.io.getStdErr().writer());
}
|
src/util/ansi.zig
|
const std = @import("std");
const print = std.debug.print;
const util = @import("./util.zig");
const NumberCount = 100;
const BoardCount = 100;
const data = @embedFile("../data/day04.txt");
const BingoCell = struct {
number: u8,
marked: bool = false,
};
const Board = struct {
cells: [5][5]BingoCell = undefined,
fn mark(self: *Board, number: u8) bool {
var x: u8 = 0;
while (x < 5) : (x += 1) {
var y: u8 = 0;
while (y < 5) : (y += 1) {
const cell = &(self.cells[x][y]);
if (cell.number == number) {
cell.marked = true;
return true;
}
}
}
return false;
}
fn checkIfWon(self: Board) bool {
var i: u8 = 0;
while (i < 5) : (i += 1) {
const won = self.checkVertically(i) or self.checkHorizontally(i);
if (won)
return won;
}
return false;
}
fn checkVertically(self: Board, column: u8) bool {
var y: u8 = 0;
while (y < 5) : (y += 1) {
if (!self.cells[column][y].marked)
return false;
}
//If we didn't find an unmarked cell, we won!
return true;
}
fn checkHorizontally(self: Board, row: u8) bool {
var x: u8 = 0;
while (x < 5) : (x += 1) {
if (!self.cells[x][row].marked)
return false;
}
//If we didn't find an unmarked cell, we won!
return true;
}
fn calculateScore(self: Board) u16 {
var score: u16 = 0;
var x: u8 = 0;
while (x < 5) : (x += 1) {
var y: u8 = 0;
while (y < 5) : (y += 1) {
if (!self.cells[x][y].marked)
score += self.cells[x][y].number;
}
}
return score;
}
fn print(self: Board) void {
var x: u8 = 0;
while (x < 5) : (x += 1) {
var y: u8 = 0;
while (y < 5) : (y += 1) {
const cell = &(self.cells[x][y]);
if (cell.marked) {
print("[{d}] ", .{cell.number});
} else {
print("{d} ", .{cell.number});
}
}
print("\n", .{});
}
}
};
fn parseNumbers(line: []const u8) ![NumberCount]u8 {
var lineTokenizer = std.mem.tokenize(line, ",");
var numbers: [NumberCount]u8 = undefined;
var position: u8 = 0;
while (lineTokenizer.next()) |n| {
numbers[position] = try std.fmt.parseUnsigned(u8, n, 10);
position += 1;
}
return numbers;
}
fn parseBingoBoard(tokenizer: *std.mem.TokenIterator) !?Board {
if (tokenizer.index == tokenizer.buffer.len)
return null;
var board: Board = .{};
var x: u8 = 0;
while (x < 5) : (x += 1) {
var line = tokenizer.next().?;
var numbers = std.mem.tokenize(line, " ");
var y: u8 = 0;
while (y < 5) : (y += 1) {
const n = numbers.next().?;
const cellNumber = try std.fmt.parseUnsigned(u8, n, 10);
board.cells[x][y].number = cellNumber;
board.cells[x][y].marked = false;
}
}
return board;
}
const WinPair = util.Pair(*Board, u8);
fn findWinningBoard(numbers: [NumberCount]u8, boards: []Board) ?WinPair {
var numberIndex: u8 = 0;
while (numberIndex < numbers.len) : (numberIndex += 1) {
var n = numbers[numberIndex];
var boardIndex: u8 = 0;
while (boardIndex < boards.len) : (boardIndex += 1) {
var board = &boards[boardIndex];
if (board.mark(n))
if (board.checkIfWon())
return WinPair.init(board, n);
}
}
return null;
}
fn findLastWinningBoard(numbers: [NumberCount]u8, boards: []Board) ?WinPair {
var lastBoard: ?WinPair = null;
var availableBoards: [BoardCount]bool = undefined;
{
var boardIndex: u8 = 0;
while (boardIndex < BoardCount) : (boardIndex += 1)
availableBoards[boardIndex] = true;
}
var numberIndex: u8 = 0;
while (numberIndex < NumberCount) : (numberIndex += 1) {
const n = numbers[numberIndex];
var boardIndex: u8 = 0;
while (boardIndex < BoardCount) : (boardIndex += 1) {
if (availableBoards[boardIndex]) {
var board = &boards[boardIndex];
if (board.mark(n) and board.checkIfWon()) {
lastBoard = WinPair.init(board, n);
availableBoards[boardIndex] = false;
}
}
}
}
return lastBoard;
}
fn part1() !void {
var tokenizer = std.mem.tokenize(data, "\r\n");
const numbers = try parseNumbers(tokenizer.next().?);
var boards: [NumberCount]Board = undefined;
{
var boardIndex: u8 = 0;
while (boardIndex < NumberCount) : (boardIndex += 1) {
if (try parseBingoBoard(&tokenizer)) |board|
boards[boardIndex] = board;
}
}
print("Part 1:\n", .{});
if (findWinningBoard(numbers, &boards)) |winning| {
const winningBoard = winning.a;
const n = winning.b;
const score = winningBoard.calculateScore();
print("Board won at number {d} with score: {d}\n\n", .{ n, score });
print("The result is {d}\n", .{n * score});
} else {
print("No winning board?\n", .{});
}
}
fn part2() !void {
var tokenizer = std.mem.tokenize(data, "\r\n");
const numbers = try parseNumbers(tokenizer.next().?);
var boards: [100]Board = undefined;
var boardIndex: u8 = 0;
while (boardIndex < 100) : (boardIndex += 1) {
if (try parseBingoBoard(&tokenizer)) |board|
boards[boardIndex] = board;
}
print("\nPart 2:\n", .{});
if (findLastWinningBoard(numbers, &boards)) |winning| {
const winningBoard = winning.a;
const n = winning.b;
const score = winningBoard.calculateScore();
print("Last board to win, won at number {d} with score: {d}\n\n", .{ n, score });
print("The result is {d}\n", .{n * score});
} else {
print("No winning board?\n", .{});
}
}
pub fn main() !void {
try part1();
try part2();
}
|
src/day04.zig
|
const std = @import("std");
const utils = @import("../utils.zig");
const Atomic = std.atomic.Atomic;
pub const Lock = extern struct {
pub const name = "word_lock";
state: Atomic(usize) = Atomic(usize).init(UNLOCKED),
const UNLOCKED = 0;
const LOCKED = 1;
const WAKING = 2;
const WAITING = ~@as(usize, LOCKED | WAKING);
const Waiter = struct {
prev: ?*Waiter align(~WAITING + 1),
next: ?*Waiter,
tail: ?*Waiter,
event: utils.Event,
};
pub fn init(self: *Lock) void {
self.* = Lock{};
}
pub fn deinit(self: *Lock) void {
self.* = undefined;
}
pub fn acquire(self: *Lock) void {
if (self.state.tryCompareAndSwap(
UNLOCKED,
LOCKED,
.Acquire,
.Monotonic,
)) |_| {
self.acquireSlow();
}
}
fn acquireSlow(self: *Lock) void {
@setCold(true);
var spin = utils.SpinWait{};
var state = self.state.load(.Monotonic);
while (true) {
if (state & LOCKED == 0) {
state = self.state.tryCompareAndSwap(
state,
state | LOCKED,
.Acquire,
.Monotonic,
) orelse return;
continue;
}
const head = @intToPtr(?*Waiter, state & WAITING);
if (head == null and spin.yield()) {
state = self.state.load(.Monotonic);
continue;
}
var waiter: Waiter = undefined;
waiter = Waiter{
.prev = null,
.next = head,
.tail = if (head == null) &waiter else null,
.event = utils.Event{},
};
if (self.state.tryCompareAndSwap(
state,
(state & ~WAITING) | @ptrToInt(&waiter),
.Release,
.Monotonic,
)) |updated| {
state = updated;
continue;
}
waiter.event.wait();
spin.reset();
state = self.state.load(.Monotonic);
}
}
pub fn release(self: *Lock) void {
const state = self.state.fetchSub(LOCKED, .Release);
if ((state & WAKING == 0) and (state & WAITING != 0)) {
self.releaseSlow();
}
}
fn releaseSlow(self: *Lock) void {
@setCold(true);
var state = self.state.load(.Monotonic);
while (true) {
if ((state & (WAKING | LOCKED) != 0) or (state & WAITING == 0))
return;
state = self.state.tryCompareAndSwap(
state,
state | WAKING,
.Acquire,
.Monotonic,
) orelse break;
}
state |= WAKING;
dequeue: while (true) {
const head = @intToPtr(*Waiter, state & WAITING);
const tail = head.tail orelse blk: {
var current = head;
while (true) {
const next = current.next.?;
next.prev = current;
current = next;
if (current.tail) |tail| {
head.tail = tail;
break :blk tail;
}
}
};
if (state & LOCKED != 0) {
state = self.state.tryCompareAndSwap(
state,
state & ~@as(usize, WAKING),
.AcqRel,
.Acquire,
) orelse return;
continue;
}
if (tail.prev) |new_tail| {
head.tail = new_tail;
_ = self.state.fetchAnd(~@as(usize, WAKING), .Release);
} else {
while (true) {
state = self.state.tryCompareAndSwap(
state,
state & LOCKED,
.AcqRel,
.Acquire,
) orelse break;
if (state & WAITING != 0) {
continue :dequeue;
}
}
}
tail.event.notify();
return;
}
}
};
|
locks/word_lock.zig
|
const std = @import("std");
const spirv = @import("../spirv.zig");
const core = @import("core.zig");
pub const instructions = struct {
pub fn round(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 1,
.operands = operands.toOwnedSlice(),
});
}
pub fn roundEven(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 2,
.operands = operands.toOwnedSlice(),
});
}
pub fn trunc(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 3,
.operands = operands.toOwnedSlice(),
});
}
pub fn fAbs(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 4,
.operands = operands.toOwnedSlice(),
});
}
pub fn sAbs(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 5,
.operands = operands.toOwnedSlice(),
});
}
pub fn fSign(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 6,
.operands = operands.toOwnedSlice(),
});
}
pub fn sSign(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 7,
.operands = operands.toOwnedSlice(),
});
}
pub fn floor(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 8,
.operands = operands.toOwnedSlice(),
});
}
pub fn ceil(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 9,
.operands = operands.toOwnedSlice(),
});
}
pub fn fract(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 10,
.operands = operands.toOwnedSlice(),
});
}
pub fn radians(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 11,
.operands = operands.toOwnedSlice(),
});
}
pub fn degrees(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 12,
.operands = operands.toOwnedSlice(),
});
}
pub fn sin(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 13,
.operands = operands.toOwnedSlice(),
});
}
pub fn cos(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 14,
.operands = operands.toOwnedSlice(),
});
}
pub fn tan(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 15,
.operands = operands.toOwnedSlice(),
});
}
pub fn asin(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 16,
.operands = operands.toOwnedSlice(),
});
}
pub fn acos(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 17,
.operands = operands.toOwnedSlice(),
});
}
pub fn atan(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 18,
.operands = operands.toOwnedSlice(),
});
}
pub fn sinh(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 19,
.operands = operands.toOwnedSlice(),
});
}
pub fn cosh(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 20,
.operands = operands.toOwnedSlice(),
});
}
pub fn tanh(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 21,
.operands = operands.toOwnedSlice(),
});
}
pub fn asinh(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 22,
.operands = operands.toOwnedSlice(),
});
}
pub fn acosh(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 23,
.operands = operands.toOwnedSlice(),
});
}
pub fn atanh(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 24,
.operands = operands.toOwnedSlice(),
});
}
pub fn atan2(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 25,
.operands = operands.toOwnedSlice(),
});
}
pub fn pow(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 26,
.operands = operands.toOwnedSlice(),
});
}
pub fn exp(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 27,
.operands = operands.toOwnedSlice(),
});
}
pub fn log(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 28,
.operands = operands.toOwnedSlice(),
});
}
pub fn exp2(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 29,
.operands = operands.toOwnedSlice(),
});
}
pub fn log2(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 30,
.operands = operands.toOwnedSlice(),
});
}
pub fn sqrt(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 31,
.operands = operands.toOwnedSlice(),
});
}
pub fn inverseSqrt(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 32,
.operands = operands.toOwnedSlice(),
});
}
pub fn determinant(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 33,
.operands = operands.toOwnedSlice(),
});
}
pub fn matrixInverse(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 34,
.operands = operands.toOwnedSlice(),
});
}
pub fn modf(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 35,
.operands = operands.toOwnedSlice(),
});
}
pub fn modfStruct(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 36,
.operands = operands.toOwnedSlice(),
});
}
pub fn fMin(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 37,
.operands = operands.toOwnedSlice(),
});
}
pub fn uMin(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 38,
.operands = operands.toOwnedSlice(),
});
}
pub fn sMin(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 39,
.operands = operands.toOwnedSlice(),
});
}
pub fn fMax(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 40,
.operands = operands.toOwnedSlice(),
});
}
pub fn uMax(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 41,
.operands = operands.toOwnedSlice(),
});
}
pub fn sMax(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 42,
.operands = operands.toOwnedSlice(),
});
}
pub fn fClamp(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 43,
.operands = operands.toOwnedSlice(),
});
}
pub fn uClamp(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 44,
.operands = operands.toOwnedSlice(),
});
}
pub fn sClamp(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 45,
.operands = operands.toOwnedSlice(),
});
}
pub fn fMix(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 46,
.operands = operands.toOwnedSlice(),
});
}
pub fn iMix(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 47,
.operands = operands.toOwnedSlice(),
});
}
pub fn step(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 48,
.operands = operands.toOwnedSlice(),
});
}
pub fn smoothStep(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 49,
.operands = operands.toOwnedSlice(),
});
}
pub fn fma(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 50,
.operands = operands.toOwnedSlice(),
});
}
pub fn frexp(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 51,
.operands = operands.toOwnedSlice(),
});
}
pub fn frexpStruct(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 52,
.operands = operands.toOwnedSlice(),
});
}
pub fn ldexp(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 53,
.operands = operands.toOwnedSlice(),
});
}
pub fn packSnorm4x8(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 54,
.operands = operands.toOwnedSlice(),
});
}
pub fn packUnorm4x8(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 55,
.operands = operands.toOwnedSlice(),
});
}
pub fn packSnorm2x16(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 56,
.operands = operands.toOwnedSlice(),
});
}
pub fn packUnorm2x16(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 57,
.operands = operands.toOwnedSlice(),
});
}
pub fn packHalf2x16(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 58,
.operands = operands.toOwnedSlice(),
});
}
pub fn packDouble2x32(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 59,
.operands = operands.toOwnedSlice(),
});
}
pub fn unpackSnorm2x16(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 60,
.operands = operands.toOwnedSlice(),
});
}
pub fn unpackUnorm2x16(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 61,
.operands = operands.toOwnedSlice(),
});
}
pub fn unpackHalf2x16(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 62,
.operands = operands.toOwnedSlice(),
});
}
pub fn unpackSnorm4x8(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 63,
.operands = operands.toOwnedSlice(),
});
}
pub fn unpackUnorm4x8(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 64,
.operands = operands.toOwnedSlice(),
});
}
pub fn unpackDouble2x32(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 65,
.operands = operands.toOwnedSlice(),
});
}
pub fn length(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 66,
.operands = operands.toOwnedSlice(),
});
}
pub fn distance(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 67,
.operands = operands.toOwnedSlice(),
});
}
pub fn cross(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 68,
.operands = operands.toOwnedSlice(),
});
}
pub fn normalize(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 69,
.operands = operands.toOwnedSlice(),
});
}
pub fn faceForward(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 70,
.operands = operands.toOwnedSlice(),
});
}
pub fn reflect(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 71,
.operands = operands.toOwnedSlice(),
});
}
pub fn refract(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 72,
.operands = operands.toOwnedSlice(),
});
}
pub fn findILsb(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 73,
.operands = operands.toOwnedSlice(),
});
}
pub fn findSMsb(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 74,
.operands = operands.toOwnedSlice(),
});
}
pub fn findUMsb(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 75,
.operands = operands.toOwnedSlice(),
});
}
pub fn interpolateAtCentroid(self: *spirv.Builder, arg0: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try self.insns.append(self.allocator, .{
.op = 76,
.operands = operands.toOwnedSlice(),
});
}
pub fn interpolateAtSample(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 77,
.operands = operands.toOwnedSlice(),
});
}
pub fn interpolateAtOffset(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 78,
.operands = operands.toOwnedSlice(),
});
}
pub fn nMin(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 79,
.operands = operands.toOwnedSlice(),
});
}
pub fn nMax(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try self.insns.append(self.allocator, .{
.op = 80,
.operands = operands.toOwnedSlice(),
});
}
pub fn nClamp(self: *spirv.Builder, arg0: core.IdRef, arg1: core.IdRef, arg2: core.IdRef) !void {
var operands = std.ArrayList(spirv.Operand).init(self.allocator);
errdefer operands.deinit();
try spirv.Builder.writeOperand(&operands, core.IdRef, arg0);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg1);
try spirv.Builder.writeOperand(&operands, core.IdRef, arg2);
try self.insns.append(self.allocator, .{
.op = 81,
.operands = operands.toOwnedSlice(),
});
}
};
|
src/gen/glsl.zig
|
const std = @import("std");
const use_test_input = false;
const filename = if (use_test_input) "day-7_test-input" else "day-7_real-input";
const input_length = if (use_test_input) 10 else 1000;
pub fn main() !void {
std.debug.print("--- Day 7 ---\n", .{});
var file = try std.fs.cwd().openFile(filename, .{});
defer file.close();
var target_lower_bound: u16 = 9999;
var target_upper_bound: u16 = 0;
var crab_positions: [input_length]u16 = undefined;
{
var i: usize = 0;
while (i < input_length):(i += 1) {
var buffer: [4]u8 = undefined;
const delimiter: u8 = if (i != input_length - 1) ',' else '\n';
const pos_string = try file.reader().readUntilDelimiter(buffer[0..], delimiter);
const pos = try std.fmt.parseInt(u16, pos_string, 10);
crab_positions[i] = pos;
target_lower_bound = @minimum(target_lower_bound, pos);
target_upper_bound = @maximum(target_upper_bound, pos);
}
}
var target: u16 = undefined;
var target_moves: u32 = undefined;
while (true) {
target = (target_lower_bound + target_upper_bound) / 2;
target_moves = countMoves(crab_positions[0..], target);
if (target > target_lower_bound) {
const lower_target_moves = countMoves(crab_positions[0..], target - 1);
if (lower_target_moves < target_moves) {
target_upper_bound = target - 1;
continue;
}
}
if (target < target_upper_bound) {
const upper_target_moves = countMoves(crab_positions[0..], target + 1);
if (upper_target_moves < target_moves) {
target_lower_bound = target + 1;
continue;
}
}
break;
}
std.debug.print("target is {} with {} total moves\n", .{ target, target_moves });
}
fn countMoves(positions: []u16, target: u16) u32 {
var moves: u32 = 0;
for (positions) |pos| {
const diff = if (pos < target) target - pos else pos - target;
var i: u32 = 1;
while (i <= diff):(i += 1) {
moves += i;
}
}
return moves;
}
|
day-7.zig
|
const std = @import("std");
const utils = @import("utils.zig");
const UniqueList = utils.UniqueList;
const UniqueFixedList = utils.UniqueFixedList;
pub const Error = error{ InvalidComponent, FailedtoAllocate, InvalidRegister } || utils.Error;
/// Stores the component struct in a convenient way
pub fn StoreComponent(comptime name: []const u8, comptime Component: type, comptime MaxEntity: usize) type {
return struct {
const Self = @This();
pub const T = Component;
pub const TMax = MaxEntity;
pub const Name = name;
alloc: *std.mem.Allocator = undefined,
// the reason why this cannot be fixed list is bc
// the registered components adress in the memory is fixed
components: *UniqueFixedList(T, TMax) = undefined,
/// Initializes the storage component
pub fn init(alloc: *std.mem.Allocator) Error!Self {
var self = Self{
.alloc = alloc,
.components = alloc.create(UniqueFixedList(T, TMax)) catch return Error.FailedtoAllocate,
};
self.components.clear();
return self;
}
/// Adds a component
pub fn add(self: *Self, id: u64, data: T) Error!void {
return self.components.append(id, data);
}
/// Returns a component
/// NOTE: READ ONLY
pub fn get(self: Self, id: u64) Error!T {
return self.components.get(id);
}
/// Returns a component
/// NOTE: MUTABLE
pub fn getPtr(self: *Self, id: u64) Error!*T {
return self.components.getPtr(id);
}
/// Has the component?
pub fn has(self: Self, id: u64) bool {
return !self.components.isUnique(id);
}
/// Removes the component
pub fn remove(self: *Self, id: u64) bool {
return self.components.remove(id);
}
/// Deinitializes the storage component
pub fn deinit(self: Self) void {
self.alloc.destroy(self.components);
}
};
}
pub fn World(comptime Storage: type) type {
return struct {
const TNames = comptime std.meta.fieldNames(T);
const _World = @This();
pub const T = Storage;
pub const Register = struct {
pub const Entry = struct {
id: u64 = undefined,
name: []const u8 = undefined,
ptr: ?u64 = null,
};
world: *_World = undefined,
attached: UniqueList(Entry) = undefined,
id: u64 = undefined,
fn removeStorage(self: *Register, name: []const u8) Error!void {
inline for (TNames) |tname| {
const typ = @TypeOf(@field(self.world.entries, tname));
if (std.mem.eql(u8, typ.Name, name)) {
if (!@field(self.world.entries, tname).remove(self.id)) return Error.InvalidComponent;
return;
}
}
return Error.InvalidComponent;
}
/// Creates the register
pub fn create(self: *Register) Error!void {
self.attached = try UniqueList(Entry).init(self.world.alloc, 0);
}
/// Attaches a component
pub fn attach(self: *Register, name: []const u8, component: anytype) Error!void {
inline for (TNames) |tname| {
const typ = @TypeOf(@field(self.world.entries, tname));
if (std.mem.eql(u8, typ.Name, name)) {
//std.log.debug("{s}", .{typ});
//std.log.debug("comp: {s} {s}", .{ typ.T, @TypeOf(component) });
if (typ.T == @TypeOf(component)) {
var storage = &@field(self.world.entries, tname);
//std.log.debug("component: {}", .{component});
try storage.add(self.id, component);
const entry = Entry{
.id = self.attached.findUnique(),
.name = typ.Name,
.ptr = @ptrToInt(try storage.getPtr(self.id)),
};
//std.log.debug("id: {}, {s}", .{ self.id, entry });
return self.attached.append(entry.id, entry);
}
}
}
return Error.InvalidComponent;
}
/// Detaches a component
pub fn detach(self: *Register, name: []const u8) Error!void {
var it = self.attached.iterator();
while (it.next()) |entry| {
if (entry.data) |data| {
if (std.mem.eql(u8, data.name, name)) {
if (data.ptr) |ptr| {
try self.removeStorage(name);
if (!self.attached.remove(data.id)) return Error.InvalidComponent;
return;
}
}
}
}
return Error.InvalidComponent;
}
/// Returns the attached component
/// NOTE: READ-ONLY
pub fn get(self: Register, name: []const u8, comptime ctype: type) Error!ctype {
var it = self.attached.iterator();
while (it.next()) |entry| {
if (entry.data) |data| {
if (std.mem.eql(u8, data.name, name)) {
if (data.ptr) |ptr| {
var component = @intToPtr(*ctype, ptr);
return component.*;
}
}
}
}
return Error.InvalidComponent;
}
/// Returns the attached component
/// NOTE: MUTABLE
pub fn getPtr(self: Register, name: []const u8, comptime ctype: type) Error!*ctype {
var it = self.attached.iterator();
while (it.next()) |entry| {
if (entry.data) |data| {
if (std.mem.eql(u8, data.name, name)) {
if (data.ptr) |ptr| {
var component = @intToPtr(*ctype, ptr);
return component;
}
}
}
}
return Error.InvalidComponent;
}
/// Has the component?
pub fn has(self: Register, component: []const u8) bool {
var it = self.attached.iterator();
while (it.next()) |entry| {
if (entry.data) |data| {
if (std.mem.eql(u8, data.name, component)) {
return true;
}
}
}
return false;
}
/// Has these components?
pub fn hasThese(self: Register, comptime len: usize, complist: [len][]const u8) bool {
for (complist) |comp| {
var it = self.attached.iterator();
while (it.next()) |entry| {
if (entry.data) |data| {
if (!self.has(comp)) {
return false;
}
}
}
}
return true;
}
/// Destroys the register
pub fn destroy(self: Register) void {
self.attached.deinit();
}
};
/// Iterator
fn Iterator(comptime len: usize, comps: [len][]const u8) type {
return struct {
const _Iterator = @This();
pub const Entry = struct {
value: ?*Register = 0,
index: usize = 0,
};
world: *_World = undefined,
index: usize = 0,
fn getRegister(it: *_Iterator) ?*Register {
if (it.world.registers.items[it.index].data != null) {
var data = &it.world.registers.items[it.index].data.?;
if (data.hasThese(len, comps)) {
return data;
}
}
return null;
}
pub fn next(it: *_Iterator) ?Entry {
if (it.index >= it.world.registers.items.len) return null;
const result = Entry{ .value = it.getRegister(), .index = it.index };
it.index += 1;
return result;
}
/// Reset the iterator
pub fn reset(it: *_Iterator) void {
it.index = 0;
}
};
}
alloc: *std.mem.Allocator = undefined,
entries: T = undefined,
registers: UniqueList(Register) = undefined,
/// Initializes the world
pub fn init(alloc: *std.mem.Allocator) Error!_World {
var self = _World{
.alloc = alloc,
.entries = undefined,
};
inline for (TNames) |name| {
const typ = @TypeOf(@field(self.entries, name));
@field(self.entries, name) = try typ.init(self.alloc);
}
self.registers = try UniqueList(Register).init(self.alloc, 10);
return self;
}
/// Creates an iterator
pub fn iterator(comptime len: usize, complist: [len][]const u8) type {
return Iterator(len, complist);
}
/// Creates a register
pub fn createRegister(self: *_World, id: u64) Error!*Register {
var reg = Register{
.world = self,
.id = id,
};
try self.registers.append(reg.id, reg);
return self.registers.getPtr(reg.id);
}
/// Finds a non-unique id
pub fn findID(self: _World) u64 {
return self.registers.findUnique();
}
/// Returns a register
/// NOTE: READ-ONLY
pub fn getRegister(self: _World, id: u64) Error!Register {
return self.registers.get(id);
}
/// Returns a register
/// NOTE: MUTABLE
pub fn getRegisterPtr(self: *_World, id: u64) Error!*Register {
return self.registers.getPtr(id);
}
/// Removes a register
pub fn removeRegister(self: *_World, id: u64) Error!void {
inline for (TNames) |name| {
_ = @field(self.entries, name).remove(id);
}
if (!self.registers.remove(id)) return Error.InvalidRegister;
}
/// Deinitializes the world
pub fn deinit(self: *_World) void {
var it = self.registers.iterator();
while (it.next()) |entry| {
if (entry.data) |entity|
entity.destroy();
}
self.registers.deinit();
inline for (TNames) |name| {
@field(self.entries, name).deinit();
}
}
};
}
|
src/core/ecs.zig
|
const std = @import("../std.zig");
const builtin = @import("builtin");
const root = @import("root");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
const os = std.os;
const windows = os.windows;
const maxInt = std.math.maxInt;
const Thread = std.Thread;
const is_windows = std.Target.current.os.tag == .windows;
pub const Loop = struct {
next_tick_queue: std.atomic.Queue(anyframe),
os_data: OsData,
final_resume_node: ResumeNode,
pending_event_count: usize,
extra_threads: []*Thread,
/// TODO change this to a pool of configurable number of threads
/// and rename it to be not file-system-specific. it will become
/// a thread pool for turning non-CPU-bound blocking things into
/// async things. A fallback for any missing OS-specific API.
fs_thread: *Thread,
fs_queue: std.atomic.Queue(Request),
fs_end_request: Request.Node,
fs_thread_wakeup: std.ResetEvent,
/// For resources that have the same lifetime as the `Loop`.
/// This is only used by `Loop` for the thread pool and associated resources.
arena: std.heap.ArenaAllocator,
/// Pre-allocated eventfds. All permanently active.
/// This is how `Loop` sends promises to be resumed on other threads.
available_eventfd_resume_nodes: std.atomic.Stack(ResumeNode.EventFd),
eventfd_resume_nodes: []std.atomic.Stack(ResumeNode.EventFd).Node,
pub const NextTickNode = std.atomic.Queue(anyframe).Node;
pub const ResumeNode = struct {
id: Id,
handle: anyframe,
overlapped: Overlapped,
pub const overlapped_init = switch (builtin.os.tag) {
.windows => windows.OVERLAPPED{
.Internal = 0,
.InternalHigh = 0,
.Offset = 0,
.OffsetHigh = 0,
.hEvent = null,
},
else => {},
};
pub const Overlapped = @TypeOf(overlapped_init);
pub const Id = enum {
Basic,
Stop,
EventFd,
};
pub const EventFd = switch (builtin.os.tag) {
.macosx, .freebsd, .netbsd, .dragonfly => KEventFd,
.linux => struct {
base: ResumeNode,
epoll_op: u32,
eventfd: i32,
},
.windows => struct {
base: ResumeNode,
completion_key: usize,
},
else => struct {},
};
const KEventFd = struct {
base: ResumeNode,
kevent: os.Kevent,
};
pub const Basic = switch (builtin.os.tag) {
.macosx, .freebsd, .netbsd, .dragonfly => KEventBasic,
.linux => struct {
base: ResumeNode,
},
.windows => struct {
base: ResumeNode,
},
else => @compileError("unsupported OS"),
};
const KEventBasic = struct {
base: ResumeNode,
kev: os.Kevent,
};
};
var global_instance_state: Loop = undefined;
const default_instance: ?*Loop = switch (std.io.mode) {
.blocking => null,
.evented => &global_instance_state,
};
pub const instance: ?*Loop = if (@hasDecl(root, "event_loop")) root.event_loop else default_instance;
/// TODO copy elision / named return values so that the threads referencing *Loop
/// have the correct pointer value.
/// https://github.com/ziglang/zig/issues/2761 and https://github.com/ziglang/zig/issues/2765
pub fn init(self: *Loop) !void {
if (builtin.single_threaded) {
return self.initSingleThreaded();
} else {
return self.initMultiThreaded();
}
}
/// After initialization, call run().
/// TODO copy elision / named return values so that the threads referencing *Loop
/// have the correct pointer value.
/// https://github.com/ziglang/zig/issues/2761 and https://github.com/ziglang/zig/issues/2765
pub fn initSingleThreaded(self: *Loop) !void {
return self.initThreadPool(1);
}
/// After initialization, call run().
/// This is the same as `initThreadPool` using `Thread.cpuCount` to determine the thread
/// pool size.
/// TODO copy elision / named return values so that the threads referencing *Loop
/// have the correct pointer value.
/// https://github.com/ziglang/zig/issues/2761 and https://github.com/ziglang/zig/issues/2765
pub fn initMultiThreaded(self: *Loop) !void {
if (builtin.single_threaded)
@compileError("initMultiThreaded unavailable when building in single-threaded mode");
const core_count = try Thread.cpuCount();
return self.initThreadPool(core_count);
}
/// Thread count is the total thread count. The thread pool size will be
/// max(thread_count - 1, 0)
pub fn initThreadPool(self: *Loop, thread_count: usize) !void {
self.* = Loop{
.arena = std.heap.ArenaAllocator.init(std.heap.page_allocator),
.pending_event_count = 1,
.os_data = undefined,
.next_tick_queue = std.atomic.Queue(anyframe).init(),
.extra_threads = undefined,
.available_eventfd_resume_nodes = std.atomic.Stack(ResumeNode.EventFd).init(),
.eventfd_resume_nodes = undefined,
.final_resume_node = ResumeNode{
.id = ResumeNode.Id.Stop,
.handle = undefined,
.overlapped = ResumeNode.overlapped_init,
},
.fs_end_request = .{ .data = .{ .msg = .end, .finish = .NoAction } },
.fs_queue = std.atomic.Queue(Request).init(),
.fs_thread = undefined,
.fs_thread_wakeup = std.ResetEvent.init(),
};
errdefer self.fs_thread_wakeup.deinit();
errdefer self.arena.deinit();
// We need at least one of these in case the fs thread wants to use onNextTick
const extra_thread_count = thread_count - 1;
const resume_node_count = std.math.max(extra_thread_count, 1);
self.eventfd_resume_nodes = try self.arena.allocator.alloc(
std.atomic.Stack(ResumeNode.EventFd).Node,
resume_node_count,
);
self.extra_threads = try self.arena.allocator.alloc(*Thread, extra_thread_count);
try self.initOsData(extra_thread_count);
errdefer self.deinitOsData();
if (!builtin.single_threaded) {
self.fs_thread = try Thread.spawn(self, posixFsRun);
}
errdefer if (!builtin.single_threaded) {
self.posixFsRequest(&self.fs_end_request);
self.fs_thread.wait();
};
}
pub fn deinit(self: *Loop) void {
self.deinitOsData();
self.fs_thread_wakeup.deinit();
self.arena.deinit();
self.* = undefined;
}
const InitOsDataError = os.EpollCreateError || mem.Allocator.Error || os.EventFdError ||
Thread.SpawnError || os.EpollCtlError || os.KEventError ||
windows.CreateIoCompletionPortError;
const wakeup_bytes = [_]u8{0x1} ** 8;
fn initOsData(self: *Loop, extra_thread_count: usize) InitOsDataError!void {
nosuspend switch (builtin.os.tag) {
.linux => {
errdefer {
while (self.available_eventfd_resume_nodes.pop()) |node| os.close(node.data.eventfd);
}
for (self.eventfd_resume_nodes) |*eventfd_node| {
eventfd_node.* = std.atomic.Stack(ResumeNode.EventFd).Node{
.data = ResumeNode.EventFd{
.base = ResumeNode{
.id = .EventFd,
.handle = undefined,
.overlapped = ResumeNode.overlapped_init,
},
.eventfd = try os.eventfd(1, os.EFD_CLOEXEC | os.EFD_NONBLOCK),
.epoll_op = os.EPOLL_CTL_ADD,
},
.next = undefined,
};
self.available_eventfd_resume_nodes.push(eventfd_node);
}
self.os_data.epollfd = try os.epoll_create1(os.EPOLL_CLOEXEC);
errdefer os.close(self.os_data.epollfd);
self.os_data.final_eventfd = try os.eventfd(0, os.EFD_CLOEXEC | os.EFD_NONBLOCK);
errdefer os.close(self.os_data.final_eventfd);
self.os_data.final_eventfd_event = os.epoll_event{
.events = os.EPOLLIN,
.data = os.epoll_data{ .ptr = @ptrToInt(&self.final_resume_node) },
};
try os.epoll_ctl(
self.os_data.epollfd,
os.EPOLL_CTL_ADD,
self.os_data.final_eventfd,
&self.os_data.final_eventfd_event,
);
if (builtin.single_threaded) {
assert(extra_thread_count == 0);
return;
}
var extra_thread_index: usize = 0;
errdefer {
// writing 8 bytes to an eventfd cannot fail
const amt = os.write(self.os_data.final_eventfd, &wakeup_bytes) catch unreachable;
assert(amt == wakeup_bytes.len);
while (extra_thread_index != 0) {
extra_thread_index -= 1;
self.extra_threads[extra_thread_index].wait();
}
}
while (extra_thread_index < extra_thread_count) : (extra_thread_index += 1) {
self.extra_threads[extra_thread_index] = try Thread.spawn(self, workerRun);
}
},
.macosx, .freebsd, .netbsd, .dragonfly => {
self.os_data.kqfd = try os.kqueue();
errdefer os.close(self.os_data.kqfd);
const empty_kevs = &[0]os.Kevent{};
for (self.eventfd_resume_nodes) |*eventfd_node, i| {
eventfd_node.* = std.atomic.Stack(ResumeNode.EventFd).Node{
.data = ResumeNode.EventFd{
.base = ResumeNode{
.id = ResumeNode.Id.EventFd,
.handle = undefined,
.overlapped = ResumeNode.overlapped_init,
},
// this one is for sending events
.kevent = os.Kevent{
.ident = i,
.filter = os.EVFILT_USER,
.flags = os.EV_CLEAR | os.EV_ADD | os.EV_DISABLE,
.fflags = 0,
.data = 0,
.udata = @ptrToInt(&eventfd_node.data.base),
},
},
.next = undefined,
};
self.available_eventfd_resume_nodes.push(eventfd_node);
const kevent_array = @as(*const [1]os.Kevent, &eventfd_node.data.kevent);
_ = try os.kevent(self.os_data.kqfd, kevent_array, empty_kevs, null);
eventfd_node.data.kevent.flags = os.EV_CLEAR | os.EV_ENABLE;
eventfd_node.data.kevent.fflags = os.NOTE_TRIGGER;
}
// Pre-add so that we cannot get error.SystemResources
// later when we try to activate it.
self.os_data.final_kevent = os.Kevent{
.ident = extra_thread_count,
.filter = os.EVFILT_USER,
.flags = os.EV_ADD | os.EV_DISABLE,
.fflags = 0,
.data = 0,
.udata = @ptrToInt(&self.final_resume_node),
};
const final_kev_arr = @as(*const [1]os.Kevent, &self.os_data.final_kevent);
_ = try os.kevent(self.os_data.kqfd, final_kev_arr, empty_kevs, null);
self.os_data.final_kevent.flags = os.EV_ENABLE;
self.os_data.final_kevent.fflags = os.NOTE_TRIGGER;
if (builtin.single_threaded) {
assert(extra_thread_count == 0);
return;
}
var extra_thread_index: usize = 0;
errdefer {
_ = os.kevent(self.os_data.kqfd, final_kev_arr, empty_kevs, null) catch unreachable;
while (extra_thread_index != 0) {
extra_thread_index -= 1;
self.extra_threads[extra_thread_index].wait();
}
}
while (extra_thread_index < extra_thread_count) : (extra_thread_index += 1) {
self.extra_threads[extra_thread_index] = try Thread.spawn(self, workerRun);
}
},
.windows => {
self.os_data.io_port = try windows.CreateIoCompletionPort(
windows.INVALID_HANDLE_VALUE,
null,
undefined,
maxInt(windows.DWORD),
);
errdefer windows.CloseHandle(self.os_data.io_port);
for (self.eventfd_resume_nodes) |*eventfd_node, i| {
eventfd_node.* = std.atomic.Stack(ResumeNode.EventFd).Node{
.data = ResumeNode.EventFd{
.base = ResumeNode{
.id = ResumeNode.Id.EventFd,
.handle = undefined,
.overlapped = ResumeNode.overlapped_init,
},
// this one is for sending events
.completion_key = @ptrToInt(&eventfd_node.data.base),
},
.next = undefined,
};
self.available_eventfd_resume_nodes.push(eventfd_node);
}
if (builtin.single_threaded) {
assert(extra_thread_count == 0);
return;
}
var extra_thread_index: usize = 0;
errdefer {
var i: usize = 0;
while (i < extra_thread_index) : (i += 1) {
while (true) {
const overlapped = &self.final_resume_node.overlapped;
windows.PostQueuedCompletionStatus(self.os_data.io_port, undefined, undefined, overlapped) catch continue;
break;
}
}
while (extra_thread_index != 0) {
extra_thread_index -= 1;
self.extra_threads[extra_thread_index].wait();
}
}
while (extra_thread_index < extra_thread_count) : (extra_thread_index += 1) {
self.extra_threads[extra_thread_index] = try Thread.spawn(self, workerRun);
}
},
else => {},
};
}
fn deinitOsData(self: *Loop) void {
nosuspend switch (builtin.os.tag) {
.linux => {
os.close(self.os_data.final_eventfd);
while (self.available_eventfd_resume_nodes.pop()) |node| os.close(node.data.eventfd);
os.close(self.os_data.epollfd);
},
.macosx, .freebsd, .netbsd, .dragonfly => {
os.close(self.os_data.kqfd);
},
.windows => {
windows.CloseHandle(self.os_data.io_port);
},
else => {},
};
}
/// resume_node must live longer than the anyframe that it holds a reference to.
/// flags must contain EPOLLET
pub fn linuxAddFd(self: *Loop, fd: i32, resume_node: *ResumeNode, flags: u32) !void {
assert(flags & os.EPOLLET == os.EPOLLET);
self.beginOneEvent();
errdefer self.finishOneEvent();
try self.linuxModFd(
fd,
os.EPOLL_CTL_ADD,
flags,
resume_node,
);
}
pub fn linuxModFd(self: *Loop, fd: i32, op: u32, flags: u32, resume_node: *ResumeNode) !void {
assert(flags & os.EPOLLET == os.EPOLLET);
var ev = os.linux.epoll_event{
.events = flags,
.data = os.linux.epoll_data{ .ptr = @ptrToInt(resume_node) },
};
try os.epoll_ctl(self.os_data.epollfd, op, fd, &ev);
}
pub fn linuxRemoveFd(self: *Loop, fd: i32) void {
os.epoll_ctl(self.os_data.epollfd, os.linux.EPOLL_CTL_DEL, fd, null) catch {};
self.finishOneEvent();
}
pub fn linuxWaitFd(self: *Loop, fd: i32, flags: u32) void {
assert(flags & os.EPOLLET == os.EPOLLET);
assert(flags & os.EPOLLONESHOT == os.EPOLLONESHOT);
var resume_node = ResumeNode.Basic{
.base = ResumeNode{
.id = .Basic,
.handle = @frame(),
.overlapped = ResumeNode.overlapped_init,
},
};
var need_to_delete = false;
defer if (need_to_delete) self.linuxRemoveFd(fd);
suspend {
if (self.linuxAddFd(fd, &resume_node.base, flags)) |_| {
need_to_delete = true;
} else |err| switch (err) {
error.FileDescriptorNotRegistered => unreachable,
error.OperationCausesCircularLoop => unreachable,
error.FileDescriptorIncompatibleWithEpoll => unreachable,
error.FileDescriptorAlreadyPresentInSet => unreachable, // evented writes to the same fd is not thread-safe
error.SystemResources,
error.UserResourceLimitReached,
error.Unexpected,
=> {
// Fall back to a blocking poll(). Ideally this codepath is never hit, since
// epoll should be just fine. But this is better than incorrect behavior.
var poll_flags: i16 = 0;
if ((flags & os.EPOLLIN) != 0) poll_flags |= os.POLLIN;
if ((flags & os.EPOLLOUT) != 0) poll_flags |= os.POLLOUT;
var pfd = [1]os.pollfd{os.pollfd{
.fd = fd,
.events = poll_flags,
.revents = undefined,
}};
_ = os.poll(&pfd, -1) catch |poll_err| switch (poll_err) {
error.SystemResources,
error.Unexpected,
=> {
// Even poll() didn't work. The best we can do now is sleep for a
// small duration and then hope that something changed.
std.time.sleep(1 * std.time.millisecond);
},
};
resume @frame();
},
}
}
}
pub fn waitUntilFdReadable(self: *Loop, fd: os.fd_t) void {
switch (builtin.os.tag) {
.linux => {
self.linuxWaitFd(fd, os.EPOLLET | os.EPOLLONESHOT | os.EPOLLIN);
},
.macosx, .freebsd, .netbsd, .dragonfly => {
self.bsdWaitKev(@intCast(usize, fd), os.EVFILT_READ, os.EV_ONESHOT);
},
else => @compileError("Unsupported OS"),
}
}
pub fn waitUntilFdWritable(self: *Loop, fd: os.fd_t) void {
switch (builtin.os.tag) {
.linux => {
self.linuxWaitFd(fd, os.EPOLLET | os.EPOLLONESHOT | os.EPOLLOUT);
},
.macosx, .freebsd, .netbsd, .dragonfly => {
self.bsdWaitKev(@intCast(usize, fd), os.EVFILT_WRITE, os.EV_ONESHOT);
},
else => @compileError("Unsupported OS"),
}
}
pub fn waitUntilFdWritableOrReadable(self: *Loop, fd: os.fd_t) void {
switch (builtin.os.tag) {
.linux => {
self.linuxWaitFd(@intCast(usize, fd), os.EPOLLET | os.EPOLLONESHOT | os.EPOLLOUT | os.EPOLLIN);
},
.macosx, .freebsd, .netbsd, .dragonfly => {
self.bsdWaitKev(@intCast(usize, fd), os.EVFILT_READ, os.EV_ONESHOT);
self.bsdWaitKev(@intCast(usize, fd), os.EVFILT_WRITE, os.EV_ONESHOT);
},
else => @compileError("Unsupported OS"),
}
}
pub async fn bsdWaitKev(self: *Loop, ident: usize, filter: i16, fflags: u32) void {
var resume_node = ResumeNode.Basic{
.base = ResumeNode{
.id = ResumeNode.Id.Basic,
.handle = @frame(),
.overlapped = ResumeNode.overlapped_init,
},
.kev = undefined,
};
defer self.bsdRemoveKev(ident, filter);
suspend {
self.bsdAddKev(&resume_node, ident, filter, fflags) catch unreachable;
}
}
/// resume_node must live longer than the anyframe that it holds a reference to.
pub fn bsdAddKev(self: *Loop, resume_node: *ResumeNode.Basic, ident: usize, filter: i16, fflags: u32) !void {
self.beginOneEvent();
errdefer self.finishOneEvent();
var kev = [1]os.Kevent{os.Kevent{
.ident = ident,
.filter = filter,
.flags = os.EV_ADD | os.EV_ENABLE | os.EV_CLEAR,
.fflags = fflags,
.data = 0,
.udata = @ptrToInt(&resume_node.base),
}};
const empty_kevs = &[0]os.Kevent{};
_ = try os.kevent(self.os_data.kqfd, &kev, empty_kevs, null);
}
pub fn bsdRemoveKev(self: *Loop, ident: usize, filter: i16) void {
var kev = [1]os.Kevent{os.Kevent{
.ident = ident,
.filter = filter,
.flags = os.EV_DELETE,
.fflags = 0,
.data = 0,
.udata = 0,
}};
const empty_kevs = &[0]os.Kevent{};
_ = os.kevent(self.os_data.kqfd, &kev, empty_kevs, null) catch undefined;
self.finishOneEvent();
}
fn dispatch(self: *Loop) void {
while (self.available_eventfd_resume_nodes.pop()) |resume_stack_node| {
const next_tick_node = self.next_tick_queue.get() orelse {
self.available_eventfd_resume_nodes.push(resume_stack_node);
return;
};
const eventfd_node = &resume_stack_node.data;
eventfd_node.base.handle = next_tick_node.data;
switch (builtin.os.tag) {
.macosx, .freebsd, .netbsd, .dragonfly => {
const kevent_array = @as(*const [1]os.Kevent, &eventfd_node.kevent);
const empty_kevs = &[0]os.Kevent{};
_ = os.kevent(self.os_data.kqfd, kevent_array, empty_kevs, null) catch {
self.next_tick_queue.unget(next_tick_node);
self.available_eventfd_resume_nodes.push(resume_stack_node);
return;
};
},
.linux => {
// the pending count is already accounted for
const epoll_events = os.EPOLLONESHOT | os.linux.EPOLLIN | os.linux.EPOLLOUT |
os.linux.EPOLLET;
self.linuxModFd(
eventfd_node.eventfd,
eventfd_node.epoll_op,
epoll_events,
&eventfd_node.base,
) catch {
self.next_tick_queue.unget(next_tick_node);
self.available_eventfd_resume_nodes.push(resume_stack_node);
return;
};
},
.windows => {
windows.PostQueuedCompletionStatus(
self.os_data.io_port,
undefined,
undefined,
&eventfd_node.base.overlapped,
) catch {
self.next_tick_queue.unget(next_tick_node);
self.available_eventfd_resume_nodes.push(resume_stack_node);
return;
};
},
else => @compileError("unsupported OS"),
}
}
}
/// Bring your own linked list node. This means it can't fail.
pub fn onNextTick(self: *Loop, node: *NextTickNode) void {
self.beginOneEvent(); // finished in dispatch()
self.next_tick_queue.put(node);
self.dispatch();
}
pub fn cancelOnNextTick(self: *Loop, node: *NextTickNode) void {
if (self.next_tick_queue.remove(node)) {
self.finishOneEvent();
}
}
pub fn run(self: *Loop) void {
self.finishOneEvent(); // the reference we start with
self.workerRun();
switch (builtin.os.tag) {
.linux,
.macosx,
.freebsd,
.netbsd,
.dragonfly,
=> self.fs_thread.wait(),
else => {},
}
for (self.extra_threads) |extra_thread| {
extra_thread.wait();
}
}
/// Yielding lets the event loop run, starting any unstarted async operations.
/// Note that async operations automatically start when a function yields for any other reason,
/// for example, when async I/O is performed. This function is intended to be used only when
/// CPU bound tasks would be waiting in the event loop but never get started because no async I/O
/// is performed.
pub fn yield(self: *Loop) void {
suspend {
var my_tick_node = NextTickNode{
.prev = undefined,
.next = undefined,
.data = @frame(),
};
self.onNextTick(&my_tick_node);
}
}
/// If the build is multi-threaded and there is an event loop, then it calls `yield`. Otherwise,
/// does nothing.
pub fn startCpuBoundOperation() void {
if (builtin.single_threaded) {
return;
} else if (instance) |event_loop| {
event_loop.yield();
}
}
/// call finishOneEvent when done
pub fn beginOneEvent(self: *Loop) void {
_ = @atomicRmw(usize, &self.pending_event_count, .Add, 1, .SeqCst);
}
pub fn finishOneEvent(self: *Loop) void {
nosuspend {
const prev = @atomicRmw(usize, &self.pending_event_count, .Sub, 1, .SeqCst);
if (prev != 1) return;
// cause all the threads to stop
self.posixFsRequest(&self.fs_end_request);
switch (builtin.os.tag) {
.linux => {
// writing 8 bytes to an eventfd cannot fail
const amt = os.write(self.os_data.final_eventfd, &wakeup_bytes) catch unreachable;
assert(amt == wakeup_bytes.len);
return;
},
.macosx, .freebsd, .netbsd, .dragonfly => {
const final_kevent = @as(*const [1]os.Kevent, &self.os_data.final_kevent);
const empty_kevs = &[0]os.Kevent{};
// cannot fail because we already added it and this just enables it
_ = os.kevent(self.os_data.kqfd, final_kevent, empty_kevs, null) catch unreachable;
return;
},
.windows => {
var i: usize = 0;
while (i < self.extra_threads.len + 1) : (i += 1) {
while (true) {
const overlapped = &self.final_resume_node.overlapped;
windows.PostQueuedCompletionStatus(self.os_data.io_port, undefined, undefined, overlapped) catch continue;
break;
}
}
return;
},
else => @compileError("unsupported OS"),
}
}
}
/// Performs an async `os.open` using a separate thread.
pub fn openZ(self: *Loop, file_path: [*:0]const u8, flags: u32, mode: os.mode_t) os.OpenError!os.fd_t {
var req_node = Request.Node{
.data = .{
.msg = .{
.open = .{
.path = file_path,
.flags = flags,
.mode = mode,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.open.result;
}
/// Performs an async `os.opent` using a separate thread.
pub fn openatZ(self: *Loop, fd: os.fd_t, file_path: [*:0]const u8, flags: u32, mode: os.mode_t) os.OpenError!os.fd_t {
var req_node = Request.Node{
.data = .{
.msg = .{
.openat = .{
.fd = fd,
.path = file_path,
.flags = flags,
.mode = mode,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.openat.result;
}
/// Performs an async `os.close` using a separate thread.
pub fn close(self: *Loop, fd: os.fd_t) void {
var req_node = Request.Node{
.data = .{
.msg = .{ .close = .{ .fd = fd } },
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
}
/// Performs an async `os.read` using a separate thread.
/// `fd` must block and not return EAGAIN.
pub fn read(self: *Loop, fd: os.fd_t, buf: []u8) os.ReadError!usize {
var req_node = Request.Node{
.data = .{
.msg = .{
.read = .{
.fd = fd,
.buf = buf,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.read.result;
}
/// Performs an async `os.readv` using a separate thread.
/// `fd` must block and not return EAGAIN.
pub fn readv(self: *Loop, fd: os.fd_t, iov: []const os.iovec) os.ReadError!usize {
var req_node = Request.Node{
.data = .{
.msg = .{
.readv = .{
.fd = fd,
.iov = iov,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.readv.result;
}
/// Performs an async `os.pread` using a separate thread.
/// `fd` must block and not return EAGAIN.
pub fn pread(self: *Loop, fd: os.fd_t, buf: []u8, offset: u64) os.PReadError!usize {
var req_node = Request.Node{
.data = .{
.msg = .{
.pread = .{
.fd = fd,
.buf = buf,
.offset = offset,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.pread.result;
}
/// Performs an async `os.preadv` using a separate thread.
/// `fd` must block and not return EAGAIN.
pub fn preadv(self: *Loop, fd: os.fd_t, iov: []const os.iovec, offset: u64) os.ReadError!usize {
var req_node = Request.Node{
.data = .{
.msg = .{
.preadv = .{
.fd = fd,
.iov = iov,
.offset = offset,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.preadv.result;
}
/// Performs an async `os.write` using a separate thread.
/// `fd` must block and not return EAGAIN.
pub fn write(self: *Loop, fd: os.fd_t, bytes: []const u8) os.WriteError!usize {
var req_node = Request.Node{
.data = .{
.msg = .{
.write = .{
.fd = fd,
.bytes = bytes,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.write.result;
}
/// Performs an async `os.writev` using a separate thread.
/// `fd` must block and not return EAGAIN.
pub fn writev(self: *Loop, fd: os.fd_t, iov: []const os.iovec_const) os.WriteError!usize {
var req_node = Request.Node{
.data = .{
.msg = .{
.writev = .{
.fd = fd,
.iov = iov,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.writev.result;
}
/// Performs an async `os.pwritev` using a separate thread.
/// `fd` must block and not return EAGAIN.
pub fn pwritev(self: *Loop, fd: os.fd_t, iov: []const os.iovec_const, offset: u64) os.WriteError!usize {
var req_node = Request.Node{
.data = .{
.msg = .{
.pwritev = .{
.fd = fd,
.iov = iov,
.offset = offset,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.pwritev.result;
}
/// Performs an async `os.faccessatZ` using a separate thread.
/// `fd` must block and not return EAGAIN.
pub fn faccessatZ(
self: *Loop,
dirfd: os.fd_t,
path_z: [*:0]const u8,
mode: u32,
flags: u32,
) os.AccessError!void {
var req_node = Request.Node{
.data = .{
.msg = .{
.faccessat = .{
.dirfd = dirfd,
.path = path_z,
.mode = mode,
.flags = flags,
.result = undefined,
},
},
.finish = .{ .TickNode = .{ .data = @frame() } },
},
};
suspend {
self.posixFsRequest(&req_node);
}
return req_node.data.msg.faccessat.result;
}
fn workerRun(self: *Loop) void {
while (true) {
while (true) {
const next_tick_node = self.next_tick_queue.get() orelse break;
self.dispatch();
resume next_tick_node.data;
self.finishOneEvent();
}
switch (builtin.os.tag) {
.linux => {
// only process 1 event so we don't steal from other threads
var events: [1]os.linux.epoll_event = undefined;
const count = os.epoll_wait(self.os_data.epollfd, events[0..], -1);
for (events[0..count]) |ev| {
const resume_node = @intToPtr(*ResumeNode, ev.data.ptr);
const handle = resume_node.handle;
const resume_node_id = resume_node.id;
switch (resume_node_id) {
.Basic => {},
.Stop => return,
.EventFd => {
const event_fd_node = @fieldParentPtr(ResumeNode.EventFd, "base", resume_node);
event_fd_node.epoll_op = os.EPOLL_CTL_MOD;
const stack_node = @fieldParentPtr(std.atomic.Stack(ResumeNode.EventFd).Node, "data", event_fd_node);
self.available_eventfd_resume_nodes.push(stack_node);
},
}
resume handle;
if (resume_node_id == ResumeNode.Id.EventFd) {
self.finishOneEvent();
}
}
},
.macosx, .freebsd, .netbsd, .dragonfly => {
var eventlist: [1]os.Kevent = undefined;
const empty_kevs = &[0]os.Kevent{};
const count = os.kevent(self.os_data.kqfd, empty_kevs, eventlist[0..], null) catch unreachable;
for (eventlist[0..count]) |ev| {
const resume_node = @intToPtr(*ResumeNode, ev.udata);
const handle = resume_node.handle;
const resume_node_id = resume_node.id;
switch (resume_node_id) {
.Basic => {
const basic_node = @fieldParentPtr(ResumeNode.Basic, "base", resume_node);
basic_node.kev = ev;
},
.Stop => return,
.EventFd => {
const event_fd_node = @fieldParentPtr(ResumeNode.EventFd, "base", resume_node);
const stack_node = @fieldParentPtr(std.atomic.Stack(ResumeNode.EventFd).Node, "data", event_fd_node);
self.available_eventfd_resume_nodes.push(stack_node);
},
}
resume handle;
if (resume_node_id == ResumeNode.Id.EventFd) {
self.finishOneEvent();
}
}
},
.windows => {
var completion_key: usize = undefined;
const overlapped = while (true) {
var nbytes: windows.DWORD = undefined;
var overlapped: ?*windows.OVERLAPPED = undefined;
switch (windows.GetQueuedCompletionStatus(self.os_data.io_port, &nbytes, &completion_key, &overlapped, windows.INFINITE)) {
.Aborted => return,
.Normal => {},
.EOF => {},
.Cancelled => continue,
}
if (overlapped) |o| break o;
} else unreachable; // TODO else unreachable should not be necessary
const resume_node = @fieldParentPtr(ResumeNode, "overlapped", overlapped);
const handle = resume_node.handle;
const resume_node_id = resume_node.id;
switch (resume_node_id) {
.Basic => {},
.Stop => return,
.EventFd => {
const event_fd_node = @fieldParentPtr(ResumeNode.EventFd, "base", resume_node);
const stack_node = @fieldParentPtr(std.atomic.Stack(ResumeNode.EventFd).Node, "data", event_fd_node);
self.available_eventfd_resume_nodes.push(stack_node);
},
}
resume handle;
self.finishOneEvent();
},
else => @compileError("unsupported OS"),
}
}
}
fn posixFsRequest(self: *Loop, request_node: *Request.Node) void {
self.beginOneEvent(); // finished in posixFsRun after processing the msg
self.fs_queue.put(request_node);
self.fs_thread_wakeup.set();
}
fn posixFsCancel(self: *Loop, request_node: *Request.Node) void {
if (self.fs_queue.remove(request_node)) {
self.finishOneEvent();
}
}
fn posixFsRun(self: *Loop) void {
nosuspend while (true) {
self.fs_thread_wakeup.reset();
while (self.fs_queue.get()) |node| {
switch (node.data.msg) {
.end => return,
.read => |*msg| {
msg.result = os.read(msg.fd, msg.buf);
},
.readv => |*msg| {
msg.result = os.readv(msg.fd, msg.iov);
},
.write => |*msg| {
msg.result = os.write(msg.fd, msg.bytes);
},
.writev => |*msg| {
msg.result = os.writev(msg.fd, msg.iov);
},
.pwritev => |*msg| {
msg.result = os.pwritev(msg.fd, msg.iov, msg.offset);
},
.pread => |*msg| {
msg.result = os.pread(msg.fd, msg.buf, msg.offset);
},
.preadv => |*msg| {
msg.result = os.preadv(msg.fd, msg.iov, msg.offset);
},
.open => |*msg| {
if (is_windows) unreachable; // TODO
msg.result = os.openZ(msg.path, msg.flags, msg.mode);
},
.openat => |*msg| {
if (is_windows) unreachable; // TODO
msg.result = os.openatZ(msg.fd, msg.path, msg.flags, msg.mode);
},
.faccessat => |*msg| {
msg.result = os.faccessatZ(msg.dirfd, msg.path, msg.mode, msg.flags);
},
.close => |*msg| os.close(msg.fd),
}
switch (node.data.finish) {
.TickNode => |*tick_node| self.onNextTick(tick_node),
.NoAction => {},
}
self.finishOneEvent();
}
self.fs_thread_wakeup.wait();
};
}
const OsData = switch (builtin.os.tag) {
.linux => LinuxOsData,
.macosx, .freebsd, .netbsd, .dragonfly => KEventData,
.windows => struct {
io_port: windows.HANDLE,
extra_thread_count: usize,
},
else => struct {},
};
const KEventData = struct {
kqfd: i32,
final_kevent: os.Kevent,
};
const LinuxOsData = struct {
epollfd: i32,
final_eventfd: i32,
final_eventfd_event: os.linux.epoll_event,
};
pub const Request = struct {
msg: Msg,
finish: Finish,
pub const Node = std.atomic.Queue(Request).Node;
pub const Finish = union(enum) {
TickNode: Loop.NextTickNode,
NoAction,
};
pub const Msg = union(enum) {
read: Read,
readv: ReadV,
write: Write,
writev: WriteV,
pwritev: PWriteV,
pread: PRead,
preadv: PReadV,
open: Open,
openat: OpenAt,
close: Close,
faccessat: FAccessAt,
/// special - means the fs thread should exit
end,
pub const Read = struct {
fd: os.fd_t,
buf: []u8,
result: Error!usize,
pub const Error = os.ReadError;
};
pub const ReadV = struct {
fd: os.fd_t,
iov: []const os.iovec,
result: Error!usize,
pub const Error = os.ReadError;
};
pub const Write = struct {
fd: os.fd_t,
bytes: []const u8,
result: Error!usize,
pub const Error = os.WriteError;
};
pub const WriteV = struct {
fd: os.fd_t,
iov: []const os.iovec_const,
result: Error!usize,
pub const Error = os.WriteError;
};
pub const PWriteV = struct {
fd: os.fd_t,
iov: []const os.iovec_const,
offset: usize,
result: Error!usize,
pub const Error = os.PWriteError;
};
pub const PRead = struct {
fd: os.fd_t,
buf: []u8,
offset: usize,
result: Error!usize,
pub const Error = os.PReadError;
};
pub const PReadV = struct {
fd: os.fd_t,
iov: []const os.iovec,
offset: usize,
result: Error!usize,
pub const Error = os.PReadError;
};
pub const Open = struct {
path: [*:0]const u8,
flags: u32,
mode: os.mode_t,
result: Error!os.fd_t,
pub const Error = os.OpenError;
};
pub const OpenAt = struct {
fd: os.fd_t,
path: [*:0]const u8,
flags: u32,
mode: os.mode_t,
result: Error!os.fd_t,
pub const Error = os.OpenError;
};
pub const Close = struct {
fd: os.fd_t,
};
pub const FAccessAt = struct {
dirfd: os.fd_t,
path: [*:0]const u8,
mode: u32,
flags: u32,
result: Error!void,
pub const Error = os.AccessError;
};
};
};
};
test "std.event.Loop - basic" {
// https://github.com/ziglang/zig/issues/1908
if (builtin.single_threaded) return error.SkipZigTest;
if (true) {
// https://github.com/ziglang/zig/issues/4922
return error.SkipZigTest;
}
var loop: Loop = undefined;
try loop.initMultiThreaded();
defer loop.deinit();
loop.run();
}
fn testEventLoop() i32 {
return 1234;
}
fn testEventLoop2(h: anyframe->i32, did_it: *bool) void {
const value = await h;
testing.expect(value == 1234);
did_it.* = true;
}
|
lib/std/event/loop.zig
|
const std = @import("../std.zig");
const assert = std.debug.assert;
const maxInt = std.math.maxInt;
const State = enum {
Complete,
Value,
ArrayStart,
Array,
ObjectStart,
Object,
};
/// Writes JSON ([RFC8259](https://tools.ietf.org/html/rfc8259)) formatted data
/// to a stream. `max_depth` is a comptime-known upper bound on the nesting depth.
/// TODO A future iteration of this API will allow passing `null` for this value,
/// and disable safety checks in release builds.
pub fn WriteStream(comptime OutStream: type, comptime max_depth: usize) type {
return struct {
const Self = @This();
pub const Stream = OutStream;
whitespace: std.json.StringifyOptions.Whitespace = std.json.StringifyOptions.Whitespace{
.indent_level = 0,
.indent = .{ .Space = 1 },
},
stream: OutStream,
state_index: usize,
state: [max_depth]State,
pub fn init(stream: OutStream) Self {
var self = Self{
.stream = stream,
.state_index = 1,
.state = undefined,
};
self.state[0] = .Complete;
self.state[1] = .Value;
return self;
}
pub fn beginArray(self: *Self) !void {
assert(self.state[self.state_index] == State.Value); // need to call arrayElem or objectField
try self.stream.writeByte('[');
self.state[self.state_index] = State.ArrayStart;
self.whitespace.indent_level += 1;
}
pub fn beginObject(self: *Self) !void {
assert(self.state[self.state_index] == State.Value); // need to call arrayElem or objectField
try self.stream.writeByte('{');
self.state[self.state_index] = State.ObjectStart;
self.whitespace.indent_level += 1;
}
pub fn arrayElem(self: *Self) !void {
const state = self.state[self.state_index];
switch (state) {
.Complete => unreachable,
.Value => unreachable,
.ObjectStart => unreachable,
.Object => unreachable,
.Array, .ArrayStart => {
if (state == .Array) {
try self.stream.writeByte(',');
}
self.state[self.state_index] = .Array;
self.pushState(.Value);
try self.indent();
},
}
}
pub fn objectField(self: *Self, name: []const u8) !void {
const state = self.state[self.state_index];
switch (state) {
.Complete => unreachable,
.Value => unreachable,
.ArrayStart => unreachable,
.Array => unreachable,
.Object, .ObjectStart => {
if (state == .Object) {
try self.stream.writeByte(',');
}
self.state[self.state_index] = .Object;
self.pushState(.Value);
try self.indent();
try self.writeEscapedString(name);
try self.stream.writeByte(':');
if (self.whitespace.separator) {
try self.stream.writeByte(' ');
}
},
}
}
pub fn endArray(self: *Self) !void {
switch (self.state[self.state_index]) {
.Complete => unreachable,
.Value => unreachable,
.ObjectStart => unreachable,
.Object => unreachable,
.ArrayStart => {
self.whitespace.indent_level -= 1;
try self.stream.writeByte(']');
self.popState();
},
.Array => {
self.whitespace.indent_level -= 1;
try self.indent();
self.popState();
try self.stream.writeByte(']');
},
}
}
pub fn endObject(self: *Self) !void {
switch (self.state[self.state_index]) {
.Complete => unreachable,
.Value => unreachable,
.ArrayStart => unreachable,
.Array => unreachable,
.ObjectStart => {
self.whitespace.indent_level -= 1;
try self.stream.writeByte('}');
self.popState();
},
.Object => {
self.whitespace.indent_level -= 1;
try self.indent();
self.popState();
try self.stream.writeByte('}');
},
}
}
pub fn emitNull(self: *Self) !void {
assert(self.state[self.state_index] == State.Value);
try self.stringify(null);
self.popState();
}
pub fn emitBool(self: *Self, value: bool) !void {
assert(self.state[self.state_index] == State.Value);
try self.stringify(value);
self.popState();
}
pub fn emitNumber(
self: *Self,
/// An integer, float, or `std.math.BigInt`. Emitted as a bare number if it fits losslessly
/// in a IEEE 754 double float, otherwise emitted as a string to the full precision.
value: var,
) !void {
assert(self.state[self.state_index] == State.Value);
switch (@typeInfo(@TypeOf(value))) {
.Int => |info| {
if (info.bits < 53) {
try self.stream.print("{}", .{value});
self.popState();
return;
}
if (value < 4503599627370496 and (!info.is_signed or value > -4503599627370496)) {
try self.stream.print("{}", .{value});
self.popState();
return;
}
},
.Float => if (@floatCast(f64, value) == value) {
try self.stream.print("{}", .{value});
self.popState();
return;
},
else => {},
}
try self.stream.print("\"{}\"", .{value});
self.popState();
}
pub fn emitString(self: *Self, string: []const u8) !void {
try self.writeEscapedString(string);
self.popState();
}
fn writeEscapedString(self: *Self, string: []const u8) !void {
assert(std.unicode.utf8ValidateSlice(string));
try self.stringify(string);
}
/// Writes the complete json into the output stream
pub fn emitJson(self: *Self, json: std.json.Value) Stream.Error!void {
try self.stringify(json);
}
fn indent(self: *Self) !void {
assert(self.state_index >= 1);
try self.stream.writeByte('\n');
try self.whitespace.outputIndent(self.stream);
}
fn pushState(self: *Self, state: State) void {
self.state_index += 1;
self.state[self.state_index] = state;
}
fn popState(self: *Self) void {
self.state_index -= 1;
}
fn stringify(self: *Self, value: var) !void {
try std.json.stringify(value, std.json.StringifyOptions{
.whitespace = self.whitespace,
}, self.stream);
}
};
}
pub fn writeStream(
out_stream: var,
comptime max_depth: usize,
) WriteStream(@TypeOf(out_stream), max_depth) {
return WriteStream(@TypeOf(out_stream), max_depth).init(out_stream);
}
test "json write stream" {
var out_buf: [1024]u8 = undefined;
var slice_stream = std.io.fixedBufferStream(&out_buf);
const out = slice_stream.outStream();
var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_allocator.deinit();
var w = std.json.writeStream(out, 10);
try w.emitJson(try getJson(&arena_allocator.allocator));
const result = slice_stream.getWritten();
const expected =
\\{
\\ "object": {
\\ "one": 1,
\\ "two": 2.0e+00
\\ },
\\ "string": "This is a string",
\\ "array": [
\\ "Another string",
\\ 1,
\\ 3.14e+00
\\ ],
\\ "int": 10,
\\ "float": 3.14e+00
\\}
;
std.testing.expect(std.mem.eql(u8, expected, result));
}
fn getJson(allocator: *std.mem.Allocator) !std.json.Value {
var value = std.json.Value{ .Object = std.json.ObjectMap.init(allocator) };
_ = try value.Object.put("string", std.json.Value{ .String = "This is a string" });
_ = try value.Object.put("int", std.json.Value{ .Integer = @intCast(i64, 10) });
_ = try value.Object.put("float", std.json.Value{ .Float = 3.14 });
_ = try value.Object.put("array", try getJsonArray(allocator));
_ = try value.Object.put("object", try getJsonObject(allocator));
return value;
}
fn getJsonObject(allocator: *std.mem.Allocator) !std.json.Value {
var value = std.json.Value{ .Object = std.json.ObjectMap.init(allocator) };
_ = try value.Object.put("one", std.json.Value{ .Integer = @intCast(i64, 1) });
_ = try value.Object.put("two", std.json.Value{ .Float = 2.0 });
return value;
}
fn getJsonArray(allocator: *std.mem.Allocator) !std.json.Value {
var value = std.json.Value{ .Array = std.json.Array.init(allocator) };
var array = &value.Array;
_ = try array.append(std.json.Value{ .String = "Another string" });
_ = try array.append(std.json.Value{ .Integer = @intCast(i64, 1) });
_ = try array.append(std.json.Value{ .Float = 3.14 });
return value;
}
|
lib/std/json/write_stream.zig
|
const builtin = @import("builtin");
const std = @import("../std.zig");
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
const mem = std.mem;
const fmt = std.fmt;
const Allocator = mem.Allocator;
const math = std.math;
const windows = std.os.windows;
const fs = std.fs;
const process = std.process;
pub const sep_windows = '\\';
pub const sep_posix = '/';
pub const sep = if (builtin.os == .windows) sep_windows else sep_posix;
pub const sep_str = [1]u8{sep};
pub const delimiter_windows = ';';
pub const delimiter_posix = ':';
pub const delimiter = if (builtin.os == .windows) delimiter_windows else delimiter_posix;
pub fn isSep(byte: u8) bool {
if (builtin.os == .windows) {
return byte == '/' or byte == '\\';
} else {
return byte == '/';
}
}
/// This is different from mem.join in that the separator will not be repeated if
/// it is found at the end or beginning of a pair of consecutive paths.
fn joinSep(allocator: *Allocator, separator: u8, paths: []const []const u8) ![]u8 {
if (paths.len == 0) return &[0]u8{};
const total_len = blk: {
var sum: usize = paths[0].len;
var i: usize = 1;
while (i < paths.len) : (i += 1) {
const prev_path = paths[i - 1];
const this_path = paths[i];
const prev_sep = (prev_path.len != 0 and prev_path[prev_path.len - 1] == separator);
const this_sep = (this_path.len != 0 and this_path[0] == separator);
sum += @boolToInt(!prev_sep and !this_sep);
sum += if (prev_sep and this_sep) this_path.len - 1 else this_path.len;
}
break :blk sum;
};
const buf = try allocator.alloc(u8, total_len);
errdefer allocator.free(buf);
mem.copy(u8, buf, paths[0]);
var buf_index: usize = paths[0].len;
var i: usize = 1;
while (i < paths.len) : (i += 1) {
const prev_path = paths[i - 1];
const this_path = paths[i];
const prev_sep = (prev_path.len != 0 and prev_path[prev_path.len - 1] == separator);
const this_sep = (this_path.len != 0 and this_path[0] == separator);
if (!prev_sep and !this_sep) {
buf[buf_index] = separator;
buf_index += 1;
}
const adjusted_path = if (prev_sep and this_sep) this_path[1..] else this_path;
mem.copy(u8, buf[buf_index..], adjusted_path);
buf_index += adjusted_path.len;
}
// No need for shrink since buf is exactly the correct size.
return buf;
}
pub const join = if (builtin.os == .windows) joinWindows else joinPosix;
/// Naively combines a series of paths with the native path seperator.
/// Allocates memory for the result, which must be freed by the caller.
pub fn joinWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
return joinSep(allocator, sep_windows, paths);
}
/// Naively combines a series of paths with the native path seperator.
/// Allocates memory for the result, which must be freed by the caller.
pub fn joinPosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
return joinSep(allocator, sep_posix, paths);
}
fn testJoinWindows(paths: []const []const u8, expected: []const u8) void {
var buf: [1024]u8 = undefined;
const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
const actual = joinWindows(a, paths) catch @panic("fail");
testing.expectEqualSlices(u8, expected, actual);
}
fn testJoinPosix(paths: []const []const u8, expected: []const u8) void {
var buf: [1024]u8 = undefined;
const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
const actual = joinPosix(a, paths) catch @panic("fail");
testing.expectEqualSlices(u8, expected, actual);
}
test "join" {
testJoinWindows([_][]const u8{ "c:\\a\\b", "c" }, "c:\\a\\b\\c");
testJoinWindows([_][]const u8{ "c:\\a\\b", "c" }, "c:\\a\\b\\c");
testJoinWindows([_][]const u8{ "c:\\a\\b\\", "c" }, "c:\\a\\b\\c");
testJoinWindows([_][]const u8{ "c:\\", "a", "b\\", "c" }, "c:\\a\\b\\c");
testJoinWindows([_][]const u8{ "c:\\a\\", "b\\", "c" }, "c:\\a\\b\\c");
testJoinWindows(
[_][]const u8{ "c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std", "io.zig" },
"c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std\\io.zig",
);
testJoinPosix([_][]const u8{ "/a/b", "c" }, "/a/b/c");
testJoinPosix([_][]const u8{ "/a/b/", "c" }, "/a/b/c");
testJoinPosix([_][]const u8{ "/", "a", "b/", "c" }, "/a/b/c");
testJoinPosix([_][]const u8{ "/a/", "b/", "c" }, "/a/b/c");
testJoinPosix(
[_][]const u8{ "/home/andy/dev/zig/build/lib/zig/std", "io.zig" },
"/home/andy/dev/zig/build/lib/zig/std/io.zig",
);
testJoinPosix([_][]const u8{ "a", "/c" }, "a/c");
testJoinPosix([_][]const u8{ "a/", "/c" }, "a/c");
}
pub fn isAbsolute(path: []const u8) bool {
if (builtin.os == .windows) {
return isAbsoluteWindows(path);
} else {
return isAbsolutePosix(path);
}
}
pub fn isAbsoluteW(path_w: [*]const u16) bool {
if (path_w[0] == '/')
return true;
if (path_w[0] == '\\') {
return true;
}
if (path_w[0] == 0 or path_w[1] == 0 or path_w[2] == 0) {
return false;
}
if (path_w[1] == ':') {
if (path_w[2] == '/')
return true;
if (path_w[2] == '\\')
return true;
}
return false;
}
pub fn isAbsoluteWindows(path: []const u8) bool {
if (path[0] == '/')
return true;
if (path[0] == '\\') {
return true;
}
if (path.len < 3) {
return false;
}
if (path[1] == ':') {
if (path[2] == '/')
return true;
if (path[2] == '\\')
return true;
}
return false;
}
pub fn isAbsolutePosix(path: []const u8) bool {
return path[0] == sep_posix;
}
test "isAbsoluteWindows" {
testIsAbsoluteWindows("/", true);
testIsAbsoluteWindows("//", true);
testIsAbsoluteWindows("//server", true);
testIsAbsoluteWindows("//server/file", true);
testIsAbsoluteWindows("\\\\server\\file", true);
testIsAbsoluteWindows("\\\\server", true);
testIsAbsoluteWindows("\\\\", true);
testIsAbsoluteWindows("c", false);
testIsAbsoluteWindows("c:", false);
testIsAbsoluteWindows("c:\\", true);
testIsAbsoluteWindows("c:/", true);
testIsAbsoluteWindows("c://", true);
testIsAbsoluteWindows("C:/Users/", true);
testIsAbsoluteWindows("C:\\Users\\", true);
testIsAbsoluteWindows("C:cwd/another", false);
testIsAbsoluteWindows("C:cwd\\another", false);
testIsAbsoluteWindows("directory/directory", false);
testIsAbsoluteWindows("directory\\directory", false);
testIsAbsoluteWindows("/usr/local", true);
}
test "isAbsolutePosix" {
testIsAbsolutePosix("/home/foo", true);
testIsAbsolutePosix("/home/foo/..", true);
testIsAbsolutePosix("bar/", false);
testIsAbsolutePosix("./baz", false);
}
fn testIsAbsoluteWindows(path: []const u8, expected_result: bool) void {
testing.expectEqual(expected_result, isAbsoluteWindows(path));
}
fn testIsAbsolutePosix(path: []const u8, expected_result: bool) void {
testing.expectEqual(expected_result, isAbsolutePosix(path));
}
pub const WindowsPath = struct {
is_abs: bool,
kind: Kind,
disk_designator: []const u8,
pub const Kind = enum {
None,
Drive,
NetworkShare,
};
};
pub fn windowsParsePath(path: []const u8) WindowsPath {
if (path.len >= 2 and path[1] == ':') {
return WindowsPath{
.is_abs = isAbsoluteWindows(path),
.kind = WindowsPath.Kind.Drive,
.disk_designator = path[0..2],
};
}
if (path.len >= 1 and (path[0] == '/' or path[0] == '\\') and
(path.len == 1 or (path[1] != '/' and path[1] != '\\')))
{
return WindowsPath{
.is_abs = true,
.kind = WindowsPath.Kind.None,
.disk_designator = path[0..0],
};
}
const relative_path = WindowsPath{
.kind = WindowsPath.Kind.None,
.disk_designator = [_]u8{},
.is_abs = false,
};
if (path.len < "//a/b".len) {
return relative_path;
}
inline for ("/\\") |this_sep| {
const two_sep = [_]u8{ this_sep, this_sep };
if (mem.startsWith(u8, path, two_sep)) {
if (path[2] == this_sep) {
return relative_path;
}
var it = mem.tokenize(path, [_]u8{this_sep});
_ = (it.next() orelse return relative_path);
_ = (it.next() orelse return relative_path);
return WindowsPath{
.is_abs = isAbsoluteWindows(path),
.kind = WindowsPath.Kind.NetworkShare,
.disk_designator = path[0..it.index],
};
}
}
return relative_path;
}
test "windowsParsePath" {
{
const parsed = windowsParsePath("//a/b");
testing.expect(parsed.is_abs);
testing.expect(parsed.kind == WindowsPath.Kind.NetworkShare);
testing.expect(mem.eql(u8, parsed.disk_designator, "//a/b"));
}
{
const parsed = windowsParsePath("\\\\a\\b");
testing.expect(parsed.is_abs);
testing.expect(parsed.kind == WindowsPath.Kind.NetworkShare);
testing.expect(mem.eql(u8, parsed.disk_designator, "\\\\a\\b"));
}
{
const parsed = windowsParsePath("\\\\a\\");
testing.expect(!parsed.is_abs);
testing.expect(parsed.kind == WindowsPath.Kind.None);
testing.expect(mem.eql(u8, parsed.disk_designator, ""));
}
{
const parsed = windowsParsePath("/usr/local");
testing.expect(parsed.is_abs);
testing.expect(parsed.kind == WindowsPath.Kind.None);
testing.expect(mem.eql(u8, parsed.disk_designator, ""));
}
{
const parsed = windowsParsePath("c:../");
testing.expect(!parsed.is_abs);
testing.expect(parsed.kind == WindowsPath.Kind.Drive);
testing.expect(mem.eql(u8, parsed.disk_designator, "c:"));
}
}
pub fn diskDesignator(path: []const u8) []const u8 {
if (builtin.os == .windows) {
return diskDesignatorWindows(path);
} else {
return "";
}
}
pub fn diskDesignatorWindows(path: []const u8) []const u8 {
return windowsParsePath(path).disk_designator;
}
fn networkShareServersEql(ns1: []const u8, ns2: []const u8) bool {
const sep1 = ns1[0];
const sep2 = ns2[0];
var it1 = mem.tokenize(ns1, [_]u8{sep1});
var it2 = mem.tokenize(ns2, [_]u8{sep2});
// TODO ASCII is wrong, we actually need full unicode support to compare paths.
return asciiEqlIgnoreCase(it1.next().?, it2.next().?);
}
fn compareDiskDesignators(kind: WindowsPath.Kind, p1: []const u8, p2: []const u8) bool {
switch (kind) {
WindowsPath.Kind.None => {
assert(p1.len == 0);
assert(p2.len == 0);
return true;
},
WindowsPath.Kind.Drive => {
return asciiUpper(p1[0]) == asciiUpper(p2[0]);
},
WindowsPath.Kind.NetworkShare => {
const sep1 = p1[0];
const sep2 = p2[0];
var it1 = mem.tokenize(p1, [_]u8{sep1});
var it2 = mem.tokenize(p2, [_]u8{sep2});
// TODO ASCII is wrong, we actually need full unicode support to compare paths.
return asciiEqlIgnoreCase(it1.next().?, it2.next().?) and asciiEqlIgnoreCase(it1.next().?, it2.next().?);
},
}
}
fn asciiUpper(byte: u8) u8 {
return switch (byte) {
'a'...'z' => 'A' + (byte - 'a'),
else => byte,
};
}
fn asciiEqlIgnoreCase(s1: []const u8, s2: []const u8) bool {
if (s1.len != s2.len)
return false;
var i: usize = 0;
while (i < s1.len) : (i += 1) {
if (asciiUpper(s1[i]) != asciiUpper(s2[i]))
return false;
}
return true;
}
/// On Windows, this calls `resolveWindows` and on POSIX it calls `resolvePosix`.
pub fn resolve(allocator: *Allocator, paths: []const []const u8) ![]u8 {
if (builtin.os == .windows) {
return resolveWindows(allocator, paths);
} else {
return resolvePosix(allocator, paths);
}
}
/// This function is like a series of `cd` statements executed one after another.
/// It resolves "." and "..".
/// The result does not have a trailing path separator.
/// If all paths are relative it uses the current working directory as a starting point.
/// Each drive has its own current working directory.
/// Path separators are canonicalized to '\\' and drives are canonicalized to capital letters.
/// Note: all usage of this function should be audited due to the existence of symlinks.
/// Without performing actual syscalls, resolving `..` could be incorrect.
pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
if (paths.len == 0) {
assert(builtin.os == .windows); // resolveWindows called on non windows can't use getCwd
return process.getCwdAlloc(allocator);
}
// determine which disk designator we will result with, if any
var result_drive_buf = "_:";
var result_disk_designator: []const u8 = "";
var have_drive_kind = WindowsPath.Kind.None;
var have_abs_path = false;
var first_index: usize = 0;
var max_size: usize = 0;
for (paths) |p, i| {
const parsed = windowsParsePath(p);
if (parsed.is_abs) {
have_abs_path = true;
first_index = i;
max_size = result_disk_designator.len;
}
switch (parsed.kind) {
WindowsPath.Kind.Drive => {
result_drive_buf[0] = asciiUpper(parsed.disk_designator[0]);
result_disk_designator = result_drive_buf[0..];
have_drive_kind = WindowsPath.Kind.Drive;
},
WindowsPath.Kind.NetworkShare => {
result_disk_designator = parsed.disk_designator;
have_drive_kind = WindowsPath.Kind.NetworkShare;
},
WindowsPath.Kind.None => {},
}
max_size += p.len + 1;
}
// if we will result with a disk designator, loop again to determine
// which is the last time the disk designator is absolutely specified, if any
// and count up the max bytes for paths related to this disk designator
if (have_drive_kind != WindowsPath.Kind.None) {
have_abs_path = false;
first_index = 0;
max_size = result_disk_designator.len;
var correct_disk_designator = false;
for (paths) |p, i| {
const parsed = windowsParsePath(p);
if (parsed.kind != WindowsPath.Kind.None) {
if (parsed.kind == have_drive_kind) {
correct_disk_designator = compareDiskDesignators(have_drive_kind, result_disk_designator, parsed.disk_designator);
} else {
continue;
}
}
if (!correct_disk_designator) {
continue;
}
if (parsed.is_abs) {
first_index = i;
max_size = result_disk_designator.len;
have_abs_path = true;
}
max_size += p.len + 1;
}
}
// Allocate result and fill in the disk designator, calling getCwd if we have to.
var result: []u8 = undefined;
var result_index: usize = 0;
if (have_abs_path) {
switch (have_drive_kind) {
WindowsPath.Kind.Drive => {
result = try allocator.alloc(u8, max_size);
mem.copy(u8, result, result_disk_designator);
result_index += result_disk_designator.len;
},
WindowsPath.Kind.NetworkShare => {
result = try allocator.alloc(u8, max_size);
var it = mem.tokenize(paths[first_index], "/\\");
const server_name = it.next().?;
const other_name = it.next().?;
result[result_index] = '\\';
result_index += 1;
result[result_index] = '\\';
result_index += 1;
mem.copy(u8, result[result_index..], server_name);
result_index += server_name.len;
result[result_index] = '\\';
result_index += 1;
mem.copy(u8, result[result_index..], other_name);
result_index += other_name.len;
result_disk_designator = result[0..result_index];
},
WindowsPath.Kind.None => {
assert(builtin.os == .windows); // resolveWindows called on non windows can't use getCwd
const cwd = try process.getCwdAlloc(allocator);
defer allocator.free(cwd);
const parsed_cwd = windowsParsePath(cwd);
result = try allocator.alloc(u8, max_size + parsed_cwd.disk_designator.len + 1);
mem.copy(u8, result, parsed_cwd.disk_designator);
result_index += parsed_cwd.disk_designator.len;
result_disk_designator = result[0..parsed_cwd.disk_designator.len];
if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
result[0] = asciiUpper(result[0]);
}
have_drive_kind = parsed_cwd.kind;
},
}
} else {
assert(builtin.os == .windows); // resolveWindows called on non windows can't use getCwd
// TODO call get cwd for the result_disk_designator instead of the global one
const cwd = try process.getCwdAlloc(allocator);
defer allocator.free(cwd);
result = try allocator.alloc(u8, max_size + cwd.len + 1);
mem.copy(u8, result, cwd);
result_index += cwd.len;
const parsed_cwd = windowsParsePath(result[0..result_index]);
result_disk_designator = parsed_cwd.disk_designator;
if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
result[0] = asciiUpper(result[0]);
}
have_drive_kind = parsed_cwd.kind;
}
errdefer allocator.free(result);
// Now we know the disk designator to use, if any, and what kind it is. And our result
// is big enough to append all the paths to.
var correct_disk_designator = true;
for (paths[first_index..]) |p, i| {
const parsed = windowsParsePath(p);
if (parsed.kind != WindowsPath.Kind.None) {
if (parsed.kind == have_drive_kind) {
correct_disk_designator = compareDiskDesignators(have_drive_kind, result_disk_designator, parsed.disk_designator);
} else {
continue;
}
}
if (!correct_disk_designator) {
continue;
}
var it = mem.tokenize(p[parsed.disk_designator.len..], "/\\");
while (it.next()) |component| {
if (mem.eql(u8, component, ".")) {
continue;
} else if (mem.eql(u8, component, "..")) {
while (true) {
if (result_index == 0 or result_index == result_disk_designator.len)
break;
result_index -= 1;
if (result[result_index] == '\\' or result[result_index] == '/')
break;
}
} else {
result[result_index] = sep_windows;
result_index += 1;
mem.copy(u8, result[result_index..], component);
result_index += component.len;
}
}
}
if (result_index == result_disk_designator.len) {
result[result_index] = '\\';
result_index += 1;
}
return allocator.shrink(result, result_index);
}
/// This function is like a series of `cd` statements executed one after another.
/// It resolves "." and "..".
/// The result does not have a trailing path separator.
/// If all paths are relative it uses the current working directory as a starting point.
/// Note: all usage of this function should be audited due to the existence of symlinks.
/// Without performing actual syscalls, resolving `..` could be incorrect.
pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
if (paths.len == 0) {
assert(builtin.os != .windows); // resolvePosix called on windows can't use getCwd
return process.getCwdAlloc(allocator);
}
var first_index: usize = 0;
var have_abs = false;
var max_size: usize = 0;
for (paths) |p, i| {
if (isAbsolutePosix(p)) {
first_index = i;
have_abs = true;
max_size = 0;
}
max_size += p.len + 1;
}
var result: []u8 = undefined;
var result_index: usize = 0;
if (have_abs) {
result = try allocator.alloc(u8, max_size);
} else {
assert(builtin.os != .windows); // resolvePosix called on windows can't use getCwd
const cwd = try process.getCwdAlloc(allocator);
defer allocator.free(cwd);
result = try allocator.alloc(u8, max_size + cwd.len + 1);
mem.copy(u8, result, cwd);
result_index += cwd.len;
}
errdefer allocator.free(result);
for (paths[first_index..]) |p, i| {
var it = mem.tokenize(p, "/");
while (it.next()) |component| {
if (mem.eql(u8, component, ".")) {
continue;
} else if (mem.eql(u8, component, "..")) {
while (true) {
if (result_index == 0)
break;
result_index -= 1;
if (result[result_index] == '/')
break;
}
} else {
result[result_index] = '/';
result_index += 1;
mem.copy(u8, result[result_index..], component);
result_index += component.len;
}
}
}
if (result_index == 0) {
result[0] = '/';
result_index += 1;
}
return allocator.shrink(result, result_index);
}
test "resolve" {
const cwd = try process.getCwdAlloc(debug.global_allocator);
if (builtin.os == .windows) {
if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {
cwd[0] = asciiUpper(cwd[0]);
}
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{"."}), cwd));
} else {
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "a/b/c/", "../../.." }), cwd));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{"."}), cwd));
}
}
test "resolveWindows" {
if (@import("builtin").arch == .aarch64) {
// TODO https://github.com/ziglang/zig/issues/3288
return error.SkipZigTest;
}
if (builtin.os == .windows) {
const cwd = try process.getCwdAlloc(debug.global_allocator);
const parsed_cwd = windowsParsePath(cwd);
{
const result = testResolveWindows([_][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" });
const expected = try join(debug.global_allocator, [_][]const u8{
parsed_cwd.disk_designator,
"usr\\local\\lib\\zig\\std\\array_list.zig",
});
if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
}
testing.expect(mem.eql(u8, result, expected));
}
{
const result = testResolveWindows([_][]const u8{ "usr/local", "lib\\zig" });
const expected = try join(debug.global_allocator, [_][]const u8{
cwd,
"usr\\local\\lib\\zig",
});
if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
}
testing.expect(mem.eql(u8, result, expected));
}
}
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:\\a\\b\\c", "/hi", "ok" }), "C:\\hi\\ok"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/blah\\blah", "d:/games", "c:../a" }), "C:\\blah\\a"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/blah\\blah", "d:/games", "C:../a" }), "C:\\blah\\a"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/ignore", "d:\\a/b\\c/d", "\\e.exe" }), "D:\\e.exe"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/ignore", "c:/some/file" }), "C:\\some\\file"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "d:/ignore", "d:some/dir//" }), "D:\\ignore\\some\\dir"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "//server/share", "..", "relative\\" }), "\\\\server\\share\\relative"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/", "//" }), "C:\\"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/", "//dir" }), "C:\\dir"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/", "//server/share" }), "\\\\server\\share\\"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/", "//server//share" }), "\\\\server\\share\\"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "c:/", "///some//dir" }), "C:\\some\\dir"));
testing.expect(mem.eql(u8, testResolveWindows([_][]const u8{ "C:\\foo\\tmp.3\\", "..\\tmp.3\\cycles\\root.js" }), "C:\\foo\\tmp.3\\cycles\\root.js"));
}
test "resolvePosix" {
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "/a/b", "c" }), "/a/b/c"));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "/a/b", "c", "//d", "e///" }), "/d/e"));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "/a/b/c", "..", "../" }), "/a"));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "/", "..", ".." }), "/"));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{"/a/b/c/"}), "/a/b/c"));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "/var/lib", "../", "file/" }), "/var/file"));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "/var/lib", "/../", "file/" }), "/file"));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "/some/dir", ".", "/absolute/" }), "/absolute"));
testing.expect(mem.eql(u8, testResolvePosix([_][]const u8{ "/foo/tmp.3/", "../tmp.3/cycles/root.js" }), "/foo/tmp.3/cycles/root.js"));
}
fn testResolveWindows(paths: []const []const u8) []u8 {
return resolveWindows(debug.global_allocator, paths) catch unreachable;
}
fn testResolvePosix(paths: []const []const u8) []u8 {
return resolvePosix(debug.global_allocator, paths) catch unreachable;
}
/// If the path is a file in the current directory (no directory component)
/// then returns null
pub fn dirname(path: []const u8) ?[]const u8 {
if (builtin.os == .windows) {
return dirnameWindows(path);
} else {
return dirnamePosix(path);
}
}
pub fn dirnameWindows(path: []const u8) ?[]const u8 {
if (path.len == 0)
return null;
const root_slice = diskDesignatorWindows(path);
if (path.len == root_slice.len)
return path;
const have_root_slash = path.len > root_slice.len and (path[root_slice.len] == '/' or path[root_slice.len] == '\\');
var end_index: usize = path.len - 1;
while ((path[end_index] == '/' or path[end_index] == '\\') and end_index > root_slice.len) {
if (end_index == 0)
return null;
end_index -= 1;
}
while (path[end_index] != '/' and path[end_index] != '\\' and end_index > root_slice.len) {
if (end_index == 0)
return null;
end_index -= 1;
}
if (have_root_slash and end_index == root_slice.len) {
end_index += 1;
}
if (end_index == 0)
return null;
return path[0..end_index];
}
pub fn dirnamePosix(path: []const u8) ?[]const u8 {
if (path.len == 0)
return null;
var end_index: usize = path.len - 1;
while (path[end_index] == '/') {
if (end_index == 0)
return path[0..1];
end_index -= 1;
}
while (path[end_index] != '/') {
if (end_index == 0)
return null;
end_index -= 1;
}
if (end_index == 0 and path[end_index] == '/')
return path[0..1];
if (end_index == 0)
return null;
return path[0..end_index];
}
test "dirnamePosix" {
testDirnamePosix("/a/b/c", "/a/b");
testDirnamePosix("/a/b/c///", "/a/b");
testDirnamePosix("/a", "/");
testDirnamePosix("/", "/");
testDirnamePosix("////", "/");
testDirnamePosix("", null);
testDirnamePosix("a", null);
testDirnamePosix("a/", null);
testDirnamePosix("a//", null);
}
test "dirnameWindows" {
testDirnameWindows("c:\\", "c:\\");
testDirnameWindows("c:\\foo", "c:\\");
testDirnameWindows("c:\\foo\\", "c:\\");
testDirnameWindows("c:\\foo\\bar", "c:\\foo");
testDirnameWindows("c:\\foo\\bar\\", "c:\\foo");
testDirnameWindows("c:\\foo\\bar\\baz", "c:\\foo\\bar");
testDirnameWindows("\\", "\\");
testDirnameWindows("\\foo", "\\");
testDirnameWindows("\\foo\\", "\\");
testDirnameWindows("\\foo\\bar", "\\foo");
testDirnameWindows("\\foo\\bar\\", "\\foo");
testDirnameWindows("\\foo\\bar\\baz", "\\foo\\bar");
testDirnameWindows("c:", "c:");
testDirnameWindows("c:foo", "c:");
testDirnameWindows("c:foo\\", "c:");
testDirnameWindows("c:foo\\bar", "c:foo");
testDirnameWindows("c:foo\\bar\\", "c:foo");
testDirnameWindows("c:foo\\bar\\baz", "c:foo\\bar");
testDirnameWindows("file:stream", null);
testDirnameWindows("dir\\file:stream", "dir");
testDirnameWindows("\\\\unc\\share", "\\\\unc\\share");
testDirnameWindows("\\\\unc\\share\\foo", "\\\\unc\\share\\");
testDirnameWindows("\\\\unc\\share\\foo\\", "\\\\unc\\share\\");
testDirnameWindows("\\\\unc\\share\\foo\\bar", "\\\\unc\\share\\foo");
testDirnameWindows("\\\\unc\\share\\foo\\bar\\", "\\\\unc\\share\\foo");
testDirnameWindows("\\\\unc\\share\\foo\\bar\\baz", "\\\\unc\\share\\foo\\bar");
testDirnameWindows("/a/b/", "/a");
testDirnameWindows("/a/b", "/a");
testDirnameWindows("/a", "/");
testDirnameWindows("", null);
testDirnameWindows("/", "/");
testDirnameWindows("////", "/");
testDirnameWindows("foo", null);
}
fn testDirnamePosix(input: []const u8, expected_output: ?[]const u8) void {
if (dirnamePosix(input)) |output| {
testing.expect(mem.eql(u8, output, expected_output.?));
} else {
testing.expect(expected_output == null);
}
}
fn testDirnameWindows(input: []const u8, expected_output: ?[]const u8) void {
if (dirnameWindows(input)) |output| {
testing.expect(mem.eql(u8, output, expected_output.?));
} else {
testing.expect(expected_output == null);
}
}
pub fn basename(path: []const u8) []const u8 {
if (builtin.os == .windows) {
return basenameWindows(path);
} else {
return basenamePosix(path);
}
}
pub fn basenamePosix(path: []const u8) []const u8 {
if (path.len == 0)
return [_]u8{};
var end_index: usize = path.len - 1;
while (path[end_index] == '/') {
if (end_index == 0)
return [_]u8{};
end_index -= 1;
}
var start_index: usize = end_index;
end_index += 1;
while (path[start_index] != '/') {
if (start_index == 0)
return path[0..end_index];
start_index -= 1;
}
return path[start_index + 1 .. end_index];
}
pub fn basenameWindows(path: []const u8) []const u8 {
if (path.len == 0)
return [_]u8{};
var end_index: usize = path.len - 1;
while (true) {
const byte = path[end_index];
if (byte == '/' or byte == '\\') {
if (end_index == 0)
return [_]u8{};
end_index -= 1;
continue;
}
if (byte == ':' and end_index == 1) {
return [_]u8{};
}
break;
}
var start_index: usize = end_index;
end_index += 1;
while (path[start_index] != '/' and path[start_index] != '\\' and
!(path[start_index] == ':' and start_index == 1))
{
if (start_index == 0)
return path[0..end_index];
start_index -= 1;
}
return path[start_index + 1 .. end_index];
}
test "basename" {
testBasename("", "");
testBasename("/", "");
testBasename("/dir/basename.ext", "basename.ext");
testBasename("/basename.ext", "basename.ext");
testBasename("basename.ext", "basename.ext");
testBasename("basename.ext/", "basename.ext");
testBasename("basename.ext//", "basename.ext");
testBasename("/aaa/bbb", "bbb");
testBasename("/aaa/", "aaa");
testBasename("/aaa/b", "b");
testBasename("/a/b", "b");
testBasename("//a", "a");
testBasenamePosix("\\dir\\basename.ext", "\\dir\\basename.ext");
testBasenamePosix("\\basename.ext", "\\basename.ext");
testBasenamePosix("basename.ext", "basename.ext");
testBasenamePosix("basename.ext\\", "basename.ext\\");
testBasenamePosix("basename.ext\\\\", "basename.ext\\\\");
testBasenamePosix("foo", "foo");
testBasenameWindows("\\dir\\basename.ext", "basename.ext");
testBasenameWindows("\\basename.ext", "basename.ext");
testBasenameWindows("basename.ext", "basename.ext");
testBasenameWindows("basename.ext\\", "basename.ext");
testBasenameWindows("basename.ext\\\\", "basename.ext");
testBasenameWindows("foo", "foo");
testBasenameWindows("C:", "");
testBasenameWindows("C:.", ".");
testBasenameWindows("C:\\", "");
testBasenameWindows("C:\\dir\\base.ext", "base.ext");
testBasenameWindows("C:\\basename.ext", "basename.ext");
testBasenameWindows("C:basename.ext", "basename.ext");
testBasenameWindows("C:basename.ext\\", "basename.ext");
testBasenameWindows("C:basename.ext\\\\", "basename.ext");
testBasenameWindows("C:foo", "foo");
testBasenameWindows("file:stream", "file:stream");
}
fn testBasename(input: []const u8, expected_output: []const u8) void {
testing.expectEqualSlices(u8, expected_output, basename(input));
}
fn testBasenamePosix(input: []const u8, expected_output: []const u8) void {
testing.expectEqualSlices(u8, expected_output, basenamePosix(input));
}
fn testBasenameWindows(input: []const u8, expected_output: []const u8) void {
testing.expectEqualSlices(u8, expected_output, basenameWindows(input));
}
/// Returns the relative path from `from` to `to`. If `from` and `to` each
/// resolve to the same path (after calling `resolve` on each), a zero-length
/// string is returned.
/// On Windows this canonicalizes the drive to a capital letter and paths to `\\`.
pub fn relative(allocator: *Allocator, from: []const u8, to: []const u8) ![]u8 {
if (builtin.os == .windows) {
return relativeWindows(allocator, from, to);
} else {
return relativePosix(allocator, from, to);
}
}
pub fn relativeWindows(allocator: *Allocator, from: []const u8, to: []const u8) ![]u8 {
const resolved_from = try resolveWindows(allocator, [_][]const u8{from});
defer allocator.free(resolved_from);
var clean_up_resolved_to = true;
const resolved_to = try resolveWindows(allocator, [_][]const u8{to});
defer if (clean_up_resolved_to) allocator.free(resolved_to);
const parsed_from = windowsParsePath(resolved_from);
const parsed_to = windowsParsePath(resolved_to);
const result_is_to = x: {
if (parsed_from.kind != parsed_to.kind) {
break :x true;
} else switch (parsed_from.kind) {
WindowsPath.Kind.NetworkShare => {
break :x !networkShareServersEql(parsed_to.disk_designator, parsed_from.disk_designator);
},
WindowsPath.Kind.Drive => {
break :x asciiUpper(parsed_from.disk_designator[0]) != asciiUpper(parsed_to.disk_designator[0]);
},
else => unreachable,
}
};
if (result_is_to) {
clean_up_resolved_to = false;
return resolved_to;
}
var from_it = mem.tokenize(resolved_from, "/\\");
var to_it = mem.tokenize(resolved_to, "/\\");
while (true) {
const from_component = from_it.next() orelse return mem.dupe(allocator, u8, to_it.rest());
const to_rest = to_it.rest();
if (to_it.next()) |to_component| {
// TODO ASCII is wrong, we actually need full unicode support to compare paths.
if (asciiEqlIgnoreCase(from_component, to_component))
continue;
}
var up_count: usize = 1;
while (from_it.next()) |_| {
up_count += 1;
}
const up_index_end = up_count * "..\\".len;
const result = try allocator.alloc(u8, up_index_end + to_rest.len);
errdefer allocator.free(result);
var result_index: usize = 0;
while (result_index < up_index_end) {
result[result_index] = '.';
result_index += 1;
result[result_index] = '.';
result_index += 1;
result[result_index] = '\\';
result_index += 1;
}
// shave off the trailing slash
result_index -= 1;
var rest_it = mem.tokenize(to_rest, "/\\");
while (rest_it.next()) |to_component| {
result[result_index] = '\\';
result_index += 1;
mem.copy(u8, result[result_index..], to_component);
result_index += to_component.len;
}
return result[0..result_index];
}
return [_]u8{};
}
pub fn relativePosix(allocator: *Allocator, from: []const u8, to: []const u8) ![]u8 {
const resolved_from = try resolvePosix(allocator, [_][]const u8{from});
defer allocator.free(resolved_from);
const resolved_to = try resolvePosix(allocator, [_][]const u8{to});
defer allocator.free(resolved_to);
var from_it = mem.tokenize(resolved_from, "/");
var to_it = mem.tokenize(resolved_to, "/");
while (true) {
const from_component = from_it.next() orelse return mem.dupe(allocator, u8, to_it.rest());
const to_rest = to_it.rest();
if (to_it.next()) |to_component| {
if (mem.eql(u8, from_component, to_component))
continue;
}
var up_count: usize = 1;
while (from_it.next()) |_| {
up_count += 1;
}
const up_index_end = up_count * "../".len;
const result = try allocator.alloc(u8, up_index_end + to_rest.len);
errdefer allocator.free(result);
var result_index: usize = 0;
while (result_index < up_index_end) {
result[result_index] = '.';
result_index += 1;
result[result_index] = '.';
result_index += 1;
result[result_index] = '/';
result_index += 1;
}
if (to_rest.len == 0) {
// shave off the trailing slash
return result[0 .. result_index - 1];
}
mem.copy(u8, result[result_index..], to_rest);
return result;
}
return [_]u8{};
}
test "relative" {
if (@import("builtin").arch == .aarch64) {
// TODO https://github.com/ziglang/zig/issues/3288
return error.SkipZigTest;
}
testRelativeWindows("c:/blah\\blah", "d:/games", "D:\\games");
testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa", "..");
testRelativeWindows("c:/aaaa/bbbb", "c:/cccc", "..\\..\\cccc");
testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa/bbbb", "");
testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa/cccc", "..\\cccc");
testRelativeWindows("c:/aaaa/", "c:/aaaa/cccc", "cccc");
testRelativeWindows("c:/", "c:\\aaaa\\bbbb", "aaaa\\bbbb");
testRelativeWindows("c:/aaaa/bbbb", "d:\\", "D:\\");
testRelativeWindows("c:/AaAa/bbbb", "c:/aaaa/bbbb", "");
testRelativeWindows("c:/aaaaa/", "c:/aaaa/cccc", "..\\aaaa\\cccc");
testRelativeWindows("C:\\foo\\bar\\baz\\quux", "C:\\", "..\\..\\..\\..");
testRelativeWindows("C:\\foo\\test", "C:\\foo\\test\\bar\\package.json", "bar\\package.json");
testRelativeWindows("C:\\foo\\bar\\baz-quux", "C:\\foo\\bar\\baz", "..\\baz");
testRelativeWindows("C:\\foo\\bar\\baz", "C:\\foo\\bar\\baz-quux", "..\\baz-quux");
testRelativeWindows("\\\\foo\\bar", "\\\\foo\\bar\\baz", "baz");
testRelativeWindows("\\\\foo\\bar\\baz", "\\\\foo\\bar", "..");
testRelativeWindows("\\\\foo\\bar\\baz-quux", "\\\\foo\\bar\\baz", "..\\baz");
testRelativeWindows("\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz-quux", "..\\baz-quux");
testRelativeWindows("C:\\baz-quux", "C:\\baz", "..\\baz");
testRelativeWindows("C:\\baz", "C:\\baz-quux", "..\\baz-quux");
testRelativeWindows("\\\\foo\\baz-quux", "\\\\foo\\baz", "..\\baz");
testRelativeWindows("\\\\foo\\baz", "\\\\foo\\baz-quux", "..\\baz-quux");
testRelativeWindows("C:\\baz", "\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz");
testRelativeWindows("\\\\foo\\bar\\baz", "C:\\baz", "C:\\baz");
testRelativePosix("/var/lib", "/var", "..");
testRelativePosix("/var/lib", "/bin", "../../bin");
testRelativePosix("/var/lib", "/var/lib", "");
testRelativePosix("/var/lib", "/var/apache", "../apache");
testRelativePosix("/var/", "/var/lib", "lib");
testRelativePosix("/", "/var/lib", "var/lib");
testRelativePosix("/foo/test", "/foo/test/bar/package.json", "bar/package.json");
testRelativePosix("/Users/a/web/b/test/mails", "/Users/a/web/b", "../..");
testRelativePosix("/foo/bar/baz-quux", "/foo/bar/baz", "../baz");
testRelativePosix("/foo/bar/baz", "/foo/bar/baz-quux", "../baz-quux");
testRelativePosix("/baz-quux", "/baz", "../baz");
testRelativePosix("/baz", "/baz-quux", "../baz-quux");
}
fn testRelativePosix(from: []const u8, to: []const u8, expected_output: []const u8) void {
const result = relativePosix(debug.global_allocator, from, to) catch unreachable;
testing.expectEqualSlices(u8, expected_output, result);
}
fn testRelativeWindows(from: []const u8, to: []const u8, expected_output: []const u8) void {
const result = relativeWindows(debug.global_allocator, from, to) catch unreachable;
testing.expectEqualSlices(u8, expected_output, result);
}
|
lib/std/fs/path.zig
|
// TODO
// 1. Validation of input data in parser: slice ranges and object sizes/alignments
// 2. Refactorings to simplify a bit where possible
// 5. Optimization pass in encoder to speed up instances of reasonably packed
// data? (slices, packed structs, etc)
// 6. Make arrays less silly
const std = @import("std");
const builtin = @import("builtin");
const liu = @import("./lib.zig");
const assert = std.debug.assert;
const Marker: u8 = 0;
fn isInternalType(comptime T: type) bool {
comptime {
return @typeInfo(T) == .Struct and @hasDecl(T, "LiuPackedAssetDummyField") and
T.LiuPackedAssetDummyField == &Marker;
}
}
pub fn U32Slice(comptime T: type) type {
return extern struct {
word_offset: u32,
len: u32,
pub const SliceType = T;
const LiuPackedAssetDummyField: *const u8 = &Marker;
pub fn slice(self: *const @This()) []const T {
const address = @ptrToInt(self);
var out: []T = &.{};
out.ptr = @intToPtr([*]T, 4 * self.word_offset + address);
out.len = self.len;
return out;
}
};
}
const Version: u32 = 0;
const Header = extern struct {
magic: [4]u8 = "aliu"[0..4].*,
version: u32 = Version,
data_begin: u32,
spec_len: u32,
};
pub const EncoderInfo = struct { type_info: TypeInfo, offset: u32 = 0 };
pub const TypeInfo = enum(u8) {
const ALIGN_2: u8 = 4;
const ALIGN_4: u8 = 8;
const ALIGN_8: u8 = 14;
// struct open/close alignment comes from trailing number
pu8,
pi8,
ustruct_open_1,
ustruct_close_1,
pu16 = ALIGN_2,
pi16,
ustruct_open_2,
ustruct_close_2,
pu32 = ALIGN_4,
pi32,
pf32,
uslice_of_next, // align 4, size 8
ustruct_open_4,
ustruct_close_4,
pu64 = ALIGN_8,
pi64,
pf64,
ustruct_open_8,
ustruct_close_8,
_,
pub fn alignment(self: @This()) u16 {
return switch (self) {
.pu8, .pi8, .ustruct_open_1, .ustruct_close_1 => 1,
.pu16, .pi16, .ustruct_open_2, .ustruct_close_2 => 2,
.pu32, .pi32, .pf32, .uslice_of_next, .ustruct_open_4, .ustruct_close_4 => 4,
.pu64, .pi64, .pf64, .ustruct_open_8, .ustruct_close_8 => 8,
else => unreachable,
};
}
};
pub const Spec = struct {
Type: type,
encoder_info: []const EncoderInfo,
header: Header,
comptime {
const native_endian = builtin.target.cpu.arch.endian();
if (native_endian != .Little)
@compileError("target platform must be little endian");
}
pub fn typeInfo(comptime self: @This()) []const TypeInfo {
comptime {
var info: []const TypeInfo = &.{};
for (self.encoder_info) |e| {
info = info ++ &[_]TypeInfo{e.type_info};
}
return info;
}
}
pub fn fromType(comptime T: type) @This() {
comptime {
const ExternType = translateType(T);
const encode_info = makeInfo(ExternType, T);
const spec_len = @truncate(u32, encode_info.len);
const data_begin = @truncate(u32, std.mem.alignForward(16 + spec_len, 8));
const header = Header{ .data_begin = data_begin, .spec_len = spec_len };
return .{
.Type = ExternType,
.encoder_info = encode_info,
.header = header,
};
}
}
fn makeInfo(comptime T: type, comptime Base: type) []const EncoderInfo {
// @compileLog(T, Base);
comptime {
const info = switch (@typeInfo(T)) {
.Int => |info| {
const type_info: TypeInfo = switch (info.bits) {
8 => if (info.signedness == .signed) .pi8 else .pu8,
16 => if (info.signedness == .signed) .pi16 else .pu16,
32 => if (info.signedness == .signed) .pi32 else .pu32,
64 => if (info.signedness == .signed) .pi64 else .pu64,
else => @compileError("doesn't handle non-standard integer sizes"),
};
return &.{EncoderInfo{ .type_info = type_info }};
},
.Struct => |info| info,
.Array => |info| {
const Elem = @typeInfo(Base).Array.child;
const encode_info = makeInfo(info.child, Elem);
const spec_info: [2]TypeInfo = switch (@alignOf(info.child)) {
1 => .{ .ustruct_open_1, .ustruct_close_1 },
2 => .{ .ustruct_open_2, .ustruct_close_2 },
4 => .{ .ustruct_open_4, .ustruct_close_4 },
8 => .{ .ustruct_open_8, .ustruct_close_8 },
else => unreachable,
};
const val = EncoderInfo{ .type_info = spec_info[0] };
var spec: []const EncoderInfo = &[_]EncoderInfo{val};
var i: u32 = 0;
const end: u32 = info.len;
// Empirically, this reduces the number of branches needed at
// compile time.
if (encode_info.len == 1) { // This means its a primitive
while (i < end) : (i += 1) {
const new_info = EncoderInfo{
.type_info = encode_info[0].type_info,
.offset = i * @sizeOf(Elem),
};
spec = spec ++ &[_]EncoderInfo{new_info};
}
return spec ++ &[_]EncoderInfo{.{ .type_info = spec_info[1] }};
}
while (i < end) : (i += 1) {
var iter = EncoderInfoIter{ .info = encode_info };
while (iter.peek()) |sa| : (iter.index = sa.next_index) {
const offset = sa.offset + i * @sizeOf(Elem);
const new_info = EncoderInfo{
.type_info = sa.type_info,
.offset = offset,
};
spec = spec ++ &[_]EncoderInfo{new_info};
if (sa.slice_info) |slice_info| {
spec = spec ++ slice_info.spec;
}
}
}
return spec ++ &[_]EncoderInfo{.{ .type_info = spec_info[1] }};
},
.Pointer => @compileError("Native pointers are unsupported. " ++
"If you're looking for slices, use the custom wrapper type instead"),
else => @compileError("Unsupported type: " ++ @typeName(T)),
};
// There's an argument you could make that this should actually
// accept only packed and not extern. Extern is easier to implement.
// - <NAME>, Jun 04, 2022 Sat 14:48 PDT
if (info.layout != .Extern)
@compileError("struct must be laid out using extern format");
if (isInternalType(T)) {
const ElemBase = if (isInternalType(Base)) T.SliceType else std.meta.Child(Base);
const elem_type = makeInfo(T.SliceType, ElemBase);
const slice_info = EncoderInfo{
.type_info = .uslice_of_next,
};
return &[_]EncoderInfo{slice_info} ++ elem_type;
}
const spec_info: [2]TypeInfo = switch (@alignOf(T)) {
1 => .{ .ustruct_open_1, .ustruct_close_1 },
2 => .{ .ustruct_open_2, .ustruct_close_2 },
4 => .{ .ustruct_open_4, .ustruct_close_4 },
8 => .{ .ustruct_open_8, .ustruct_close_8 },
else => unreachable,
};
const val = EncoderInfo{ .type_info = spec_info[0] };
var spec: []const EncoderInfo = &[_]EncoderInfo{val};
var b: Base = undefined;
for (info.fields) |field| {
const BField = @TypeOf(@field(b, field.name));
const encode_info = makeInfo(field.field_type, BField);
// Empirically, this reduces the number of branches needed at
// compile time.
if (encode_info.len == 1) {
// This means its a primitive
const new_info = EncoderInfo{
.type_info = encode_info[0].type_info,
.offset = @offsetOf(Base, field.name),
};
spec = spec ++ &[_]EncoderInfo{new_info};
continue;
}
var iter = EncoderInfoIter{ .info = encode_info };
while (iter.peek()) |sa| : (iter.index = sa.next_index) {
const offset = sa.offset + @offsetOf(Base, field.name);
const new_info = EncoderInfo{
.type_info = sa.type_info,
.offset = offset,
};
spec = spec ++ &[_]EncoderInfo{new_info};
if (sa.slice_info) |slice_info| {
spec = spec ++ slice_info.spec;
}
}
}
return spec ++ &[_]EncoderInfo{.{ .type_info = spec_info[1] }};
}
}
fn translateType(comptime T: type) type {
const Field = std.builtin.Type.StructField;
comptime {
const info = switch (@typeInfo(T)) {
.Int => return T,
.Float => return T,
.Struct => |info| info,
.Array => |info| {
if (info.sentinel != null) @compileError("we don't support sentinels");
const Child = translateType(info.child);
return [info.len]Child;
},
.Pointer => |info| {
if (info.size == .Slice)
return U32Slice(translateType(info.child));
@compileError("only slices allowed right now");
},
else => @compileError("type is not compatible with serialization"),
};
// These only need to be checked for structs, because
// Ints are checked again anyways in makeInfo
// Floats always follow these rules
// Pointers to anything are checked in the recursive call to translateType
// or in makeInfo
// Everything else will fail anyways
if (@sizeOf(T) == 0)
@compileError("type has size=0, there's no data to store");
if (@alignOf(T) > 8)
@compileError("maximum alignment for values is 8");
if (@alignOf(T) == 0)
@compileError("what does align=0 even mean");
if (isInternalType(T)) return T;
var translated: []const Field = &.{};
// NOTE: we use change_count instead of a boolean here, even though
// the eventual data we need is just a boolean, because it allows
// us to prevent a branch during comptime. Maybe this is necessary,
// maybe its not, it's unclear. We're hovering right at that 1000
// mark right now for one of the test cases.
var change_count: usize = 0;
for (info.fields) |field| {
const FieldT = translateType(field.field_type);
change_count += @boolToInt(FieldT != field.field_type);
const to_add = Field{
.name = field.name,
.field_type = FieldT,
.default_value = null,
.is_comptime = false,
.alignment = @alignOf(FieldT),
};
translated = translated ++ &[_]Field{to_add};
}
if (info.layout == .Extern) {
if (change_count == 0) return T;
return @Type(.{ .Struct = .{
.layout = .Extern,
.decls = &.{},
.is_tuple = false,
.fields = translated,
} });
}
var fields: []const Field = &.{};
// This process is just for sorting fields by alignment,
// it's not using sort because sorting Fields isn't really
// allowed at compile-time.
for (translated) |field| {
if (field.alignment == 8) fields = fields ++ &[_]Field{field};
}
for (translated) |field| {
if (field.alignment == 4) fields = fields ++ &[_]Field{field};
}
for (translated) |field| {
if (field.alignment == 2) fields = fields ++ &[_]Field{field};
}
for (translated) |field| {
if (field.alignment == 1) fields = fields ++ &[_]Field{field};
}
return @Type(.{ .Struct = .{
.layout = .Extern,
.decls = &.{},
.is_tuple = false,
.fields = fields,
} });
}
}
};
const ObjectInfo = struct { spec: []const EncoderInfo, size: u32, alignment: u16 };
fn objectInfo(spec: []const EncoderInfo) ObjectInfo {
var iter: EncoderInfoIter = .{ .info = spec };
var alignment: u16 = 0;
var total_size: u32 = 0;
while (iter.peek()) |sa| {
alignment = std.math.max(alignment, sa.alignment);
total_size = @truncate(u32, std.mem.alignForward(total_size, sa.alignment));
total_size += sa.size;
iter.index = sa.next_index;
}
return .{
.spec = spec[0..iter.index],
.size = total_size,
.alignment = alignment,
};
}
const EncoderInfoIter = struct {
info: []const EncoderInfo,
index: usize = 0,
struct_count: u32 = 0,
const SA = struct {
next_index: usize = undefined,
type_info: TypeInfo = undefined,
size: u32,
alignment: u16,
offset: u32 = 0,
slice_info: ?ObjectInfo = null,
};
fn peek(self: *@This()) ?SA {
const is_cancelled = self.index != 0 and self.struct_count == 0;
const has_more_data = self.index < self.info.len;
if (is_cancelled or !has_more_data) return null;
var sa = SA{ .size = 0, .alignment = 0 };
var index: usize = self.index;
const encoder_info = self.info[index];
sa.type_info = encoder_info.type_info;
sa.next_index = index + 1;
sa.offset = encoder_info.offset;
{
// Equivalent to max operation:
// const alignment_ = encoder_info.type_info.alignment();
// sa.alignment = std.math.max(sa.alignment, alignment_);
//
// Empirically, this reduces the number of comptime branches.
const val = @enumToInt(encoder_info.type_info);
const a2: u4 = @boolToInt(val >= TypeInfo.ALIGN_2);
const a4: u4 = @boolToInt(val >= TypeInfo.ALIGN_4);
const a8: u4 = @boolToInt(val >= TypeInfo.ALIGN_8);
const alignment_ = @intCast(u16, 1) << (a2 + a4 + a8);
const cmp: u16 = @boolToInt(sa.alignment > alignment_);
sa.alignment = cmp * sa.alignment + (1 - cmp) * alignment_;
}
switch (encoder_info.type_info) {
.pu8, .pi8 => {
sa.size = 1;
},
.pu16, .pi16 => {
sa.size = 2;
},
.pu32, .pi32, .pf32 => {
sa.size = 4;
},
.pu64, .pi64, .pf64 => {
sa.size = 8;
},
.uslice_of_next => {
const remainder = self.info[(index + 1)..];
var info = objectInfo(remainder);
info.alignment = std.math.max(info.alignment, 4);
sa.next_index += info.spec.len;
sa.size = 8;
sa.slice_info = info;
},
.ustruct_open_1, .ustruct_open_2, .ustruct_open_4, .ustruct_open_8 => {
self.struct_count += 1;
},
.ustruct_close_1, .ustruct_close_2, .ustruct_close_4, .ustruct_close_8 => {
self.struct_count -= 1;
},
// Encoder info comes from a trusted source (the program text)
else => unreachable,
}
return sa;
}
};
const Encoder = struct {
header: Header,
file_offset: u32 = 0,
slice_data: std.ArrayListUnmanaged(SliceInfo) = .{},
next_slice_data: u32 = 0,
next_slice_offset: u32,
iter: EncoderInfoIter,
object: [*]const u8,
object_size: u32,
obj_left: u32 = 1,
const Self = @This();
const SliceInfo = struct {
spec: []const EncoderInfo,
data: [*]const u8,
obj_left: u32,
obj_size: u32,
offset: u32,
};
fn init(comptime T: type, value: *const T) Self {
const spec = Spec.fromType(T);
const obj_info = objectInfo(spec.encoder_info);
assert(obj_info.size == @sizeOf(spec.Type));
return .{
.header = spec.header,
.iter = .{ .info = spec.encoder_info },
.object = @ptrCast([*]const u8, value),
.object_size = obj_info.size,
.next_slice_offset = spec.header.data_begin + obj_info.size,
};
}
fn deinit(self: *Self) void {
self.slice_data.deinit(liu.Pages);
}
fn encodeObj(self: *Self, cursor_: u32, chunk: []align(8) u8) !?u32 {
const len = @truncate(u32, chunk.len);
var cursor = cursor_;
while (self.iter.peek()) |sa| {
const aligned = @truncate(u32, std.mem.alignForward(cursor, sa.alignment));
std.mem.set(u8, chunk[cursor..aligned], 0); // fill padding with zeroes
cursor = aligned;
const field_mem = self.object + sa.offset;
// NOTE: We don't have to do partial writes of fields here,
// because we maintain the invariants that chunks are aligned
// to 8 bytes and all primitive data has a maximum alignment/size of 8.
if (cursor + sa.size > len) return null;
const out = chunk[cursor..];
defer cursor += sa.size;
self.iter.index = sa.next_index;
if (sa.slice_info) |info| {
const raw_slice = @bitCast([]const u8, field_mem[0..@sizeOf([]u8)].*);
const obj_left = @truncate(u32, raw_slice.len);
const offset = if (obj_left == 0) 0 else offset: {
const offset = @truncate(u32, std.mem.alignForward(
self.next_slice_offset,
info.alignment,
));
try self.slice_data.append(liu.Pages, SliceInfo{
.spec = info.spec,
.data = raw_slice.ptr,
.obj_size = info.size,
.obj_left = obj_left,
.offset = offset,
});
const current_offset = cursor + self.file_offset;
const relative_offset = offset - current_offset;
assert(relative_offset % 4 == 0);
self.next_slice_offset = offset + info.size * obj_left;
break :offset relative_offset;
};
out[0..4].* = @bitCast([4]u8, offset / 4);
out[4..8].* = @bitCast([4]u8, obj_left);
continue;
}
std.mem.copy(u8, out[0..sa.size], field_mem[0..sa.size]);
}
return cursor;
}
fn encode(self: *Self, chunk: []align(8) u8) !?u32 {
assert(chunk.len % 8 == 0);
const len = @truncate(u32, chunk.len);
var cursor: u32 = 0;
defer self.file_offset += len;
// We're in the first chunk, at offset 0. We can safely assume that we
// have the spec of the root type in its spec field. At this point, we
// need to output the header of the file.
if (self.file_offset == 0) {
const header = self.header;
assert(self.next_slice_offset == header.data_begin + self.object_size);
@ptrCast(*Header, chunk[0..16]).* = header;
// spec array
for (self.iter.info) |s, i| {
chunk[i + 16] = @enumToInt(s.type_info);
}
// fill out padding between spec and data begin with zeros
std.mem.set(u8, chunk[(16 + header.spec_len)..header.data_begin], 0);
cursor = header.data_begin;
}
while (true) {
while (self.obj_left > 0) {
const new_cursor = try self.encodeObj(cursor, chunk);
cursor = new_cursor orelse return null;
self.iter = .{ .info = self.iter.info };
self.object += self.object_size;
self.obj_left -= 1;
}
if (self.next_slice_data >= self.slice_data.items.len) break;
const slice_data = self.slice_data.items[self.next_slice_data];
self.next_slice_data += 1;
if (self.next_slice_data >= self.slice_data.items.len) {
self.next_slice_data = 0;
self.slice_data.items.len = 0;
}
self.iter = .{ .info = slice_data.spec };
self.object = slice_data.data;
self.object_size = slice_data.obj_size;
self.obj_left = slice_data.obj_left;
const alignment = std.math.max(4, slice_data.spec[0].type_info.alignment());
const aligned = @truncate(u32, std.mem.alignForward(cursor, alignment));
std.mem.set(u8, chunk[cursor..aligned], 0); // fill padding with zeroes
cursor = aligned;
assert(aligned + self.file_offset == slice_data.offset);
}
return cursor;
}
};
fn Encoded(comptime chunk_size: u32) type {
return struct {
chunks: []*align(8) [chunk_size]u8,
last: []align(8) const u8,
pub const ChunkSize = chunk_size;
pub fn len(self: *const @This()) usize {
return self.chunks.len * chunk_size + self.last.len;
}
pub fn copyContiguous(self: *const @This(), alloc: std.mem.Allocator) ![]align(8) u8 {
const bytes = try alloc.alignedAlloc(u8, 8, self.len());
for (self.chunks) |chunk, i| {
const begin = i * ChunkSize;
std.mem.copy(u8, bytes[begin..], chunk);
}
{
const begin = self.chunks.len * ChunkSize;
std.mem.copy(u8, bytes[begin..], self.last);
}
return bytes;
}
};
}
const DefaultChunkSize = 16 * 4096;
pub fn tempEncode(value: anytype, comptime chunk_size_: ?u32) !Encoded(chunk_size_ orelse DefaultChunkSize) {
const chunk_size = chunk_size_ orelse DefaultChunkSize;
if (comptime chunk_size % 8 != 0)
@compileError("chunk size must be aligned to 8 bytes");
const spec = Spec.fromType(@TypeOf(value));
if (comptime chunk_size < spec.header.data_begin)
@compileError("chunk size should be at least enough bytes to hold the header");
const ChunkT = [chunk_size]u8;
const ChunkPtrT = *align(8) ChunkT;
var encoder = Encoder.init(@TypeOf(value), &value);
defer encoder.deinit();
var list = std.ArrayList(ChunkPtrT).init(liu.Temp);
while (true) {
const chunk_ = try liu.Temp.alignedAlloc(ChunkT, 8, 1);
const chunk = &chunk_[0];
if (try encoder.encode(chunk)) |size| {
return Encoded(chunk_size){ .chunks = list.items, .last = chunk[0..size] };
}
try list.append(chunk);
}
}
const AssetError = error{
NotAsset,
VersionMismatch,
InvalidData,
TypeMismatch,
OutOfBounds,
};
pub fn parse(comptime T: type, bytes: []align(8) const u8) !*const Spec.fromType(T).Type {
if (bytes.len < @sizeOf(Header)) return error.NotAsset;
const header = @ptrCast(*const Header, bytes[0..16]);
if (!std.mem.eql(u8, &header.magic, "aliu")) return error.NotAsset;
if (header.version > Version) return error.VersionMismatch;
if (header.data_begin > bytes.len) return error.OutOfBounds;
if (header.data_begin % 8 != 0) return error.InvalidData;
const spec_end = 16 + header.spec_len;
if (spec_end > header.data_begin) return error.InvalidData;
const spec = comptime Spec.fromType(T);
const type_info = comptime spec.typeInfo();
const asset_spec = @ptrCast([]const TypeInfo, bytes[16..spec_end]);
if (!std.mem.eql(TypeInfo, type_info, asset_spec)) return error.TypeMismatch;
// TODO validation code
// var list = std.ArrayList(u8).init(liu.Pages);
// defer list.deinit();
// while () {
// }
return @ptrCast(*const spec.Type, bytes[header.data_begin..]);
}
test {
_ = @import("./test_packed_asset.zig");
}
|
src/liu/packed_asset.zig
|
const aoc = @import("../aoc.zig");
const std = @import("std");
const Ingredient = struct {
capacity: i32, durability: i32, flavor: i32, texture: i32, calories: i32
};
const Params = struct {
i: i32 = 0, j: i32 = 0, k: i32 = 0, l: i32 = 0,
ingredients: [4]Ingredient = undefined,
fn calcSubscore(self: Params, comptime field: []const u8) ?i32 {
const subscore = self.i*@field(self.ingredients[0], field) + self.j*@field(self.ingredients[1], field) +
self.k*@field(self.ingredients[2], field) + self.l*@field(self.ingredients[3], field);
return if (subscore > 0) subscore else null;
}
};
pub fn run(problem: *aoc.Problem) !aoc.Solution {
var params = Params {};
var ingredients_idx: usize = 0;
while (problem.line()) |line| {
var tokens = std.mem.tokenize(u8, line, " ");
_ = tokens.next().?;
params.ingredients[ingredients_idx] = Ingredient {
.capacity = try int_from_tokens(&tokens, 1),
.durability = try int_from_tokens(&tokens, 1),
.flavor = try int_from_tokens(&tokens, 1),
.texture = try int_from_tokens(&tokens, 1),
.calories = try int_from_tokens(&tokens, 0)
};
ingredients_idx += 1;
}
var best: i32 = 0;
var best_500: i32 = 0;
while (params.i <= 100) : (params.i += 1) {
params.j = 0;
while (params.j <= 100 - params.i) : (params.j += 1) {
params.k = 0;
while (params.k <= 100 - params.i - params.j) : (params.k += 1) {
params.l = 100 - params.i - params.j - params.k;
const capacity = params.calcSubscore("capacity") orelse continue;
const durability = params.calcSubscore("durability") orelse continue;
const flavor = params.calcSubscore("flavor") orelse continue;
const texture = params.calcSubscore("texture") orelse continue;
const score = capacity * durability * flavor * texture;
best = std.math.max(best, score);
const calories = params.calcSubscore("calories") orelse continue;
if (calories == 500) {
best_500 = std.math.max(best_500, score);
}
}
}
}
return problem.solution(best, best_500);
}
fn int_from_tokens(tokens: *std.mem.TokenIterator(u8), offset: usize) !i32 {
_ = tokens.next().?;
const token = tokens.next().?;
return try std.fmt.parseInt(i32, token[0..token.len-offset], 10);
}
|
src/main/zig/2015/day15.zig
|
const std = @import("../std.zig");
const assert = std.debug.assert;
const mem = std.mem;
const Allocator = std.mem.Allocator;
/// This allocator takes an existing allocator, wraps it, and provides an interface
/// where you can allocate without freeing, and then free it all together.
pub const ArenaAllocator = struct {
allocator: Allocator,
child_allocator: *Allocator,
state: State,
/// Inner state of ArenaAllocator. Can be stored rather than the entire ArenaAllocator
/// as a memory-saving optimization.
pub const State = struct {
buffer_list: std.SinglyLinkedList([]u8) = @as(std.SinglyLinkedList([]u8), .{}),
end_index: usize = 0,
pub fn promote(self: State, child_allocator: *Allocator) ArenaAllocator {
return .{
.allocator = Allocator{
.allocFn = alloc,
.resizeFn = Allocator.noResize,
},
.child_allocator = child_allocator,
.state = self,
};
}
};
const BufNode = std.SinglyLinkedList([]u8).Node;
pub fn init(child_allocator: *Allocator) ArenaAllocator {
return (State{}).promote(child_allocator);
}
pub fn deinit(self: ArenaAllocator) void {
var it = self.state.buffer_list.first;
while (it) |node| {
// this has to occur before the free because the free frees node
const next_it = node.next;
self.child_allocator.free(node.data);
it = next_it;
}
}
fn createNode(self: *ArenaAllocator, prev_len: usize, minimum_size: usize) !*BufNode {
const actual_min_size = minimum_size + (@sizeOf(BufNode) + 16);
const big_enough_len = prev_len + actual_min_size;
const len = big_enough_len + big_enough_len / 2;
const buf = try self.child_allocator.allocFn(self.child_allocator, len, @alignOf(BufNode), 1, @returnAddress());
const buf_node = @ptrCast(*BufNode, @alignCast(@alignOf(BufNode), buf.ptr));
buf_node.* = BufNode{
.data = buf,
.next = null,
};
self.state.buffer_list.prepend(buf_node);
self.state.end_index = 0;
return buf_node;
}
fn alloc(allocator: *Allocator, n: usize, ptr_align: u29, len_align: u29, ra: usize) ![]u8 {
const self = @fieldParentPtr(ArenaAllocator, "allocator", allocator);
var cur_node = if (self.state.buffer_list.first) |first_node| first_node else try self.createNode(0, n + ptr_align);
while (true) {
const cur_buf = cur_node.data[@sizeOf(BufNode)..];
const addr = @ptrToInt(cur_buf.ptr) + self.state.end_index;
const adjusted_addr = mem.alignForward(addr, ptr_align);
const adjusted_index = self.state.end_index + (adjusted_addr - addr);
const new_end_index = adjusted_index + n;
if (new_end_index > cur_buf.len) {
cur_node = try self.createNode(cur_buf.len, n + ptr_align);
continue;
}
const result = cur_buf[adjusted_index..new_end_index];
self.state.end_index = new_end_index;
return result;
}
}
};
|
lib/std/heap/arena_allocator.zig
|
const std = @import("std");
const builtin = @import("builtin");
const testing = std.testing;
const dif = @import("dif.zig");
const dot = @import("dot.zig");
const sema = @import("sema.zig");
const ial = @import("indexedarraylist.zig");
pub const LIB_VERSION = blk: {
if (builtin.mode != .Debug) {
break :blk @embedFile("../VERSION");
} else {
break :blk @embedFile("../VERSION") ++ "-UNRELEASED";
}
};
/// Represents a file w/ contents
const Unit = struct {
const Self = @This();
path: []const u8,
contents: []const u8, // owned
allocator: std.mem.Allocator,
pub fn init(allocator: std.mem.Allocator, path: []const u8) !Self {
return Self{ .path = path, .allocator = allocator, .contents = try std.fs.cwd().readFileAlloc(allocator, path, 5 * 1024 * 1024) };
}
pub fn deinit(self: *Self) void {
self.allocator.free(self.contents);
}
};
/// Converts daya data to dot, written to passed writer. If includes are found, it will attempt to read those files.
/// Accepts a buf to allow simple entry-point to parse arbitrary strings and not requiring actual files.
/// TODO: Assume cwd is set to direct parent of file included. Any other includes will then operate relative to this.
// TBD: Can possible resolve this maintaining concatinated paths throughout...
pub fn dayaToDot(allocator: std.mem.Allocator, comptime Writer: type, writer: Writer, buf: []const u8, entry_file: []const u8) !void {
// The actual buffers and path-references
var units = std.StringHashMap(Unit).init(allocator);
defer units.deinit();
defer {
var it = units.valueIterator();
while (it.next()) |unit| unit.deinit();
}
var node_pool = ial.IndexedArrayList(dif.DifNode).init(allocator);
defer node_pool.deinit();
// Keep to append the rest of includes to later
var document_root = try dif.bufToDif(&node_pool, buf, entry_file);
// Include-handling
// Att! This will traverse the entire dif, including the newly included units. No check for duplicate includes, recursions etc.
// TODO: Add certain checks. E.g. do a sema of some sorts to ensure certain degree of correctness (as far as possible since all includes are possibly not included yet)?
var include_iterator = dif.DifTraverser.init(&document_root, .Include);
while (include_iterator.next()) |include| {
// Read and tokenize
// TODO: Set cwd to the folder of the file so any includes are handled relatively to file
var unit = if (units.getPtr(include.name.?)) |val| blk: {
break :blk val;
} else blk: {
try units.put(include.name.?, try Unit.init(allocator, include.name.?));
break :blk units.getPtr(include.name.?).?;
};
// Convert to dif
var dif_root = try dif.bufToDif(&node_pool, unit.contents, unit.path);
// Join in at location of include-node (directly after)
dif_root.get().next_sibling = include.next_sibling;
include.next_sibling = dif_root;
}
// TBD: Could also do incremental sema on unit by unit as they are parsed
var sema_ctx = sema.SemaContext().init(allocator, document_root);
defer sema_ctx.deinit();
// TODO: Have sema produce a more proper data structure of verified integrity? That way the output-handlers (being the current dot, or a futere renderer) can be simplified
// This will also allow us to be better prepared for the hypothetical self-rolled renderer.
try sema.doSema(&sema_ctx);
var dot_ctx = dot.DotContext(Writer).init(writer);
try dot.difToDot(Writer, &dot_ctx, &document_root);
}
test "dayaToDot w/ includes" {
const bufwriter = @import("bufwriter.zig");
var out_buf: [1024]u8 = undefined;
var out_buf_context = bufwriter.ArrayBuf{ .buf = out_buf[0..] };
var writer = out_buf_context.writer();
// TODO: Revert cwd
try (try std.fs.cwd().openDir("testfiles", .{})).setAsCwd();
var file_buf = try std.fs.cwd().readFileAlloc(std.testing.allocator, "include.daya", 5 * 1024 * 1024);
defer std.testing.allocator.free(file_buf);
try dayaToDot(std.testing.allocator, @TypeOf(writer), writer, file_buf, "include.daya");
try testing.expect(out_buf_context.slice().len > 0);
// std.debug.print("Contents: {s}\n", .{out_buf_context.slice()});
}
test "dayaToDot w/ nested includes" {
const bufwriter = @import("bufwriter.zig");
var out_buf: [1024]u8 = undefined;
var out_buf_context = bufwriter.ArrayBuf{ .buf = out_buf[0..] };
var writer = out_buf_context.writer();
try (try std.fs.cwd().openDir("multiinclude", .{})).setAsCwd();
var file_buf = try std.fs.cwd().readFileAlloc(std.testing.allocator, "main.daya", 5 * 1024 * 1024);
defer std.testing.allocator.free(file_buf);
try dayaToDot(std.testing.allocator, @TypeOf(writer), writer, file_buf, "main.daya");
try testing.expect(out_buf_context.slice().len > 0);
}
test "test entry" {
comptime {
_ = @import("dif.zig");
_ = @import("tokenizer.zig");
_ = @import("utils.zig");
_ = @import("bufwriter.zig");
_ = @import("dot.zig");
_ = @import("sema.zig");
}
}
|
libdaya/src/main.zig
|
const std = @import("std");
const Sprite = struct {
// `image_id` must be a unique identifier for the image a sprite references.
// You must set this value!
image_id: u64,
// The `texture_id` can set to zero `spritebatch_push`. This value will be overwritten
// with a valid texture id of a generated atlas before batches are reported back to you.
texture_id: u64,
w: i32, h: i32, // width and height of this sprite in pixels
x: f32, y: f32, // x and y position
sx: f32, sy: f32, // scale on x and y axis
c: f32, s: f32, // cosine and sine (represents cos(angle) and sin(angle))
minx: f32, miny: f32, // u coordinate -- This value is for internal use only -- do not set.
maxx: f32, maxy: f32, // v coordinate -- This value is for internal use only -- do not set.
sort_bits: u32,
};
const SpriteBatch = struct {
pub fn init(sb: *SpriteBatch, config: *Config, udata: ?*c_void) i32 {
}
pub fn term(sb: *SpriteBatch) void {
}
// Pushes a sprite onto an internal buffer. Does no other logic.
pub fn push(sb: *SpriteBatch, sprite: Sprite) i32 {
}
// Ensures the image associated with your unique `image_id` is loaded up into spritebatch. This
// function pretends to draw a sprite referencing `image_id` but doesn't actually do any
// drawing at all. Use this function as an optimization to pre-load images you know will be
// drawn very soon, e.g. prefetch all ten images within a single animation just as it starts
// playing.
pub fn prefetch(sb: *SpriteBatch, image_id: u64, w: i32, h: i32) void {
}
// Increments internal timestamps on all textures, for use in `spritebatch_defrag`.
pub fn tick(sb: *SpriteBatch) void {
}
// Sorts the internal sprites and flushes the buffer built by `spritebatch_push`. Will call
// the `submit_batch_fn` function for each batch of sprites and return them as an array. Any `image_id`
// within the `spritebatch_push` buffer that do not yet have a texture handle will request pixels
// from the image via `get_pixels_fn` and request a texture handle via `generate_texture_handle_fn`.
// Returns the number of batches created and submitted.
pub fn flush(sb: *SpriteBatch) i32 {
}
// All textures created so far by `spritebatch_flush` will be considered as candidates for creating
// new internal texture atlases. Internal texture atlases compress images together inside of one
// texture to dramatically reduce draw calls. When an atlas is created, the most recently used `image_id`
// instances are prioritized, to ensure atlases are filled with images all drawn at the same time.
// As some textures cease to draw on screen, they "decay" over time. Once enough images in an atlas
// decay, the atlas is removed, and any "live" images in the atlas are used to create new atlases.
// Can be called every 1/N times `spritebatch_flush` is called.
pub fn defrag(sb: *SpriteBatch) i32 {
}
// Sets all function pointers originally defined in the `config` struct when calling `spritebatch_init`.
// Useful if DLL's are reloaded, or swapped, etc.
pub fn resetFunctionPtrs(sb: *SpriteBatch) void {
}
// Initializes a set of good default paramaters. The users must still set
// the four callbacks inside of `config`.
pub fn setDefaultConfig(config: *Config) void {
}
};
const Callbacks = struct {
batch_callback: SubmitBatchFn,
get_pixels_callback: GetPixelsFn,
generate_texture_callback: GenerateTextureHandleFn,
delete_texture_callback: DestroyTextureHandleFn,
sprites_sorter_callback: ?SpritesSorterFn,
};
const Config = struct {
pixel_stride: i32,
atlas_width_in_pixels: i32,
atlas_height_in_pixels: i32,
atlas_use_border_pixels: i32,
ticks_to_decay_texture: i32, // number of ticks it takes for a texture handle to be destroyed via `destroy_texture_handle_fn`
lonely_buffer_count_till_flush: i32, // Number of unique textures allowed to persist that are not a part of an atlas yet, each one allowed is another draw call.
// These are called "lonely textures", since they don't belong to any atlas yet. Set this to 0 if you want all textures to be
// immediately put into atlases. Setting a higher number, like 64, will buffer up 64 unique textures (which means up to an
// additional 64 draw calls) before flushing them into atlases. Too low of a lonely buffer count combined with a low tick
// to decay rate will cause performance problems where atlases are constantly created and immedately destroyed -- you have
// been warned! Use `SPRITEBATCH_LOG` to gain some insight on what's going on inside the spritebatch when tuning these settings.
ratio_to_decay_atlas: f32, // from 0 to 1, once ratio is less than `ratio_to_decay_atlas`, flush active textures in atlas to lonely buffer
ratio_to_merge_atlases: f32, // from 0 to 0.5, attempts to merge atlases with some ratio of empty space
callbacks: Callbacks,
allocator: *std.mem.Allocator,
};
const SpriteInternal = struct {
image_id: u64,
sort_bits: i32,
w: i32, h: i32,
x: f32, y: f32,
sx: f32, sy: f32,
c: f32, s: f32
};
const TextureInternal = struct {
timestamp: i32,
w: i32, h: i32,
minx: f32, miny: f32,
maxx: f32, maxy: f32,
image_id: u64,
};
// Sprite batches are submit via synchronous callback back to the user. This function is called
// from inside `spritebatch_flush`. Each time `submit_batch_fn` is called an array of sprites
// is handed to the user. The sprites are intended to be further sorted by the user as desired
// (for example, additional sorting based on depth). `w` and `h` are the width/height, respectively,
// of the texture the batch of sprites resides upon. w/h can be useful for knowing texture dim-
// ensions, which is needed to know texel size or other measurements.
const SubmitBatchFn = fn(sprites: *Sprite, count: i32, texture_w: i32, texture_h: i32, udate: ?*c_void) void;
// cute_spritebatch.h needs to know how to get the pixels of an image, generate textures handles (for
// example glGenTextures for OpenGL), and destroy texture handles. These functions are all called
// from within the `spritebatch_defrag` function, and sometimes from `spritebatch_flush`.
// Called when the pixels are needed from the user. `image_id` maps to a unique image, and is *not*
// related to `texture_id` at all. `buffer` must be filled in with `bytes_to_fill` number of bytes.
// The user is assumed to know the width/height of the image, and can optionally verify that
// `bytes_to_fill` matches the user's w * h * stride for this particular image.
const GetPixelsFn = fn(image_id: u64, buffer: ?*c_void, bytes_to_fill: i32, udata: ?*c_void) void;
// Called with a new texture handle is needed. This will happen whenever a new atlas is created,
// and whenever new `image_id`s first appear to cute_spritebatch, and have yet to find their way
// into an appropriate atlas.
const GenerateTextureHandleFn = fn(pixels: ?*c_void, w: i32, h: i32, udata: ?*c_void) u64;
// Called whenever a texture handle is ready to be free'd up. This happens whenever a particular image
// or a particular atlas has not been used for a while, and is ready to be released.
const DestroyTextureHandleFn = fn(texture_id: u64, udata: ?*c_void) void;
// (Optional) If the user provides this callback, cute_spritebatch will call it to sort all of sprites before submit_batch
// callback is called. The intention of sorting is to minimize the submit_batch calls. cute_spritebatch
// provides its own internal sorting function which will be used if the user does not provide this callback.
//
// Example using std::sort (C++) - Please note the lambda needs to be a non-capturing one.
//
// config.sprites_sorter_callback = [](spritebatch_sprite_t* sprites, int count)
// {
// std::sort(sprites, sprites + count,
// [](const spritebatch_sprite_t& a, const spritebatch_sprite_t& b) {
// if (a.sort_bits < b.sort_bits) return true;
// if (a.sort_bits == b.sort_bits && a.texture_id < b.texture_id) return true;
// return false;
// });
// };
const SpritesSorterFn = fn(sprites: []Sprite) void;
|
src/cute_batcher.zig
|
const std = @import("std");
const TestContext = @import("../../src/test.zig").TestContext;
// These tests should work with all platforms, but we're using linux_x64 for
// now for consistency. Will be expanded eventually.
const linux_x64 = std.zig.CrossTarget{
.cpu_arch = .x86_64,
.os_tag = .linux,
};
pub fn addCases(ctx: *TestContext) !void {
{
var case = ctx.exeFromCompiledC("hello world with updates", .{});
// Regular old hello world
case.addCompareOutput(
\\extern fn puts(s: [*:0]const u8) c_int;
\\export fn main() c_int {
\\ _ = puts("hello world!");
\\ return 0;
\\}
, "hello world!" ++ std.cstr.line_sep);
// Now change the message only
case.addCompareOutput(
\\extern fn puts(s: [*:0]const u8) c_int;
\\export fn main() c_int {
\\ _ = puts("yo");
\\ return 0;
\\}
, "yo" ++ std.cstr.line_sep);
// Add an unused Decl
case.addCompareOutput(
\\extern fn puts(s: [*:0]const u8) c_int;
\\export fn main() c_int {
\\ _ = puts("yo!");
\\ return 0;
\\}
\\fn unused() void {}
, "yo!" ++ std.cstr.line_sep);
}
{
var case = ctx.exeFromCompiledC("var args", .{});
case.addCompareOutput(
\\extern fn printf(format: [*:0]const u8, ...) c_int;
\\
\\export fn main() c_int {
\\ _ = printf("Hello, %s!\n", "world");
\\ return 0;
\\}
, "Hello, world!" ++ std.cstr.line_sep);
}
{
var case = ctx.exeFromCompiledC("x86_64-linux inline assembly", linux_x64);
// Exit with 0
case.addCompareOutput(
\\fn exitGood() noreturn {
\\ asm volatile ("syscall"
\\ :
\\ : [number] "{rax}" (231),
\\ [arg1] "{rdi}" (0)
\\ );
\\ unreachable;
\\}
\\
\\export fn main() c_int {
\\ exitGood();
\\}
, "");
// Pass a usize parameter to exit
case.addCompareOutput(
\\export fn main() c_int {
\\ exit(0);
\\}
\\
\\fn exit(code: usize) noreturn {
\\ asm volatile ("syscall"
\\ :
\\ : [number] "{rax}" (231),
\\ [arg1] "{rdi}" (code)
\\ );
\\ unreachable;
\\}
, "");
// Change the parameter to u8
case.addCompareOutput(
\\export fn main() c_int {
\\ exit(0);
\\}
\\
\\fn exit(code: u8) noreturn {
\\ asm volatile ("syscall"
\\ :
\\ : [number] "{rax}" (231),
\\ [arg1] "{rdi}" (code)
\\ );
\\ unreachable;
\\}
, "");
// Do some arithmetic at the exit callsite
case.addCompareOutput(
\\export fn main() c_int {
\\ exitMath(1);
\\}
\\
\\fn exitMath(a: u8) noreturn {
\\ exit(0 + a - a);
\\}
\\
\\fn exit(code: u8) noreturn {
\\ asm volatile ("syscall"
\\ :
\\ : [number] "{rax}" (231),
\\ [arg1] "{rdi}" (code)
\\ );
\\ unreachable;
\\}
\\
, "");
// Invert the arithmetic
case.addCompareOutput(
\\export fn main() c_int {
\\ exitMath(1);
\\}
\\
\\fn exitMath(a: u8) noreturn {
\\ exit(a + 0 - a);
\\}
\\
\\fn exit(code: u8) noreturn {
\\ asm volatile ("syscall"
\\ :
\\ : [number] "{rax}" (231),
\\ [arg1] "{rdi}" (code)
\\ );
\\ unreachable;
\\}
\\
, "");
}
{
var case = ctx.exeFromCompiledC("alloc and retptr", .{});
case.addCompareOutput(
\\fn add(a: i32, b: i32) i32 {
\\ return a + b;
\\}
\\
\\fn addIndirect(a: i32, b: i32) i32 {
\\ return add(a, b);
\\}
\\
\\export fn main() c_int {
\\ return addIndirect(1, 2) - 3;
\\}
, "");
}
{
var case = ctx.exeFromCompiledC("inferred local const and var", .{});
case.addCompareOutput(
\\fn add(a: i32, b: i32) i32 {
\\ return a + b;
\\}
\\
\\export fn main() c_int {
\\ const x = add(1, 2);
\\ var y = add(3, 0);
\\ y -= x;
\\ return y;
\\}
, "");
}
{
var case = ctx.exeFromCompiledC("@setEvalBranchQuota", .{});
case.addCompareOutput(
\\export fn main() i32 {
\\ @setEvalBranchQuota(1001);
\\ const y = rec(1001);
\\ return y - 1;
\\}
\\
\\fn rec(n: usize) callconv(.Inline) usize {
\\ if (n <= 1) return n;
\\ return rec(n - 1);
\\}
, "");
}
{
var case = ctx.exeFromCompiledC("control flow", .{});
// Simple while loop
case.addCompareOutput(
\\export fn main() c_int {
\\ var a: c_int = 0;
\\ while (a < 5) : (a+=1) {}
\\ return a - 5;
\\}
, "");
case.addCompareOutput(
\\export fn main() c_int {
\\ var a = true;
\\ while (!a) {}
\\ return 0;
\\}
, "");
// If expression
case.addCompareOutput(
\\export fn main() c_int {
\\ var cond: c_int = 0;
\\ var a: c_int = @as(c_int, if (cond == 0)
\\ 2
\\ else
\\ 3) + 9;
\\ return a - 11;
\\}
, "");
// Switch expression
case.addCompareOutput(
\\export fn main() c_int {
\\ var cond: c_int = 0;
\\ var a: c_int = switch (cond) {
\\ 1 => 1,
\\ 2 => 2,
\\ 99...300, 12 => 3,
\\ 0 => 4,
\\ else => 5,
\\ };
\\ return a - 4;
\\}
, "");
}
//{
// var case = ctx.exeFromCompiledC("optionals", .{});
// // Simple while loop
// case.addCompareOutput(
// \\export fn main() c_int {
// \\ var count: c_int = 0;
// \\ var opt_ptr: ?*c_int = &count;
// \\ while (opt_ptr) |_| : (count += 1) {
// \\ if (count == 4) opt_ptr = null;
// \\ }
// \\ return count - 5;
// \\}
// , "");
// // Same with non pointer optionals
// case.addCompareOutput(
// \\export fn main() c_int {
// \\ var count: c_int = 0;
// \\ var opt_ptr: ?c_int = count;
// \\ while (opt_ptr) |_| : (count += 1) {
// \\ if (count == 4) opt_ptr = null;
// \\ }
// \\ return count - 5;
// \\}
// , "");
//}
{
var case = ctx.exeFromCompiledC("errors", .{});
case.addCompareOutput(
\\export fn main() c_int {
\\ var e1 = error.Foo;
\\ var e2 = error.Bar;
\\ assert(e1 != e2);
\\ assert(e1 == error.Foo);
\\ assert(e2 == error.Bar);
\\ return 0;
\\}
\\fn assert(b: bool) void {
\\ if (!b) unreachable;
\\}
, "");
case.addCompareOutput(
\\export fn main() c_int {
\\ var e: anyerror!c_int = 0;
\\ const i = e catch 69;
\\ return i;
\\}
, "");
case.addCompareOutput(
\\export fn main() c_int {
\\ var e: anyerror!c_int = error.Foo;
\\ const i = e catch 69;
\\ return 69 - i;
\\}
, "");
}
ctx.c("empty start function", linux_x64,
\\export fn _start() noreturn {
\\ unreachable;
\\}
,
\\ZIG_EXTERN_C zig_noreturn void _start(void);
\\
\\zig_noreturn void _start(void) {
\\ zig_breakpoint();
\\ zig_unreachable();
\\}
\\
);
ctx.h("simple header", linux_x64,
\\export fn start() void{}
,
\\ZIG_EXTERN_C void start(void);
\\
);
ctx.h("header with single param function", linux_x64,
\\export fn start(a: u8) void{}
,
\\ZIG_EXTERN_C void start(uint8_t a0);
\\
);
ctx.h("header with multiple param function", linux_x64,
\\export fn start(a: u8, b: u8, c: u8) void{}
,
\\ZIG_EXTERN_C void start(uint8_t a0, uint8_t a1, uint8_t a2);
\\
);
ctx.h("header with u32 param function", linux_x64,
\\export fn start(a: u32) void{}
,
\\ZIG_EXTERN_C void start(uint32_t a0);
\\
);
ctx.h("header with usize param function", linux_x64,
\\export fn start(a: usize) void{}
,
\\ZIG_EXTERN_C void start(uintptr_t a0);
\\
);
ctx.h("header with bool param function", linux_x64,
\\export fn start(a: bool) void{}
,
\\ZIG_EXTERN_C void start(bool a0);
\\
);
ctx.h("header with noreturn function", linux_x64,
\\export fn start() noreturn {
\\ unreachable;
\\}
,
\\ZIG_EXTERN_C zig_noreturn void start(void);
\\
);
ctx.h("header with multiple functions", linux_x64,
\\export fn a() void{}
\\export fn b() void{}
\\export fn c() void{}
,
\\ZIG_EXTERN_C void a(void);
\\ZIG_EXTERN_C void b(void);
\\ZIG_EXTERN_C void c(void);
\\
);
ctx.h("header with multiple includes", linux_x64,
\\export fn start(a: u32, b: usize) void{}
,
\\ZIG_EXTERN_C void start(uint32_t a0, uintptr_t a1);
\\
);
}
|
test/stage2/cbe.zig
|
const std = @import("std");
const string = []const u8;
const zigmod = @import("../lib.zig");
const u = @import("index.zig");
const yaml = @import("./yaml.zig");
//
//
const b = 1;
const kb = b * 1024;
const mb = kb * 1024;
pub const ModFile = struct {
const Self = @This();
id: string,
name: string,
main: string,
c_include_dirs: []const string,
c_source_flags: []const string,
c_source_files: []const string,
deps: []zigmod.Dep,
yaml: yaml.Mapping,
root_files: []const string,
files: []const string,
rootdeps: []zigmod.Dep,
builddeps: []zigmod.Dep,
min_zig_version: ?std.SemanticVersion,
vcpkg: bool,
pub fn openFile(dir: std.fs.Dir, ops: std.fs.File.OpenFlags) !std.fs.File {
return dir.openFile("zig.mod", ops) catch |err| switch (err) {
error.FileNotFound => dir.openFile("zigmod.yml", ops) catch |err2| switch (err2) {
error.FileNotFound => return error.ManifestNotFound,
else => |e2| return e2,
},
else => |e| return e,
};
}
pub fn init(alloc: std.mem.Allocator) !Self {
return try from_dir(alloc, std.fs.cwd());
}
pub fn from_dir(alloc: std.mem.Allocator, dir: std.fs.Dir) !Self {
const file = try openFile(dir, .{});
defer file.close();
const input = try file.reader().readAllAlloc(alloc, mb);
const doc = try yaml.parse(alloc, input);
return from_mapping(alloc, doc.mapping);
}
pub fn from_mapping(alloc: std.mem.Allocator, mapping: yaml.Mapping) !Self {
const id = mapping.get_string("id");
const name = mapping.get("name").?.string;
const main = mapping.get_string("main");
if (std.mem.indexOf(u8, name, "/")) |_| {
u.fail("name may not contain any '/'", .{});
}
return Self{
.id = if (id.len == 0) try u.random_string(alloc, 48) else id,
.name = name,
.main = main,
.c_include_dirs = try mapping.get_string_array(alloc, "c_include_dirs"),
.c_source_flags = try mapping.get_string_array(alloc, "c_source_flags"),
.c_source_files = try mapping.get_string_array(alloc, "c_source_files"),
.deps = try dep_list_by_name(alloc, mapping, &.{"dependencies"}, false),
.yaml = mapping,
.root_files = try mapping.get_string_array(alloc, "root_files"),
.files = try mapping.get_string_array(alloc, "files"),
.rootdeps = try dep_list_by_name(alloc, mapping, &.{ "dev_dependencies", "root_dependencies" }, false),
.builddeps = try dep_list_by_name(alloc, mapping, &.{ "dev_dependencies", "build_dependencies" }, true),
.min_zig_version = std.SemanticVersion.parse(mapping.get_string("min_zig_version")) catch null,
.vcpkg = std.mem.eql(u8, "true", mapping.get_string("vcpkg")),
};
}
fn dep_list_by_name(alloc: std.mem.Allocator, mapping: yaml.Mapping, props: []const string, for_build: bool) std.mem.Allocator.Error![]zigmod.Dep {
var dep_list = std.ArrayList(zigmod.Dep).init(alloc);
defer dep_list.deinit();
for (props) |prop| {
if (mapping.get(prop)) |dep_seq| {
if (dep_seq != .sequence) continue;
for (dep_seq.sequence) |item| {
var dtype: string = undefined;
var path: string = undefined;
var version: ?string = null;
var name = item.mapping.get_string("name");
var main = item.mapping.get_string("main");
if (item.mapping.get("src")) |val| {
var src_iter = std.mem.tokenize(u8, val.string, " ");
dtype = src_iter.next().?;
path = src_iter.next().?;
if (src_iter.next()) |dver| {
version = dver;
}
} else {
dtype = item.mapping.get("type").?.string;
path = item.mapping.get("path").?.string;
}
if (item.mapping.get("version")) |verv| {
version = verv.string;
}
if (version == null) {
version = "";
}
const dep_type = std.meta.stringToEnum(zigmod.DepType, dtype).?;
if (dep_type == .local) {
if (path.len > 0) {
name = path;
path = "";
}
if (version.?.len > 0) {
main = version.?;
version = "";
}
}
try dep_list.append(zigmod.Dep{
.alloc = alloc,
.type = dep_type,
.path = path,
.id = item.mapping.get_string("id"),
.name = name,
.main = main,
.version = version.?,
.c_include_dirs = try item.mapping.get_string_array(alloc, "c_include_dirs"),
.c_source_flags = try item.mapping.get_string_array(alloc, "c_source_flags"),
.c_source_files = try item.mapping.get_string_array(alloc, "c_source_files"),
.only_os = try u.list_remove(alloc, try u.split(alloc, item.mapping.get_string("only_os"), ","), ""),
.except_os = try u.list_remove(alloc, try u.split(alloc, item.mapping.get_string("except_os"), ","), ""),
.yaml = item.mapping,
.deps = try dep_list_by_name(alloc, item.mapping, &.{"dependencies"}, for_build),
.keep = std.mem.eql(u8, "true", item.mapping.get_string("keep")),
.vcpkg = std.mem.eql(u8, "true", item.mapping.get_string("vcpkg")),
.for_build = for_build,
});
}
}
}
return dep_list.toOwnedSlice();
}
};
|
src/util/modfile.zig
|
const std = @import("std");
const v8 = @import("v8.zig");
// Demo js repl.
pub fn main() !void {
repl();
std.process.exit(0);
}
fn repl() void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const alloc = gpa.allocator();
var input_buf = std.ArrayList(u8).init(alloc);
defer input_buf.deinit();
const platform = v8.Platform.initDefault(0, true);
defer platform.deinit();
v8.initV8Platform(platform);
defer v8.deinitV8Platform();
v8.initV8();
defer _ = v8.deinitV8();
var params = v8.initCreateParams();
params.array_buffer_allocator = v8.createDefaultArrayBufferAllocator();
defer v8.destroyArrayBufferAllocator(params.array_buffer_allocator.?);
var isolate = v8.Isolate.init(¶ms);
defer isolate.deinit();
isolate.enter();
defer isolate.exit();
var hscope: v8.HandleScope = undefined;
hscope.init(isolate);
defer hscope.deinit();
var context = v8.Context.init(isolate, null, null);
context.enter();
defer context.exit();
const origin = v8.String.initUtf8(isolate, "(shell)");
printFmt(
\\JS Repl
\\exit with Ctrl+D or "exit()"
\\
, .{});
while (true) {
printFmt("\n> ", .{});
if (getInput(&input_buf)) |input| {
if (std.mem.eql(u8, input, "exit()")) {
break;
}
var res: ExecuteResult = undefined;
defer res.deinit();
executeString(alloc, isolate, input, origin, &res);
if (res.success) {
printFmt("{s}", .{res.result.?});
} else {
printFmt("{s}", .{res.err.?});
}
while (platform.pumpMessageLoop(isolate, false)) {
continue;
}
} else {
printFmt("\n", .{});
return;
}
}
}
fn getInput(input_buf: *std.ArrayList(u8)) ?[]const u8 {
input_buf.clearRetainingCapacity();
std.io.getStdIn().reader().readUntilDelimiterArrayList(input_buf, '\n', 1e9) catch |err| {
if (err == error.EndOfStream) {
return null;
} else {
unreachable;
}
};
return input_buf.items;
}
pub fn printFmt(comptime format: []const u8, args: anytype) void {
const stdout = std.io.getStdOut().writer();
stdout.print(format, args) catch unreachable;
}
pub const ExecuteResult = struct {
const Self = @This();
alloc: std.mem.Allocator,
result: ?[]const u8,
err: ?[]const u8,
success: bool,
pub fn deinit(self: Self) void {
if (self.result) |result| {
self.alloc.free(result);
}
if (self.err) |err| {
self.alloc.free(err);
}
}
};
pub fn executeString(alloc: std.mem.Allocator, isolate: v8.Isolate, src: []const u8, src_origin: v8.String, result: *ExecuteResult) void {
var hscope: v8.HandleScope = undefined;
hscope.init(isolate);
defer hscope.deinit();
var try_catch: v8.TryCatch = undefined;
try_catch.init(isolate);
defer try_catch.deinit();
var origin = v8.ScriptOrigin.initDefault(isolate, src_origin.handle);
var context = isolate.getCurrentContext();
const js_src = v8.String.initUtf8(isolate, src);
if (v8.Script.compile(context, js_src, origin)) |script| {
if (script.run(context)) |script_res| {
result.* = .{
.alloc = alloc,
.result = valueToUtf8Alloc(alloc, isolate, context, script_res),
.err = null,
.success = true,
};
} else {
setResultError(alloc, isolate, try_catch, result);
}
} else {
setResultError(alloc, isolate, try_catch, result);
}
}
fn setResultError(alloc: std.mem.Allocator, isolate: v8.Isolate, try_catch: v8.TryCatch, result: *ExecuteResult) void {
result.* = .{
.alloc = alloc,
.result = null,
.err = getTryCatchErrorString(alloc, isolate, try_catch),
.success = false,
};
}
pub fn valueToUtf8Alloc(alloc: std.mem.Allocator, isolate: v8.Isolate, ctx: v8.Context, any_value: anytype) []const u8 {
const val = v8.getValue(any_value);
const str = val.toString(ctx);
const len = str.lenUtf8(isolate);
const buf = alloc.alloc(u8, len) catch unreachable;
_ = str.writeUtf8(isolate, buf);
return buf;
}
pub fn getTryCatchErrorString(alloc: std.mem.Allocator, isolate: v8.Isolate, try_catch: v8.TryCatch) []const u8 {
var hscope: v8.HandleScope = undefined;
hscope.init(isolate);
defer hscope.deinit();
const ctx = isolate.getCurrentContext();
if (try_catch.getMessage()) |message| {
var buf = std.ArrayList(u8).init(alloc);
const writer = buf.writer();
// Append source line.
const source_line = message.getSourceLine(ctx).?;
_ = appendValueAsUtf8(&buf, isolate, ctx, source_line);
writer.writeAll("\n") catch unreachable;
// Print wavy underline.
const col_start = message.getStartColumn();
const col_end = message.getEndColumn();
var i: u32 = 0;
while (i < col_start) : (i += 1) {
writer.writeByte(' ') catch unreachable;
}
while (i < col_end) : (i += 1) {
writer.writeByte('^') catch unreachable;
}
writer.writeByte('\n') catch unreachable;
if (try_catch.getStackTrace(ctx)) |trace| {
_ = appendValueAsUtf8(&buf, isolate, ctx, trace);
writer.writeByte('\n') catch unreachable;
}
return buf.toOwnedSlice();
} else {
// V8 didn't provide any extra information about this error, just get exception str.
const exception = try_catch.getException();
return valueToUtf8Alloc(alloc, isolate, ctx, exception);
}
}
pub fn appendValueAsUtf8(arr: *std.ArrayList(u8), isolate: v8.Isolate, ctx: v8.Context, any_value: anytype) []const u8 {
const val = v8.getValue(any_value);
const str = val.toString(ctx);
const len = str.lenUtf8(isolate);
const start = arr.items.len;
arr.resize(start + len) catch unreachable;
_ = str.writeUtf8(isolate, arr.items[start..arr.items.len]);
return arr.items[start..];
}
|
src/shell.zig
|
const std = @import("std");
const unistd = @cImport(@cInclude("unistd.h"));
fn matInit(alloc: *std.mem.Allocator, x: usize, y: usize) [][]f64 {
var mat: [][]f64 = alloc.alloc([]f64, x) catch unreachable;
for (mat) |*row| {
row.* = alloc.alloc(f64, y) catch unreachable;
std.mem.set(f64, row.*, 0.0);
}
return mat;
}
fn matGen(alloc: *std.mem.Allocator, n: usize, seed: f64) [][]f64 {
var mat: [][]f64 = matInit(alloc, n, n);
const tmp = seed / @intToFloat(f64, n) / @intToFloat(f64, n);
for (mat) |*row, i| {
for (row.*) |*x, j| {
x.* = tmp * (@intToFloat(f64, i) - @intToFloat(f64, j)) * (@intToFloat(f64, i) + @intToFloat(f64, j));
}
}
return mat;
}
fn matMul(alloc: *std.mem.Allocator, a: [][]f64, b: [][]f64) [][]f64 {
const m = a.len;
const n = a[0].len;
const p = b[0].len;
var b2: [][]f64 = matInit(alloc, n, p);
var i: usize = 0;
while (i < p) : (i += 1) {
var j: usize = 0;
while (j < n) : (j += 1) {
b2[i][j] = b[j][i];
}
}
var c: [][]f64 = matInit(alloc, m, p);
i = 0;
while (i < m) : (i += 1) {
var j: usize = 0;
while (j < p) : (j += 1) {
var s: f64 = 0.0;
var k: usize = 0;
while (k < n) : (k += 1) {
s += a[i][k] * b2[j][k];
}
c[i][j] = s;
}
}
return c;
}
fn notify(msg: []const u8) void {
const addr = std.net.Address.parseIp("127.0.0.1", 9001) catch unreachable;
var stream = std.net.tcpConnectToAddress(addr) catch unreachable;
_ = stream.write(msg) catch unreachable;
stream.close();
}
fn calc(alloc: *std.mem.Allocator, n: usize) f64 {
const size: usize = @divTrunc(n, 2) * @as(usize, 2);
const a = matGen(alloc, size, 1.0);
const b = matGen(alloc, size, 2.0);
const x = matMul(alloc, a, b);
const i = @intCast(usize, @divTrunc(size, 2));
return x[i][i];
}
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.c_allocator);
defer arena.deinit();
var alloc: *std.mem.Allocator = &arena.allocator;
var arg_iter = std.process.args();
_ = arg_iter.skip(); // Skip binary name
const arg = try arg_iter.next(alloc) orelse "";
const n = std.fmt.parseInt(usize, arg, 10) catch 100;
const left = calc(alloc, 101);
const right = -18.67;
if (std.math.absFloat(left - right) > 0.1) {
std.debug.panic("{d} != {d}\n", .{left, right});
}
const pid = unistd.getpid();
const pid_str = try std.fmt.allocPrint(alloc, "Zig\t{d}", .{pid});
notify(pid_str);
const result = calc(alloc, n);
notify("stop");
std.debug.print("{d}\n", .{result});
}
|
matmul/matmul.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/day11.txt");
//const data = "5483143223\n2745854711\n5264556173\n6141336146\n6357385478\n4167524645\n2176841721\n6882881134\n4846848554\n5283751526\n";
pub fn main() !void {
const input: [][]u8 = blk: {
var lines = std.ArrayList([]u8).init(gpa);
var iter = tokenize(u8, data, "\r\n");
while (iter.next()) |line| {
var cols = std.ArrayList(u8).init(gpa);
for (line) |c| {
const n = try parseInt(u8, &[1]u8{c}, 10);
try cols.append(n);
}
try lines.append(cols.toOwnedSlice());
}
break :blk lines.toOwnedSlice();
};
// Data structure to keep track of needed info
const Cell = struct {
value: u8,
flashed: bool,
};
// copy input into mutable array of cells
var array: [10][10]Cell = undefined;
for (input) |row, i| {
for (row) |cell, j| {
array[i][j] = Cell {
.value = cell,
.flashed = false,
};
}
}
var flash_count: usize = 0;
var step: usize = 1;
while (true) : (step += 1) {
// Add one to each input
for (array) |*row| {
for (row) |*cell| {
cell.value += 1;
}
}
// Flash every cell >9
var keep_flashing: bool = true;
while (keep_flashing) {
keep_flashing = false;
for (array) |*row, i| {
for (row) |*cell, j| {
if (cell.value > 9 and !cell.flashed) {
cell.value = 10; // limit cell size to prevent possible overflow
keep_flashing = true;
cell.flashed = true;
flash_count += 1;
// find index bounds
const up: usize = if (i==0) 0 else i-1;
const down: usize = if (i==9) 9 else i+1;
const left: usize = if (j==0) 0 else j-1;
const right: usize = if (j==9) 9 else j+1;
// add one to all cells within bounds
var ii: usize = up;
while (ii <= down) : (ii += 1) {
var jj: usize = left;
while (jj <= right) : (jj += 1) {
array[ii][jj].value += 1;
}
}
}
}
}
}
// Set all flashed cells back to zero
var all_cells_flash = true;
for (array) |*row| {
for (row) |*cell| {
if (cell.flashed) {
assert(cell.value > 9);
cell.value = 0;
cell.flashed = false;
} else {
all_cells_flash = false;
}
}
}
if (all_cells_flash) {
assert(step == 351);
print("{}\n", .{step});
break;
}
if (step == 100) {
assert(flash_count == 1669);
print("{}\n", .{flash_count});
}
}
}
// 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/day11.zig
|
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
const desc_usize = std.sort.desc(usize);
pub const Navigation = struct {
syntax_error_score: usize,
completion_scores: std.ArrayList(usize),
pub fn init() Navigation {
var self = Navigation{
.syntax_error_score = 0,
.completion_scores = std.ArrayList(usize).init(allocator),
};
return self;
}
pub fn deinit(self: *Navigation) void {
self.completion_scores.deinit();
}
pub fn process_line(self: *Navigation, data: []const u8) !void {
var stack: [1024]u8 = undefined;
var pos: usize = 0;
var score: usize = 0;
for (data) |c| {
if (c == '(' or c == '[' or c == '{' or c == '<') {
stack[pos] = c;
pos += 1;
continue;
}
if (c == ')' or c == ']' or c == '}' or c == '>') {
pos -= 1;
const p = stack[pos];
if (p == '(' and c == ')') continue;
if (p == '[' and c == ']') continue;
if (p == '{' and c == '}') continue;
if (p == '<' and c == '>') continue;
if (c == ')') score = 3;
if (c == ']') score = 57;
if (c == '}') score = 1197;
if (c == '>') score = 25137;
break;
}
unreachable;
}
if (score > 0) {
self.syntax_error_score += score;
return;
}
while (pos > 0) {
pos -= 1;
const p = stack[pos];
var s: usize = 0;
if (p == '(') s = 1;
if (p == '[') s = 2;
if (p == '{') s = 3;
if (p == '<') s = 4;
score = 5 * score + s;
}
try self.completion_scores.append(score);
}
pub fn get_syntax_error_score(self: Navigation) usize {
return self.syntax_error_score;
}
pub fn get_completion_middle_score(self: Navigation) usize {
const size = self.completion_scores.items.len;
if (size == 0) return 0;
std.sort.sort(usize, self.completion_scores.items, {}, desc_usize);
const middle = size / 2;
return self.completion_scores.items[middle];
}
};
test "sample part a" {
const data: []const u8 =
\\[({(<(())[]>[[{[]{<()<>>
\\[(()[<>])]({[<{<<[]>>(
\\{([(<{}[<>[]}>{[]{[(<()>
\\(((({<>}<{<{<>}{[]{[]{}
\\[[<[([]))<([[{}[[()]]]
\\[{[{({}]{}}([{[{{{}}([]
\\{<[[]]>}<{[{[{[]{()[[[]
\\[<(<(<(<{}))><([]([]()
\\<{([([[(<>()){}]>(<<{{
\\<{([{{}}[<[[[<>{}]]]>[]]
;
var navigation = Navigation.init();
defer navigation.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try navigation.process_line(line);
}
const syntax_error_score = navigation.get_syntax_error_score();
try testing.expect(syntax_error_score == 26397);
}
test "sample part b" {
const data: []const u8 =
\\[({(<(())[]>[[{[]{<()<>>
\\[(()[<>])]({[<{<<[]>>(
\\{([(<{}[<>[]}>{[]{[(<()>
\\(((({<>}<{<{<>}{[]{[]{}
\\[[<[([]))<([[{}[[()]]]
\\[{[{({}]{}}([{[{{{}}([]
\\{<[[]]>}<{[{[{[]{()[[[]
\\[<(<(<(<{}))><([]([]()
\\<{([([[(<>()){}]>(<<{{
\\<{([{{}}[<[[[<>{}]]]>[]]
;
var navigation = Navigation.init();
defer navigation.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try navigation.process_line(line);
}
const middle_score = navigation.get_completion_middle_score();
try testing.expect(middle_score == 288957);
}
|
2021/p10/navigation.zig
|
const builtin = @import("builtin");
const std = @import("std");
const mem = std.mem;
const print = std.debug.print;
const fs = std.fs;
const ChildProcess = std.ChildProcess;
const process = std.process;
const render_utils = @import("render_utils.zig");
/// This struct bundles all the options necessary to run a snippet of code.
/// `id` is used to differentiate between the different commands (e.g. build-exe, test).
pub const BuildCommand = struct {
format: Format,
name: ?[]const u8 = null,
is_inline: bool = false,
mode: builtin.Mode = .Debug,
link_objects: []const []const u8 = &[0][]u8{},
target_str: ?[]const u8 = null,
link_libc: bool = false,
disable_cache: bool = false, // TODO make sure it's used somewhere
tmp_dir_name: []const u8, // TODO, maybe this should be automated at a different level?
expected_outcome: union(enum) { SilentSuccess, Success, Failure: []const u8 } = .Success,
max_doc_file_size: usize = 1024 * 1024 * 1, // 1MB TODO: change?
pub const obj_ext = (std.zig.CrossTarget{}).oFileExt();
pub const Format = enum { exe, obj, lib };
};
fn dumpArgs(args: []const []const u8) void {
for (args) |arg|
print("{} ", .{arg})
else
print("\n", .{});
}
pub fn runBuild(
allocator: *mem.Allocator,
input_bytes: []const u8,
out: anytype,
env_map: *std.BufMap,
zig_exe: []const u8,
cmd: BuildCommand,
) !?[]const u8 {
const name = cmd.name orelse "test";
const zig_command = switch (cmd.format) {
.exe => "build-exe",
.obj => "build-obj",
.lib => "build-lib",
};
// Save the code as a temp .zig file and start preparing
// the argument list for the Zig compiler.
var build_args = std.ArrayList([]const u8).init(allocator);
defer build_args.deinit();
{
const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", .{name});
const tmp_source_file_name = try fs.path.join(
allocator,
&[_][]const u8{ cmd.tmp_dir_name, name_plus_ext },
);
try fs.cwd().writeFile(tmp_source_file_name, input_bytes);
try build_args.appendSlice(&[_][]const u8{
zig_exe, zig_command,
"--name", name,
"--color", "on",
"--enable-cache", tmp_source_file_name,
});
}
// Invocation line (continues into the following blocks)
try out.print("<pre><code class=\"shell\">$ zig {} {}.zig", .{ zig_command, name });
// Add release switches
switch (cmd.mode) {
.Debug => {},
else => {
try build_args.appendSlice(&[_][]const u8{ "-O", @tagName(cmd.mode) });
try out.print(" -O {s}", .{@tagName(cmd.mode)});
},
}
// Add link options
for (cmd.link_objects) |link_object| {
// TODO: we're setting the obj file extension before parsing
// the provided crosstarget string. Prob not ok.
const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ link_object, BuildCommand.obj_ext });
const full_path_object = try fs.path.join(
allocator,
&[_][]const u8{ cmd.tmp_dir_name, name_with_ext },
);
try build_args.append(full_path_object);
try out.print(" {s}", .{name_with_ext});
}
if (cmd.link_libc) {
try build_args.append("-lc");
try out.print(" -lc", .{});
}
// Add target options
// TODO: solve the target mistery and win one less symbol in the lexical scope!
const target = try std.zig.CrossTarget.parse(.{
.arch_os_abi = cmd.target_str orelse "native",
});
// TODO: is_inline is a switch that prevents the target option from being
// shown in the output. It seems a stylistical thing, do we keep it?
if (cmd.target_str) |triple| {
try build_args.appendSlice(&[_][]const u8{ "-target", triple });
if (!cmd.is_inline) {
try out.print(" -target {}", .{triple});
}
}
// Create a path for the resulting executable
const ext = switch (cmd.format) {
.exe => target.exeFileExt(),
.obj => target.dynamicLibSuffix(),
.lib => target.staticLibSuffix(), // TODO: I don't even know how this stupid naming scheme works, please somebody make this correct for me.
};
const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ name, ext });
const path_to_exe = try fs.path.join(allocator, &[_][]const u8{
cmd.tmp_dir_name,
name_with_ext,
});
try build_args.appendSlice(&[_][]const u8{
try std.fmt.allocPrint(allocator, "-femit-bin={}", .{path_to_exe}),
});
// Build the script
const result = try ChildProcess.exec(.{
.allocator = allocator,
.argv = build_args.items,
.env_map = env_map,
.max_output_bytes = cmd.max_doc_file_size,
});
// We check the output and confront it with the expected result.
switch (result.term) {
.Exited => |exit_code| {
if (exit_code == 0) { // build succeded
switch (cmd.expected_outcome) {
.SilentSuccess => {
return path_to_exe;
},
.Success => {
const escaped_stderr = try render_utils.escapeHtml(allocator, result.stderr);
const colored_stderr = try render_utils.termColor(allocator, escaped_stderr);
try out.print("\n{}</code></pre>\n", .{colored_stderr});
return null; // TODO: return values are confusing the way they are now.
},
.Failure => {
print("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
render_utils.dumpArgs(build_args.items);
return null;
},
}
} else { // build failed
switch (cmd.expected_outcome) {
.Success, .SilentSuccess => {
print("{}\nBuild failed unexpectedly\n", .{result.stderr});
render_utils.dumpArgs(build_args.items);
return null;
// return parseError(tokenizer, code.source_token, "example failed to compile", .{});
},
.Failure => {
const escaped_stderr = try render_utils.escapeHtml(allocator, result.stderr);
const colored_stderr = try render_utils.termColor(allocator, escaped_stderr);
try out.print("\n{}</code></pre>\n", .{colored_stderr});
return null;
},
}
}
},
else => {
print("{}\nThe following command crashed:\n", .{result.stderr});
render_utils.dumpArgs(build_args.items);
// return parseError(tokenizer, code.source_token, "example compile crashed", .{});
return error.BuildError;
},
}
}
|
src/doctest/build.zig
|
const std = @import("std");
const SYS = @import("./consts.zig").SYS;
inline fn syscall0(n: SYS) usize {
return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize),
: [n] "{r7}" (n),
: "memory", "cc"
);
}
inline fn syscall1(n: SYS, arg1: usize) usize {
return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize),
: [n] "{r7}" (n),
[arg1] "{r0}" (arg1),
: "memory", "cc"
);
}
inline fn syscall2(n: SYS, arg1: usize, arg2: usize) usize {
return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize),
: [n] "{r7}" (n),
[arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2),
: "memory", "cc"
);
}
inline fn syscall3(n: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize),
: [n] "{r7}" (n),
[arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3),
: "memory", "cc"
);
}
inline fn syscall4(n: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize),
: [n] "{r7}" (n),
[arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4),
: "memory", "cc"
);
}
inline fn syscall5(n: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize),
: [n] "{r7}" (n),
[arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4),
[arg5] "{r4}" (arg5),
: "memory", "cc"
);
}
inline fn syscall6(n: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize, arg6: usize) usize {
return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize),
: [n] "{r7}" (n),
[arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4),
[arg5] "{r4}" (arg5),
[arg6] "{r5}" (arg6),
: "memory", "cc"
);
}
pub inline fn syscall(n: SYS, args: anytype) usize {
const typ = @TypeOf(args);
comptime if (!std.meta.trait.isTuple(typ)) {
@compileError("syscall only accept tuple as argument");
};
const fun = comptime switch (args.len) {
0 => syscall0,
1 => syscall1,
2 => syscall2,
3 => syscall3,
4 => syscall4,
5 => syscall5,
6 => syscall6,
else => @compileError("Unsupported arguments length"),
};
const full_args = comptime .{n} ++ args;
return @call(.{}, fun, full_args);
}
|
src/linux/arm/calls.zig
|
const std = @import("std");
// const math = std.math;
const math = @import("lib.zig");
const expect = std.testing.expect;
/// Returns 2 raised to the power of x (2^x).
///
/// Special Cases:
/// - exp2(+inf) = +inf
/// - exp2(nan) = nan
pub fn exp2(x: anytype) @TypeOf(x) {
const T = @TypeOf(x);
return switch (T) {
f32 => exp2_32(x),
f64 => exp2_64(x),
f128 => exp2_128(x),
else => @compileError("exp2 not implemented for " ++ @typeName(T)),
};
}
const exp2_32_table = [_]f64{
0x1.6a09e667f3bcdp-1,
0x1.7a11473eb0187p-1,
0x1.8ace5422aa0dbp-1,
0x1.9c49182a3f090p-1,
0x1.ae89f995ad3adp-1,
0x1.c199bdd85529cp-1,
0x1.d5818dcfba487p-1,
0x1.ea4afa2a490dap-1,
0x1.0000000000000p+0,
0x1.0b5586cf9890fp+0,
0x1.172b83c7d517bp+0,
0x1.2387a6e756238p+0,
0x1.306fe0a31b715p+0,
0x1.3dea64c123422p+0,
0x1.4bfdad5362a27p+0,
0x1.5ab07dd485429p+0,
};
fn exp2_32(x: f32) f32 {
const tblsiz = @intCast(u32, exp2_32_table.len);
const redux: f32 = 0x1.8p23 / @intToFloat(f32, tblsiz);
const P1: f32 = 0x1.62e430p-1;
const P2: f32 = 0x1.ebfbe0p-3;
const P3: f32 = 0x1.c6b348p-5;
const P4: f32 = 0x1.3b2c9cp-7;
// Return canonical NaN for any NaN input.
if (math.isNan(x)) {
return math.nan(f32);
}
var u = @bitCast(u32, x);
const ix = u & 0x7FFFFFFF;
// |x| > 126
if (ix > 0x42FC0000) {
// nan
if (ix > 0x7F800000) {
return x;
}
// x >= 128
if (u >= 0x43000000 and u < 0x80000000) {
return x * 0x1.0p127;
}
// x < -126
if (u >= 0x80000000) {
if (u >= 0xC3160000 or u & 0x000FFFF != 0) {
math.doNotOptimizeAway(-0x1.0p-149 / x);
}
// x <= -150
if (u >= 0xC3160000) {
return 0;
}
}
}
// |x| <= 0x1p-25
else if (ix <= 0x33000000) {
return 1.0 + x;
}
// NOTE: musl relies on unsafe behaviours which are replicated below
// (addition/bit-shift overflow). Appears that this produces the
// intended result but should confirm how GCC/Clang handle this to ensure.
var uf = x + redux;
var i_0 = @bitCast(u32, uf);
i_0 +%= tblsiz / 2;
const k = i_0 / tblsiz;
const uk = @bitCast(f64, @as(u64, 0x3FF + k) << 52);
i_0 &= tblsiz - 1;
uf -= redux;
const z: f64 = x - uf;
var r: f64 = exp2_32_table[@intCast(usize, i_0)];
const t: f64 = r * z;
r = r + t * (P1 + z * P2) + t * (z * z) * (P3 + z * P4);
return @floatCast(f32, r * uk);
}
const exp2_64_table = [_]f64{
// exp2(z + eps) eps
0x1.6a09e667f3d5dp-1, 0x1.9880p-44,
0x1.6b052fa751744p-1, 0x1.8000p-50,
0x1.6c012750bd9fep-1, -0x1.8780p-45,
0x1.6cfdcddd476bfp-1, 0x1.ec00p-46,
0x1.6dfb23c651a29p-1, -0x1.8000p-50,
0x1.6ef9298593ae3p-1, -0x1.c000p-52,
0x1.6ff7df9519386p-1, -0x1.fd80p-45,
0x1.70f7466f42da3p-1, -0x1.c880p-45,
0x1.71f75e8ec5fc3p-1, 0x1.3c00p-46,
0x1.72f8286eacf05p-1, -0x1.8300p-44,
0x1.73f9a48a58152p-1, -0x1.0c00p-47,
0x1.74fbd35d7ccfcp-1, 0x1.f880p-45,
0x1.75feb564267f1p-1, 0x1.3e00p-47,
0x1.77024b1ab6d48p-1, -0x1.7d00p-45,
0x1.780694fde5d38p-1, -0x1.d000p-50,
0x1.790b938ac1d00p-1, 0x1.3000p-49,
0x1.7a11473eb0178p-1, -0x1.d000p-49,
0x1.7b17b0976d060p-1, 0x1.0400p-45,
0x1.7c1ed0130c133p-1, 0x1.0000p-53,
0x1.7d26a62ff8636p-1, -0x1.6900p-45,
0x1.7e2f336cf4e3bp-1, -0x1.2e00p-47,
0x1.7f3878491c3e8p-1, -0x1.4580p-45,
0x1.80427543e1b4ep-1, 0x1.3000p-44,
0x1.814d2add1071ap-1, 0x1.f000p-47,
0x1.82589994ccd7ep-1, -0x1.1c00p-45,
0x1.8364c1eb942d0p-1, 0x1.9d00p-45,
0x1.8471a4623cab5p-1, 0x1.7100p-43,
0x1.857f4179f5bbcp-1, 0x1.2600p-45,
0x1.868d99b4491afp-1, -0x1.2c40p-44,
0x1.879cad931a395p-1, -0x1.3000p-45,
0x1.88ac7d98a65b8p-1, -0x1.a800p-45,
0x1.89bd0a4785800p-1, -0x1.d000p-49,
0x1.8ace5422aa223p-1, 0x1.3280p-44,
0x1.8be05bad619fap-1, 0x1.2b40p-43,
0x1.8cf3216b54383p-1, -0x1.ed00p-45,
0x1.8e06a5e08664cp-1, -0x1.0500p-45,
0x1.8f1ae99157807p-1, 0x1.8280p-45,
0x1.902fed0282c0ep-1, -0x1.cb00p-46,
0x1.9145b0b91ff96p-1, -0x1.5e00p-47,
0x1.925c353aa2ff9p-1, 0x1.5400p-48,
0x1.93737b0cdc64ap-1, 0x1.7200p-46,
0x1.948b82b5f98aep-1, -0x1.9000p-47,
0x1.95a44cbc852cbp-1, 0x1.5680p-45,
0x1.96bdd9a766f21p-1, -0x1.6d00p-44,
0x1.97d829fde4e2ap-1, -0x1.1000p-47,
0x1.98f33e47a23a3p-1, 0x1.d000p-45,
0x1.9a0f170ca0604p-1, -0x1.8a40p-44,
0x1.9b2bb4d53ff89p-1, 0x1.55c0p-44,
0x1.9c49182a3f15bp-1, 0x1.6b80p-45,
0x1.9d674194bb8c5p-1, -0x1.c000p-49,
0x1.9e86319e3238ep-1, 0x1.7d00p-46,
0x1.9fa5e8d07f302p-1, 0x1.6400p-46,
0x1.a0c667b5de54dp-1, -0x1.5000p-48,
0x1.a1e7aed8eb8f6p-1, 0x1.9e00p-47,
0x1.a309bec4a2e27p-1, 0x1.ad80p-45,
0x1.a42c980460a5dp-1, -0x1.af00p-46,
0x1.a5503b23e259bp-1, 0x1.b600p-47,
0x1.a674a8af46213p-1, 0x1.8880p-44,
0x1.a799e1330b3a7p-1, 0x1.1200p-46,
0x1.a8bfe53c12e8dp-1, 0x1.6c00p-47,
0x1.a9e6b5579fcd2p-1, -0x1.9b80p-45,
0x1.ab0e521356fb8p-1, 0x1.b700p-45,
0x1.ac36bbfd3f381p-1, 0x1.9000p-50,
0x1.ad5ff3a3c2780p-1, 0x1.4000p-49,
0x1.ae89f995ad2a3p-1, -0x1.c900p-45,
0x1.afb4ce622f367p-1, 0x1.6500p-46,
0x1.b0e07298db790p-1, 0x1.fd40p-45,
0x1.b20ce6c9a89a9p-1, 0x1.2700p-46,
0x1.b33a2b84f1a4bp-1, 0x1.d470p-43,
0x1.b468415b747e7p-1, -0x1.8380p-44,
0x1.b59728de5593ap-1, 0x1.8000p-54,
0x1.b6c6e29f1c56ap-1, 0x1.ad00p-47,
0x1.b7f76f2fb5e50p-1, 0x1.e800p-50,
0x1.b928cf22749b2p-1, -0x1.4c00p-47,
0x1.ba5b030a10603p-1, -0x1.d700p-47,
0x1.bb8e0b79a6f66p-1, 0x1.d900p-47,
0x1.bcc1e904bc1ffp-1, 0x1.2a00p-47,
0x1.bdf69c3f3a16fp-1, -0x1.f780p-46,
0x1.bf2c25bd71db8p-1, -0x1.0a00p-46,
0x1.c06286141b2e9p-1, -0x1.1400p-46,
0x1.c199bdd8552e0p-1, 0x1.be00p-47,
0x1.c2d1cd9fa64eep-1, -0x1.9400p-47,
0x1.c40ab5fffd02fp-1, -0x1.ed00p-47,
0x1.c544778fafd15p-1, 0x1.9660p-44,
0x1.c67f12e57d0cbp-1, -0x1.a100p-46,
0x1.c7ba88988c1b6p-1, -0x1.8458p-42,
0x1.c8f6d9406e733p-1, -0x1.a480p-46,
0x1.ca3405751c4dfp-1, 0x1.b000p-51,
0x1.cb720dcef9094p-1, 0x1.1400p-47,
0x1.ccb0f2e6d1689p-1, 0x1.0200p-48,
0x1.cdf0b555dc412p-1, 0x1.3600p-48,
0x1.cf3155b5bab3bp-1, -0x1.6900p-47,
0x1.d072d4a0789bcp-1, 0x1.9a00p-47,
0x1.d1b532b08c8fap-1, -0x1.5e00p-46,
0x1.d2f87080d8a85p-1, 0x1.d280p-46,
0x1.d43c8eacaa203p-1, 0x1.1a00p-47,
0x1.d5818dcfba491p-1, 0x1.f000p-50,
0x1.d6c76e862e6a1p-1, -0x1.3a00p-47,
0x1.d80e316c9834ep-1, -0x1.cd80p-47,
0x1.d955d71ff6090p-1, 0x1.4c00p-48,
0x1.da9e603db32aep-1, 0x1.f900p-48,
0x1.dbe7cd63a8325p-1, 0x1.9800p-49,
0x1.dd321f301b445p-1, -0x1.5200p-48,
0x1.de7d5641c05bfp-1, -0x1.d700p-46,
0x1.dfc97337b9aecp-1, -0x1.6140p-46,
0x1.e11676b197d5ep-1, 0x1.b480p-47,
0x1.e264614f5a3e7p-1, 0x1.0ce0p-43,
0x1.e3b333b16ee5cp-1, 0x1.c680p-47,
0x1.e502ee78b3fb4p-1, -0x1.9300p-47,
0x1.e653924676d68p-1, -0x1.5000p-49,
0x1.e7a51fbc74c44p-1, -0x1.7f80p-47,
0x1.e8f7977cdb726p-1, -0x1.3700p-48,
0x1.ea4afa2a490e8p-1, 0x1.5d00p-49,
0x1.eb9f4867ccae4p-1, 0x1.61a0p-46,
0x1.ecf482d8e680dp-1, 0x1.5500p-48,
0x1.ee4aaa2188514p-1, 0x1.6400p-51,
0x1.efa1bee615a13p-1, -0x1.e800p-49,
0x1.f0f9c1cb64106p-1, -0x1.a880p-48,
0x1.f252b376bb963p-1, -0x1.c900p-45,
0x1.f3ac948dd7275p-1, 0x1.a000p-53,
0x1.f50765b6e4524p-1, -0x1.4f00p-48,
0x1.f6632798844fdp-1, 0x1.a800p-51,
0x1.f7bfdad9cbe38p-1, 0x1.abc0p-48,
0x1.f91d802243c82p-1, -0x1.4600p-50,
0x1.fa7c1819e908ep-1, -0x1.b0c0p-47,
0x1.fbdba3692d511p-1, -0x1.0e00p-51,
0x1.fd3c22b8f7194p-1, -0x1.0de8p-46,
0x1.fe9d96b2a23eep-1, 0x1.e430p-49,
0x1.0000000000000p+0, 0x0.0000p+0,
0x1.00b1afa5abcbep+0, -0x1.3400p-52,
0x1.0163da9fb3303p+0, -0x1.2170p-46,
0x1.02168143b0282p+0, 0x1.a400p-52,
0x1.02c9a3e77806cp+0, 0x1.f980p-49,
0x1.037d42e11bbcap+0, -0x1.7400p-51,
0x1.04315e86e7f89p+0, 0x1.8300p-50,
0x1.04e5f72f65467p+0, -0x1.a3f0p-46,
0x1.059b0d315855ap+0, -0x1.2840p-47,
0x1.0650a0e3c1f95p+0, 0x1.1600p-48,
0x1.0706b29ddf71ap+0, 0x1.5240p-46,
0x1.07bd42b72a82dp+0, -0x1.9a00p-49,
0x1.0874518759bd0p+0, 0x1.6400p-49,
0x1.092bdf66607c8p+0, -0x1.0780p-47,
0x1.09e3ecac6f383p+0, -0x1.8000p-54,
0x1.0a9c79b1f3930p+0, 0x1.fa00p-48,
0x1.0b5586cf988fcp+0, -0x1.ac80p-48,
0x1.0c0f145e46c8ap+0, 0x1.9c00p-50,
0x1.0cc922b724816p+0, 0x1.5200p-47,
0x1.0d83b23395dd8p+0, -0x1.ad00p-48,
0x1.0e3ec32d3d1f3p+0, 0x1.bac0p-46,
0x1.0efa55fdfa9a6p+0, -0x1.4e80p-47,
0x1.0fb66affed2f0p+0, -0x1.d300p-47,
0x1.1073028d7234bp+0, 0x1.1500p-48,
0x1.11301d0125b5bp+0, 0x1.c000p-49,
0x1.11edbab5e2af9p+0, 0x1.6bc0p-46,
0x1.12abdc06c31d5p+0, 0x1.8400p-49,
0x1.136a814f2047dp+0, -0x1.ed00p-47,
0x1.1429aaea92de9p+0, 0x1.8e00p-49,
0x1.14e95934f3138p+0, 0x1.b400p-49,
0x1.15a98c8a58e71p+0, 0x1.5300p-47,
0x1.166a45471c3dfp+0, 0x1.3380p-47,
0x1.172b83c7d5211p+0, 0x1.8d40p-45,
0x1.17ed48695bb9fp+0, -0x1.5d00p-47,
0x1.18af9388c8d93p+0, -0x1.c880p-46,
0x1.1972658375d66p+0, 0x1.1f00p-46,
0x1.1a35beb6fcba7p+0, 0x1.0480p-46,
0x1.1af99f81387e3p+0, -0x1.7390p-43,
0x1.1bbe084045d54p+0, 0x1.4e40p-45,
0x1.1c82f95281c43p+0, -0x1.a200p-47,
0x1.1d4873168b9b2p+0, 0x1.3800p-49,
0x1.1e0e75eb44031p+0, 0x1.ac00p-49,
0x1.1ed5022fcd938p+0, 0x1.1900p-47,
0x1.1f9c18438cdf7p+0, -0x1.b780p-46,
0x1.2063b88628d8fp+0, 0x1.d940p-45,
0x1.212be3578a81ep+0, 0x1.8000p-50,
0x1.21f49917ddd41p+0, 0x1.b340p-45,
0x1.22bdda2791323p+0, 0x1.9f80p-46,
0x1.2387a6e7561e7p+0, -0x1.9c80p-46,
0x1.2451ffb821427p+0, 0x1.2300p-47,
0x1.251ce4fb2a602p+0, -0x1.3480p-46,
0x1.25e85711eceb0p+0, 0x1.2700p-46,
0x1.26b4565e27d16p+0, 0x1.1d00p-46,
0x1.2780e341de00fp+0, 0x1.1ee0p-44,
0x1.284dfe1f5633ep+0, -0x1.4c00p-46,
0x1.291ba7591bb30p+0, -0x1.3d80p-46,
0x1.29e9df51fdf09p+0, 0x1.8b00p-47,
0x1.2ab8a66d10e9bp+0, -0x1.27c0p-45,
0x1.2b87fd0dada3ap+0, 0x1.a340p-45,
0x1.2c57e39771af9p+0, -0x1.0800p-46,
0x1.2d285a6e402d9p+0, -0x1.ed00p-47,
0x1.2df961f641579p+0, -0x1.4200p-48,
0x1.2ecafa93e2ecfp+0, -0x1.4980p-45,
0x1.2f9d24abd8822p+0, -0x1.6300p-46,
0x1.306fe0a31b625p+0, -0x1.2360p-44,
0x1.31432edeea50bp+0, -0x1.0df8p-40,
0x1.32170fc4cd7b8p+0, -0x1.2480p-45,
0x1.32eb83ba8e9a2p+0, -0x1.5980p-45,
0x1.33c08b2641766p+0, 0x1.ed00p-46,
0x1.3496266e3fa27p+0, -0x1.c000p-50,
0x1.356c55f929f0fp+0, -0x1.0d80p-44,
0x1.36431a2de88b9p+0, 0x1.2c80p-45,
0x1.371a7373aaa39p+0, 0x1.0600p-45,
0x1.37f26231e74fep+0, -0x1.6600p-46,
0x1.38cae6d05d838p+0, -0x1.ae00p-47,
0x1.39a401b713ec3p+0, -0x1.4720p-43,
0x1.3a7db34e5a020p+0, 0x1.8200p-47,
0x1.3b57fbfec6e95p+0, 0x1.e800p-44,
0x1.3c32dc313a8f2p+0, 0x1.f800p-49,
0x1.3d0e544ede122p+0, -0x1.7a00p-46,
0x1.3dea64c1234bbp+0, 0x1.6300p-45,
0x1.3ec70df1c4eccp+0, -0x1.8a60p-43,
0x1.3fa4504ac7e8cp+0, -0x1.cdc0p-44,
0x1.40822c367a0bbp+0, 0x1.5b80p-45,
0x1.4160a21f72e95p+0, 0x1.ec00p-46,
0x1.423fb27094646p+0, -0x1.3600p-46,
0x1.431f5d950a920p+0, 0x1.3980p-45,
0x1.43ffa3f84b9ebp+0, 0x1.a000p-48,
0x1.44e0860618919p+0, -0x1.6c00p-48,
0x1.45c2042a7d201p+0, -0x1.bc00p-47,
0x1.46a41ed1d0016p+0, -0x1.2800p-46,
0x1.4786d668b3326p+0, 0x1.0e00p-44,
0x1.486a2b5c13c00p+0, -0x1.d400p-45,
0x1.494e1e192af04p+0, 0x1.c200p-47,
0x1.4a32af0d7d372p+0, -0x1.e500p-46,
0x1.4b17dea6db801p+0, 0x1.7800p-47,
0x1.4bfdad53629e1p+0, -0x1.3800p-46,
0x1.4ce41b817c132p+0, 0x1.0800p-47,
0x1.4dcb299fddddbp+0, 0x1.c700p-45,
0x1.4eb2d81d8ab96p+0, -0x1.ce00p-46,
0x1.4f9b2769d2d02p+0, 0x1.9200p-46,
0x1.508417f4531c1p+0, -0x1.8c00p-47,
0x1.516daa2cf662ap+0, -0x1.a000p-48,
0x1.5257de83f51eap+0, 0x1.a080p-43,
0x1.5342b569d4edap+0, -0x1.6d80p-45,
0x1.542e2f4f6ac1ap+0, -0x1.2440p-44,
0x1.551a4ca5d94dbp+0, 0x1.83c0p-43,
0x1.56070dde9116bp+0, 0x1.4b00p-45,
0x1.56f4736b529dep+0, 0x1.15a0p-43,
0x1.57e27dbe2c40ep+0, -0x1.9e00p-45,
0x1.58d12d497c76fp+0, -0x1.3080p-45,
0x1.59c0827ff0b4cp+0, 0x1.dec0p-43,
0x1.5ab07dd485427p+0, -0x1.4000p-51,
0x1.5ba11fba87af4p+0, 0x1.0080p-44,
0x1.5c9268a59460bp+0, -0x1.6c80p-45,
0x1.5d84590998e3fp+0, 0x1.69a0p-43,
0x1.5e76f15ad20e1p+0, -0x1.b400p-46,
0x1.5f6a320dcebcap+0, 0x1.7700p-46,
0x1.605e1b976dcb8p+0, 0x1.6f80p-45,
0x1.6152ae6cdf715p+0, 0x1.1000p-47,
0x1.6247eb03a5531p+0, -0x1.5d00p-46,
0x1.633dd1d1929b5p+0, -0x1.2d00p-46,
0x1.6434634ccc313p+0, -0x1.a800p-49,
0x1.652b9febc8efap+0, -0x1.8600p-45,
0x1.6623882553397p+0, 0x1.1fe0p-40,
0x1.671c1c708328ep+0, -0x1.7200p-44,
0x1.68155d44ca97ep+0, 0x1.6800p-49,
0x1.690f4b19e9471p+0, -0x1.9780p-45,
};
fn exp2_64(x: f64) f64 {
const tblsiz: u32 = @intCast(u32, exp2_64_table.len / 2);
const redux: f64 = 0x1.8p52 / @intToFloat(f64, tblsiz);
const P1: f64 = 0x1.62e42fefa39efp-1;
const P2: f64 = 0x1.ebfbdff82c575p-3;
const P3: f64 = 0x1.c6b08d704a0a6p-5;
const P4: f64 = 0x1.3b2ab88f70400p-7;
const P5: f64 = 0x1.5d88003875c74p-10;
// Return canonical NaN for any NaN input.
if (math.isNan(x)) {
return math.nan(f64);
}
const ux = @bitCast(u64, x);
const ix = @intCast(u32, ux >> 32) & 0x7FFFFFFF;
// |x| >= 1022 or nan
if (ix >= 0x408FF000) {
// x >= 1024 or nan
if (ix >= 0x40900000 and ux >> 63 == 0) {
math.raiseOverflow();
return math.inf(f64);
}
// -inf or nan
if (ix >= 0x7FF00000) {
return -1 / x;
}
// x <= -1022
if (ux >> 63 != 0) {
// underflow
if (x <= -1075 or x - 0x1.0p52 + 0x1.0p52 != x) {
math.doNotOptimizeAway(@floatCast(f32, -0x1.0p-149 / x));
}
if (x <= -1075) {
return 0;
}
}
}
// |x| < 0x1p-54
else if (ix < 0x3C900000) {
return 1.0 + x;
}
// NOTE: musl relies on unsafe behaviours which are replicated below
// (addition overflow, division truncation, casting). Appears that this
// produces the intended result but should confirm how GCC/Clang handle this
// to ensure.
// reduce x
var uf: f64 = x + redux;
var i_0: u32 = @truncate(u32, @bitCast(u64, uf));
i_0 +%= tblsiz / 2;
const k: u32 = i_0 / tblsiz * tblsiz;
const ik: i32 = @divTrunc(@bitCast(i32, k), tblsiz);
i_0 %= tblsiz;
uf -= redux;
// r = exp2(y) = exp2t[i_0] * p(z - eps[i])
var z: f64 = x - uf;
const t: f64 = exp2_64_table[@intCast(usize, 2 * i_0)];
z -= exp2_64_table[@intCast(usize, 2 * i_0 + 1)];
const r: f64 = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * P5))));
return math.scalbn(r, ik);
}
const exp2_128_table = [_]f128{
0x1.6a09e667f3bcc908b2fb1366dfeap-1,
0x1.6c012750bdabeed76a99800f4edep-1,
0x1.6dfb23c651a2ef220e2cbe1bc0d4p-1,
0x1.6ff7df9519483cf87e1b4f3e1e98p-1,
0x1.71f75e8ec5f73dd2370f2ef0b148p-1,
0x1.73f9a48a58173bd5c9a4e68ab074p-1,
0x1.75feb564267c8bf6e9aa33a489a8p-1,
0x1.780694fde5d3f619ae02808592a4p-1,
0x1.7a11473eb0186d7d51023f6ccb1ap-1,
0x1.7c1ed0130c1327c49334459378dep-1,
0x1.7e2f336cf4e62105d02ba1579756p-1,
0x1.80427543e1a11b60de67649a3842p-1,
0x1.82589994cce128acf88afab34928p-1,
0x1.8471a4623c7acce52f6b97c6444cp-1,
0x1.868d99b4492ec80e41d90ac2556ap-1,
0x1.88ac7d98a669966530bcdf2d4cc0p-1,
0x1.8ace5422aa0db5ba7c55a192c648p-1,
0x1.8cf3216b5448bef2aa1cd161c57ap-1,
0x1.8f1ae991577362b982745c72eddap-1,
0x1.9145b0b91ffc588a61b469f6b6a0p-1,
0x1.93737b0cdc5e4f4501c3f2540ae8p-1,
0x1.95a44cbc8520ee9b483695a0e7fep-1,
0x1.97d829fde4e4f8b9e920f91e8eb6p-1,
0x1.9a0f170ca07b9ba3109b8c467844p-1,
0x1.9c49182a3f0901c7c46b071f28dep-1,
0x1.9e86319e323231824ca78e64c462p-1,
0x1.a0c667b5de564b29ada8b8cabbacp-1,
0x1.a309bec4a2d3358c171f770db1f4p-1,
0x1.a5503b23e255c8b424491caf88ccp-1,
0x1.a799e1330b3586f2dfb2b158f31ep-1,
0x1.a9e6b5579fdbf43eb243bdff53a2p-1,
0x1.ac36bbfd3f379c0db966a3126988p-1,
0x1.ae89f995ad3ad5e8734d17731c80p-1,
0x1.b0e07298db66590842acdfc6fb4ep-1,
0x1.b33a2b84f15faf6bfd0e7bd941b0p-1,
0x1.b59728de559398e3881111648738p-1,
0x1.b7f76f2fb5e46eaa7b081ab53ff6p-1,
0x1.ba5b030a10649840cb3c6af5b74cp-1,
0x1.bcc1e904bc1d2247ba0f45b3d06cp-1,
0x1.bf2c25bd71e088408d7025190cd0p-1,
0x1.c199bdd85529c2220cb12a0916bap-1,
0x1.c40ab5fffd07a6d14df820f17deap-1,
0x1.c67f12e57d14b4a2137fd20f2a26p-1,
0x1.c8f6d9406e7b511acbc48805c3f6p-1,
0x1.cb720dcef90691503cbd1e949d0ap-1,
0x1.cdf0b555dc3f9c44f8958fac4f12p-1,
0x1.d072d4a07897b8d0f22f21a13792p-1,
0x1.d2f87080d89f18ade123989ea50ep-1,
0x1.d5818dcfba48725da05aeb66dff8p-1,
0x1.d80e316c98397bb84f9d048807a0p-1,
0x1.da9e603db3285708c01a5b6d480cp-1,
0x1.dd321f301b4604b695de3c0630c0p-1,
0x1.dfc97337b9b5eb968cac39ed284cp-1,
0x1.e264614f5a128a12761fa17adc74p-1,
0x1.e502ee78b3ff6273d130153992d0p-1,
0x1.e7a51fbc74c834b548b2832378a4p-1,
0x1.ea4afa2a490d9858f73a18f5dab4p-1,
0x1.ecf482d8e67f08db0312fb949d50p-1,
0x1.efa1bee615a27771fd21a92dabb6p-1,
0x1.f252b376bba974e8696fc3638f24p-1,
0x1.f50765b6e4540674f84b762861a6p-1,
0x1.f7bfdad9cbe138913b4bfe72bd78p-1,
0x1.fa7c1819e90d82e90a7e74b26360p-1,
0x1.fd3c22b8f71f10975ba4b32bd006p-1,
0x1.0000000000000000000000000000p+0,
0x1.0163da9fb33356d84a66ae336e98p+0,
0x1.02c9a3e778060ee6f7caca4f7a18p+0,
0x1.04315e86e7f84bd738f9a20da442p+0,
0x1.059b0d31585743ae7c548eb68c6ap+0,
0x1.0706b29ddf6ddc6dc403a9d87b1ep+0,
0x1.0874518759bc808c35f25d942856p+0,
0x1.09e3ecac6f3834521e060c584d5cp+0,
0x1.0b5586cf9890f6298b92b7184200p+0,
0x1.0cc922b7247f7407b705b893dbdep+0,
0x1.0e3ec32d3d1a2020742e4f8af794p+0,
0x1.0fb66affed31af232091dd8a169ep+0,
0x1.11301d0125b50a4ebbf1aed9321cp+0,
0x1.12abdc06c31cbfb92bad324d6f84p+0,
0x1.1429aaea92ddfb34101943b2588ep+0,
0x1.15a98c8a58e512480d573dd562aep+0,
0x1.172b83c7d517adcdf7c8c50eb162p+0,
0x1.18af9388c8de9bbbf70b9a3c269cp+0,
0x1.1a35beb6fcb753cb698f692d2038p+0,
0x1.1bbe084045cd39ab1e72b442810ep+0,
0x1.1d4873168b9aa7805b8028990be8p+0,
0x1.1ed5022fcd91cb8819ff61121fbep+0,
0x1.2063b88628cd63b8eeb0295093f6p+0,
0x1.21f49917ddc962552fd29294bc20p+0,
0x1.2387a6e75623866c1fadb1c159c0p+0,
0x1.251ce4fb2a63f3582ab7de9e9562p+0,
0x1.26b4565e27cdd257a673281d3068p+0,
0x1.284dfe1f5638096cf15cf03c9fa0p+0,
0x1.29e9df51fdee12c25d15f5a25022p+0,
0x1.2b87fd0dad98ffddea46538fca24p+0,
0x1.2d285a6e4030b40091d536d0733ep+0,
0x1.2ecafa93e2f5611ca0f45d5239a4p+0,
0x1.306fe0a31b7152de8d5a463063bep+0,
0x1.32170fc4cd8313539cf1c3009330p+0,
0x1.33c08b26416ff4c9c8610d96680ep+0,
0x1.356c55f929ff0c94623476373be4p+0,
0x1.371a7373aa9caa7145502f45452ap+0,
0x1.38cae6d05d86585a9cb0d9bed530p+0,
0x1.3a7db34e59ff6ea1bc9299e0a1fep+0,
0x1.3c32dc313a8e484001f228b58cf0p+0,
0x1.3dea64c12342235b41223e13d7eep+0,
0x1.3fa4504ac801ba0bf701aa417b9cp+0,
0x1.4160a21f72e29f84325b8f3dbacap+0,
0x1.431f5d950a896dc704439410b628p+0,
0x1.44e086061892d03136f409df0724p+0,
0x1.46a41ed1d005772512f459229f0ap+0,
0x1.486a2b5c13cd013c1a3b69062f26p+0,
0x1.4a32af0d7d3de672d8bcf46f99b4p+0,
0x1.4bfdad5362a271d4397afec42e36p+0,
0x1.4dcb299fddd0d63b36ef1a9e19dep+0,
0x1.4f9b2769d2ca6ad33d8b69aa0b8cp+0,
0x1.516daa2cf6641c112f52c84d6066p+0,
0x1.5342b569d4f81df0a83c49d86bf4p+0,
0x1.551a4ca5d920ec52ec620243540cp+0,
0x1.56f4736b527da66ecb004764e61ep+0,
0x1.58d12d497c7fd252bc2b7343d554p+0,
0x1.5ab07dd48542958c93015191e9a8p+0,
0x1.5c9268a5946b701c4b1b81697ed4p+0,
0x1.5e76f15ad21486e9be4c20399d12p+0,
0x1.605e1b976dc08b076f592a487066p+0,
0x1.6247eb03a5584b1f0fa06fd2d9eap+0,
0x1.6434634ccc31fc76f8714c4ee122p+0,
0x1.66238825522249127d9e29b92ea2p+0,
0x1.68155d44ca973081c57227b9f69ep+0,
};
// Use a separate table since these values are only 32-bit floats.
const exp2_128_eps_table = [exp2_128_table.len]f32{
-0x1.5c50p-101,
-0x1.5d00p-106,
0x1.8e90p-102,
-0x1.5340p-103,
0x1.1bd0p-102,
-0x1.4600p-105,
-0x1.7a40p-104,
0x1.d590p-102,
-0x1.d590p-101,
0x1.b100p-103,
-0x1.0d80p-105,
0x1.6b00p-103,
-0x1.9f00p-105,
0x1.c400p-103,
0x1.e120p-103,
-0x1.c100p-104,
-0x1.9d20p-103,
0x1.a800p-108,
0x1.4c00p-106,
-0x1.9500p-106,
0x1.6900p-105,
-0x1.29d0p-100,
0x1.4c60p-103,
0x1.13a0p-102,
-0x1.5b60p-103,
-0x1.1c40p-103,
0x1.db80p-102,
0x1.91a0p-102,
0x1.dc00p-105,
0x1.44c0p-104,
0x1.9710p-102,
0x1.8760p-103,
-0x1.a720p-103,
0x1.ed20p-103,
-0x1.49c0p-102,
-0x1.e000p-111,
0x1.86a0p-103,
0x1.2b40p-103,
-0x1.b400p-108,
0x1.1280p-99,
-0x1.02d8p-102,
-0x1.e3d0p-103,
-0x1.b080p-105,
-0x1.f100p-107,
-0x1.16c0p-105,
-0x1.1190p-103,
-0x1.a7d2p-100,
0x1.3450p-103,
-0x1.67c0p-105,
0x1.4b80p-104,
-0x1.c4e0p-103,
0x1.6000p-108,
-0x1.3f60p-105,
0x1.93f0p-104,
0x1.5fe0p-105,
0x1.6f80p-107,
-0x1.7600p-106,
0x1.21e0p-106,
-0x1.3a40p-106,
-0x1.40c0p-104,
-0x1.9860p-105,
-0x1.5d40p-108,
-0x1.1d70p-106,
0x1.2760p-105,
0x0.0000p+0,
0x1.21e2p-104,
-0x1.9520p-108,
-0x1.5720p-106,
-0x1.4810p-106,
-0x1.be00p-109,
0x1.0080p-105,
-0x1.5780p-108,
-0x1.d460p-105,
-0x1.6140p-105,
0x1.4630p-104,
0x1.ad50p-103,
0x1.82e0p-105,
0x1.1d3cp-101,
0x1.6100p-107,
0x1.ec30p-104,
0x1.f200p-108,
0x1.0b40p-103,
0x1.3660p-102,
0x1.d9d0p-103,
-0x1.02d0p-102,
0x1.b070p-103,
0x1.b9c0p-104,
-0x1.01c0p-103,
-0x1.dfe0p-103,
0x1.1b60p-104,
-0x1.ae94p-101,
-0x1.3340p-104,
0x1.b3d8p-102,
-0x1.6e40p-105,
-0x1.3670p-103,
0x1.c140p-104,
0x1.1840p-101,
0x1.1ab0p-102,
-0x1.a400p-104,
0x1.1f00p-104,
-0x1.7180p-103,
0x1.4ce0p-102,
0x1.9200p-107,
-0x1.54c0p-103,
0x1.1b80p-105,
-0x1.1828p-101,
0x1.5720p-102,
-0x1.a060p-100,
0x1.9160p-102,
0x1.a280p-104,
0x1.3400p-107,
0x1.2b20p-102,
0x1.7800p-108,
0x1.cfd0p-101,
0x1.2ef0p-102,
-0x1.2760p-99,
0x1.b380p-104,
0x1.0048p-101,
-0x1.60b0p-102,
0x1.a1ccp-100,
-0x1.a640p-104,
-0x1.08a0p-101,
0x1.7e60p-102,
0x1.22c0p-103,
-0x1.7200p-106,
0x1.f0f0p-102,
0x1.eb4ep-99,
0x1.c6e0p-103,
};
fn exp2_128(x: f128) f128 {
const tblsiz: u32 = @intCast(u32, exp2_128_table.len);
const redux: f128 = 0x1.8p112 / @intToFloat(f128, tblsiz);
const P1: f128 = 0x1.62e42fefa39ef35793c7673007e6p-1;
const P2: f128 = 0x1.ebfbdff82c58ea86f16b06ec9736p-3;
const P3: f128 = 0x1.c6b08d704a0bf8b33a762bad3459p-5;
const P4: f128 = 0x1.3b2ab6fba4e7729ccbbe0b4f3fc2p-7;
const P5: f128 = 0x1.5d87fe78a67311071dee13fd11d9p-10;
const P6: f128 = 0x1.430912f86c7876f4b663b23c5fe5p-13;
const P7: f64 = 0x1.ffcbfc588b041p-17;
const P8: f64 = 0x1.62c0223a5c7c7p-20;
const P9: f64 = 0x1.b52541ff59713p-24;
const P10: f64 = 0x1.e4cf56a391e22p-28;
// Return canonical NaN for any NaN input.
if (math.isNan(x)) {
return math.nan(f128);
}
const ux = @bitCast(u128, x);
const e: u16 = @intCast(u16, ux >> 112) & 0x7FFF; // exponent
// |x| >= 16384 or nan
if (e >= 0x3FFF + 14) {
// x >= 16384
if (e >= 0x3FFF + 15 and ux >> 127 == 0) {
math.raiseOverflow();
return math.inf(f128);
}
// -inf or nan
if (e == 0x7FFF) {
return -1 / x;
}
// x <= -1022
if (x < -16382) {
// underflow
if (x <= -16495 or x - 0x1p112 + 0x1p112 != x) {
math.doNotOptimizeAway(@floatCast(f32, -0x1.0p-149 / x));
}
if (x <= -16495) {
return 0;
}
}
}
// |x| < 0x1p-114
else if (e < 0x3FFF - 114) {
return 1.0 + x;
}
// NOTE: musl relies on unsafe behaviours which are replicated below
// (addition overflow, division truncation, casting). Appears that this
// produces the intended result but should confirm how GCC/Clang handle this
// to ensure.
// reduce x
var u_f: f128 = x + redux;
var i_0: u32 = @truncate(u32, @bitCast(u128, u_f));
i_0 +%= tblsiz / 2;
const k_u: u32 = i_0 / tblsiz * tblsiz;
const k_i: i32 = @divTrunc(@bitCast(i32, k_u), tblsiz);
i_0 %= tblsiz;
u_f -= redux;
var z: f128 = x - u_f;
// r = exp2(y) = exp2t[i_0] * p(z - eps[i])
const t: f128 = exp2_128_table[@intCast(usize, i_0)];
z -= exp2_128_eps_table[@intCast(usize, i_0)];
// zig fmt: off
const r: f128 = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * (P5
+ z * (P6 + z * (P7 + z * (P8 + z * (P9 + z * P10)))))))));
// zig fmt: on
return math.scalbn(r, k_i);
}
test "math.exp2() delegation" {
try expect(exp2(@as(f32, 0.8923)) == exp2_32(0.8923));
try expect(exp2(@as(f64, 0.8923)) == exp2_64(0.8923));
try expect(exp2(@as(f128, 0.8923)) == exp2_128(0.8923));
}
test "math.exp2_32() basic" {
const epsilon = 0.000001;
try expect(exp2_32(0.0) == 1.0);
try expect(math.approxEqAbs(f32, exp2_32(0.2), 1.148698, epsilon));
try expect(math.approxEqAbs(f32, exp2_32(0.8923), 1.856133, epsilon));
try expect(math.approxEqAbs(f32, exp2_32(1.5), 2.828427, epsilon));
try expect(math.approxEqAbs(f32, exp2_32(37.45), 187747237888, epsilon));
try expect(math.approxEqAbs(f32, exp2_32(-1), 0.5, epsilon));
}
test "math.exp2_64() basic" {
const epsilon = 0.000001;
try expect(exp2_64(0.0) == 1.0);
try expect(math.approxEqAbs(f64, exp2_64(0.2), 1.148698, epsilon));
try expect(math.approxEqAbs(f64, exp2_64(0.8923), 1.856133, epsilon));
try expect(math.approxEqAbs(f64, exp2_64(1.5), 2.828427, epsilon));
try expect(math.approxEqAbs(f64, exp2_64(-1), 0.5, epsilon));
}
test "math.exp2_128() basic" {
const epsilon = 0.000001;
try expect(exp2_128(0.0) == 1.0);
try expect(math.approxEqAbs(f128, exp2_128(0.2), 1.148698, epsilon));
try expect(math.approxEqAbs(f128, exp2_128(0.8923), 1.856133, epsilon));
try expect(math.approxEqAbs(f128, exp2_128(1.5), 2.828427, epsilon));
try expect(math.approxEqAbs(f128, exp2_128(-1), 0.5, epsilon));
}
pub fn main() !void {
try @import("util.zig").singleInputFuncMain(exp2);
}
|
src/exp2.zig
|
const std = @import("std");
const tools = @import("tools");
const with_trace = false;
const assert = std.debug.assert;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
// horrible -> O(n3) + sloppy floats..
const map_width = 36;
const eps = 0.001;
const Map = [map_width * map_width]bool;
const Vec2 = struct {
x: f32,
y: f32,
};
fn length(d: Vec2) f32 {
return @sqrt(d.x * d.x + d.y * d.y);
}
fn dist(a: Vec2, b: Vec2) f32 {
return length(Vec2{ .x = a.x - b.x, .y = a.y - b.y });
}
fn is_visible(map: Map, eye: Vec2, target: Vec2) bool {
const d = Vec2{ .x = target.x - eye.x, .y = target.y - eye.y };
const l = length(d);
if (l < eps)
return false;
const v = Vec2{ .x = d.x / l, .y = d.y / l };
for (map) |has_asteroid, i| {
if (!has_asteroid) continue;
const x = i % map_width;
const y = i / map_width;
const p = Vec2{ .x = @intToFloat(f32, x) - eye.x, .y = @intToFloat(f32, y) - eye.y };
const s = v.x * p.x + v.y * p.y;
if (s < eps or s > l - eps)
continue;
const proj = Vec2{ .x = s * v.x, .y = s * v.y };
if (dist(p, proj) < eps)
return false;
}
return true;
}
fn mod2pi(a0: f32) f32 {
var a = a0;
while (a < 0) {
a += std.math.pi * 2.0;
}
while (a > std.math.pi * 2.0) {
a -= std.math.pi * 2.0;
}
return a;
}
fn angle(v: Vec2) f32 {
return mod2pi(-std.math.atan2(f32, v.x, v.y));
}
fn next_to_destroy(map: Map, eye: Vec2, prev_target: Vec2) ?struct {
x: u32,
y: u32,
} {
const d = Vec2{ .x = prev_target.x - eye.x, .y = prev_target.y - eye.y };
const angleref = angle(d);
var bestangle: f32 = 7;
var bestx: u32 = undefined;
var besty: u32 = undefined;
for (map) |has_asteroid, i| {
if (!has_asteroid) continue;
const x = i % map_width;
const y = i / map_width;
if (!is_visible(map, eye, Vec2{ .x = @intToFloat(f32, x), .y = @intToFloat(f32, y) }))
continue;
const p = Vec2{ .x = @intToFloat(f32, x) - eye.x, .y = @intToFloat(f32, y) - eye.y };
const a = angle(p);
if (mod2pi(a - angleref) > 0 and mod2pi(a - angleref) < bestangle) {
bestangle = mod2pi(a - angleref);
bestx = @intCast(u32, x);
besty = @intCast(u32, y);
}
}
return if (bestangle < 6.5) .{ .x = bestx, .y = besty } else null;
}
pub fn run(input: []const u8, allocator: std.mem.Allocator) ![2][]const u8 {
var map: Map = undefined;
{
var i: u32 = 0;
for (input) |c| {
if (c != '.' and c != '#')
continue;
map[i] = (c == '#');
i += 1;
}
}
var best: u32 = 0;
var besteye: Vec2 = undefined;
for (map) |has_asteroid0, i| {
if (!has_asteroid0) continue;
const x0 = i % map_width;
const y0 = i / map_width;
const eye = Vec2{ .x = @intToFloat(f32, x0), .y = @intToFloat(f32, y0) };
var counter: u32 = 0;
for (map) |has_asteroid1, j| {
if (!has_asteroid1) continue;
const x1 = j % map_width;
const y1 = j / map_width;
if (x1 == x0 and y1 == y0)
continue;
const tgt = Vec2{ .x = @intToFloat(f32, x1), .y = @intToFloat(f32, y1) };
if (is_visible(map, eye, tgt)) {
// trace("can see {},{}\n", .{ x1, y1});
counter += 1;
}
}
if (counter > best) {
best = counter;
besteye = eye;
trace("new best {} @ {},{}\n", .{ counter, x0, y0 });
}
}
const asteroid200 = ans: {
var ord: u32 = 1;
var prev = Vec2{ .x = besteye.x - eps, .y = -10 };
while (next_to_destroy(map, besteye, prev)) |target| {
trace("shootn°{} {}\n", .{ ord, target });
assert(map[target.x + map_width * target.y]);
map[target.x + map_width * target.y] = false;
prev = Vec2{ .x = @intToFloat(f32, target.x), .y = @intToFloat(f32, target.y) };
if (ord == 200)
break :ans (target.x * 100 + target.y);
ord += 1;
} else {
unreachable;
}
};
return [_][]const u8{
try std.fmt.allocPrint(allocator, "{}", .{best}),
try std.fmt.allocPrint(allocator, "{}", .{asteroid200}),
};
}
pub const main = tools.defaultMain("2019/day10.txt", run);
|
2019/day10a.zig
|
const std = @import("std");
const hash_map = std.hash_map;
const testing = std.testing;
const math = std.math;
/// A comptime hashmap constructed with automatically selected hash and eql functions.
pub fn AutoComptimeHashMap(comptime K: type, comptime V: type, comptime values: anytype) type {
return ComptimeHashMap(K, V, hash_map.getAutoHashFn(K), hash_map.getAutoEqlFn(K), values);
}
/// Builtin hashmap for strings as keys.
pub fn ComptimeStringHashMap(comptime V: type, comptime values: anytype) type {
return ComptimeHashMap([]const u8, V, hash_map.hashString, hash_map.eqlString, values);
}
/// A hashmap which is constructed at compile time from constant values.
/// Intended to be used as a faster lookup table.
pub fn ComptimeHashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u64, comptime eql: fn (a: K, b: K) bool, comptime values: anytype) type {
std.debug.assert(values.len != 0);
@setEvalBranchQuota(1000 * values.len);
const Entry = struct {
distance_from_start_index: usize = 0,
key: K = undefined,
val: V = undefined,
used: bool = false,
};
// ensure that the hash map will be at most 60% full
const size = math.ceilPowerOfTwo(usize, values.len * 5 / 3) catch unreachable;
var slots_wip = [1]Entry{.{}} ** size;
var max_distance_from_start_index_wip = 0;
slot_loop: for (values) |kv| {
var key: K = kv.@"0";
var value: V = kv.@"1";
const start_index = @as(usize, hash(key)) & (size - 1);
var roll_over = 0;
var distance_from_start_index = 0;
while (roll_over < size) : ({
roll_over += 1;
distance_from_start_index += 1;
}) {
const index = (start_index + roll_over) & (size - 1);
const entry = &slots_wip[index];
if (entry.used and !eql(entry.key, key)) {
if (entry.distance_from_start_index < distance_from_start_index) {
// robin hood to the rescue
const tmp = slots_wip[index];
max_distance_from_start_index_wip = math.max(max_distance_from_start_index_wip, distance_from_start_index);
entry.* = .{
.used = true,
.distance_from_start_index = distance_from_start_index,
.key = key,
.val = value,
};
key = tmp.key;
value = tmp.val;
distance_from_start_index = tmp.distance_from_start_index;
}
continue;
}
max_distance_from_start_index_wip = math.max(distance_from_start_index, max_distance_from_start_index_wip);
entry.* = .{
.used = true,
.distance_from_start_index = distance_from_start_index,
.key = key,
.val = value,
};
continue :slot_loop;
}
unreachable; // put into a full map
}
// Constify so compiler is happy mutable values are not spanning a namespace boundary
const max_distance_from_start_index = max_distance_from_start_index_wip;
const slots = slots_wip;
return struct {
const entries = slots;
pub fn has(key: K) bool {
return get(key) != null;
}
pub fn get(key: K) ?*const V {
const start_index = @as(usize, hash(key)) & (size - 1);
{
var roll_over: usize = 0;
while (roll_over <= max_distance_from_start_index) : (roll_over += 1) {
const index = (start_index + roll_over) & (size - 1);
const entry = &entries[index];
if (!entry.used) return null;
if (eql(entry.key, key)) return &entry.val;
}
}
return null;
}
};
}
test "basic usage" {
const map = ComptimeStringHashMap(usize, .{
.{ "foo", 1 },
.{ "bar", 2 },
.{ "baz", 3 },
.{ "quux", 4 },
});
testing.expect(map.has("foo"));
testing.expect(map.has("bar"));
testing.expect(!map.has("zig"));
testing.expect(!map.has("ziguana"));
testing.expect(map.get("baz").?.* == 3);
testing.expect(map.get("quux").?.* == 4);
testing.expect(map.get("nah") == null);
testing.expect(map.get("...") == null);
}
test "auto comptime hash map" {
const map = AutoComptimeHashMap(usize, []const u8, .{
.{ 1, "foo" },
.{ 2, "bar" },
.{ 3, "baz" },
.{ 45, "quux" },
});
testing.expect(map.has(1));
testing.expect(map.has(2));
testing.expect(!map.has(4));
testing.expect(!map.has(1_000_000));
testing.expectEqualStrings("foo", map.get(1).?.*);
testing.expectEqualStrings("bar", map.get(2).?.*);
testing.expect(map.get(4) == null);
testing.expect(map.get(4_000_000) == null);
}
|
comptime_hash_map.zig
|
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const testing = std.testing;
const os = std.os;
const Target = std.Target;
/// Detect macOS version.
/// `target_os` is not modified in case of error.
pub fn detect(target_os: *Target.Os) !void {
// Drop use of osproductversion sysctl because:
// 1. only available 10.13.4 High Sierra and later
// 2. when used from a binary built against < SDK 11.0 it returns 10.16 and masks Big Sur 11.x version
//
// NEW APPROACH, STEP 1, parse file:
//
// /System/Library/CoreServices/SystemVersion.plist
//
// NOTE: Historically `SystemVersion.plist` first appeared circa '2003
// with the release of Mac OS X 10.3.0 Panther.
//
// and if it contains a `10.16` value where the `16` is `>= 16` then it is non-canonical,
// discarded, and we move on to next step. Otherwise we accept the version.
//
// BACKGROUND: `10.(16+)` is not a proper version and does not have enough fidelity to
// indicate minor/point version of Big Sur and later. It is a context-sensitive result
// issued by the kernel for backwards compatibility purposes. Likely the kernel checks
// if the executable was linked against an SDK older than Big Sur.
//
// STEP 2, parse next file:
//
// /System/Library/CoreServices/.SystemVersionPlatform.plist
//
// NOTE: Historically `SystemVersionPlatform.plist` first appeared circa '2020
// with the release of macOS 11.0 Big Sur.
//
// Accessing the content via this path circumvents a context-sensitive result and
// yields a canonical Big Sur version.
//
// At this time there is no other known way for a < SDK 11.0 executable to obtain a
// canonical Big Sur version.
//
// This implementation uses a reasonably simplified approach to parse .plist file
// that while it is an xml document, we have good history on the file and its format
// such that I am comfortable with implementing a minimalistic parser.
// Things like string and general escapes are not supported.
const prefixSlash = "/System/Library/CoreServices/";
const paths = [_][]const u8{
prefixSlash ++ "SystemVersion.plist",
prefixSlash ++ ".SystemVersionPlatform.plist",
};
for (paths) |path| {
// approx. 4 times historical file size
var buf: [2048]u8 = undefined;
if (std.fs.cwd().readFile(path, &buf)) |bytes| {
if (parseSystemVersion(bytes)) |ver| {
// never return non-canonical `10.(16+)`
if (!(ver.major == 10 and ver.minor >= 16)) {
target_os.version_range.semver.min = ver;
target_os.version_range.semver.max = ver;
return;
}
continue;
} else |err| {
return error.OSVersionDetectionFail;
}
} else |err| {
return error.OSVersionDetectionFail;
}
}
return error.OSVersionDetectionFail;
}
fn parseSystemVersion(buf: []const u8) !std.builtin.Version {
var svt = SystemVersionTokenizer{ .bytes = buf };
try svt.skipUntilTag(.start, "dict");
while (true) {
try svt.skipUntilTag(.start, "key");
const content = try svt.expectContent();
try svt.skipUntilTag(.end, "key");
if (std.mem.eql(u8, content, "ProductVersion")) break;
}
try svt.skipUntilTag(.start, "string");
const ver = try svt.expectContent();
try svt.skipUntilTag(.end, "string");
return std.builtin.Version.parse(ver);
}
const SystemVersionTokenizer = struct {
bytes: []const u8,
index: usize = 0,
state: State = .begin,
fn next(self: *@This()) !?Token {
var mark: usize = self.index;
var tag = Tag{};
var content: []const u8 = "";
while (self.index < self.bytes.len) {
const char = self.bytes[self.index];
switch (self.state) {
.begin => switch (char) {
'<' => {
self.state = .tag0;
self.index += 1;
tag = Tag{};
mark = self.index;
},
'>' => {
return error.BadToken;
},
else => {
self.state = .content;
content = "";
mark = self.index;
},
},
.tag0 => switch (char) {
'<' => {
return error.BadToken;
},
'>' => {
self.state = .begin;
self.index += 1;
tag.name = self.bytes[mark..self.index];
return Token{ .tag = tag };
},
'"' => {
self.state = .tag_string;
self.index += 1;
},
'/' => {
self.state = .tag0_end_or_empty;
self.index += 1;
},
'A'...'Z', 'a'...'z' => {
self.state = .tagN;
tag.kind = .start;
self.index += 1;
},
else => {
self.state = .tagN;
self.index += 1;
},
},
.tag0_end_or_empty => switch (char) {
'<' => {
return error.BadToken;
},
'>' => {
self.state = .begin;
tag.kind = .empty;
tag.name = self.bytes[self.index..self.index];
self.index += 1;
return Token{ .tag = tag };
},
else => {
self.state = .tagN;
tag.kind = .end;
mark = self.index;
self.index += 1;
},
},
.tagN => switch (char) {
'<' => {
return error.BadToken;
},
'>' => {
self.state = .begin;
tag.name = self.bytes[mark..self.index];
self.index += 1;
return Token{ .tag = tag };
},
'"' => {
self.state = .tag_string;
self.index += 1;
},
'/' => {
self.state = .tagN_end;
tag.kind = .end;
self.index += 1;
},
else => {
self.index += 1;
},
},
.tagN_end => switch (char) {
'>' => {
self.state = .begin;
tag.name = self.bytes[mark..self.index];
self.index += 1;
return Token{ .tag = tag };
},
else => {
return error.BadToken;
},
},
.tag_string => switch (char) {
'"' => {
self.state = .tagN;
self.index += 1;
},
else => {
self.index += 1;
},
},
.content => switch (char) {
'<' => {
self.state = .tag0;
content = self.bytes[mark..self.index];
self.index += 1;
tag = Tag{};
mark = self.index;
return Token{ .content = content };
},
'>' => {
return error.BadToken;
},
else => {
self.index += 1;
},
},
}
}
return null;
}
fn expectContent(self: *@This()) ![]const u8 {
if (try self.next()) |tok| {
switch (tok) {
.content => |content| {
return content;
},
else => {},
}
}
return error.UnexpectedToken;
}
fn skipUntilTag(self: *@This(), kind: Tag.Kind, name: []const u8) !void {
while (try self.next()) |tok| {
switch (tok) {
.tag => |tag| {
if (tag.kind == kind and std.mem.eql(u8, tag.name, name)) return;
},
else => {},
}
}
return error.TagNotFound;
}
const State = enum {
begin,
tag0,
tag0_end_or_empty,
tagN,
tagN_end,
tag_string,
content,
};
const Token = union(enum) {
tag: Tag,
content: []const u8,
};
const Tag = struct {
kind: Kind = .unknown,
name: []const u8 = "",
const Kind = enum { unknown, start, end, empty };
};
};
test "detect" {
const cases = .{
.{
\\<?xml version="1.0" encoding="UTF-8"?>
\\<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
\\<plist version="1.0">
\\<dict>
\\ <key>ProductBuildVersion</key>
\\ <string>7B85</string>
\\ <key>ProductCopyright</key>
\\ <string>Apple Computer, Inc. 1983-2003</string>
\\ <key>ProductName</key>
\\ <string>Mac OS X</string>
\\ <key>ProductUserVisibleVersion</key>
\\ <string>10.3</string>
\\ <key>ProductVersion</key>
\\ <string>10.3</string>
\\</dict>
\\</plist>
,
.{ .major = 10, .minor = 3 },
},
.{
\\<?xml version="1.0" encoding="UTF-8"?>
\\<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
\\<plist version="1.0">
\\<dict>
\\ <key>ProductBuildVersion</key>
\\ <string>7W98</string>
\\ <key>ProductCopyright</key>
\\ <string>Apple Computer, Inc. 1983-2004</string>
\\ <key>ProductName</key>
\\ <string>Mac OS X</string>
\\ <key>ProductUserVisibleVersion</key>
\\ <string>10.3.9</string>
\\ <key>ProductVersion</key>
\\ <string>10.3.9</string>
\\</dict>
\\</plist>
,
.{ .major = 10, .minor = 3, .patch = 9 },
},
.{
\\<?xml version="1.0" encoding="UTF-8"?>
\\<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
\\<plist version="1.0">
\\<dict>
\\ <key>ProductBuildVersion</key>
\\ <string>19G68</string>
\\ <key>ProductCopyright</key>
\\ <string>1983-2020 Apple Inc.</string>
\\ <key>ProductName</key>
\\ <string>Mac OS X</string>
\\ <key>ProductUserVisibleVersion</key>
\\ <string>10.15.6</string>
\\ <key>ProductVersion</key>
\\ <string>10.15.6</string>
\\ <key>iOSSupportVersion</key>
\\ <string>13.6</string>
\\</dict>
\\</plist>
,
.{ .major = 10, .minor = 15, .patch = 6 },
},
.{
\\<?xml version="1.0" encoding="UTF-8"?>
\\<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
\\<plist version="1.0">
\\<dict>
\\ <key>ProductBuildVersion</key>
\\ <string>20A2408</string>
\\ <key>ProductCopyright</key>
\\ <string>1983-2020 Apple Inc.</string>
\\ <key>ProductName</key>
\\ <string>macOS</string>
\\ <key>ProductUserVisibleVersion</key>
\\ <string>11.0</string>
\\ <key>ProductVersion</key>
\\ <string>11.0</string>
\\ <key>iOSSupportVersion</key>
\\ <string>14.2</string>
\\</dict>
\\</plist>
,
.{ .major = 11, .minor = 0 },
},
.{
\\<?xml version="1.0" encoding="UTF-8"?>
\\<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
\\<plist version="1.0">
\\<dict>
\\ <key>ProductBuildVersion</key>
\\ <string>20C63</string>
\\ <key>ProductCopyright</key>
\\ <string>1983-2020 Apple Inc.</string>
\\ <key>ProductName</key>
\\ <string>macOS</string>
\\ <key>ProductUserVisibleVersion</key>
\\ <string>11.1</string>
\\ <key>ProductVersion</key>
\\ <string>11.1</string>
\\ <key>iOSSupportVersion</key>
\\ <string>14.3</string>
\\</dict>
\\</plist>
,
.{ .major = 11, .minor = 1 },
},
};
inline for (cases) |case| {
const ver0 = try parseSystemVersion(case[0]);
const ver1: std.builtin.Version = case[1];
try testVersionEquality(ver1, ver0);
}
}
fn testVersionEquality(expected: std.builtin.Version, got: std.builtin.Version) !void {
var b_expected: [64]u8 = undefined;
const s_expected: []const u8 = try std.fmt.bufPrint(b_expected[0..], "{}", .{expected});
var b_got: [64]u8 = undefined;
const s_got: []const u8 = try std.fmt.bufPrint(b_got[0..], "{}", .{got});
try testing.expectEqualStrings(s_expected, s_got);
}
/// Detect SDK path on Darwin.
/// Calls `xcrun --show-sdk-path` which result can be used to specify
/// `-syslibroot` param of the linker.
/// The caller needs to free the resulting path slice.
pub fn getSDKPath(allocator: *mem.Allocator) ![]u8 {
assert(Target.current.isDarwin());
const argv = &[_][]const u8{ "xcrun", "--show-sdk-path" };
const result = try std.ChildProcess.exec(.{ .allocator = allocator, .argv = argv });
defer {
allocator.free(result.stderr);
allocator.free(result.stdout);
}
if (result.stderr.len != 0) {
std.log.err("unexpected 'xcrun --show-sdk-path' stderr: {s}", .{result.stderr});
}
if (result.term.Exited != 0) {
return error.ProcessTerminated;
}
const syslibroot = mem.trimRight(u8, result.stdout, "\r\n");
return mem.dupe(allocator, u8, syslibroot);
}
pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
var cpu_family: os.CPUFAMILY = undefined;
var len: usize = @sizeOf(os.CPUFAMILY);
os.sysctlbynameZ("hw.cpufamily", &cpu_family, &len, null, 0) catch |err| switch (err) {
error.NameTooLong => unreachable, // constant, known good value
error.PermissionDenied => unreachable, // only when setting values,
error.SystemResources => unreachable, // memory already on the stack
error.UnknownName => unreachable, // constant, known good value
error.Unexpected => unreachable, // EFAULT: stack should be safe, EISDIR/ENOTDIR: constant, known good value
};
const current_arch = Target.current.cpu.arch;
switch (current_arch) {
.aarch64, .aarch64_be, .aarch64_32 => {
const model = switch (cpu_family) {
.ARM_FIRESTORM_ICESTORM => &Target.aarch64.cpu.apple_a14,
.ARM_LIGHTNING_THUNDER => &Target.aarch64.cpu.apple_a13,
.ARM_VORTEX_TEMPEST => &Target.aarch64.cpu.apple_a12,
.ARM_MONSOON_MISTRAL => &Target.aarch64.cpu.apple_a11,
.ARM_HURRICANE => &Target.aarch64.cpu.apple_a10,
.ARM_TWISTER => &Target.aarch64.cpu.apple_a9,
.ARM_TYPHOON => &Target.aarch64.cpu.apple_a8,
.ARM_CYCLONE => &Target.aarch64.cpu.cyclone,
else => return null,
};
return Target.Cpu{
.arch = current_arch,
.model = model,
.features = model.features,
};
},
else => {},
}
return null;
}
|
lib/std/zig/system/macos.zig
|