code
stringlengths 38
801k
| repo_path
stringlengths 6
263
|
|---|---|
const print = @import("std").debug.print;
// Let's define three structs: Duck, RubberDuck, and Duct. Notice
// that Duck and RubberDuck both contain waddle() and quack()
// methods declared in their namespace (also known as "decls").
const Duck = struct {
eggs: u8,
loudness: u8,
location_x: i32 = 0,
location_y: i32 = 0,
fn waddle(self: Duck, x: i16, y: i16) void {
self.location_x += x;
self.location_y += y;
}
fn quack(self: Duck) void {
if (self.loudness < 4) {
print("\"Quack.\" ", .{});
} else {
print("\"QUACK!\" ", .{});
}
}
};
const RubberDuck = struct {
in_bath: bool = false,
location_x: i32 = 0,
location_y: i32 = 0,
fn waddle(self: RubberDuck, x: i16, y: i16) void {
self.location_x += x;
self.location_y += y;
}
fn quack(self: RubberDuck) void {
// Assigning an expression to '_' allows us to safely
// "use" the value while also ignoring it.
_ = self;
print("\"Squeek!\" ", .{});
}
fn listen(self: RubberDuck, dev_talk: []const u8) void {
// Listen to developer talk about programming problem.
// Silently contemplate problem. Emit helpful sound.
_ = dev_talk;
self.quack();
}
};
const Duct = struct {
diameter: u32,
length: u32,
galvanized: bool,
connection: ?*Duct = null,
fn connect(self: Duct, other: *Duct) !void {
if (self.diameter == other.diameter) {
self.connection = other;
} else {
return DuctError.UnmatchedDiameters;
}
}
};
const DuctError = error{UnmatchedDiameters};
pub fn main() void {
// This is a real duck!
const ducky1 = Duck{
.eggs = 0,
.loudness = 3,
};
// This is not a real duck, but it has quack() and waddle()
// abilities, so it's still a "duck".
const ducky2 = RubberDuck{
.in_bath = false,
};
// This is not even remotely a duck.
const ducky3 = Duct{
.diameter = 17,
.length = 165,
.galvanized = true,
};
print("ducky1: {}, ", .{isADuck(ducky1)});
print("ducky2: {}, ", .{isADuck(ducky2)});
print("ducky3: {}\n", .{isADuck(ducky3)});
}
// This function has a single parameter which is inferred at
// compile time. It uses builtins @TypeOf() and @hasDecl() to
// perform duck typing ("if it walks like a duck and it quacks
// like a duck, then it must be a duck") to determine if the type
// is a "duck".
fn isADuck(comptime possible_duck: anytype) bool {
// We'll use @hasDecl() to determine if the type has
// everything needed to be a "duck".
//
// In this example, 'has_increment' will be true if type Foo
// has an increment() method:
//
// const has_increment = @hasDecl(Foo, "increment");
//
// Please make sure MyType has both waddle() and quack()
// methods:
const MyType = @TypeOf(possible_duck);
const walks_like_duck = @hasDecl(MyType, "waddle");
const quacks_like_duck = @hasDecl(MyType, "quack");
const is_duck = walks_like_duck and quacks_like_duck;
if (is_duck) {
// We also call the quack() method here to prove that Zig
// allows us to perform duck actions on anything
// sufficiently duck-like.
//
// Because all of the checking and inference is performed
// at compile time, we still have complete type safety:
// attempting to call the quack() method on a struct that
// doesn't have it (like Duct) would result in a compile
// error, not a runtime panic or crash!
possible_duck.quack();
}
return is_duck;
} | exercises/070_comptime5.zig |
pub const DIRECTMANIPULATION_KEYBOARDFOCUS = @as(u32, 4294967294);
pub const DIRECTMANIPULATION_MOUSEFOCUS = @as(u32, 4294967293);
pub const CLSID_VerticalIndicatorContent = Guid.initString("a10b5f17-afe0-4aa2-91e9-3e7001d2e6b4");
pub const CLSID_HorizontalIndicatorContent = Guid.initString("e7d18cf5-3ec7-44d5-a76b-3770f3cf903d");
pub const CLSID_VirtualViewportContent = Guid.initString("3206a19a-86f0-4cb4-a7f3-16e3b7e2d852");
pub const CLSID_DragDropConfigurationBehavior = Guid.initString("09b01b3e-ba6c-454d-82e8-95e352329f23");
pub const CLSID_AutoScrollBehavior = Guid.initString("26126a51-3c70-4c9a-aec2-948849eeb093");
pub const CLSID_DeferContactService = Guid.initString("d7b67cf4-84bb-434e-86ae-6592bbc9abd9");
//--------------------------------------------------------------------------------
// Section: Types (39)
//--------------------------------------------------------------------------------
const CLSID_DirectManipulationViewport_Value = Guid.initString("34e211b6-3650-4f75-8334-fa359598e1c5");
pub const CLSID_DirectManipulationViewport = &CLSID_DirectManipulationViewport_Value;
const CLSID_DirectManipulationUpdateManager_Value = Guid.initString("9fc1bfd5-1835-441a-b3b1-b6cc74b727d0");
pub const CLSID_DirectManipulationUpdateManager = &CLSID_DirectManipulationUpdateManager_Value;
const CLSID_DirectManipulationPrimaryContent_Value = Guid.initString("caa02661-d59e-41c7-8393-3ba3bacb6b57");
pub const CLSID_DirectManipulationPrimaryContent = &CLSID_DirectManipulationPrimaryContent_Value;
const CLSID_DirectManipulationManager_Value = Guid.initString("54e211b6-3650-4f75-8334-fa359598e1c5");
pub const CLSID_DirectManipulationManager = &CLSID_DirectManipulationManager_Value;
const CLSID_DirectManipulationSharedManager_Value = Guid.initString("99793286-77cc-4b57-96db-3b354f6f9fb5");
pub const CLSID_DirectManipulationSharedManager = &CLSID_DirectManipulationSharedManager_Value;
const CLSID_DCompManipulationCompositor_Value = Guid.initString("79dea627-a08a-43ac-8ef5-6900b9299126");
pub const CLSID_DCompManipulationCompositor = &CLSID_DCompManipulationCompositor_Value;
pub const DIRECTMANIPULATION_STATUS = enum(i32) {
BUILDING = 0,
ENABLED = 1,
DISABLED = 2,
RUNNING = 3,
INERTIA = 4,
READY = 5,
SUSPENDED = 6,
};
pub const DIRECTMANIPULATION_BUILDING = DIRECTMANIPULATION_STATUS.BUILDING;
pub const DIRECTMANIPULATION_ENABLED = DIRECTMANIPULATION_STATUS.ENABLED;
pub const DIRECTMANIPULATION_DISABLED = DIRECTMANIPULATION_STATUS.DISABLED;
pub const DIRECTMANIPULATION_RUNNING = DIRECTMANIPULATION_STATUS.RUNNING;
pub const DIRECTMANIPULATION_INERTIA = DIRECTMANIPULATION_STATUS.INERTIA;
pub const DIRECTMANIPULATION_READY = DIRECTMANIPULATION_STATUS.READY;
pub const DIRECTMANIPULATION_SUSPENDED = DIRECTMANIPULATION_STATUS.SUSPENDED;
pub const DIRECTMANIPULATION_HITTEST_TYPE = enum(i32) {
ASYNCHRONOUS = 0,
SYNCHRONOUS = 1,
AUTO_SYNCHRONOUS = 2,
};
pub const DIRECTMANIPULATION_HITTEST_TYPE_ASYNCHRONOUS = DIRECTMANIPULATION_HITTEST_TYPE.ASYNCHRONOUS;
pub const DIRECTMANIPULATION_HITTEST_TYPE_SYNCHRONOUS = DIRECTMANIPULATION_HITTEST_TYPE.SYNCHRONOUS;
pub const DIRECTMANIPULATION_HITTEST_TYPE_AUTO_SYNCHRONOUS = DIRECTMANIPULATION_HITTEST_TYPE.AUTO_SYNCHRONOUS;
pub const DIRECTMANIPULATION_CONFIGURATION = enum(i32) {
NONE = 0,
INTERACTION = 1,
TRANSLATION_X = 2,
TRANSLATION_Y = 4,
SCALING = 16,
TRANSLATION_INERTIA = 32,
SCALING_INERTIA = 128,
RAILS_X = 256,
RAILS_Y = 512,
};
pub const DIRECTMANIPULATION_CONFIGURATION_NONE = DIRECTMANIPULATION_CONFIGURATION.NONE;
pub const DIRECTMANIPULATION_CONFIGURATION_INTERACTION = DIRECTMANIPULATION_CONFIGURATION.INTERACTION;
pub const DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_X = DIRECTMANIPULATION_CONFIGURATION.TRANSLATION_X;
pub const DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_Y = DIRECTMANIPULATION_CONFIGURATION.TRANSLATION_Y;
pub const DIRECTMANIPULATION_CONFIGURATION_SCALING = DIRECTMANIPULATION_CONFIGURATION.SCALING;
pub const DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_INERTIA = DIRECTMANIPULATION_CONFIGURATION.TRANSLATION_INERTIA;
pub const DIRECTMANIPULATION_CONFIGURATION_SCALING_INERTIA = DIRECTMANIPULATION_CONFIGURATION.SCALING_INERTIA;
pub const DIRECTMANIPULATION_CONFIGURATION_RAILS_X = DIRECTMANIPULATION_CONFIGURATION.RAILS_X;
pub const DIRECTMANIPULATION_CONFIGURATION_RAILS_Y = DIRECTMANIPULATION_CONFIGURATION.RAILS_Y;
pub const DIRECTMANIPULATION_GESTURE_CONFIGURATION = enum(i32) {
NONE = 0,
// DEFAULT = 0, this enum value conflicts with NONE
CROSS_SLIDE_VERTICAL = 8,
CROSS_SLIDE_HORIZONTAL = 16,
PINCH_ZOOM = 32,
};
pub const DIRECTMANIPULATION_GESTURE_NONE = DIRECTMANIPULATION_GESTURE_CONFIGURATION.NONE;
pub const DIRECTMANIPULATION_GESTURE_DEFAULT = DIRECTMANIPULATION_GESTURE_CONFIGURATION.NONE;
pub const DIRECTMANIPULATION_GESTURE_CROSS_SLIDE_VERTICAL = DIRECTMANIPULATION_GESTURE_CONFIGURATION.CROSS_SLIDE_VERTICAL;
pub const DIRECTMANIPULATION_GESTURE_CROSS_SLIDE_HORIZONTAL = DIRECTMANIPULATION_GESTURE_CONFIGURATION.CROSS_SLIDE_HORIZONTAL;
pub const DIRECTMANIPULATION_GESTURE_PINCH_ZOOM = DIRECTMANIPULATION_GESTURE_CONFIGURATION.PINCH_ZOOM;
pub const DIRECTMANIPULATION_MOTION_TYPES = enum(i32) {
NONE = 0,
TRANSLATEX = 1,
TRANSLATEY = 2,
ZOOM = 4,
CENTERX = 16,
CENTERY = 32,
ALL = 55,
};
pub const DIRECTMANIPULATION_MOTION_NONE = DIRECTMANIPULATION_MOTION_TYPES.NONE;
pub const DIRECTMANIPULATION_MOTION_TRANSLATEX = DIRECTMANIPULATION_MOTION_TYPES.TRANSLATEX;
pub const DIRECTMANIPULATION_MOTION_TRANSLATEY = DIRECTMANIPULATION_MOTION_TYPES.TRANSLATEY;
pub const DIRECTMANIPULATION_MOTION_ZOOM = DIRECTMANIPULATION_MOTION_TYPES.ZOOM;
pub const DIRECTMANIPULATION_MOTION_CENTERX = DIRECTMANIPULATION_MOTION_TYPES.CENTERX;
pub const DIRECTMANIPULATION_MOTION_CENTERY = DIRECTMANIPULATION_MOTION_TYPES.CENTERY;
pub const DIRECTMANIPULATION_MOTION_ALL = DIRECTMANIPULATION_MOTION_TYPES.ALL;
pub const DIRECTMANIPULATION_VIEWPORT_OPTIONS = enum(i32) {
DEFAULT = 0,
AUTODISABLE = 1,
MANUALUPDATE = 2,
INPUT = 4,
EXPLICITHITTEST = 8,
DISABLEPIXELSNAPPING = 16,
};
pub const DIRECTMANIPULATION_VIEWPORT_OPTIONS_DEFAULT = DIRECTMANIPULATION_VIEWPORT_OPTIONS.DEFAULT;
pub const DIRECTMANIPULATION_VIEWPORT_OPTIONS_AUTODISABLE = DIRECTMANIPULATION_VIEWPORT_OPTIONS.AUTODISABLE;
pub const DIRECTMANIPULATION_VIEWPORT_OPTIONS_MANUALUPDATE = DIRECTMANIPULATION_VIEWPORT_OPTIONS.MANUALUPDATE;
pub const DIRECTMANIPULATION_VIEWPORT_OPTIONS_INPUT = DIRECTMANIPULATION_VIEWPORT_OPTIONS.INPUT;
pub const DIRECTMANIPULATION_VIEWPORT_OPTIONS_EXPLICITHITTEST = DIRECTMANIPULATION_VIEWPORT_OPTIONS.EXPLICITHITTEST;
pub const DIRECTMANIPULATION_VIEWPORT_OPTIONS_DISABLEPIXELSNAPPING = DIRECTMANIPULATION_VIEWPORT_OPTIONS.DISABLEPIXELSNAPPING;
pub const DIRECTMANIPULATION_SNAPPOINT_TYPE = enum(i32) {
MANDATORY = 0,
OPTIONAL = 1,
MANDATORY_SINGLE = 2,
OPTIONAL_SINGLE = 3,
};
pub const DIRECTMANIPULATION_SNAPPOINT_MANDATORY = DIRECTMANIPULATION_SNAPPOINT_TYPE.MANDATORY;
pub const DIRECTMANIPULATION_SNAPPOINT_OPTIONAL = DIRECTMANIPULATION_SNAPPOINT_TYPE.OPTIONAL;
pub const DIRECTMANIPULATION_SNAPPOINT_MANDATORY_SINGLE = DIRECTMANIPULATION_SNAPPOINT_TYPE.MANDATORY_SINGLE;
pub const DIRECTMANIPULATION_SNAPPOINT_OPTIONAL_SINGLE = DIRECTMANIPULATION_SNAPPOINT_TYPE.OPTIONAL_SINGLE;
pub const DIRECTMANIPULATION_SNAPPOINT_COORDINATE = enum(i32) {
BOUNDARY = 0,
ORIGIN = 1,
MIRRORED = 16,
};
pub const DIRECTMANIPULATION_COORDINATE_BOUNDARY = DIRECTMANIPULATION_SNAPPOINT_COORDINATE.BOUNDARY;
pub const DIRECTMANIPULATION_COORDINATE_ORIGIN = DIRECTMANIPULATION_SNAPPOINT_COORDINATE.ORIGIN;
pub const DIRECTMANIPULATION_COORDINATE_MIRRORED = DIRECTMANIPULATION_SNAPPOINT_COORDINATE.MIRRORED;
pub const DIRECTMANIPULATION_HORIZONTALALIGNMENT = enum(i32) {
NONE = 0,
LEFT = 1,
CENTER = 2,
RIGHT = 4,
UNLOCKCENTER = 8,
};
pub const DIRECTMANIPULATION_HORIZONTALALIGNMENT_NONE = DIRECTMANIPULATION_HORIZONTALALIGNMENT.NONE;
pub const DIRECTMANIPULATION_HORIZONTALALIGNMENT_LEFT = DIRECTMANIPULATION_HORIZONTALALIGNMENT.LEFT;
pub const DIRECTMANIPULATION_HORIZONTALALIGNMENT_CENTER = DIRECTMANIPULATION_HORIZONTALALIGNMENT.CENTER;
pub const DIRECTMANIPULATION_HORIZONTALALIGNMENT_RIGHT = DIRECTMANIPULATION_HORIZONTALALIGNMENT.RIGHT;
pub const DIRECTMANIPULATION_HORIZONTALALIGNMENT_UNLOCKCENTER = DIRECTMANIPULATION_HORIZONTALALIGNMENT.UNLOCKCENTER;
pub const DIRECTMANIPULATION_VERTICALALIGNMENT = enum(i32) {
NONE = 0,
TOP = 1,
CENTER = 2,
BOTTOM = 4,
UNLOCKCENTER = 8,
};
pub const DIRECTMANIPULATION_VERTICALALIGNMENT_NONE = DIRECTMANIPULATION_VERTICALALIGNMENT.NONE;
pub const DIRECTMANIPULATION_VERTICALALIGNMENT_TOP = DIRECTMANIPULATION_VERTICALALIGNMENT.TOP;
pub const DIRECTMANIPULATION_VERTICALALIGNMENT_CENTER = DIRECTMANIPULATION_VERTICALALIGNMENT.CENTER;
pub const DIRECTMANIPULATION_VERTICALALIGNMENT_BOTTOM = DIRECTMANIPULATION_VERTICALALIGNMENT.BOTTOM;
pub const DIRECTMANIPULATION_VERTICALALIGNMENT_UNLOCKCENTER = DIRECTMANIPULATION_VERTICALALIGNMENT.UNLOCKCENTER;
pub const DIRECTMANIPULATION_INPUT_MODE = enum(i32) {
AUTOMATIC = 0,
MANUAL = 1,
};
pub const DIRECTMANIPULATION_INPUT_MODE_AUTOMATIC = DIRECTMANIPULATION_INPUT_MODE.AUTOMATIC;
pub const DIRECTMANIPULATION_INPUT_MODE_MANUAL = DIRECTMANIPULATION_INPUT_MODE.MANUAL;
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationManager_Value = Guid.initString("fbf5d3b4-70c7-4163-9322-5a6f660d6fbc");
pub const IID_IDirectManipulationManager = &IID_IDirectManipulationManager_Value;
pub const IDirectManipulationManager = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Activate: fn(
self: *const IDirectManipulationManager,
window: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Deactivate: fn(
self: *const IDirectManipulationManager,
window: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterHitTestTarget: fn(
self: *const IDirectManipulationManager,
window: ?HWND,
hitTestWindow: ?HWND,
type: DIRECTMANIPULATION_HITTEST_TYPE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ProcessInput: fn(
self: *const IDirectManipulationManager,
message: ?*const MSG,
handled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetUpdateManager: fn(
self: *const IDirectManipulationManager,
riid: ?*const Guid,
object: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateViewport: fn(
self: *const IDirectManipulationManager,
frameInfo: ?*IDirectManipulationFrameInfoProvider,
window: ?HWND,
riid: ?*const Guid,
object: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateContent: fn(
self: *const IDirectManipulationManager,
frameInfo: ?*IDirectManipulationFrameInfoProvider,
clsid: ?*const Guid,
riid: ?*const Guid,
object: ?*?*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 IDirectManipulationManager_Activate(self: *const T, window: ?HWND) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager.VTable, self.vtable).Activate(@ptrCast(*const IDirectManipulationManager, self), window);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationManager_Deactivate(self: *const T, window: ?HWND) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager.VTable, self.vtable).Deactivate(@ptrCast(*const IDirectManipulationManager, self), window);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationManager_RegisterHitTestTarget(self: *const T, window: ?HWND, hitTestWindow: ?HWND, type_: DIRECTMANIPULATION_HITTEST_TYPE) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager.VTable, self.vtable).RegisterHitTestTarget(@ptrCast(*const IDirectManipulationManager, self), window, hitTestWindow, type_);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationManager_ProcessInput(self: *const T, message: ?*const MSG, handled: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager.VTable, self.vtable).ProcessInput(@ptrCast(*const IDirectManipulationManager, self), message, handled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationManager_GetUpdateManager(self: *const T, riid: ?*const Guid, object: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager.VTable, self.vtable).GetUpdateManager(@ptrCast(*const IDirectManipulationManager, self), riid, object);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationManager_CreateViewport(self: *const T, frameInfo: ?*IDirectManipulationFrameInfoProvider, window: ?HWND, riid: ?*const Guid, object: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager.VTable, self.vtable).CreateViewport(@ptrCast(*const IDirectManipulationManager, self), frameInfo, window, riid, object);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationManager_CreateContent(self: *const T, frameInfo: ?*IDirectManipulationFrameInfoProvider, clsid: ?*const Guid, riid: ?*const Guid, object: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager.VTable, self.vtable).CreateContent(@ptrCast(*const IDirectManipulationManager, self), frameInfo, clsid, riid, object);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.1'
const IID_IDirectManipulationManager2_Value = Guid.initString("fa1005e9-3d16-484c-bfc9-62b61e56ec4e");
pub const IID_IDirectManipulationManager2 = &IID_IDirectManipulationManager2_Value;
pub const IDirectManipulationManager2 = extern struct {
pub const VTable = extern struct {
base: IDirectManipulationManager.VTable,
CreateBehavior: fn(
self: *const IDirectManipulationManager2,
clsid: ?*const Guid,
riid: ?*const Guid,
object: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDirectManipulationManager.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationManager2_CreateBehavior(self: *const T, clsid: ?*const Guid, riid: ?*const Guid, object: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager2.VTable, self.vtable).CreateBehavior(@ptrCast(*const IDirectManipulationManager2, self), clsid, riid, object);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.10240'
const IID_IDirectManipulationManager3_Value = Guid.initString("2cb6b33d-ffe8-488c-b750-fbdfe88dca8c");
pub const IID_IDirectManipulationManager3 = &IID_IDirectManipulationManager3_Value;
pub const IDirectManipulationManager3 = extern struct {
pub const VTable = extern struct {
base: IDirectManipulationManager2.VTable,
GetService: fn(
self: *const IDirectManipulationManager3,
clsid: ?*const Guid,
riid: ?*const Guid,
object: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDirectManipulationManager2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationManager3_GetService(self: *const T, clsid: ?*const Guid, riid: ?*const Guid, object: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationManager3.VTable, self.vtable).GetService(@ptrCast(*const IDirectManipulationManager3, self), clsid, riid, object);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationViewport_Value = Guid.initString("28b85a3d-60a0-48bd-9ba1-5ce8d9ea3a6d");
pub const IID_IDirectManipulationViewport = &IID_IDirectManipulationViewport_Value;
pub const IDirectManipulationViewport = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Enable: fn(
self: *const IDirectManipulationViewport,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Disable: fn(
self: *const IDirectManipulationViewport,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetContact: fn(
self: *const IDirectManipulationViewport,
pointerId: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReleaseContact: fn(
self: *const IDirectManipulationViewport,
pointerId: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReleaseAllContacts: fn(
self: *const IDirectManipulationViewport,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStatus: fn(
self: *const IDirectManipulationViewport,
status: ?*DIRECTMANIPULATION_STATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTag: fn(
self: *const IDirectManipulationViewport,
riid: ?*const Guid,
object: ?*?*anyopaque,
id: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetTag: fn(
self: *const IDirectManipulationViewport,
object: ?*IUnknown,
id: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetViewportRect: fn(
self: *const IDirectManipulationViewport,
viewport: ?*RECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetViewportRect: fn(
self: *const IDirectManipulationViewport,
viewport: ?*const RECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ZoomToRect: fn(
self: *const IDirectManipulationViewport,
left: f32,
top: f32,
right: f32,
bottom: f32,
animate: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetViewportTransform: fn(
self: *const IDirectManipulationViewport,
matrix: [*]const f32,
pointCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SyncDisplayTransform: fn(
self: *const IDirectManipulationViewport,
matrix: [*]const f32,
pointCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPrimaryContent: fn(
self: *const IDirectManipulationViewport,
riid: ?*const Guid,
object: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddContent: fn(
self: *const IDirectManipulationViewport,
content: ?*IDirectManipulationContent,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveContent: fn(
self: *const IDirectManipulationViewport,
content: ?*IDirectManipulationContent,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetViewportOptions: fn(
self: *const IDirectManipulationViewport,
options: DIRECTMANIPULATION_VIEWPORT_OPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddConfiguration: fn(
self: *const IDirectManipulationViewport,
configuration: DIRECTMANIPULATION_CONFIGURATION,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveConfiguration: fn(
self: *const IDirectManipulationViewport,
configuration: DIRECTMANIPULATION_CONFIGURATION,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ActivateConfiguration: fn(
self: *const IDirectManipulationViewport,
configuration: DIRECTMANIPULATION_CONFIGURATION,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetManualGesture: fn(
self: *const IDirectManipulationViewport,
configuration: DIRECTMANIPULATION_GESTURE_CONFIGURATION,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetChaining: fn(
self: *const IDirectManipulationViewport,
enabledTypes: DIRECTMANIPULATION_MOTION_TYPES,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddEventHandler: fn(
self: *const IDirectManipulationViewport,
window: ?HWND,
eventHandler: ?*IDirectManipulationViewportEventHandler,
cookie: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveEventHandler: fn(
self: *const IDirectManipulationViewport,
cookie: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetInputMode: fn(
self: *const IDirectManipulationViewport,
mode: DIRECTMANIPULATION_INPUT_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetUpdateMode: fn(
self: *const IDirectManipulationViewport,
mode: DIRECTMANIPULATION_INPUT_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Stop: fn(
self: *const IDirectManipulationViewport,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Abandon: fn(
self: *const IDirectManipulationViewport,
) 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 IDirectManipulationViewport_Enable(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).Enable(@ptrCast(*const IDirectManipulationViewport, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_Disable(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).Disable(@ptrCast(*const IDirectManipulationViewport, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetContact(self: *const T, pointerId: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetContact(@ptrCast(*const IDirectManipulationViewport, self), pointerId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_ReleaseContact(self: *const T, pointerId: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).ReleaseContact(@ptrCast(*const IDirectManipulationViewport, self), pointerId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_ReleaseAllContacts(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).ReleaseAllContacts(@ptrCast(*const IDirectManipulationViewport, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_GetStatus(self: *const T, status: ?*DIRECTMANIPULATION_STATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).GetStatus(@ptrCast(*const IDirectManipulationViewport, self), status);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_GetTag(self: *const T, riid: ?*const Guid, object: ?*?*anyopaque, id: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).GetTag(@ptrCast(*const IDirectManipulationViewport, self), riid, object, id);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetTag(self: *const T, object: ?*IUnknown, id: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetTag(@ptrCast(*const IDirectManipulationViewport, self), object, id);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_GetViewportRect(self: *const T, viewport: ?*RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).GetViewportRect(@ptrCast(*const IDirectManipulationViewport, self), viewport);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetViewportRect(self: *const T, viewport: ?*const RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetViewportRect(@ptrCast(*const IDirectManipulationViewport, self), viewport);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_ZoomToRect(self: *const T, left: f32, top: f32, right: f32, bottom: f32, animate: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).ZoomToRect(@ptrCast(*const IDirectManipulationViewport, self), left, top, right, bottom, animate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetViewportTransform(self: *const T, matrix: [*]const f32, pointCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetViewportTransform(@ptrCast(*const IDirectManipulationViewport, self), matrix, pointCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SyncDisplayTransform(self: *const T, matrix: [*]const f32, pointCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SyncDisplayTransform(@ptrCast(*const IDirectManipulationViewport, self), matrix, pointCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_GetPrimaryContent(self: *const T, riid: ?*const Guid, object: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).GetPrimaryContent(@ptrCast(*const IDirectManipulationViewport, self), riid, object);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_AddContent(self: *const T, content: ?*IDirectManipulationContent) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).AddContent(@ptrCast(*const IDirectManipulationViewport, self), content);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_RemoveContent(self: *const T, content: ?*IDirectManipulationContent) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).RemoveContent(@ptrCast(*const IDirectManipulationViewport, self), content);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetViewportOptions(self: *const T, options: DIRECTMANIPULATION_VIEWPORT_OPTIONS) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetViewportOptions(@ptrCast(*const IDirectManipulationViewport, self), options);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_AddConfiguration(self: *const T, configuration: DIRECTMANIPULATION_CONFIGURATION) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).AddConfiguration(@ptrCast(*const IDirectManipulationViewport, self), configuration);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_RemoveConfiguration(self: *const T, configuration: DIRECTMANIPULATION_CONFIGURATION) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).RemoveConfiguration(@ptrCast(*const IDirectManipulationViewport, self), configuration);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_ActivateConfiguration(self: *const T, configuration: DIRECTMANIPULATION_CONFIGURATION) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).ActivateConfiguration(@ptrCast(*const IDirectManipulationViewport, self), configuration);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetManualGesture(self: *const T, configuration: DIRECTMANIPULATION_GESTURE_CONFIGURATION) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetManualGesture(@ptrCast(*const IDirectManipulationViewport, self), configuration);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetChaining(self: *const T, enabledTypes: DIRECTMANIPULATION_MOTION_TYPES) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetChaining(@ptrCast(*const IDirectManipulationViewport, self), enabledTypes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_AddEventHandler(self: *const T, window: ?HWND, eventHandler: ?*IDirectManipulationViewportEventHandler, cookie: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).AddEventHandler(@ptrCast(*const IDirectManipulationViewport, self), window, eventHandler, cookie);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_RemoveEventHandler(self: *const T, cookie: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).RemoveEventHandler(@ptrCast(*const IDirectManipulationViewport, self), cookie);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetInputMode(self: *const T, mode: DIRECTMANIPULATION_INPUT_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetInputMode(@ptrCast(*const IDirectManipulationViewport, self), mode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_SetUpdateMode(self: *const T, mode: DIRECTMANIPULATION_INPUT_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).SetUpdateMode(@ptrCast(*const IDirectManipulationViewport, self), mode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_Stop(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).Stop(@ptrCast(*const IDirectManipulationViewport, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport_Abandon(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport.VTable, self.vtable).Abandon(@ptrCast(*const IDirectManipulationViewport, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.1'
const IID_IDirectManipulationViewport2_Value = Guid.initString("923ccaac-61e1-4385-b726-017af189882a");
pub const IID_IDirectManipulationViewport2 = &IID_IDirectManipulationViewport2_Value;
pub const IDirectManipulationViewport2 = extern struct {
pub const VTable = extern struct {
base: IDirectManipulationViewport.VTable,
AddBehavior: fn(
self: *const IDirectManipulationViewport2,
behavior: ?*IUnknown,
cookie: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveBehavior: fn(
self: *const IDirectManipulationViewport2,
cookie: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveAllBehaviors: fn(
self: *const IDirectManipulationViewport2,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDirectManipulationViewport.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport2_AddBehavior(self: *const T, behavior: ?*IUnknown, cookie: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport2.VTable, self.vtable).AddBehavior(@ptrCast(*const IDirectManipulationViewport2, self), behavior, cookie);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport2_RemoveBehavior(self: *const T, cookie: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport2.VTable, self.vtable).RemoveBehavior(@ptrCast(*const IDirectManipulationViewport2, self), cookie);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewport2_RemoveAllBehaviors(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewport2.VTable, self.vtable).RemoveAllBehaviors(@ptrCast(*const IDirectManipulationViewport2, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationViewportEventHandler_Value = Guid.initString("952121da-d69f-45f9-b0f9-f23944321a6d");
pub const IID_IDirectManipulationViewportEventHandler = &IID_IDirectManipulationViewportEventHandler_Value;
pub const IDirectManipulationViewportEventHandler = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnViewportStatusChanged: fn(
self: *const IDirectManipulationViewportEventHandler,
viewport: ?*IDirectManipulationViewport,
current: DIRECTMANIPULATION_STATUS,
previous: DIRECTMANIPULATION_STATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnViewportUpdated: fn(
self: *const IDirectManipulationViewportEventHandler,
viewport: ?*IDirectManipulationViewport,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnContentUpdated: fn(
self: *const IDirectManipulationViewportEventHandler,
viewport: ?*IDirectManipulationViewport,
content: ?*IDirectManipulationContent,
) 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 IDirectManipulationViewportEventHandler_OnViewportStatusChanged(self: *const T, viewport: ?*IDirectManipulationViewport, current: DIRECTMANIPULATION_STATUS, previous: DIRECTMANIPULATION_STATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewportEventHandler.VTable, self.vtable).OnViewportStatusChanged(@ptrCast(*const IDirectManipulationViewportEventHandler, self), viewport, current, previous);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewportEventHandler_OnViewportUpdated(self: *const T, viewport: ?*IDirectManipulationViewport) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewportEventHandler.VTable, self.vtable).OnViewportUpdated(@ptrCast(*const IDirectManipulationViewportEventHandler, self), viewport);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationViewportEventHandler_OnContentUpdated(self: *const T, viewport: ?*IDirectManipulationViewport, content: ?*IDirectManipulationContent) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationViewportEventHandler.VTable, self.vtable).OnContentUpdated(@ptrCast(*const IDirectManipulationViewportEventHandler, self), viewport, content);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationContent_Value = Guid.initString("b89962cb-3d89-442b-bb58-5098fa0f9f16");
pub const IID_IDirectManipulationContent = &IID_IDirectManipulationContent_Value;
pub const IDirectManipulationContent = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetContentRect: fn(
self: *const IDirectManipulationContent,
contentSize: ?*RECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetContentRect: fn(
self: *const IDirectManipulationContent,
contentSize: ?*const RECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetViewport: fn(
self: *const IDirectManipulationContent,
riid: ?*const Guid,
object: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTag: fn(
self: *const IDirectManipulationContent,
riid: ?*const Guid,
object: ?*?*anyopaque,
id: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetTag: fn(
self: *const IDirectManipulationContent,
object: ?*IUnknown,
id: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetOutputTransform: fn(
self: *const IDirectManipulationContent,
matrix: [*]f32,
pointCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetContentTransform: fn(
self: *const IDirectManipulationContent,
matrix: [*]f32,
pointCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SyncContentTransform: fn(
self: *const IDirectManipulationContent,
matrix: [*]const f32,
pointCount: 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 IDirectManipulationContent_GetContentRect(self: *const T, contentSize: ?*RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationContent.VTable, self.vtable).GetContentRect(@ptrCast(*const IDirectManipulationContent, self), contentSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationContent_SetContentRect(self: *const T, contentSize: ?*const RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationContent.VTable, self.vtable).SetContentRect(@ptrCast(*const IDirectManipulationContent, self), contentSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationContent_GetViewport(self: *const T, riid: ?*const Guid, object: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationContent.VTable, self.vtable).GetViewport(@ptrCast(*const IDirectManipulationContent, self), riid, object);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationContent_GetTag(self: *const T, riid: ?*const Guid, object: ?*?*anyopaque, id: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationContent.VTable, self.vtable).GetTag(@ptrCast(*const IDirectManipulationContent, self), riid, object, id);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationContent_SetTag(self: *const T, object: ?*IUnknown, id: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationContent.VTable, self.vtable).SetTag(@ptrCast(*const IDirectManipulationContent, self), object, id);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationContent_GetOutputTransform(self: *const T, matrix: [*]f32, pointCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationContent.VTable, self.vtable).GetOutputTransform(@ptrCast(*const IDirectManipulationContent, self), matrix, pointCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationContent_GetContentTransform(self: *const T, matrix: [*]f32, pointCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationContent.VTable, self.vtable).GetContentTransform(@ptrCast(*const IDirectManipulationContent, self), matrix, pointCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationContent_SyncContentTransform(self: *const T, matrix: [*]const f32, pointCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationContent.VTable, self.vtable).SyncContentTransform(@ptrCast(*const IDirectManipulationContent, self), matrix, pointCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationPrimaryContent_Value = Guid.initString("c12851e4-1698-4625-b9b1-7ca3ec18630b");
pub const IID_IDirectManipulationPrimaryContent = &IID_IDirectManipulationPrimaryContent_Value;
pub const IDirectManipulationPrimaryContent = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetSnapInterval: fn(
self: *const IDirectManipulationPrimaryContent,
motion: DIRECTMANIPULATION_MOTION_TYPES,
interval: f32,
offset: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSnapPoints: fn(
self: *const IDirectManipulationPrimaryContent,
motion: DIRECTMANIPULATION_MOTION_TYPES,
points: ?[*]const f32,
pointCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSnapType: fn(
self: *const IDirectManipulationPrimaryContent,
motion: DIRECTMANIPULATION_MOTION_TYPES,
type: DIRECTMANIPULATION_SNAPPOINT_TYPE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSnapCoordinate: fn(
self: *const IDirectManipulationPrimaryContent,
motion: DIRECTMANIPULATION_MOTION_TYPES,
coordinate: DIRECTMANIPULATION_SNAPPOINT_COORDINATE,
origin: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetZoomBoundaries: fn(
self: *const IDirectManipulationPrimaryContent,
zoomMinimum: f32,
zoomMaximum: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetHorizontalAlignment: fn(
self: *const IDirectManipulationPrimaryContent,
alignment: DIRECTMANIPULATION_HORIZONTALALIGNMENT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetVerticalAlignment: fn(
self: *const IDirectManipulationPrimaryContent,
alignment: DIRECTMANIPULATION_VERTICALALIGNMENT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInertiaEndTransform: fn(
self: *const IDirectManipulationPrimaryContent,
matrix: [*]f32,
pointCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCenterPoint: fn(
self: *const IDirectManipulationPrimaryContent,
centerX: ?*f32,
centerY: ?*f32,
) 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 IDirectManipulationPrimaryContent_SetSnapInterval(self: *const T, motion: DIRECTMANIPULATION_MOTION_TYPES, interval: f32, offset: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).SetSnapInterval(@ptrCast(*const IDirectManipulationPrimaryContent, self), motion, interval, offset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationPrimaryContent_SetSnapPoints(self: *const T, motion: DIRECTMANIPULATION_MOTION_TYPES, points: ?[*]const f32, pointCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).SetSnapPoints(@ptrCast(*const IDirectManipulationPrimaryContent, self), motion, points, pointCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationPrimaryContent_SetSnapType(self: *const T, motion: DIRECTMANIPULATION_MOTION_TYPES, type_: DIRECTMANIPULATION_SNAPPOINT_TYPE) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).SetSnapType(@ptrCast(*const IDirectManipulationPrimaryContent, self), motion, type_);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationPrimaryContent_SetSnapCoordinate(self: *const T, motion: DIRECTMANIPULATION_MOTION_TYPES, coordinate: DIRECTMANIPULATION_SNAPPOINT_COORDINATE, origin: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).SetSnapCoordinate(@ptrCast(*const IDirectManipulationPrimaryContent, self), motion, coordinate, origin);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationPrimaryContent_SetZoomBoundaries(self: *const T, zoomMinimum: f32, zoomMaximum: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).SetZoomBoundaries(@ptrCast(*const IDirectManipulationPrimaryContent, self), zoomMinimum, zoomMaximum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationPrimaryContent_SetHorizontalAlignment(self: *const T, alignment: DIRECTMANIPULATION_HORIZONTALALIGNMENT) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).SetHorizontalAlignment(@ptrCast(*const IDirectManipulationPrimaryContent, self), alignment);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationPrimaryContent_SetVerticalAlignment(self: *const T, alignment: DIRECTMANIPULATION_VERTICALALIGNMENT) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).SetVerticalAlignment(@ptrCast(*const IDirectManipulationPrimaryContent, self), alignment);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationPrimaryContent_GetInertiaEndTransform(self: *const T, matrix: [*]f32, pointCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).GetInertiaEndTransform(@ptrCast(*const IDirectManipulationPrimaryContent, self), matrix, pointCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationPrimaryContent_GetCenterPoint(self: *const T, centerX: ?*f32, centerY: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationPrimaryContent.VTable, self.vtable).GetCenterPoint(@ptrCast(*const IDirectManipulationPrimaryContent, self), centerX, centerY);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const DIRECTMANIPULATION_DRAG_DROP_STATUS = enum(i32) {
READY = 0,
PRESELECT = 1,
SELECTING = 2,
DRAGGING = 3,
CANCELLED = 4,
COMMITTED = 5,
};
pub const DIRECTMANIPULATION_DRAG_DROP_READY = DIRECTMANIPULATION_DRAG_DROP_STATUS.READY;
pub const DIRECTMANIPULATION_DRAG_DROP_PRESELECT = DIRECTMANIPULATION_DRAG_DROP_STATUS.PRESELECT;
pub const DIRECTMANIPULATION_DRAG_DROP_SELECTING = DIRECTMANIPULATION_DRAG_DROP_STATUS.SELECTING;
pub const DIRECTMANIPULATION_DRAG_DROP_DRAGGING = DIRECTMANIPULATION_DRAG_DROP_STATUS.DRAGGING;
pub const DIRECTMANIPULATION_DRAG_DROP_CANCELLED = DIRECTMANIPULATION_DRAG_DROP_STATUS.CANCELLED;
pub const DIRECTMANIPULATION_DRAG_DROP_COMMITTED = DIRECTMANIPULATION_DRAG_DROP_STATUS.COMMITTED;
// TODO: this type is limited to platform 'windows8.1'
const IID_IDirectManipulationDragDropEventHandler_Value = Guid.initString("1fa11b10-701b-41ae-b5f2-49e36bd595aa");
pub const IID_IDirectManipulationDragDropEventHandler = &IID_IDirectManipulationDragDropEventHandler_Value;
pub const IDirectManipulationDragDropEventHandler = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnDragDropStatusChange: fn(
self: *const IDirectManipulationDragDropEventHandler,
viewport: ?*IDirectManipulationViewport2,
current: DIRECTMANIPULATION_DRAG_DROP_STATUS,
previous: DIRECTMANIPULATION_DRAG_DROP_STATUS,
) 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 IDirectManipulationDragDropEventHandler_OnDragDropStatusChange(self: *const T, viewport: ?*IDirectManipulationViewport2, current: DIRECTMANIPULATION_DRAG_DROP_STATUS, previous: DIRECTMANIPULATION_DRAG_DROP_STATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationDragDropEventHandler.VTable, self.vtable).OnDragDropStatusChange(@ptrCast(*const IDirectManipulationDragDropEventHandler, self), viewport, current, previous);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION = enum(i32) {
VERTICAL = 1,
HORIZONTAL = 2,
SELECT_ONLY = 16,
SELECT_DRAG = 32,
HOLD_DRAG = 64,
};
pub const DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION_VERTICAL = DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION.VERTICAL;
pub const DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION_HORIZONTAL = DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION.HORIZONTAL;
pub const DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION_SELECT_ONLY = DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION.SELECT_ONLY;
pub const DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION_SELECT_DRAG = DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION.SELECT_DRAG;
pub const DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION_HOLD_DRAG = DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION.HOLD_DRAG;
// TODO: this type is limited to platform 'windows8.1'
const IID_IDirectManipulationDragDropBehavior_Value = Guid.initString("814b5af5-c2c8-4270-a9b7-a198ce8d02fa");
pub const IID_IDirectManipulationDragDropBehavior = &IID_IDirectManipulationDragDropBehavior_Value;
pub const IDirectManipulationDragDropBehavior = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetConfiguration: fn(
self: *const IDirectManipulationDragDropBehavior,
configuration: DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStatus: fn(
self: *const IDirectManipulationDragDropBehavior,
status: ?*DIRECTMANIPULATION_DRAG_DROP_STATUS,
) 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 IDirectManipulationDragDropBehavior_SetConfiguration(self: *const T, configuration: DIRECTMANIPULATION_DRAG_DROP_CONFIGURATION) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationDragDropBehavior.VTable, self.vtable).SetConfiguration(@ptrCast(*const IDirectManipulationDragDropBehavior, self), configuration);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationDragDropBehavior_GetStatus(self: *const T, status: ?*DIRECTMANIPULATION_DRAG_DROP_STATUS) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationDragDropBehavior.VTable, self.vtable).GetStatus(@ptrCast(*const IDirectManipulationDragDropBehavior, self), status);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const DIRECTMANIPULATION_INTERACTION_TYPE = enum(i32) {
BEGIN = 0,
TYPE_MANIPULATION = 1,
TYPE_GESTURE_TAP = 2,
TYPE_GESTURE_HOLD = 3,
TYPE_GESTURE_CROSS_SLIDE = 4,
TYPE_GESTURE_PINCH_ZOOM = 5,
END = 100,
};
pub const DIRECTMANIPULATION_INTERACTION_BEGIN = DIRECTMANIPULATION_INTERACTION_TYPE.BEGIN;
pub const DIRECTMANIPULATION_INTERACTION_TYPE_MANIPULATION = DIRECTMANIPULATION_INTERACTION_TYPE.TYPE_MANIPULATION;
pub const DIRECTMANIPULATION_INTERACTION_TYPE_GESTURE_TAP = DIRECTMANIPULATION_INTERACTION_TYPE.TYPE_GESTURE_TAP;
pub const DIRECTMANIPULATION_INTERACTION_TYPE_GESTURE_HOLD = DIRECTMANIPULATION_INTERACTION_TYPE.TYPE_GESTURE_HOLD;
pub const DIRECTMANIPULATION_INTERACTION_TYPE_GESTURE_CROSS_SLIDE = DIRECTMANIPULATION_INTERACTION_TYPE.TYPE_GESTURE_CROSS_SLIDE;
pub const DIRECTMANIPULATION_INTERACTION_TYPE_GESTURE_PINCH_ZOOM = DIRECTMANIPULATION_INTERACTION_TYPE.TYPE_GESTURE_PINCH_ZOOM;
pub const DIRECTMANIPULATION_INTERACTION_END = DIRECTMANIPULATION_INTERACTION_TYPE.END;
// TODO: this type is limited to platform 'windows8.1'
const IID_IDirectManipulationInteractionEventHandler_Value = Guid.initString("e43f45b8-42b4-403e-b1f2-273b8f510830");
pub const IID_IDirectManipulationInteractionEventHandler = &IID_IDirectManipulationInteractionEventHandler_Value;
pub const IDirectManipulationInteractionEventHandler = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnInteraction: fn(
self: *const IDirectManipulationInteractionEventHandler,
viewport: ?*IDirectManipulationViewport2,
interaction: DIRECTMANIPULATION_INTERACTION_TYPE,
) 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 IDirectManipulationInteractionEventHandler_OnInteraction(self: *const T, viewport: ?*IDirectManipulationViewport2, interaction: DIRECTMANIPULATION_INTERACTION_TYPE) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationInteractionEventHandler.VTable, self.vtable).OnInteraction(@ptrCast(*const IDirectManipulationInteractionEventHandler, self), viewport, interaction);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationFrameInfoProvider_Value = Guid.initString("fb759dba-6f4c-4c01-874e-19c8a05907f9");
pub const IID_IDirectManipulationFrameInfoProvider = &IID_IDirectManipulationFrameInfoProvider_Value;
pub const IDirectManipulationFrameInfoProvider = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetNextFrameInfo: fn(
self: *const IDirectManipulationFrameInfoProvider,
time: ?*u64,
processTime: ?*u64,
compositionTime: ?*u64,
) 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 IDirectManipulationFrameInfoProvider_GetNextFrameInfo(self: *const T, time: ?*u64, processTime: ?*u64, compositionTime: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationFrameInfoProvider.VTable, self.vtable).GetNextFrameInfo(@ptrCast(*const IDirectManipulationFrameInfoProvider, self), time, processTime, compositionTime);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationCompositor_Value = Guid.initString("537a0825-0387-4efa-b62f-71eb1f085a7e");
pub const IID_IDirectManipulationCompositor = &IID_IDirectManipulationCompositor_Value;
pub const IDirectManipulationCompositor = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AddContent: fn(
self: *const IDirectManipulationCompositor,
content: ?*IDirectManipulationContent,
device: ?*IUnknown,
parentVisual: ?*IUnknown,
childVisual: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveContent: fn(
self: *const IDirectManipulationCompositor,
content: ?*IDirectManipulationContent,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetUpdateManager: fn(
self: *const IDirectManipulationCompositor,
updateManager: ?*IDirectManipulationUpdateManager,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Flush: fn(
self: *const IDirectManipulationCompositor,
) 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 IDirectManipulationCompositor_AddContent(self: *const T, content: ?*IDirectManipulationContent, device: ?*IUnknown, parentVisual: ?*IUnknown, childVisual: ?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationCompositor.VTable, self.vtable).AddContent(@ptrCast(*const IDirectManipulationCompositor, self), content, device, parentVisual, childVisual);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationCompositor_RemoveContent(self: *const T, content: ?*IDirectManipulationContent) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationCompositor.VTable, self.vtable).RemoveContent(@ptrCast(*const IDirectManipulationCompositor, self), content);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationCompositor_SetUpdateManager(self: *const T, updateManager: ?*IDirectManipulationUpdateManager) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationCompositor.VTable, self.vtable).SetUpdateManager(@ptrCast(*const IDirectManipulationCompositor, self), updateManager);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationCompositor_Flush(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationCompositor.VTable, self.vtable).Flush(@ptrCast(*const IDirectManipulationCompositor, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.10240'
const IID_IDirectManipulationCompositor2_Value = Guid.initString("d38c7822-f1cb-43cb-b4b9-ac0c767a412e");
pub const IID_IDirectManipulationCompositor2 = &IID_IDirectManipulationCompositor2_Value;
pub const IDirectManipulationCompositor2 = extern struct {
pub const VTable = extern struct {
base: IDirectManipulationCompositor.VTable,
AddContentWithCrossProcessChaining: fn(
self: *const IDirectManipulationCompositor2,
content: ?*IDirectManipulationPrimaryContent,
device: ?*IUnknown,
parentVisual: ?*IUnknown,
childVisual: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDirectManipulationCompositor.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationCompositor2_AddContentWithCrossProcessChaining(self: *const T, content: ?*IDirectManipulationPrimaryContent, device: ?*IUnknown, parentVisual: ?*IUnknown, childVisual: ?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationCompositor2.VTable, self.vtable).AddContentWithCrossProcessChaining(@ptrCast(*const IDirectManipulationCompositor2, self), content, device, parentVisual, childVisual);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationUpdateHandler_Value = Guid.initString("790b6337-64f8-4ff5-a269-b32bc2af27a7");
pub const IID_IDirectManipulationUpdateHandler = &IID_IDirectManipulationUpdateHandler_Value;
pub const IDirectManipulationUpdateHandler = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Update: fn(
self: *const IDirectManipulationUpdateHandler,
) 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 IDirectManipulationUpdateHandler_Update(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationUpdateHandler.VTable, self.vtable).Update(@ptrCast(*const IDirectManipulationUpdateHandler, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IDirectManipulationUpdateManager_Value = Guid.initString("b0ae62fd-be34-46e7-9caa-d361facbb9cc");
pub const IID_IDirectManipulationUpdateManager = &IID_IDirectManipulationUpdateManager_Value;
pub const IDirectManipulationUpdateManager = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
RegisterWaitHandleCallback: fn(
self: *const IDirectManipulationUpdateManager,
handle: ?HANDLE,
eventHandler: ?*IDirectManipulationUpdateHandler,
cookie: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterWaitHandleCallback: fn(
self: *const IDirectManipulationUpdateManager,
cookie: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Update: fn(
self: *const IDirectManipulationUpdateManager,
frameInfo: ?*IDirectManipulationFrameInfoProvider,
) 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 IDirectManipulationUpdateManager_RegisterWaitHandleCallback(self: *const T, handle: ?HANDLE, eventHandler: ?*IDirectManipulationUpdateHandler, cookie: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationUpdateManager.VTable, self.vtable).RegisterWaitHandleCallback(@ptrCast(*const IDirectManipulationUpdateManager, self), handle, eventHandler, cookie);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationUpdateManager_UnregisterWaitHandleCallback(self: *const T, cookie: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationUpdateManager.VTable, self.vtable).UnregisterWaitHandleCallback(@ptrCast(*const IDirectManipulationUpdateManager, self), cookie);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationUpdateManager_Update(self: *const T, frameInfo: ?*IDirectManipulationFrameInfoProvider) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationUpdateManager.VTable, self.vtable).Update(@ptrCast(*const IDirectManipulationUpdateManager, self), frameInfo);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION = enum(i32) {
STOP = 0,
FORWARD = 1,
REVERSE = 2,
};
pub const DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION_STOP = DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION.STOP;
pub const DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION_FORWARD = DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION.FORWARD;
pub const DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION_REVERSE = DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION.REVERSE;
// TODO: this type is limited to platform 'windows8.1'
const IID_IDirectManipulationAutoScrollBehavior_Value = Guid.initString("6d5954d4-2003-4356-9b31-d051c9ff0af7");
pub const IID_IDirectManipulationAutoScrollBehavior = &IID_IDirectManipulationAutoScrollBehavior_Value;
pub const IDirectManipulationAutoScrollBehavior = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetConfiguration: fn(
self: *const IDirectManipulationAutoScrollBehavior,
motionTypes: DIRECTMANIPULATION_MOTION_TYPES,
scrollMotion: DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION,
) 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 IDirectManipulationAutoScrollBehavior_SetConfiguration(self: *const T, motionTypes: DIRECTMANIPULATION_MOTION_TYPES, scrollMotion: DIRECTMANIPULATION_AUTOSCROLL_CONFIGURATION) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationAutoScrollBehavior.VTable, self.vtable).SetConfiguration(@ptrCast(*const IDirectManipulationAutoScrollBehavior, self), motionTypes, scrollMotion);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.10240'
const IID_IDirectManipulationDeferContactService_Value = Guid.initString("652d5c71-fe60-4a98-be70-e5f21291e7f1");
pub const IID_IDirectManipulationDeferContactService = &IID_IDirectManipulationDeferContactService_Value;
pub const IDirectManipulationDeferContactService = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
DeferContact: fn(
self: *const IDirectManipulationDeferContactService,
pointerId: u32,
timeout: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CancelContact: fn(
self: *const IDirectManipulationDeferContactService,
pointerId: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CancelDeferral: fn(
self: *const IDirectManipulationDeferContactService,
pointerId: 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 IDirectManipulationDeferContactService_DeferContact(self: *const T, pointerId: u32, timeout: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationDeferContactService.VTable, self.vtable).DeferContact(@ptrCast(*const IDirectManipulationDeferContactService, self), pointerId, timeout);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationDeferContactService_CancelContact(self: *const T, pointerId: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationDeferContactService.VTable, self.vtable).CancelContact(@ptrCast(*const IDirectManipulationDeferContactService, self), pointerId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDirectManipulationDeferContactService_CancelDeferral(self: *const T, pointerId: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDirectManipulationDeferContactService.VTable, self.vtable).CancelDeferral(@ptrCast(*const IDirectManipulationDeferContactService, self), pointerId);
}
};}
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 (8)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const HANDLE = @import("../foundation.zig").HANDLE;
const HRESULT = @import("../foundation.zig").HRESULT;
const HWND = @import("../foundation.zig").HWND;
const IUnknown = @import("../system/com.zig").IUnknown;
const MSG = @import("../ui/windows_and_messaging.zig").MSG;
const RECT = @import("../foundation.zig").RECT;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/graphics/direct_manipulation.zig |
const base = @import("../base.zig");
const gen = @import("../gen.zig");
const COMMON = [_:null]?base.Segment{
.{ .offset = 30 * 0, .month = 1, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 1, .month = 2, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 2, .month = 3, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 3, .month = 4, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 4, .month = 5, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 5, .month = 6, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 6, .month = 7, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 7, .month = 8, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 8, .month = 9, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 9, .month = 10, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 10, .month = 11, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 11, .month = 12, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 12, .month = 0, .day_start = 1, .day_end = 5 },
};
const LEAP = [_:null]?base.Segment{
.{ .offset = 30 * 0, .month = 1, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 1, .month = 2, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 2, .month = 3, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 3, .month = 4, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 4, .month = 5, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 5, .month = 6, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 6, .month = 7, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 7, .month = 8, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 8, .month = 9, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 9, .month = 10, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 10, .month = 11, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 11, .month = 12, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 12, .month = 0, .day_start = 1, .day_end = 6 },
};
const IC = [_:null]?base.Intercalary{
gen.initIc(.{ .month = 0, .day = 1 }, COMMON[0..COMMON.len], LEAP[0..LEAP.len]),
gen.initIc(.{ .month = 0, .day = 2 }, COMMON[0..COMMON.len], LEAP[0..LEAP.len]),
gen.initIc(.{ .month = 0, .day = 3 }, COMMON[0..COMMON.len], LEAP[0..LEAP.len]),
gen.initIc(.{ .month = 0, .day = 4 }, COMMON[0..COMMON.len], LEAP[0..LEAP.len]),
gen.initIc(.{ .month = 0, .day = 5 }, COMMON[0..COMMON.len], LEAP[0..LEAP.len]),
gen.initIc(.{ .month = 0, .day = 6 }, LEAP[0..LEAP.len], LEAP[0..LEAP.len]),
};
var ic_var: [IC.len:null]?base.Intercalary = IC;
var common_var: [COMMON.len:null]?base.Segment = COMMON;
var leap_var: [LEAP.len:null]?base.Segment = LEAP;
pub const french_revolutionary_romme = base.Cal{
.intercalary_list = @as([*:null]?base.Intercalary, &ic_var),
.common_lookup_list = @as([*:null]?base.Segment, &common_var),
.leap_lookup_list = @as([*:null]?base.Segment, &leap_var),
.leap_cycle = .{
.year_count = 4,
.leap_year_count = 1,
.offset_years = 0,
.common_days = gen.dayCount(COMMON[0..COMMON.len]),
.leap_days = gen.leapDayCount(COMMON[0..COMMON.len], LEAP[0..LEAP.len]),
.offset_days = 0,
.skip100 = true,
.skip4000 = true,
.symmetric = false,
},
.week = .{
.start = @enumToInt(base.Weekday10.Primidi),
.length = gen.lastOfEnum(base.Weekday10),
.continuous = false,
},
.epoch_mjd = gen.mjdFromVcalc(-24160.5), //22 Sept, 1792 CE
.common_month_max = gen.monthMax(COMMON[0..COMMON.len]),
.leap_month_max = gen.monthMax(LEAP[0..LEAP.len]),
.year0 = true,
};
pub const french_revolutionary_romme_sub1 = base.Cal{
.intercalary_list = french_revolutionary_romme.intercalary_list,
.common_lookup_list = french_revolutionary_romme.common_lookup_list,
.leap_lookup_list = french_revolutionary_romme.leap_lookup_list,
.leap_cycle = .{
.year_count = french_revolutionary_romme.leap_cycle.year_count,
.leap_year_count = french_revolutionary_romme.leap_cycle.leap_year_count,
.offset_years = -1,
.common_days = french_revolutionary_romme.leap_cycle.common_days,
.leap_days = french_revolutionary_romme.leap_cycle.leap_days,
.offset_days = -365,
.skip100 = french_revolutionary_romme.leap_cycle.skip100,
.skip4000 = french_revolutionary_romme.leap_cycle.skip4000,
.symmetric = french_revolutionary_romme.leap_cycle.symmetric,
},
.week = french_revolutionary_romme.week,
.epoch_mjd = french_revolutionary_romme.epoch_mjd,
.common_month_max = french_revolutionary_romme.common_month_max,
.leap_month_max = french_revolutionary_romme.leap_month_max,
.year0 = french_revolutionary_romme.year0,
}; | src/cal/french_revolutionary.zig |
const expect = std.testing.expect;
const expectFmt = std.testing.expectFmt;
const std = @import("std");
test "if statement" {
const a = true;
var x: u16 = 0;
if (a) {
x += 1;
} else {
x += 2;
}
try expect(x == 1);
}
test "if statement expression" {
const a = true;
var x: u16 = 0;
x += if (a) 1 else 2;
try expect(x == 1);
}
test "while with continue expression" {
var sum: u8 = 0;
var i: u8 = 1;
while (i <= 10) : (i += 1) {
sum += i;
}
try expect(sum == 55);
}
test "for" {
const string = [_]u8{ 'a', 'b', 'c' };
for (string) |character, index| {
_ = character;
_ = index;
}
}
fn createFile() !void {
return error.AccessDenied;
}
test "@divExact" {
try expect(@divExact(6, 3) == 2);
}
test "out of bounds" {
@setRuntimeSafety(false);
const a = [3]u8{ 1, 2, 3 };
var index: u8 = 5;
const b = a[index];
_ = b;
}
fn increment(num: *u8) void {
num.* += 1;
}
test "pointers" {
var x: u8 = 1;
increment(&x);
try expect(x == 2);
}
fn total(values: []const u8) usize {
var sum: usize = 0;
for (values) |v| sum += v;
return sum;
}
test "slices" {
const array = [_]u8{ 1, 2, 3, 4, 5 };
const slice = array[0..3];
try expect(slice.len == 3);
try expect(total(slice) == 6);
}
test "slices 2" {
const array = [_]u8{ 1, 2, 3, 4, 5 };
const slice = array[0..3];
try expect(@TypeOf(slice) == *const [3]u8);
const _a: []const u8 = slice;
}
const Suit = enum {
clubs,
spades,
diamonds,
hearts,
pub fn isClubs(self: Suit) bool {
return self == Suit.clubs;
}
};
test "enum method" {
try expect(Suit.spades.isClubs() == Suit.isClubs(Suit.spades));
}
const Vec3 = struct { x: f32, y: f32, z: f32 };
test "struct usage" {
const my_verctor = Vec3{ .x = 0, .y = 100, .z = 50 };
_ = my_verctor;
}
const Vec4 = struct { x: f32, y: f32, z: f32 = 0, w: f32 = undefined };
test "struct defaults" {
const my_vector = Vec4{
.x = 25,
.y = -50,
};
_ = my_vector;
}
const Stuff = struct {
x: i32,
y: i32,
fn swap(self: *Stuff) void {
const tmp = self.x;
self.x = self.y;
self.y = tmp;
}
};
test "automatic dereference" {
var thing = Stuff{ .x = 10, .y = 20 };
thing.swap();
try expect(thing.x == 20);
try expect(thing.y == 10);
}
const Tagged = union(enum) { a: u8, b: f32, c: bool };
test "switch on tagged union" {
var value = Tagged{ .b = 1.5 };
switch (value) {
.a => |*byte| byte.* += 1,
.b => |*float| float.* *= 2,
.c => |*b| b.* = !b.*,
}
try expect(value.b == 3);
}
test "@intCast" {
const x: u64 = 200;
const y: u8 = @intCast(u8, x);
}
fn rangeHasNumber(begin: usize, end: usize, number: usize) bool {
var i = begin;
return while (begin < end) : (i += 1) {
if (i == number) break true;
} else false;
}
test "while loop experssion" {
try expect(rangeHasNumber(1, 10, 3));
}
test "expectFmt" {
var a = "expectFmt:abc\n";
const b = try std.fmt.allocPrint(std.testing.allocator, "{s}", .{a});
defer std.testing.allocator.free(b);
try expectFmt("aa..", "{s}..", .{"aa"});
std.debug.print("{s}", .{b});
}
test "if optional payload capture" {
const a: ?i32 = 5;
if (a != null) {
const value = a.?;
_ = value;
}
var b: ?i32 = 100;
if (b) |*value| {
value.* += 1;
}
try expect(b.? == 101);
}
fn fibonacci(n: u16) u16 {
if (n == 0 or n == 1) return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}
test "comptime blocks" {
var x = comptime fibonacci(10);
_ = x;
var y = comptime blk: {
break :blk fibonacci(10);
};
_ = y;
}
fn Matrix(comptime T: type, comptime width: comptime_int, comptime height: comptime_int) type {
return [height][width]T;
}
test "returning a type" {
try expect(Matrix(f32, 4, 4) == [4][4]f32);
}
fn addSmallInts(comptime T: type, a: T, b: T) T {
return switch (@typeInfo(T)) {
.ComptimeInt => a + b,
.Int => |info| if (info.bits <= 16) a + b else @compileError("ints too large"),
else => @compileError("only ints accepted"),
};
}
test "typeinfo switch" {
const x = addSmallInts(u16, 10, 10);
try expect(@TypeOf(x) == u16);
// std.debug.print("{}", @typeName(@TypeOf()))
}
fn GetBiggerInt(comptime T: type) type {
return @Type(.{
.Int = .{
.bits = @typeInfo(T).Int.bits + 1,
.signedness = @typeInfo(T).Int.signedness,
},
});
}
test "@type" {
try expect(GetBiggerInt(u8) == u9);
}
fn Vec(comptime count: comptime_int, comptime T: type) type {
return struct {
data: [count]T,
const Self = @This();
fn abs(self: Self) Self {
var tmp = Self{ .data = undefined };
for (self.data) |elem, i| {
tmp.data[i] = if (elem < 0) -elem else elem;
}
return tmp;
}
fn init(data: [count]T) Self {
return Self{ .data = data };
}
};
}
const eql = std.mem.eql;
test "generic vector" {
const x = Vec(3, f32).init([_]f32{ 10, -10, 5 });
const y = x.abs();
try expect(eql(f32, &y.data, &[_]f32{ 10, 10, 5 }));
}
var numbers_left2: u32 = undefined;
fn eventuallyErrorSequence() error{RZ}!u32 {
return if (numbers_left2 == 0) error.RZ else blk: {
numbers_left2 -= 1;
break :blk numbers_left2;
};
}
test "while error union capture" {
var sum: u32 = 0;
numbers_left2 = 3;
while (eventuallyErrorSequence()) |value| {
sum += value;
} else |err| {
try expect(err == error.RZ);
}
} | zig/learn/basics_test.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = false;
const with_dissassemble = false;
const assert = std.debug.assert;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const Vec2 = tools.Vec2;
const Computer = tools.IntCode_Computer;
const Map = tools.Map(u8, 1024 * 2, 1024 * 2, false);
fn cpu_request(cpu: *Computer, boot_image: []const Computer.Data, in: Vec2) bool {
cpu.boot(boot_image);
trace("starting {}\n", .{cpu.name});
_ = async cpu.run();
assert(cpu.io_mode == .input);
cpu.io_port = in.x;
trace("wrting input to {} = {}\n", .{ cpu.name, cpu.io_port });
resume cpu.io_runframe;
assert(cpu.io_mode == .input);
cpu.io_port = in.y;
trace("wrting input to {} = {}\n", .{ cpu.name, cpu.io_port });
resume cpu.io_runframe;
assert(cpu.io_mode == .output);
trace("{} outputs {}\n", .{ cpu.name, cpu.io_port });
const ret = (cpu.io_port != 0);
resume cpu.io_runframe;
assert(cpu.is_halted());
return ret;
}
fn request_canfit(cpu: *Computer, boot_image: []const Computer.Data, map: *Map, pos: Vec2, size: Vec2) enum {
out,
partial,
in,
} {
{
const p = Vec2{ .x = pos.x, .y = pos.y + size.y - 1 };
var m = map.get(p) orelse ' ';
if (m == ' ') {
const is_affected = cpu_request(cpu, boot_image, p);
m = if (is_affected) '#' else '.';
map.set(p, m);
}
if (m == '.')
return .out;
}
{
const p = Vec2{ .x = pos.x + size.x - 1, .y = pos.y };
var m = map.get(p) orelse ' ';
if (m == ' ') {
const is_affected = cpu_request(cpu, boot_image, p);
m = if (is_affected) '#' else '.';
map.set(p, m);
}
if (m == '.')
return .partial;
}
{
const p = Vec2{ .x = pos.x, .y = pos.y };
var m = map.get(p) orelse ' ';
if (m == ' ') {
const is_affected = cpu_request(cpu, boot_image, p);
m = if (is_affected) '#' else '.';
map.set(p, m);
}
assert(m == '#');
if (m == '.')
return .out;
}
return .in;
}
pub fn run(input: []const u8, allocator: std.mem.Allocator) tools.RunError![2][]const u8 {
const int_count = blk: {
var int_count: usize = 0;
var it = std.mem.split(u8, input, ",");
while (it.next()) |_| int_count += 1;
break :blk int_count;
};
const boot_image = try allocator.alloc(Computer.Data, int_count);
defer allocator.free(boot_image);
{
var it = std.mem.split(u8, input, ",");
var i: usize = 0;
while (it.next()) |n_text| : (i += 1) {
const trimmed = std.mem.trim(u8, n_text, " \n\r\t");
boot_image[i] = try std.fmt.parseInt(Computer.Data, trimmed, 10);
}
}
if (with_dissassemble)
Computer.disassemble(boot_image);
var cpu = Computer{
.name = "Drone",
.memory = try allocator.alloc(Computer.Data, 5000),
};
defer allocator.free(cpu.memory);
var map = try allocator.create(Map);
defer allocator.destroy(map);
map.default_tile = ' ';
map.bbox = tools.BBox.empty;
var affected = blk: {
var affected: u32 = 0;
var cursor = Vec2{ .x = 0, .y = 0 };
cursor.y = 0;
while (cursor.y < 50) : (cursor.y += 1) {
cursor.x = 0;
while (cursor.x < 50) : (cursor.x += 1) {
const is_affected = cpu_request(&cpu, boot_image, cursor);
map.set(cursor, if (is_affected) '#' else '.');
if (is_affected)
affected += 1;
}
}
//{
// var buf: [15000]u8 = undefined;
// std.debug.print("{s}\n", .{map.printToBuf(cursor, null, null, &buf)});
//}
trace("affected: {}\n", .{affected});
break :blk affected;
};
const answer = blk: {
var cursor = Vec2{ .x = 1300, .y = 750 };
var lineref: ?Vec2 = null;
while (true) {
const fits = request_canfit(&cpu, boot_image, map, cursor, Vec2{ .x = 100, .y = 100 });
if (fits == .in)
break;
if (lineref != null and fits == .out) {
trace("Trying {}-{}\n", .{ lineref, cursor });
cursor = Vec2{ .x = lineref.?.x, .y = lineref.?.y + 1 };
lineref = null;
} else if (lineref == null and fits != .out) {
lineref = cursor;
} else {
cursor.x += 1;
}
}
trace("fits @ {} : {}\n", .{ cursor, cursor.x * 10000 + cursor.y });
break :blk cursor.x * 10000 + cursor.y;
};
return [_][]const u8{
try std.fmt.allocPrint(allocator, "{}", .{affected}),
try std.fmt.allocPrint(allocator, "{}", .{answer}),
};
}
pub const main = tools.defaultMain("2019/day19.txt", run); | 2019/day19.zig |
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
const std = @import("std");
const math = std.math;
const meta = std.meta;
const assert = std.debug.assert;
const warn = std.debug.warn;
const bufPrint = std.fmt.bufPrint;
const testExpected = @import("testexpected.zig").testExpected;
const ae = @import("../modules/zig-approxEql/approxeql.zig");
const v = @import("vec.zig");
const DBG = false;
pub fn Matrix(comptime T: type, comptime m: usize, comptime n: usize) type {
return struct {
const Self = @This();
const row_cnt = m;
const col_cnt = n;
pub data: [m][n]T,
/// Create an uninitialized Matrix
pub fn create() Self {
return Self{ .data = undefined };
}
/// Initialize Matrix to a value
pub fn initVal(val: T) Self {
var r = Self.create();
return r.visit(fillFunc, val).*;
}
/// Initialize Matrix as a Unit matrix with 1's on the diagonal
pub fn initUnit() Self {
var r = Self.create();
return r.visit(unitFunc, 0).*;
}
/// Return true of pSelf.data == pOther.data
pub fn eql(pSelf: *const Self, pOther: *const Self) bool {
for (pSelf.data) |row, i| {
for (row) |val, j| {
if (val != pOther.data[i][j]) return false;
}
}
return true;
}
/// Visit each matrix value starting at [0][0], [0][1] .. [m][n]
/// calling func for each passing the Matrix and current i, j plus
/// the parameter. To continue looping func returns true or false
/// to stop looping.
pub fn visit(
pSelf: *Self,
comptime func: fn (pSelf: *Self, i: usize, j: usize, param: var) bool,
param: var,
) *Self {
// Unroll the loops for speed
comptime var i: usize = 0;
done: inline while (i < m) : (i += 1) {
//warn("visit {}:", i);
comptime var j: usize = 0;
inline while (j < n) : (j += 1) {
if (!func(pSelf, i, j, param)) {
break :done;
}
//warn(" {}", pSelf.data[i][j]);
}
//warn("\n");
}
return pSelf;
}
/// Custom format routine for Mat4x4
pub fn format(
self: *const Self,
comptime fmt: []const u8,
context: var,
comptime FmtError: type,
output: fn (@typeOf(context), []const u8) FmtError!void,
) FmtError!void {
for (self.data) |row, i| {
try std.fmt.format(context, FmtError, output, "[]{}.{{ ", @typeName(T));
for (row) |col, j| {
switch (@typeId(T)) {
TypeId.Float => try std.fmt.format(context, FmtError, output, "{.7}{}", col, if (j < (col_cnt - 1)) ", " else " "),
TypeId.Int => try std.fmt.format(context, FmtError, output, "{}{}", col, if (j < (col_cnt - 1)) ", " else " "),
else => @compileError("Only Float and Int types are supported"),
}
}
try std.fmt.format(context, FmtError, output, "}}");
if (row_cnt > 1) {
if (i < (row_cnt - 1)) {
try std.fmt.format(context, FmtError, output, ",\n");
} else {
try std.fmt.format(context, FmtError, output, ",");
}
}
}
}
fn unitFunc(pSelf: *Self, i: usize, j: usize, param: var) bool {
pSelf.data[i][j] = if (i == j) T(1) else T(0);
return true;
}
fn fillFunc(pSelf: *Self, i: usize, j: usize, param: var) bool {
pSelf.data[i][j] = param;
return true;
}
};
}
/// Returns a struct.mul function that multiplies m1 by m2
pub fn MatrixMultiplier(comptime m1: type, comptime m2: type) type {
const m1_DataType = @typeInfo(@typeInfo(meta.fieldInfo(m1, "data").field_type).Array.child).Array.child;
const m2_DataType = @typeInfo(@typeInfo(meta.fieldInfo(m2, "data").field_type).Array.child).Array.child;
// What other validations should I check
if (m1_DataType != m2_DataType) {
@compileError("m1:" ++ @typeName(m1_DataType) ++ " != m2:" ++ @typeName(m2_DataType));
}
if (m1.col_cnt != m2.row_cnt) {
@compileError("m1.col_cnt: m1.col_cnt != m2.row_cnt");
}
const DataType = m1_DataType;
const row_cnt = m1.row_cnt;
const col_cnt = m2.col_cnt;
return struct {
pub fn mul(mt1: *const m1, mt2: *const m2) Matrix(DataType, row_cnt, col_cnt) {
var r = Matrix(DataType, row_cnt, col_cnt).create();
comptime var i: usize = 0;
inline while (i < row_cnt) : (i += 1) {
//warn("mul {}:\n", i);
comptime var j: usize = 0;
inline while (j < col_cnt) : (j += 1) {
//warn(" ({}:", j);
comptime var k: usize = 0;
// The inner loop is m1.col_cnt or m2.row_cnt, which are equal
inline while (k < m1.col_cnt) : (k += 1) {
var val = mt1.data[i][k] * mt2.data[k][j];
if (k == 0) {
r.data[i][j] = val;
//warn(" {}:{}={} * {}", k, val, mt1.data[i][k], mt2.data[k][j]);
} else {
r.data[i][j] += val;
//warn(" {}:{}={} * {}", k, val, mt1.data[i][k], mt2.data[k][j]);
}
}
//warn(" {})\n", r.data[i][j]);
}
}
return r;
}
};
}
pub const M44f32 = Matrix(f32, 4, 4);
pub const m44f32_unit = M44f32.initUnit();
pub const m44f32_zero = M44f32.initVal(0);
test "matrix.init" {
if (DBG) warn("\n");
const mf32 = Matrix(f32, 4, 4).initVal(1);
if (DBG) warn("matrix.init: m4x4f32 init(1)\n{}", &mf32);
for (mf32.data) |row| {
for (row) |val| {
assert(val == 1);
}
}
const mf64 = Matrix(f64, 4, 4).initUnit();
if (DBG) warn("matrix.init: mf64 initUnit\n{}", &mf64);
for (mf64.data) |row, i| {
for (row) |val, j| {
if (i == j) {
assert(val == 1);
} else {
assert(val == 0);
}
}
}
// Maybe initUnit shouldn't allow non-square values
// See test "initUnit" for a possible solution
const m2x4 = Matrix(f32, 2, 4).initUnit();
if (DBG) warn("2x4: initUnit\n{}", &m2x4);
for (m2x4.data) |row, i| {
for (row) |val, j| {
if (i == j) {
assert(val == 1);
} else {
assert(val == 0);
}
}
}
}
// Example of using visit outside of Matrix
// to create a unit matrix.
//
// I'm not completely happy with this as M1x1 in this
// example needed to be declared globally.
test "initUnit" {
var m1x1 = M1x1.create();
initUnit(&m1x1);
if (DBG) warn("matrix.initUnit: 1x1 initUnit\n{}", &m1x1);
const t1x1 = M1x1.initUnit();
assert(m1x1.eql(&t1x1));
}
// Define the Matrix globaly so unitFunc can know the type
const M1x1 = Matrix(f32, 1, 1);
// Initialize Matrix as a Unit matrix with 1's on the diagonal
pub fn initUnit(pMat: var) void {
comptime const T = @typeOf(pMat.*);
comptime if (T.row_cnt != T.col_cnt) @compileError("initUnit can't be used on non-square Matrix's");
_ = T.visit(pMat, unitFunc, 0);
}
fn unitFunc(pMat: *M1x1, i: usize, j: usize, param: var) bool {
const T = @typeInfo(@typeInfo(meta.fieldInfo(@typeOf(pMat.*), "data").field_type).Array.child).Array.child;
pMat.data[i][j] = if (i == j) T(1) else T(0);
return true;
}
//test "initUnit.fails" {
// var m4x2 = Matrix(f32, 4, 2).create();
// initUnit(&m4x2);
// if (DBG) warn("matrix.initUnit.fails: 4x2 initUnit\n{}", m4x2);
//}
test "matrix.eql" {
if (DBG) warn("\n");
const m0 = Matrix(f32, 4, 4).initVal(0);
for (m0.data) |row| {
for (row) |val| {
assert(val == 0);
}
}
var o0 = Matrix(f32, 4, 4).initVal(0);
assert(m0.eql(&o0));
// Modify last value and verify !eql
o0.data[3][3] = 1;
if (DBG) warn("matrix.eql: o0\n{}", &o0);
assert(!m0.eql(&o0));
// Modify first value and verify !eql
o0.data[0][0] = 1;
if (DBG) warn("matrix.eql: o0\n{}", &o0);
assert(!m0.eql(&o0));
// Restore back to 0 and verify eql
o0.data[3][3] = 0;
o0.data[0][0] = 0;
if (DBG) warn("matrix.eql: o0\n{}", &o0);
assert(m0.eql(&o0));
}
test "matrix.1x1*1x1" {
if (DBG) warn("\n");
const m1 = Matrix(f32, 1, 1).initVal(2);
if (DBG) warn("matrix.1x1*1x1: m1\n{}", &m1);
const m2 = Matrix(f32, 1, 1).initVal(3);
if (DBG) warn("matrix.1x1*1x1: m2\n{}", &m2);
const m3 = MatrixMultiplier(@typeOf(m1), @typeOf(m2)).mul(&m1, &m2);
if (DBG) warn("matrix.1x1*1x1: m3\n{}", &m3);
var expected = Matrix(f32, 1, 1).create();
expected.data = [][1]f32{[]f32{(m1.data[0][0] * m2.data[0][0])}};
if (DBG) warn("matrix.1x1*1x1: expected\n{}", &expected);
assert(m3.eql(&expected));
}
test "matrix.2x2*2x2" {
if (DBG) warn("\n");
var m1 = Matrix(f32, 2, 2).create();
m1.data = [][2]f32{
[]f32{ 1, 2 },
[]f32{ 3, 4 },
};
if (DBG) warn("matrix.2x2*2x2: m1\n{}", &m1);
var m2 = Matrix(f32, 2, 2).create();
m2.data = [][2]f32{
[]f32{ 5, 6 },
[]f32{ 7, 8 },
};
if (DBG) warn("matrix.2x2*2x2: m2\n{}", &m2);
const m3 = MatrixMultiplier(@typeOf(m1), @typeOf(m2)).mul(&m1, &m2);
if (DBG) warn("matrix.2x2*2x2: m3\n{}", &m3);
var expected = Matrix(f32, 2, 2).create();
expected.data = [][2]f32{
[]f32{
(m1.data[0][0] * m2.data[0][0]) + (m1.data[0][1] * m2.data[1][0]),
(m1.data[0][0] * m2.data[0][1]) + (m1.data[0][1] * m2.data[1][1]),
},
[]f32{
(m1.data[1][0] * m2.data[0][0]) + (m1.data[1][1] * m2.data[1][0]),
(m1.data[1][0] * m2.data[0][1]) + (m1.data[1][1] * m2.data[1][1]),
},
};
if (DBG) warn("matrix.2x2*2x2: expected\n{}", &expected);
assert(m3.eql(&expected));
}
test "matrix.1x2*2x1" {
if (DBG) warn("\n");
var m1 = Matrix(f32, 1, 2).create();
m1.data = [][2]f32{[]f32{ 3, 4 }};
if (DBG) warn("matrix.1x2*2x1: m1\n{}", &m1);
var m2 = Matrix(f32, 2, 1).create();
m2.data = [][1]f32{
[]f32{5},
[]f32{7},
};
if (DBG) warn("matrix.1x2*2x1: m2\n{}", &m2);
const m3 = MatrixMultiplier(@typeOf(m1), @typeOf(m2)).mul(&m1, &m2);
if (DBG) warn("matrix.1x2*2x1: m3\n{}", &m3);
var expected = Matrix(f32, 1, 1).create();
expected.data = [][1]f32{[]f32{(m1.data[0][0] * m2.data[0][0]) + (m1.data[0][1] * m2.data[1][0])}};
if (DBG) warn("matrix.1x2*2x1: expected\n{}", &expected);
assert(m3.eql(&expected));
}
test "matrix.i32.1x2*2x1" {
if (DBG) warn("\n");
var m1 = Matrix(i32, 1, 2).create();
m1.data = [][2]i32{[]i32{ 3, 4 }};
if (DBG) warn("matrix.i32.1x2*2x1: m1\n{}", &m1);
var m2 = Matrix(i32, 2, 1).create();
m2.data = [][1]i32{
[]i32{5},
[]i32{7},
};
if (DBG) warn("matrix.i32.1x2*2x1: m2\n{}", &m2);
const m3 = MatrixMultiplier(@typeOf(m1), @typeOf(m2)).mul(&m1, &m2);
if (DBG) warn("matrix.i32.1x2*2x1: m3\n{}", &m3);
var expected = Matrix(i32, 1, 1).create();
expected.data = [][1]i32{[]i32{(m1.data[0][0] * m2.data[0][0]) + (m1.data[0][1] * m2.data[1][0])}};
if (DBG) warn("matrix.i32.1x2*2x1: expected\n{}", &expected);
assert(m3.eql(&expected));
}
test "matrix.format.f32" {
var buf: [256]u8 = undefined;
const v2 = Matrix(f32, 1, 2).initVal(2);
var result = try bufPrint(buf[0..], "v2={}", v2);
if (DBG) warn("\nmatrix.format: {}\n", result);
try testExpected("v2=[]f32.{ 2.0000000, 2.0000000 }", result);
const v3 = Matrix(f32, 3, 3).initVal(4);
result = try bufPrint(buf[0..], "v3\n{}", v3);
if (DBG) warn("matrix.format: {}\n", result);
try testExpected(
\\v3
\\[]f32.{ 4.0000000, 4.0000000, 4.0000000 },
\\[]f32.{ 4.0000000, 4.0000000, 4.0000000 },
\\[]f32.{ 4.0000000, 4.0000000, 4.0000000 },
, result);
}
test "matrix.format.i32" {
var buf: [100]u8 = undefined;
const v2 = Matrix(i32, 1, 2).initVal(2);
var result = try bufPrint(buf[0..], "v2={}", v2);
if (DBG) warn("\nmatrix.format: {}\n", result);
try testExpected("v2=[]i32.{ 2, 2 }", result);
const v3 = Matrix(i32, 3, 3).initVal(4);
result = try bufPrint(buf[0..], "v3\n{}", v3);
if (DBG) warn("matrix.format: {}\n", result);
try testExpected(
\\v3
\\[]i32.{ 4, 4, 4 },
\\[]i32.{ 4, 4, 4 },
\\[]i32.{ 4, 4, 4 },
, result);
}
/// Return true of pSelf.data == pOther.data
pub fn approxEql(pSelf: var, pOther: var, digits: usize) bool {
for (pSelf.data) |row, i| {
for (row) |val, j| {
if (!ae.approxEql(val, pOther.data[i][j], digits)) return false;
}
}
return true;
}
test "matrix.approxEql" {
if (DBG) warn("\n");
const m0 = Matrix(f32, 4, 4).initVal(1.234567);
const m1 = Matrix(f32, 4, 4).initVal(1.234578);
assert(approxEql(&m0, &m1, 1));
assert(approxEql(&m0, &m1, 2));
assert(approxEql(&m0, &m1, 3));
assert(approxEql(&m0, &m1, 4));
assert(approxEql(&m0, &m1, 5));
assert(!approxEql(&m0, &m1, 6));
assert(!approxEql(&m0, &m1, 7));
assert(!approxEql(&m0, &m1, 8));
}
/// Creates a perspective project matrix
/// BasedOn: https://github.com/sharpdx/SharpDX/blob/755cb46d59f4bfb94386ff2df3fceccc511c216b/Source/SharpDX.Mathematics/Matrix.cs#L2328
/// and: https://www.scratchapixel.com/code.php?id=4&origin=/lessons/3d-basic-rendering/perspective-and-orthographic-projection-matrix
pub fn perspectiveM44(comptime T: type, fovDegrees: T, aspect: T, znear: T, zfar: T) Matrix(T, 4, 4) {
var scale: T = 1.0 / math.tan(T(fovDegrees * math.pi / 180.0) * 0.5);
var q = -zfar / (zfar - znear);
return Matrix(T, 4, 4){ .data = [][4]T{
[]T{ scale / aspect, 0, 0, 0 },
[]T{ 0, scale, 0, 0 },
[]T{ 0, 0, q, -1.0 },
[]T{ 0, 0, q * znear, 0 },
} };
}
test "matrix.perspectiveM44" {
const T = f32;
const M44 = Matrix(T, 4, 4);
const fov: T = 90;
const widthf: T = 512;
const heightf: T = 512;
const aspect: T = widthf / heightf;
const znear: T = 0.01;
const zfar: T = 1.0;
var camera_to_perspective_matrix = perspectiveM44(T, fov, aspect, znear, zfar);
var expected: M44 = undefined;
expected.data = [][4]T{
[]T{ 1, 0, 0, 0 },
[]T{ 0, 1, 0, 0 },
[]T{ 0, 0, -1.01010, -1 },
[]T{ 0, 0, -0.01010, 0 },
};
assert(approxEql(&camera_to_perspective_matrix, &expected, 5));
} | src/matrix.zig |
const std = @import("std");
const test_allocator = std.testing.allocator;
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const data = @embedFile("input.txt");
fn main_1(input: []const u8) anyerror!void {
var lines = tokenize(u8, input, "\r\n");
var counts = [1]isize{0} ** 12;
while(lines.next()) |bin| {
for(bin) |b, idx| {
if(b == '1'){
counts[idx] += 1;
} else {
counts[idx] -= 1;
}
}
}
var gamma: u12 = 0;
for(counts) |count, idx| {
if(count > 0) {
gamma |= @as(u12, 1) << @intCast(u4, idx);
}
}
gamma = @bitReverse(u12, gamma);
std.log.info("Gamma: {b:0>12}", .{ gamma });
std.log.info("Epsilon: {b:0>12}", . { ~gamma });
std.log.info("result: {}", . { gamma * @as(u64,~gamma) });
}
fn most_common_bit(a: [][]const u8, size: usize, bit_position: u8, most: bool) u8 {
var count: isize = 0;
for(a) |n, i| {
if(i >= size){
break;
}
if(n[bit_position] == '1'){
count += 1;
}else {
count -= 1;
}
}
if(count >= 0) {
if(most) return '1' else return '0';
} else {
if(most) return '0' else return '1';
}
}
fn criteria(numbers: [][]const u8, size: usize, most: bool) ?[]const u8 {
var bit_position:u8 = 0;
var remaining: usize = size;
while(remaining > 1){
var common = most_common_bit(numbers, remaining, bit_position, most);
var i: usize = 0;
while(i <= remaining) {
if(remaining == 1){
break;
}
while(numbers[i][bit_position] != common) {
if(i >= remaining) break;
numbers[i] = numbers[remaining - 1];
remaining -= 1;
}
i += 1;
}
bit_position += 1;
}
return numbers[0];
}
fn main_2(input: []const u8) anyerror!u64 {
var lines = tokenize(u8, input, "\r\n");
var oxygen: [1000][]const u8 = undefined;
var co2: [1000][]const u8 = undefined;
var count: usize = 0;
while(lines.next()) |line| {
oxygen[count] = line;
co2[count] = line;
count += 1;
}
std.log.info("count {}", .{ count });
var oxygen_str = criteria(&oxygen, count, true);
var co2_str = criteria(&co2, count,false);
var result:u64 = (try std.fmt.parseInt(u64, oxygen_str.?, 2)) * (try std.fmt.parseInt(u64, co2_str.?, 2));
std.log.info("oxygen {s}", .{ oxygen_str });
std.log.info("co2 {s}", . { co2_str });
return result;
}
pub fn main() anyerror!void {
// try main_1();
var result = try main_2(data);
std.log.info("result {}", . { result });
}
test "example" {
const input = @embedFile("test.txt");
const result = try main_2(input);
std.log.info("result {}", .{ result });
try std.testing.expectEqual(@as(u64, 230), result);
} | src/day03/main.zig |
const std = @import("std");
const bytesAsSlice = std.mem.bytesAsSlice;
const utils = @import("utils");
const Guid = utils.Guid;
const io = @import("io.zig");
const constant_guids = @import("constant_guids.zig");
pub const Error = error {
InvalidMbr,
InvalidGptHeader,
} || Guid.Error || io.BlockError;
pub const Mbr = struct {
const Part = packed struct {
status: u8,
chs_start: u24,
partition_type: u8,
chs_end: u24,
lba_start: u32,
sector_count: u32,
};
const magic: u16 = 0xaa55;
const gpt_protective_type: u8 = 0xEE;
signature: u32 = undefined,
partitions: [4]Part = undefined,
gpt_protective: bool = undefined,
pub fn new(block: []const u8) Error!Mbr {
var mbr = Mbr{};
// Check MBR "Boot Signature" (magic)
if (bytesAsSlice(u16, block)[255] != magic) {
return Error.InvalidMbr;
}
mbr.signature = bytesAsSlice(u32, block)[110];
const partitions = @ptrCast([*]const Part,
@alignCast(@alignOf(Part), &block[446]))[0..4];
for (partitions) |*partition, i| {
mbr.partitions[i] = partition.*;
}
mbr.gpt_protective =
partitions[0].partition_type == gpt_protective_type;
return mbr;
}
};
pub const Partition = struct {
type_guid: Guid,
start: io.AddressType,
end: io.AddressType,
pub fn is_linux(self: *const Partition) bool {
return self.type_guid.equals(&constant_guids.linux_partition_type);
}
};
pub const Disk = struct {
const magic = "EFI PART";
block_store: *io.BlockStore = undefined,
guid: Guid = undefined,
partition_entries_lba: io.AddressType = undefined,
partition_entry_size: usize = undefined,
pub fn new(block_store: *io.BlockStore) Error!Disk {
var disk = Disk{.block_store = block_store};
// Check to see if there's a MBR and it says this is a GPT disk.
var mbr_block = io.Block{.address = 0};
try block_store.read_block(&mbr_block);
defer (block_store.free_block(&mbr_block) catch unreachable);
const mbr = try Mbr.new(mbr_block.data.?);
if (!mbr.gpt_protective) {
return Error.InvalidGptHeader;
}
// Get GPT Header Block
var gpt_block = io.Block{.address = 1};
try block_store.read_block(&gpt_block);
defer (block_store.free_block(&gpt_block) catch unreachable);
const block = gpt_block.data.?;
// Check Magic
for (block[0..magic.len]) |*ptr, i| {
if (ptr.* != magic[i]) {
return Error.InvalidGptHeader;
}
}
// Get Info
try disk.guid.from_ms(block[0x38..0x48]);
disk.partition_entries_lba = @as(io.AddressType,
bytesAsSlice(u64, block[0x48..0x50])[0]);
disk.partition_entry_size = bytesAsSlice(u32, block[0x54..0x58])[0];
return disk;
}
pub fn partitions(self: *const Disk) Error!PartitionIterator {
var it = PartitionIterator{
.block_store = self.block_store,
.block = io.Block{.address = self.partition_entries_lba},
.entry_size = self.partition_entry_size,
};
try self.block_store.read_block(&it.block);
return it;
}
pub const PartitionIterator = struct {
offset: usize = 0,
block_store: *io.BlockStore,
block: io.Block,
entry_size: usize,
pub fn next(self: *PartitionIterator) Error!?Partition {
var partition: Partition = undefined;
if (self.offset >= self.block.data.?.len) {
self.block.address += 1;
try self.block_store.read_block(&self.block);
self.offset = 0;
}
const id_offset = self.offset + 16;
try partition.type_guid.from_ms(self.block.data.?[self.offset..id_offset]);
if (partition.type_guid.is_null()) {
return null;
}
const start_lba_offset = id_offset + 16;
const end_lba_offset = start_lba_offset + 8;
partition.start = @as(io.AddressType,
bytesAsSlice(u64, self.block.data.?[start_lba_offset..end_lba_offset])[0]);
const attributes_offset = end_lba_offset + 8;
partition.end = @as(io.AddressType,
bytesAsSlice(u64, self.block.data.?[end_lba_offset..attributes_offset])[0]);
const name_offset = attributes_offset + 8;
const supported_end = name_offset + 72;
// Add any ammount we are over the entry size
self.offset = supported_end + self.entry_size - (supported_end - self.offset);
return partition;
}
pub fn done(self: *PartitionIterator) Error!void {
try self.block_store.free_block(&self.block);
}
};
}; | kernel/gpt.zig |
const std = @import("std");
const builtin = @import("builtin");
const clap = @import("clap");
const curl = @import("curl");
const Dependency = @import("Dependency.zig");
const cmds = @import("commands.zig");
const loadSystemCerts = @import("certs.zig").loadSystemCerts;
const Display = @import("Display.zig");
const utils = @import("utils.zig");
const c = @cImport({
@cInclude("git2.h");
@cInclude("mbedtls/debug.h");
});
export fn gai_strerrorA(err: c_int) [*c]u8 {
_ = err;
return null;
}
extern fn git_mbedtls__insecure() void;
extern fn git_mbedtls__set_debug() void;
pub const log_level: std.log.Level = if (builtin.mode == .Debug) .debug else .info;
pub var display: Display = undefined;
pub fn log(
comptime level: std.log.Level,
comptime scope: @TypeOf(.EnumLiteral),
comptime format: []const u8,
args: anytype,
) void {
display.log(level, scope, format, args);
}
pub fn main() !void {
var exit_val: u8 = 0;
{
const allocator = std.heap.c_allocator;
try Display.init(&display, allocator);
defer display.deinit();
try curl.globalInit();
defer curl.globalCleanup();
if (builtin.mode == .Debug)
c.mbedtls_debug_set_threshold(1);
const rc = c.git_libgit2_init();
if (rc < 0) {
const last_error = c.git_error_last();
std.log.err("{s}", .{last_error.*.message});
return error.Libgit2Init;
}
defer _ = c.git_libgit2_shutdown();
try loadSystemCerts(allocator);
if (!(builtin.target.os.tag == .linux) or std.process.hasEnvVarConstant("GYRO_INSECURE"))
git_mbedtls__insecure();
runCommands(allocator) catch |err| {
switch (err) {
error.Explained => exit_val = 1,
else => return err,
}
};
}
std.process.exit(exit_val);
}
// prints gyro command usage to stderr
fn usage() !void {
const stderr = std.io.getStdErr().writer();
try stderr.writeAll("Usage: gyro [command] [options]\n\n");
try stderr.writeAll("Commands:\n\n");
inline for (all_commands) |cmd| {
try stderr.print(" {s: <10} {s}\n", .{ cmd.name, cmd.summary });
}
try stderr.writeAll("\nOptions:\n\n");
try stderr.print(" {s: <10} Print command-specific usage\n\n", .{"-h, --help"});
}
// prints usage and help for a single command
fn help(comptime command: completion.Command) !void {
const stderr = std.io.getStdErr().writer();
try stderr.writeAll("Usage: gyro " ++ command.name ++ " ");
try clap.usage(stderr, command.clap_params);
try stderr.writeAll("\n\nOptions:\n\n");
try clap.help(stderr, command.clap_params);
try stderr.writeAll("\n");
}
fn runCommands(allocator: std.mem.Allocator) !void {
const stderr = std.io.getStdErr().writer();
var iter = try std.process.ArgIterator.initWithAllocator(allocator);
defer iter.deinit();
// skip process name
_ = iter.next();
const command_name = (iter.next()) orelse {
try usage();
std.log.err("expected command argument", .{});
return error.Explained;
};
inline for (all_commands) |cmd| {
if (std.mem.eql(u8, command_name, cmd.name)) {
var args: cmd.parent.Args = if (!cmd.passthrough) blk: {
var diag = clap.Diagnostic{};
var ret = cmd.parent.Args.parse(&iter, .{ .diagnostic = &diag }) catch |err| {
try diag.report(stderr, err);
try help(cmd);
return error.Explained;
};
if (ret.flag("--help")) {
try help(cmd);
return;
}
break :blk ret;
} else undefined;
defer if (!cmd.passthrough) args.deinit();
try cmd.parent.run(allocator, &args, &iter);
return;
}
} else {
try usage();
std.log.err("{s} is not a valid command", .{command_name});
return error.Explained;
}
}
const completion = @import("completion.zig");
pub const all_commands = blk: {
var list: []const completion.Command = &[_]completion.Command{};
for (std.meta.declarations(commands)) |decl| {
list = list ++ [_]completion.Command{
@field(commands, decl.name).info,
};
}
break :blk list;
};
pub const commands = struct {
pub const init = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("init", "Initialize a gyro.zzz with a link to a github repo", init);
cmd.addFlag('h', "help", "Display help");
cmd.addPositional("repo", ?completion.Param.Repository, .one, "The repository to initialize this project with");
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, args: *Args, _: *std.process.ArgIterator) !void {
const num = args.positionals().len;
if (num > 1) {
std.log.err("that's too many args, please just give me one in the form of a link to your github repo or just '<user>/<repo>'", .{});
return error.Explained;
}
const repo = if (num == 1) args.positionals()[0] else null;
try cmds.init(allocator, repo);
}
};
pub const add = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("add", "Add dependencies to the project", add);
cmd.addFlag('h', "help", "Display help");
cmd.addOption('s', "src", "kind", enum { pkg, github, url, local }, "Set type of dependency, one of pkg, github, url, or local");
cmd.addOption('a', "alias", "package", completion.Param.Package, "Override what string the package is imported with");
cmd.addFlag('b', "build-dep", "Add this as a build dependency");
cmd.addOption('r', "root", "file", completion.Param.File, "Set root path with respect to the project root, default is 'src/main.zig'");
cmd.addOption('c', "ref", "file", completion.Param.File, "commit, tag, or branch to reference for git or github source types");
cmd.addOption('p', "repository", "repo", ?completion.Param.Repository, "The package repository you want to add a package from, default is " ++ utils.default_repo);
cmd.addPositional("package", completion.Param.Package, .one, "The package to add");
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, args: *Args, _: *std.process.ArgIterator) !void {
const src_str = args.option("--src") orelse "pkg";
const src_tag = inline for (std.meta.fields(Dependency.SourceType)) |field| {
if (std.mem.eql(u8, src_str, field.name))
break @field(Dependency.SourceType, field.name);
} else {
std.log.err("{s} is not a valid source type", .{src_str});
return error.Explained;
};
try cmds.add(
allocator,
src_tag,
args.option("--alias"),
args.flag("--build-dep"),
args.option("--ref"),
args.option("--root"),
args.option("--repository"),
args.positionals()[0],
);
}
};
pub const rm = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("rm", "Remove dependencies from the project", rm);
cmd.addFlag('h', "help", "Display help");
cmd.addFlag('b', "build-dep", "Remove this as a build dependency");
cmd.addPositional("package", completion.Param.Package, .many, "The package(s) to remove");
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, args: *Args, _: *std.process.ArgIterator) !void {
try cmds.rm(allocator, args.flag("--build-dep"), args.positionals());
}
};
pub const build = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("build", "Wrapper around 'zig build', automatically downloads dependencies", build);
cmd.addFlag('h', "help", "Display help");
cmd.addPositional("args", void, .many, "arguments to pass to zig build");
cmd.passthrough = true;
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, _: *Args, iterator: *std.process.ArgIterator) !void {
try cmds.build(allocator, iterator);
}
};
pub const fetch = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("fetch", "Manually download dependencies and generate deps.zig file", fetch);
cmd.addFlag('h', "help", "Display help");
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, _: *Args, iterator: *std.process.ArgIterator) !void {
_ = iterator;
try cmds.fetch(allocator);
}
};
pub const update = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("update", "Update project dependencies to latest", update);
cmd.addFlag('h', "help", "Display help");
cmd.addPositional("package", ?completion.Param.Package, .many, "The package(s) to update");
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, args: *Args, _: *std.process.ArgIterator) !void {
try cmds.update(allocator, args.positionals());
}
};
pub const publish = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("publish", "Publish package to astrolabe.pm, requires github account", publish);
cmd.addFlag('h', "help", "Display help");
cmd.addPositional("package", ?completion.Param.Package, .one, "The package to publish");
cmd.addOption('r', "repository", "repo", ?completion.Param.Repository, "The package repository you want to publish to, default is " ++ utils.default_repo);
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, args: *Args, _: *std.process.ArgIterator) !void {
try cmds.publish(
allocator,
args.option("--repository"),
if (args.positionals().len > 0) args.positionals()[0] else null,
);
}
};
pub const package = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("package", "Generate a tar file for publishing", package);
cmd.addFlag('h', "help", "Display help");
cmd.addOption('o', "output-dir", "dir", completion.Param.Directory, "Set package output directory");
cmd.addPositional("package", ?completion.Param.Package, .one, "The package(s) to package");
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, args: *Args, _: *std.process.ArgIterator) !void {
try cmds.package(allocator, args.option("--output-dir"), args.positionals());
}
};
pub const redirect = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("redirect", "Manage local development", redirect);
cmd.addFlag('h', "help", "Display help");
cmd.addFlag('c', "clean", "Undo all local redirects");
cmd.addOption('a', "alias", "package", completion.Param.Package, "Which package to redirect");
cmd.addOption('p', "path", "dir", completion.Param.Directory, "Project root directory");
cmd.addFlag('b', "build-dep", "Redirect a build dependency");
cmd.addFlag('e', "check", "Return successfully if there are no redirects (intended for git pre-commit hook)");
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, args: *Args, _: *std.process.ArgIterator) !void {
try cmds.redirect(allocator, args.flag("--check"), args.flag("--clean"), args.flag("--build-dep"), args.option("--alias"), args.option("--path"));
}
};
pub const install_completions = struct {
pub const info: completion.Command = blk: {
var cmd = completion.Command.init("completion", "Install shell completions", install_completions);
cmd.addFlag('h', "help", "Display help");
cmd.addOption('s', "shell", "shell", completion.shells.List, "The shell to install completions for. One of zsh");
cmd.addPositional("dir", completion.Param.Directory, .one, "Where to install the completion");
cmd.done();
break :blk cmd;
};
pub const Args = info.ClapComptime();
pub fn run(allocator: std.mem.Allocator, args: *Args, _: *std.process.ArgIterator) !void {
const positionals = args.positionals();
if (positionals.len < 1) {
std.log.err("missing completion install path", .{});
return error.Explained;
}
const shell_name = args.option("--shell") orelse {
std.log.err("missing shell", .{});
return error.Explained;
};
const shell = std.meta.stringToEnum(completion.shells.List, shell_name) orelse {
std.log.err("invalid shell", .{});
return error.Explained;
};
switch (shell) {
.zsh => {
const path = try std.fs.path.join(allocator, &.{ positionals[0], "_gyro" });
defer allocator.free(path);
const file = try std.fs.cwd().createFile(path, .{});
defer file.close();
try completion.shells.zsh.writeAll(file.writer(), all_commands);
},
}
}
};
};
test "all" {
std.testing.refAllDecls(@import("Dependency.zig"));
} | src/main.zig |
const std = @import("std");
const types = @import("types");
const Allocator = std.mem.Allocator;
const Value = std.json.Value;
const Array = std.json.Array;
const ObjectMap = std.json.ObjectMap;
const assert = std.debug.assert;
fn toSnakeCase(str: []const u8, buf: []u8) []const u8 {
var i: usize = 0;
var off: usize = 0;
while (i < str.len) : (i += 1) {
if (std.ascii.isUpper(str[i])) {
buf[i + off] = '_';
buf[i + off + 1] = std.ascii.toLower(str[i]);
off += 1;
} else {
buf[i + off] = str[i];
}
}
return buf[0 .. str.len + off];
}
fn toCamelCase(str: []const u8, buf: []u8) []const u8 {
var i: usize = 0;
var off: usize = 0;
while (i + off < str.len) : (i += 1) {
if (str[i + off] == '_') {
buf[i] = std.ascii.toUpper(str[i + off + 1]);
off += 1;
} else {
buf[i] = str[i + off];
}
}
return buf[0 .. str.len - off];
}
// TODO I don't think we need this data type? Can't we just copy the given
// object map directly?
pub fn JsonStringMap(comptime V: type) type {
return struct {
const Self = @This();
map: std.StringHashMap(V),
pub fn toJson(self: Self, allocator: *Allocator) Allocator.Error!Value {
var map = ObjectMap.init(allocator);
try map.ensureCapacity(self.map.count());
var it = self.map.iterator();
while (it.next()) |kv| {
const json_val = try json_serializer.toJson(kv.value, allocator);
_ = map.putAssumeCapacity(kv.key, json_val);
}
return Value{ .Object = map };
}
};
}
pub const json_deserializer = struct {
fn fromJsonArray(comptime T: type, allocator: *Allocator, arr: Array) !T {
const type_info = @typeInfo(T);
switch (@typeId(T)) {
.Pointer => {
// TODO figure out if this assumption is correct
if (type_info.Pointer.Size != .Slice) {
return error.CannotDeserialize;
}
const Child = type_info.Pointer.child;
const result = try allocator.alloc(Child, arr.len);
for (result) |*ptr, i| {
const arr_val = arr.at(i);
ptr.* = try fromJson(Child, allocator, arr_val);
}
return result;
},
.Array => {
const Child = type_info.Array.child;
if (arr.len != type_info.Array.len) {
return error.CannotDeserialize;
}
var result: T = undefined;
for (result) |*ptr, i| {
const arr_val = arr.at(i);
ptr.* = try fromJson(Child, allocator, arr_val);
}
return result;
},
else => error.CannotDeserialize,
}
}
fn fromJsonObject(comptime T: type, allocator: *Allocator, obj: ObjectMap) !T {
const type_info = @typeInfo(T);
var result: T = undefined;
inline for (type_info.Struct.fields) |f| {
const camel_cased = comptime blk: {
var buf: [f.name.len]u8 = undefined;
break :blk toCamelCase(f.name, buf[0..]);
};
if (obj.getValue(camel_cased)) |val| {
@field(result, f.name) = try fromJson(f.field_type, allocator, val);
} else if (@typeId(f.field_type) == .Optional) {
@field(result, f.name) = null;
} else {
return error.CannotDeserialize;
}
}
return result;
}
fn verifyAndReturn(comptime T: type, comptime tag: @TagType(Value), obj: Value) !T {
return if (obj == tag)
@field(obj, @tagName(tag))
else
error.CannotDeserialize;
}
pub fn fromJson(comptime T: type, allocator: *Allocator, val: Value) !T {
if (T == []const u8) {
if (val != .String) return error.CannotDeserialize;
return std.mem.dupe(allocator, u8, val.String);
}
// TODO figure out if I need comptime assertions here
// TODO do proper integer range checking to convert from i to u
// TODO clean this up to reduce duplicate "return error" code
return switch (@typeInfo(T)) {
.Bool => verifyAndReturn(T, .Bool, val),
.Int => verifyAndReturn(T, .Integer, val),
.Float => verifyAndReturn(T, .Float, val),
.Pointer, .Array => if (val != .Array)
error.CannotDeserialize
else
fromJsonArray(T, allocator, val.Array),
.Optional => if (val == .Null)
null
else
try fromJson(T.Child, allocator, val),
.Struct => if (val != .Object)
error.CannotDeserialize;
else if (comptime std.meta.trait.hasFn("fromJson")(T))
T.fromJson(allocator, obj.Object)
else
fromJsonObject(T, allocator, obj.Object),
else => error.CannotDeserialize,
};
}
};
pub const json_serializer = struct {
fn toJsonArray(thing: var, allocator: *Allocator) Allocator.Error!Array {
var arr = try Array.initCapacity(allocator, thing.len);
for (thing) |el| {
arr.appendAssumeCapacity(try toJson(el, allocator));
}
return arr;
}
pub fn toJson(thing: var, allocator: *Allocator) Allocator.Error!Value {
const T = @TypeOf(thing);
if (T == Value) {
return thing;
}
if (comptime std.meta.trait.hasFn("toJson")(T)) {
return T.toJson(thing, allocator);
}
const type_info = @typeInfo(T);
return switch (type_info) {
.Array => Value{ .Array = try toJsonArray(thing, allocator) },
.Bool => Value{ .Bool = thing },
// TODO camelCase enum value string
.Enum => Value{ .String = @tagName(thing) },
.Float, .ComptimeFloat => Value{ .Float = thing },
.Int, .ComptimeInt => Value{ .Integer = @intCast(i64, thing) },
.Optional => if (thing) |thing_unwrapped|
toJson(thing_unwrapped, allocator)
else
Value{ .Null = {} },
.Pointer => |p| if (p.child == u8)
Value{ .String = thing }
else switch (p.size) {
.One => toJson(thing.*, allocator),
.Many, .Slice => Value{ .Array = try toJsonArray(thing, allocator) },
else => Value{ .Null = {} },
},
.Struct => |s| blk: {
var map = ObjectMap.init(allocator);
try map.ensureCapacity(s.fields.len);
inline for (s.fields) |field| {
const name = field.name;
const camel_cased = comptime blk: {
var buf: [name.len]u8 = undefined;
break :blk toCamelCase(name, buf[0..]);
};
const serialized_field = try toJson(@field(thing, name), allocator);
_ = map.putAssumeCapacity(camel_cased, serialized_field);
}
break :blk Value{ .Object = map };
},
// TODO figure out what to do about untagged bare unions
.Union => |u| blk: {
const tag_int = @enumToInt(std.meta.activeTag(thing));
inline for (u.fields) |field| {
if (tag_int == field.enum_field.?.value) {
break :blk toJson(@field(thing, field.name), allocator);
}
}
unreachable;
},
else => Value.Null,
};
}
};
const Invocation = struct {
const Self = @This();
/// Name of the method to call or of the response.
name: []const u8,
arguments: ObjectMap,
/// An arbitrary string from the client to be echoed back with the
/// responses emitted by that method call.
method_call_id: []const u8,
pub fn toJson(self: Self, allocator: *Allocator) !Value {
var arr = try Array.initCapacity(allocator, 3);
arr.appendAssumeCapacity(Value{ .String = self.name });
arr.appendAssumeCapacity(Value{ .Object = self.arguments });
arr.appendAssumeCapacity(Value{ .String = self.method_call_id });
return Value{ .Array = arr };
}
};
const Request = struct {
/// The set of capabilities the client wishes to use.
using: []const []const u8,
/// An array of method calls to process on the server.
method_calls: []const Invocation,
/// A map of a (client-specified) creation id to the id the server assigned
/// when a record was successfully created.
created_ids: ?std.AutoHashMap(types.Id, types.Id),
};
const Response = struct {
/// An array of responses, in the same format as the "methodCalls" on the
/// Request object.
method_responses: []const Invocation,
/// A map of a (client-specified) creation id to the id the server assigned
/// when a record was successfully created.
created_ids: ?std.AutoHashMap(types.Id, types.Id),
/// The current value of the "state" string on the Session object.
session_state: []const u8,
};
const ResultReference = struct {
/// The method call id of a previous method call in the current request.
result_of: []const u8,
/// The required name of a response to that method call.
name: []const u8,
/// A pointer into the arguments of the response selected via the name and
/// resultOf properties.
path: []const u8,
};
// TODO remove hardcoded "using" capability
pub fn sendRequest(allocator: *Allocator, methods: var) !void {
var method_calls: []Invocation = try allocator.alloc(Invocation, methods.len);
for (methods) |method, i| {
// TODO figure out how to generate the name of the method call
// TODO figure out id generation
method_calls[i] = Invocation{
.name = "Core/echo",
.arguments = method.toJson(allocator),
.method_call_id = "LOL",
};
}
const request = Request{
.using = &[_][]const u8{"urn:ietf:params:jmap:core"},
.method_calls = method_calls,
};
} | json.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 int = i64;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day19.txt");
const P3 = struct {
x: i32, y: i32, z: i32,
pub fn add(self: @This(), b: @This()) @This() {
const result = P3{
.x = self.x + b.x,
.y = self.y + b.y,
.z = self.z + b.z,
};
return result;
}
pub fn sub(self: @This(), b: @This()) @This() {
const result = P3{
.x = self.x - b.x,
.y = self.y - b.y,
.z = self.z - b.z,
};
return result;
}
pub fn rotate(self: @This(), rotation: u32) P3 {
const x = self.x;
const y = self.y;
const z = self.z;
const result = switch (rotation) {
0 => P3{ .x = x, .y = y, .z = z },
1 => P3{ .x = x, .y = z, .z = -y },
2 => P3{ .x = x, .y = -y, .z = -z },
3 => P3{ .x = x, .y = -z, .z = y },
4 => P3{ .x = -x, .y = y, .z = -z },
5 => P3{ .x = -x, .y = z, .z = y },
6 => P3{ .x = -x, .y = -y, .z = z },
7 => P3{ .x = -x, .y = -z, .z = -y },
8 => P3{ .x = y, .y = -x, .z = z },
9 => P3{ .x = y, .y = -z, .z = -x },
10 => P3{ .x = y, .y = x, .z = -z },
11 => P3{ .x = y, .y = z, .z = x },
12 => P3{ .x = -y, .y = -x, .z = -z },
13 => P3{ .x = -y, .y = -z, .z = x },
14 => P3{ .x = -y, .y = x, .z = z },
15 => P3{ .x = -y, .y = z, .z = -x },
16 => P3{ .x = z, .y = x, .z = y },
17 => P3{ .x = z, .y = y, .z = -x },
18 => P3{ .x = z, .y = -x, .z = -y },
19 => P3{ .x = z, .y = -y, .z = x },
20 => P3{ .x = -z, .y = x, .z = -y },
21 => P3{ .x = -z, .y = y, .z = x },
22 => P3{ .x = -z, .y = -x, .z = y },
23 => P3{ .x = -z, .y = -y, .z = -x },
else => unreachable,
};
return result;
}
pub fn cross(a: P3, b: P3) P3 {
const result = P3{
.x = a.y * b.z - a.z * b.y,
.y = a.z * b.x - a.x * b.z,
.z = a.x * b.y - a.y * b.x,
};
return result;
}
pub fn eql(a: P3, b: P3) bool {
return a.x == b.x and a.y == b.y and a.z == b.z;
}
};
test "rotations" {
var rot: u32 = 0;
var any_failed = false;
while (rot < 24) : (rot += 1) {
const x = P3{ .x = 1, .y = 0, .z = 0 };
const y = P3{ .x = 0, .y = 1, .z = 0 };
const z = P3{ .x = 0, .y = 0, .z = 1 };
const rx = x.rotate(rot);
const ry = y.rotate(rot);
const rz = z.rotate(rot);
if (!rx.cross(ry).eql(rz)) {
print("\nwrong: {}\n", .{rot});
any_failed = true;
}
}
if (any_failed) unreachable;
}
const Scanner = struct {
beacons: []const P3,
};
const ScanMap = struct {
placed: std.DynamicBitSet,
rotations: []u32,
positions: []P3,
known_beacons: std.AutoArrayHashMap(P3, void),
pub fn init(count: usize) !ScanMap {
return ScanMap{
.placed = try std.DynamicBitSet.initFull(gpa, count),
.rotations = try gpa.alloc(u32, count),
.positions = try gpa.alloc(P3, count),
.known_beacons = std.AutoArrayHashMap(P3, void).init(gpa),
};
}
pub fn deinit(self: *@This()) void {
self.known_beacons.deinit();
gpa.free(self.positions);
gpa.free(self.rotations);
self.placed.deinit();
self.* = undefined;
}
pub fn add(self: *@This(), scanner: Scanner, rotation: u32, position: P3, index: usize) void {
self.placed.unset(index);
self.rotations[index] = rotation;
self.positions[index] = position;
for (scanner.beacons) |be| {
self.known_beacons.put(be.rotate(rotation).add(position), {}) catch unreachable;
}
}
};
pub fn main() !void {
var timer = try std.time.Timer.start();
var recs = blk: {
var lines = tokenize(u8, data, "\r\n");
var beacons = std.ArrayList(Scanner).init(gpa);
errdefer beacons.deinit();
var points = std.ArrayList(P3).init(gpa);
defer points.deinit();
while (lines.next()) |line| {
if (line.len == 0) { continue; }
if (line[1] == '-') {
if (points.items.len > 0) {
const items = points.toOwnedSlice();
try beacons.append(.{ .beacons = items });
}
continue;
}
var parts = split(u8, line, ",");
try points.append(.{
.x = parseInt(i32, parts.next().?, 10) catch unreachable,
.y = parseInt(i32, parts.next().?, 10) catch unreachable,
.z = parseInt(i32, parts.next().?, 10) catch unreachable,
});
assert(parts.next() == null);
}
if (points.items.len > 0) {
const items = points.toOwnedSlice();
try beacons.append(.{ .beacons = items });
}
break :blk beacons.toOwnedSlice();
};
defer gpa.free(recs);
const parse_time = timer.lap();
var count_table = Map(P3, u8).init(gpa);
defer count_table.deinit();
var maps = try ScanMap.init(recs.len);
defer maps.deinit();
maps.add(recs[0], 0, .{.x = 0, .y = 0, .z = 0}, 0);
placed: while (maps.placed.count() != 0) {
var it = maps.placed.iterator(.{});
while (it.next()) |idx| {
const scanner = recs[idx];
var rotation: u32 = 0;
while (rotation < 24) : (rotation += 1) {
count_table.clearRetainingCapacity();
for (scanner.beacons) |ank_be| {
for (maps.known_beacons.keys()) |ank_raw| {
const scanner_pos = ank_raw.sub(ank_be.rotate(rotation));
const entry = try count_table.getOrPut(scanner_pos);
if (entry.found_existing) {
entry.value_ptr.* += 1;
if (entry.value_ptr.* >= 12) {
//print("Scanner {} @{},{},{}\n", .{idx, scanner_pos.x, scanner_pos.y, scanner_pos.z});
maps.add(scanner, rotation, scanner_pos, idx);
continue :placed;
}
} else {
entry.value_ptr.* = 1;
}
}
}
}
}
unreachable;
}
const part1 = maps.known_beacons.count();
const part1_time = timer.lap();
var part2: int = 0;
for (maps.positions[0..maps.positions.len-1]) |p0, i| {
for (maps.positions[i+1..]) |p1| {
const delta = p0.sub(p1);
const manh =
(std.math.absInt(delta.x) catch unreachable) +
(std.math.absInt(delta.y) catch unreachable) +
(std.math.absInt(delta.z) catch unreachable);
if (manh > part2) part2 = manh;
}
}
const part2_time = timer.read();
print("part1={}, part2={}\n", .{part1, part2});
print("Timing: parse={}, part1={}, part2={}, total={}\n", .{parse_time, part1_time, part2_time, parse_time + part1_time + part2_time});
}
// 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 eql = std.mem.eql;
const parseEnum = std.meta.stringToEnum;
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/day19.zig |
const std = @import("std");
fn isArrayList(comptime T: type) bool {
// TODO: Improve this ArrayList check, specifically by actually checking the functions we use
// TODO: Consider unmanaged ArrayLists
if (!@hasField(T, "items")) return false;
if (!@hasField(T, "capacity")) return false;
return true;
}
fn isHashMap(comptime T: type) bool {
// TODO: Consider unmanaged HashMaps
if (!@hasDecl(T, "KV")) return false;
if (!@hasField(T.KV, "key")) return false;
if (!@hasField(T.KV, "value")) return false;
const Key = std.meta.fields(T.KV)[std.meta.fieldIndex(T.KV, "key") orelse unreachable].field_type;
const Value = std.meta.fields(T.KV)[std.meta.fieldIndex(T.KV, "value") orelse unreachable].field_type;
if (!@hasDecl(T, "init")) return false;
if (!@hasDecl(T, "put")) return false;
const init = @TypeOf(T.init);
if (init != fn (std.mem.Allocator) T) return false;
const put = @typeInfo(@TypeOf(T.put));
if (put != .Fn) return false;
if (put.Fn.args.len != 3) return false;
if (put.Fn.args[0].arg_type.? != *T) return false;
if (put.Fn.args[1].arg_type.? != Key) return false;
if (put.Fn.args[2].arg_type.? != Value) return false;
if (put.Fn.return_type == null) return false;
const put_return = @typeInfo(put.Fn.return_type.?);
if (put_return != .ErrorUnion) return false;
if (put_return.ErrorUnion.payload != void) return false;
return true;
}
pub fn parse(comptime T: type, tree: std.json.Value, allocator: ?std.mem.Allocator) ParseInternalError(T)!T {
return try parseInternal(T, "root", @typeName(T), tree, allocator, false);
}
pub fn Undefinedable(comptime T: type) type {
return struct {
const __json_T = T;
const __json_is_undefinedable = true;
value: T,
missing: bool,
pub fn asOptional(self: @This()) ?T {
return if (self.missing)
null
else
self.value;
}
pub fn format(self: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = fmt;
_ = options;
if (self.missing)
try writer.print("Undefinedable({s}){{ missing }}", .{@typeName(T)})
else {
try writer.print("Undefinedable({s}){{ .value = {any} }}", .{ @typeName(T), self.value });
}
}
};
}
pub fn ParseInternalError(comptime T: type) type {
// `inferred_types` is used to avoid infinite recursion for recursive type definitions.
const inferred_types = [_]type{};
return ParseInternalErrorImpl(T, &inferred_types);
}
fn ParseInternalErrorImpl(comptime T: type, comptime inferred_types: []const type) type {
if (comptime std.meta.trait.isContainer(T) and @hasDecl(T, "tresParse")) {
const tresParse_return = @typeInfo(@typeInfo(@TypeOf(T.tresParse)).Fn.return_type.?);
if (tresParse_return == .ErrorUnion) {
return tresParse_return.ErrorUnion.error_set;
} else {
return error{};
}
}
for (inferred_types) |ty| {
if (T == ty) return error{};
}
const inferred_set = inferred_types ++ [_]type{T};
switch (@typeInfo(T)) {
.Bool, .Float => return error{UnexpectedFieldType},
.Int => return error{ UnexpectedFieldType, Overflow },
.Optional => |info| return ParseInternalErrorImpl(info.child, inferred_set),
.Enum => return error{ InvalidEnumTag, UnexpectedFieldType },
.Union => |info| {
var errors = error{UnexpectedFieldType};
for (info.fields) |field| {
errors = errors || ParseInternalErrorImpl(field.field_type, inferred_set);
}
return errors;
},
.Struct => |info| {
var errors = error{
UnexpectedFieldType,
InvalidFieldValue,
MissingRequiredField,
};
if (isArrayList(T)) {
const Child = std.meta.Child(@field(T, "Slice"));
errors = errors || ParseInternalErrorImpl(Child, inferred_set);
}
if (isHashMap(T)) {
const Value = std.meta.fields(T.KV)[std.meta.fieldIndex(T.KV, "value") orelse unreachable].field_type;
errors = errors || ParseInternalErrorImpl(Value, inferred_set);
}
if (isAllocatorRequired(T)) {
errors = errors || error{AllocatorRequired} || std.mem.Allocator.Error;
}
for (info.fields) |field| {
errors = errors || ParseInternalErrorImpl(field.field_type, inferred_set);
}
return errors;
},
.Pointer => |info| {
var errors = error{UnexpectedFieldType};
if (isAllocatorRequired(T)) {
errors = errors || error{AllocatorRequired} || std.mem.Allocator.Error;
}
if (info.size == .Slice and info.child == u8 or info.child == std.json.Value)
return errors;
errors = errors || ParseInternalErrorImpl(info.child, inferred_set);
return errors;
},
.Array => |info| {
var errors = error{UnexpectedFieldType};
errors = errors || ParseInternalErrorImpl(info.child, inferred_set);
return errors;
},
.Vector => |info| {
var errors = error{UnexpectedFieldType};
errors = errors || ParseInternalErrorImpl(info.child, inferred_set);
return errors;
},
else => return error{},
}
}
pub fn isAllocatorRequired(comptime T: type) bool {
// `inferred_types` is used to avoid infinite recursion for recursive type definitions.
const inferred_types = [_]type{};
return isAllocatorRequiredImpl(T, &inferred_types);
}
fn isAllocatorRequiredImpl(comptime T: type, comptime inferred_types: []const type) bool {
for (inferred_types) |ty| {
if (T == ty) return false;
}
const inferred_set = inferred_types ++ [_]type{T};
switch (@typeInfo(T)) {
.Optional => |info| return isAllocatorRequiredImpl(info.child, inferred_set),
.Union => |info| {
for (info.fields) |field| {
if (isAllocatorRequiredImpl(field.field_type, inferred_set))
return true;
}
},
.Struct => |info| {
if (isArrayList(T)) {
if (T == std.json.Array)
return false;
return true;
}
if (isHashMap(T)) {
if (T == std.json.ObjectMap)
return false;
return true;
}
for (info.fields) |field| {
if (@typeInfo(field.field_type) == .Struct and @hasDecl(field.field_type, "__json_is_undefinedable")) {
if (isAllocatorRequiredImpl(field.field_type.__json_T, inferred_set))
return true;
} else if (isAllocatorRequiredImpl(field.field_type, inferred_set))
return true;
}
},
.Pointer => |info| {
if (info.size == .Slice and info.child == u8 or info.child == std.json.Value)
return false;
return true;
},
.Array => |info| {
return isAllocatorRequiredImpl(info.child, inferred_set);
},
.Vector => |info| {
return isAllocatorRequiredImpl(info.child, inferred_set); // is it even possible for this to be true?
},
else => {},
}
return false;
}
const logger = std.log.scoped(.json);
fn parseInternal(
comptime T: type,
comptime parent_name: []const u8,
comptime field_name: []const u8,
json_value: std.json.Value,
maybe_allocator: ?std.mem.Allocator,
comptime suppress_error_logs: bool,
) ParseInternalError(T)!T {
// TODO: Revert name fixes when stage2 comes out
// and properly memoizes comptime strings
const name = parent_name ++ "." ++ field_name;
if (T == std.json.Value) return json_value;
if (comptime std.meta.trait.isContainer(T) and @hasDecl(T, "tresParse")) {
return T.tresParse(json_value, maybe_allocator);
}
switch (@typeInfo(T)) {
.Bool => {
if (json_value == .Bool) {
return json_value.Bool;
} else {
if (comptime !suppress_error_logs) logger.debug("expected Bool, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
},
.Float => {
if (json_value == .Float) {
return @floatCast(T, json_value.Float);
} else if (json_value == .Integer) {
return @intToFloat(T, json_value.Integer);
} else {
if (comptime !suppress_error_logs) logger.debug("expected Float, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
},
.Int => {
if (json_value == .Integer) {
return std.math.cast(T, json_value.Integer) orelse return error.Overflow;
} else {
if (comptime !suppress_error_logs) logger.debug("expected Integer, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
},
.Optional => |info| {
if (json_value == .Null) {
return null;
} else {
return try parseInternal(
info.child,
@typeName(T),
"?",
json_value,
maybe_allocator,
suppress_error_logs,
);
}
},
.Enum => {
if (json_value == .Integer) {
// we use this to convert signed to unsigned and check if it actually fits.
const tag = std.math.cast(std.meta.Tag(T), json_value.Integer) orelse {
if (comptime !suppress_error_logs) logger.debug("invalid enum tag for {s}, found {d} at {s}", .{ @typeName(T), json_value.Integer, name });
return error.InvalidEnumTag;
};
return try std.meta.intToEnum(T, tag);
} else if (json_value == .String) {
return std.meta.stringToEnum(T, json_value.String) orelse {
if (comptime !suppress_error_logs) logger.debug("invalid enum tag for {s}, found '{s}' at {s}", .{ @typeName(T), json_value.String, name });
return error.InvalidEnumTag;
};
} else {
if (comptime !suppress_error_logs) logger.debug("expected Integer or String, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
},
.Union => |info| {
if (info.tag_type != null) {
inline for (info.fields) |field| {
if (parseInternal(
field.field_type,
@typeName(T),
field.name,
json_value,
maybe_allocator,
true,
)) |parsed_value| {
return @unionInit(T, field.name, parsed_value);
} else |_| {}
}
if (comptime !suppress_error_logs) logger.debug("union fell through for {s}, found {s} at {s}", .{ @typeName(T), @tagName(json_value), name });
return error.UnexpectedFieldType;
} else {
@compileError("cannot parse an untagged union: " ++ @typeName(T));
}
},
.Struct => |info| {
if (comptime isArrayList(T)) {
const Child = std.meta.Child(@field(T, "Slice"));
if (json_value == .Array) {
if (T == std.json.Array) return json_value.Array;
const allocator = maybe_allocator orelse return error.AllocatorRequired;
var array_list = try T.initCapacity(allocator, json_value.Array.capacity);
for (json_value.Array.items) |item| {
try array_list.append(try parseInternal(
Child,
@typeName(T),
".(arraylist item)",
item,
maybe_allocator,
suppress_error_logs,
));
}
return array_list;
} else {
if (comptime !suppress_error_logs) logger.debug("expected array of {s} at {s}, found {s}", .{ @typeName(Child), name, @tagName(json_value) });
return error.UnexpectedFieldType;
}
}
if (comptime isHashMap(T)) {
const Key = std.meta.fields(T.KV)[std.meta.fieldIndex(T.KV, "key") orelse unreachable].field_type;
const Value = std.meta.fields(T.KV)[std.meta.fieldIndex(T.KV, "value") orelse unreachable].field_type;
if (Key != []const u8) @compileError("HashMap key must be of type []const u8!");
if (json_value == .Object) {
if (T == std.json.ObjectMap) return json_value.Object;
const allocator = maybe_allocator orelse return error.AllocatorRequired;
var map = T.init(allocator);
var map_iterator = json_value.Object.iterator();
while (map_iterator.next()) |entry| {
try map.put(entry.key_ptr.*, try parseInternal(
Value,
@typeName(T),
".(hashmap entry)",
entry.value_ptr.*,
maybe_allocator,
suppress_error_logs,
));
}
return map;
} else {
if (comptime !suppress_error_logs) logger.debug("expected map of {s} at {s}, found {s}", .{ @typeName(Value), name, @tagName(json_value) });
return error.UnexpectedFieldType;
}
}
if (info.is_tuple) {
if (json_value != .Array) {
if (comptime !suppress_error_logs) logger.debug("expected Array, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
if (json_value.Array.items.len != std.meta.fields(T).len) {
if (comptime !suppress_error_logs) logger.debug("expected Array to match length of Tuple {s} but it doesn't; at {s}", .{ @typeName(T), name });
return error.UnexpectedFieldType;
}
var tuple: T = undefined;
comptime var index: usize = 0;
inline while (index < std.meta.fields(T).len) : (index += 1) {
tuple[index] = try parseInternal(
std.meta.fields(T)[index].field_type,
@typeName(T),
comptime std.fmt.comptimePrint("[{d}]", .{index}),
json_value.Array.items[index],
maybe_allocator,
suppress_error_logs,
);
}
return tuple;
}
if (json_value == .Object) {
var result: T = undefined;
// Must use in order to bypass [#2727](https://github.com/ziglang/zig/issues/2727) :(
var missing_field = false;
inline for (info.fields) |field| {
const field_value = json_value.Object.get(field.name);
if (field.is_comptime) {
if (field_value == null) {
if (comptime !suppress_error_logs) logger.debug("comptime field {s}.{s} missing, at {s}", .{ @typeName(T), field.name, name });
return error.InvalidFieldValue;
}
if (field.default_value) |default| {
const parsed_value = try parseInternal(
field.field_type,
@typeName(T),
field.name,
field_value.?,
maybe_allocator,
suppress_error_logs,
);
const default_value = @ptrCast(*const field.field_type, default).*;
// NOTE: This only works for strings!
// TODODODODODODO ASAP
if (!std.mem.eql(u8, parsed_value, default_value)) {
if (comptime !suppress_error_logs) logger.debug("comptime field {s}.{s} does not match", .{ @typeName(T), field.name });
return error.InvalidFieldValue;
}
} else unreachable; // zig requires comptime fields to have a default initialization value
} else {
if (field_value) |fv| {
if (@typeInfo(field.field_type) == .Struct and @hasDecl(field.field_type, "__json_is_undefinedable"))
@field(result, field.name) = .{
.value = try parseInternal(
field.field_type.__json_T,
@typeName(T),
field.name,
fv,
maybe_allocator,
suppress_error_logs,
),
.missing = false,
}
else
@field(result, field.name) = try parseInternal(
field.field_type,
@typeName(T),
field.name,
fv,
maybe_allocator,
suppress_error_logs,
);
} else {
if (@typeInfo(field.field_type) == .Struct and @hasDecl(field.field_type, "__json_is_undefinedable")) {
@field(result, field.name) = .{
.value = undefined,
.missing = true,
};
} else if (field.default_value) |default| {
const default_value = @ptrCast(*const field.field_type, default).*;
@field(result, field.name) = default_value;
} else {
if (comptime !suppress_error_logs) logger.debug("required field {s}.{s} missing, at {s}", .{ @typeName(T), field.name, name });
missing_field = true;
}
}
}
}
if (missing_field) return error.MissingRequiredField;
return result;
} else {
if (comptime !suppress_error_logs) logger.debug("expected Object, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
},
.Pointer => |info| {
if (info.size == .Slice) {
if (info.child == u8) {
if (json_value == .String) {
return json_value.String;
} else {
if (comptime !suppress_error_logs) logger.debug("expected String, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
} else if (info.child == std.json.Value) {
return json_value.Array.items;
}
}
const allocator = maybe_allocator orelse return error.AllocatorRequired;
switch (info.size) {
.Slice, .Many => {
const sentinel = if (info.sentinel) |ptr| @ptrCast(*const info.child, ptr).* else null;
if (info.child == u8 and json_value == .String) {
const array = try allocator.allocWithOptions(
info.child,
json_value.String.len,
info.alignment,
sentinel,
);
std.mem.copy(u8, array, json_value.String);
return @ptrCast(T, array);
}
if (json_value == .Array) {
if (info.child == std.json.Value) return json_value.Array.items;
const array = try allocator.allocWithOptions(
info.child,
json_value.Array.items.len,
info.alignment,
sentinel,
);
for (json_value.Array.items) |item, index|
array[index] = try parseInternal(
info.child,
@typeName(T),
"[...]",
item,
maybe_allocator,
suppress_error_logs,
);
return @ptrCast(T, array);
} else {
if (comptime !suppress_error_logs) logger.debug("expected Array, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
},
.One, .C => {
const data = try allocator.allocAdvanced(info.child, info.alignment, 1, .exact);
data[0] = try parseInternal(
info.child,
@typeName(T),
"*",
json_value,
maybe_allocator,
suppress_error_logs,
);
return &data[0];
},
}
},
.Array => |info| {
if (json_value == .Array) {
var array: T = undefined;
if (info.sentinel) |ptr| {
const sentinel = @ptrCast(*const info.child, ptr).*;
array[array.len] = sentinel;
}
if (json_value.Array.items.len != info.len) {
if (comptime !suppress_error_logs) logger.debug("expected Array to match length of {s} but it doesn't; at {s}", .{ @typeName(T), name });
return error.UnexpectedFieldType;
}
for (array) |*item, index|
item.* = try parseInternal(
info.child,
@typeName(T),
"[...]",
json_value.Array.items[index],
maybe_allocator,
suppress_error_logs,
);
return array;
} else {
if (comptime !suppress_error_logs) logger.debug("expected Array, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
},
.Vector => |info| {
if (json_value == .Array) {
var vector: T = undefined;
if (json_value.Array.items.len != info.len) {
if (comptime !suppress_error_logs) logger.debug("expected Array to match length of {s} ({d}) but it doesn't; at {s}", .{ @typeName(T), info.len, name });
return error.UnexpectedFieldType;
}
for (vector) |*item|
item.* = try parseInternal(
info.child,
@typeName(T),
"[...]",
item,
maybe_allocator,
suppress_error_logs,
);
return vector;
} else {
if (comptime !suppress_error_logs) logger.debug("expected Array, found {s} at {s}", .{ @tagName(json_value), name });
return error.UnexpectedFieldType;
}
},
else => {
@compileError("unhandled json type: " ++ @typeName(T) ++ " at " ++ name);
},
}
}
fn outputUnicodeEscape(
codepoint: u21,
out_stream: anytype,
) !void {
if (codepoint <= 0xFFFF) {
// If the character is in the Basic Multilingual Plane (U+0000 through U+FFFF),
// then it may be represented as a six-character sequence: a reverse solidus, followed
// by the lowercase letter u, followed by four hexadecimal digits that encode the character's code point.
try out_stream.writeAll("\\u");
try std.fmt.formatIntValue(codepoint, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
} else {
std.debug.assert(codepoint <= 0x10FFFF);
// To escape an extended character that is not in the Basic Multilingual Plane,
// the character is represented as a 12-character sequence, encoding the UTF-16 surrogate pair.
const high = @intCast(u16, (codepoint - 0x10000) >> 10) + 0xD800;
const low = @intCast(u16, codepoint & 0x3FF) + 0xDC00;
try out_stream.writeAll("\\u");
try std.fmt.formatIntValue(high, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
try out_stream.writeAll("\\u");
try std.fmt.formatIntValue(low, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
}
}
fn outputJsonString(value: []const u8, options: std.json.StringifyOptions, out_stream: anytype) !void {
try out_stream.writeByte('\"');
var i: usize = 0;
while (i < value.len) : (i += 1) {
switch (value[i]) {
// normal ascii character
0x20...0x21, 0x23...0x2E, 0x30...0x5B, 0x5D...0x7F => |c| try out_stream.writeByte(c),
// only 2 characters that *must* be escaped
'\\' => try out_stream.writeAll("\\\\"),
'\"' => try out_stream.writeAll("\\\""),
// solidus is optional to escape
'/' => {
if (options.string.String.escape_solidus) {
try out_stream.writeAll("\\/");
} else {
try out_stream.writeByte('/');
}
},
// control characters with short escapes
// TODO: option to switch between unicode and 'short' forms?
0x8 => try out_stream.writeAll("\\b"),
0xC => try out_stream.writeAll("\\f"),
'\n' => try out_stream.writeAll("\\n"),
'\r' => try out_stream.writeAll("\\r"),
'\t' => try out_stream.writeAll("\\t"),
else => {
const ulen = std.unicode.utf8ByteSequenceLength(value[i]) catch unreachable;
// control characters (only things left with 1 byte length) should always be printed as unicode escapes
if (ulen == 1 or options.string.String.escape_unicode) {
const codepoint = std.unicode.utf8Decode(value[i .. i + ulen]) catch unreachable;
try outputUnicodeEscape(codepoint, out_stream);
} else {
try out_stream.writeAll(value[i .. i + ulen]);
}
i += ulen - 1;
},
}
}
try out_stream.writeByte('\"');
}
pub fn stringify(
value: anytype,
options: std.json.StringifyOptions,
out_stream: anytype,
) @TypeOf(out_stream).Error!void {
const T = @TypeOf(value);
switch (@typeInfo(T)) {
.Float, .ComptimeFloat => {
return std.fmt.formatFloatScientific(value, std.fmt.FormatOptions{}, out_stream);
},
.Int, .ComptimeInt => {
return std.fmt.formatIntValue(value, "", std.fmt.FormatOptions{}, out_stream);
},
.Bool => {
return out_stream.writeAll(if (value) "true" else "false");
},
.Null => {
return out_stream.writeAll("null");
},
.Optional => {
if (value) |payload| {
return try stringify(payload, options, out_stream);
} else {
return try stringify(null, options, out_stream);
}
},
.Enum => {
if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
return value.jsonStringify(options, out_stream);
}
@compileError("Unable to stringify enum '" ++ @typeName(T) ++ "'");
},
.Union => {
if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
return value.jsonStringify(options, out_stream);
}
const info = @typeInfo(T).Union;
if (info.tag_type) |UnionTagType| {
inline for (info.fields) |u_field| {
if (value == @field(UnionTagType, u_field.name)) {
return try stringify(@field(value, u_field.name), options, out_stream);
}
}
} else {
@compileError("Unable to stringify untagged union '" ++ @typeName(T) ++ "'");
}
},
.Struct => |S| {
if (comptime isArrayList(T)) {
return stringify(value.items, options, out_stream);
}
if (comptime isHashMap(T)) {
var iterator = value.iterator();
var first = true;
try out_stream.writeByte('{');
while (iterator.next()) |entry| {
if (!first) {
try out_stream.writeByte(',');
} else first = false;
try stringify(entry.key_ptr.*, options, out_stream);
try out_stream.writeByte(':');
try stringify(entry.value_ptr.*, options, out_stream);
}
try out_stream.writeByte('}');
return;
}
if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
return value.jsonStringify(options, out_stream);
}
try out_stream.writeByte('{');
var field_output = false;
var child_options = options;
if (child_options.whitespace) |*child_whitespace| {
child_whitespace.indent_level += 1;
}
inline for (S.fields) |Field| {
// don't include void fields
if (Field.field_type == void) continue;
var emit_field = true;
// don't include optional fields that are null when emit_null_optional_fields is set to false
if (@typeInfo(Field.field_type) == .Optional) {
if (options.emit_null_optional_fields == false) {
if (@field(value, Field.name) == null) {
emit_field = false;
}
}
}
const is_undefinedable = comptime @typeInfo(@TypeOf(@field(value, Field.name))) == .Struct and @hasDecl(@TypeOf(@field(value, Field.name)), "__json_is_undefinedable");
if (is_undefinedable) {
if (@field(value, Field.name).missing)
emit_field = false;
}
if (emit_field) {
if (!field_output) {
field_output = true;
} else {
try out_stream.writeByte(',');
}
if (child_options.whitespace) |child_whitespace| {
try out_stream.writeByte('\n');
try child_whitespace.outputIndent(out_stream);
}
try outputJsonString(Field.name, options, out_stream);
try out_stream.writeByte(':');
if (child_options.whitespace) |child_whitespace| {
if (child_whitespace.separator) {
try out_stream.writeByte(' ');
}
}
try stringify(if (is_undefinedable)
@field(value, Field.name).value
else
@field(value, Field.name), child_options, out_stream);
}
}
if (field_output) {
if (options.whitespace) |whitespace| {
try out_stream.writeByte('\n');
try whitespace.outputIndent(out_stream);
}
}
try out_stream.writeByte('}');
return;
},
.ErrorSet => return stringify(@as([]const u8, @errorName(value)), options, out_stream),
.Pointer => |ptr_info| switch (ptr_info.size) {
.One => switch (@typeInfo(ptr_info.child)) {
.Array => {
const Slice = []const std.meta.Elem(ptr_info.child);
return stringify(@as(Slice, value), options, out_stream);
},
else => {
// TODO: avoid loops?
return stringify(value.*, options, out_stream);
},
},
// TODO: .Many when there is a sentinel (waiting for https://github.com/ziglang/zig/pull/3972)
.Slice => {
if (ptr_info.child == u8 and options.string == .String and std.unicode.utf8ValidateSlice(value)) {
try outputJsonString(value, options, out_stream);
return;
}
try out_stream.writeByte('[');
var child_options = options;
if (child_options.whitespace) |*whitespace| {
whitespace.indent_level += 1;
}
for (value) |x, i| {
if (i != 0) {
try out_stream.writeByte(',');
}
if (child_options.whitespace) |child_whitespace| {
try out_stream.writeByte('\n');
try child_whitespace.outputIndent(out_stream);
}
try stringify(x, child_options, out_stream);
}
if (value.len != 0) {
if (options.whitespace) |whitespace| {
try out_stream.writeByte('\n');
try whitespace.outputIndent(out_stream);
}
}
try out_stream.writeByte(']');
return;
},
else => @compileError("Unable to stringify type '" ++ @typeName(T) ++ "'"),
},
.Array => return stringify(&value, options, out_stream),
.Vector => |info| {
const array: [info.len]info.child = value;
return stringify(&array, options, out_stream);
},
else => @compileError("Unable to stringify type '" ++ @typeName(T) ++ "'"),
}
unreachable;
}
test "json.parse simple struct" {
@setEvalBranchQuota(10_000);
const Role = enum(i64) { crewmate, impostor, ghost };
const Union = union(enum) {
a: i64,
b: []const u8,
};
const Substruct = struct {
value: std.json.Value,
slice_of_values: []std.json.Value,
union_a: Union,
union_b: Union,
};
const Player = struct {
name: []const u8,
based: bool,
};
const MyTuple = std.meta.Tuple(&[_]type{ i64, bool });
const Struct = struct {
bool_true: bool,
bool_false: bool,
integer: u8,
float: f64,
optional: ?f32,
an_enum: Role,
an_enum_string: Role,
slice: []i64,
substruct: Substruct,
random_map: std.json.ObjectMap,
number_map: std.StringArrayHashMap(i64),
players: std.StringHashMap(Player),
my_tuple: MyTuple,
my_array: [2]u8,
my_array_of_any: [2]std.json.Value,
my_array_list: std.ArrayList(i64),
my_array_list_of_any: std.json.Array,
a_pointer: *u8,
a_weird_string: [*:0]u8,
};
const json =
\\{
\\ "bool_true": true,
\\ "bool_false": false,
\\ "integer": 100,
\\ "float": 4.2069,
\\ "optional": null,
\\ "an_enum": 1,
\\ "an_enum_string": "crewmate",
\\ "slice": [1, 2, 3, 4, 5, 6],
\\ "substruct": {
\\ "value": "hello",
\\ "slice_of_values": ["hello", "world"],
\\ "union_a": -42,
\\ "union_b": "hello"
\\ },
\\ "random_map": {
\\ "a": 123,
\\ "b": "Amogus!!"
\\ },
\\ "number_map": {
\\ "a": 123,
\\ "b": 456
\\ },
\\ "players": {
\\ "aurame": {"name": "Auguste", "based": true},
\\ "mattnite": {"name": "Matt", "based": true}
\\ },
\\ "my_tuple": [10, false],
\\ "my_array": [1, 255],
\\ "my_array_of_any": ["a", 2],
\\ "my_array_list": [2, 254],
\\ "my_array_list_of_any": ["b", 3],
\\ "a_pointer": 5,
\\ "a_weird_string": "hello"
\\}
;
// NOTE: In practice, we're going to use an arena, thus no parseFree exists because it is not required :)
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var testing_parser = std.json.Parser.init(arena.allocator(), false);
const tree = try testing_parser.parse(json);
const parsed = try parse(Struct, tree.root, arena.allocator());
try std.testing.expectEqual(true, parsed.bool_true);
try std.testing.expectEqual(false, parsed.bool_false);
try std.testing.expectEqual(@as(u8, 100), parsed.integer);
try std.testing.expectApproxEqRel(@as(f64, 4.2069), parsed.float, std.math.epsilon(f64));
try std.testing.expectEqual(@as(?f32, null), parsed.optional);
try std.testing.expectEqual(Role.impostor, parsed.an_enum);
try std.testing.expectEqual(Role.crewmate, parsed.an_enum_string);
try std.testing.expectEqualSlices(i64, &[_]i64{ 1, 2, 3, 4, 5, 6 }, parsed.slice);
try std.testing.expect(parsed.substruct.value == .String);
try std.testing.expectEqualStrings("hello", parsed.substruct.value.String);
try std.testing.expect(parsed.substruct.slice_of_values.len == 2);
try std.testing.expect(parsed.substruct.slice_of_values[0] == .String);
try std.testing.expectEqualStrings("hello", parsed.substruct.slice_of_values[0].String);
try std.testing.expect(parsed.substruct.slice_of_values[1] == .String);
try std.testing.expectEqualStrings("world", parsed.substruct.slice_of_values[1].String);
try std.testing.expect(parsed.substruct.union_a == .a);
try std.testing.expectEqual(@as(i64, -42), parsed.substruct.union_a.a);
try std.testing.expect(parsed.substruct.union_b == .b);
try std.testing.expectEqualStrings("hello", parsed.substruct.union_b.b);
try std.testing.expectEqual(@as(i64, 123), parsed.random_map.get("a").?.Integer);
try std.testing.expectEqualStrings("Amogus!!", parsed.random_map.get("b").?.String);
try std.testing.expectEqual(@as(i64, 123), parsed.number_map.get("a").?);
try std.testing.expectEqual(@as(i64, 456), parsed.number_map.get("b").?);
try std.testing.expectEqualStrings("Auguste", parsed.players.get("aurame").?.name);
try std.testing.expectEqualStrings("Matt", parsed.players.get("mattnite").?.name);
try std.testing.expectEqual(true, parsed.players.get("aurame").?.based);
try std.testing.expectEqual(true, parsed.players.get("mattnite").?.based);
try std.testing.expectEqual(MyTuple{ 10, false }, parsed.my_tuple);
try std.testing.expectEqual([2]u8{ 1, 255 }, parsed.my_array);
try std.testing.expect(parsed.my_array_of_any[0] == .String);
try std.testing.expectEqualStrings("a", parsed.my_array_of_any[0].String);
try std.testing.expect(parsed.my_array_of_any[1] == .Integer);
try std.testing.expectEqual(@as(i64, 2), parsed.my_array_of_any[1].Integer);
try std.testing.expectEqual(@as(usize, 2), parsed.my_array_list.items.len);
try std.testing.expectEqualSlices(i64, &[_]i64{ 2, 254 }, parsed.my_array_list.items);
try std.testing.expectEqual(@as(usize, 2), parsed.my_array_list_of_any.items.len);
try std.testing.expect(parsed.my_array_list_of_any.items[0] == .String);
try std.testing.expectEqualStrings("b", parsed.my_array_list_of_any.items[0].String);
try std.testing.expect(parsed.my_array_list_of_any.items[1] == .Integer);
try std.testing.expectEqual(@as(i64, 3), parsed.my_array_list_of_any.items[1].Integer);
try std.testing.expectEqual(@as(u8, 5), parsed.a_pointer.*);
try std.testing.expectEqualStrings("hello", std.mem.sliceTo(parsed.a_weird_string, 0));
}
test "json.parse missing field" {
const Struct = struct {
my_super_duper_important_field: bool,
};
const json =
\\{}
;
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var testing_parser = std.json.Parser.init(arena.allocator(), false);
const tree = try testing_parser.parse(json);
const parsed = parse(Struct, tree.root, arena.allocator());
try std.testing.expectError(error.MissingRequiredField, parsed);
}
test "json.parse undefinedable fields and default values" {
const Struct = struct {
meh: Undefinedable(i64),
meh2: Undefinedable(i64),
default: u8 = 123,
};
const json =
\\{
\\ "meh": 42069
\\}
;
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var testing_parser = std.json.Parser.init(arena.allocator(), false);
const tree = try testing_parser.parse(json);
const parsed = try parse(Struct, tree.root, arena.allocator());
try std.testing.expectEqual(@as(i64, 42069), parsed.meh.value);
try std.testing.expectEqual(true, parsed.meh2.missing);
try std.testing.expectEqual(@as(u8, 123), parsed.default);
}
test "json.parse comptime fields" {
const YoureTheImpostorMessage = struct {
comptime method: []const u8 = "ship/impostor",
sussiness: f64,
};
const YoureCuteUwUMessage = struct {
comptime method: []const u8 = "a/cutiepie",
cuteness: i64,
};
const Message = union(enum) {
youre_the_impostor: YoureTheImpostorMessage,
youre_cute_uwu: YoureCuteUwUMessage,
};
const first_message =
\\{
\\ "method": "ship/impostor",
\\ "sussiness": 69.420
\\}
;
const second_message =
\\{
\\ "method": "a/cutiepie",
\\ "cuteness": 100
\\}
;
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var testing_parser = std.json.Parser.init(arena.allocator(), false);
const first_tree = try testing_parser.parse(first_message);
const first_parsed = try parse(Message, first_tree.root, arena.allocator());
try std.testing.expect(first_parsed == .youre_the_impostor);
testing_parser.reset();
const second_tree = try testing_parser.parse(second_message);
const second_parsed = try parse(Message, second_tree.root, arena.allocator());
try std.testing.expect(second_parsed == .youre_cute_uwu);
}
test "json.parse custom check functions for unions" {
// jsonrpc request
const RequestId = union(enum) { string: []const u8, integer: i64 };
const AmogusRequest = struct {
const method = "spaceship/amogus";
sussy: bool,
};
const MinecraftNotification = struct {
const method = "game/minecraft";
crafted: i64,
mined: i64,
};
const RequestParams = union(enum) {
amogus: AmogusRequest,
minecraft: MinecraftNotification,
};
const RequestOrNotification = struct {
const Self = @This();
jsonrpc: []const u8,
id: ?RequestId = null,
method: []const u8,
params: RequestParams,
fn RequestOrNotificationParseError() type {
var err = ParseInternalError(RequestId);
inline for (std.meta.fields(RequestParams)) |field| {
err = err || ParseInternalError(field.field_type);
}
return err;
}
pub fn tresParse(value: std.json.Value, allocator: ?std.mem.Allocator) RequestOrNotificationParseError()!Self {
// var allocator = options.allocator orelse return error.AllocatorRequired;
var object = value.Object;
var request_or_notif: Self = undefined;
request_or_notif.jsonrpc = object.get("jsonrpc").?.String;
request_or_notif.id = if (object.get("id")) |id| try parse(RequestId, id, allocator) else null;
request_or_notif.method = object.get("method").?.String;
inline for (std.meta.fields(RequestParams)) |field| {
if (std.mem.eql(u8, request_or_notif.method, field.field_type.method)) {
request_or_notif.params = @unionInit(RequestParams, field.name, try parse(field.field_type, object.get("params").?, allocator));
}
}
return request_or_notif;
}
};
const first_message =
\\{
\\ "jsonrpc": "2.0",
\\ "id": 10,
\\ "method": "spaceship/amogus",
\\ "params": {"sussy": true}
\\}
;
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var testing_parser = std.json.Parser.init(arena.allocator(), false);
const first_tree = try testing_parser.parse(first_message);
const first_parsed = try parse(RequestOrNotification, first_tree.root, arena.allocator());
try std.testing.expectEqualStrings("2.0", first_parsed.jsonrpc);
try std.testing.expect(first_parsed.id != null);
try std.testing.expect(first_parsed.id.? == .integer);
try std.testing.expectEqual(@as(i64, 10), first_parsed.id.?.integer);
try std.testing.expectEqualStrings("spaceship/amogus", first_parsed.method);
try std.testing.expect(first_parsed.params == .amogus);
try std.testing.expectEqual(true, first_parsed.params.amogus.sussy);
// TODO: Add second test
}
test "json.parse allocator required errors" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var testing_parser = std.json.Parser.init(arena.allocator(), false);
try std.testing.expectError(error.AllocatorRequired, parse([]i64, (try testing_parser.parse("[1, 2, 3, 4]")).root, null));
testing_parser.reset();
try std.testing.expectError(error.AllocatorRequired, parse(std.StringArrayHashMap(i64), (try testing_parser.parse(
\\{"a": 123, "b": -69}
)).root, null));
}
test "json.stringify basics" {
var stringify_buf: [28]u8 = undefined;
var fbs = std.io.fixedBufferStream(&stringify_buf);
const Basic = struct {
unsigned: u16,
signed: i16,
};
var basic = Basic{
.unsigned = 69,
.signed = -69,
};
try stringify(basic, .{}, fbs.writer());
try std.testing.expectEqualStrings(
\\{"unsigned":69,"signed":-69}
, &stringify_buf);
}
test "json.stringify undefinedables" {
var furry_buf: [49]u8 = undefined;
var fbs = std.io.fixedBufferStream(&furry_buf);
const Furry = struct {
name: Undefinedable([]const u8),
age: Undefinedable(i64),
plays_amogus: bool,
joe: Undefinedable([]const u8),
};
var rimu = Furry{
.name = .{ .value = "Rimu", .missing = false },
.age = .{ .value = undefined, .missing = true },
.plays_amogus = false,
.joe = .{ .value = "Mama", .missing = false },
};
try stringify(rimu, .{}, fbs.writer());
try std.testing.expectEqualStrings(
\\{"name":"Rimu","plays_amogus":false,"joe":"Mama"}
, &furry_buf);
}
test "json.stringify arraylist" {
var stringify_buf: [49]u8 = undefined;
var fbs = std.io.fixedBufferStream(&stringify_buf);
const Database = struct {
names_of_my_pals: std.ArrayList([]const u8),
};
var db = Database{
.names_of_my_pals = std.ArrayList([]const u8).init(std.testing.allocator),
};
defer db.names_of_my_pals.deinit();
try db.names_of_my_pals.append("Travis");
try db.names_of_my_pals.append("Rimu");
try db.names_of_my_pals.append("Flandere");
try stringify(db, .{}, fbs.writer());
try std.testing.expectEqualStrings(
\\{"names_of_my_pals":["Travis","Rimu","Flandere"]}
, &stringify_buf);
}
test "json.stringify hashmaps" {
var stringify_buf: [51]u8 = undefined;
var fbs = std.io.fixedBufferStream(&stringify_buf);
const Database = struct {
coolness: std.StringHashMap(f64),
};
var db = Database{
.coolness = std.StringHashMap(f64).init(std.testing.allocator),
};
defer db.coolness.deinit();
try db.coolness.put("Montreal", -20);
try db.coolness.put("Beirut", 20);
try stringify(db, .{}, fbs.writer());
try std.testing.expectEqualStrings(
\\{"coolness":{"Montreal":-2.0e+01,"Beirut":2.0e+01}}
, &stringify_buf);
} | tres.zig |
const std = @import("std");
pub const Reader = struct {
const Self = @This();
pub const ReadError = error{EOF};
buf: []u8,
remain: []u8,
allocator: std.mem.Allocator,
pub fn init(buf: []u8, allocator: std.mem.Allocator) Reader {
return Reader{
.buf = buf,
.remain = buf,
.allocator = allocator,
};
}
pub fn read(this: *Self, count: usize) ![]u8 {
const read_count = @minimum(count, this.remain.len);
if (read_count < count) {
return error.EOF;
}
var slice = this.remain[0..read_count];
this.remain = this.remain[read_count..];
return slice;
}
pub inline fn readAs(this: *Self, comptime T: type) !T {
if (!std.meta.trait.hasUniqueRepresentation(T)) {
@compileError(@typeName(T) ++ " must have unique representation.");
}
return std.mem.bytesAsValue(T, try this.read(@sizeOf(T)));
}
pub inline fn readByte(this: *Self) !u8 {
return (try this.read(1))[0];
}
pub fn readEnum(this: *Self, comptime Enum: type) !Enum {
const E = error{
/// An integer was read, but it did not match any of the tags in the supplied enum.
InvalidValue,
};
const type_info = @typeInfo(Enum).Enum;
const tag = try this.readInt(type_info.tag_type);
inline for (std.meta.fields(Enum)) |field| {
if (tag == field.value) {
return @field(Enum, field.name);
}
}
return E.InvalidValue;
}
pub inline fn readArray(this: *Self, comptime T: type) ![]const T {
const length = try this.readInt(u32);
if (length == 0) {
return &([_]T{});
}
switch (comptime T) {
u8 => {
return try this.read(length);
},
u16, u32, i8, i16, i32 => {
return std.mem.readIntSliceNative(T, this.read(length * @sizeOf(T)));
},
[:0]const u8, []const u8 => {
var i: u32 = 0;
var array = try this.allocator.alloc(T, length);
while (i < length) : (i += 1) {
array[i] = try this.readArray(u8);
}
return array;
},
else => {
switch (comptime @typeInfo(T)) {
.Struct => |Struct| {
switch (Struct.layout) {
.Packed => {
const sizeof = @sizeOf(T);
var slice = try this.read(sizeof * length);
return std.mem.bytesAsSlice(T, slice);
},
else => {},
}
},
.Enum => |type_info| {
const enum_values = try this.read(length * @sizeOf(type_info.tag_type));
return @ptrCast([*]T, enum_values.ptr)[0..length];
},
else => {},
}
var i: u32 = 0;
var array = try this.allocator.alloc(T, length);
while (i < length) : (i += 1) {
array[i] = try this.readValue(T);
}
return array;
},
}
}
pub inline fn readByteArray(this: *Self) ![]u8 {
const length = try this.readInt(u32);
if (length == 0) {
return &([_]u8{});
}
return try this.read(@as(usize, length));
}
pub inline fn readInt(this: *Self, comptime T: type) !T {
var slice = try this.read(@sizeOf(T));
return std.mem.readIntSliceNative(T, slice);
}
pub inline fn readBool(this: *Self) !bool {
return (try this.readByte()) > 0;
}
pub inline fn readValue(this: *Self, comptime T: type) !T {
switch (comptime T) {
bool => {
return try this.readBool();
},
u8 => {
return try this.readByte();
},
[*:0]const u8, [:0]const u8, []const u8 => {
return try this.readArray(u8);
},
[]const [:0]const u8, []const [*:0]const u8, []const []const u8 => {
return try this.readArray([]const u8);
},
[]u8, [:0]u8, [*:0]u8 => {
return try this.readArray([]u8);
},
u16, u32, i8, i16, i32 => {
return std.mem.readIntSliceNative(T, try this.read(@sizeOf(T)));
},
else => {
switch (comptime @typeInfo(T)) {
.Struct => |Struct| {
switch (Struct.layout) {
.Packed => {
const sizeof = @sizeOf(T);
var slice = try this.read(sizeof);
return @ptrCast(*T, slice[0..sizeof]).*;
},
else => {},
}
},
.Enum => {
return try this.readEnum(T);
},
else => {},
}
return try T.decode(this);
},
}
@compileError("Invalid type passed to readValue");
}
};
pub fn Writer(comptime WritableStream: type) type {
return struct {
const Self = @This();
writable: WritableStream,
pub fn init(writable: WritableStream) Self {
return Self{ .writable = writable };
}
pub inline fn write(this: *Self, bytes: anytype) !void {
_ = try this.writable.write(bytes);
}
pub inline fn writeByte(this: *Self, byte: u8) !void {
_ = try this.writable.write(&[1]u8{byte});
}
pub inline fn writeInt(this: *Self, int: anytype) !void {
try this.write(std.mem.asBytes(&int));
}
pub inline fn writeFieldID(this: *Self, comptime id: comptime_int) !void {
try this.writeByte(id);
}
pub inline fn writeEnum(this: *Self, val: anytype) !void {
try this.writeInt(@enumToInt(val));
}
pub fn writeValue(this: *Self, comptime SliceType: type, slice: SliceType) !void {
switch (SliceType) {
[]u16,
[]u32,
[]i16,
[]i32,
[]i8,
[]const u16,
[]const u32,
[]const i16,
[]const i32,
[]const i8,
[:0]u16,
[:0]u32,
[:0]i16,
[:0]i32,
[:0]i8,
[:0]const u16,
[:0]const u32,
[:0]const i16,
[:0]const i32,
[:0]const i8,
[*:0]u16,
[*:0]u32,
[*:0]i16,
[*:0]i32,
[*:0]i8,
[*:0]const u16,
[*:0]const u32,
[*:0]const i16,
[*:0]const i32,
[*:0]const i8,
=> {
try this.writeArray(SliceType, slice);
},
[]u8,
[]const u8,
[:0]u8,
[:0]const u8,
[*:0]u8,
[*:0]const u8,
=> {
try this.writeArray(u8, slice);
},
u8 => {
try this.write(slice);
},
u16, u32, i16, i32, i8 => {
try this.write(std.mem.asBytes(slice));
},
else => {
try slice.encode(this);
},
}
}
pub inline fn writeArray(this: *Self, comptime T: type, slice: anytype) !void {
try this.writeInt(@truncate(u32, slice.len));
switch (T) {
u8 => {
try this.write(slice);
},
u16, u32, i16, i32, i8 => {
try this.write(std.mem.asBytes(slice));
},
[:0]u8,
[]u8,
[]u16,
[]u32,
[]i16,
[]i32,
[]i8,
[]const u8,
[:0]const u8,
[]const u16,
[]const u32,
[]const i16,
[]const i32,
[]const i8,
[:0]u16,
[:0]u32,
[:0]i16,
[:0]i32,
[:0]i8,
[:0]const u16,
[:0]const u32,
[:0]const i16,
[:0]const i32,
[:0]const i8,
[*:0]u16,
[*:0]u32,
[*:0]i16,
[*:0]i32,
[*:0]i8,
[*:0]const u16,
[*:0]const u32,
[*:0]const i16,
[*:0]const i32,
[*:0]const i8,
=> {
for (slice) |num_slice| {
try this.writeArray(std.meta.Child(@TypeOf(num_slice)), num_slice);
}
},
else => {
for (slice) |val| {
try val.encode(this);
}
},
}
}
pub inline fn endMessage(this: *Self) !void {
try this.writeByte(0);
}
};
}
pub const ByteWriter = Writer(*std.io.FixedBufferStream([]u8));
pub const FileWriter = Writer(std.fs.File);
// --- DIVIDING LINE ---- | js/peechy.zig |
const std = @import("std");
const sqlite = @import("sqlite");
const manage_main = @import("main.zig");
const libpcre = @import("libpcre");
const Context = manage_main.Context;
const log = std.log.scoped(.awtfdb_janitor);
const VERSION = "0.0.1";
const HELPTEXT =
\\ awtfdb-janitor: investigate the semantic consistency of the index file
\\
\\ usage:
\\ awtfdb-janitor
\\
\\ options:
\\ -h prints this help and exits
\\ -V prints version and exits
\\ --repair attempt to repair consistency
\\ (this operation may be destructive to
\\ the index file, only run this manually)
;
pub fn main() anyerror!u8 {
const rc = sqlite.c.sqlite3_config(sqlite.c.SQLITE_CONFIG_LOG, manage_main.sqliteLog, @as(?*anyopaque, null));
if (rc != sqlite.c.SQLITE_OK) {
std.log.err("failed to configure: {d} '{s}'", .{
rc, sqlite.c.sqlite3_errstr(rc),
});
return error.ConfigFail;
}
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
var allocator = gpa.allocator();
var args_it = std.process.args();
_ = args_it.skip();
const Args = struct {
help: bool = false,
version: bool = false,
repair: bool = false,
full: bool = false,
};
var given_args = Args{};
while (args_it.next()) |arg| {
if (std.mem.eql(u8, arg, "-h")) {
given_args.help = true;
} else if (std.mem.eql(u8, arg, "-V")) {
given_args.version = true;
} else if (std.mem.eql(u8, arg, "--repair")) {
given_args.repair = true;
} else if (std.mem.eql(u8, arg, "--full")) {
given_args.full = true;
} else {
return error.InvalidArgument;
}
}
if (given_args.help) {
std.debug.print(HELPTEXT, .{});
return 1;
} else if (given_args.version) {
std.debug.print("awtfdb-janitor {s}\n", .{VERSION});
return 1;
}
var ctx = Context{
.home_path = null,
.args_it = undefined,
.stdout = undefined,
.db = null,
.allocator = allocator,
};
defer ctx.deinit();
try ctx.loadDatabase(.{});
var stmt = try ctx.db.?.prepare(
\\ select file_hash, local_path
\\ from files
\\ order by file_hash asc
);
defer stmt.deinit();
const FileRow = struct {
file_hash: i64,
local_path: []const u8,
};
var iter = try stmt.iterator(
FileRow,
.{},
);
const Counter = struct { total: usize = 0, unrepairable: usize = 0 };
var counters: struct {
file_not_found: Counter = .{},
incorrect_hash_files: Counter = .{},
incorrect_hash_cores: Counter = .{},
unused_hash: Counter = .{},
} = .{};
var savepoint = try ctx.db.?.savepoint("janitor");
errdefer savepoint.rollback();
defer savepoint.commit();
while (try iter.nextAlloc(allocator, .{})) |row| {
defer allocator.free(row.local_path);
const indexed_file = (try ctx.fetchFileExact(row.file_hash, row.local_path)) orelse return error.InconsistentIndex;
defer indexed_file.deinit();
var file = std.fs.openFileAbsolute(row.local_path, .{ .mode = .read_only }) catch |err| switch (err) {
error.FileNotFound => {
log.err("file {s} not found", .{row.local_path});
counters.file_not_found.total += 1;
const repeated_count = (try ctx.db.?.one(
i64,
\\ select count(*)
\\ from files
\\ where file_hash = ?
,
.{},
.{row.file_hash},
)).?;
std.debug.assert(repeated_count != 0);
if (repeated_count > 1) {
// repair action: delete old entry to keep index consistent
log.warn(
"found {d} files with same hash, assuming a file move happened for {d}",
.{ repeated_count, row.file_hash },
);
if (given_args.repair) {
try indexed_file.delete();
}
} else if (repeated_count == 1) {
log.err(
"can not repair {s} as it is not indexed, please index a file with same contents or remove it manually from the index",
.{row.local_path},
);
counters.file_not_found.unrepairable += 1;
if (given_args.repair) {
return error.ManualInterventionRequired;
}
}
continue;
},
else => return err,
};
defer file.close();
if (given_args.full) {
var calculated_hash = try ctx.calculateHash(file, .{ .insert_new_hash = false });
if (!std.mem.eql(u8, &calculated_hash.hash_data, &indexed_file.hash.hash_data)) {
// repair option: fuck
counters.incorrect_hash_files.total += 1;
counters.incorrect_hash_files.unrepairable += 1;
log.err(
"hashes are incorrect for file {d}",
.{row.file_hash},
);
if (given_args.repair) {
return error.ManualInterventionRequired;
}
continue;
}
}
log.info("path {s} ok", .{row.local_path});
}
// calculate hashes for tag_cores
var cores_stmt = try ctx.db.?.prepare(
\\ select core_hash, core_data
\\ from tag_cores
\\ order by core_hash asc
);
defer cores_stmt.deinit();
var cores_iter = try cores_stmt.iterator(struct {
core_hash: i64,
core_data: sqlite.Blob,
}, .{});
while (try cores_iter.nextAlloc(allocator, .{})) |core_with_blob| {
defer allocator.free(core_with_blob.core_data.data);
const calculated_hash = try ctx.calculateHashFromMemory(
core_with_blob.core_data.data,
.{ .insert_new_hash = false },
);
var hash_with_blob = (try ctx.db.?.oneAlloc(
Context.HashWithBlob,
allocator,
\\ select id, hash_data
\\ from hashes
\\ where id = ?
,
.{},
.{core_with_blob.core_hash},
)).?;
defer allocator.free(hash_with_blob.hash_data.data);
const upstream_hash = hash_with_blob.toRealHash();
if (!std.mem.eql(u8, &calculated_hash.hash_data, &upstream_hash.hash_data)) {
counters.incorrect_hash_cores.total += 1;
counters.incorrect_hash_cores.unrepairable += 1;
log.err(
"hashes are incorrect for tag core {d} ({s} != {s})",
.{ core_with_blob.core_hash, calculated_hash, upstream_hash },
);
if (given_args.repair) {
return error.ManualInterventionRequired;
}
continue;
}
// TODO validate if there's any tag names to the core
}
// garbage collect unused entires in hashes table
var hashes_stmt = try ctx.db.?.prepare(
\\ select id
\\ from hashes
\\ order by id asc
);
defer hashes_stmt.deinit();
var hashes_iter = try hashes_stmt.iterator(i64, .{});
while (try hashes_iter.nextAlloc(allocator, .{})) |hash_id| {
const core_count = (try ctx.db.?.one(
i64,
\\ select count(*) from tag_cores
\\ where core_hash = ?
,
.{},
.{hash_id},
)).?;
if (core_count > 0) continue;
const file_count = (try ctx.db.?.one(
i64,
\\ select count(*) from files
\\ where file_hash = ?
,
.{},
.{hash_id},
)).?;
if (file_count > 0) continue;
log.warn("unused hash in table: {d}", .{hash_id});
counters.unused_hash.total += 1;
if (given_args.repair) {
try ctx.db.?.exec(
\\ delete from hashes
\\ where id = ?
,
.{},
.{hash_id},
);
log.info("deleted hash {d}", .{hash_id});
}
}
const CountersTypeInfo = @typeInfo(@TypeOf(counters));
var total_problems: usize = 0;
inline for (CountersTypeInfo.Struct.fields) |field| {
const total = @field(counters, field.name).total;
log.info("problem {s}, {d} found, {d} unrepairable", .{
field.name,
total,
@field(counters, field.name).unrepairable,
});
total_problems += total;
}
if ((!given_args.repair) and total_problems > 0) {
log.info("this database has identified problems, please run --repair", .{});
return 2;
}
return 0;
} | src/janitor_main.zig |
pub const DWM_BB_ENABLE = @as(u32, 1);
pub const DWM_BB_BLURREGION = @as(u32, 2);
pub const DWM_BB_TRANSITIONONMAXIMIZED = @as(u32, 4);
pub const DWM_CLOAKED_APP = @as(u32, 1);
pub const DWM_CLOAKED_SHELL = @as(u32, 2);
pub const DWM_CLOAKED_INHERITED = @as(u32, 4);
pub const DWM_TNP_RECTDESTINATION = @as(u32, 1);
pub const DWM_TNP_RECTSOURCE = @as(u32, 2);
pub const DWM_TNP_OPACITY = @as(u32, 4);
pub const DWM_TNP_VISIBLE = @as(u32, 8);
pub const DWM_TNP_SOURCECLIENTAREAONLY = @as(u32, 16);
pub const DWM_FRAME_DURATION_DEFAULT = @as(i32, -1);
pub const DWM_EC_DISABLECOMPOSITION = @as(u32, 0);
pub const DWM_EC_ENABLECOMPOSITION = @as(u32, 1);
pub const DWM_SIT_DISPLAYFRAME = @as(u32, 1);
pub const c_DwmMaxQueuedBuffers = @as(u32, 8);
pub const c_DwmMaxMonitors = @as(u32, 16);
pub const c_DwmMaxAdapters = @as(u32, 16);
//--------------------------------------------------------------------------------
// Section: Types (14)
//--------------------------------------------------------------------------------
pub const DWM_BLURBEHIND = packed struct {
dwFlags: u32,
fEnable: BOOL,
hRgnBlur: ?HRGN,
fTransitionOnMaximized: BOOL,
};
pub const DWMWINDOWATTRIBUTE = enum(i32) {
NCRENDERING_ENABLED = 1,
NCRENDERING_POLICY = 2,
TRANSITIONS_FORCEDISABLED = 3,
ALLOW_NCPAINT = 4,
CAPTION_BUTTON_BOUNDS = 5,
NONCLIENT_RTL_LAYOUT = 6,
FORCE_ICONIC_REPRESENTATION = 7,
FLIP3D_POLICY = 8,
EXTENDED_FRAME_BOUNDS = 9,
HAS_ICONIC_BITMAP = 10,
DISALLOW_PEEK = 11,
EXCLUDED_FROM_PEEK = 12,
CLOAK = 13,
CLOAKED = 14,
FREEZE_REPRESENTATION = 15,
PASSIVE_UPDATE_MODE = 16,
LAST = 17,
};
pub const DWMWA_NCRENDERING_ENABLED = DWMWINDOWATTRIBUTE.NCRENDERING_ENABLED;
pub const DWMWA_NCRENDERING_POLICY = DWMWINDOWATTRIBUTE.NCRENDERING_POLICY;
pub const DWMWA_TRANSITIONS_FORCEDISABLED = DWMWINDOWATTRIBUTE.TRANSITIONS_FORCEDISABLED;
pub const DWMWA_ALLOW_NCPAINT = DWMWINDOWATTRIBUTE.ALLOW_NCPAINT;
pub const DWMWA_CAPTION_BUTTON_BOUNDS = DWMWINDOWATTRIBUTE.CAPTION_BUTTON_BOUNDS;
pub const DWMWA_NONCLIENT_RTL_LAYOUT = DWMWINDOWATTRIBUTE.NONCLIENT_RTL_LAYOUT;
pub const DWMWA_FORCE_ICONIC_REPRESENTATION = DWMWINDOWATTRIBUTE.FORCE_ICONIC_REPRESENTATION;
pub const DWMWA_FLIP3D_POLICY = DWMWINDOWATTRIBUTE.FLIP3D_POLICY;
pub const DWMWA_EXTENDED_FRAME_BOUNDS = DWMWINDOWATTRIBUTE.EXTENDED_FRAME_BOUNDS;
pub const DWMWA_HAS_ICONIC_BITMAP = DWMWINDOWATTRIBUTE.HAS_ICONIC_BITMAP;
pub const DWMWA_DISALLOW_PEEK = DWMWINDOWATTRIBUTE.DISALLOW_PEEK;
pub const DWMWA_EXCLUDED_FROM_PEEK = DWMWINDOWATTRIBUTE.EXCLUDED_FROM_PEEK;
pub const DWMWA_CLOAK = DWMWINDOWATTRIBUTE.CLOAK;
pub const DWMWA_CLOAKED = DWMWINDOWATTRIBUTE.CLOAKED;
pub const DWMWA_FREEZE_REPRESENTATION = DWMWINDOWATTRIBUTE.FREEZE_REPRESENTATION;
pub const DWMWA_PASSIVE_UPDATE_MODE = DWMWINDOWATTRIBUTE.PASSIVE_UPDATE_MODE;
pub const DWMWA_LAST = DWMWINDOWATTRIBUTE.LAST;
pub const DWMNCRENDERINGPOLICY = enum(i32) {
USEWINDOWSTYLE = 0,
DISABLED = 1,
ENABLED = 2,
LAST = 3,
};
pub const DWMNCRP_USEWINDOWSTYLE = DWMNCRENDERINGPOLICY.USEWINDOWSTYLE;
pub const DWMNCRP_DISABLED = DWMNCRENDERINGPOLICY.DISABLED;
pub const DWMNCRP_ENABLED = DWMNCRENDERINGPOLICY.ENABLED;
pub const DWMNCRP_LAST = DWMNCRENDERINGPOLICY.LAST;
pub const DWMFLIP3DWINDOWPOLICY = enum(i32) {
DEFAULT = 0,
EXCLUDEBELOW = 1,
EXCLUDEABOVE = 2,
LAST = 3,
};
pub const DWMFLIP3D_DEFAULT = DWMFLIP3DWINDOWPOLICY.DEFAULT;
pub const DWMFLIP3D_EXCLUDEBELOW = DWMFLIP3DWINDOWPOLICY.EXCLUDEBELOW;
pub const DWMFLIP3D_EXCLUDEABOVE = DWMFLIP3DWINDOWPOLICY.EXCLUDEABOVE;
pub const DWMFLIP3D_LAST = DWMFLIP3DWINDOWPOLICY.LAST;
pub const DWM_THUMBNAIL_PROPERTIES = packed struct {
dwFlags: u32,
rcDestination: RECT,
rcSource: RECT,
opacity: u8,
fVisible: BOOL,
fSourceClientAreaOnly: BOOL,
};
pub const UNSIGNED_RATIO = packed struct {
uiNumerator: u32,
uiDenominator: u32,
};
pub const DWM_TIMING_INFO = packed struct {
cbSize: u32,
rateRefresh: UNSIGNED_RATIO,
qpcRefreshPeriod: u64,
rateCompose: UNSIGNED_RATIO,
qpcVBlank: u64,
cRefresh: u64,
cDXRefresh: u32,
qpcCompose: u64,
cFrame: u64,
cDXPresent: u32,
cRefreshFrame: u64,
cFrameSubmitted: u64,
cDXPresentSubmitted: u32,
cFrameConfirmed: u64,
cDXPresentConfirmed: u32,
cRefreshConfirmed: u64,
cDXRefreshConfirmed: u32,
cFramesLate: u64,
cFramesOutstanding: u32,
cFrameDisplayed: u64,
qpcFrameDisplayed: u64,
cRefreshFrameDisplayed: u64,
cFrameComplete: u64,
qpcFrameComplete: u64,
cFramePending: u64,
qpcFramePending: u64,
cFramesDisplayed: u64,
cFramesComplete: u64,
cFramesPending: u64,
cFramesAvailable: u64,
cFramesDropped: u64,
cFramesMissed: u64,
cRefreshNextDisplayed: u64,
cRefreshNextPresented: u64,
cRefreshesDisplayed: u64,
cRefreshesPresented: u64,
cRefreshStarted: u64,
cPixelsReceived: u64,
cPixelsDrawn: u64,
cBuffersEmpty: u64,
};
pub const DWM_SOURCE_FRAME_SAMPLING = enum(i32) {
POINT = 0,
COVERAGE = 1,
LAST = 2,
};
pub const DWM_SOURCE_FRAME_SAMPLING_POINT = DWM_SOURCE_FRAME_SAMPLING.POINT;
pub const DWM_SOURCE_FRAME_SAMPLING_COVERAGE = DWM_SOURCE_FRAME_SAMPLING.COVERAGE;
pub const DWM_SOURCE_FRAME_SAMPLING_LAST = DWM_SOURCE_FRAME_SAMPLING.LAST;
pub const DWM_PRESENT_PARAMETERS = packed struct {
cbSize: u32,
fQueue: BOOL,
cRefreshStart: u64,
cBuffer: u32,
fUseSourceRate: BOOL,
rateSource: UNSIGNED_RATIO,
cRefreshesPerFrame: u32,
eSampling: DWM_SOURCE_FRAME_SAMPLING,
};
pub const MilMatrix3x2D = packed struct {
S_11: f64,
S_12: f64,
S_21: f64,
S_22: f64,
DX: f64,
DY: f64,
};
pub const DWMTRANSITION_OWNEDWINDOW_TARGET = enum(i32) {
NULL = -1,
REPOSITION = 0,
};
pub const DWMTRANSITION_OWNEDWINDOW_NULL = DWMTRANSITION_OWNEDWINDOW_TARGET.NULL;
pub const DWMTRANSITION_OWNEDWINDOW_REPOSITION = DWMTRANSITION_OWNEDWINDOW_TARGET.REPOSITION;
pub const GESTURE_TYPE = enum(i32) {
PEN_TAP = 0,
PEN_DOUBLETAP = 1,
PEN_RIGHTTAP = 2,
PEN_PRESSANDHOLD = 3,
PEN_PRESSANDHOLDABORT = 4,
TOUCH_TAP = 5,
TOUCH_DOUBLETAP = 6,
TOUCH_RIGHTTAP = 7,
TOUCH_PRESSANDHOLD = 8,
TOUCH_PRESSANDHOLDABORT = 9,
TOUCH_PRESSANDTAP = 10,
};
pub const GT_PEN_TAP = GESTURE_TYPE.PEN_TAP;
pub const GT_PEN_DOUBLETAP = GESTURE_TYPE.PEN_DOUBLETAP;
pub const GT_PEN_RIGHTTAP = GESTURE_TYPE.PEN_RIGHTTAP;
pub const GT_PEN_PRESSANDHOLD = GESTURE_TYPE.PEN_PRESSANDHOLD;
pub const GT_PEN_PRESSANDHOLDABORT = GESTURE_TYPE.PEN_PRESSANDHOLDABORT;
pub const GT_TOUCH_TAP = GESTURE_TYPE.TOUCH_TAP;
pub const GT_TOUCH_DOUBLETAP = GESTURE_TYPE.TOUCH_DOUBLETAP;
pub const GT_TOUCH_RIGHTTAP = GESTURE_TYPE.TOUCH_RIGHTTAP;
pub const GT_TOUCH_PRESSANDHOLD = GESTURE_TYPE.TOUCH_PRESSANDHOLD;
pub const GT_TOUCH_PRESSANDHOLDABORT = GESTURE_TYPE.TOUCH_PRESSANDHOLDABORT;
pub const GT_TOUCH_PRESSANDTAP = GESTURE_TYPE.TOUCH_PRESSANDTAP;
pub const DWM_SHOWCONTACT = enum(u32) {
DOWN = 1,
UP = 2,
DRAG = 4,
HOLD = 8,
PENBARREL = 16,
NONE = 0,
ALL = 4294967295,
_,
pub fn initFlags(o: struct {
DOWN: u1 = 0,
UP: u1 = 0,
DRAG: u1 = 0,
HOLD: u1 = 0,
PENBARREL: u1 = 0,
NONE: u1 = 0,
ALL: u1 = 0,
}) DWM_SHOWCONTACT {
return @intToEnum(DWM_SHOWCONTACT,
(if (o.DOWN == 1) @enumToInt(DWM_SHOWCONTACT.DOWN) else 0)
| (if (o.UP == 1) @enumToInt(DWM_SHOWCONTACT.UP) else 0)
| (if (o.DRAG == 1) @enumToInt(DWM_SHOWCONTACT.DRAG) else 0)
| (if (o.HOLD == 1) @enumToInt(DWM_SHOWCONTACT.HOLD) else 0)
| (if (o.PENBARREL == 1) @enumToInt(DWM_SHOWCONTACT.PENBARREL) else 0)
| (if (o.NONE == 1) @enumToInt(DWM_SHOWCONTACT.NONE) else 0)
| (if (o.ALL == 1) @enumToInt(DWM_SHOWCONTACT.ALL) else 0)
);
}
};
pub const DWMSC_DOWN = DWM_SHOWCONTACT.DOWN;
pub const DWMSC_UP = DWM_SHOWCONTACT.UP;
pub const DWMSC_DRAG = DWM_SHOWCONTACT.DRAG;
pub const DWMSC_HOLD = DWM_SHOWCONTACT.HOLD;
pub const DWMSC_PENBARREL = DWM_SHOWCONTACT.PENBARREL;
pub const DWMSC_NONE = DWM_SHOWCONTACT.NONE;
pub const DWMSC_ALL = DWM_SHOWCONTACT.ALL;
pub const DWM_TAB_WINDOW_REQUIREMENTS = enum(u32) {
NONE = 0,
IMPLEMENTED_BY_SYSTEM = 1,
WINDOW_RELATIONSHIP = 2,
WINDOW_STYLES = 4,
WINDOW_REGION = 8,
WINDOW_DWM_ATTRIBUTES = 16,
WINDOW_MARGINS = 32,
TABBING_ENABLED = 64,
USER_POLICY = 128,
GROUP_POLICY = 256,
APP_COMPAT = 512,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
IMPLEMENTED_BY_SYSTEM: u1 = 0,
WINDOW_RELATIONSHIP: u1 = 0,
WINDOW_STYLES: u1 = 0,
WINDOW_REGION: u1 = 0,
WINDOW_DWM_ATTRIBUTES: u1 = 0,
WINDOW_MARGINS: u1 = 0,
TABBING_ENABLED: u1 = 0,
USER_POLICY: u1 = 0,
GROUP_POLICY: u1 = 0,
APP_COMPAT: u1 = 0,
}) DWM_TAB_WINDOW_REQUIREMENTS {
return @intToEnum(DWM_TAB_WINDOW_REQUIREMENTS,
(if (o.NONE == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.NONE) else 0)
| (if (o.IMPLEMENTED_BY_SYSTEM == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.IMPLEMENTED_BY_SYSTEM) else 0)
| (if (o.WINDOW_RELATIONSHIP == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_RELATIONSHIP) else 0)
| (if (o.WINDOW_STYLES == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_STYLES) else 0)
| (if (o.WINDOW_REGION == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_REGION) else 0)
| (if (o.WINDOW_DWM_ATTRIBUTES == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_DWM_ATTRIBUTES) else 0)
| (if (o.WINDOW_MARGINS == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_MARGINS) else 0)
| (if (o.TABBING_ENABLED == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.TABBING_ENABLED) else 0)
| (if (o.USER_POLICY == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.USER_POLICY) else 0)
| (if (o.GROUP_POLICY == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.GROUP_POLICY) else 0)
| (if (o.APP_COMPAT == 1) @enumToInt(DWM_TAB_WINDOW_REQUIREMENTS.APP_COMPAT) else 0)
);
}
};
pub const DWMTWR_NONE = DWM_TAB_WINDOW_REQUIREMENTS.NONE;
pub const DWMTWR_IMPLEMENTED_BY_SYSTEM = DWM_TAB_WINDOW_REQUIREMENTS.IMPLEMENTED_BY_SYSTEM;
pub const DWMTWR_WINDOW_RELATIONSHIP = DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_RELATIONSHIP;
pub const DWMTWR_WINDOW_STYLES = DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_STYLES;
pub const DWMTWR_WINDOW_REGION = DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_REGION;
pub const DWMTWR_WINDOW_DWM_ATTRIBUTES = DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_DWM_ATTRIBUTES;
pub const DWMTWR_WINDOW_MARGINS = DWM_TAB_WINDOW_REQUIREMENTS.WINDOW_MARGINS;
pub const DWMTWR_TABBING_ENABLED = DWM_TAB_WINDOW_REQUIREMENTS.TABBING_ENABLED;
pub const DWMTWR_USER_POLICY = DWM_TAB_WINDOW_REQUIREMENTS.USER_POLICY;
pub const DWMTWR_GROUP_POLICY = DWM_TAB_WINDOW_REQUIREMENTS.GROUP_POLICY;
pub const DWMTWR_APP_COMPAT = DWM_TAB_WINDOW_REQUIREMENTS.APP_COMPAT;
//--------------------------------------------------------------------------------
// Section: Functions (31)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmDefWindowProc(
hWnd: ?HWND,
msg: u32,
wParam: WPARAM,
lParam: LPARAM,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmEnableBlurBehindWindow(
hWnd: ?HWND,
pBlurBehind: ?*const DWM_BLURBEHIND,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmEnableComposition(
uCompositionAction: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmEnableMMCSS(
fEnableMMCSS: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmExtendFrameIntoClientArea(
hWnd: ?HWND,
pMarInset: ?*const MARGINS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmGetColorizationColor(
pcrColorization: ?*u32,
pfOpaqueBlend: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmGetCompositionTimingInfo(
hwnd: ?HWND,
pTimingInfo: ?*DWM_TIMING_INFO,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmGetWindowAttribute(
hwnd: ?HWND,
dwAttribute: DWMWINDOWATTRIBUTE,
// TODO: what to do with BytesParamIndex 3?
pvAttribute: ?*c_void,
cbAttribute: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmIsCompositionEnabled(
pfEnabled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmModifyPreviousDxFrameDuration(
hwnd: ?HWND,
cRefreshes: i32,
fRelative: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmQueryThumbnailSourceSize(
hThumbnail: isize,
pSize: ?*SIZE,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmRegisterThumbnail(
hwndDestination: ?HWND,
hwndSource: ?HWND,
phThumbnailId: ?*isize,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmSetDxFrameDuration(
hwnd: ?HWND,
cRefreshes: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmSetPresentParameters(
hwnd: ?HWND,
pPresentParams: ?*DWM_PRESENT_PARAMETERS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmSetWindowAttribute(
hwnd: ?HWND,
dwAttribute: DWMWINDOWATTRIBUTE,
// TODO: what to do with BytesParamIndex 3?
pvAttribute: ?*const c_void,
cbAttribute: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmUnregisterThumbnail(
hThumbnailId: isize,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmUpdateThumbnailProperties(
hThumbnailId: isize,
ptnProperties: ?*const DWM_THUMBNAIL_PROPERTIES,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "dwmapi" fn DwmSetIconicThumbnail(
hwnd: ?HWND,
hbmp: ?HBITMAP,
dwSITFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "dwmapi" fn DwmSetIconicLivePreviewBitmap(
hwnd: ?HWND,
hbmp: ?HBITMAP,
pptClient: ?*POINT,
dwSITFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "dwmapi" fn DwmInvalidateIconicBitmaps(
hwnd: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmAttachMilContent(
hwnd: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmDetachMilContent(
hwnd: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmFlush(
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmGetGraphicsStreamTransformHint(
uIndex: u32,
pTransform: ?*MilMatrix3x2D,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmGetGraphicsStreamClient(
uIndex: u32,
pClientUuid: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "dwmapi" fn DwmGetTransportAttributes(
pfIsRemoting: ?*BOOL,
pfIsConnected: ?*BOOL,
pDwGeneration: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows8.0'
pub extern "dwmapi" fn DwmTransitionOwnedWindow(
hwnd: ?HWND,
target: DWMTRANSITION_OWNEDWINDOW_TARGET,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows8.0'
pub extern "dwmapi" fn DwmRenderGesture(
gt: GESTURE_TYPE,
cContacts: u32,
pdwPointerID: [*]const u32,
pPoints: [*]const POINT,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows8.0'
pub extern "dwmapi" fn DwmTetherContact(
dwPointerID: u32,
fEnable: BOOL,
ptTether: POINT,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows8.0'
pub extern "dwmapi" fn DwmShowContact(
dwPointerID: u32,
eShowContact: DWM_SHOWCONTACT,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows10.0.17134'
pub extern "dwmapi" fn DwmGetUnmetTabRequirements(
appWindow: ?HWND,
value: ?*DWM_TAB_WINDOW_REQUIREMENTS,
) 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 (13)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const HBITMAP = @import("../graphics/gdi.zig").HBITMAP;
const HRESULT = @import("../foundation.zig").HRESULT;
const HRGN = @import("../graphics/gdi.zig").HRGN;
const HWND = @import("../foundation.zig").HWND;
const LPARAM = @import("../foundation.zig").LPARAM;
const LRESULT = @import("../foundation.zig").LRESULT;
const MARGINS = @import("../ui/controls.zig").MARGINS;
const POINT = @import("../foundation.zig").POINT;
const RECT = @import("../foundation.zig").RECT;
const SIZE = @import("../foundation.zig").SIZE;
const WPARAM = @import("../foundation.zig").WPARAM;
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;
}
}
} | deps/zigwin32/win32/graphics/dwm.zig |
pub const PSS_PERF_RESOLUTION = @as(u32, 1000000);
//--------------------------------------------------------------------------------
// Section: Types (23)
//--------------------------------------------------------------------------------
pub const HPSS = *opaque{};
pub const HPSSWALK = *opaque{};
pub const PSS_HANDLE_FLAGS = enum(u32) {
NONE = 0,
HAVE_TYPE = 1,
HAVE_NAME = 2,
HAVE_BASIC_INFORMATION = 4,
HAVE_TYPE_SPECIFIC_INFORMATION = 8,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
HAVE_TYPE: u1 = 0,
HAVE_NAME: u1 = 0,
HAVE_BASIC_INFORMATION: u1 = 0,
HAVE_TYPE_SPECIFIC_INFORMATION: u1 = 0,
}) PSS_HANDLE_FLAGS {
return @intToEnum(PSS_HANDLE_FLAGS,
(if (o.NONE == 1) @enumToInt(PSS_HANDLE_FLAGS.NONE) else 0)
| (if (o.HAVE_TYPE == 1) @enumToInt(PSS_HANDLE_FLAGS.HAVE_TYPE) else 0)
| (if (o.HAVE_NAME == 1) @enumToInt(PSS_HANDLE_FLAGS.HAVE_NAME) else 0)
| (if (o.HAVE_BASIC_INFORMATION == 1) @enumToInt(PSS_HANDLE_FLAGS.HAVE_BASIC_INFORMATION) else 0)
| (if (o.HAVE_TYPE_SPECIFIC_INFORMATION == 1) @enumToInt(PSS_HANDLE_FLAGS.HAVE_TYPE_SPECIFIC_INFORMATION) else 0)
);
}
};
pub const PSS_HANDLE_NONE = PSS_HANDLE_FLAGS.NONE;
pub const PSS_HANDLE_HAVE_TYPE = PSS_HANDLE_FLAGS.HAVE_TYPE;
pub const PSS_HANDLE_HAVE_NAME = PSS_HANDLE_FLAGS.HAVE_NAME;
pub const PSS_HANDLE_HAVE_BASIC_INFORMATION = PSS_HANDLE_FLAGS.HAVE_BASIC_INFORMATION;
pub const PSS_HANDLE_HAVE_TYPE_SPECIFIC_INFORMATION = PSS_HANDLE_FLAGS.HAVE_TYPE_SPECIFIC_INFORMATION;
pub const PSS_OBJECT_TYPE = enum(i32) {
UNKNOWN = 0,
PROCESS = 1,
THREAD = 2,
MUTANT = 3,
EVENT = 4,
SECTION = 5,
SEMAPHORE = 6,
};
pub const PSS_OBJECT_TYPE_UNKNOWN = PSS_OBJECT_TYPE.UNKNOWN;
pub const PSS_OBJECT_TYPE_PROCESS = PSS_OBJECT_TYPE.PROCESS;
pub const PSS_OBJECT_TYPE_THREAD = PSS_OBJECT_TYPE.THREAD;
pub const PSS_OBJECT_TYPE_MUTANT = PSS_OBJECT_TYPE.MUTANT;
pub const PSS_OBJECT_TYPE_EVENT = PSS_OBJECT_TYPE.EVENT;
pub const PSS_OBJECT_TYPE_SECTION = PSS_OBJECT_TYPE.SECTION;
pub const PSS_OBJECT_TYPE_SEMAPHORE = PSS_OBJECT_TYPE.SEMAPHORE;
pub const PSS_CAPTURE_FLAGS = enum(u32) {
APTURE_NONE = 0,
APTURE_VA_CLONE = 1,
APTURE_RESERVED_00000002 = 2,
APTURE_HANDLES = 4,
APTURE_HANDLE_NAME_INFORMATION = 8,
APTURE_HANDLE_BASIC_INFORMATION = 16,
APTURE_HANDLE_TYPE_SPECIFIC_INFORMATION = 32,
APTURE_HANDLE_TRACE = 64,
APTURE_THREADS = 128,
APTURE_THREAD_CONTEXT = 256,
APTURE_THREAD_CONTEXT_EXTENDED = 512,
APTURE_RESERVED_00000400 = 1024,
APTURE_VA_SPACE = 2048,
APTURE_VA_SPACE_SECTION_INFORMATION = 4096,
APTURE_IPT_TRACE = 8192,
APTURE_RESERVED_00004000 = 16384,
REATE_BREAKAWAY_OPTIONAL = 67108864,
REATE_BREAKAWAY = 134217728,
REATE_FORCE_BREAKAWAY = 268435456,
REATE_USE_VM_ALLOCATIONS = 536870912,
REATE_MEASURE_PERFORMANCE = 1073741824,
REATE_RELEASE_SECTION = 2147483648,
_,
pub fn initFlags(o: struct {
APTURE_NONE: u1 = 0,
APTURE_VA_CLONE: u1 = 0,
APTURE_RESERVED_00000002: u1 = 0,
APTURE_HANDLES: u1 = 0,
APTURE_HANDLE_NAME_INFORMATION: u1 = 0,
APTURE_HANDLE_BASIC_INFORMATION: u1 = 0,
APTURE_HANDLE_TYPE_SPECIFIC_INFORMATION: u1 = 0,
APTURE_HANDLE_TRACE: u1 = 0,
APTURE_THREADS: u1 = 0,
APTURE_THREAD_CONTEXT: u1 = 0,
APTURE_THREAD_CONTEXT_EXTENDED: u1 = 0,
APTURE_RESERVED_00000400: u1 = 0,
APTURE_VA_SPACE: u1 = 0,
APTURE_VA_SPACE_SECTION_INFORMATION: u1 = 0,
APTURE_IPT_TRACE: u1 = 0,
APTURE_RESERVED_00004000: u1 = 0,
REATE_BREAKAWAY_OPTIONAL: u1 = 0,
REATE_BREAKAWAY: u1 = 0,
REATE_FORCE_BREAKAWAY: u1 = 0,
REATE_USE_VM_ALLOCATIONS: u1 = 0,
REATE_MEASURE_PERFORMANCE: u1 = 0,
REATE_RELEASE_SECTION: u1 = 0,
}) PSS_CAPTURE_FLAGS {
return @intToEnum(PSS_CAPTURE_FLAGS,
(if (o.APTURE_NONE == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_NONE) else 0)
| (if (o.APTURE_VA_CLONE == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_VA_CLONE) else 0)
| (if (o.APTURE_RESERVED_00000002 == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_RESERVED_00000002) else 0)
| (if (o.APTURE_HANDLES == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_HANDLES) else 0)
| (if (o.APTURE_HANDLE_NAME_INFORMATION == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_HANDLE_NAME_INFORMATION) else 0)
| (if (o.APTURE_HANDLE_BASIC_INFORMATION == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_HANDLE_BASIC_INFORMATION) else 0)
| (if (o.APTURE_HANDLE_TYPE_SPECIFIC_INFORMATION == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_HANDLE_TYPE_SPECIFIC_INFORMATION) else 0)
| (if (o.APTURE_HANDLE_TRACE == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_HANDLE_TRACE) else 0)
| (if (o.APTURE_THREADS == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_THREADS) else 0)
| (if (o.APTURE_THREAD_CONTEXT == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_THREAD_CONTEXT) else 0)
| (if (o.APTURE_THREAD_CONTEXT_EXTENDED == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_THREAD_CONTEXT_EXTENDED) else 0)
| (if (o.APTURE_RESERVED_00000400 == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_RESERVED_00000400) else 0)
| (if (o.APTURE_VA_SPACE == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_VA_SPACE) else 0)
| (if (o.APTURE_VA_SPACE_SECTION_INFORMATION == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_VA_SPACE_SECTION_INFORMATION) else 0)
| (if (o.APTURE_IPT_TRACE == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_IPT_TRACE) else 0)
| (if (o.APTURE_RESERVED_00004000 == 1) @enumToInt(PSS_CAPTURE_FLAGS.APTURE_RESERVED_00004000) else 0)
| (if (o.REATE_BREAKAWAY_OPTIONAL == 1) @enumToInt(PSS_CAPTURE_FLAGS.REATE_BREAKAWAY_OPTIONAL) else 0)
| (if (o.REATE_BREAKAWAY == 1) @enumToInt(PSS_CAPTURE_FLAGS.REATE_BREAKAWAY) else 0)
| (if (o.REATE_FORCE_BREAKAWAY == 1) @enumToInt(PSS_CAPTURE_FLAGS.REATE_FORCE_BREAKAWAY) else 0)
| (if (o.REATE_USE_VM_ALLOCATIONS == 1) @enumToInt(PSS_CAPTURE_FLAGS.REATE_USE_VM_ALLOCATIONS) else 0)
| (if (o.REATE_MEASURE_PERFORMANCE == 1) @enumToInt(PSS_CAPTURE_FLAGS.REATE_MEASURE_PERFORMANCE) else 0)
| (if (o.REATE_RELEASE_SECTION == 1) @enumToInt(PSS_CAPTURE_FLAGS.REATE_RELEASE_SECTION) else 0)
);
}
};
pub const PSS_CAPTURE_NONE = PSS_CAPTURE_FLAGS.APTURE_NONE;
pub const PSS_CAPTURE_VA_CLONE = PSS_CAPTURE_FLAGS.APTURE_VA_CLONE;
pub const PSS_CAPTURE_RESERVED_00000002 = PSS_CAPTURE_FLAGS.APTURE_RESERVED_00000002;
pub const PSS_CAPTURE_HANDLES = PSS_CAPTURE_FLAGS.APTURE_HANDLES;
pub const PSS_CAPTURE_HANDLE_NAME_INFORMATION = PSS_CAPTURE_FLAGS.APTURE_HANDLE_NAME_INFORMATION;
pub const PSS_CAPTURE_HANDLE_BASIC_INFORMATION = PSS_CAPTURE_FLAGS.APTURE_HANDLE_BASIC_INFORMATION;
pub const PSS_CAPTURE_HANDLE_TYPE_SPECIFIC_INFORMATION = PSS_CAPTURE_FLAGS.APTURE_HANDLE_TYPE_SPECIFIC_INFORMATION;
pub const PSS_CAPTURE_HANDLE_TRACE = PSS_CAPTURE_FLAGS.APTURE_HANDLE_TRACE;
pub const PSS_CAPTURE_THREADS = PSS_CAPTURE_FLAGS.APTURE_THREADS;
pub const PSS_CAPTURE_THREAD_CONTEXT = PSS_CAPTURE_FLAGS.APTURE_THREAD_CONTEXT;
pub const PSS_CAPTURE_THREAD_CONTEXT_EXTENDED = PSS_CAPTURE_FLAGS.APTURE_THREAD_CONTEXT_EXTENDED;
pub const PSS_CAPTURE_RESERVED_00000400 = PSS_CAPTURE_FLAGS.APTURE_RESERVED_00000400;
pub const PSS_CAPTURE_VA_SPACE = PSS_CAPTURE_FLAGS.APTURE_VA_SPACE;
pub const PSS_CAPTURE_VA_SPACE_SECTION_INFORMATION = PSS_CAPTURE_FLAGS.APTURE_VA_SPACE_SECTION_INFORMATION;
pub const PSS_CAPTURE_IPT_TRACE = PSS_CAPTURE_FLAGS.APTURE_IPT_TRACE;
pub const PSS_CAPTURE_RESERVED_00004000 = PSS_CAPTURE_FLAGS.APTURE_RESERVED_00004000;
pub const PSS_CREATE_BREAKAWAY_OPTIONAL = PSS_CAPTURE_FLAGS.REATE_BREAKAWAY_OPTIONAL;
pub const PSS_CREATE_BREAKAWAY = PSS_CAPTURE_FLAGS.REATE_BREAKAWAY;
pub const PSS_CREATE_FORCE_BREAKAWAY = PSS_CAPTURE_FLAGS.REATE_FORCE_BREAKAWAY;
pub const PSS_CREATE_USE_VM_ALLOCATIONS = PSS_CAPTURE_FLAGS.REATE_USE_VM_ALLOCATIONS;
pub const PSS_CREATE_MEASURE_PERFORMANCE = PSS_CAPTURE_FLAGS.REATE_MEASURE_PERFORMANCE;
pub const PSS_CREATE_RELEASE_SECTION = PSS_CAPTURE_FLAGS.REATE_RELEASE_SECTION;
pub const PSS_QUERY_INFORMATION_CLASS = enum(i32) {
PROCESS_INFORMATION = 0,
VA_CLONE_INFORMATION = 1,
AUXILIARY_PAGES_INFORMATION = 2,
VA_SPACE_INFORMATION = 3,
HANDLE_INFORMATION = 4,
THREAD_INFORMATION = 5,
HANDLE_TRACE_INFORMATION = 6,
PERFORMANCE_COUNTERS = 7,
};
pub const PSS_QUERY_PROCESS_INFORMATION = PSS_QUERY_INFORMATION_CLASS.PROCESS_INFORMATION;
pub const PSS_QUERY_VA_CLONE_INFORMATION = PSS_QUERY_INFORMATION_CLASS.VA_CLONE_INFORMATION;
pub const PSS_QUERY_AUXILIARY_PAGES_INFORMATION = PSS_QUERY_INFORMATION_CLASS.AUXILIARY_PAGES_INFORMATION;
pub const PSS_QUERY_VA_SPACE_INFORMATION = PSS_QUERY_INFORMATION_CLASS.VA_SPACE_INFORMATION;
pub const PSS_QUERY_HANDLE_INFORMATION = PSS_QUERY_INFORMATION_CLASS.HANDLE_INFORMATION;
pub const PSS_QUERY_THREAD_INFORMATION = PSS_QUERY_INFORMATION_CLASS.THREAD_INFORMATION;
pub const PSS_QUERY_HANDLE_TRACE_INFORMATION = PSS_QUERY_INFORMATION_CLASS.HANDLE_TRACE_INFORMATION;
pub const PSS_QUERY_PERFORMANCE_COUNTERS = PSS_QUERY_INFORMATION_CLASS.PERFORMANCE_COUNTERS;
pub const PSS_WALK_INFORMATION_CLASS = enum(i32) {
AUXILIARY_PAGES = 0,
VA_SPACE = 1,
HANDLES = 2,
THREADS = 3,
};
pub const PSS_WALK_AUXILIARY_PAGES = PSS_WALK_INFORMATION_CLASS.AUXILIARY_PAGES;
pub const PSS_WALK_VA_SPACE = PSS_WALK_INFORMATION_CLASS.VA_SPACE;
pub const PSS_WALK_HANDLES = PSS_WALK_INFORMATION_CLASS.HANDLES;
pub const PSS_WALK_THREADS = PSS_WALK_INFORMATION_CLASS.THREADS;
pub const PSS_DUPLICATE_FLAGS = enum(u32) {
NONE = 0,
CLOSE_SOURCE = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
CLOSE_SOURCE: u1 = 0,
}) PSS_DUPLICATE_FLAGS {
return @intToEnum(PSS_DUPLICATE_FLAGS,
(if (o.NONE == 1) @enumToInt(PSS_DUPLICATE_FLAGS.NONE) else 0)
| (if (o.CLOSE_SOURCE == 1) @enumToInt(PSS_DUPLICATE_FLAGS.CLOSE_SOURCE) else 0)
);
}
};
pub const PSS_DUPLICATE_NONE = PSS_DUPLICATE_FLAGS.NONE;
pub const PSS_DUPLICATE_CLOSE_SOURCE = PSS_DUPLICATE_FLAGS.CLOSE_SOURCE;
pub const PSS_PROCESS_FLAGS = enum(u32) {
NONE = 0,
PROTECTED = 1,
WOW64 = 2,
RESERVED_03 = 4,
RESERVED_04 = 8,
FROZEN = 16,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
PROTECTED: u1 = 0,
WOW64: u1 = 0,
RESERVED_03: u1 = 0,
RESERVED_04: u1 = 0,
FROZEN: u1 = 0,
}) PSS_PROCESS_FLAGS {
return @intToEnum(PSS_PROCESS_FLAGS,
(if (o.NONE == 1) @enumToInt(PSS_PROCESS_FLAGS.NONE) else 0)
| (if (o.PROTECTED == 1) @enumToInt(PSS_PROCESS_FLAGS.PROTECTED) else 0)
| (if (o.WOW64 == 1) @enumToInt(PSS_PROCESS_FLAGS.WOW64) else 0)
| (if (o.RESERVED_03 == 1) @enumToInt(PSS_PROCESS_FLAGS.RESERVED_03) else 0)
| (if (o.RESERVED_04 == 1) @enumToInt(PSS_PROCESS_FLAGS.RESERVED_04) else 0)
| (if (o.FROZEN == 1) @enumToInt(PSS_PROCESS_FLAGS.FROZEN) else 0)
);
}
};
pub const PSS_PROCESS_FLAGS_NONE = PSS_PROCESS_FLAGS.NONE;
pub const PSS_PROCESS_FLAGS_PROTECTED = PSS_PROCESS_FLAGS.PROTECTED;
pub const PSS_PROCESS_FLAGS_WOW64 = PSS_PROCESS_FLAGS.WOW64;
pub const PSS_PROCESS_FLAGS_RESERVED_03 = PSS_PROCESS_FLAGS.RESERVED_03;
pub const PSS_PROCESS_FLAGS_RESERVED_04 = PSS_PROCESS_FLAGS.RESERVED_04;
pub const PSS_PROCESS_FLAGS_FROZEN = PSS_PROCESS_FLAGS.FROZEN;
pub const PSS_PROCESS_INFORMATION = extern struct {
ExitStatus: u32,
PebBaseAddress: ?*c_void,
AffinityMask: usize,
BasePriority: i32,
ProcessId: u32,
ParentProcessId: u32,
Flags: PSS_PROCESS_FLAGS,
CreateTime: FILETIME,
ExitTime: FILETIME,
KernelTime: FILETIME,
UserTime: FILETIME,
PriorityClass: u32,
PeakVirtualSize: usize,
VirtualSize: usize,
PageFaultCount: u32,
PeakWorkingSetSize: usize,
WorkingSetSize: usize,
QuotaPeakPagedPoolUsage: usize,
QuotaPagedPoolUsage: usize,
QuotaPeakNonPagedPoolUsage: usize,
QuotaNonPagedPoolUsage: usize,
PagefileUsage: usize,
PeakPagefileUsage: usize,
PrivateUsage: usize,
ExecuteFlags: u32,
ImageFileName: [260]u16,
};
pub const PSS_VA_CLONE_INFORMATION = extern struct {
VaCloneHandle: ?HANDLE,
};
pub const PSS_AUXILIARY_PAGES_INFORMATION = extern struct {
AuxPagesCaptured: u32,
};
pub const PSS_VA_SPACE_INFORMATION = extern struct {
RegionCount: u32,
};
pub const PSS_HANDLE_INFORMATION = extern struct {
HandlesCaptured: u32,
};
pub const PSS_THREAD_INFORMATION = extern struct {
ThreadsCaptured: u32,
ContextLength: u32,
};
pub const PSS_HANDLE_TRACE_INFORMATION = extern struct {
SectionHandle: ?HANDLE,
Size: u32,
};
pub const PSS_PERFORMANCE_COUNTERS = extern struct {
TotalCycleCount: u64,
TotalWallClockPeriod: u64,
VaCloneCycleCount: u64,
VaCloneWallClockPeriod: u64,
VaSpaceCycleCount: u64,
VaSpaceWallClockPeriod: u64,
AuxPagesCycleCount: u64,
AuxPagesWallClockPeriod: u64,
HandlesCycleCount: u64,
HandlesWallClockPeriod: u64,
ThreadsCycleCount: u64,
ThreadsWallClockPeriod: u64,
};
pub const PSS_AUXILIARY_PAGE_ENTRY = extern struct {
Address: ?*c_void,
BasicInformation: MEMORY_BASIC_INFORMATION,
CaptureTime: FILETIME,
PageContents: ?*c_void,
PageSize: u32,
};
pub const PSS_VA_SPACE_ENTRY = extern struct {
BaseAddress: ?*c_void,
AllocationBase: ?*c_void,
AllocationProtect: u32,
RegionSize: usize,
State: u32,
Protect: u32,
Type: u32,
TimeDateStamp: u32,
SizeOfImage: u32,
ImageBase: ?*c_void,
CheckSum: u32,
MappedFileNameLength: u16,
MappedFileName: ?[*:0]const u16,
};
pub const PSS_HANDLE_ENTRY = extern struct {
Handle: ?HANDLE,
Flags: PSS_HANDLE_FLAGS,
ObjectType: PSS_OBJECT_TYPE,
CaptureTime: FILETIME,
Attributes: u32,
GrantedAccess: u32,
HandleCount: u32,
PointerCount: u32,
PagedPoolCharge: u32,
NonPagedPoolCharge: u32,
CreationTime: FILETIME,
TypeNameLength: u16,
TypeName: ?[*:0]const u16,
ObjectNameLength: u16,
ObjectName: ?[*:0]const u16,
TypeSpecificInformation: extern union {
Process: extern struct {
ExitStatus: u32,
PebBaseAddress: ?*c_void,
AffinityMask: usize,
BasePriority: i32,
ProcessId: u32,
ParentProcessId: u32,
Flags: u32,
},
Thread: extern struct {
ExitStatus: u32,
TebBaseAddress: ?*c_void,
ProcessId: u32,
ThreadId: u32,
AffinityMask: usize,
Priority: i32,
BasePriority: i32,
Win32StartAddress: ?*c_void,
},
Mutant: extern struct {
CurrentCount: i32,
Abandoned: BOOL,
OwnerProcessId: u32,
OwnerThreadId: u32,
},
Event: extern struct {
ManualReset: BOOL,
Signaled: BOOL,
},
Section: extern struct {
BaseAddress: ?*c_void,
AllocationAttributes: u32,
MaximumSize: LARGE_INTEGER,
},
Semaphore: extern struct {
CurrentCount: i32,
MaximumCount: i32,
},
},
};
pub const PSS_THREAD_FLAGS = enum(u32) {
NONE = 0,
TERMINATED = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
TERMINATED: u1 = 0,
}) PSS_THREAD_FLAGS {
return @intToEnum(PSS_THREAD_FLAGS,
(if (o.NONE == 1) @enumToInt(PSS_THREAD_FLAGS.NONE) else 0)
| (if (o.TERMINATED == 1) @enumToInt(PSS_THREAD_FLAGS.TERMINATED) else 0)
);
}
};
pub const PSS_THREAD_FLAGS_NONE = PSS_THREAD_FLAGS.NONE;
pub const PSS_THREAD_FLAGS_TERMINATED = PSS_THREAD_FLAGS.TERMINATED;
pub const PSS_THREAD_ENTRY = extern struct {
ExitStatus: u32,
TebBaseAddress: ?*c_void,
ProcessId: u32,
ThreadId: u32,
AffinityMask: usize,
Priority: i32,
BasePriority: i32,
LastSyscallFirstArgument: ?*c_void,
LastSyscallNumber: u16,
CreateTime: FILETIME,
ExitTime: FILETIME,
KernelTime: FILETIME,
UserTime: FILETIME,
Win32StartAddress: ?*c_void,
CaptureTime: FILETIME,
Flags: PSS_THREAD_FLAGS,
SuspendCount: u16,
SizeOfContextRecord: u16,
ContextRecord: ?*CONTEXT,
};
pub const PSS_ALLOCATOR = extern struct {
Context: ?*c_void,
AllocRoutine: isize,
FreeRoutine: isize,
};
//--------------------------------------------------------------------------------
// Section: Functions (10)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssCaptureSnapshot(
ProcessHandle: ?HANDLE,
CaptureFlags: PSS_CAPTURE_FLAGS,
ThreadContextFlags: u32,
SnapshotHandle: ?*?HPSS,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssFreeSnapshot(
ProcessHandle: ?HANDLE,
SnapshotHandle: ?HPSS,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssQuerySnapshot(
SnapshotHandle: ?HPSS,
InformationClass: PSS_QUERY_INFORMATION_CLASS,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*c_void,
BufferLength: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssWalkSnapshot(
SnapshotHandle: ?HPSS,
InformationClass: PSS_WALK_INFORMATION_CLASS,
WalkMarkerHandle: ?HPSSWALK,
Buffer: ?[*]u8,
BufferLength: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.1'
// This function from dll 'KERNEL32' is being skipped because it has some sort of issue
pub fn PssDuplicateSnapshot() void { @panic("this function is not working"); }
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssWalkMarkerCreate(
Allocator: ?*const PSS_ALLOCATOR,
WalkMarkerHandle: ?*?HPSSWALK,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssWalkMarkerFree(
WalkMarkerHandle: ?HPSSWALK,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssWalkMarkerGetPosition(
WalkMarkerHandle: ?HPSSWALK,
Position: ?*usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssWalkMarkerSetPosition(
WalkMarkerHandle: ?HPSSWALK,
Position: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.1'
pub extern "KERNEL32" fn PssWalkMarkerSeekToBeginning(
WalkMarkerHandle: ?HPSSWALK,
) callconv(@import("std").os.windows.WINAPI) u32;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (7)
//--------------------------------------------------------------------------------
const BOOL = @import("../../foundation.zig").BOOL;
const CONTEXT = @import("../../system/diagnostics/debug.zig").CONTEXT;
const FILETIME = @import("../../foundation.zig").FILETIME;
const HANDLE = @import("../../foundation.zig").HANDLE;
const LARGE_INTEGER = @import("../../system/system_services.zig").LARGE_INTEGER;
const MEMORY_BASIC_INFORMATION = @import("../../system/memory.zig").MEMORY_BASIC_INFORMATION;
const PWSTR = @import("../../foundation.zig").PWSTR;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | deps/zigwin32/win32/system/diagnostics/process_snapshotting.zig |
const gfx = @import("gfx.zig");
pub const Quad = struct {
pos_uv: [4]f32,
};
pub const quad_vertices: []const Quad = &.{
.{ .pos_uv = [_]f32{ -0.5, -0.5, 0.0, 1.0 } },
.{ .pos_uv = [_]f32{ 0.5, -0.5, 1.0, 1.0 } },
.{ .pos_uv = [_]f32{ -0.5, 0.5, 0.0, 0.0 } },
.{ .pos_uv = [_]f32{ 0.5, 0.5, 1.0, 0.0 } },
};
pub const quad_indices: []const u16 = &.{ 0, 1, 2, 2, 1, 3 };
pub const ContextDesc = struct {
device: *gfx.Device,
format: gfx.TextureFormat,
vert_shader_bytes: []const u8,
frag_shader_bytes: []const u8,
instance_size: usize,
max_instances: usize,
};
pub const Context = struct {
device: *gfx.Device,
vertex_buffer: gfx.Buffer,
index_buffer: gfx.Buffer,
instance_buffer: gfx.Buffer,
render_pipeline: gfx.RenderPipeline,
pub fn init(desc: ContextDesc) !Context {
const vertex_buffer = try desc.device.initBufferSlice(
quad_vertices,
.{ .vertex = true },
);
const index_buffer = try desc.device.initBufferSlice(
quad_indices,
.{ .index = true },
);
const instance_buffer = try desc.device.initBuffer(.{
.size = desc.instance_size * desc.max_instances,
.usage = .{ .vertex = true, .copy_dst = true },
});
var vert_shader = try desc.device.initShader(desc.vert_shader_bytes);
defer desc.device.deinitShader(&vert_shader);
var frag_shader = try desc.device.initShader(desc.frag_shader_bytes);
defer desc.device.deinitShader(&frag_shader);
var render_pipeline_desc = gfx.RenderPipelineDesc{};
render_pipeline_desc.setVertexState(.{
.module = &vert_shader,
.entry_point = "vs_main",
// todo: zig #7607
.buffers = &[_]gfx.VertexBufferLayout{
gfx.getVertexBufferLayoutStruct(Quad, .vertex, 0),
gfx.getVertexBufferLayoutTypes(&[_]type{@Vector(4, f32)} ** 4, .instance, 2),
},
});
render_pipeline_desc.setFragmentState(.{
.module = &frag_shader,
.entry_point = "fs_main",
// todo: zig #7607
.targets = &[_]gfx.ColorTargetState{.{ .format = desc.format }},
});
const render_pipeline = try desc.device.initRenderPipeline(render_pipeline_desc);
return Context{
.device = desc.device,
.vertex_buffer = vertex_buffer,
.index_buffer = index_buffer,
.instance_buffer = instance_buffer,
.render_pipeline = render_pipeline,
};
}
pub fn render(ctx: *Context, render_pass: *gfx.RenderPass, instance_bytes: []const u8) !void {
try ctx.device.getQueue().writeBuffer(&ctx.instance_buffer, 0, instance_bytes, 0);
try render_pass.setPipeline(&ctx.render_pipeline);
try render_pass.setVertexBuffer(0, &ctx.vertex_buffer, 0, gfx.whole_size);
try render_pass.setVertexBuffer(1, &ctx.instance_buffer, 0, instance_bytes.len);
try render_pass.setIndexBuffer(&ctx.index_buffer, .uint16, 0, gfx.whole_size);
try render_pass.drawIndexed(quad_indices.len, 1, 0, 0, 0);
}
pub fn deinit(ctx: *Context) void {
ctx.device.deinitRenderPipeline(&ctx.render_pipeline);
ctx.device.deinitBuffer(&ctx.instance_buffer);
ctx.device.deinitBuffer(&ctx.index_buffer);
ctx.device.deinitBuffer(&ctx.vertex_buffer);
}
}; | src/ui_gfx.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const gui = @import("gui");
const nvg = @import("nanovg");
const Document = @import("Document.zig");
const Rect = @import("gui/geometry.zig").Rect;
const Point = @import("gui/geometry.zig").Point;
const PreviewWidget = @This();
widget: gui.Widget,
allocator: *Allocator,
document: *Document,
translation: Point(f32) = Point(f32).make(0, 0),
drag_offset: ?Point(f32) = null,
background_image: nvg.Image,
const Self = @This();
pub fn init(allocator: *Allocator, rect: Rect(f32), document: *Document) !*Self {
var self = try allocator.create(Self);
self.* = Self{
.widget = gui.Widget.init(allocator, rect),
.allocator = allocator,
.document = document,
.background_image = nvg.createImageRgba(2, 2, .{ .repeat_x = true, .repeat_y = true, .nearest = true }, &.{
0x66, 0x66, 0x66, 0xFF, 0x99, 0x99, 0x99, 0xFF,
0x99, 0x99, 0x99, 0xFF, 0x66, 0x66, 0x66, 0xFF,
}),
};
self.widget.onMouseMoveFn = onMouseMove;
self.widget.onMouseDownFn = onMouseDown;
self.widget.onMouseUpFn = onMouseUp;
self.widget.drawFn = draw;
return self;
}
pub fn deinit(self: *Self) void {
nvg.deleteImage(self.background_image);
self.widget.deinit();
self.allocator.destroy(self);
}
fn onMouseMove(widget: *gui.Widget, event: *const gui.MouseEvent) void {
var self = @fieldParentPtr(Self, "widget", widget);
if (self.drag_offset) |drag_offset| {
self.translation = Point(f32).make(event.x, event.y).subtracted(drag_offset);
}
}
fn onMouseDown(widget: *gui.Widget, event: *const gui.MouseEvent) void {
var self = @fieldParentPtr(Self, "widget", widget);
self.drag_offset = Point(f32).make(event.x, event.y).subtracted(self.translation);
}
fn onMouseUp(widget: *gui.Widget, event: *const gui.MouseEvent) void {
_ = event; // unused
var self = @fieldParentPtr(Self, "widget", widget);
self.drag_offset = null;
}
pub fn draw(widget: *gui.Widget) void {
var self = @fieldParentPtr(Self, "widget", widget);
const rect = widget.relative_rect;
nvg.save();
defer nvg.restore();
nvg.translate(rect.x, rect.y);
gui.drawPanel(0, 0, rect.w, rect.h, 1, false, false);
nvg.beginPath();
nvg.rect(5.5, 5.5, rect.w - 11, rect.h - 11);
nvg.strokeColor(nvg.rgb(66, 66, 66));
nvg.stroke();
const client_w = rect.w - 12;
const client_h = rect.h - 12;
nvg.scissor(6, 6, client_w, client_h);
nvg.translate(6, 6);
nvg.beginPath();
nvg.rect(0, 0, client_w, client_h);
nvg.fillPaint(nvg.imagePattern(0, 0, 8, 8, 0, self.background_image, 1));
nvg.fill();
const d_x = client_w - @intToFloat(f32, self.document.width);
const d_y = client_h - @intToFloat(f32, self.document.height);
self.translation.x = std.math.clamp(self.translation.x, std.math.min(0, d_x), std.math.max(0, d_x));
self.translation.y = std.math.clamp(self.translation.y, std.math.min(0, d_y), std.math.max(0, d_y));
nvg.translate(self.translation.x, self.translation.y);
self.document.draw();
} | src/PreviewWidget.zig |
const std = @import("std");
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const testing = std.testing;
const default_mask = 0x80;
const threshold = 2;
pub fn decode(allocator: mem.Allocator, data: []const u8) ![]u8 {
const Lengths = struct {
enc: u32,
dec: u32,
pak: u32,
raw: u32,
};
if (data.len < 8)
return error.BadHeader;
const inc_len = mem.readIntLittle(u32, data[data.len - 4 ..][0..4]);
const lengths = if (inc_len == 0) blk: {
break :blk Lengths{
.enc = 0,
.dec = @intCast(u32, data.len),
.pak = 0,
.raw = @intCast(u32, data.len),
};
} else blk: {
const hdr_len = data[data.len - 5];
if (hdr_len < 8 or hdr_len > 0xB) return error.BadHeaderLength;
if (data.len <= hdr_len) return error.BadLength;
const enc_len = mem.readIntLittle(u32, data[data.len - 8 ..][0..4]) & 0x00FFFFFF;
const dec_len = try math.sub(u32, @intCast(u32, data.len), enc_len);
const pak_len = try math.sub(u32, enc_len, hdr_len);
const raw_len = dec_len + enc_len + inc_len;
if (raw_len > 0x00FFFFFF)
return error.BadLength;
break :blk Lengths{
.enc = enc_len,
.dec = dec_len,
.pak = pak_len,
.raw = raw_len,
};
};
const result = try allocator.alloc(u8, lengths.raw);
errdefer allocator.free(result);
const pak_buffer = try allocator.alloc(u8, data.len + 3);
defer allocator.free(pak_buffer);
mem.copy(u8, result, data[0..lengths.dec]);
mem.copy(u8, pak_buffer, data);
mem.reverse(u8, pak_buffer[lengths.dec .. lengths.dec + lengths.pak]);
const pak_end = lengths.dec + lengths.pak;
var pak = lengths.dec;
var raw = lengths.dec;
var mask = @as(usize, 0);
var flags = @as(usize, 0);
while (raw < lengths.raw) {
mask = mask >> 1;
if (mask == 0) {
if (pak == pak_end) break;
flags = pak_buffer[pak];
mask = default_mask;
pak += 1;
}
if (flags & mask == 0) {
if (pak == pak_end) break;
result[raw] = pak_buffer[pak];
raw += 1;
pak += 1;
} else {
if (pak + 1 >= pak_end) break;
const pos = (@as(usize, pak_buffer[pak]) << 8) | pak_buffer[pak + 1];
pak += 2;
const len = (pos >> 12) + threshold + 1;
if (raw + len > lengths.raw)
return error.WrongDecodedLength;
const new_pos = (pos & 0xFFF) + 3;
var i = @as(usize, 0);
while (i < len) : (i += 1) {
result[raw] = result[raw - new_pos];
raw += 1;
}
}
}
if (raw != lengths.raw) return error.UnexpectedEnd;
mem.reverse(u8, result[lengths.dec..lengths.raw]);
return result[0..raw];
}
pub fn encode(allocator: mem.Allocator, data: []const u8, start: usize) ![]u8 {
var pos_best: usize = 0;
var flg: usize = 0;
var inc_len: usize = 0;
var hdr_len: usize = 0;
var enc_len: usize = 0;
const raw_buffer = try allocator.dupe(u8, data);
const raw_len = raw_buffer.len;
defer allocator.free(raw_buffer);
var pak_tmp: usize = 0;
var raw_tmp = raw_len;
var pak_len = raw_len + ((raw_len + 7) / 8) + 11;
var pak_buffer = try allocator.alloc(u8, pak_len);
var raw_new = raw_len - start;
mem.reverse(u8, raw_buffer);
var pak: usize = 0;
var raw: usize = 0;
var raw_end = raw_new;
var mask: usize = 0;
while (raw < raw_end) {
mask = mask >> 1;
if (mask == 0) {
flg = pak;
pak += 1;
pak_buffer[flg] = 0;
mask = 0x80;
}
const match = search(pos_best, raw_buffer, raw, raw_end);
pos_best = @ptrToInt(match.ptr) - @ptrToInt(raw_buffer.ptr);
pak_buffer[flg] = (pak_buffer[flg] << 1);
if (match.len > threshold) {
raw += match.len;
pak_buffer[flg] |= 1;
pak_buffer[pak + 0] = @truncate(u8, ((match.len - (threshold + 1)) << 4) | ((pos_best - 3) >> 8));
pak_buffer[pak + 1] = @truncate(u8, pos_best - 3);
pak += 2;
} else {
pak_buffer[pak] = raw_buffer[raw];
pak += 1;
raw += 1;
}
if (pak + raw_len - raw < pak_tmp + raw_tmp) {
pak_tmp = pak;
raw_tmp = raw_len - raw;
}
}
while ((mask > 0) and (mask != 1)) {
mask = (mask >> 1);
pak_buffer[flg] = pak_buffer[flg] << 1;
}
pak_len = pak;
mem.reverse(u8, raw_buffer);
mem.reverse(u8, pak_buffer[0..pak_len]);
if (pak_tmp == 0 or (raw_len + 4 < ((pak_tmp + raw_tmp + 3) & 0xFFFFFFFC) + 8)) {
pak = 0;
raw = 0;
raw_end = raw_len;
while (raw < raw_end) {
pak_buffer[pak] = raw_buffer[raw];
pak += 1;
raw += 1;
}
while ((pak & 3) > 0) {
pak_buffer[pak] = 0;
pak += 1;
}
pak_buffer[pak + 0] = 0;
pak_buffer[pak + 1] = 0;
pak_buffer[pak + 2] = 0;
pak_buffer[pak + 3] = 0;
pak += 4;
} else {
var tmp = try allocator.alloc(u8, raw_tmp + pak_tmp + 11);
defer allocator.free(tmp);
mem.copy(u8, tmp[0..raw_tmp], raw_buffer[0..raw_tmp]);
mem.copy(u8, tmp[raw_tmp..][0..pak_tmp], pak_buffer[pak_len - pak_tmp ..][0..pak_tmp]);
pak = 0;
mem.swap([]u8, &pak_buffer, &tmp);
pak = raw_tmp + pak_tmp;
enc_len = pak_tmp;
hdr_len = 8;
inc_len = raw_len - pak_tmp - raw_tmp;
while ((pak & 3) > 0) {
pak_buffer[pak] = 0xFF;
pak += 1;
hdr_len += 1;
}
mem.writeIntLittle(u32, pak_buffer[pak..][0..4], @intCast(u32, enc_len + hdr_len));
pak += 3;
pak_buffer[pak] = @intCast(u8, hdr_len);
pak += 1;
mem.writeIntLittle(u32, pak_buffer[pak..][0..4], @intCast(u32, inc_len - hdr_len));
pak += 4;
}
return allocator.shrink(pak_buffer, pak);
}
fn search(_p: usize, raw_buffer: []const u8, raw: usize, raw_end: usize) []const u8 {
const blz_f = 0x12;
const blz_n = 0x1002;
const max = math.min(raw, blz_n);
var p = _p;
var l: usize = threshold;
var pos: usize = 0;
while (true) : (pos += 1) {
while (pos <= max and raw_buffer[raw] != raw_buffer[raw - pos]) : (pos += 1) {}
if (pos > max)
break;
var len: usize = 1;
while (len < blz_f) : (len += 1) {
if (raw + len == raw_end)
break;
if (len >= pos)
break;
if (raw_buffer[raw + len] != raw_buffer[raw + len - pos])
break;
}
if (len > l) {
p = pos;
l = len;
if (l == blz_f)
break;
}
}
return raw_buffer[p..][0..l];
}
fn testIt(expected_decoded: []const u8, expected_encoded: []const u8) !void {
const allocator = testing.allocator;
const encoded = try encode(allocator, expected_decoded, 0);
defer allocator.free(encoded);
try testing.expectEqualSlices(u8, expected_encoded, encoded);
const decoded = try decode(allocator, expected_encoded);
defer allocator.free(decoded);
try testing.expectEqualSlices(u8, expected_decoded, decoded);
}
test "" {
try testIt(&[_]u8{
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7, 0xaa,
}, &[_]u8{
0x0c, 0x30, 0x1b, 0xf0, 0xc0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0,
0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0xff, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0,
0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0xff, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0,
0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0xff, 0x1b, 0xf0, 0x1b, 0xf0,
0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0x1b, 0xf0, 0xff, 0x0c, 0xc0,
0x29, 0xec, 0x8b, 0x64, 0x54, 0xec, 0x45, 0x01, 0xa6, 0x23, 0x5d, 0x5d, 0xd1, 0x7a, 0xe7,
0xaa, 0x00, 0x64, 0x00, 0x00, 0x08, 0x12, 0x02, 0x00, 0x00,
});
try testIt(
"770777d9febe1b7b0b5a54820387a621e596e6e3898341fa23ed6e8a82ac3f8b9e5b3001359725ada77a" ++
"4128d9a99cd55b4632273248ce2267a47d5f669efe7823a9e8b7bdfe8f42de9faabbb3c4b5cbcfd62" ++
"1cdfa1a7885265830d5ed994627ad6096359d76b0a2bf998b3b05aab7c36a3406998fdb6397b25964" ++
"3bd4a25566d8844c23a1809477fb2b1eb057b7143e4d156a912d8b26b5acdb3508bbed38f708f1fee" ++
"<KEY>" ++
"<KEY>" ++
"16d5b4a0335a41ceab4fcff223404e23d4c198bbc9c7d44980bc00628965111b1f5e430ce8923f1ca" ++
"3bd4a25566d8844c23a1809477fb2b1eb057b7143e4d156a912d8b26b5acdb3508bbed38f708f1fee" ++
"7f069798a16475649ad3e2cc54b2a70f5084fc25ff73ce879c898ecbaa46e4e2b69e43fdd46da210f" ++
"adb0272e6e621914a03d98b464a28d975c4660680dfb0777897e7551d9f8c8c1d16513ca19d1f0fbb",
&[_]u8{
0x37, 0x37, 0x03, 0x13, 0x0b, 0x03, 0x65, 0x62, 0x30, 0x65, 0x31, 0x76, 0x00, 0x30,
0x1a, 0x01, 0x35, 0x34, 0x38, 0x14, 0x32, 0x30, 0x33, 0x38, 0x37, 0x61, 0x83, 0x00,
0x65, 0x40, 0xce, 0x00, 0xbc, 0x02, 0x33, 0x92, 0x02, 0x33, 0x34, 0x31, 0x66, 0x0b,
0x61, 0x32, 0x33, 0x65, 0x64, 0x36, 0x65, 0x38, 0x00, 0x61, 0x38, 0x32, 0x61, 0x63,
0x33, 0x66, 0x38, 0x00, 0x62, 0x39, 0x65, 0x35, 0x62, 0x33, 0x30, 0x30, 0x00, 0x31,
0x7b, 0x00, 0x37, 0x32, 0x35, 0x61, 0x64, 0x61, 0x02, 0x37, 0x37, 0x61, 0xf0, 0x40,
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf8, 0x40, 0x02, 0x63, 0x64, 0x66,
0x61, 0x31, 0x61, 0x37, 0x01, 0x38, 0x38, 0x35, 0x32, 0x36, 0x35, 0x38, 0x33, 0x00,
0x30, 0x64, 0x35, 0x65, 0x64, 0x39, 0x39, 0x34, 0x00, 0x36, 0x32, 0x37, 0x61, 0x64,
0x36, 0x30, 0xec, 0x00, 0x80, 0x35, 0x39, 0x64, 0x37, 0x36, 0x62, 0x30, 0x61, 0x00,
0x32, 0x62, 0x66, 0x39, 0x37, 0x01, 0x33, 0x3c, 0x00, 0xaa, 0x00, 0xd0, 0x37, 0x63,
0x33, 0x36, 0x61, 0x33, 0x34, 0xa6, 0x01, 0x80, 0x39, 0x38, 0x66, 0x64, 0x62, 0x36,
0x33, 0x39, 0x00, 0x37, 0x62, 0x32, 0x35, 0x39, 0x36, 0x34, 0x41, 0x61, 0x80, 0x41,
0xf1, 0x41, 0xf1, 0x41, 0xf1, 0x41, 0xf1, 0x34, 0x31, 0xab, 0x11, 0x61, 0x4f, 0x39,
0x39, 0x63, 0x64, 0x35, 0x35, 0x9b, 0x01, 0x33, 0x40, 0x32, 0x32, 0x37, 0x33, 0x32,
0x34, 0x38, 0x63, 0x00, 0x65, 0x32, 0x32, 0x36, 0x37, 0x61, 0x34, 0x37, 0x00, 0x64,
0x35, 0x66, 0x36, 0x5d, 0x01, 0x66, 0x65, 0x37, 0x10, 0x38, 0xd4, 0x00, 0x39, 0x65,
0x38, 0x62, 0x37, 0x62, 0x02, 0x64, 0x66, 0x65, 0x38, 0x66, 0x34, 0x32, 0x64, 0x00,
0x65, 0x39, 0x66, 0x61, 0x61, 0x62, 0x62, 0x62, 0x00, 0x33, 0x63, 0x34, 0x62, 0x35,
0x63, 0x62, 0x63, 0x00, 0x66, 0x64, 0x86, 0x00, 0x37, 0x37, 0x31, 0x30, 0x35, 0x04,
0x64, 0x38, 0x37, 0x1f, 0x00, 0x35, 0x37, 0x61, 0x33, 0x08, 0x38, 0x38, 0x65, 0x32,
0x38, 0x63, 0x64, 0x37, 0x00, 0x38, 0x32, 0x64, 0x39, 0x36, 0x33, 0x61, 0x37, 0x00,
0x31, 0x33, 0x32, 0x61, 0x31, 0x62, 0x61, 0x30, 0x00, 0x65, 0x31, 0x64, 0x62, 0x39,
0x32, 0x61, 0x66, 0x00, 0x7e, 0x00, 0x38, 0x30, 0x61, 0x37, 0x62, 0x0c, 0x00, 0x34,
0x41, 0x35, 0x5c, 0x00, 0x62, 0x66, 0x62, 0x37, 0x35, 0x37, 0x02, 0x39, 0x62, 0x66,
0x61, 0x36, 0x63, 0x38, 0x57, 0x00, 0x80, 0xa8, 0x00, 0x64, 0x35, 0x62, 0xfa, 0x10,
0x33, 0x35, 0x61, 0x11, 0x34, 0x31, 0x63, 0x65, 0x61, 0x62, 0xb0, 0x00, 0x66, 0x40,
0x66, 0x32, 0x32, 0x33, 0x34, 0x30, 0xc0, 0x00, 0x33, 0x40, 0x64, 0x34, 0x63, 0x31,
0x39, 0x6a, 0x00, 0x63, 0x39, 0x20, 0x63, 0x37, 0x64, 0x34, 0x34, 0x39, 0x38, 0x30,
0x00, 0x62, 0x63, 0x30, 0x30, 0x36, 0x32, 0x38, 0x39, 0x00, 0xf8, 0x00, 0x31, 0x31,
0x62, 0x31, 0x66, 0x35, 0x9f, 0x00, 0x81, 0x30, 0x84, 0x00, 0x39, 0x32, 0x33, 0x66,
0x31, 0x63, 0x02, 0x61, 0x33, 0x62, 0x64, 0xb5, 0x00, 0x35, 0x35, 0x36, 0x10, 0x36,
0x64, 0x38, 0x38, 0x34, 0x34, 0x63, 0x32, 0x00, 0x33, 0x61, 0x31, 0x38, 0x30, 0x39,
0x34, 0x37, 0x00, 0x37, 0x66, 0x62, 0x32, 0x62, 0x31, 0x65, 0x62, 0x00, 0x30, 0x35,
0x37, 0x62, 0x37, 0x31, 0x34, 0x33, 0x00, 0x65, 0x34, 0x64, 0x31, 0x35, 0x36, 0x61,
0x39, 0x00, 0x31, 0x32, 0x64, 0x38, 0x62, 0x32, 0x36, 0x62, 0x00, 0x35, 0x61, 0x63,
0x64, 0x62, 0x33, 0x2f, 0x00, 0x62, 0x40, 0x62, 0x65, 0x64, 0x33, 0x38, 0x66, 0x37,
0x30, 0x00, 0x38, 0x66, 0x31, 0x66, 0x65, 0x65, 0x37, 0x66, 0x00, 0x30, 0x36, 0x39,
0x37, 0x39, 0x38, 0x61, 0x31, 0x00, 0x36, 0x34, 0x37, 0x35, 0x36, 0x34, 0x39, 0x61,
0x00, 0x64, 0x33, 0x65, 0x32, 0x63, 0x63, 0x35, 0x34, 0x00, 0x62, 0x32, 0x61, 0x37,
0x30, 0x66, 0x35, 0x30, 0x00, 0x38, 0x34, 0x66, 0x63, 0x32, 0x35, 0x66, 0x66, 0x00,
0x37, 0x33, 0x63, 0x65, 0x38, 0x37, 0x39, 0x63, 0x00, 0x38, 0x39, 0x38, 0x65, 0x63,
0x62, 0x61, 0x61, 0x00, 0x34, 0x36, 0x65, 0x34, 0x65, 0x32, 0x62, 0x36, 0x00, 0x39,
0x65, 0x34, 0x33, 0x66, 0x64, 0x64, 0x34, 0x00, 0x36, 0x64, 0x61, 0x32, 0x31, 0x30,
0x66, 0x61, 0x00, 0x64, 0x62, 0x30, 0x32, 0x37, 0x32, 0x65, 0x36, 0x00, 0x65, 0x36,
0x32, 0x31, 0x39, 0x31, 0x34, 0x61, 0x00, 0x30, 0x33, 0x64, 0x39, 0x38, 0x62, 0x34,
0x36, 0x00, 0x34, 0x61, 0x32, 0x38, 0x64, 0x39, 0x37, 0x35, 0x00, 0x63, 0x34, 0x36,
0x36, 0x30, 0x36, 0x38, 0x30, 0x00, 0x64, 0x66, 0x62, 0x30, 0x37, 0x37, 0x37, 0x38,
0x00, 0x39, 0x37, 0x65, 0x37, 0x35, 0x35, 0x31, 0x64, 0x00, 0x39, 0x66, 0x38, 0x63,
0x38, 0x63, 0x31, 0x64, 0x00, 0x31, 0x36, 0x35, 0x31, 0x33, 0x63, 0x61, 0x31, 0x00,
0x39, 0x64, 0x31, 0x66, 0x30, 0x66, 0x62, 0x62, 0x00, 0xff, 0xff, 0xff, 0xce, 0x02,
0x00, 0x0b, 0x5d, 0x00, 0x00, 0x00,
},
);
} | src/core/rom/nds/blz.zig |
const std = @import("std");
const assert = std.debug.assert;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var input_file = try std.fs.cwd().openFile("input/05.txt", .{});
defer input_file.close();
var buffered_reader = std.io.bufferedReader(input_file.reader());
const count = try countOverlappingPoints(allocator, buffered_reader.reader());
std.debug.print("points where at least two lines overlap: {}\n", .{count});
}
const Point = struct {
x: i64,
y: i64,
};
const Direction = enum {
horizontal,
vertical,
};
const Line = struct {
p1: Point,
p2: Point,
pub fn direction(self: Line) Direction {
if (self.p1.x == self.p2.x) {
return .vertical;
} else if (self.p1.y == self.p2.y) {
return .horizontal;
} else {
unreachable;
}
}
pub fn swapped(self: Line) Line {
return .{ .p1 = self.p2, .p2 = self.p1 };
}
pub fn sorted(self: Line) Line {
switch (self.direction()) {
.horizontal => {
if (self.p1.x > self.p2.x) {
return self.swapped();
} else {
return self;
}
},
.vertical => {
if (self.p1.y > self.p2.y) {
return self.swapped();
} else {
return self;
}
},
}
}
};
fn countOverlappingPoints(gpa: std.mem.Allocator, reader: anytype) !u64 {
var arena = std.heap.ArenaAllocator.init(gpa);
defer arena.deinit();
const allocator = arena.allocator();
var buf: [1024]u8 = undefined;
var lines = std.ArrayList(Line).init(allocator);
while (try reader.readUntilDelimiterOrEof(&buf, '\n')) |line| {
var iter = std.mem.split(u8, line, " ");
const p1_raw = iter.next() orelse return error.WrongFormat;
if (!std.mem.eql(u8, "->", iter.next() orelse return error.WrongFormat)) return error.WrongFormat;
const p2_raw = iter.next() orelse return error.WrongFormat;
if (iter.next() != null) return error.WrongFormat;
var p1_raw_iter = std.mem.split(u8, p1_raw, ",");
const x1 = try std.fmt.parseInt(i64, p1_raw_iter.next() orelse return error.WrongFormat, 10);
const y1 = try std.fmt.parseInt(i64, p1_raw_iter.next() orelse return error.WrongFormat, 10);
if (p1_raw_iter.next() != null) return error.WrongFormat;
var p2_raw_iter = std.mem.split(u8, p2_raw, ",");
const x2 = try std.fmt.parseInt(i64, p2_raw_iter.next() orelse return error.WrongFormat, 10);
const y2 = try std.fmt.parseInt(i64, p2_raw_iter.next() orelse return error.WrongFormat, 10);
if (p2_raw_iter.next() != null) return error.WrongFormat;
// Only consider horizontal and vertical lines
if (!(x1 == x2 or y1 == y2)) continue;
try lines.append(Line{
.p1 = .{ .x = x1, .y = y1 },
.p2 = .{ .x = x2, .y = y2 },
});
}
var overlapping_points = std.AutoHashMap(Point, void).init(allocator);
for (lines.items) |line_1, i| {
if (i == lines.items.len - 1) continue;
for (lines.items[i + 1 ..]) |line_2| {
const sorted_line_1 = line_1.sorted();
const sorted_line_2 = line_2.sorted();
if (line_1.direction() == line_2.direction()) {
switch (line_1.direction()) {
.horizontal => {
if (line_1.p1.y != line_2.p1.y) continue;
const first_line = if (sorted_line_1.p1.x < sorted_line_2.p1.x) sorted_line_1 else sorted_line_2;
const second_line = if (sorted_line_1.p1.x < sorted_line_2.p1.x) sorted_line_2 else sorted_line_1;
var x: i64 = second_line.p1.x;
while (x <= first_line.p2.x and x <= second_line.p2.x) : (x += 1) {
// std.debug.print("- adding {} {} for lines {} and {}\n", .{ x, first_line.p1.y, line_1, line_2 });
try overlapping_points.put(.{
.x = x,
.y = first_line.p1.y,
}, {});
}
},
.vertical => {
if (line_1.p1.x != line_2.p1.x) continue;
const first_line = if (sorted_line_1.p1.y < sorted_line_2.p1.y) sorted_line_1 else sorted_line_2;
const second_line = if (sorted_line_1.p1.y < sorted_line_2.p1.y) sorted_line_2 else sorted_line_1;
var y: i64 = second_line.p1.y;
while (y <= first_line.p2.y and y <= second_line.p2.y) : (y += 1) {
// std.debug.print("| adding {} {} for lines {} and {}\n", .{ first_line.p1.x, y, line_1, line_2 });
try overlapping_points.put(.{
.x = first_line.p1.x,
.y = y,
}, {});
}
},
}
} else {
const horizontal_line = if (sorted_line_1.direction() == .horizontal) sorted_line_1 else sorted_line_2;
const vertical_line = if (sorted_line_1.direction() == .horizontal) sorted_line_2 else sorted_line_1;
if (horizontal_line.p1.x <= vertical_line.p1.x and vertical_line.p1.x <= horizontal_line.p2.x and
vertical_line.p1.y <= horizontal_line.p1.y and horizontal_line.p1.y <= vertical_line.p2.y)
{
// std.debug.print("x adding {} {} for lines {} and {}\n", .{ vertical_line.p1.x, horizontal_line.p1.y, line_1, line_2 });
try overlapping_points.put(.{
.x = vertical_line.p1.x,
.y = horizontal_line.p1.y,
}, {});
}
}
}
}
// {
// var iter = overlapping_points.iterator();
// while (iter.next()) |entry| {
// std.debug.print("{}\n", .{entry.key_ptr.*});
// }
// }
return overlapping_points.count();
}
test "example 1" {
const text =
\\0,9 -> 5,9
\\8,0 -> 0,8
\\9,4 -> 3,4
\\2,2 -> 2,1
\\7,0 -> 7,4
\\6,4 -> 2,0
\\0,9 -> 2,9
\\3,4 -> 1,4
\\0,0 -> 8,8
\\5,5 -> 8,2
;
var fbs = std.io.fixedBufferStream(text);
const count = try countOverlappingPoints(std.testing.allocator, fbs.reader());
try std.testing.expectEqual(@as(u64, 5), count);
} | src/05.zig |
const vk = @import("vulkan.zig");
pub const GLenum = c_uint;
pub const GLboolean = u8;
pub const GLbitfield = c_uint;
pub const GLvoid = c_void;
pub const GLbyte = i8;
pub const GLshort = c_short;
pub const GLint = c_int;
pub const GLubyte = u8;
pub const GLushort = c_ushort;
pub const GLuint = c_uint;
pub const GLsizei = c_int;
pub const GLfloat = f32;
pub const GLclampf = f32;
pub const GLdouble = f64;
pub const GLclampd = f64;
pub extern fn glClearIndex(c: GLfloat) void;
pub extern fn glClearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf) void;
pub extern fn glClear(mask: GLbitfield) void;
pub extern fn glIndexMask(mask: GLuint) void;
pub extern fn glColorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean) void;
pub extern fn glAlphaFunc(func: GLenum, ref: GLclampf) void;
pub extern fn glBlendFunc(sfactor: GLenum, dfactor: GLenum) void;
pub extern fn glLogicOp(opcode: GLenum) void;
pub extern fn glCullFace(mode: GLenum) void;
pub extern fn glFrontFace(mode: GLenum) void;
pub extern fn glPointSize(size: GLfloat) void;
pub extern fn glLineWidth(width: GLfloat) void;
pub extern fn glLineStipple(factor: GLint, pattern: GLushort) void;
pub extern fn glPolygonMode(face: GLenum, mode: GLenum) void;
pub extern fn glPolygonOffset(factor: GLfloat, units: GLfloat) void;
pub extern fn glPolygonStipple(mask: [*c]const GLubyte) void;
pub extern fn glGetPolygonStipple(mask: [*c]GLubyte) void;
pub extern fn glEdgeFlag(flag: GLboolean) void;
pub extern fn glEdgeFlagv(flag: [*c]const GLboolean) void;
pub extern fn glScissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei) void;
pub extern fn glClipPlane(plane: GLenum, equation: [*c]const GLdouble) void;
pub extern fn glGetClipPlane(plane: GLenum, equation: [*c]GLdouble) void;
pub extern fn glDrawBuffer(mode: GLenum) void;
pub extern fn glReadBuffer(mode: GLenum) void;
pub extern fn glEnable(cap: GLenum) void;
pub extern fn glDisable(cap: GLenum) void;
pub extern fn glIsEnabled(cap: GLenum) GLboolean;
pub extern fn glEnableClientState(cap: GLenum) void;
pub extern fn glDisableClientState(cap: GLenum) void;
pub extern fn glGetBooleanv(pname: GLenum, params: [*c]GLboolean) void;
pub extern fn glGetDoublev(pname: GLenum, params: [*c]GLdouble) void;
pub extern fn glGetFloatv(pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetIntegerv(pname: GLenum, params: [*c]GLint) void;
pub extern fn glPushAttrib(mask: GLbitfield) void;
pub extern fn glPopAttrib() void;
pub extern fn glPushClientAttrib(mask: GLbitfield) void;
pub extern fn glPopClientAttrib() void;
pub extern fn glRenderMode(mode: GLenum) GLint;
pub extern fn glGetError() GLenum;
pub extern fn glGetString(name: GLenum) [*c]const GLubyte;
pub extern fn glFinish() void;
pub extern fn glFlush() void;
pub extern fn glHint(target: GLenum, mode: GLenum) void;
pub extern fn glClearDepth(depth: GLclampd) void;
pub extern fn glDepthFunc(func: GLenum) void;
pub extern fn glDepthMask(flag: GLboolean) void;
pub extern fn glDepthRange(near_val: GLclampd, far_val: GLclampd) void;
pub extern fn glClearAccum(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) void;
pub extern fn glAccum(op: GLenum, value: GLfloat) void;
pub extern fn glMatrixMode(mode: GLenum) void;
pub extern fn glOrtho(left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, near_val: GLdouble, far_val: GLdouble) void;
pub extern fn glFrustum(left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, near_val: GLdouble, far_val: GLdouble) void;
pub extern fn glViewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei) void;
pub extern fn glPushMatrix() void;
pub extern fn glPopMatrix() void;
pub extern fn glLoadIdentity() void;
pub extern fn glLoadMatrixd(m: [*c]const GLdouble) void;
pub extern fn glLoadMatrixf(m: [*c]const GLfloat) void;
pub extern fn glMultMatrixd(m: [*c]const GLdouble) void;
pub extern fn glMultMatrixf(m: [*c]const GLfloat) void;
pub extern fn glRotated(angle: GLdouble, x: GLdouble, y: GLdouble, z: GLdouble) void;
pub extern fn glRotatef(angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) void;
pub extern fn glScaled(x: GLdouble, y: GLdouble, z: GLdouble) void;
pub extern fn glScalef(x: GLfloat, y: GLfloat, z: GLfloat) void;
pub extern fn glTranslated(x: GLdouble, y: GLdouble, z: GLdouble) void;
pub extern fn glTranslatef(x: GLfloat, y: GLfloat, z: GLfloat) void;
pub extern fn glIsList(list: GLuint) GLboolean;
pub extern fn glDeleteLists(list: GLuint, range: GLsizei) void;
pub extern fn glGenLists(range: GLsizei) GLuint;
pub extern fn glNewList(list: GLuint, mode: GLenum) void;
pub extern fn glEndList() void;
pub extern fn glCallList(list: GLuint) void;
pub extern fn glCallLists(n: GLsizei, type: GLenum, lists: ?*const GLvoid) void;
pub extern fn glListBase(base: GLuint) void;
pub extern fn glBegin(mode: GLenum) void;
pub extern fn glEnd() void;
pub extern fn glVertex2d(x: GLdouble, y: GLdouble) void;
pub extern fn glVertex2f(x: GLfloat, y: GLfloat) void;
pub extern fn glVertex2i(x: GLint, y: GLint) void;
pub extern fn glVertex2s(x: GLshort, y: GLshort) void;
pub extern fn glVertex3d(x: GLdouble, y: GLdouble, z: GLdouble) void;
pub extern fn glVertex3f(x: GLfloat, y: GLfloat, z: GLfloat) void;
pub extern fn glVertex3i(x: GLint, y: GLint, z: GLint) void;
pub extern fn glVertex3s(x: GLshort, y: GLshort, z: GLshort) void;
pub extern fn glVertex4d(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) void;
pub extern fn glVertex4f(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) void;
pub extern fn glVertex4i(x: GLint, y: GLint, z: GLint, w: GLint) void;
pub extern fn glVertex4s(x: GLshort, y: GLshort, z: GLshort, w: GLshort) void;
pub extern fn glVertex2dv(v: [*c]const GLdouble) void;
pub extern fn glVertex2fv(v: [*c]const GLfloat) void;
pub extern fn glVertex2iv(v: [*c]const GLint) void;
pub extern fn glVertex2sv(v: [*c]const GLshort) void;
pub extern fn glVertex3dv(v: [*c]const GLdouble) void;
pub extern fn glVertex3fv(v: [*c]const GLfloat) void;
pub extern fn glVertex3iv(v: [*c]const GLint) void;
pub extern fn glVertex3sv(v: [*c]const GLshort) void;
pub extern fn glVertex4dv(v: [*c]const GLdouble) void;
pub extern fn glVertex4fv(v: [*c]const GLfloat) void;
pub extern fn glVertex4iv(v: [*c]const GLint) void;
pub extern fn glVertex4sv(v: [*c]const GLshort) void;
pub extern fn glNormal3b(nx: GLbyte, ny: GLbyte, nz: GLbyte) void;
pub extern fn glNormal3d(nx: GLdouble, ny: GLdouble, nz: GLdouble) void;
pub extern fn glNormal3f(nx: GLfloat, ny: GLfloat, nz: GLfloat) void;
pub extern fn glNormal3i(nx: GLint, ny: GLint, nz: GLint) void;
pub extern fn glNormal3s(nx: GLshort, ny: GLshort, nz: GLshort) void;
pub extern fn glNormal3bv(v: [*c]const GLbyte) void;
pub extern fn glNormal3dv(v: [*c]const GLdouble) void;
pub extern fn glNormal3fv(v: [*c]const GLfloat) void;
pub extern fn glNormal3iv(v: [*c]const GLint) void;
pub extern fn glNormal3sv(v: [*c]const GLshort) void;
pub extern fn glIndexd(c: GLdouble) void;
pub extern fn glIndexf(c: GLfloat) void;
pub extern fn glIndexi(c: GLint) void;
pub extern fn glIndexs(c: GLshort) void;
pub extern fn glIndexub(c: GLubyte) void;
pub extern fn glIndexdv(c: [*c]const GLdouble) void;
pub extern fn glIndexfv(c: [*c]const GLfloat) void;
pub extern fn glIndexiv(c: [*c]const GLint) void;
pub extern fn glIndexsv(c: [*c]const GLshort) void;
pub extern fn glIndexubv(c: [*c]const GLubyte) void;
pub extern fn glColor3b(red: GLbyte, green: GLbyte, blue: GLbyte) void;
pub extern fn glColor3d(red: GLdouble, green: GLdouble, blue: GLdouble) void;
pub extern fn glColor3f(red: GLfloat, green: GLfloat, blue: GLfloat) void;
pub extern fn glColor3i(red: GLint, green: GLint, blue: GLint) void;
pub extern fn glColor3s(red: GLshort, green: GLshort, blue: GLshort) void;
pub extern fn glColor3ub(red: GLubyte, green: GLubyte, blue: GLubyte) void;
pub extern fn glColor3ui(red: GLuint, green: GLuint, blue: GLuint) void;
pub extern fn glColor3us(red: GLushort, green: GLushort, blue: GLushort) void;
pub extern fn glColor4b(red: GLbyte, green: GLbyte, blue: GLbyte, alpha: GLbyte) void;
pub extern fn glColor4d(red: GLdouble, green: GLdouble, blue: GLdouble, alpha: GLdouble) void;
pub extern fn glColor4f(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) void;
pub extern fn glColor4i(red: GLint, green: GLint, blue: GLint, alpha: GLint) void;
pub extern fn glColor4s(red: GLshort, green: GLshort, blue: GLshort, alpha: GLshort) void;
pub extern fn glColor4ub(red: GLubyte, green: GLubyte, blue: GLubyte, alpha: GLubyte) void;
pub extern fn glColor4ui(red: GLuint, green: GLuint, blue: GLuint, alpha: GLuint) void;
pub extern fn glColor4us(red: GLushort, green: GLushort, blue: GLushort, alpha: GLushort) void;
pub extern fn glColor3bv(v: [*c]const GLbyte) void;
pub extern fn glColor3dv(v: [*c]const GLdouble) void;
pub extern fn glColor3fv(v: [*c]const GLfloat) void;
pub extern fn glColor3iv(v: [*c]const GLint) void;
pub extern fn glColor3sv(v: [*c]const GLshort) void;
pub extern fn glColor3ubv(v: [*c]const GLubyte) void;
pub extern fn glColor3uiv(v: [*c]const GLuint) void;
pub extern fn glColor3usv(v: [*c]const GLushort) void;
pub extern fn glColor4bv(v: [*c]const GLbyte) void;
pub extern fn glColor4dv(v: [*c]const GLdouble) void;
pub extern fn glColor4fv(v: [*c]const GLfloat) void;
pub extern fn glColor4iv(v: [*c]const GLint) void;
pub extern fn glColor4sv(v: [*c]const GLshort) void;
pub extern fn glColor4ubv(v: [*c]const GLubyte) void;
pub extern fn glColor4uiv(v: [*c]const GLuint) void;
pub extern fn glColor4usv(v: [*c]const GLushort) void;
pub extern fn glTexCoord1d(s: GLdouble) void;
pub extern fn glTexCoord1f(s: GLfloat) void;
pub extern fn glTexCoord1i(s: GLint) void;
pub extern fn glTexCoord1s(s: GLshort) void;
pub extern fn glTexCoord2d(s: GLdouble, t: GLdouble) void;
pub extern fn glTexCoord2f(s: GLfloat, t: GLfloat) void;
pub extern fn glTexCoord2i(s: GLint, t: GLint) void;
pub extern fn glTexCoord2s(s: GLshort, t: GLshort) void;
pub extern fn glTexCoord3d(s: GLdouble, t: GLdouble, r: GLdouble) void;
pub extern fn glTexCoord3f(s: GLfloat, t: GLfloat, r: GLfloat) void;
pub extern fn glTexCoord3i(s: GLint, t: GLint, r: GLint) void;
pub extern fn glTexCoord3s(s: GLshort, t: GLshort, r: GLshort) void;
pub extern fn glTexCoord4d(s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) void;
pub extern fn glTexCoord4f(s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) void;
pub extern fn glTexCoord4i(s: GLint, t: GLint, r: GLint, q: GLint) void;
pub extern fn glTexCoord4s(s: GLshort, t: GLshort, r: GLshort, q: GLshort) void;
pub extern fn glTexCoord1dv(v: [*c]const GLdouble) void;
pub extern fn glTexCoord1fv(v: [*c]const GLfloat) void;
pub extern fn glTexCoord1iv(v: [*c]const GLint) void;
pub extern fn glTexCoord1sv(v: [*c]const GLshort) void;
pub extern fn glTexCoord2dv(v: [*c]const GLdouble) void;
pub extern fn glTexCoord2fv(v: [*c]const GLfloat) void;
pub extern fn glTexCoord2iv(v: [*c]const GLint) void;
pub extern fn glTexCoord2sv(v: [*c]const GLshort) void;
pub extern fn glTexCoord3dv(v: [*c]const GLdouble) void;
pub extern fn glTexCoord3fv(v: [*c]const GLfloat) void;
pub extern fn glTexCoord3iv(v: [*c]const GLint) void;
pub extern fn glTexCoord3sv(v: [*c]const GLshort) void;
pub extern fn glTexCoord4dv(v: [*c]const GLdouble) void;
pub extern fn glTexCoord4fv(v: [*c]const GLfloat) void;
pub extern fn glTexCoord4iv(v: [*c]const GLint) void;
pub extern fn glTexCoord4sv(v: [*c]const GLshort) void;
pub extern fn glRasterPos2d(x: GLdouble, y: GLdouble) void;
pub extern fn glRasterPos2f(x: GLfloat, y: GLfloat) void;
pub extern fn glRasterPos2i(x: GLint, y: GLint) void;
pub extern fn glRasterPos2s(x: GLshort, y: GLshort) void;
pub extern fn glRasterPos3d(x: GLdouble, y: GLdouble, z: GLdouble) void;
pub extern fn glRasterPos3f(x: GLfloat, y: GLfloat, z: GLfloat) void;
pub extern fn glRasterPos3i(x: GLint, y: GLint, z: GLint) void;
pub extern fn glRasterPos3s(x: GLshort, y: GLshort, z: GLshort) void;
pub extern fn glRasterPos4d(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) void;
pub extern fn glRasterPos4f(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) void;
pub extern fn glRasterPos4i(x: GLint, y: GLint, z: GLint, w: GLint) void;
pub extern fn glRasterPos4s(x: GLshort, y: GLshort, z: GLshort, w: GLshort) void;
pub extern fn glRasterPos2dv(v: [*c]const GLdouble) void;
pub extern fn glRasterPos2fv(v: [*c]const GLfloat) void;
pub extern fn glRasterPos2iv(v: [*c]const GLint) void;
pub extern fn glRasterPos2sv(v: [*c]const GLshort) void;
pub extern fn glRasterPos3dv(v: [*c]const GLdouble) void;
pub extern fn glRasterPos3fv(v: [*c]const GLfloat) void;
pub extern fn glRasterPos3iv(v: [*c]const GLint) void;
pub extern fn glRasterPos3sv(v: [*c]const GLshort) void;
pub extern fn glRasterPos4dv(v: [*c]const GLdouble) void;
pub extern fn glRasterPos4fv(v: [*c]const GLfloat) void;
pub extern fn glRasterPos4iv(v: [*c]const GLint) void;
pub extern fn glRasterPos4sv(v: [*c]const GLshort) void;
pub extern fn glRectd(x1: GLdouble, y1: GLdouble, x2: GLdouble, y2: GLdouble) void;
pub extern fn glRectf(x1: GLfloat, y1: GLfloat, x2: GLfloat, y2: GLfloat) void;
pub extern fn glRecti(x1: GLint, y1: GLint, x2: GLint, y2: GLint) void;
pub extern fn glRects(x1: GLshort, y1: GLshort, x2: GLshort, y2: GLshort) void;
pub extern fn glRectdv(v1: [*c]const GLdouble, v2: [*c]const GLdouble) void;
pub extern fn glRectfv(v1: [*c]const GLfloat, v2: [*c]const GLfloat) void;
pub extern fn glRectiv(v1: [*c]const GLint, v2: [*c]const GLint) void;
pub extern fn glRectsv(v1: [*c]const GLshort, v2: [*c]const GLshort) void;
pub extern fn glVertexPointer(size: GLint, type: GLenum, stride: GLsizei, ptr: ?*const GLvoid) void;
pub extern fn glNormalPointer(type: GLenum, stride: GLsizei, ptr: ?*const GLvoid) void;
pub extern fn glColorPointer(size: GLint, type: GLenum, stride: GLsizei, ptr: ?*const GLvoid) void;
pub extern fn glIndexPointer(type: GLenum, stride: GLsizei, ptr: ?*const GLvoid) void;
pub extern fn glTexCoordPointer(size: GLint, type: GLenum, stride: GLsizei, ptr: ?*const GLvoid) void;
pub extern fn glEdgeFlagPointer(stride: GLsizei, ptr: ?*const GLvoid) void;
pub extern fn glGetPointerv(pname: GLenum, params: [*c]?*GLvoid) void;
pub extern fn glArrayElement(i: GLint) void;
pub extern fn glDrawArrays(mode: GLenum, first: GLint, count: GLsizei) void;
pub extern fn glDrawElements(mode: GLenum, count: GLsizei, type: GLenum, indices: ?*const GLvoid) void;
pub extern fn glInterleavedArrays(format: GLenum, stride: GLsizei, pointer: ?*const GLvoid) void;
pub extern fn glShadeModel(mode: GLenum) void;
pub extern fn glLightf(light: GLenum, pname: GLenum, param: GLfloat) void;
pub extern fn glLighti(light: GLenum, pname: GLenum, param: GLint) void;
pub extern fn glLightfv(light: GLenum, pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glLightiv(light: GLenum, pname: GLenum, params: [*c]const GLint) void;
pub extern fn glGetLightfv(light: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetLightiv(light: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glLightModelf(pname: GLenum, param: GLfloat) void;
pub extern fn glLightModeli(pname: GLenum, param: GLint) void;
pub extern fn glLightModelfv(pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glLightModeliv(pname: GLenum, params: [*c]const GLint) void;
pub extern fn glMaterialf(face: GLenum, pname: GLenum, param: GLfloat) void;
pub extern fn glMateriali(face: GLenum, pname: GLenum, param: GLint) void;
pub extern fn glMaterialfv(face: GLenum, pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glMaterialiv(face: GLenum, pname: GLenum, params: [*c]const GLint) void;
pub extern fn glGetMaterialfv(face: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetMaterialiv(face: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glColorMaterial(face: GLenum, mode: GLenum) void;
pub extern fn glPixelZoom(xfactor: GLfloat, yfactor: GLfloat) void;
pub extern fn glPixelStoref(pname: GLenum, param: GLfloat) void;
pub extern fn glPixelStorei(pname: GLenum, param: GLint) void;
pub extern fn glPixelTransferf(pname: GLenum, param: GLfloat) void;
pub extern fn glPixelTransferi(pname: GLenum, param: GLint) void;
pub extern fn glPixelMapfv(map: GLenum, mapsize: GLsizei, values: [*c]const GLfloat) void;
pub extern fn glPixelMapuiv(map: GLenum, mapsize: GLsizei, values: [*c]const GLuint) void;
pub extern fn glPixelMapusv(map: GLenum, mapsize: GLsizei, values: [*c]const GLushort) void;
pub extern fn glGetPixelMapfv(map: GLenum, values: [*c]GLfloat) void;
pub extern fn glGetPixelMapuiv(map: GLenum, values: [*c]GLuint) void;
pub extern fn glGetPixelMapusv(map: GLenum, values: [*c]GLushort) void;
pub extern fn glBitmap(width: GLsizei, height: GLsizei, xorig: GLfloat, yorig: GLfloat, xmove: GLfloat, ymove: GLfloat, bitmap: [*c]const GLubyte) void;
pub extern fn glReadPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ?*GLvoid) void;
pub extern fn glDrawPixels(width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ?*const GLvoid) void;
pub extern fn glCopyPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, type: GLenum) void;
pub extern fn glStencilFunc(func: GLenum, ref: GLint, mask: GLuint) void;
pub extern fn glStencilMask(mask: GLuint) void;
pub extern fn glStencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum) void;
pub extern fn glClearStencil(s: GLint) void;
pub extern fn glTexGend(coord: GLenum, pname: GLenum, param: GLdouble) void;
pub extern fn glTexGenf(coord: GLenum, pname: GLenum, param: GLfloat) void;
pub extern fn glTexGeni(coord: GLenum, pname: GLenum, param: GLint) void;
pub extern fn glTexGendv(coord: GLenum, pname: GLenum, params: [*c]const GLdouble) void;
pub extern fn glTexGenfv(coord: GLenum, pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glTexGeniv(coord: GLenum, pname: GLenum, params: [*c]const GLint) void;
pub extern fn glGetTexGendv(coord: GLenum, pname: GLenum, params: [*c]GLdouble) void;
pub extern fn glGetTexGenfv(coord: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetTexGeniv(coord: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glTexEnvf(target: GLenum, pname: GLenum, param: GLfloat) void;
pub extern fn glTexEnvi(target: GLenum, pname: GLenum, param: GLint) void;
pub extern fn glTexEnvfv(target: GLenum, pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glTexEnviv(target: GLenum, pname: GLenum, params: [*c]const GLint) void;
pub extern fn glGetTexEnvfv(target: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetTexEnviv(target: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glTexParameterf(target: GLenum, pname: GLenum, param: GLfloat) void;
pub extern fn glTexParameteri(target: GLenum, pname: GLenum, param: GLint) void;
pub extern fn glTexParameterfv(target: GLenum, pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glTexParameteriv(target: GLenum, pname: GLenum, params: [*c]const GLint) void;
pub extern fn glGetTexParameterfv(target: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetTexParameteriv(target: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glGetTexLevelParameterfv(target: GLenum, level: GLint, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetTexLevelParameteriv(target: GLenum, level: GLint, pname: GLenum, params: [*c]GLint) void;
pub extern fn glTexImage1D(target: GLenum, level: GLint, internalFormat: GLint, width: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ?*const GLvoid) void;
pub extern fn glTexImage2D(target: GLenum, level: GLint, internalFormat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ?*const GLvoid) void;
pub extern fn glGetTexImage(target: GLenum, level: GLint, format: GLenum, type: GLenum, pixels: ?*GLvoid) void;
pub extern fn glGenTextures(n: GLsizei, textures: [*c]GLuint) void;
pub extern fn glDeleteTextures(n: GLsizei, textures: [*c]const GLuint) void;
pub extern fn glBindTexture(target: GLenum, texture: GLuint) void;
pub extern fn glPrioritizeTextures(n: GLsizei, textures: [*c]const GLuint, priorities: [*c]const GLclampf) void;
pub extern fn glAreTexturesResident(n: GLsizei, textures: [*c]const GLuint, residences: [*c]GLboolean) GLboolean;
pub extern fn glIsTexture(texture: GLuint) GLboolean;
pub extern fn glTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, type: GLenum, pixels: ?*const GLvoid) void;
pub extern fn glTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ?*const GLvoid) void;
pub extern fn glCopyTexImage1D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) void;
pub extern fn glCopyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) void;
pub extern fn glCopyTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) void;
pub extern fn glCopyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) void;
pub extern fn glMap1d(target: GLenum, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: [*c]const GLdouble) void;
pub extern fn glMap1f(target: GLenum, u1: GLfloat, u2: GLfloat, stride: GLint, order: GLint, points: [*c]const GLfloat) void;
pub extern fn glMap2d(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: [*c]const GLdouble) void;
pub extern fn glMap2f(target: GLenum, u1: GLfloat, u2: GLfloat, ustride: GLint, uorder: GLint, v1: GLfloat, v2: GLfloat, vstride: GLint, vorder: GLint, points: [*c]const GLfloat) void;
pub extern fn glGetMapdv(target: GLenum, query: GLenum, v: [*c]GLdouble) void;
pub extern fn glGetMapfv(target: GLenum, query: GLenum, v: [*c]GLfloat) void;
pub extern fn glGetMapiv(target: GLenum, query: GLenum, v: [*c]GLint) void;
pub extern fn glEvalCoord1d(u: GLdouble) void;
pub extern fn glEvalCoord1f(u: GLfloat) void;
pub extern fn glEvalCoord1dv(u: [*c]const GLdouble) void;
pub extern fn glEvalCoord1fv(u: [*c]const GLfloat) void;
pub extern fn glEvalCoord2d(u: GLdouble, v: GLdouble) void;
pub extern fn glEvalCoord2f(u: GLfloat, v: GLfloat) void;
pub extern fn glEvalCoord2dv(u: [*c]const GLdouble) void;
pub extern fn glEvalCoord2fv(u: [*c]const GLfloat) void;
pub extern fn glMapGrid1d(un: GLint, u1: GLdouble, u2: GLdouble) void;
pub extern fn glMapGrid1f(un: GLint, u1: GLfloat, u2: GLfloat) void;
pub extern fn glMapGrid2d(un: GLint, u1: GLdouble, u2: GLdouble, vn: GLint, v1: GLdouble, v2: GLdouble) void;
pub extern fn glMapGrid2f(un: GLint, u1: GLfloat, u2: GLfloat, vn: GLint, v1: GLfloat, v2: GLfloat) void;
pub extern fn glEvalPoint1(i: GLint) void;
pub extern fn glEvalPoint2(i: GLint, j: GLint) void;
pub extern fn glEvalMesh1(mode: GLenum, i1: GLint, i2: GLint) void;
pub extern fn glEvalMesh2(mode: GLenum, i1: GLint, i2: GLint, j1: GLint, j2: GLint) void;
pub extern fn glFogf(pname: GLenum, param: GLfloat) void;
pub extern fn glFogi(pname: GLenum, param: GLint) void;
pub extern fn glFogfv(pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glFogiv(pname: GLenum, params: [*c]const GLint) void;
pub extern fn glFeedbackBuffer(size: GLsizei, type: GLenum, buffer: [*c]GLfloat) void;
pub extern fn glPassThrough(token: GLfloat) void;
pub extern fn glSelectBuffer(size: GLsizei, buffer: [*c]GLuint) void;
pub extern fn glInitNames() void;
pub extern fn glLoadName(name: GLuint) void;
pub extern fn glPushName(name: GLuint) void;
pub extern fn glPopName() void;
pub extern fn glDrawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, indices: ?*const GLvoid) void;
pub extern fn glTexImage3D(target: GLenum, level: GLint, internalFormat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ?*const GLvoid) void;
pub extern fn glTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pixels: ?*const GLvoid) void;
pub extern fn glCopyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) void;
pub const PFNGLDRAWRANGEELEMENTSPROC = ?fn (GLenum, GLuint, GLuint, GLsizei, GLenum, ?*const GLvoid) callconv(.C) void;
pub const PFNGLTEXIMAGE3DPROC = ?fn (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, ?*const GLvoid) callconv(.C) void;
pub const PFNGLTEXSUBIMAGE3DPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, ?*const GLvoid) callconv(.C) void;
pub const PFNGLCOPYTEXSUBIMAGE3DPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub extern fn glColorTable(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, type: GLenum, table: ?*const GLvoid) void;
pub extern fn glColorSubTable(target: GLenum, start: GLsizei, count: GLsizei, format: GLenum, type: GLenum, data: ?*const GLvoid) void;
pub extern fn glColorTableParameteriv(target: GLenum, pname: GLenum, params: [*c]const GLint) void;
pub extern fn glColorTableParameterfv(target: GLenum, pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glCopyColorSubTable(target: GLenum, start: GLsizei, x: GLint, y: GLint, width: GLsizei) void;
pub extern fn glCopyColorTable(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) void;
pub extern fn glGetColorTable(target: GLenum, format: GLenum, type: GLenum, table: ?*GLvoid) void;
pub extern fn glGetColorTableParameterfv(target: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetColorTableParameteriv(target: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glBlendEquation(mode: GLenum) void;
pub extern fn glBlendColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf) void;
pub extern fn glHistogram(target: GLenum, width: GLsizei, internalformat: GLenum, sink: GLboolean) void;
pub extern fn glResetHistogram(target: GLenum) void;
pub extern fn glGetHistogram(target: GLenum, reset: GLboolean, format: GLenum, type: GLenum, values: ?*GLvoid) void;
pub extern fn glGetHistogramParameterfv(target: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetHistogramParameteriv(target: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glMinmax(target: GLenum, internalformat: GLenum, sink: GLboolean) void;
pub extern fn glResetMinmax(target: GLenum) void;
pub extern fn glGetMinmax(target: GLenum, reset: GLboolean, format: GLenum, types: GLenum, values: ?*GLvoid) void;
pub extern fn glGetMinmaxParameterfv(target: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetMinmaxParameteriv(target: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glConvolutionFilter1D(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, type: GLenum, image: ?*const GLvoid) void;
pub extern fn glConvolutionFilter2D(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, image: ?*const GLvoid) void;
pub extern fn glConvolutionParameterf(target: GLenum, pname: GLenum, params: GLfloat) void;
pub extern fn glConvolutionParameterfv(target: GLenum, pname: GLenum, params: [*c]const GLfloat) void;
pub extern fn glConvolutionParameteri(target: GLenum, pname: GLenum, params: GLint) void;
pub extern fn glConvolutionParameteriv(target: GLenum, pname: GLenum, params: [*c]const GLint) void;
pub extern fn glCopyConvolutionFilter1D(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) void;
pub extern fn glCopyConvolutionFilter2D(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei) void;
pub extern fn glGetConvolutionFilter(target: GLenum, format: GLenum, type: GLenum, image: ?*GLvoid) void;
pub extern fn glGetConvolutionParameterfv(target: GLenum, pname: GLenum, params: [*c]GLfloat) void;
pub extern fn glGetConvolutionParameteriv(target: GLenum, pname: GLenum, params: [*c]GLint) void;
pub extern fn glSeparableFilter2D(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, row: ?*const GLvoid, column: ?*const GLvoid) void;
pub extern fn glGetSeparableFilter(target: GLenum, format: GLenum, type: GLenum, row: ?*GLvoid, column: ?*GLvoid, span: ?*GLvoid) void;
pub extern fn glActiveTexture(texture: GLenum) void;
pub extern fn glClientActiveTexture(texture: GLenum) void;
pub extern fn glCompressedTexImage1D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, data: ?*const GLvoid) void;
pub extern fn glCompressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, data: ?*const GLvoid) void;
pub extern fn glCompressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: ?*const GLvoid) void;
pub extern fn glCompressedTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, data: ?*const GLvoid) void;
pub extern fn glCompressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, data: ?*const GLvoid) void;
pub extern fn glCompressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, data: ?*const GLvoid) void;
pub extern fn glGetCompressedTexImage(target: GLenum, lod: GLint, img: ?*GLvoid) void;
pub extern fn glMultiTexCoord1d(target: GLenum, s: GLdouble) void;
pub extern fn glMultiTexCoord1dv(target: GLenum, v: [*c]const GLdouble) void;
pub extern fn glMultiTexCoord1f(target: GLenum, s: GLfloat) void;
pub extern fn glMultiTexCoord1fv(target: GLenum, v: [*c]const GLfloat) void;
pub extern fn glMultiTexCoord1i(target: GLenum, s: GLint) void;
pub extern fn glMultiTexCoord1iv(target: GLenum, v: [*c]const GLint) void;
pub extern fn glMultiTexCoord1s(target: GLenum, s: GLshort) void;
pub extern fn glMultiTexCoord1sv(target: GLenum, v: [*c]const GLshort) void;
pub extern fn glMultiTexCoord2d(target: GLenum, s: GLdouble, t: GLdouble) void;
pub extern fn glMultiTexCoord2dv(target: GLenum, v: [*c]const GLdouble) void;
pub extern fn glMultiTexCoord2f(target: GLenum, s: GLfloat, t: GLfloat) void;
pub extern fn glMultiTexCoord2fv(target: GLenum, v: [*c]const GLfloat) void;
pub extern fn glMultiTexCoord2i(target: GLenum, s: GLint, t: GLint) void;
pub extern fn glMultiTexCoord2iv(target: GLenum, v: [*c]const GLint) void;
pub extern fn glMultiTexCoord2s(target: GLenum, s: GLshort, t: GLshort) void;
pub extern fn glMultiTexCoord2sv(target: GLenum, v: [*c]const GLshort) void;
pub extern fn glMultiTexCoord3d(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble) void;
pub extern fn glMultiTexCoord3dv(target: GLenum, v: [*c]const GLdouble) void;
pub extern fn glMultiTexCoord3f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) void;
pub extern fn glMultiTexCoord3fv(target: GLenum, v: [*c]const GLfloat) void;
pub extern fn glMultiTexCoord3i(target: GLenum, s: GLint, t: GLint, r: GLint) void;
pub extern fn glMultiTexCoord3iv(target: GLenum, v: [*c]const GLint) void;
pub extern fn glMultiTexCoord3s(target: GLenum, s: GLshort, t: GLshort, r: GLshort) void;
pub extern fn glMultiTexCoord3sv(target: GLenum, v: [*c]const GLshort) void;
pub extern fn glMultiTexCoord4d(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) void;
pub extern fn glMultiTexCoord4dv(target: GLenum, v: [*c]const GLdouble) void;
pub extern fn glMultiTexCoord4f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) void;
pub extern fn glMultiTexCoord4fv(target: GLenum, v: [*c]const GLfloat) void;
pub extern fn glMultiTexCoord4i(target: GLenum, s: GLint, t: GLint, r: GLint, q: GLint) void;
pub extern fn glMultiTexCoord4iv(target: GLenum, v: [*c]const GLint) void;
pub extern fn glMultiTexCoord4s(target: GLenum, s: GLshort, t: GLshort, r: GLshort, q: GLshort) void;
pub extern fn glMultiTexCoord4sv(target: GLenum, v: [*c]const GLshort) void;
pub extern fn glLoadTransposeMatrixd(m: [*c]const GLdouble) void;
pub extern fn glLoadTransposeMatrixf(m: [*c]const GLfloat) void;
pub extern fn glMultTransposeMatrixd(m: [*c]const GLdouble) void;
pub extern fn glMultTransposeMatrixf(m: [*c]const GLfloat) void;
pub extern fn glSampleCoverage(value: GLclampf, invert: GLboolean) void;
pub const PFNGLACTIVETEXTUREPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLSAMPLECOVERAGEPROC = ?fn (GLclampf, GLboolean) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXIMAGE3DPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, ?*const GLvoid) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXIMAGE2DPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, ?*const GLvoid) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXIMAGE1DPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, ?*const GLvoid) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, ?*const GLvoid) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC = ?fn (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, ?*const GLvoid) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC = ?fn (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, ?*const GLvoid) callconv(.C) void;
pub const PFNGLGETCOMPRESSEDTEXIMAGEPROC = ?fn (GLenum, GLint, ?*GLvoid) callconv(.C) void;
pub extern fn glActiveTextureARB(texture: GLenum) void;
pub extern fn glClientActiveTextureARB(texture: GLenum) void;
pub extern fn glMultiTexCoord1dARB(target: GLenum, s: GLdouble) void;
pub extern fn glMultiTexCoord1dvARB(target: GLenum, v: [*c]const GLdouble) void;
pub extern fn glMultiTexCoord1fARB(target: GLenum, s: GLfloat) void;
pub extern fn glMultiTexCoord1fvARB(target: GLenum, v: [*c]const GLfloat) void;
pub extern fn glMultiTexCoord1iARB(target: GLenum, s: GLint) void;
pub extern fn glMultiTexCoord1ivARB(target: GLenum, v: [*c]const GLint) void;
pub extern fn glMultiTexCoord1sARB(target: GLenum, s: GLshort) void;
pub extern fn glMultiTexCoord1svARB(target: GLenum, v: [*c]const GLshort) void;
pub extern fn glMultiTexCoord2dARB(target: GLenum, s: GLdouble, t: GLdouble) void;
pub extern fn glMultiTexCoord2dvARB(target: GLenum, v: [*c]const GLdouble) void;
pub extern fn glMultiTexCoord2fARB(target: GLenum, s: GLfloat, t: GLfloat) void;
pub extern fn glMultiTexCoord2fvARB(target: GLenum, v: [*c]const GLfloat) void;
pub extern fn glMultiTexCoord2iARB(target: GLenum, s: GLint, t: GLint) void;
pub extern fn glMultiTexCoord2ivARB(target: GLenum, v: [*c]const GLint) void;
pub extern fn glMultiTexCoord2sARB(target: GLenum, s: GLshort, t: GLshort) void;
pub extern fn glMultiTexCoord2svARB(target: GLenum, v: [*c]const GLshort) void;
pub extern fn glMultiTexCoord3dARB(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble) void;
pub extern fn glMultiTexCoord3dvARB(target: GLenum, v: [*c]const GLdouble) void;
pub extern fn glMultiTexCoord3fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) void;
pub extern fn glMultiTexCoord3fvARB(target: GLenum, v: [*c]const GLfloat) void;
pub extern fn glMultiTexCoord3iARB(target: GLenum, s: GLint, t: GLint, r: GLint) void;
pub extern fn glMultiTexCoord3ivARB(target: GLenum, v: [*c]const GLint) void;
pub extern fn glMultiTexCoord3sARB(target: GLenum, s: GLshort, t: GLshort, r: GLshort) void;
pub extern fn glMultiTexCoord3svARB(target: GLenum, v: [*c]const GLshort) void;
pub extern fn glMultiTexCoord4dARB(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) void;
pub extern fn glMultiTexCoord4dvARB(target: GLenum, v: [*c]const GLdouble) void;
pub extern fn glMultiTexCoord4fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) void;
pub extern fn glMultiTexCoord4fvARB(target: GLenum, v: [*c]const GLfloat) void;
pub extern fn glMultiTexCoord4iARB(target: GLenum, s: GLint, t: GLint, r: GLint, q: GLint) void;
pub extern fn glMultiTexCoord4ivARB(target: GLenum, v: [*c]const GLint) void;
pub extern fn glMultiTexCoord4sARB(target: GLenum, s: GLshort, t: GLshort, r: GLshort, q: GLshort) void;
pub extern fn glMultiTexCoord4svARB(target: GLenum, v: [*c]const GLshort) void;
pub const PFNGLACTIVETEXTUREARBPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLCLIENTACTIVETEXTUREARBPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1DARBPROC = ?fn (GLenum, GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1DVARBPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1FARBPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1FVARBPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1IARBPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1IVARBPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1SARBPROC = ?fn (GLenum, GLshort) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1SVARBPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2DARBPROC = ?fn (GLenum, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2DVARBPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2FARBPROC = ?fn (GLenum, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2FVARBPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2IARBPROC = ?fn (GLenum, GLint, GLint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2IVARBPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2SARBPROC = ?fn (GLenum, GLshort, GLshort) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2SVARBPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3DARBPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3DVARBPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3FARBPROC = ?fn (GLenum, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3FVARBPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3IARBPROC = ?fn (GLenum, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3IVARBPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3SARBPROC = ?fn (GLenum, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3SVARBPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4DARBPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4DVARBPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4FARBPROC = ?fn (GLenum, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4FVARBPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4IARBPROC = ?fn (GLenum, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4IVARBPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4SARBPROC = ?fn (GLenum, GLshort, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4SVARBPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const khronos_int32_t = i32;
pub const khronos_uint32_t = u32;
pub const khronos_int64_t = i64;
pub const khronos_uint64_t = u64;
pub const khronos_int8_t = i8;
pub const khronos_uint8_t = u8;
pub const khronos_int16_t = c_short;
pub const khronos_uint16_t = c_ushort;
pub const khronos_intptr_t = c_long;
pub const khronos_uintptr_t = c_ulong;
pub const khronos_ssize_t = c_long;
pub const khronos_usize_t = c_ulong;
pub const khronos_float_t = f32;
pub const khronos_utime_nanoseconds_t = khronos_uint64_t;
pub const khronos_stime_nanoseconds_t = khronos_int64_t;
pub const KHRONOS_FALSE = @enumToInt(enum_unnamed_3.KHRONOS_FALSE);
pub const KHRONOS_TRUE = @enumToInt(enum_unnamed_3.KHRONOS_TRUE);
pub const KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = @enumToInt(enum_unnamed_3.KHRONOS_BOOLEAN_ENUM_FORCE_SIZE);
const enum_unnamed_3 = extern enum(c_int) {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = 2147483647,
_,
};
pub const khronos_boolean_enum_t = enum_unnamed_3;
pub const PFNGLBLENDFUNCSEPARATEPROC = ?fn (GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLMULTIDRAWARRAYSPROC = ?fn (GLenum, [*c]const GLint, [*c]const GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSPROC = ?fn (GLenum, [*c]const GLsizei, GLenum, [*c]const ?*const c_void, GLsizei) callconv(.C) void;
pub const PFNGLPOINTPARAMETERFPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLPOINTPARAMETERFVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPOINTPARAMETERIPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLPOINTPARAMETERIVPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLFOGCOORDFPROC = ?fn (GLfloat) callconv(.C) void;
pub const PFNGLFOGCOORDFVPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLFOGCOORDDPROC = ?fn (GLdouble) callconv(.C) void;
pub const PFNGLFOGCOORDDVPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLFOGCOORDPOINTERPROC = ?fn (GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3BPROC = ?fn (GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3BVPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3DPROC = ?fn (GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3DVPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3FPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3FVPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3IPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3IVPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3SPROC = ?fn (GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3SVPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3UBPROC = ?fn (GLubyte, GLubyte, GLubyte) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3UBVPROC = ?fn ([*c]const GLubyte) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3UIPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3UIVPROC = ?fn ([*c]const GLuint) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3USPROC = ?fn (GLushort, GLushort, GLushort) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3USVPROC = ?fn ([*c]const GLushort) callconv(.C) void;
pub const PFNGLSECONDARYCOLORPOINTERPROC = ?fn (GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLWINDOWPOS2DPROC = ?fn (GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS2DVPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS2FPROC = ?fn (GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS2FVPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS2IPROC = ?fn (GLint, GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS2IVPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS2SPROC = ?fn (GLshort, GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS2SVPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS3DPROC = ?fn (GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS3DVPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS3FPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS3FVPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS3IPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS3IVPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS3SPROC = ?fn (GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS3SVPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLBLENDCOLORPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLBLENDEQUATIONPROC = ?fn (GLenum) callconv(.C) void;
pub const GLsizeiptr = khronos_ssize_t;
pub const GLintptr = khronos_intptr_t;
pub const PFNGLGENQUERIESPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETEQUERIESPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISQUERYPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBEGINQUERYPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLENDQUERYPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLGETQUERYIVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETQUERYOBJECTIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETQUERYOBJECTUIVPROC = ?fn (GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLBINDBUFFERPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETEBUFFERSPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENBUFFERSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISBUFFERPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBUFFERDATAPROC = ?fn (GLenum, GLsizeiptr, ?*const c_void, GLenum) callconv(.C) void;
pub const PFNGLBUFFERSUBDATAPROC = ?fn (GLenum, GLintptr, GLsizeiptr, ?*const c_void) callconv(.C) void;
pub const PFNGLGETBUFFERSUBDATAPROC = ?fn (GLenum, GLintptr, GLsizeiptr, ?*c_void) callconv(.C) void;
pub const PFNGLMAPBUFFERPROC = ?fn (GLenum, GLenum) callconv(.C) ?*c_void;
pub const PFNGLUNMAPBUFFERPROC = ?fn (GLenum) callconv(.C) GLboolean;
pub const PFNGLGETBUFFERPARAMETERIVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETBUFFERPOINTERVPROC = ?fn (GLenum, GLenum, [*c]?*c_void) callconv(.C) void;
pub const GLchar = u8;
pub const PFNGLBLENDEQUATIONSEPARATEPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLDRAWBUFFERSPROC = ?fn (GLsizei, [*c]const GLenum) callconv(.C) void;
pub const PFNGLSTENCILOPSEPARATEPROC = ?fn (GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLSTENCILFUNCSEPARATEPROC = ?fn (GLenum, GLenum, GLint, GLuint) callconv(.C) void;
pub const PFNGLSTENCILMASKSEPARATEPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLATTACHSHADERPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLBINDATTRIBLOCATIONPROC = ?fn (GLuint, GLuint, [*c]const GLchar) callconv(.C) void;
pub const PFNGLCOMPILESHADERPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLCREATEPROGRAMPROC = ?fn () callconv(.C) GLuint;
pub const PFNGLCREATESHADERPROC = ?fn (GLenum) callconv(.C) GLuint;
pub const PFNGLDELETEPROGRAMPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDELETESHADERPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDETACHSHADERPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLDISABLEVERTEXATTRIBARRAYPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLENABLEVERTEXATTRIBARRAYPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLGETACTIVEATTRIBPROC = ?fn (GLuint, GLuint, GLsizei, [*c]GLsizei, [*c]GLint, [*c]GLenum, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETACTIVEUNIFORMPROC = ?fn (GLuint, GLuint, GLsizei, [*c]GLsizei, [*c]GLint, [*c]GLenum, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETATTACHEDSHADERSPROC = ?fn (GLuint, GLsizei, [*c]GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETATTRIBLOCATIONPROC = ?fn (GLuint, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLGETPROGRAMIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPROGRAMINFOLOGPROC = ?fn (GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETSHADERIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETSHADERINFOLOGPROC = ?fn (GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETSHADERSOURCEPROC = ?fn (GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETUNIFORMLOCATIONPROC = ?fn (GLuint, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLGETUNIFORMFVPROC = ?fn (GLuint, GLint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETUNIFORMIVPROC = ?fn (GLuint, GLint, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBDVPROC = ?fn (GLuint, GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBFVPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBPOINTERVPROC = ?fn (GLuint, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLISPROGRAMPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLISSHADERPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLLINKPROGRAMPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLSHADERSOURCEPROC = ?fn (GLuint, GLsizei, [*c]const [*c]const GLchar, [*c]const GLint) callconv(.C) void;
pub const PFNGLUSEPROGRAMPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLUNIFORM1FPROC = ?fn (GLint, GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM2FPROC = ?fn (GLint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM3FPROC = ?fn (GLint, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM4FPROC = ?fn (GLint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM1IPROC = ?fn (GLint, GLint) callconv(.C) void;
pub const PFNGLUNIFORM2IPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLUNIFORM3IPROC = ?fn (GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLUNIFORM4IPROC = ?fn (GLint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLUNIFORM1FVPROC = ?fn (GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM2FVPROC = ?fn (GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM3FVPROC = ?fn (GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM4FVPROC = ?fn (GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM1IVPROC = ?fn (GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORM2IVPROC = ?fn (GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORM3IVPROC = ?fn (GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORM4IVPROC = ?fn (GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX2FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX3FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX4FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVALIDATEPROGRAMPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1DPROC = ?fn (GLuint, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1DVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1FPROC = ?fn (GLuint, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1FVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1SPROC = ?fn (GLuint, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1SVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2DPROC = ?fn (GLuint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2DVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2FPROC = ?fn (GLuint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2FVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2SPROC = ?fn (GLuint, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2SVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3DPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3DVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3FPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3FVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3SPROC = ?fn (GLuint, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3SVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NBVPROC = ?fn (GLuint, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NIVPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NSVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NUBPROC = ?fn (GLuint, GLubyte, GLubyte, GLubyte, GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NUBVPROC = ?fn (GLuint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NUIVPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NUSVPROC = ?fn (GLuint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4BVPROC = ?fn (GLuint, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4DPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4DVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4FPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4FVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4IVPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4SPROC = ?fn (GLuint, GLshort, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4SVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4UBVPROC = ?fn (GLuint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4UIVPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4USVPROC = ?fn (GLuint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBPOINTERPROC = ?fn (GLuint, GLint, GLenum, GLboolean, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX2X3FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX3X2FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX2X4FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX4X2FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX3X4FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX4X3FVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const GLhalf = khronos_uint16_t;
pub const PFNGLCOLORMASKIPROC = ?fn (GLuint, GLboolean, GLboolean, GLboolean, GLboolean) callconv(.C) void;
pub const PFNGLGETBOOLEANI_VPROC = ?fn (GLenum, GLuint, [*c]GLboolean) callconv(.C) void;
pub const PFNGLGETINTEGERI_VPROC = ?fn (GLenum, GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLENABLEIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDISABLEIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLISENABLEDIPROC = ?fn (GLenum, GLuint) callconv(.C) GLboolean;
pub const PFNGLBEGINTRANSFORMFEEDBACKPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLENDTRANSFORMFEEDBACKPROC = ?fn () callconv(.C) void;
pub const PFNGLBINDBUFFERRANGEPROC = ?fn (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLBINDBUFFERBASEPROC = ?fn (GLenum, GLuint, GLuint) callconv(.C) void;
pub const PFNGLTRANSFORMFEEDBACKVARYINGSPROC = ?fn (GLuint, GLsizei, [*c]const [*c]const GLchar, GLenum) callconv(.C) void;
pub const PFNGLGETTRANSFORMFEEDBACKVARYINGPROC = ?fn (GLuint, GLuint, GLsizei, [*c]GLsizei, [*c]GLsizei, [*c]GLenum, [*c]GLchar) callconv(.C) void;
pub const PFNGLCLAMPCOLORPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLBEGINCONDITIONALRENDERPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLENDCONDITIONALRENDERPROC = ?fn () callconv(.C) void;
pub const PFNGLVERTEXATTRIBIPOINTERPROC = ?fn (GLuint, GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBIIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBIUIVPROC = ?fn (GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI1IPROC = ?fn (GLuint, GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI2IPROC = ?fn (GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI3IPROC = ?fn (GLuint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4IPROC = ?fn (GLuint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI1UIPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI2UIPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI3UIPROC = ?fn (GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4UIPROC = ?fn (GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI1IVPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI2IVPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI3IVPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4IVPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI1UIVPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI2UIVPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI3UIVPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4UIVPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4BVPROC = ?fn (GLuint, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4SVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4UBVPROC = ?fn (GLuint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4USVPROC = ?fn (GLuint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLGETUNIFORMUIVPROC = ?fn (GLuint, GLint, [*c]GLuint) callconv(.C) void;
pub const PFNGLBINDFRAGDATALOCATIONPROC = ?fn (GLuint, GLuint, [*c]const GLchar) callconv(.C) void;
pub const PFNGLGETFRAGDATALOCATIONPROC = ?fn (GLuint, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLUNIFORM1UIPROC = ?fn (GLint, GLuint) callconv(.C) void;
pub const PFNGLUNIFORM2UIPROC = ?fn (GLint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLUNIFORM3UIPROC = ?fn (GLint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLUNIFORM4UIPROC = ?fn (GLint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLUNIFORM1UIVPROC = ?fn (GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLUNIFORM2UIVPROC = ?fn (GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLUNIFORM3UIVPROC = ?fn (GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLUNIFORM4UIVPROC = ?fn (GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLTEXPARAMETERIIVPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLTEXPARAMETERIUIVPROC = ?fn (GLenum, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETTEXPARAMETERIIVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTEXPARAMETERIUIVPROC = ?fn (GLenum, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLCLEARBUFFERIVPROC = ?fn (GLenum, GLint, [*c]const GLint) callconv(.C) void;
pub const PFNGLCLEARBUFFERUIVPROC = ?fn (GLenum, GLint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLCLEARBUFFERFVPROC = ?fn (GLenum, GLint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCLEARBUFFERFIPROC = ?fn (GLenum, GLint, GLfloat, GLint) callconv(.C) void;
pub const PFNGLGETSTRINGIPROC = ?fn (GLenum, GLuint) callconv(.C) [*c]const GLubyte;
pub const PFNGLISRENDERBUFFERPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBINDRENDERBUFFERPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETERENDERBUFFERSPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENRENDERBUFFERSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLRENDERBUFFERSTORAGEPROC = ?fn (GLenum, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGETRENDERBUFFERPARAMETERIVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLISFRAMEBUFFERPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBINDFRAMEBUFFERPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETEFRAMEBUFFERSPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENFRAMEBUFFERSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLCHECKFRAMEBUFFERSTATUSPROC = ?fn (GLenum) callconv(.C) GLenum;
pub const PFNGLFRAMEBUFFERTEXTURE1DPROC = ?fn (GLenum, GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTURE2DPROC = ?fn (GLenum, GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTURE3DPROC = ?fn (GLenum, GLenum, GLenum, GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERRENDERBUFFERPROC = ?fn (GLenum, GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGENERATEMIPMAPPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLBLITFRAMEBUFFERPROC = ?fn (GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) callconv(.C) void;
pub const PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTURELAYERPROC = ?fn (GLenum, GLenum, GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLMAPBUFFERRANGEPROC = ?fn (GLenum, GLintptr, GLsizeiptr, GLbitfield) callconv(.C) ?*c_void;
pub const PFNGLFLUSHMAPPEDBUFFERRANGEPROC = ?fn (GLenum, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLBINDVERTEXARRAYPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDELETEVERTEXARRAYSPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENVERTEXARRAYSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISVERTEXARRAYPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLDRAWARRAYSINSTANCEDPROC = ?fn (GLenum, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLDRAWELEMENTSINSTANCEDPROC = ?fn (GLenum, GLsizei, GLenum, ?*const c_void, GLsizei) callconv(.C) void;
pub const PFNGLTEXBUFFERPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLPRIMITIVERESTARTINDEXPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLCOPYBUFFERSUBDATAPROC = ?fn (GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLGETUNIFORMINDICESPROC = ?fn (GLuint, GLsizei, [*c]const [*c]const GLchar, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETACTIVEUNIFORMSIVPROC = ?fn (GLuint, GLsizei, [*c]const GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETACTIVEUNIFORMNAMEPROC = ?fn (GLuint, GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETUNIFORMBLOCKINDEXPROC = ?fn (GLuint, [*c]const GLchar) callconv(.C) GLuint;
pub const PFNGLGETACTIVEUNIFORMBLOCKIVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC = ?fn (GLuint, GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLUNIFORMBLOCKBINDINGPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const struct___GLsync = opaque {};
pub const GLsync = ?*struct___GLsync;
pub const GLuint64 = khronos_uint64_t;
pub const GLint64 = khronos_int64_t;
pub const PFNGLDRAWELEMENTSBASEVERTEXPROC = ?fn (GLenum, GLsizei, GLenum, ?*const c_void, GLint) callconv(.C) void;
pub const PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC = ?fn (GLenum, GLuint, GLuint, GLsizei, GLenum, ?*const c_void, GLint) callconv(.C) void;
pub const PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC = ?fn (GLenum, GLsizei, GLenum, ?*const c_void, GLsizei, GLint) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC = ?fn (GLenum, [*c]const GLsizei, GLenum, [*c]const ?*const c_void, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROVOKINGVERTEXPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLFENCESYNCPROC = ?fn (GLenum, GLbitfield) callconv(.C) GLsync;
pub const PFNGLISSYNCPROC = ?fn (GLsync) callconv(.C) GLboolean;
pub const PFNGLDELETESYNCPROC = ?fn (GLsync) callconv(.C) void;
pub const PFNGLCLIENTWAITSYNCPROC = ?fn (GLsync, GLbitfield, GLuint64) callconv(.C) GLenum;
pub const PFNGLWAITSYNCPROC = ?fn (GLsync, GLbitfield, GLuint64) callconv(.C) void;
pub const PFNGLGETINTEGER64VPROC = ?fn (GLenum, [*c]GLint64) callconv(.C) void;
pub const PFNGLGETSYNCIVPROC = ?fn (GLsync, GLenum, GLsizei, [*c]GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLGETINTEGER64I_VPROC = ?fn (GLenum, GLuint, [*c]GLint64) callconv(.C) void;
pub const PFNGLGETBUFFERPARAMETERI64VPROC = ?fn (GLenum, GLenum, [*c]GLint64) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTUREPROC = ?fn (GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLTEXIMAGE2DMULTISAMPLEPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXIMAGE3DMULTISAMPLEPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLGETMULTISAMPLEFVPROC = ?fn (GLenum, GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLSAMPLEMASKIPROC = ?fn (GLuint, GLbitfield) callconv(.C) void;
pub const PFNGLBINDFRAGDATALOCATIONINDEXEDPROC = ?fn (GLuint, GLuint, GLuint, [*c]const GLchar) callconv(.C) void;
pub const PFNGLGETFRAGDATAINDEXPROC = ?fn (GLuint, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLGENSAMPLERSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETESAMPLERSPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISSAMPLERPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBINDSAMPLERPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLSAMPLERPARAMETERIPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLSAMPLERPARAMETERIVPROC = ?fn (GLuint, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLSAMPLERPARAMETERFPROC = ?fn (GLuint, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLSAMPLERPARAMETERFVPROC = ?fn (GLuint, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLSAMPLERPARAMETERIIVPROC = ?fn (GLuint, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLSAMPLERPARAMETERIUIVPROC = ?fn (GLuint, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETSAMPLERPARAMETERIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETSAMPLERPARAMETERIIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETSAMPLERPARAMETERFVPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETSAMPLERPARAMETERIUIVPROC = ?fn (GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLQUERYCOUNTERPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLGETQUERYOBJECTI64VPROC = ?fn (GLuint, GLenum, [*c]GLint64) callconv(.C) void;
pub const PFNGLGETQUERYOBJECTUI64VPROC = ?fn (GLuint, GLenum, [*c]GLuint64) callconv(.C) void;
pub const PFNGLVERTEXATTRIBDIVISORPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBP1UIPROC = ?fn (GLuint, GLenum, GLboolean, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBP1UIVPROC = ?fn (GLuint, GLenum, GLboolean, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBP2UIPROC = ?fn (GLuint, GLenum, GLboolean, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBP2UIVPROC = ?fn (GLuint, GLenum, GLboolean, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBP3UIPROC = ?fn (GLuint, GLenum, GLboolean, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBP3UIVPROC = ?fn (GLuint, GLenum, GLboolean, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBP4UIPROC = ?fn (GLuint, GLenum, GLboolean, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBP4UIVPROC = ?fn (GLuint, GLenum, GLboolean, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXP2UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXP2UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXP3UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXP3UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXP4UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXP4UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLTEXCOORDP1UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLTEXCOORDP1UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLTEXCOORDP2UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLTEXCOORDP2UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLTEXCOORDP3UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLTEXCOORDP3UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLTEXCOORDP4UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLTEXCOORDP4UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDP1UIPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDP1UIVPROC = ?fn (GLenum, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDP2UIPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDP2UIVPROC = ?fn (GLenum, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDP3UIPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDP3UIVPROC = ?fn (GLenum, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDP4UIPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDP4UIVPROC = ?fn (GLenum, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLNORMALP3UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLNORMALP3UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLCOLORP3UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLCOLORP3UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLCOLORP4UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLCOLORP4UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLSECONDARYCOLORP3UIPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLSECONDARYCOLORP3UIVPROC = ?fn (GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLMINSAMPLESHADINGPROC = ?fn (GLfloat) callconv(.C) void;
pub const PFNGLBLENDEQUATIONIPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLBLENDEQUATIONSEPARATEIPROC = ?fn (GLuint, GLenum, GLenum) callconv(.C) void;
pub const PFNGLBLENDFUNCIPROC = ?fn (GLuint, GLenum, GLenum) callconv(.C) void;
pub const PFNGLBLENDFUNCSEPARATEIPROC = ?fn (GLuint, GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLDRAWARRAYSINDIRECTPROC = ?fn (GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLDRAWELEMENTSINDIRECTPROC = ?fn (GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLUNIFORM1DPROC = ?fn (GLint, GLdouble) callconv(.C) void;
pub const PFNGLUNIFORM2DPROC = ?fn (GLint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLUNIFORM3DPROC = ?fn (GLint, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLUNIFORM4DPROC = ?fn (GLint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLUNIFORM1DVPROC = ?fn (GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORM2DVPROC = ?fn (GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORM3DVPROC = ?fn (GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORM4DVPROC = ?fn (GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX2DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX3DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX4DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX2X3DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX2X4DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX3X2DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX3X4DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX4X2DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX4X3DVPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLGETUNIFORMDVPROC = ?fn (GLuint, GLint, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC = ?fn (GLuint, GLenum, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLGETSUBROUTINEINDEXPROC = ?fn (GLuint, GLenum, [*c]const GLchar) callconv(.C) GLuint;
pub const PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC = ?fn (GLuint, GLenum, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC = ?fn (GLuint, GLenum, GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETACTIVESUBROUTINENAMEPROC = ?fn (GLuint, GLenum, GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLUNIFORMSUBROUTINESUIVPROC = ?fn (GLenum, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETUNIFORMSUBROUTINEUIVPROC = ?fn (GLenum, GLint, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETPROGRAMSTAGEIVPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLPATCHPARAMETERIPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLPATCHPARAMETERFVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLBINDTRANSFORMFEEDBACKPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETETRANSFORMFEEDBACKSPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENTRANSFORMFEEDBACKSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISTRANSFORMFEEDBACKPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLPAUSETRANSFORMFEEDBACKPROC = ?fn () callconv(.C) void;
pub const PFNGLRESUMETRANSFORMFEEDBACKPROC = ?fn () callconv(.C) void;
pub const PFNGLDRAWTRANSFORMFEEDBACKPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC = ?fn (GLenum, GLuint, GLuint) callconv(.C) void;
pub const PFNGLBEGINQUERYINDEXEDPROC = ?fn (GLenum, GLuint, GLuint) callconv(.C) void;
pub const PFNGLENDQUERYINDEXEDPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLGETQUERYINDEXEDIVPROC = ?fn (GLenum, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLRELEASESHADERCOMPILERPROC = ?fn () callconv(.C) void;
pub const PFNGLSHADERBINARYPROC = ?fn (GLsizei, [*c]const GLuint, GLenum, ?*const c_void, GLsizei) callconv(.C) void;
pub const PFNGLGETSHADERPRECISIONFORMATPROC = ?fn (GLenum, GLenum, [*c]GLint, [*c]GLint) callconv(.C) void;
pub const PFNGLDEPTHRANGEFPROC = ?fn (GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLCLEARDEPTHFPROC = ?fn (GLfloat) callconv(.C) void;
pub const PFNGLGETPROGRAMBINARYPROC = ?fn (GLuint, GLsizei, [*c]GLsizei, [*c]GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLPROGRAMBINARYPROC = ?fn (GLuint, GLenum, ?*const c_void, GLsizei) callconv(.C) void;
pub const PFNGLPROGRAMPARAMETERIPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLUSEPROGRAMSTAGESPROC = ?fn (GLuint, GLbitfield, GLuint) callconv(.C) void;
pub const PFNGLACTIVESHADERPROGRAMPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLCREATESHADERPROGRAMVPROC = ?fn (GLenum, GLsizei, [*c]const [*c]const GLchar) callconv(.C) GLuint;
pub const PFNGLBINDPROGRAMPIPELINEPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDELETEPROGRAMPIPELINESPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENPROGRAMPIPELINESPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISPROGRAMPIPELINEPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLGETPROGRAMPIPELINEIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1IPROC = ?fn (GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1IVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1FPROC = ?fn (GLuint, GLint, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1FVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1DPROC = ?fn (GLuint, GLint, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1DVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1UIPROC = ?fn (GLuint, GLint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1UIVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2IPROC = ?fn (GLuint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2IVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2FPROC = ?fn (GLuint, GLint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2FVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2DPROC = ?fn (GLuint, GLint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2DVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2UIPROC = ?fn (GLuint, GLint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2UIVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3IPROC = ?fn (GLuint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3IVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3FPROC = ?fn (GLuint, GLint, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3FVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3DPROC = ?fn (GLuint, GLint, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3DVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3UIPROC = ?fn (GLuint, GLint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3UIVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4IPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4IVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4FPROC = ?fn (GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4FVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4DPROC = ?fn (GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4DVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4UIPROC = ?fn (GLuint, GLint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4UIVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVALIDATEPROGRAMPIPELINEPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLGETPROGRAMPIPELINEINFOLOGPROC = ?fn (GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1DPROC = ?fn (GLuint, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL2DPROC = ?fn (GLuint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL3DPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL4DPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1DVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL2DVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL3DVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL4DVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBLPOINTERPROC = ?fn (GLuint, GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBLDVPROC = ?fn (GLuint, GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLVIEWPORTARRAYVPROC = ?fn (GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVIEWPORTINDEXEDFPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVIEWPORTINDEXEDFVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLSCISSORARRAYVPROC = ?fn (GLuint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLSCISSORINDEXEDPROC = ?fn (GLuint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLSCISSORINDEXEDVPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLDEPTHRANGEARRAYVPROC = ?fn (GLuint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLDEPTHRANGEINDEXEDPROC = ?fn (GLuint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLGETFLOATI_VPROC = ?fn (GLenum, GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETDOUBLEI_VPROC = ?fn (GLenum, GLuint, [*c]GLdouble) callconv(.C) void;
pub const PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC = ?fn (GLenum, GLint, GLsizei, GLsizei, GLuint) callconv(.C) void;
pub const PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC = ?fn (GLenum, GLsizei, GLenum, ?*const c_void, GLsizei, GLuint) callconv(.C) void;
pub const PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC = ?fn (GLenum, GLsizei, GLenum, ?*const c_void, GLsizei, GLint, GLuint) callconv(.C) void;
pub const PFNGLGETINTERNALFORMATIVPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLBINDIMAGETEXTUREPROC = ?fn (GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum) callconv(.C) void;
pub const PFNGLMEMORYBARRIERPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLTEXSTORAGE1DPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLTEXSTORAGE2DPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLTEXSTORAGE3DPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC = ?fn (GLenum, GLuint, GLsizei) callconv(.C) void;
pub const PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC = ?fn (GLenum, GLuint, GLuint, GLsizei) callconv(.C) void;
pub const GLDEBUGPROC = ?fn (GLenum, GLenum, GLuint, GLenum, GLsizei, [*c]const GLchar, ?*const c_void) callconv(.C) void;
pub const PFNGLCLEARBUFFERDATAPROC = ?fn (GLenum, GLenum, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCLEARBUFFERSUBDATAPROC = ?fn (GLenum, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLDISPATCHCOMPUTEPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLDISPATCHCOMPUTEINDIRECTPROC = ?fn (GLintptr) callconv(.C) void;
pub const PFNGLCOPYIMAGESUBDATAPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLFRAMEBUFFERPARAMETERIPROC = ?fn (GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLGETFRAMEBUFFERPARAMETERIVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETINTERNALFORMATI64VPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, [*c]GLint64) callconv(.C) void;
pub const PFNGLINVALIDATETEXSUBIMAGEPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLINVALIDATETEXIMAGEPROC = ?fn (GLuint, GLint) callconv(.C) void;
pub const PFNGLINVALIDATEBUFFERSUBDATAPROC = ?fn (GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLINVALIDATEBUFFERDATAPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLINVALIDATEFRAMEBUFFERPROC = ?fn (GLenum, GLsizei, [*c]const GLenum) callconv(.C) void;
pub const PFNGLINVALIDATESUBFRAMEBUFFERPROC = ?fn (GLenum, GLsizei, [*c]const GLenum, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWARRAYSINDIRECTPROC = ?fn (GLenum, ?*const c_void, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSINDIRECTPROC = ?fn (GLenum, GLenum, ?*const c_void, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGETPROGRAMINTERFACEIVPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPROGRAMRESOURCEINDEXPROC = ?fn (GLuint, GLenum, [*c]const GLchar) callconv(.C) GLuint;
pub const PFNGLGETPROGRAMRESOURCENAMEPROC = ?fn (GLuint, GLenum, GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETPROGRAMRESOURCEIVPROC = ?fn (GLuint, GLenum, GLuint, GLsizei, [*c]const GLenum, GLsizei, [*c]GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPROGRAMRESOURCELOCATIONPROC = ?fn (GLuint, GLenum, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC = ?fn (GLuint, GLenum, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLSHADERSTORAGEBLOCKBINDINGPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLTEXBUFFERRANGEPROC = ?fn (GLenum, GLenum, GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLTEXSTORAGE2DMULTISAMPLEPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXSTORAGE3DMULTISAMPLEPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXTUREVIEWPROC = ?fn (GLuint, GLenum, GLuint, GLenum, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLBINDVERTEXBUFFERPROC = ?fn (GLuint, GLuint, GLintptr, GLsizei) callconv(.C) void;
pub const PFNGLVERTEXATTRIBFORMATPROC = ?fn (GLuint, GLint, GLenum, GLboolean, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBIFORMATPROC = ?fn (GLuint, GLint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBLFORMATPROC = ?fn (GLuint, GLint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBBINDINGPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXBINDINGDIVISORPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLDEBUGMESSAGECONTROLPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, [*c]const GLuint, GLboolean) callconv(.C) void;
pub const PFNGLDEBUGMESSAGEINSERTPROC = ?fn (GLenum, GLenum, GLuint, GLenum, GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLDEBUGMESSAGECALLBACKPROC = ?fn (GLDEBUGPROC, ?*const c_void) callconv(.C) void;
pub const PFNGLGETDEBUGMESSAGELOGPROC = ?fn (GLuint, GLsizei, [*c]GLenum, [*c]GLenum, [*c]GLuint, [*c]GLenum, [*c]GLsizei, [*c]GLchar) callconv(.C) GLuint;
pub const PFNGLPUSHDEBUGGROUPPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLPOPDEBUGGROUPPROC = ?fn () callconv(.C) void;
pub const PFNGLOBJECTLABELPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLGETOBJECTLABELPROC = ?fn (GLenum, GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLOBJECTPTRLABELPROC = ?fn (?*const c_void, GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLGETOBJECTPTRLABELPROC = ?fn (?*const c_void, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLBUFFERSTORAGEPROC = ?fn (GLenum, GLsizeiptr, ?*const c_void, GLbitfield) callconv(.C) void;
pub const PFNGLCLEARTEXIMAGEPROC = ?fn (GLuint, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCLEARTEXSUBIMAGEPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLBINDBUFFERSBASEPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLBINDBUFFERSRANGEPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLuint, [*c]const GLintptr, [*c]const GLsizeiptr) callconv(.C) void;
pub const PFNGLBINDTEXTURESPROC = ?fn (GLuint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLBINDSAMPLERSPROC = ?fn (GLuint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLBINDIMAGETEXTURESPROC = ?fn (GLuint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLBINDVERTEXBUFFERSPROC = ?fn (GLuint, GLsizei, [*c]const GLuint, [*c]const GLintptr, [*c]const GLsizei) callconv(.C) void;
pub const PFNGLCLIPCONTROLPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLCREATETRANSFORMFEEDBACKSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC = ?fn (GLuint, GLuint, GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLGETTRANSFORMFEEDBACKIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTRANSFORMFEEDBACKI_VPROC = ?fn (GLuint, GLenum, GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTRANSFORMFEEDBACKI64_VPROC = ?fn (GLuint, GLenum, GLuint, [*c]GLint64) callconv(.C) void;
pub const PFNGLCREATEBUFFERSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLNAMEDBUFFERSTORAGEPROC = ?fn (GLuint, GLsizeiptr, ?*const c_void, GLbitfield) callconv(.C) void;
pub const PFNGLNAMEDBUFFERDATAPROC = ?fn (GLuint, GLsizeiptr, ?*const c_void, GLenum) callconv(.C) void;
pub const PFNGLNAMEDBUFFERSUBDATAPROC = ?fn (GLuint, GLintptr, GLsizeiptr, ?*const c_void) callconv(.C) void;
pub const PFNGLCOPYNAMEDBUFFERSUBDATAPROC = ?fn (GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLCLEARNAMEDBUFFERDATAPROC = ?fn (GLuint, GLenum, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCLEARNAMEDBUFFERSUBDATAPROC = ?fn (GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLMAPNAMEDBUFFERPROC = ?fn (GLuint, GLenum) callconv(.C) ?*c_void;
pub const PFNGLMAPNAMEDBUFFERRANGEPROC = ?fn (GLuint, GLintptr, GLsizeiptr, GLbitfield) callconv(.C) ?*c_void;
pub const PFNGLUNMAPNAMEDBUFFERPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC = ?fn (GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLGETNAMEDBUFFERPARAMETERIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNAMEDBUFFERPARAMETERI64VPROC = ?fn (GLuint, GLenum, [*c]GLint64) callconv(.C) void;
pub const PFNGLGETNAMEDBUFFERPOINTERVPROC = ?fn (GLuint, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLGETNAMEDBUFFERSUBDATAPROC = ?fn (GLuint, GLintptr, GLsizeiptr, ?*c_void) callconv(.C) void;
pub const PFNGLCREATEFRAMEBUFFERSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC = ?fn (GLuint, GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERTEXTUREPROC = ?fn (GLuint, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC = ?fn (GLuint, GLenum, GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC = ?fn (GLuint, GLsizei, [*c]const GLenum) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC = ?fn (GLuint, GLsizei, [*c]const GLenum) callconv(.C) void;
pub const PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC = ?fn (GLuint, GLsizei, [*c]const GLenum, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLCLEARNAMEDFRAMEBUFFERIVPROC = ?fn (GLuint, GLenum, GLint, [*c]const GLint) callconv(.C) void;
pub const PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC = ?fn (GLuint, GLenum, GLint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLCLEARNAMEDFRAMEBUFFERFVPROC = ?fn (GLuint, GLenum, GLint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCLEARNAMEDFRAMEBUFFERFIPROC = ?fn (GLuint, GLenum, GLint, GLfloat, GLint) callconv(.C) void;
pub const PFNGLBLITNAMEDFRAMEBUFFERPROC = ?fn (GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) callconv(.C) void;
pub const PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC = ?fn (GLuint, GLenum) callconv(.C) GLenum;
pub const PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLCREATERENDERBUFFERSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLNAMEDRENDERBUFFERSTORAGEPROC = ?fn (GLuint, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLCREATETEXTURESPROC = ?fn (GLenum, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLTEXTUREBUFFERPROC = ?fn (GLuint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLTEXTUREBUFFERRANGEPROC = ?fn (GLuint, GLenum, GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE1DPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE2DPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE3DPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXTURESUBIMAGE1DPROC = ?fn (GLuint, GLint, GLint, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXTURESUBIMAGE2DPROC = ?fn (GLuint, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXTURESUBIMAGE3DPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC = ?fn (GLuint, GLint, GLint, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC = ?fn (GLuint, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOPYTEXTURESUBIMAGE1DPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLCOPYTEXTURESUBIMAGE2DPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLCOPYTEXTURESUBIMAGE3DPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERFPROC = ?fn (GLuint, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERFVPROC = ?fn (GLuint, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERIPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERIIVPROC = ?fn (GLuint, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERIUIVPROC = ?fn (GLuint, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERIVPROC = ?fn (GLuint, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLGENERATETEXTUREMIPMAPPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLBINDTEXTUREUNITPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLGETTEXTUREIMAGEPROC = ?fn (GLuint, GLint, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC = ?fn (GLuint, GLint, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETTEXTURELEVELPARAMETERFVPROC = ?fn (GLuint, GLint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETTEXTURELEVELPARAMETERIVPROC = ?fn (GLuint, GLint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTEXTUREPARAMETERFVPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETTEXTUREPARAMETERIIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTEXTUREPARAMETERIUIVPROC = ?fn (GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETTEXTUREPARAMETERIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLCREATEVERTEXARRAYSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDISABLEVERTEXARRAYATTRIBPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLENABLEVERTEXARRAYATTRIBPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYELEMENTBUFFERPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXBUFFERPROC = ?fn (GLuint, GLuint, GLuint, GLintptr, GLsizei) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXBUFFERSPROC = ?fn (GLuint, GLuint, GLsizei, [*c]const GLuint, [*c]const GLintptr, [*c]const GLsizei) callconv(.C) void;
pub const PFNGLVERTEXARRAYATTRIBBINDINGPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYATTRIBFORMATPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLboolean, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYATTRIBIFORMATPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYATTRIBLFORMATPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYBINDINGDIVISORPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLGETVERTEXARRAYIVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXARRAYINDEXEDIVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXARRAYINDEXED64IVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLint64) callconv(.C) void;
pub const PFNGLCREATESAMPLERSPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLCREATEPROGRAMPIPELINESPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLCREATEQUERIESPROC = ?fn (GLenum, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETQUERYBUFFEROBJECTI64VPROC = ?fn (GLuint, GLuint, GLenum, GLintptr) callconv(.C) void;
pub const PFNGLGETQUERYBUFFEROBJECTIVPROC = ?fn (GLuint, GLuint, GLenum, GLintptr) callconv(.C) void;
pub const PFNGLGETQUERYBUFFEROBJECTUI64VPROC = ?fn (GLuint, GLuint, GLenum, GLintptr) callconv(.C) void;
pub const PFNGLGETQUERYBUFFEROBJECTUIVPROC = ?fn (GLuint, GLuint, GLenum, GLintptr) callconv(.C) void;
pub const PFNGLMEMORYBARRIERBYREGIONPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLGETTEXTURESUBIMAGEPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETGRAPHICSRESETSTATUSPROC = ?fn () callconv(.C) GLenum;
pub const PFNGLGETNCOMPRESSEDTEXIMAGEPROC = ?fn (GLenum, GLint, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNTEXIMAGEPROC = ?fn (GLenum, GLint, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNUNIFORMDVPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETNUNIFORMFVPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETNUNIFORMIVPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNUNIFORMUIVPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLREADNPIXELSPROC = ?fn (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNMAPDVPROC = ?fn (GLenum, GLenum, GLsizei, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETNMAPFVPROC = ?fn (GLenum, GLenum, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETNMAPIVPROC = ?fn (GLenum, GLenum, GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNPIXELMAPFVPROC = ?fn (GLenum, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETNPIXELMAPUIVPROC = ?fn (GLenum, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETNPIXELMAPUSVPROC = ?fn (GLenum, GLsizei, [*c]GLushort) callconv(.C) void;
pub const PFNGLGETNPOLYGONSTIPPLEPROC = ?fn (GLsizei, [*c]GLubyte) callconv(.C) void;
pub const PFNGLGETNCOLORTABLEPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNCONVOLUTIONFILTERPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNSEPARABLEFILTERPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, ?*c_void, GLsizei, ?*c_void, ?*c_void) callconv(.C) void;
pub const PFNGLGETNHISTOGRAMPROC = ?fn (GLenum, GLboolean, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNMINMAXPROC = ?fn (GLenum, GLboolean, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLTEXTUREBARRIERPROC = ?fn () callconv(.C) void;
pub const PFNGLSPECIALIZESHADERPROC = ?fn (GLuint, [*c]const GLchar, GLuint, [*c]const GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC = ?fn (GLenum, ?*const c_void, GLintptr, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC = ?fn (GLenum, GLenum, ?*const c_void, GLintptr, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLPOLYGONOFFSETCLAMPPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPRIMITIVEBOUNDINGBOXARBPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const GLuint64EXT = khronos_uint64_t;
pub const PFNGLGETTEXTUREHANDLEARBPROC = ?fn (GLuint) callconv(.C) GLuint64;
pub const PFNGLGETTEXTURESAMPLERHANDLEARBPROC = ?fn (GLuint, GLuint) callconv(.C) GLuint64;
pub const PFNGLMAKETEXTUREHANDLERESIDENTARBPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLGETIMAGEHANDLEARBPROC = ?fn (GLuint, GLint, GLboolean, GLint, GLenum) callconv(.C) GLuint64;
pub const PFNGLMAKEIMAGEHANDLERESIDENTARBPROC = ?fn (GLuint64, GLenum) callconv(.C) void;
pub const PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLUNIFORMHANDLEUI64ARBPROC = ?fn (GLint, GLuint64) callconv(.C) void;
pub const PFNGLUNIFORMHANDLEUI64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC = ?fn (GLuint, GLint, GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLISTEXTUREHANDLERESIDENTARBPROC = ?fn (GLuint64) callconv(.C) GLboolean;
pub const PFNGLISIMAGEHANDLERESIDENTARBPROC = ?fn (GLuint64) callconv(.C) GLboolean;
pub const PFNGLVERTEXATTRIBL1UI64ARBPROC = ?fn (GLuint, GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1UI64VARBPROC = ?fn (GLuint, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBLUI64VARBPROC = ?fn (GLuint, GLenum, [*c]GLuint64EXT) callconv(.C) void;
pub const struct__cl_context = opaque {};
pub const struct__cl_event = opaque {};
pub const PFNGLCREATESYNCFROMCLEVENTARBPROC = ?fn (?*struct__cl_context, ?*struct__cl_event, GLbitfield) callconv(.C) GLsync;
pub const PFNGLCLAMPCOLORARBPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC = ?fn (GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const GLDEBUGPROCARB = ?fn (GLenum, GLenum, GLuint, GLenum, GLsizei, [*c]const GLchar, ?*const c_void) callconv(.C) void;
pub const PFNGLDEBUGMESSAGECONTROLARBPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, [*c]const GLuint, GLboolean) callconv(.C) void;
pub const PFNGLDEBUGMESSAGEINSERTARBPROC = ?fn (GLenum, GLenum, GLuint, GLenum, GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLDEBUGMESSAGECALLBACKARBPROC = ?fn (GLDEBUGPROCARB, ?*const c_void) callconv(.C) void;
pub const PFNGLGETDEBUGMESSAGELOGARBPROC = ?fn (GLuint, GLsizei, [*c]GLenum, [*c]GLenum, [*c]GLuint, [*c]GLenum, [*c]GLsizei, [*c]GLchar) callconv(.C) GLuint;
pub const PFNGLDRAWBUFFERSARBPROC = ?fn (GLsizei, [*c]const GLenum) callconv(.C) void;
pub const PFNGLBLENDEQUATIONIARBPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLBLENDEQUATIONSEPARATEIARBPROC = ?fn (GLuint, GLenum, GLenum) callconv(.C) void;
pub const PFNGLBLENDFUNCIARBPROC = ?fn (GLuint, GLenum, GLenum) callconv(.C) void;
pub const PFNGLBLENDFUNCSEPARATEIARBPROC = ?fn (GLuint, GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLDRAWARRAYSINSTANCEDARBPROC = ?fn (GLenum, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLDRAWELEMENTSINSTANCEDARBPROC = ?fn (GLenum, GLsizei, GLenum, ?*const c_void, GLsizei) callconv(.C) void;
pub const PFNGLPROGRAMSTRINGARBPROC = ?fn (GLenum, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLBINDPROGRAMARBPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETEPROGRAMSARBPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENPROGRAMSARBPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETER4DARBPROC = ?fn (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETER4DVARBPROC = ?fn (GLenum, GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETER4FARBPROC = ?fn (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETER4FVARBPROC = ?fn (GLenum, GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETER4DARBPROC = ?fn (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETER4DVARBPROC = ?fn (GLenum, GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETER4FARBPROC = ?fn (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETER4FVARBPROC = ?fn (GLenum, GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETPROGRAMENVPARAMETERDVARBPROC = ?fn (GLenum, GLuint, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETPROGRAMENVPARAMETERFVARBPROC = ?fn (GLenum, GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC = ?fn (GLenum, GLuint, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC = ?fn (GLenum, GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPROGRAMIVARBPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPROGRAMSTRINGARBPROC = ?fn (GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLISPROGRAMARBPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLPROGRAMPARAMETERIARBPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTUREARBPROC = ?fn (GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTURELAYERARBPROC = ?fn (GLenum, GLenum, GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTUREFACEARBPROC = ?fn (GLenum, GLenum, GLuint, GLint, GLenum) callconv(.C) void;
pub const PFNGLSPECIALIZESHADERARBPROC = ?fn (GLuint, [*c]const GLchar, GLuint, [*c]const GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLUNIFORM1I64ARBPROC = ?fn (GLint, GLint64) callconv(.C) void;
pub const PFNGLUNIFORM2I64ARBPROC = ?fn (GLint, GLint64, GLint64) callconv(.C) void;
pub const PFNGLUNIFORM3I64ARBPROC = ?fn (GLint, GLint64, GLint64, GLint64) callconv(.C) void;
pub const PFNGLUNIFORM4I64ARBPROC = ?fn (GLint, GLint64, GLint64, GLint64, GLint64) callconv(.C) void;
pub const PFNGLUNIFORM1I64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLint64) callconv(.C) void;
pub const PFNGLUNIFORM2I64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLint64) callconv(.C) void;
pub const PFNGLUNIFORM3I64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLint64) callconv(.C) void;
pub const PFNGLUNIFORM4I64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLint64) callconv(.C) void;
pub const PFNGLUNIFORM1UI64ARBPROC = ?fn (GLint, GLuint64) callconv(.C) void;
pub const PFNGLUNIFORM2UI64ARBPROC = ?fn (GLint, GLuint64, GLuint64) callconv(.C) void;
pub const PFNGLUNIFORM3UI64ARBPROC = ?fn (GLint, GLuint64, GLuint64, GLuint64) callconv(.C) void;
pub const PFNGLUNIFORM4UI64ARBPROC = ?fn (GLint, GLuint64, GLuint64, GLuint64, GLuint64) callconv(.C) void;
pub const PFNGLUNIFORM1UI64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLUNIFORM2UI64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLUNIFORM3UI64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLUNIFORM4UI64VARBPROC = ?fn (GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLGETUNIFORMI64VARBPROC = ?fn (GLuint, GLint, [*c]GLint64) callconv(.C) void;
pub const PFNGLGETUNIFORMUI64VARBPROC = ?fn (GLuint, GLint, [*c]GLuint64) callconv(.C) void;
pub const PFNGLGETNUNIFORMI64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLint64) callconv(.C) void;
pub const PFNGLGETNUNIFORMUI64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1I64ARBPROC = ?fn (GLuint, GLint, GLint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2I64ARBPROC = ?fn (GLuint, GLint, GLint64, GLint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3I64ARBPROC = ?fn (GLuint, GLint, GLint64, GLint64, GLint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4I64ARBPROC = ?fn (GLuint, GLint, GLint64, GLint64, GLint64, GLint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1I64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2I64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3I64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4I64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1UI64ARBPROC = ?fn (GLuint, GLint, GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2UI64ARBPROC = ?fn (GLuint, GLint, GLuint64, GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3UI64ARBPROC = ?fn (GLuint, GLint, GLuint64, GLuint64, GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4UI64ARBPROC = ?fn (GLuint, GLint, GLuint64, GLuint64, GLuint64, GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1UI64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2UI64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3UI64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4UI64VARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const GLhalfARB = khronos_uint16_t;
pub const PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC = ?fn (GLenum, ?*const c_void, GLintptr, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC = ?fn (GLenum, GLenum, ?*const c_void, GLintptr, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLVERTEXATTRIBDIVISORARBPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLCURRENTPALETTEMATRIXARBPROC = ?fn (GLint) callconv(.C) void;
pub const PFNGLMATRIXINDEXUBVARBPROC = ?fn (GLint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLMATRIXINDEXUSVARBPROC = ?fn (GLint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLMATRIXINDEXUIVARBPROC = ?fn (GLint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLMATRIXINDEXPOINTERARBPROC = ?fn (GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLSAMPLECOVERAGEARBPROC = ?fn (GLfloat, GLboolean) callconv(.C) void;
pub const PFNGLGENQUERIESARBPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETEQUERIESARBPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISQUERYARBPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBEGINQUERYARBPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLENDQUERYARBPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLGETQUERYIVARBPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETQUERYOBJECTIVARBPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETQUERYOBJECTUIVARBPROC = ?fn (GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLMAXSHADERCOMPILERTHREADSARBPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLPOINTPARAMETERFARBPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLPOINTPARAMETERFVARBPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETGRAPHICSRESETSTATUSARBPROC = ?fn () callconv(.C) GLenum;
pub const PFNGLGETNTEXIMAGEARBPROC = ?fn (GLenum, GLint, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLREADNPIXELSARBPROC = ?fn (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC = ?fn (GLenum, GLint, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNUNIFORMFVARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETNUNIFORMIVARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNUNIFORMUIVARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETNUNIFORMDVARBPROC = ?fn (GLuint, GLint, GLsizei, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETNMAPDVARBPROC = ?fn (GLenum, GLenum, GLsizei, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETNMAPFVARBPROC = ?fn (GLenum, GLenum, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETNMAPIVARBPROC = ?fn (GLenum, GLenum, GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNPIXELMAPFVARBPROC = ?fn (GLenum, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETNPIXELMAPUIVARBPROC = ?fn (GLenum, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETNPIXELMAPUSVARBPROC = ?fn (GLenum, GLsizei, [*c]GLushort) callconv(.C) void;
pub const PFNGLGETNPOLYGONSTIPPLEARBPROC = ?fn (GLsizei, [*c]GLubyte) callconv(.C) void;
pub const PFNGLGETNCOLORTABLEARBPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNCONVOLUTIONFILTERARBPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNSEPARABLEFILTERARBPROC = ?fn (GLenum, GLenum, GLenum, GLsizei, ?*c_void, GLsizei, ?*c_void, ?*c_void) callconv(.C) void;
pub const PFNGLGETNHISTOGRAMARBPROC = ?fn (GLenum, GLboolean, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLGETNMINMAXARBPROC = ?fn (GLenum, GLboolean, GLenum, GLenum, GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC = ?fn (GLuint, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLEVALUATEDEPTHVALUESARBPROC = ?fn () callconv(.C) void;
pub const PFNGLMINSAMPLESHADINGARBPROC = ?fn (GLfloat) callconv(.C) void;
pub const GLhandleARB = c_uint;
pub const GLcharARB = u8;
pub const PFNGLDELETEOBJECTARBPROC = ?fn (GLhandleARB) callconv(.C) void;
pub const PFNGLGETHANDLEARBPROC = ?fn (GLenum) callconv(.C) GLhandleARB;
pub const PFNGLDETACHOBJECTARBPROC = ?fn (GLhandleARB, GLhandleARB) callconv(.C) void;
pub const PFNGLCREATESHADEROBJECTARBPROC = ?fn (GLenum) callconv(.C) GLhandleARB;
pub const PFNGLSHADERSOURCEARBPROC = ?fn (GLhandleARB, GLsizei, [*c][*c]const GLcharARB, [*c]const GLint) callconv(.C) void;
pub const PFNGLCOMPILESHADERARBPROC = ?fn (GLhandleARB) callconv(.C) void;
pub const PFNGLCREATEPROGRAMOBJECTARBPROC = ?fn () callconv(.C) GLhandleARB;
pub const PFNGLATTACHOBJECTARBPROC = ?fn (GLhandleARB, GLhandleARB) callconv(.C) void;
pub const PFNGLLINKPROGRAMARBPROC = ?fn (GLhandleARB) callconv(.C) void;
pub const PFNGLUSEPROGRAMOBJECTARBPROC = ?fn (GLhandleARB) callconv(.C) void;
pub const PFNGLVALIDATEPROGRAMARBPROC = ?fn (GLhandleARB) callconv(.C) void;
pub const PFNGLUNIFORM1FARBPROC = ?fn (GLint, GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM2FARBPROC = ?fn (GLint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM3FARBPROC = ?fn (GLint, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM4FARBPROC = ?fn (GLint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM1IARBPROC = ?fn (GLint, GLint) callconv(.C) void;
pub const PFNGLUNIFORM2IARBPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLUNIFORM3IARBPROC = ?fn (GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLUNIFORM4IARBPROC = ?fn (GLint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLUNIFORM1FVARBPROC = ?fn (GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM2FVARBPROC = ?fn (GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM3FVARBPROC = ?fn (GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM4FVARBPROC = ?fn (GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORM1IVARBPROC = ?fn (GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORM2IVARBPROC = ?fn (GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORM3IVARBPROC = ?fn (GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORM4IVARBPROC = ?fn (GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX2FVARBPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX3FVARBPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLUNIFORMMATRIX4FVARBPROC = ?fn (GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETOBJECTPARAMETERFVARBPROC = ?fn (GLhandleARB, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETOBJECTPARAMETERIVARBPROC = ?fn (GLhandleARB, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETINFOLOGARBPROC = ?fn (GLhandleARB, GLsizei, [*c]GLsizei, [*c]GLcharARB) callconv(.C) void;
pub const PFNGLGETATTACHEDOBJECTSARBPROC = ?fn (GLhandleARB, GLsizei, [*c]GLsizei, [*c]GLhandleARB) callconv(.C) void;
pub const PFNGLGETUNIFORMLOCATIONARBPROC = ?fn (GLhandleARB, [*c]const GLcharARB) callconv(.C) GLint;
pub const PFNGLGETACTIVEUNIFORMARBPROC = ?fn (GLhandleARB, GLuint, GLsizei, [*c]GLsizei, [*c]GLint, [*c]GLenum, [*c]GLcharARB) callconv(.C) void;
pub const PFNGLGETUNIFORMFVARBPROC = ?fn (GLhandleARB, GLint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETUNIFORMIVARBPROC = ?fn (GLhandleARB, GLint, [*c]GLint) callconv(.C) void;
pub const PFNGLGETSHADERSOURCEARBPROC = ?fn (GLhandleARB, GLsizei, [*c]GLsizei, [*c]GLcharARB) callconv(.C) void;
pub const PFNGLNAMEDSTRINGARBPROC = ?fn (GLenum, GLint, [*c]const GLchar, GLint, [*c]const GLchar) callconv(.C) void;
pub const PFNGLDELETENAMEDSTRINGARBPROC = ?fn (GLint, [*c]const GLchar) callconv(.C) void;
pub const PFNGLCOMPILESHADERINCLUDEARBPROC = ?fn (GLuint, GLsizei, [*c]const [*c]const GLchar, [*c]const GLint) callconv(.C) void;
pub const PFNGLISNAMEDSTRINGARBPROC = ?fn (GLint, [*c]const GLchar) callconv(.C) GLboolean;
pub const PFNGLGETNAMEDSTRINGARBPROC = ?fn (GLint, [*c]const GLchar, GLsizei, [*c]GLint, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETNAMEDSTRINGIVARBPROC = ?fn (GLint, [*c]const GLchar, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLBUFFERPAGECOMMITMENTARBPROC = ?fn (GLenum, GLintptr, GLsizeiptr, GLboolean) callconv(.C) void;
pub const PFNGLNAMEDBUFFERPAGECOMMITMENTEXTPROC = ?fn (GLuint, GLintptr, GLsizeiptr, GLboolean) callconv(.C) void;
pub const PFNGLNAMEDBUFFERPAGECOMMITMENTARBPROC = ?fn (GLuint, GLintptr, GLsizeiptr, GLboolean) callconv(.C) void;
pub const PFNGLTEXPAGECOMMITMENTARBPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXBUFFERARBPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXIMAGE3DARBPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXIMAGE2DARBPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXIMAGE1DARBPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC = ?fn (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC = ?fn (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGETCOMPRESSEDTEXIMAGEARBPROC = ?fn (GLenum, GLint, ?*c_void) callconv(.C) void;
pub const PFNGLLOADTRANSPOSEMATRIXFARBPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLLOADTRANSPOSEMATRIXDARBPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLMULTTRANSPOSEMATRIXFARBPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTTRANSPOSEMATRIXDARBPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLWEIGHTBVARBPROC = ?fn (GLint, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLWEIGHTSVARBPROC = ?fn (GLint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLWEIGHTIVARBPROC = ?fn (GLint, [*c]const GLint) callconv(.C) void;
pub const PFNGLWEIGHTFVARBPROC = ?fn (GLint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLWEIGHTDVARBPROC = ?fn (GLint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLWEIGHTUBVARBPROC = ?fn (GLint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLWEIGHTUSVARBPROC = ?fn (GLint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLWEIGHTUIVARBPROC = ?fn (GLint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLWEIGHTPOINTERARBPROC = ?fn (GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLVERTEXBLENDARBPROC = ?fn (GLint) callconv(.C) void;
pub const GLsizeiptrARB = khronos_ssize_t;
pub const GLintptrARB = khronos_intptr_t;
pub const PFNGLBINDBUFFERARBPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETEBUFFERSARBPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENBUFFERSARBPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISBUFFERARBPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBUFFERDATAARBPROC = ?fn (GLenum, GLsizeiptrARB, ?*const c_void, GLenum) callconv(.C) void;
pub const PFNGLBUFFERSUBDATAARBPROC = ?fn (GLenum, GLintptrARB, GLsizeiptrARB, ?*const c_void) callconv(.C) void;
pub const PFNGLGETBUFFERSUBDATAARBPROC = ?fn (GLenum, GLintptrARB, GLsizeiptrARB, ?*c_void) callconv(.C) void;
pub const PFNGLMAPBUFFERARBPROC = ?fn (GLenum, GLenum) callconv(.C) ?*c_void;
pub const PFNGLUNMAPBUFFERARBPROC = ?fn (GLenum) callconv(.C) GLboolean;
pub const PFNGLGETBUFFERPARAMETERIVARBPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETBUFFERPOINTERVARBPROC = ?fn (GLenum, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1DARBPROC = ?fn (GLuint, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1DVARBPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1FARBPROC = ?fn (GLuint, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1FVARBPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1SARBPROC = ?fn (GLuint, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1SVARBPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2DARBPROC = ?fn (GLuint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2DVARBPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2FARBPROC = ?fn (GLuint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2FVARBPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2SARBPROC = ?fn (GLuint, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2SVARBPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3DARBPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3DVARBPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3FARBPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3FVARBPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3SARBPROC = ?fn (GLuint, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3SVARBPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NBVARBPROC = ?fn (GLuint, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NIVARBPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NSVARBPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NUBARBPROC = ?fn (GLuint, GLubyte, GLubyte, GLubyte, GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NUBVARBPROC = ?fn (GLuint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NUIVARBPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4NUSVARBPROC = ?fn (GLuint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4BVARBPROC = ?fn (GLuint, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4DARBPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4DVARBPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4FARBPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4FVARBPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4IVARBPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4SARBPROC = ?fn (GLuint, GLshort, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4SVARBPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4UBVARBPROC = ?fn (GLuint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4UIVARBPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4USVARBPROC = ?fn (GLuint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBPOINTERARBPROC = ?fn (GLuint, GLint, GLenum, GLboolean, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLENABLEVERTEXATTRIBARRAYARBPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDISABLEVERTEXATTRIBARRAYARBPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBDVARBPROC = ?fn (GLuint, GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBFVARBPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBIVARBPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBPOINTERVARBPROC = ?fn (GLuint, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLBINDATTRIBLOCATIONARBPROC = ?fn (GLhandleARB, GLuint, [*c]const GLcharARB) callconv(.C) void;
pub const PFNGLGETACTIVEATTRIBARBPROC = ?fn (GLhandleARB, GLuint, GLsizei, [*c]GLsizei, [*c]GLint, [*c]GLenum, [*c]GLcharARB) callconv(.C) void;
pub const PFNGLGETATTRIBLOCATIONARBPROC = ?fn (GLhandleARB, [*c]const GLcharARB) callconv(.C) GLint;
pub const PFNGLWINDOWPOS2DARBPROC = ?fn (GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS2DVARBPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS2FARBPROC = ?fn (GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS2FVARBPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS2IARBPROC = ?fn (GLint, GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS2IVARBPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS2SARBPROC = ?fn (GLshort, GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS2SVARBPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS3DARBPROC = ?fn (GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS3DVARBPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS3FARBPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS3FVARBPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS3IARBPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS3IVARBPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS3SARBPROC = ?fn (GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS3SVARBPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLBLENDBARRIERKHRPROC = ?fn () callconv(.C) void;
pub const PFNGLMAXSHADERCOMPILERTHREADSKHRPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1BOESPROC = ?fn (GLenum, GLbyte) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1BVOESPROC = ?fn (GLenum, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2BOESPROC = ?fn (GLenum, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2BVOESPROC = ?fn (GLenum, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3BOESPROC = ?fn (GLenum, GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3BVOESPROC = ?fn (GLenum, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4BOESPROC = ?fn (GLenum, GLbyte, GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4BVOESPROC = ?fn (GLenum, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLTEXCOORD1BOESPROC = ?fn (GLbyte) callconv(.C) void;
pub const PFNGLTEXCOORD1BVOESPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLTEXCOORD2BOESPROC = ?fn (GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLTEXCOORD2BVOESPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLTEXCOORD3BOESPROC = ?fn (GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLTEXCOORD3BVOESPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLTEXCOORD4BOESPROC = ?fn (GLbyte, GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLTEXCOORD4BVOESPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEX2BOESPROC = ?fn (GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLVERTEX2BVOESPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEX3BOESPROC = ?fn (GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLVERTEX3BVOESPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEX4BOESPROC = ?fn (GLbyte, GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLVERTEX4BVOESPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const GLfixed = khronos_int32_t;
pub const PFNGLALPHAFUNCXOESPROC = ?fn (GLenum, GLfixed) callconv(.C) void;
pub const PFNGLCLEARCOLORXOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLCLEARDEPTHXOESPROC = ?fn (GLfixed) callconv(.C) void;
pub const PFNGLCLIPPLANEXOESPROC = ?fn (GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLCOLOR4XOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLDEPTHRANGEXOESPROC = ?fn (GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLFOGXOESPROC = ?fn (GLenum, GLfixed) callconv(.C) void;
pub const PFNGLFOGXVOESPROC = ?fn (GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLFRUSTUMXOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLGETCLIPPLANEXOESPROC = ?fn (GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETFIXEDVOESPROC = ?fn (GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETTEXENVXVOESPROC = ?fn (GLenum, GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETTEXPARAMETERXVOESPROC = ?fn (GLenum, GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLLIGHTMODELXOESPROC = ?fn (GLenum, GLfixed) callconv(.C) void;
pub const PFNGLLIGHTMODELXVOESPROC = ?fn (GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLLIGHTXOESPROC = ?fn (GLenum, GLenum, GLfixed) callconv(.C) void;
pub const PFNGLLIGHTXVOESPROC = ?fn (GLenum, GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLLINEWIDTHXOESPROC = ?fn (GLfixed) callconv(.C) void;
pub const PFNGLLOADMATRIXXOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLMATERIALXOESPROC = ?fn (GLenum, GLenum, GLfixed) callconv(.C) void;
pub const PFNGLMATERIALXVOESPROC = ?fn (GLenum, GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLMULTMATRIXXOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4XOESPROC = ?fn (GLenum, GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLNORMAL3XOESPROC = ?fn (GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLORTHOXOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLPOINTPARAMETERXVOESPROC = ?fn (GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLPOINTSIZEXOESPROC = ?fn (GLfixed) callconv(.C) void;
pub const PFNGLPOLYGONOFFSETXOESPROC = ?fn (GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLROTATEXOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLSCALEXOESPROC = ?fn (GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLTEXENVXOESPROC = ?fn (GLenum, GLenum, GLfixed) callconv(.C) void;
pub const PFNGLTEXENVXVOESPROC = ?fn (GLenum, GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLTEXPARAMETERXOESPROC = ?fn (GLenum, GLenum, GLfixed) callconv(.C) void;
pub const PFNGLTEXPARAMETERXVOESPROC = ?fn (GLenum, GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLTRANSLATEXOESPROC = ?fn (GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLACCUMXOESPROC = ?fn (GLenum, GLfixed) callconv(.C) void;
pub const PFNGLBITMAPXOESPROC = ?fn (GLsizei, GLsizei, GLfixed, GLfixed, GLfixed, GLfixed, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLBLENDCOLORXOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLCLEARACCUMXOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLCOLOR3XOESPROC = ?fn (GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLCOLOR3XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLCOLOR4XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLCONVOLUTIONPARAMETERXOESPROC = ?fn (GLenum, GLenum, GLfixed) callconv(.C) void;
pub const PFNGLCONVOLUTIONPARAMETERXVOESPROC = ?fn (GLenum, GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLEVALCOORD1XOESPROC = ?fn (GLfixed) callconv(.C) void;
pub const PFNGLEVALCOORD1XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLEVALCOORD2XOESPROC = ?fn (GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLEVALCOORD2XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLFEEDBACKBUFFERXOESPROC = ?fn (GLsizei, GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLGETCONVOLUTIONPARAMETERXVOESPROC = ?fn (GLenum, GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETHISTOGRAMPARAMETERXVOESPROC = ?fn (GLenum, GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETLIGHTXOESPROC = ?fn (GLenum, GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETMAPXVOESPROC = ?fn (GLenum, GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETMATERIALXOESPROC = ?fn (GLenum, GLenum, GLfixed) callconv(.C) void;
pub const PFNGLGETPIXELMAPXVPROC = ?fn (GLenum, GLint, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETTEXGENXVOESPROC = ?fn (GLenum, GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLGETTEXLEVELPARAMETERXVOESPROC = ?fn (GLenum, GLint, GLenum, [*c]GLfixed) callconv(.C) void;
pub const PFNGLINDEXXOESPROC = ?fn (GLfixed) callconv(.C) void;
pub const PFNGLINDEXXVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLLOADTRANSPOSEMATRIXXOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLMAP1XOESPROC = ?fn (GLenum, GLfixed, GLfixed, GLint, GLint, GLfixed) callconv(.C) void;
pub const PFNGLMAP2XOESPROC = ?fn (GLenum, GLfixed, GLfixed, GLint, GLint, GLfixed, GLfixed, GLint, GLint, GLfixed) callconv(.C) void;
pub const PFNGLMAPGRID1XOESPROC = ?fn (GLint, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLMAPGRID2XOESPROC = ?fn (GLint, GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLMULTTRANSPOSEMATRIXXOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1XOESPROC = ?fn (GLenum, GLfixed) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1XVOESPROC = ?fn (GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2XOESPROC = ?fn (GLenum, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2XVOESPROC = ?fn (GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3XOESPROC = ?fn (GLenum, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3XVOESPROC = ?fn (GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4XVOESPROC = ?fn (GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLNORMAL3XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLPASSTHROUGHXOESPROC = ?fn (GLfixed) callconv(.C) void;
pub const PFNGLPIXELMAPXPROC = ?fn (GLenum, GLint, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLPIXELSTOREXPROC = ?fn (GLenum, GLfixed) callconv(.C) void;
pub const PFNGLPIXELTRANSFERXOESPROC = ?fn (GLenum, GLfixed) callconv(.C) void;
pub const PFNGLPIXELZOOMXOESPROC = ?fn (GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLPRIORITIZETEXTURESXOESPROC = ?fn (GLsizei, [*c]const GLuint, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLRASTERPOS2XOESPROC = ?fn (GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLRASTERPOS2XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLRASTERPOS3XOESPROC = ?fn (GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLRASTERPOS3XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLRASTERPOS4XOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLRASTERPOS4XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLRECTXOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLRECTXVOESPROC = ?fn ([*c]const GLfixed, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLTEXCOORD1XOESPROC = ?fn (GLfixed) callconv(.C) void;
pub const PFNGLTEXCOORD1XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLTEXCOORD2XOESPROC = ?fn (GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLTEXCOORD2XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLTEXCOORD3XOESPROC = ?fn (GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLTEXCOORD3XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLTEXCOORD4XOESPROC = ?fn (GLfixed, GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLTEXCOORD4XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLTEXGENXOESPROC = ?fn (GLenum, GLenum, GLfixed) callconv(.C) void;
pub const PFNGLTEXGENXVOESPROC = ?fn (GLenum, GLenum, [*c]const GLfixed) callconv(.C) void;
pub const PFNGLVERTEX2XOESPROC = ?fn (GLfixed) callconv(.C) void;
pub const PFNGLVERTEX2XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLVERTEX3XOESPROC = ?fn (GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLVERTEX3XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLVERTEX4XOESPROC = ?fn (GLfixed, GLfixed, GLfixed) callconv(.C) void;
pub const PFNGLVERTEX4XVOESPROC = ?fn ([*c]const GLfixed) callconv(.C) void;
pub const PFNGLQUERYMATRIXXOESPROC = ?fn ([*c]GLfixed, [*c]GLint) callconv(.C) GLbitfield;
pub const PFNGLCLEARDEPTHFOESPROC = ?fn (GLclampf) callconv(.C) void;
pub const PFNGLCLIPPLANEFOESPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLDEPTHRANGEFOESPROC = ?fn (GLclampf, GLclampf) callconv(.C) void;
pub const PFNGLFRUSTUMFOESPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLGETCLIPPLANEFOESPROC = ?fn (GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLORTHOFOESPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTBUFFERMASK3DFXPROC = ?fn (GLuint) callconv(.C) void;
pub const GLDEBUGPROCAMD = ?fn (GLuint, GLenum, GLenum, GLsizei, [*c]const GLchar, ?*c_void) callconv(.C) void;
pub const PFNGLDEBUGMESSAGEENABLEAMDPROC = ?fn (GLenum, GLenum, GLsizei, [*c]const GLuint, GLboolean) callconv(.C) void;
pub const PFNGLDEBUGMESSAGEINSERTAMDPROC = ?fn (GLenum, GLenum, GLuint, GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLDEBUGMESSAGECALLBACKAMDPROC = ?fn (GLDEBUGPROCAMD, ?*c_void) callconv(.C) void;
pub const PFNGLGETDEBUGMESSAGELOGAMDPROC = ?fn (GLuint, GLsizei, [*c]GLenum, [*c]GLuint, [*c]GLuint, [*c]GLsizei, [*c]GLchar) callconv(.C) GLuint;
pub const PFNGLBLENDFUNCINDEXEDAMDPROC = ?fn (GLuint, GLenum, GLenum) callconv(.C) void;
pub const PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC = ?fn (GLuint, GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLBLENDEQUATIONINDEXEDAMDPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC = ?fn (GLuint, GLenum, GLenum) callconv(.C) void;
pub const PFNGLRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC = ?fn (GLenum, GLsizei, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC = ?fn (GLuint, GLsizei, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC = ?fn (GLenum, GLuint, GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC = ?fn (GLuint, GLuint, GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC = ?fn (GLenum, GLenum, GLuint, GLuint, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC = ?fn (GLuint, GLenum, GLuint, GLuint, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const GLint64EXT = khronos_int64_t;
pub const PFNGLUNIFORM1I64NVPROC = ?fn (GLint, GLint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM2I64NVPROC = ?fn (GLint, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM3I64NVPROC = ?fn (GLint, GLint64EXT, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM4I64NVPROC = ?fn (GLint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM1I64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM2I64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM3I64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM4I64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM1UI64NVPROC = ?fn (GLint, GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM2UI64NVPROC = ?fn (GLint, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM3UI64NVPROC = ?fn (GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM4UI64NVPROC = ?fn (GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM1UI64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM2UI64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM3UI64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORM4UI64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLGETUNIFORMI64VNVPROC = ?fn (GLuint, GLint, [*c]GLint64EXT) callconv(.C) void;
pub const PFNGLGETUNIFORMUI64VNVPROC = ?fn (GLuint, GLint, [*c]GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1I64NVPROC = ?fn (GLuint, GLint, GLint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2I64NVPROC = ?fn (GLuint, GLint, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3I64NVPROC = ?fn (GLuint, GLint, GLint64EXT, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4I64NVPROC = ?fn (GLuint, GLint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1I64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2I64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3I64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4I64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1UI64NVPROC = ?fn (GLuint, GLint, GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2UI64NVPROC = ?fn (GLuint, GLint, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3UI64NVPROC = ?fn (GLuint, GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4UI64NVPROC = ?fn (GLuint, GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1UI64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2UI64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3UI64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4UI64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBPARAMETERIAMDPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC = ?fn (GLenum, ?*const c_void, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC = ?fn (GLenum, GLenum, ?*const c_void, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGENNAMESAMDPROC = ?fn (GLenum, GLuint, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETENAMESAMDPROC = ?fn (GLenum, GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISNAMEAMDPROC = ?fn (GLenum, GLuint) callconv(.C) GLboolean;
pub const PFNGLQUERYOBJECTPARAMETERUIAMDPROC = ?fn (GLenum, GLuint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLGETPERFMONITORGROUPSAMDPROC = ?fn ([*c]GLint, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETPERFMONITORCOUNTERSAMDPROC = ?fn (GLuint, [*c]GLint, [*c]GLint, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETPERFMONITORGROUPSTRINGAMDPROC = ?fn (GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC = ?fn (GLuint, GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETPERFMONITORCOUNTERINFOAMDPROC = ?fn (GLuint, GLuint, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLGENPERFMONITORSAMDPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETEPERFMONITORSAMDPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLSELECTPERFMONITORCOUNTERSAMDPROC = ?fn (GLuint, GLboolean, GLuint, GLint, [*c]GLuint) callconv(.C) void;
pub const PFNGLBEGINPERFMONITORAMDPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLENDPERFMONITORAMDPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLGETPERFMONITORCOUNTERDATAAMDPROC = ?fn (GLuint, GLenum, GLsizei, [*c]GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLSETMULTISAMPLEFVAMDPROC = ?fn (GLenum, GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXSTORAGESPARSEAMDPROC = ?fn (GLenum, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLbitfield) callconv(.C) void;
pub const PFNGLTEXTURESTORAGESPARSEAMDPROC = ?fn (GLuint, GLenum, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLbitfield) callconv(.C) void;
pub const PFNGLSTENCILOPVALUEAMDPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLTESSELLATIONFACTORAMDPROC = ?fn (GLfloat) callconv(.C) void;
pub const PFNGLTESSELLATIONMODEAMDPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLELEMENTPOINTERAPPLEPROC = ?fn (GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLDRAWELEMENTARRAYAPPLEPROC = ?fn (GLenum, GLint, GLsizei) callconv(.C) void;
pub const PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC = ?fn (GLenum, GLuint, GLuint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC = ?fn (GLenum, [*c]const GLint, [*c]const GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC = ?fn (GLenum, GLuint, GLuint, [*c]const GLint, [*c]const GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGENFENCESAPPLEPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETEFENCESAPPLEPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLSETFENCEAPPLEPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLISFENCEAPPLEPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLTESTFENCEAPPLEPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLFINISHFENCEAPPLEPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLTESTOBJECTAPPLEPROC = ?fn (GLenum, GLuint) callconv(.C) GLboolean;
pub const PFNGLFINISHOBJECTAPPLEPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLBUFFERPARAMETERIAPPLEPROC = ?fn (GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC = ?fn (GLenum, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLOBJECTPURGEABLEAPPLEPROC = ?fn (GLenum, GLuint, GLenum) callconv(.C) GLenum;
pub const PFNGLOBJECTUNPURGEABLEAPPLEPROC = ?fn (GLenum, GLuint, GLenum) callconv(.C) GLenum;
pub const PFNGLGETOBJECTPARAMETERIVAPPLEPROC = ?fn (GLenum, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLTEXTURERANGEAPPLEPROC = ?fn (GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC = ?fn (GLenum, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLBINDVERTEXARRAYAPPLEPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDELETEVERTEXARRAYSAPPLEPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENVERTEXARRAYSAPPLEPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISVERTEXARRAYAPPLEPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLVERTEXARRAYRANGEAPPLEPROC = ?fn (GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC = ?fn (GLsizei, ?*c_void) callconv(.C) void;
pub const PFNGLVERTEXARRAYPARAMETERIAPPLEPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLENABLEVERTEXATTRIBAPPLEPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLDISABLEVERTEXATTRIBAPPLEPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLISVERTEXATTRIBENABLEDAPPLEPROC = ?fn (GLuint, GLenum) callconv(.C) GLboolean;
pub const PFNGLMAPVERTEXATTRIB1DAPPLEPROC = ?fn (GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMAPVERTEXATTRIB1FAPPLEPROC = ?fn (GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMAPVERTEXATTRIB2DAPPLEPROC = ?fn (GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMAPVERTEXATTRIB2FAPPLEPROC = ?fn (GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLDRAWBUFFERSATIPROC = ?fn (GLsizei, [*c]const GLenum) callconv(.C) void;
pub const PFNGLELEMENTPOINTERATIPROC = ?fn (GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLDRAWELEMENTARRAYATIPROC = ?fn (GLenum, GLsizei) callconv(.C) void;
pub const PFNGLDRAWRANGEELEMENTARRAYATIPROC = ?fn (GLenum, GLuint, GLuint, GLsizei) callconv(.C) void;
pub const PFNGLTEXBUMPPARAMETERIVATIPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLTEXBUMPPARAMETERFVATIPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETTEXBUMPPARAMETERIVATIPROC = ?fn (GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTEXBUMPPARAMETERFVATIPROC = ?fn (GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGENFRAGMENTSHADERSATIPROC = ?fn (GLuint) callconv(.C) GLuint;
pub const PFNGLBINDFRAGMENTSHADERATIPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDELETEFRAGMENTSHADERATIPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLBEGINFRAGMENTSHADERATIPROC = ?fn () callconv(.C) void;
pub const PFNGLENDFRAGMENTSHADERATIPROC = ?fn () callconv(.C) void;
pub const PFNGLPASSTEXCOORDATIPROC = ?fn (GLuint, GLuint, GLenum) callconv(.C) void;
pub const PFNGLSAMPLEMAPATIPROC = ?fn (GLuint, GLuint, GLenum) callconv(.C) void;
pub const PFNGLCOLORFRAGMENTOP1ATIPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLCOLORFRAGMENTOP2ATIPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLCOLORFRAGMENTOP3ATIPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLALPHAFRAGMENTOP1ATIPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLALPHAFRAGMENTOP2ATIPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLALPHAFRAGMENTOP3ATIPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLSETFRAGMENTSHADERCONSTANTATIPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMAPOBJECTBUFFERATIPROC = ?fn (GLuint) callconv(.C) ?*c_void;
pub const PFNGLUNMAPOBJECTBUFFERATIPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLPNTRIANGLESIATIPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLPNTRIANGLESFATIPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLSTENCILOPSEPARATEATIPROC = ?fn (GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLSTENCILFUNCSEPARATEATIPROC = ?fn (GLenum, GLenum, GLint, GLuint) callconv(.C) void;
pub const PFNGLNEWOBJECTBUFFERATIPROC = ?fn (GLsizei, ?*const c_void, GLenum) callconv(.C) GLuint;
pub const PFNGLISOBJECTBUFFERATIPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLUPDATEOBJECTBUFFERATIPROC = ?fn (GLuint, GLuint, GLsizei, ?*const c_void, GLenum) callconv(.C) void;
pub const PFNGLGETOBJECTBUFFERFVATIPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETOBJECTBUFFERIVATIPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLFREEOBJECTBUFFERATIPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLARRAYOBJECTATIPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLuint, GLuint) callconv(.C) void;
pub const PFNGLGETARRAYOBJECTFVATIPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETARRAYOBJECTIVATIPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLVARIANTARRAYOBJECTATIPROC = ?fn (GLuint, GLenum, GLsizei, GLuint, GLuint) callconv(.C) void;
pub const PFNGLGETVARIANTARRAYOBJECTFVATIPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETVARIANTARRAYOBJECTIVATIPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBARRAYOBJECTATIPROC = ?fn (GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM1SATIPROC = ?fn (GLenum, GLshort) callconv(.C) void;
pub const PFNGLVERTEXSTREAM1SVATIPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXSTREAM1IATIPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM1IVATIPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM1FATIPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXSTREAM1FVATIPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXSTREAM1DATIPROC = ?fn (GLenum, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXSTREAM1DVATIPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXSTREAM2SATIPROC = ?fn (GLenum, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXSTREAM2SVATIPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXSTREAM2IATIPROC = ?fn (GLenum, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM2IVATIPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM2FATIPROC = ?fn (GLenum, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXSTREAM2FVATIPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXSTREAM2DATIPROC = ?fn (GLenum, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXSTREAM2DVATIPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXSTREAM3SATIPROC = ?fn (GLenum, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXSTREAM3SVATIPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXSTREAM3IATIPROC = ?fn (GLenum, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM3IVATIPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM3FATIPROC = ?fn (GLenum, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXSTREAM3FVATIPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXSTREAM3DATIPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXSTREAM3DVATIPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXSTREAM4SATIPROC = ?fn (GLenum, GLshort, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXSTREAM4SVATIPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXSTREAM4IATIPROC = ?fn (GLenum, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM4IVATIPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXSTREAM4FATIPROC = ?fn (GLenum, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXSTREAM4FVATIPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXSTREAM4DATIPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXSTREAM4DVATIPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLNORMALSTREAM3BATIPROC = ?fn (GLenum, GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLNORMALSTREAM3BVATIPROC = ?fn (GLenum, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLNORMALSTREAM3SATIPROC = ?fn (GLenum, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLNORMALSTREAM3SVATIPROC = ?fn (GLenum, [*c]const GLshort) callconv(.C) void;
pub const PFNGLNORMALSTREAM3IATIPROC = ?fn (GLenum, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLNORMALSTREAM3IVATIPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLNORMALSTREAM3FATIPROC = ?fn (GLenum, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLNORMALSTREAM3FVATIPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLNORMALSTREAM3DATIPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLNORMALSTREAM3DVATIPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLVERTEXBLENDENVIATIPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLVERTEXBLENDENVFATIPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const GLeglImageOES = ?*c_void;
pub const PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC = ?fn (GLenum, GLeglImageOES, [*c]const GLint) callconv(.C) void;
pub const PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC = ?fn (GLuint, GLeglImageOES, [*c]const GLint) callconv(.C) void;
pub const PFNGLUNIFORMBUFFEREXTPROC = ?fn (GLuint, GLint, GLuint) callconv(.C) void;
pub const PFNGLGETUNIFORMBUFFERSIZEEXTPROC = ?fn (GLuint, GLint) callconv(.C) GLint;
pub const PFNGLGETUNIFORMOFFSETEXTPROC = ?fn (GLuint, GLint) callconv(.C) GLintptr;
pub const PFNGLBLENDCOLOREXTPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLBLENDEQUATIONSEPARATEEXTPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLBLENDFUNCSEPARATEEXTPROC = ?fn (GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLBLENDEQUATIONEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLCOLORSUBTABLEEXTPROC = ?fn (GLenum, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCOPYCOLORSUBTABLEEXTPROC = ?fn (GLenum, GLsizei, GLint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLLOCKARRAYSEXTPROC = ?fn (GLint, GLsizei) callconv(.C) void;
pub const PFNGLUNLOCKARRAYSEXTPROC = ?fn () callconv(.C) void;
pub const PFNGLCONVOLUTIONFILTER1DEXTPROC = ?fn (GLenum, GLenum, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCONVOLUTIONFILTER2DEXTPROC = ?fn (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCONVOLUTIONPARAMETERFEXTPROC = ?fn (GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLCONVOLUTIONPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCONVOLUTIONPARAMETERIEXTPROC = ?fn (GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLCONVOLUTIONPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGETCONVOLUTIONFILTEREXTPROC = ?fn (GLenum, GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETSEPARABLEFILTEREXTPROC = ?fn (GLenum, GLenum, GLenum, ?*c_void, ?*c_void, ?*c_void) callconv(.C) void;
pub const PFNGLSEPARABLEFILTER2DEXTPROC = ?fn (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void, ?*const c_void) callconv(.C) void;
pub const PFNGLTANGENT3BEXTPROC = ?fn (GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLTANGENT3BVEXTPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLTANGENT3DEXTPROC = ?fn (GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLTANGENT3DVEXTPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLTANGENT3FEXTPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTANGENT3FVEXTPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLTANGENT3IEXTPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLTANGENT3IVEXTPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLTANGENT3SEXTPROC = ?fn (GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLTANGENT3SVEXTPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLBINORMAL3BEXTPROC = ?fn (GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLBINORMAL3BVEXTPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLBINORMAL3DEXTPROC = ?fn (GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLBINORMAL3DVEXTPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLBINORMAL3FEXTPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLBINORMAL3FVEXTPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLBINORMAL3IEXTPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLBINORMAL3IVEXTPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLBINORMAL3SEXTPROC = ?fn (GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLBINORMAL3SVEXTPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLTANGENTPOINTEREXTPROC = ?fn (GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLBINORMALPOINTEREXTPROC = ?fn (GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOPYTEXIMAGE1DEXTPROC = ?fn (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) callconv(.C) void;
pub const PFNGLCOPYTEXIMAGE2DEXTPROC = ?fn (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) callconv(.C) void;
pub const PFNGLCOPYTEXSUBIMAGE1DEXTPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLCOPYTEXSUBIMAGE2DEXTPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLCOPYTEXSUBIMAGE3DEXTPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLCULLPARAMETERDVEXTPROC = ?fn (GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLCULLPARAMETERFVEXTPROC = ?fn (GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLLABELOBJECTEXTPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLGETOBJECTLABELEXTPROC = ?fn (GLenum, GLuint, GLsizei, [*c]GLsizei, [*c]GLchar) callconv(.C) void;
pub const PFNGLINSERTEVENTMARKEREXTPROC = ?fn (GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLPUSHGROUPMARKEREXTPROC = ?fn (GLsizei, [*c]const GLchar) callconv(.C) void;
pub const PFNGLPOPGROUPMARKEREXTPROC = ?fn () callconv(.C) void;
pub const PFNGLDEPTHBOUNDSEXTPROC = ?fn (GLclampd, GLclampd) callconv(.C) void;
pub const PFNGLMATRIXLOADFEXTPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXLOADDEXTPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMATRIXMULTFEXTPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXMULTDEXTPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMATRIXLOADIDENTITYEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLMATRIXROTATEFEXTPROC = ?fn (GLenum, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLMATRIXROTATEDEXTPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLMATRIXSCALEFEXTPROC = ?fn (GLenum, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLMATRIXSCALEDEXTPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLMATRIXTRANSLATEFEXTPROC = ?fn (GLenum, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLMATRIXTRANSLATEDEXTPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLMATRIXFRUSTUMEXTPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLMATRIXORTHOEXTPROC = ?fn (GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLMATRIXPOPEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLMATRIXPUSHEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLCLIENTATTRIBDEFAULTEXTPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERFEXTPROC = ?fn (GLuint, GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERFVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERIEXTPROC = ?fn (GLuint, GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLTEXTUREIMAGE1DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXTUREIMAGE2DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXTURESUBIMAGE1DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXTURESUBIMAGE2DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCOPYTEXTUREIMAGE1DEXTPROC = ?fn (GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) callconv(.C) void;
pub const PFNGLCOPYTEXTUREIMAGE2DEXTPROC = ?fn (GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) callconv(.C) void;
pub const PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGETTEXTUREIMAGEEXTPROC = ?fn (GLuint, GLenum, GLint, GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLGETTEXTUREPARAMETERFVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETTEXTUREPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC = ?fn (GLuint, GLenum, GLint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, GLint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLTEXTUREIMAGE3DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXTURESUBIMAGE3DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLBINDMULTITEXTUREEXTPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLMULTITEXCOORDPOINTEREXTPROC = ?fn (GLenum, GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLMULTITEXENVFEXTPROC = ?fn (GLenum, GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXENVFVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXENVIEXTPROC = ?fn (GLenum, GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLMULTITEXENVIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLMULTITEXGENDEXTPROC = ?fn (GLenum, GLenum, GLenum, GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXGENDVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMULTITEXGENFEXTPROC = ?fn (GLenum, GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXGENFVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXGENIEXTPROC = ?fn (GLenum, GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLMULTITEXGENIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLGETMULTITEXENVFVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETMULTITEXENVIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETMULTITEXGENDVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETMULTITEXGENFVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETMULTITEXGENIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLMULTITEXPARAMETERIEXTPROC = ?fn (GLenum, GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLMULTITEXPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLMULTITEXPARAMETERFEXTPROC = ?fn (GLenum, GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTITEXIMAGE1DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLMULTITEXIMAGE2DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLMULTITEXSUBIMAGE1DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLMULTITEXSUBIMAGE2DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCOPYMULTITEXIMAGE1DEXTPROC = ?fn (GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) callconv(.C) void;
pub const PFNGLCOPYMULTITEXIMAGE2DEXTPROC = ?fn (GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) callconv(.C) void;
pub const PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGETMULTITEXIMAGEEXTPROC = ?fn (GLenum, GLenum, GLint, GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLGETMULTITEXPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETMULTITEXPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, GLint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, GLint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLMULTITEXIMAGE3DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLMULTITEXSUBIMAGE3DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLENABLECLIENTSTATEINDEXEDEXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLGETFLOATINDEXEDVEXTPROC = ?fn (GLenum, GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETDOUBLEINDEXEDVEXTPROC = ?fn (GLenum, GLuint, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETPOINTERINDEXEDVEXTPROC = ?fn (GLenum, GLuint, [*c]?*c_void) callconv(.C) void;
pub const PFNGLENABLEINDEXEDEXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDISABLEINDEXEDEXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLISENABLEDINDEXEDEXTPROC = ?fn (GLenum, GLuint) callconv(.C) GLboolean;
pub const PFNGLGETINTEGERINDEXEDVEXTPROC = ?fn (GLenum, GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLGETBOOLEANINDEXEDVEXTPROC = ?fn (GLenum, GLuint, [*c]GLboolean) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC = ?fn (GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC = ?fn (GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC = ?fn (GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC = ?fn (GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC = ?fn (GLuint, GLenum, GLint, ?*c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC = ?fn (GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC = ?fn (GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC = ?fn (GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC = ?fn (GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC = ?fn (GLenum, GLenum, GLint, ?*c_void) callconv(.C) void;
pub const PFNGLMATRIXLOADTRANSPOSEFEXTPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXLOADTRANSPOSEDEXTPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLMATRIXMULTTRANSPOSEFEXTPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXMULTTRANSPOSEDEXTPROC = ?fn (GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLNAMEDBUFFERDATAEXTPROC = ?fn (GLuint, GLsizeiptr, ?*const c_void, GLenum) callconv(.C) void;
pub const PFNGLNAMEDBUFFERSUBDATAEXTPROC = ?fn (GLuint, GLintptr, GLsizeiptr, ?*const c_void) callconv(.C) void;
pub const PFNGLMAPNAMEDBUFFEREXTPROC = ?fn (GLuint, GLenum) callconv(.C) ?*c_void;
pub const PFNGLUNMAPNAMEDBUFFEREXTPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNAMEDBUFFERPOINTERVEXTPROC = ?fn (GLuint, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLGETNAMEDBUFFERSUBDATAEXTPROC = ?fn (GLuint, GLintptr, GLsizeiptr, ?*c_void) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1FEXTPROC = ?fn (GLuint, GLint, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2FEXTPROC = ?fn (GLuint, GLint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3FEXTPROC = ?fn (GLuint, GLint, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4FEXTPROC = ?fn (GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1IEXTPROC = ?fn (GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2IEXTPROC = ?fn (GLuint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3IEXTPROC = ?fn (GLuint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4IEXTPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1FVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2FVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3FVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4FVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1IVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2IVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3IVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4IVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXTUREBUFFEREXTPROC = ?fn (GLuint, GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLMULTITEXBUFFEREXTPROC = ?fn (GLenum, GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERIIVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLTEXTUREPARAMETERIUIVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETTEXTUREPARAMETERIIVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTEXTUREPARAMETERIUIVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLMULTITEXPARAMETERIIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLMULTITEXPARAMETERIUIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETMULTITEXPARAMETERIIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETMULTITEXPARAMETERIUIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1UIEXTPROC = ?fn (GLuint, GLint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2UIEXTPROC = ?fn (GLuint, GLint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3UIEXTPROC = ?fn (GLuint, GLint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4UIEXTPROC = ?fn (GLuint, GLint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1UIVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2UIVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3UIVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4UIVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC = ?fn (GLuint, GLenum, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC = ?fn (GLuint, GLenum, GLuint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC = ?fn (GLuint, GLenum, GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC = ?fn (GLuint, GLenum, GLuint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC = ?fn (GLuint, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC = ?fn (GLuint, GLenum, GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC = ?fn (GLuint, GLenum, GLuint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC = ?fn (GLuint, GLenum, GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC = ?fn (GLuint, GLenum, GLuint, [*c]GLuint) callconv(.C) void;
pub const PFNGLENABLECLIENTSTATEIEXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDISABLECLIENTSTATEIEXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLGETFLOATI_VEXTPROC = ?fn (GLenum, GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETDOUBLEI_VEXTPROC = ?fn (GLenum, GLuint, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETPOINTERI_VEXTPROC = ?fn (GLenum, GLuint, [*c]?*c_void) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMSTRINGEXTPROC = ?fn (GLuint, GLenum, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC = ?fn (GLuint, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC = ?fn (GLuint, GLenum, GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC = ?fn (GLuint, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC = ?fn (GLuint, GLenum, GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC = ?fn (GLuint, GLenum, GLuint, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC = ?fn (GLuint, GLenum, GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETNAMEDPROGRAMIVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETNAMEDPROGRAMSTRINGEXTPROC = ?fn (GLuint, GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC = ?fn (GLuint, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC = ?fn (GLuint, GLsizei, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC = ?fn (GLuint, GLenum) callconv(.C) GLenum;
pub const PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC = ?fn (GLuint, GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC = ?fn (GLuint, GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC = ?fn (GLuint, GLenum, GLenum, GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC = ?fn (GLuint, GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGENERATETEXTUREMIPMAPEXTPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLGENERATEMULTITEXMIPMAPEXTPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC = ?fn (GLuint, GLsizei, [*c]const GLenum) callconv(.C) void;
pub const PFNGLFRAMEBUFFERREADBUFFEREXTPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC = ?fn (GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC = ?fn (GLuint, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC = ?fn (GLuint, GLenum, GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC = ?fn (GLuint, GLenum, GLuint, GLint, GLenum) callconv(.C) void;
pub const PFNGLTEXTURERENDERBUFFEREXTPROC = ?fn (GLuint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLMULTITEXRENDERBUFFEREXTPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYCOLOROFFSETEXTPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC = ?fn (GLuint, GLuint, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYINDEXOFFSETEXTPROC = ?fn (GLuint, GLuint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYNORMALOFFSETEXTPROC = ?fn (GLuint, GLuint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC = ?fn (GLuint, GLuint, GLenum, GLint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC = ?fn (GLuint, GLuint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC = ?fn (GLuint, GLuint, GLuint, GLint, GLenum, GLboolean, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC = ?fn (GLuint, GLuint, GLuint, GLint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLENABLEVERTEXARRAYEXTPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLDISABLEVERTEXARRAYEXTPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLENABLEVERTEXARRAYATTRIBEXTPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLGETVERTEXARRAYINTEGERVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXARRAYPOINTERVEXTPROC = ?fn (GLuint, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC = ?fn (GLuint, GLuint, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLMAPNAMEDBUFFERRANGEEXTPROC = ?fn (GLuint, GLintptr, GLsizeiptr, GLbitfield) callconv(.C) ?*c_void;
pub const PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC = ?fn (GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLNAMEDBUFFERSTORAGEEXTPROC = ?fn (GLuint, GLsizeiptr, ?*const c_void, GLbitfield) callconv(.C) void;
pub const PFNGLCLEARNAMEDBUFFERDATAEXTPROC = ?fn (GLuint, GLenum, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC = ?fn (GLuint, GLenum, GLsizeiptr, GLsizeiptr, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1DEXTPROC = ?fn (GLuint, GLint, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2DEXTPROC = ?fn (GLuint, GLint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3DEXTPROC = ?fn (GLuint, GLint, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4DEXTPROC = ?fn (GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM1DVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM2DVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM3DVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORM4DVEXTPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC = ?fn (GLuint, GLint, GLsizei, GLboolean, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLTEXTUREBUFFERRANGEEXTPROC = ?fn (GLuint, GLenum, GLenum, GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE1DEXTPROC = ?fn (GLuint, GLenum, GLsizei, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE2DEXTPROC = ?fn (GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE3DEXTPROC = ?fn (GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC = ?fn (GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC = ?fn (GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC = ?fn (GLuint, GLuint, GLuint, GLintptr, GLsizei) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLboolean, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC = ?fn (GLuint, GLuint, GLint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC = ?fn (GLuint, GLuint, GLuint, GLint, GLenum, GLsizei, GLintptr) callconv(.C) void;
pub const PFNGLTEXTUREPAGECOMMITMENTEXTPROC = ?fn (GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLCOLORMASKINDEXEDEXTPROC = ?fn (GLuint, GLboolean, GLboolean, GLboolean, GLboolean) callconv(.C) void;
pub const PFNGLDRAWARRAYSINSTANCEDEXTPROC = ?fn (GLenum, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLDRAWELEMENTSINSTANCEDEXTPROC = ?fn (GLenum, GLsizei, GLenum, ?*const c_void, GLsizei) callconv(.C) void;
pub const PFNGLDRAWRANGEELEMENTSEXTPROC = ?fn (GLenum, GLuint, GLuint, GLsizei, GLenum, ?*const c_void) callconv(.C) void;
pub const GLeglClientBufferEXT = ?*c_void;
pub const PFNGLBUFFERSTORAGEEXTERNALEXTPROC = ?fn (GLenum, GLintptr, GLsizeiptr, GLeglClientBufferEXT, GLbitfield) callconv(.C) void;
pub const PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC = ?fn (GLuint, GLintptr, GLsizeiptr, GLeglClientBufferEXT, GLbitfield) callconv(.C) void;
pub const PFNGLFOGCOORDFEXTPROC = ?fn (GLfloat) callconv(.C) void;
pub const PFNGLFOGCOORDFVEXTPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLFOGCOORDDEXTPROC = ?fn (GLdouble) callconv(.C) void;
pub const PFNGLFOGCOORDDVEXTPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLFOGCOORDPOINTEREXTPROC = ?fn (GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLBLITFRAMEBUFFEREXTPROC = ?fn (GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) callconv(.C) void;
pub const PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLISRENDERBUFFEREXTPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBINDRENDERBUFFEREXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETERENDERBUFFERSEXTPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENRENDERBUFFERSEXTPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLRENDERBUFFERSTORAGEEXTPROC = ?fn (GLenum, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLISFRAMEBUFFEREXTPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBINDFRAMEBUFFEREXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETEFRAMEBUFFERSEXTPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENFRAMEBUFFERSEXTPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC = ?fn (GLenum) callconv(.C) GLenum;
pub const PFNGLFRAMEBUFFERTEXTURE1DEXTPROC = ?fn (GLenum, GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTURE2DEXTPROC = ?fn (GLenum, GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTURE3DEXTPROC = ?fn (GLenum, GLenum, GLenum, GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC = ?fn (GLenum, GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGENERATEMIPMAPEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLPROGRAMPARAMETERIEXTPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETERS4FVEXTPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETUNIFORMUIVEXTPROC = ?fn (GLuint, GLint, [*c]GLuint) callconv(.C) void;
pub const PFNGLBINDFRAGDATALOCATIONEXTPROC = ?fn (GLuint, GLuint, [*c]const GLchar) callconv(.C) void;
pub const PFNGLGETFRAGDATALOCATIONEXTPROC = ?fn (GLuint, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLUNIFORM1UIEXTPROC = ?fn (GLint, GLuint) callconv(.C) void;
pub const PFNGLUNIFORM2UIEXTPROC = ?fn (GLint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLUNIFORM3UIEXTPROC = ?fn (GLint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLUNIFORM4UIEXTPROC = ?fn (GLint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLUNIFORM1UIVEXTPROC = ?fn (GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLUNIFORM2UIVEXTPROC = ?fn (GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLUNIFORM3UIVEXTPROC = ?fn (GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLUNIFORM4UIVEXTPROC = ?fn (GLint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETHISTOGRAMEXTPROC = ?fn (GLenum, GLboolean, GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLGETHISTOGRAMPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETHISTOGRAMPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETMINMAXEXTPROC = ?fn (GLenum, GLboolean, GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLGETMINMAXPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETMINMAXPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLHISTOGRAMEXTPROC = ?fn (GLenum, GLsizei, GLenum, GLboolean) callconv(.C) void;
pub const PFNGLMINMAXEXTPROC = ?fn (GLenum, GLenum, GLboolean) callconv(.C) void;
pub const PFNGLRESETHISTOGRAMEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLRESETMINMAXEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLINDEXFUNCEXTPROC = ?fn (GLenum, GLclampf) callconv(.C) void;
pub const PFNGLINDEXMATERIALEXTPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLAPPLYTEXTUREEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLTEXTURELIGHTEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLTEXTUREMATERIALEXTPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLGETUNSIGNEDBYTEVEXTPROC = ?fn (GLenum, [*c]GLubyte) callconv(.C) void;
pub const PFNGLGETUNSIGNEDBYTEI_VEXTPROC = ?fn (GLenum, GLuint, [*c]GLubyte) callconv(.C) void;
pub const PFNGLDELETEMEMORYOBJECTSEXTPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISMEMORYOBJECTEXTPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLCREATEMEMORYOBJECTSEXTPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLMEMORYOBJECTPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLTEXSTORAGEMEM2DEXTPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXSTORAGEMEM3DEXTPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLBUFFERSTORAGEMEMEXTPROC = ?fn (GLenum, GLsizeiptr, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXTURESTORAGEMEM2DEXTPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXTURESTORAGEMEM2DMULTISAMPLEEXTPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLboolean, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXTURESTORAGEMEM3DEXTPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXTURESTORAGEMEM3DMULTISAMPLEEXTPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLNAMEDBUFFERSTORAGEMEMEXTPROC = ?fn (GLuint, GLsizeiptr, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXSTORAGEMEM1DEXTPROC = ?fn (GLenum, GLsizei, GLenum, GLsizei, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXTURESTORAGEMEM1DEXTPROC = ?fn (GLuint, GLsizei, GLenum, GLsizei, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLIMPORTMEMORYFDEXTPROC = ?fn (GLuint, GLuint64, GLenum, GLint) callconv(.C) void;
pub const PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC = ?fn (GLuint, GLuint64, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLIMPORTMEMORYWIN32NAMEEXTPROC = ?fn (GLuint, GLuint64, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLMULTIDRAWARRAYSEXTPROC = ?fn (GLenum, [*c]const GLint, [*c]const GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSEXTPROC = ?fn (GLenum, [*c]const GLsizei, GLenum, [*c]const ?*const c_void, GLsizei) callconv(.C) void;
pub const PFNGLSAMPLEMASKEXTPROC = ?fn (GLclampf, GLboolean) callconv(.C) void;
pub const PFNGLSAMPLEPATTERNEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLCOLORTABLEEXTPROC = ?fn (GLenum, GLenum, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLGETCOLORTABLEEXTPROC = ?fn (GLenum, GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLPIXELTRANSFORMPARAMETERIEXTPROC = ?fn (GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLPIXELTRANSFORMPARAMETERFEXTPROC = ?fn (GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLPOINTPARAMETERFEXTPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLPOINTPARAMETERFVEXTPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPOLYGONOFFSETEXTPROC = ?fn (GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPOLYGONOFFSETCLAMPEXTPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROVOKINGVERTEXEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLRASTERSAMPLESEXTPROC = ?fn (GLuint, GLboolean) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3BEXTPROC = ?fn (GLbyte, GLbyte, GLbyte) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3BVEXTPROC = ?fn ([*c]const GLbyte) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3DEXTPROC = ?fn (GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3DVEXTPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3FEXTPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3FVEXTPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3IEXTPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3IVEXTPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3SEXTPROC = ?fn (GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3SVEXTPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3UBEXTPROC = ?fn (GLubyte, GLubyte, GLubyte) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3UBVEXTPROC = ?fn ([*c]const GLubyte) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3UIEXTPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3UIVEXTPROC = ?fn ([*c]const GLuint) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3USEXTPROC = ?fn (GLushort, GLushort, GLushort) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3USVEXTPROC = ?fn ([*c]const GLushort) callconv(.C) void;
pub const PFNGLSECONDARYCOLORPOINTEREXTPROC = ?fn (GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGENSEMAPHORESEXTPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETESEMAPHORESEXTPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISSEMAPHOREEXTPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLSEMAPHOREPARAMETERUI64VEXTPROC = ?fn (GLuint, GLenum, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC = ?fn (GLuint, GLenum, [*c]GLuint64) callconv(.C) void;
pub const PFNGLWAITSEMAPHOREEXTPROC = ?fn (GLuint, GLuint, [*c]const GLuint, GLuint, [*c]const GLuint, [*c]const GLenum) callconv(.C) void;
pub const PFNGLSIGNALSEMAPHOREEXTPROC = ?fn (GLuint, GLuint, [*c]const GLuint, GLuint, [*c]const GLuint, [*c]const GLenum) callconv(.C) void;
pub const PFNGLIMPORTSEMAPHOREFDEXTPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC = ?fn (GLuint, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC = ?fn (GLuint, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLUSESHADERPROGRAMEXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLACTIVEPROGRAMEXTPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLCREATESHADERPROGRAMEXTPROC = ?fn (GLenum, [*c]const GLchar) callconv(.C) GLuint;
pub const PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC = ?fn () callconv(.C) void;
pub const PFNGLBINDIMAGETEXTUREEXTPROC = ?fn (GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLint) callconv(.C) void;
pub const PFNGLMEMORYBARRIEREXTPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLSTENCILCLEARTAGEXTPROC = ?fn (GLsizei, GLuint) callconv(.C) void;
pub const PFNGLACTIVESTENCILFACEEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLTEXSUBIMAGE1DEXTPROC = ?fn (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXSUBIMAGE2DEXTPROC = ?fn (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXIMAGE3DEXTPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXSUBIMAGE3DEXTPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC = ?fn (GLenum, GLenum, GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLTEXBUFFEREXTPROC = ?fn (GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLTEXPARAMETERIIVEXTPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLTEXPARAMETERIUIVEXTPROC = ?fn (GLenum, GLenum, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETTEXPARAMETERIIVEXTPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETTEXPARAMETERIUIVEXTPROC = ?fn (GLenum, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLCLEARCOLORIIEXTPROC = ?fn (GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLCLEARCOLORIUIEXTPROC = ?fn (GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLARETEXTURESRESIDENTEXTPROC = ?fn (GLsizei, [*c]const GLuint, [*c]GLboolean) callconv(.C) GLboolean;
pub const PFNGLBINDTEXTUREEXTPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETETEXTURESEXTPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENTEXTURESEXTPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISTEXTUREEXTPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLPRIORITIZETEXTURESEXTPROC = ?fn (GLsizei, [*c]const GLuint, [*c]const GLclampf) callconv(.C) void;
pub const PFNGLTEXTURENORMALEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLGETQUERYOBJECTI64VEXTPROC = ?fn (GLuint, GLenum, [*c]GLint64) callconv(.C) void;
pub const PFNGLGETQUERYOBJECTUI64VEXTPROC = ?fn (GLuint, GLenum, [*c]GLuint64) callconv(.C) void;
pub const PFNGLBEGINTRANSFORMFEEDBACKEXTPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLENDTRANSFORMFEEDBACKEXTPROC = ?fn () callconv(.C) void;
pub const PFNGLBINDBUFFERRANGEEXTPROC = ?fn (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLBINDBUFFEROFFSETEXTPROC = ?fn (GLenum, GLuint, GLuint, GLintptr) callconv(.C) void;
pub const PFNGLBINDBUFFERBASEEXTPROC = ?fn (GLenum, GLuint, GLuint) callconv(.C) void;
pub const PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC = ?fn (GLuint, GLsizei, [*c]const [*c]const GLchar, GLenum) callconv(.C) void;
pub const PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC = ?fn (GLuint, GLuint, GLsizei, [*c]GLsizei, [*c]GLsizei, [*c]GLenum, [*c]GLchar) callconv(.C) void;
pub const PFNGLARRAYELEMENTEXTPROC = ?fn (GLint) callconv(.C) void;
pub const PFNGLCOLORPOINTEREXTPROC = ?fn (GLint, GLenum, GLsizei, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLDRAWARRAYSEXTPROC = ?fn (GLenum, GLint, GLsizei) callconv(.C) void;
pub const PFNGLEDGEFLAGPOINTEREXTPROC = ?fn (GLsizei, GLsizei, [*c]const GLboolean) callconv(.C) void;
pub const PFNGLGETPOINTERVEXTPROC = ?fn (GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLINDEXPOINTEREXTPROC = ?fn (GLenum, GLsizei, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLNORMALPOINTEREXTPROC = ?fn (GLenum, GLsizei, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXCOORDPOINTEREXTPROC = ?fn (GLint, GLenum, GLsizei, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLVERTEXPOINTEREXTPROC = ?fn (GLint, GLenum, GLsizei, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1DEXTPROC = ?fn (GLuint, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL2DEXTPROC = ?fn (GLuint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL3DEXTPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL4DEXTPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1DVEXTPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL2DVEXTPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL3DVEXTPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL4DVEXTPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBLPOINTEREXTPROC = ?fn (GLuint, GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBLDVEXTPROC = ?fn (GLuint, GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLBEGINVERTEXSHADEREXTPROC = ?fn () callconv(.C) void;
pub const PFNGLENDVERTEXSHADEREXTPROC = ?fn () callconv(.C) void;
pub const PFNGLBINDVERTEXSHADEREXTPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLGENVERTEXSHADERSEXTPROC = ?fn (GLuint) callconv(.C) GLuint;
pub const PFNGLDELETEVERTEXSHADEREXTPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLSHADEROP1EXTPROC = ?fn (GLenum, GLuint, GLuint) callconv(.C) void;
pub const PFNGLSHADEROP2EXTPROC = ?fn (GLenum, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLSHADEROP3EXTPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLSWIZZLEEXTPROC = ?fn (GLuint, GLuint, GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLWRITEMASKEXTPROC = ?fn (GLuint, GLuint, GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLINSERTCOMPONENTEXTPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLEXTRACTCOMPONENTEXTPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLGENSYMBOLSEXTPROC = ?fn (GLenum, GLenum, GLenum, GLuint) callconv(.C) GLuint;
pub const PFNGLSETINVARIANTEXTPROC = ?fn (GLuint, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLSETLOCALCONSTANTEXTPROC = ?fn (GLuint, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLVARIANTBVEXTPROC = ?fn (GLuint, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLVARIANTSVEXTPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVARIANTIVEXTPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVARIANTFVEXTPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVARIANTDVEXTPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVARIANTUBVEXTPROC = ?fn (GLuint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVARIANTUSVEXTPROC = ?fn (GLuint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLVARIANTUIVEXTPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVARIANTPOINTEREXTPROC = ?fn (GLuint, GLenum, GLuint, ?*const c_void) callconv(.C) void;
pub const PFNGLENABLEVARIANTCLIENTSTATEEXTPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLBINDLIGHTPARAMETEREXTPROC = ?fn (GLenum, GLenum) callconv(.C) GLuint;
pub const PFNGLBINDMATERIALPARAMETEREXTPROC = ?fn (GLenum, GLenum) callconv(.C) GLuint;
pub const PFNGLBINDTEXGENPARAMETEREXTPROC = ?fn (GLenum, GLenum, GLenum) callconv(.C) GLuint;
pub const PFNGLBINDTEXTUREUNITPARAMETEREXTPROC = ?fn (GLenum, GLenum) callconv(.C) GLuint;
pub const PFNGLBINDPARAMETEREXTPROC = ?fn (GLenum) callconv(.C) GLuint;
pub const PFNGLISVARIANTENABLEDEXTPROC = ?fn (GLuint, GLenum) callconv(.C) GLboolean;
pub const PFNGLGETVARIANTBOOLEANVEXTPROC = ?fn (GLuint, GLenum, [*c]GLboolean) callconv(.C) void;
pub const PFNGLGETVARIANTINTEGERVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVARIANTFLOATVEXTPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETVARIANTPOINTERVEXTPROC = ?fn (GLuint, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLGETINVARIANTBOOLEANVEXTPROC = ?fn (GLuint, GLenum, [*c]GLboolean) callconv(.C) void;
pub const PFNGLGETINVARIANTINTEGERVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETINVARIANTFLOATVEXTPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC = ?fn (GLuint, GLenum, [*c]GLboolean) callconv(.C) void;
pub const PFNGLGETLOCALCONSTANTINTEGERVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETLOCALCONSTANTFLOATVEXTPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLVERTEXWEIGHTFEXTPROC = ?fn (GLfloat) callconv(.C) void;
pub const PFNGLVERTEXWEIGHTFVEXTPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXWEIGHTPOINTEREXTPROC = ?fn (GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC = ?fn (GLuint, GLuint64, GLuint) callconv(.C) GLboolean;
pub const PFNGLRELEASEKEYEDMUTEXWIN32EXTPROC = ?fn (GLuint, GLuint64) callconv(.C) GLboolean;
pub const PFNGLWINDOWRECTANGLESEXTPROC = ?fn (GLenum, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLIMPORTSYNCEXTPROC = ?fn (GLenum, GLintptr, GLbitfield) callconv(.C) GLsync;
pub const PFNGLFRAMETERMINATORGREMEDYPROC = ?fn () callconv(.C) void;
pub const PFNGLSTRINGMARKERGREMEDYPROC = ?fn (GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLIMAGETRANSFORMPARAMETERIHPPROC = ?fn (GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLIMAGETRANSFORMPARAMETERFHPPROC = ?fn (GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLIMAGETRANSFORMPARAMETERIVHPPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLIMAGETRANSFORMPARAMETERFVHPPROC = ?fn (GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLMULTIMODEDRAWARRAYSIBMPROC = ?fn ([*c]const GLenum, [*c]const GLint, [*c]const GLsizei, GLsizei, GLint) callconv(.C) void;
pub const PFNGLMULTIMODEDRAWELEMENTSIBMPROC = ?fn ([*c]const GLenum, [*c]const GLsizei, GLenum, [*c]const ?*const c_void, GLsizei, GLint) callconv(.C) void;
pub const PFNGLFLUSHSTATICDATAIBMPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLCOLORPOINTERLISTIBMPROC = ?fn (GLint, GLenum, GLint, [*c]?*const c_void, GLint) callconv(.C) void;
pub const PFNGLSECONDARYCOLORPOINTERLISTIBMPROC = ?fn (GLint, GLenum, GLint, [*c]?*const c_void, GLint) callconv(.C) void;
pub const PFNGLEDGEFLAGPOINTERLISTIBMPROC = ?fn (GLint, [*c][*c]const GLboolean, GLint) callconv(.C) void;
pub const PFNGLFOGCOORDPOINTERLISTIBMPROC = ?fn (GLenum, GLint, [*c]?*const c_void, GLint) callconv(.C) void;
pub const PFNGLINDEXPOINTERLISTIBMPROC = ?fn (GLenum, GLint, [*c]?*const c_void, GLint) callconv(.C) void;
pub const PFNGLNORMALPOINTERLISTIBMPROC = ?fn (GLenum, GLint, [*c]?*const c_void, GLint) callconv(.C) void;
pub const PFNGLTEXCOORDPOINTERLISTIBMPROC = ?fn (GLint, GLenum, GLint, [*c]?*const c_void, GLint) callconv(.C) void;
pub const PFNGLVERTEXPOINTERLISTIBMPROC = ?fn (GLint, GLenum, GLint, [*c]?*const c_void, GLint) callconv(.C) void;
pub const PFNGLBLENDFUNCSEPARATEINGRPROC = ?fn (GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC = ?fn () callconv(.C) void;
pub const PFNGLSYNCTEXTUREINTELPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLUNMAPTEXTURE2DINTELPROC = ?fn (GLuint, GLint) callconv(.C) void;
pub const PFNGLMAPTEXTURE2DINTELPROC = ?fn (GLuint, GLint, GLbitfield, [*c]GLint, [*c]GLenum) callconv(.C) ?*c_void;
pub const PFNGLVERTEXPOINTERVINTELPROC = ?fn (GLint, GLenum, [*c]?*const c_void) callconv(.C) void;
pub const PFNGLNORMALPOINTERVINTELPROC = ?fn (GLenum, [*c]?*const c_void) callconv(.C) void;
pub const PFNGLCOLORPOINTERVINTELPROC = ?fn (GLint, GLenum, [*c]?*const c_void) callconv(.C) void;
pub const PFNGLTEXCOORDPOINTERVINTELPROC = ?fn (GLint, GLenum, [*c]?*const c_void) callconv(.C) void;
pub const PFNGLBEGINPERFQUERYINTELPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLCREATEPERFQUERYINTELPROC = ?fn (GLuint, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETEPERFQUERYINTELPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLENDPERFQUERYINTELPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLGETFIRSTPERFQUERYIDINTELPROC = ?fn ([*c]GLuint) callconv(.C) void;
pub const PFNGLGETNEXTPERFQUERYIDINTELPROC = ?fn (GLuint, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETPERFCOUNTERINFOINTELPROC = ?fn (GLuint, GLuint, GLuint, [*c]GLchar, GLuint, [*c]GLchar, [*c]GLuint, [*c]GLuint, [*c]GLuint, [*c]GLuint, [*c]GLuint64) callconv(.C) void;
pub const PFNGLGETPERFQUERYDATAINTELPROC = ?fn (GLuint, GLuint, GLsizei, ?*c_void, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETPERFQUERYIDBYNAMEINTELPROC = ?fn ([*c]GLchar, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETPERFQUERYINFOINTELPROC = ?fn (GLuint, GLuint, [*c]GLchar, [*c]GLuint, [*c]GLuint, [*c]GLuint, [*c]GLuint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERPARAMETERIMESAPROC = ?fn (GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLRESIZEBUFFERSMESAPROC = ?fn () callconv(.C) void;
pub const PFNGLWINDOWPOS2DMESAPROC = ?fn (GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS2DVMESAPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS2FMESAPROC = ?fn (GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS2FVMESAPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS2IMESAPROC = ?fn (GLint, GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS2IVMESAPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS2SMESAPROC = ?fn (GLshort, GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS2SVMESAPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS3DMESAPROC = ?fn (GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS3DVMESAPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS3FMESAPROC = ?fn (GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS3FVMESAPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS3IMESAPROC = ?fn (GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS3IVMESAPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS3SMESAPROC = ?fn (GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS3SVMESAPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS4DMESAPROC = ?fn (GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS4DVMESAPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLWINDOWPOS4FMESAPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS4FVMESAPROC = ?fn ([*c]const GLfloat) callconv(.C) void;
pub const PFNGLWINDOWPOS4IMESAPROC = ?fn (GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS4IVMESAPROC = ?fn ([*c]const GLint) callconv(.C) void;
pub const PFNGLWINDOWPOS4SMESAPROC = ?fn (GLshort, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLWINDOWPOS4SVMESAPROC = ?fn ([*c]const GLshort) callconv(.C) void;
pub const PFNGLBEGINCONDITIONALRENDERNVXPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLENDCONDITIONALRENDERNVXPROC = ?fn () callconv(.C) void;
pub const PFNGLUPLOADGPUMASKNVXPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLMULTICASTVIEWPORTARRAYVNVXPROC = ?fn (GLuint, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTICASTVIEWPORTPOSITIONWSCALENVXPROC = ?fn (GLuint, GLuint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLMULTICASTSCISSORARRAYVNVXPROC = ?fn (GLuint, GLuint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLASYNCCOPYBUFFERSUBDATANVXPROC = ?fn (GLsizei, [*c]const GLuint, [*c]const GLuint64, GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, GLsizei, [*c]const GLuint, [*c]const GLuint64) callconv(.C) GLuint;
pub const PFNGLASYNCCOPYIMAGESUBDATANVXPROC = ?fn (GLsizei, [*c]const GLuint, [*c]const GLuint64, GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, [*c]const GLuint, [*c]const GLuint64) callconv(.C) GLuint;
pub const PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC = ?fn (GLbitfield, GLuint, GLintptr, GLsizeiptr, ?*const c_void) callconv(.C) void;
pub const PFNGLLGPUCOPYIMAGESUBDATANVXPROC = ?fn (GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLLGPUINTERLOCKNVXPROC = ?fn () callconv(.C) void;
pub const PFNGLCREATEPROGRESSFENCENVXPROC = ?fn () callconv(.C) GLuint;
pub const PFNGLSIGNALSEMAPHOREUI64NVXPROC = ?fn (GLuint, GLsizei, [*c]const GLuint, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLWAITSEMAPHOREUI64NVXPROC = ?fn (GLuint, GLsizei, [*c]const GLuint, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC = ?fn (GLsizei, [*c]const GLuint, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLALPHATOCOVERAGEDITHERCONTROLNVPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC = ?fn (GLenum, ?*const c_void, GLsizei, GLsizei, GLint) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC = ?fn (GLenum, GLenum, ?*const c_void, GLsizei, GLsizei, GLint) callconv(.C) void;
pub const PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC = ?fn (GLenum, ?*const c_void, GLsizei, GLsizei, GLsizei, GLint) callconv(.C) void;
pub const PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC = ?fn (GLenum, GLenum, ?*const c_void, GLsizei, GLsizei, GLsizei, GLint) callconv(.C) void;
pub const PFNGLGETTEXTUREHANDLENVPROC = ?fn (GLuint) callconv(.C) GLuint64;
pub const PFNGLGETTEXTURESAMPLERHANDLENVPROC = ?fn (GLuint, GLuint) callconv(.C) GLuint64;
pub const PFNGLMAKETEXTUREHANDLERESIDENTNVPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLGETIMAGEHANDLENVPROC = ?fn (GLuint, GLint, GLboolean, GLint, GLenum) callconv(.C) GLuint64;
pub const PFNGLMAKEIMAGEHANDLERESIDENTNVPROC = ?fn (GLuint64, GLenum) callconv(.C) void;
pub const PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLUNIFORMHANDLEUI64NVPROC = ?fn (GLint, GLuint64) callconv(.C) void;
pub const PFNGLUNIFORMHANDLEUI64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC = ?fn (GLuint, GLint, GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64) callconv(.C) void;
pub const PFNGLISTEXTUREHANDLERESIDENTNVPROC = ?fn (GLuint64) callconv(.C) GLboolean;
pub const PFNGLISIMAGEHANDLERESIDENTNVPROC = ?fn (GLuint64) callconv(.C) GLboolean;
pub const PFNGLBLENDPARAMETERINVPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLBLENDBARRIERNVPROC = ?fn () callconv(.C) void;
pub const PFNGLVIEWPORTPOSITIONWSCALENVPROC = ?fn (GLuint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLCREATESTATESNVPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETESTATESNVPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISSTATENVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLSTATECAPTURENVPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLGETCOMMANDHEADERNVPROC = ?fn (GLenum, GLuint) callconv(.C) GLuint;
pub const PFNGLGETSTAGEINDEXNVPROC = ?fn (GLenum) callconv(.C) GLushort;
pub const PFNGLDRAWCOMMANDSNVPROC = ?fn (GLenum, GLuint, [*c]const GLintptr, [*c]const GLsizei, GLuint) callconv(.C) void;
pub const PFNGLDRAWCOMMANDSADDRESSNVPROC = ?fn (GLenum, [*c]const GLuint64, [*c]const GLsizei, GLuint) callconv(.C) void;
pub const PFNGLDRAWCOMMANDSSTATESNVPROC = ?fn (GLuint, [*c]const GLintptr, [*c]const GLsizei, [*c]const GLuint, [*c]const GLuint, GLuint) callconv(.C) void;
pub const PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC = ?fn ([*c]const GLuint64, [*c]const GLsizei, [*c]const GLuint, [*c]const GLuint, GLuint) callconv(.C) void;
pub const PFNGLCREATECOMMANDLISTSNVPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETECOMMANDLISTSNVPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISCOMMANDLISTNVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC = ?fn (GLuint, GLuint, [*c]?*const c_void, [*c]const GLsizei, [*c]const GLuint, [*c]const GLuint, GLuint) callconv(.C) void;
pub const PFNGLCOMMANDLISTSEGMENTSNVPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLCOMPILECOMMANDLISTNVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLCALLCOMMANDLISTNVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLBEGINCONDITIONALRENDERNVPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLENDCONDITIONALRENDERNVPROC = ?fn () callconv(.C) void;
pub const PFNGLSUBPIXELPRECISIONBIASNVPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLCONSERVATIVERASTERPARAMETERFNVPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLCONSERVATIVERASTERPARAMETERINVPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLCOPYIMAGESUBDATANVPROC = ?fn (GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLDEPTHRANGEDNVPROC = ?fn (GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLCLEARDEPTHDNVPROC = ?fn (GLdouble) callconv(.C) void;
pub const PFNGLDEPTHBOUNDSDNVPROC = ?fn (GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLDRAWTEXTURENVPROC = ?fn (GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const GLVULKANPROCNV = ?fn () callconv(.C) void;
pub const PFNGLDRAWVKIMAGENVPROC = ?fn (GLuint64, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLGETVKPROCADDRNVPROC = ?fn ([*c]const GLchar) callconv(.C) GLVULKANPROCNV;
pub const PFNGLWAITVKSEMAPHORENVPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLSIGNALVKSEMAPHORENVPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLSIGNALVKFENCENVPROC = ?fn (GLuint64) callconv(.C) void;
pub const PFNGLMAPCONTROLPOINTSNVPROC = ?fn (GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, ?*const c_void) callconv(.C) void;
pub const PFNGLMAPPARAMETERIVNVPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLMAPPARAMETERFVNVPROC = ?fn (GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETMAPCONTROLPOINTSNVPROC = ?fn (GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, ?*c_void) callconv(.C) void;
pub const PFNGLGETMAPPARAMETERIVNVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETMAPPARAMETERFVNVPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETMAPATTRIBPARAMETERIVNVPROC = ?fn (GLenum, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETMAPATTRIBPARAMETERFVNVPROC = ?fn (GLenum, GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLEVALMAPSNVPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLGETMULTISAMPLEFVNVPROC = ?fn (GLenum, GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLSAMPLEMASKINDEXEDNVPROC = ?fn (GLuint, GLbitfield) callconv(.C) void;
pub const PFNGLTEXRENDERBUFFERNVPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETEFENCESNVPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENFENCESNVPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISFENCENVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLTESTFENCENVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLGETFENCEIVNVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLFINISHFENCENVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLSETFENCENVPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLFRAGMENTCOVERAGECOLORNVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLPROGRAMNAMEDPARAMETER4FNVPROC = ?fn (GLuint, GLsizei, [*c]const GLubyte, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLubyte, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMNAMEDPARAMETER4DNVPROC = ?fn (GLuint, GLsizei, [*c]const GLubyte, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLubyte, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLubyte, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLubyte, [*c]GLdouble) callconv(.C) void;
pub const PFNGLCOVERAGEMODULATIONTABLENVPROC = ?fn (GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETCOVERAGEMODULATIONTABLENVPROC = ?fn (GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLCOVERAGEMODULATIONNVPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC = ?fn (GLenum, GLsizei, GLsizei, GLenum, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLPROGRAMVERTEXLIMITNVPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTUREEXTPROC = ?fn (GLenum, GLenum, GLuint, GLint) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC = ?fn (GLenum, GLenum, GLuint, GLint, GLenum) callconv(.C) void;
pub const PFNGLRENDERGPUMASKNVPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLMULTICASTBUFFERSUBDATANVPROC = ?fn (GLbitfield, GLuint, GLintptr, GLsizeiptr, ?*const c_void) callconv(.C) void;
pub const PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC = ?fn (GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLMULTICASTCOPYIMAGESUBDATANVPROC = ?fn (GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTICASTBLITFRAMEBUFFERNVPROC = ?fn (GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) callconv(.C) void;
pub const PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = ?fn (GLuint, GLuint, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMULTICASTBARRIERNVPROC = ?fn () callconv(.C) void;
pub const PFNGLMULTICASTWAITSYNCNVPROC = ?fn (GLuint, GLbitfield) callconv(.C) void;
pub const PFNGLMULTICASTGETQUERYOBJECTIVNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLMULTICASTGETQUERYOBJECTUIVNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLint64) callconv(.C) void;
pub const PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLuint64) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETERI4INVPROC = ?fn (GLenum, GLuint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC = ?fn (GLenum, GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETERI4UINVPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC = ?fn (GLenum, GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETERI4INVPROC = ?fn (GLenum, GLuint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETERI4IVNVPROC = ?fn (GLenum, GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETERSI4IVNVPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETERI4UINVPROC = ?fn (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETERI4UIVNVPROC = ?fn (GLenum, GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC = ?fn (GLenum, GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC = ?fn (GLenum, GLuint, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETPROGRAMENVPARAMETERIIVNVPROC = ?fn (GLenum, GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC = ?fn (GLenum, GLuint, [*c]GLuint) callconv(.C) void;
pub const PFNGLPROGRAMSUBROUTINEPARAMETERSUIVNVPROC = ?fn (GLenum, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC = ?fn (GLenum, GLuint, [*c]GLuint) callconv(.C) void;
pub const GLhalfNV = c_ushort;
pub const PFNGLVERTEX2HNVPROC = ?fn (GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEX2HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEX3HNVPROC = ?fn (GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEX3HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEX4HNVPROC = ?fn (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEX4HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLNORMAL3HNVPROC = ?fn (GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLNORMAL3HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLCOLOR3HNVPROC = ?fn (GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLCOLOR3HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLCOLOR4HNVPROC = ?fn (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLCOLOR4HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLTEXCOORD1HNVPROC = ?fn (GLhalfNV) callconv(.C) void;
pub const PFNGLTEXCOORD1HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLTEXCOORD2HNVPROC = ?fn (GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLTEXCOORD2HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLTEXCOORD3HNVPROC = ?fn (GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLTEXCOORD3HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLTEXCOORD4HNVPROC = ?fn (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLTEXCOORD4HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1HNVPROC = ?fn (GLenum, GLhalfNV) callconv(.C) void;
pub const PFNGLMULTITEXCOORD1HVNVPROC = ?fn (GLenum, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2HNVPROC = ?fn (GLenum, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLMULTITEXCOORD2HVNVPROC = ?fn (GLenum, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3HNVPROC = ?fn (GLenum, GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLMULTITEXCOORD3HVNVPROC = ?fn (GLenum, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4HNVPROC = ?fn (GLenum, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLMULTITEXCOORD4HVNVPROC = ?fn (GLenum, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLFOGCOORDHNVPROC = ?fn (GLhalfNV) callconv(.C) void;
pub const PFNGLFOGCOORDHVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3HNVPROC = ?fn (GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLSECONDARYCOLOR3HVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXWEIGHTHNVPROC = ?fn (GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXWEIGHTHVNVPROC = ?fn ([*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1HNVPROC = ?fn (GLuint, GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1HVNVPROC = ?fn (GLuint, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2HNVPROC = ?fn (GLuint, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2HVNVPROC = ?fn (GLuint, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3HNVPROC = ?fn (GLuint, GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3HVNVPROC = ?fn (GLuint, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4HNVPROC = ?fn (GLuint, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4HVNVPROC = ?fn (GLuint, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS1HVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS2HVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS3HVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS4HVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLhalfNV) callconv(.C) void;
pub const PFNGLGETINTERNALFORMATSAMPLEIVNVPROC = ?fn (GLenum, GLenum, GLsizei, GLenum, GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC = ?fn (GLuint, GLenum, GLint, GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLRESETMEMORYOBJECTPARAMETERNVPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLTEXATTACHMEMORYNVPROC = ?fn (GLenum, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLBUFFERATTACHMEMORYNVPROC = ?fn (GLenum, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLTEXTUREATTACHMEMORYNVPROC = ?fn (GLuint, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLNAMEDBUFFERATTACHMEMORYNVPROC = ?fn (GLuint, GLuint, GLuint64) callconv(.C) void;
pub const PFNGLDRAWMESHTASKSNVPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLDRAWMESHTASKSINDIRECTNVPROC = ?fn (GLintptr) callconv(.C) void;
pub const PFNGLMULTIDRAWMESHTASKSINDIRECTNVPROC = ?fn (GLintptr, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC = ?fn (GLintptr, GLintptr, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLGENOCCLUSIONQUERIESNVPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLDELETEOCCLUSIONQUERIESNVPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLISOCCLUSIONQUERYNVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLBEGINOCCLUSIONQUERYNVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLENDOCCLUSIONQUERYNVPROC = ?fn () callconv(.C) void;
pub const PFNGLGETOCCLUSIONQUERYIVNVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETOCCLUSIONQUERYUIVNVPROC = ?fn (GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC = ?fn (GLenum, GLuint, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC = ?fn (GLenum, GLuint, GLuint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC = ?fn (GLenum, GLuint, GLuint, GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENPATHSNVPROC = ?fn (GLsizei) callconv(.C) GLuint;
pub const PFNGLDELETEPATHSNVPROC = ?fn (GLuint, GLsizei) callconv(.C) void;
pub const PFNGLISPATHNVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLPATHCOMMANDSNVPROC = ?fn (GLuint, GLsizei, [*c]const GLubyte, GLsizei, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLPATHCOORDSNVPROC = ?fn (GLuint, GLsizei, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLPATHSUBCOMMANDSNVPROC = ?fn (GLuint, GLsizei, GLsizei, GLsizei, [*c]const GLubyte, GLsizei, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLPATHSUBCOORDSNVPROC = ?fn (GLuint, GLsizei, GLsizei, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLPATHSTRINGNVPROC = ?fn (GLuint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLPATHGLYPHSNVPROC = ?fn (GLuint, GLenum, ?*const c_void, GLbitfield, GLsizei, GLenum, ?*const c_void, GLenum, GLuint, GLfloat) callconv(.C) void;
pub const PFNGLPATHGLYPHRANGENVPROC = ?fn (GLuint, GLenum, ?*const c_void, GLbitfield, GLuint, GLsizei, GLenum, GLuint, GLfloat) callconv(.C) void;
pub const PFNGLWEIGHTPATHSNVPROC = ?fn (GLuint, GLsizei, [*c]const GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCOPYPATHNVPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLINTERPOLATEPATHSNVPROC = ?fn (GLuint, GLuint, GLuint, GLfloat) callconv(.C) void;
pub const PFNGLTRANSFORMPATHNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPATHPARAMETERIVNVPROC = ?fn (GLuint, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLPATHPARAMETERINVPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLPATHPARAMETERFVNVPROC = ?fn (GLuint, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPATHPARAMETERFNVPROC = ?fn (GLuint, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLPATHDASHARRAYNVPROC = ?fn (GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPATHSTENCILFUNCNVPROC = ?fn (GLenum, GLint, GLuint) callconv(.C) void;
pub const PFNGLPATHSTENCILDEPTHOFFSETNVPROC = ?fn (GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLSTENCILFILLPATHNVPROC = ?fn (GLuint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLSTENCILSTROKEPATHNVPROC = ?fn (GLuint, GLint, GLuint) callconv(.C) void;
pub const PFNGLSTENCILFILLPATHINSTANCEDNVPROC = ?fn (GLsizei, GLenum, ?*const c_void, GLuint, GLenum, GLuint, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC = ?fn (GLsizei, GLenum, ?*const c_void, GLuint, GLint, GLuint, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPATHCOVERDEPTHFUNCNVPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLCOVERFILLPATHNVPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLCOVERSTROKEPATHNVPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLCOVERFILLPATHINSTANCEDNVPROC = ?fn (GLsizei, GLenum, ?*const c_void, GLuint, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCOVERSTROKEPATHINSTANCEDNVPROC = ?fn (GLsizei, GLenum, ?*const c_void, GLuint, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETPATHPARAMETERIVNVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPATHPARAMETERFVNVPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPATHCOMMANDSNVPROC = ?fn (GLuint, [*c]GLubyte) callconv(.C) void;
pub const PFNGLGETPATHCOORDSNVPROC = ?fn (GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPATHDASHARRAYNVPROC = ?fn (GLuint, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPATHMETRICSNVPROC = ?fn (GLbitfield, GLsizei, GLenum, ?*const c_void, GLuint, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPATHMETRICRANGENVPROC = ?fn (GLbitfield, GLuint, GLsizei, GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPATHSPACINGNVPROC = ?fn (GLenum, GLsizei, GLenum, ?*const c_void, GLuint, GLfloat, GLfloat, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLISPOINTINFILLPATHNVPROC = ?fn (GLuint, GLuint, GLfloat, GLfloat) callconv(.C) GLboolean;
pub const PFNGLISPOINTINSTROKEPATHNVPROC = ?fn (GLuint, GLfloat, GLfloat) callconv(.C) GLboolean;
pub const PFNGLGETPATHLENGTHNVPROC = ?fn (GLuint, GLsizei, GLsizei) callconv(.C) GLfloat;
pub const PFNGLPOINTALONGPATHNVPROC = ?fn (GLuint, GLsizei, GLsizei, GLfloat, [*c]GLfloat, [*c]GLfloat, [*c]GLfloat, [*c]GLfloat) callconv(.C) GLboolean;
pub const PFNGLMATRIXLOAD3X2FNVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXLOAD3X3FNVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXMULT3X2FNVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXMULT3X3FNVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLSTENCILTHENCOVERFILLPATHNVPROC = ?fn (GLuint, GLenum, GLuint, GLenum) callconv(.C) void;
pub const PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC = ?fn (GLuint, GLint, GLuint, GLenum) callconv(.C) void;
pub const PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC = ?fn (GLsizei, GLenum, ?*const c_void, GLuint, GLenum, GLuint, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC = ?fn (GLsizei, GLenum, ?*const c_void, GLuint, GLint, GLuint, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPATHGLYPHINDEXRANGENVPROC = ?fn (GLenum, ?*const c_void, GLbitfield, GLuint, GLfloat, [*c]GLuint) callconv(.C) GLenum;
pub const PFNGLPATHGLYPHINDEXARRAYNVPROC = ?fn (GLuint, GLenum, ?*const c_void, GLbitfield, GLuint, GLsizei, GLuint, GLfloat) callconv(.C) GLenum;
pub const PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC = ?fn (GLuint, GLenum, GLsizeiptr, ?*const c_void, GLsizei, GLuint, GLsizei, GLuint, GLfloat) callconv(.C) GLenum;
pub const PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC = ?fn (GLuint, GLint, GLenum, GLint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETPROGRAMRESOURCEFVNVPROC = ?fn (GLuint, GLenum, GLuint, GLsizei, [*c]const GLenum, GLsizei, [*c]GLsizei, [*c]GLfloat) callconv(.C) void;
pub const PFNGLPATHCOLORGENNVPROC = ?fn (GLenum, GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPATHTEXGENNVPROC = ?fn (GLenum, GLenum, GLint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPATHFOGGENNVPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLGETPATHCOLORGENIVNVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPATHCOLORGENFVNVPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPATHTEXGENIVNVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPATHTEXGENFVNVPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLPIXELDATARANGENVPROC = ?fn (GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLFLUSHPIXELDATARANGENVPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLPOINTPARAMETERINVPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLPOINTPARAMETERIVNVPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLPRESENTFRAMEKEYEDNVPROC = ?fn (GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLuint, GLenum, GLuint, GLuint) callconv(.C) void;
pub const PFNGLPRESENTFRAMEDUALFILLNVPROC = ?fn (GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint) callconv(.C) void;
pub const PFNGLGETVIDEOIVNVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVIDEOUIVNVPROC = ?fn (GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETVIDEOI64VNVPROC = ?fn (GLuint, GLenum, [*c]GLint64EXT) callconv(.C) void;
pub const PFNGLGETVIDEOUI64VNVPROC = ?fn (GLuint, GLenum, [*c]GLuint64EXT) callconv(.C) void;
pub const PFNGLPRIMITIVERESTARTNVPROC = ?fn () callconv(.C) void;
pub const PFNGLPRIMITIVERESTARTINDEXNVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLQUERYRESOURCENVPROC = ?fn (GLenum, GLint, GLuint, [*c]GLint) callconv(.C) GLint;
pub const PFNGLGENQUERYRESOURCETAGNVPROC = ?fn (GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLDELETEQUERYRESOURCETAGNVPROC = ?fn (GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLQUERYRESOURCETAGNVPROC = ?fn (GLint, [*c]const GLchar) callconv(.C) void;
pub const PFNGLCOMBINERPARAMETERFVNVPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCOMBINERPARAMETERFNVPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLCOMBINERPARAMETERIVNVPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLCOMBINERPARAMETERINVPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLCOMBINERINPUTNVPROC = ?fn (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLCOMBINEROUTPUTNVPROC = ?fn (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean) callconv(.C) void;
pub const PFNGLFINALCOMBINERINPUTNVPROC = ?fn (GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC = ?fn (GLenum, GLenum, GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC = ?fn (GLenum, GLenum, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC = ?fn (GLenum, GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLCOMBINERSTAGEPARAMETERFVNVPROC = ?fn (GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = ?fn (GLuint, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLRESOLVEDEPTHVALUESNVPROC = ?fn () callconv(.C) void;
pub const PFNGLSCISSOREXCLUSIVENVPROC = ?fn (GLint, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLSCISSOREXCLUSIVEARRAYVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLint) callconv(.C) void;
pub const PFNGLMAKEBUFFERRESIDENTNVPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLMAKEBUFFERNONRESIDENTNVPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLISBUFFERRESIDENTNVPROC = ?fn (GLenum) callconv(.C) GLboolean;
pub const PFNGLMAKENAMEDBUFFERRESIDENTNVPROC = ?fn (GLuint, GLenum) callconv(.C) void;
pub const PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLISNAMEDBUFFERRESIDENTNVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLGETBUFFERPARAMETERUI64VNVPROC = ?fn (GLenum, GLenum, [*c]GLuint64EXT) callconv(.C) void;
pub const PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC = ?fn (GLuint, GLenum, [*c]GLuint64EXT) callconv(.C) void;
pub const PFNGLGETINTEGERUI64VNVPROC = ?fn (GLenum, [*c]GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORMUI64NVPROC = ?fn (GLint, GLuint64EXT) callconv(.C) void;
pub const PFNGLUNIFORMUI64VNVPROC = ?fn (GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMUI64NVPROC = ?fn (GLuint, GLint, GLuint64EXT) callconv(.C) void;
pub const PFNGLPROGRAMUNIFORMUI64VNVPROC = ?fn (GLuint, GLint, GLsizei, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLBINDSHADINGRATEIMAGENVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLGETSHADINGRATEIMAGEPALETTENVPROC = ?fn (GLuint, GLuint, [*c]GLenum) callconv(.C) void;
pub const PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC = ?fn (GLenum, GLuint, GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLSHADINGRATEIMAGEBARRIERNVPROC = ?fn (GLboolean) callconv(.C) void;
pub const PFNGLSHADINGRATEIMAGEPALETTENVPROC = ?fn (GLuint, GLuint, GLsizei, [*c]const GLenum) callconv(.C) void;
pub const PFNGLSHADINGRATESAMPLEORDERNVPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC = ?fn (GLenum, GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLTEXTUREBARRIERNVPROC = ?fn () callconv(.C) void;
pub const PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC = ?fn (GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC = ?fn (GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC = ?fn (GLuint, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC = ?fn (GLuint, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC = ?fn (GLuint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC = ?fn (GLuint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean) callconv(.C) void;
pub const PFNGLBEGINTRANSFORMFEEDBACKNVPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLENDTRANSFORMFEEDBACKNVPROC = ?fn () callconv(.C) void;
pub const PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC = ?fn (GLsizei, [*c]const GLint, GLenum) callconv(.C) void;
pub const PFNGLBINDBUFFERRANGENVPROC = ?fn (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) callconv(.C) void;
pub const PFNGLBINDBUFFEROFFSETNVPROC = ?fn (GLenum, GLuint, GLuint, GLintptr) callconv(.C) void;
pub const PFNGLBINDBUFFERBASENVPROC = ?fn (GLenum, GLuint, GLuint) callconv(.C) void;
pub const PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC = ?fn (GLuint, GLsizei, [*c]const GLint, GLenum) callconv(.C) void;
pub const PFNGLACTIVEVARYINGNVPROC = ?fn (GLuint, [*c]const GLchar) callconv(.C) void;
pub const PFNGLGETVARYINGLOCATIONNVPROC = ?fn (GLuint, [*c]const GLchar) callconv(.C) GLint;
pub const PFNGLGETACTIVEVARYINGNVPROC = ?fn (GLuint, GLuint, GLsizei, [*c]GLsizei, [*c]GLsizei, [*c]GLenum, [*c]GLchar) callconv(.C) void;
pub const PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC = ?fn (GLuint, GLuint, [*c]GLint) callconv(.C) void;
pub const PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC = ?fn (GLsizei, [*c]const GLint, GLsizei, [*c]const GLint, GLenum) callconv(.C) void;
pub const PFNGLBINDTRANSFORMFEEDBACKNVPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETETRANSFORMFEEDBACKSNVPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLGENTRANSFORMFEEDBACKSNVPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLISTRANSFORMFEEDBACKNVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLPAUSETRANSFORMFEEDBACKNVPROC = ?fn () callconv(.C) void;
pub const PFNGLRESUMETRANSFORMFEEDBACKNVPROC = ?fn () callconv(.C) void;
pub const PFNGLDRAWTRANSFORMFEEDBACKNVPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const GLvdpauSurfaceNV = GLintptr;
pub const PFNGLVDPAUINITNVPROC = ?fn (?*const c_void, ?*const c_void) callconv(.C) void;
pub const PFNGLVDPAUFININVPROC = ?fn () callconv(.C) void;
pub const PFNGLVDPAUREGISTERVIDEOSURFACENVPROC = ?fn (?*const c_void, GLenum, GLsizei, [*c]const GLuint) callconv(.C) GLvdpauSurfaceNV;
pub const PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC = ?fn (?*const c_void, GLenum, GLsizei, [*c]const GLuint) callconv(.C) GLvdpauSurfaceNV;
pub const PFNGLVDPAUISSURFACENVPROC = ?fn (GLvdpauSurfaceNV) callconv(.C) GLboolean;
pub const PFNGLVDPAUUNREGISTERSURFACENVPROC = ?fn (GLvdpauSurfaceNV) callconv(.C) void;
pub const PFNGLVDPAUGETSURFACEIVNVPROC = ?fn (GLvdpauSurfaceNV, GLenum, GLsizei, [*c]GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLVDPAUSURFACEACCESSNVPROC = ?fn (GLvdpauSurfaceNV, GLenum) callconv(.C) void;
pub const PFNGLVDPAUMAPSURFACESNVPROC = ?fn (GLsizei, [*c]const GLvdpauSurfaceNV) callconv(.C) void;
pub const PFNGLVDPAUUNMAPSURFACESNVPROC = ?fn (GLsizei, [*c]const GLvdpauSurfaceNV) callconv(.C) void;
pub const PFNGLVDPAUREGISTERVIDEOSURFACEWITHPICTURESTRUCTURENVPROC = ?fn (?*const c_void, GLenum, GLsizei, [*c]const GLuint, GLboolean) callconv(.C) GLvdpauSurfaceNV;
pub const PFNGLFLUSHVERTEXARRAYRANGENVPROC = ?fn () callconv(.C) void;
pub const PFNGLVERTEXARRAYRANGENVPROC = ?fn (GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1I64NVPROC = ?fn (GLuint, GLint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL2I64NVPROC = ?fn (GLuint, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL3I64NVPROC = ?fn (GLuint, GLint64EXT, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL4I64NVPROC = ?fn (GLuint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1I64VNVPROC = ?fn (GLuint, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL2I64VNVPROC = ?fn (GLuint, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL3I64VNVPROC = ?fn (GLuint, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL4I64VNVPROC = ?fn (GLuint, [*c]const GLint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1UI64NVPROC = ?fn (GLuint, GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL2UI64NVPROC = ?fn (GLuint, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL3UI64NVPROC = ?fn (GLuint, GLuint64EXT, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL4UI64NVPROC = ?fn (GLuint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL1UI64VNVPROC = ?fn (GLuint, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL2UI64VNVPROC = ?fn (GLuint, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL3UI64VNVPROC = ?fn (GLuint, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBL4UI64VNVPROC = ?fn (GLuint, [*c]const GLuint64EXT) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBLI64VNVPROC = ?fn (GLuint, GLenum, [*c]GLint64EXT) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBLUI64VNVPROC = ?fn (GLuint, GLenum, [*c]GLuint64EXT) callconv(.C) void;
pub const PFNGLVERTEXATTRIBLFORMATNVPROC = ?fn (GLuint, GLint, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLBUFFERADDRESSRANGENVPROC = ?fn (GLenum, GLuint, GLuint64EXT, GLsizeiptr) callconv(.C) void;
pub const PFNGLVERTEXFORMATNVPROC = ?fn (GLint, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLNORMALFORMATNVPROC = ?fn (GLenum, GLsizei) callconv(.C) void;
pub const PFNGLCOLORFORMATNVPROC = ?fn (GLint, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLINDEXFORMATNVPROC = ?fn (GLenum, GLsizei) callconv(.C) void;
pub const PFNGLTEXCOORDFORMATNVPROC = ?fn (GLint, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLEDGEFLAGFORMATNVPROC = ?fn (GLsizei) callconv(.C) void;
pub const PFNGLSECONDARYCOLORFORMATNVPROC = ?fn (GLint, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLFOGCOORDFORMATNVPROC = ?fn (GLenum, GLsizei) callconv(.C) void;
pub const PFNGLVERTEXATTRIBFORMATNVPROC = ?fn (GLuint, GLint, GLenum, GLboolean, GLsizei) callconv(.C) void;
pub const PFNGLVERTEXATTRIBIFORMATNVPROC = ?fn (GLuint, GLint, GLenum, GLsizei) callconv(.C) void;
pub const PFNGLGETINTEGERUI64I_VNVPROC = ?fn (GLenum, GLuint, [*c]GLuint64EXT) callconv(.C) void;
pub const PFNGLAREPROGRAMSRESIDENTNVPROC = ?fn (GLsizei, [*c]const GLuint, [*c]GLboolean) callconv(.C) GLboolean;
pub const PFNGLBINDPROGRAMNVPROC = ?fn (GLenum, GLuint) callconv(.C) void;
pub const PFNGLDELETEPROGRAMSNVPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLEXECUTEPROGRAMNVPROC = ?fn (GLenum, GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGENPROGRAMSNVPROC = ?fn (GLsizei, [*c]GLuint) callconv(.C) void;
pub const PFNGLGETPROGRAMPARAMETERDVNVPROC = ?fn (GLenum, GLuint, GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETPROGRAMPARAMETERFVNVPROC = ?fn (GLenum, GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETPROGRAMIVNVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPROGRAMSTRINGNVPROC = ?fn (GLuint, GLenum, [*c]GLubyte) callconv(.C) void;
pub const PFNGLGETTRACKMATRIXIVNVPROC = ?fn (GLenum, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBDVNVPROC = ?fn (GLuint, GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBFVNVPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBIVNVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBPOINTERVNVPROC = ?fn (GLuint, GLenum, [*c]?*c_void) callconv(.C) void;
pub const PFNGLISPROGRAMNVPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLLOADPROGRAMNVPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLPROGRAMPARAMETER4DNVPROC = ?fn (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMPARAMETER4DVNVPROC = ?fn (GLenum, GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMPARAMETER4FNVPROC = ?fn (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMPARAMETER4FVNVPROC = ?fn (GLenum, GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLPROGRAMPARAMETERS4DVNVPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLPROGRAMPARAMETERS4FVNVPROC = ?fn (GLenum, GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREQUESTRESIDENTPROGRAMSNVPROC = ?fn (GLsizei, [*c]const GLuint) callconv(.C) void;
pub const PFNGLTRACKMATRIXNVPROC = ?fn (GLenum, GLuint, GLenum, GLenum) callconv(.C) void;
pub const PFNGLVERTEXATTRIBPOINTERNVPROC = ?fn (GLuint, GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1DNVPROC = ?fn (GLuint, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1DVNVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1FNVPROC = ?fn (GLuint, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1FVNVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1SNVPROC = ?fn (GLuint, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB1SVNVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2DNVPROC = ?fn (GLuint, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2DVNVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2FNVPROC = ?fn (GLuint, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2FVNVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2SNVPROC = ?fn (GLuint, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB2SVNVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3DNVPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3DVNVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3FNVPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3FVNVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3SNVPROC = ?fn (GLuint, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB3SVNVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4DNVPROC = ?fn (GLuint, GLdouble, GLdouble, GLdouble, GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4DVNVPROC = ?fn (GLuint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4FNVPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4FVNVPROC = ?fn (GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4SNVPROC = ?fn (GLuint, GLshort, GLshort, GLshort, GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4SVNVPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4UBNVPROC = ?fn (GLuint, GLubyte, GLubyte, GLubyte, GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIB4UBVNVPROC = ?fn (GLuint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS1DVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS1FVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS1SVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS2DVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS2FVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS2SVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS3DVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS3FVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS3SVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS4DVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS4FVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS4SVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBS4UBVNVPROC = ?fn (GLuint, GLsizei, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI1IEXTPROC = ?fn (GLuint, GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI2IEXTPROC = ?fn (GLuint, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI3IEXTPROC = ?fn (GLuint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4IEXTPROC = ?fn (GLuint, GLint, GLint, GLint, GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI1UIEXTPROC = ?fn (GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI2UIEXTPROC = ?fn (GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI3UIEXTPROC = ?fn (GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4UIEXTPROC = ?fn (GLuint, GLuint, GLuint, GLuint, GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI1IVEXTPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI2IVEXTPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI3IVEXTPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4IVEXTPROC = ?fn (GLuint, [*c]const GLint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI1UIVEXTPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI2UIVEXTPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI3UIVEXTPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4UIVEXTPROC = ?fn (GLuint, [*c]const GLuint) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4BVEXTPROC = ?fn (GLuint, [*c]const GLbyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4SVEXTPROC = ?fn (GLuint, [*c]const GLshort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4UBVEXTPROC = ?fn (GLuint, [*c]const GLubyte) callconv(.C) void;
pub const PFNGLVERTEXATTRIBI4USVEXTPROC = ?fn (GLuint, [*c]const GLushort) callconv(.C) void;
pub const PFNGLVERTEXATTRIBIPOINTEREXTPROC = ?fn (GLuint, GLint, GLenum, GLsizei, ?*const c_void) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBIIVEXTPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVERTEXATTRIBIUIVEXTPROC = ?fn (GLuint, GLenum, [*c]GLuint) callconv(.C) void;
pub const PFNGLBEGINVIDEOCAPTURENVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC = ?fn (GLuint, GLuint, GLenum, GLintptrARB) callconv(.C) void;
pub const PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC = ?fn (GLuint, GLuint, GLenum, GLenum, GLuint) callconv(.C) void;
pub const PFNGLENDVIDEOCAPTURENVPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLGETVIDEOCAPTUREIVNVPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVIDEOCAPTURESTREAMIVNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETVIDEOCAPTURESTREAMFVNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETVIDEOCAPTURESTREAMDVNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]GLdouble) callconv(.C) void;
pub const PFNGLVIDEOCAPTURENVPROC = ?fn (GLuint, [*c]GLuint, [*c]GLuint64EXT) callconv(.C) GLenum;
pub const PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC = ?fn (GLuint, GLuint, GLenum, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLVIEWPORTSWIZZLENVPROC = ?fn (GLuint, GLenum, GLenum, GLenum, GLenum) callconv(.C) void;
pub const PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC = ?fn (GLenum, GLenum, GLuint, GLint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLHINTPGIPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLDETAILTEXFUNCSGISPROC = ?fn (GLenum, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETDETAILTEXFUNCSGISPROC = ?fn (GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLFOGFUNCSGISPROC = ?fn (GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETFOGFUNCSGISPROC = ?fn ([*c]GLfloat) callconv(.C) void;
pub const PFNGLSAMPLEMASKSGISPROC = ?fn (GLclampf, GLboolean) callconv(.C) void;
pub const PFNGLSAMPLEPATTERNSGISPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLPIXELTEXGENPARAMETERISGISPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLPIXELTEXGENPARAMETERIVSGISPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLPIXELTEXGENPARAMETERFSGISPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLPIXELTEXGENPARAMETERFVSGISPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC = ?fn (GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC = ?fn (GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLPOINTPARAMETERFSGISPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLPOINTPARAMETERFVSGISPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLSHARPENTEXFUNCSGISPROC = ?fn (GLenum, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLGETSHARPENTEXFUNCSGISPROC = ?fn (GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLTEXIMAGE4DSGISPROC = ?fn (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXSUBIMAGE4DSGISPROC = ?fn (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLTEXTURECOLORMASKSGISPROC = ?fn (GLboolean, GLboolean, GLboolean, GLboolean) callconv(.C) void;
pub const PFNGLGETTEXFILTERFUNCSGISPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLTEXFILTERFUNCSGISPROC = ?fn (GLenum, GLenum, GLsizei, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLASYNCMARKERSGIXPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLFINISHASYNCSGIXPROC = ?fn ([*c]GLuint) callconv(.C) GLint;
pub const PFNGLPOLLASYNCSGIXPROC = ?fn ([*c]GLuint) callconv(.C) GLint;
pub const PFNGLGENASYNCMARKERSSGIXPROC = ?fn (GLsizei) callconv(.C) GLuint;
pub const PFNGLDELETEASYNCMARKERSSGIXPROC = ?fn (GLuint, GLsizei) callconv(.C) void;
pub const PFNGLISASYNCMARKERSGIXPROC = ?fn (GLuint) callconv(.C) GLboolean;
pub const PFNGLFLUSHRASTERSGIXPROC = ?fn () callconv(.C) void;
pub const PFNGLFRAGMENTCOLORMATERIALSGIXPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLFRAGMENTLIGHTFSGIXPROC = ?fn (GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLFRAGMENTLIGHTFVSGIXPROC = ?fn (GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLFRAGMENTLIGHTISGIXPROC = ?fn (GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLFRAGMENTLIGHTIVSGIXPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLFRAGMENTLIGHTMODELFSGIXPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLFRAGMENTLIGHTMODELFVSGIXPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLFRAGMENTLIGHTMODELISGIXPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLFRAGMENTLIGHTMODELIVSGIXPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLFRAGMENTMATERIALFSGIXPROC = ?fn (GLenum, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLFRAGMENTMATERIALFVSGIXPROC = ?fn (GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLFRAGMENTMATERIALISGIXPROC = ?fn (GLenum, GLenum, GLint) callconv(.C) void;
pub const PFNGLFRAGMENTMATERIALIVSGIXPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLGETFRAGMENTLIGHTFVSGIXPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETFRAGMENTLIGHTIVSGIXPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLGETFRAGMENTMATERIALFVSGIXPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETFRAGMENTMATERIALIVSGIXPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLLIGHTENVISGIXPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLFRAMEZOOMSGIXPROC = ?fn (GLint) callconv(.C) void;
pub const PFNGLIGLOOINTERFACESGIXPROC = ?fn (GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLGETINSTRUMENTSSGIXPROC = ?fn () callconv(.C) GLint;
pub const PFNGLINSTRUMENTSBUFFERSGIXPROC = ?fn (GLsizei, [*c]GLint) callconv(.C) void;
pub const PFNGLPOLLINSTRUMENTSSGIXPROC = ?fn ([*c]GLint) callconv(.C) GLint;
pub const PFNGLREADINSTRUMENTSSGIXPROC = ?fn (GLint) callconv(.C) void;
pub const PFNGLSTARTINSTRUMENTSSGIXPROC = ?fn () callconv(.C) void;
pub const PFNGLSTOPINSTRUMENTSSGIXPROC = ?fn (GLint) callconv(.C) void;
pub const PFNGLGETLISTPARAMETERFVSGIXPROC = ?fn (GLuint, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETLISTPARAMETERIVSGIXPROC = ?fn (GLuint, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLLISTPARAMETERFSGIXPROC = ?fn (GLuint, GLenum, GLfloat) callconv(.C) void;
pub const PFNGLLISTPARAMETERFVSGIXPROC = ?fn (GLuint, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLLISTPARAMETERISGIXPROC = ?fn (GLuint, GLenum, GLint) callconv(.C) void;
pub const PFNGLLISTPARAMETERIVSGIXPROC = ?fn (GLuint, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLPIXELTEXGENSGIXPROC = ?fn (GLenum) callconv(.C) void;
pub const PFNGLDEFORMATIONMAP3DSGIXPROC = ?fn (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, [*c]const GLdouble) callconv(.C) void;
pub const PFNGLDEFORMATIONMAP3FSGIXPROC = ?fn (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLDEFORMSGIXPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC = ?fn (GLbitfield) callconv(.C) void;
pub const PFNGLREFERENCEPLANESGIXPROC = ?fn ([*c]const GLdouble) callconv(.C) void;
pub const PFNGLSPRITEPARAMETERFSGIXPROC = ?fn (GLenum, GLfloat) callconv(.C) void;
pub const PFNGLSPRITEPARAMETERFVSGIXPROC = ?fn (GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLSPRITEPARAMETERISGIXPROC = ?fn (GLenum, GLint) callconv(.C) void;
pub const PFNGLSPRITEPARAMETERIVSGIXPROC = ?fn (GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLTAGSAMPLEBUFFERSGIXPROC = ?fn () callconv(.C) void;
pub const PFNGLCOLORTABLESGIPROC = ?fn (GLenum, GLenum, GLsizei, GLenum, GLenum, ?*const c_void) callconv(.C) void;
pub const PFNGLCOLORTABLEPARAMETERFVSGIPROC = ?fn (GLenum, GLenum, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCOLORTABLEPARAMETERIVSGIPROC = ?fn (GLenum, GLenum, [*c]const GLint) callconv(.C) void;
pub const PFNGLCOPYCOLORTABLESGIPROC = ?fn (GLenum, GLenum, GLint, GLint, GLsizei) callconv(.C) void;
pub const PFNGLGETCOLORTABLESGIPROC = ?fn (GLenum, GLenum, GLenum, ?*c_void) callconv(.C) void;
pub const PFNGLGETCOLORTABLEPARAMETERFVSGIPROC = ?fn (GLenum, GLenum, [*c]GLfloat) callconv(.C) void;
pub const PFNGLGETCOLORTABLEPARAMETERIVSGIPROC = ?fn (GLenum, GLenum, [*c]GLint) callconv(.C) void;
pub const PFNGLFINISHTEXTURESUNXPROC = ?fn () callconv(.C) void;
pub const PFNGLGLOBALALPHAFACTORBSUNPROC = ?fn (GLbyte) callconv(.C) void;
pub const PFNGLGLOBALALPHAFACTORSSUNPROC = ?fn (GLshort) callconv(.C) void;
pub const PFNGLGLOBALALPHAFACTORISUNPROC = ?fn (GLint) callconv(.C) void;
pub const PFNGLGLOBALALPHAFACTORFSUNPROC = ?fn (GLfloat) callconv(.C) void;
pub const PFNGLGLOBALALPHAFACTORDSUNPROC = ?fn (GLdouble) callconv(.C) void;
pub const PFNGLGLOBALALPHAFACTORUBSUNPROC = ?fn (GLubyte) callconv(.C) void;
pub const PFNGLGLOBALALPHAFACTORUSSUNPROC = ?fn (GLushort) callconv(.C) void;
pub const PFNGLGLOBALALPHAFACTORUISUNPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLDRAWMESHARRAYSSUNPROC = ?fn (GLenum, GLint, GLsizei, GLsizei) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUISUNPROC = ?fn (GLuint) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUSSUNPROC = ?fn (GLushort) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUBSUNPROC = ?fn (GLubyte) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUIVSUNPROC = ?fn ([*c]const GLuint) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUSVSUNPROC = ?fn ([*c]const GLushort) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUBVSUNPROC = ?fn ([*c]const GLubyte) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEPOINTERSUNPROC = ?fn (GLenum, GLsizei, [*c]?*const c_void) callconv(.C) void;
pub const PFNGLCOLOR4UBVERTEX2FSUNPROC = ?fn (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLCOLOR4UBVERTEX2FVSUNPROC = ?fn ([*c]const GLubyte, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCOLOR4UBVERTEX3FSUNPROC = ?fn (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLCOLOR4UBVERTEX3FVSUNPROC = ?fn ([*c]const GLubyte, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCOLOR3FVERTEX3FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLCOLOR3FVERTEX3FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLNORMAL3FVERTEX3FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLNORMAL3FVERTEX3FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FVERTEX3FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FVERTEX3FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD4FVERTEX4FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD4FVERTEX4FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC = ?fn (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLubyte, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC = ?fn (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC = ?fn ([*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC = ?fn ([*c]const GLuint, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC = ?fn (GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC = ?fn ([*c]const GLuint, [*c]const GLubyte, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC = ?fn ([*c]const GLuint, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC = ?fn ([*c]const GLuint, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC = ?fn ([*c]const GLuint, [*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC = ?fn ([*c]const GLuint, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC = ?fn ([*c]const GLuint, [*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC = ?fn (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) callconv(.C) void;
pub const PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC = ?fn ([*c]const GLuint, [*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat, [*c]const GLfloat) callconv(.C) void;
pub extern fn glBlendEquationSeparateATI(modeRGB: GLenum, modeA: GLenum) void;
pub const PFNGLBLENDEQUATIONSEPARATEATIPROC = ?fn (GLenum, GLenum) callconv(.C) void;
pub const PFNGLEGLIMAGETARGETTEXTURE2DOESPROC = ?fn (GLenum, GLeglImageOES) callconv(.C) void;
pub const PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC = ?fn (GLenum, GLeglImageOES) callconv(.C) void;
pub const Glproc = ?fn () callconv(.C) void;
pub const Vkproc = ?fn () callconv(.C) void;
pub const struct_Monitor = opaque {};
pub const Monitor = struct_Monitor;
pub const struct_Window = opaque {};
pub const Window = struct_Window;
pub const struct_Cursor = opaque {};
pub const Cursor = struct_Cursor;
pub const Errorfun = ?fn (c_int, [*c]const u8) callconv(.C) void;
pub const Windowposfun = ?fn (?*Window, c_int, c_int) callconv(.C) void;
pub const Windowsizefun = ?fn (?*Window, c_int, c_int) callconv(.C) void;
pub const Windowclosefun = ?fn (?*Window) callconv(.C) void;
pub const Windowrefreshfun = ?fn (?*Window) callconv(.C) void;
pub const Windowfocusfun = ?fn (?*Window, c_int) callconv(.C) void;
pub const Windowiconifyfun = ?fn (?*Window, c_int) callconv(.C) void;
pub const Windowmaximizefun = ?fn (?*Window, c_int) callconv(.C) void;
pub const Framebuffersizefun = ?fn (?*Window, c_int, c_int) callconv(.C) void;
pub const Windowcontentscalefun = ?fn (?*Window, f32, f32) callconv(.C) void;
pub const Mousebuttonfun = ?fn (?*Window, c_int, c_int, c_int) callconv(.C) void;
pub const Cursorposfun = ?fn (?*Window, f64, f64) callconv(.C) void;
pub const Cursorenterfun = ?fn (?*Window, c_int) callconv(.C) void;
pub const Scrollfun = ?fn (?*Window, f64, f64) callconv(.C) void;
pub const Keyfun = ?fn (?*Window, c_int, c_int, c_int, c_int) callconv(.C) void;
pub const Charfun = ?fn (?*Window, c_uint) callconv(.C) void;
pub const Charmodsfun = ?fn (?*Window, c_uint, c_int) callconv(.C) void;
pub const Dropfun = ?fn (?*Window, c_int, [*c][*c]const u8) callconv(.C) void;
pub const Monitorfun = ?fn (?*Monitor, c_int) callconv(.C) void;
pub const Joystickfun = ?fn (c_int, c_int) callconv(.C) void;
pub const struct_Vidmode = extern struct {
width: c_int,
height: c_int,
redBits: c_int,
greenBits: c_int,
blueBits: c_int,
refreshRate: c_int,
};
pub const Vidmode = struct_Vidmode;
pub const struct_Gammaramp = extern struct {
red: [*c]c_ushort,
green: [*c]c_ushort,
blue: [*c]c_ushort,
size: c_uint,
};
pub const Gammaramp = struct_Gammaramp;
pub const struct_Image = extern struct {
width: c_int,
height: c_int,
pixels: [*c]u8,
};
pub const Image = struct_Image;
pub const struct_Gamepadstate = extern struct {
buttons: [15]u8,
axes: [6]f32,
};
pub const Gamepadstate = struct_Gamepadstate;
pub extern fn glfwInit() c_int;
pub extern fn glfwTerminate() void;
pub extern fn glfwInitHint(hint: c_int, value: c_int) void;
pub extern fn glfwGetVersion(major: [*c]c_int, minor: [*c]c_int, rev: [*c]c_int) void;
pub extern fn glfwGetVersionString() [*c]const u8;
pub extern fn glfwGetError(description: [*c][*c]const u8) c_int;
pub extern fn glfwSetErrorCallback(callback: Errorfun) Errorfun;
pub extern fn glfwGetMonitors(count: [*c]c_int) [*c]?*Monitor;
pub extern fn glfwGetPrimaryMonitor() ?*Monitor;
pub extern fn glfwGetMonitorPos(monitor: ?*Monitor, xpos: [*c]c_int, ypos: [*c]c_int) void;
pub extern fn glfwGetMonitorWorkarea(monitor: ?*Monitor, xpos: [*c]c_int, ypos: [*c]c_int, width: [*c]c_int, height: [*c]c_int) void;
pub extern fn glfwGetMonitorPhysicalSize(monitor: ?*Monitor, widthMM: [*c]c_int, heightMM: [*c]c_int) void;
pub extern fn glfwGetMonitorContentScale(monitor: ?*Monitor, xscale: [*c]f32, yscale: [*c]f32) void;
pub extern fn glfwGetMonitorName(monitor: ?*Monitor) [*c]const u8;
pub extern fn glfwSetMonitorUserPointer(monitor: ?*Monitor, pointer: ?*c_void) void;
pub extern fn glfwGetMonitorUserPointer(monitor: ?*Monitor) ?*c_void;
pub extern fn glfwSetMonitorCallback(callback: Monitorfun) Monitorfun;
pub extern fn glfwGetVideoModes(monitor: ?*Monitor, count: [*c]c_int) [*c]const Vidmode;
pub extern fn glfwGetVideoMode(monitor: ?*Monitor) [*c]const Vidmode;
pub extern fn glfwSetGamma(monitor: ?*Monitor, gamma: f32) void;
pub extern fn glfwGetGammaRamp(monitor: ?*Monitor) [*c]const Gammaramp;
pub extern fn glfwSetGammaRamp(monitor: ?*Monitor, ramp: [*c]const Gammaramp) void;
pub extern fn glfwDefaultWindowHints() void;
pub extern fn glfwWindowHint(hint: c_int, value: c_int) void;
pub extern fn glfwWindowHintString(hint: c_int, value: [*c]const u8) void;
pub extern fn glfwCreateWindow(width: c_int, height: c_int, title: [*c]const u8, monitor: ?*Monitor, share: ?*Window) ?*Window;
pub extern fn glfwDestroyWindow(window: ?*Window) void;
pub extern fn glfwWindowShouldClose(window: ?*Window) c_int;
pub extern fn glfwSetWindowShouldClose(window: ?*Window, value: c_int) void;
pub extern fn glfwSetWindowTitle(window: ?*Window, title: [*c]const u8) void;
pub extern fn glfwSetWindowIcon(window: ?*Window, count: c_int, images: [*c]const Image) void;
pub extern fn glfwGetWindowPos(window: ?*Window, xpos: [*c]c_int, ypos: [*c]c_int) void;
pub extern fn glfwSetWindowPos(window: ?*Window, xpos: c_int, ypos: c_int) void;
pub extern fn glfwGetWindowSize(window: ?*Window, width: [*c]c_int, height: [*c]c_int) void;
pub extern fn glfwSetWindowSizeLimits(window: ?*Window, minwidth: c_int, minheight: c_int, maxwidth: c_int, maxheight: c_int) void;
pub extern fn glfwSetWindowAspectRatio(window: ?*Window, numer: c_int, denom: c_int) void;
pub extern fn glfwSetWindowSize(window: ?*Window, width: c_int, height: c_int) void;
pub extern fn glfwGetFramebufferSize(window: ?*Window, width: [*c]c_int, height: [*c]c_int) void;
pub extern fn glfwGetWindowFrameSize(window: ?*Window, left: [*c]c_int, top: [*c]c_int, right: [*c]c_int, bottom: [*c]c_int) void;
pub extern fn glfwGetWindowContentScale(window: ?*Window, xscale: [*c]f32, yscale: [*c]f32) void;
pub extern fn glfwGetWindowOpacity(window: ?*Window) f32;
pub extern fn glfwSetWindowOpacity(window: ?*Window, opacity: f32) void;
pub extern fn glfwIconifyWindow(window: ?*Window) void;
pub extern fn glfwRestoreWindow(window: ?*Window) void;
pub extern fn glfwMaximizeWindow(window: ?*Window) void;
pub extern fn glfwShowWindow(window: ?*Window) void;
pub extern fn glfwHideWindow(window: ?*Window) void;
pub extern fn glfwFocusWindow(window: ?*Window) void;
pub extern fn glfwRequestWindowAttention(window: ?*Window) void;
pub extern fn glfwGetWindowMonitor(window: ?*Window) ?*Monitor;
pub extern fn glfwSetWindowMonitor(window: ?*Window, monitor: ?*Monitor, xpos: c_int, ypos: c_int, width: c_int, height: c_int, refreshRate: c_int) void;
pub extern fn glfwGetWindowAttrib(window: ?*Window, attrib: c_int) c_int;
pub extern fn glfwSetWindowAttrib(window: ?*Window, attrib: c_int, value: c_int) void;
pub extern fn glfwSetWindowUserPointer(window: ?*Window, pointer: ?*c_void) void;
pub extern fn glfwGetWindowUserPointer(window: ?*Window) ?*c_void;
pub extern fn glfwSetWindowPosCallback(window: ?*Window, callback: Windowposfun) Windowposfun;
pub extern fn glfwSetWindowSizeCallback(window: ?*Window, callback: Windowsizefun) Windowsizefun;
pub extern fn glfwSetWindowCloseCallback(window: ?*Window, callback: Windowclosefun) Windowclosefun;
pub extern fn glfwSetWindowRefreshCallback(window: ?*Window, callback: Windowrefreshfun) Windowrefreshfun;
pub extern fn glfwSetWindowFocusCallback(window: ?*Window, callback: Windowfocusfun) Windowfocusfun;
pub extern fn glfwSetWindowIconifyCallback(window: ?*Window, callback: Windowiconifyfun) Windowiconifyfun;
pub extern fn glfwSetWindowMaximizeCallback(window: ?*Window, callback: Windowmaximizefun) Windowmaximizefun;
pub extern fn glfwSetFramebufferSizeCallback(window: ?*Window, callback: Framebuffersizefun) Framebuffersizefun;
pub extern fn glfwSetWindowContentScaleCallback(window: ?*Window, callback: Windowcontentscalefun) Windowcontentscalefun;
pub extern fn glfwPollEvents() void;
pub extern fn glfwWaitEvents() void;
pub extern fn glfwWaitEventsTimeout(timeout: f64) void;
pub extern fn glfwPostEmptyEvent() void;
pub extern fn glfwGetInputMode(window: ?*Window, mode: c_int) c_int;
pub extern fn glfwSetInputMode(window: ?*Window, mode: c_int, value: c_int) void;
pub extern fn glfwRawMouseMotionSupported() c_int;
pub extern fn glfwGetKeyName(key: c_int, scancode: c_int) [*c]const u8;
pub extern fn glfwGetKeyScancode(key: c_int) c_int;
pub extern fn glfwGetKey(window: ?*Window, key: c_int) c_int;
pub extern fn glfwGetMouseButton(window: ?*Window, button: c_int) c_int;
pub extern fn glfwGetCursorPos(window: ?*Window, xpos: [*c]f64, ypos: [*c]f64) void;
pub extern fn glfwSetCursorPos(window: ?*Window, xpos: f64, ypos: f64) void;
pub extern fn glfwCreateCursor(image: [*c]const Image, xhot: c_int, yhot: c_int) ?*Cursor;
pub extern fn glfwCreateStandardCursor(shape: c_int) ?*Cursor;
pub extern fn glfwDestroyCursor(cursor: ?*Cursor) void;
pub extern fn glfwSetCursor(window: ?*Window, cursor: ?*Cursor) void;
pub extern fn glfwSetKeyCallback(window: ?*Window, callback: Keyfun) Keyfun;
pub extern fn glfwSetCharCallback(window: ?*Window, callback: Charfun) Charfun;
pub extern fn glfwSetCharModsCallback(window: ?*Window, callback: Charmodsfun) Charmodsfun;
pub extern fn glfwSetMouseButtonCallback(window: ?*Window, callback: Mousebuttonfun) Mousebuttonfun;
pub extern fn glfwSetCursorPosCallback(window: ?*Window, callback: Cursorposfun) Cursorposfun;
pub extern fn glfwSetCursorEnterCallback(window: ?*Window, callback: Cursorenterfun) Cursorenterfun;
pub extern fn glfwSetScrollCallback(window: ?*Window, callback: Scrollfun) Scrollfun;
pub extern fn glfwSetDropCallback(window: ?*Window, callback: Dropfun) Dropfun;
pub extern fn glfwJoystickPresent(jid: c_int) c_int;
pub extern fn glfwGetJoystickAxes(jid: c_int, count: [*c]c_int) [*c]const f32;
pub extern fn glfwGetJoystickButtons(jid: c_int, count: [*c]c_int) [*c]const u8;
pub extern fn glfwGetJoystickHats(jid: c_int, count: [*c]c_int) [*c]const u8;
pub extern fn glfwGetJoystickName(jid: c_int) [*c]const u8;
pub extern fn glfwGetJoystickGUID(jid: c_int) [*c]const u8;
pub extern fn glfwSetJoystickUserPointer(jid: c_int, pointer: ?*c_void) void;
pub extern fn glfwGetJoystickUserPointer(jid: c_int) ?*c_void;
pub extern fn glfwJoystickIsGamepad(jid: c_int) c_int;
pub extern fn glfwSetJoystickCallback(callback: Joystickfun) Joystickfun;
pub extern fn glfwUpdateGamepadMappings(string: [*c]const u8) c_int;
pub extern fn glfwGetGamepadName(jid: c_int) [*c]const u8;
pub extern fn glfwGetGamepadState(jid: c_int, state: [*c]Gamepadstate) c_int;
pub extern fn glfwSetClipboardString(window: ?*Window, string: [*c]const u8) void;
pub extern fn glfwGetClipboardString(window: ?*Window) [*c]const u8;
pub extern fn glfwGetTime() f64;
pub extern fn glfwSetTime(time: f64) void;
pub extern fn glfwGetTimerValue() u64;
pub extern fn glfwGetTimerFrequency() u64;
pub extern fn glfwMakeContextCurrent(window: ?*Window) void;
pub extern fn glfwGetCurrentContext() ?*Window;
pub extern fn glfwSwapBuffers(window: ?*Window) void;
pub extern fn glfwSwapInterval(interval: c_int) void;
pub extern fn glfwExtensionSupported(extension: [*c]const u8) c_int;
pub extern fn glfwGetProcAddress(procname: [*c]const u8) Glproc;
pub extern fn glfwVulkanSupported() c_int;
pub extern fn glfwGetRequiredInstanceExtensions(count: [*c]u32) [*c][*c]const u8;
pub extern fn glfwGetInstanceProcAddress(instance: vk.Instance, procname: [*c]const u8) Vkproc;
pub extern fn glfwGetPhysicalDevicePresentationSupport(instance: vk.Instance, device: vk.PhysicalDevice, queuefamily: u32) c_int;
pub extern fn glfwCreateWindowSurface(instance: vk.Instance, window: ?*Window, allocator: [*c]const vk.AllocationCallbacks, surface: [*c]vk.SurfaceKHR) vk.Result;
pub const GLAPI = __attribute__(visibility("default"));
pub const GL_VERSION_1_1 = 1;
pub const GL_VERSION_1_2 = 1;
pub const GL_VERSION_1_3 = 1;
pub const GL_ARB_imaging = 1;
pub const GL_FALSE = 0;
pub const GL_TRUE = 1;
pub const GL_BYTE = 0x1400;
pub const GL_UNSIGNED_BYTE = 0x1401;
pub const GL_SHORT = 0x1402;
pub const GL_UNSIGNED_SHORT = 0x1403;
pub const GL_INT = 0x1404;
pub const GL_UNSIGNED_INT = 0x1405;
pub const GL_FLOAT = 0x1406;
pub const GL_2_BYTES = 0x1407;
pub const GL_3_BYTES = 0x1408;
pub const GL_4_BYTES = 0x1409;
pub const GL_DOUBLE = 0x140A;
pub const GL_POINTS = 0x0000;
pub const GL_LINES = 0x0001;
pub const GL_LINE_LOOP = 0x0002;
pub const GL_LINE_STRIP = 0x0003;
pub const GL_TRIANGLES = 0x0004;
pub const GL_TRIANGLE_STRIP = 0x0005;
pub const GL_TRIANGLE_FAN = 0x0006;
pub const GL_QUADS = 0x0007;
pub const GL_QUAD_STRIP = 0x0008;
pub const GL_POLYGON = 0x0009;
pub const GL_VERTEX_ARRAY = 0x8074;
pub const GL_NORMAL_ARRAY = 0x8075;
pub const GL_COLOR_ARRAY = 0x8076;
pub const GL_INDEX_ARRAY = 0x8077;
pub const GL_TEXTURE_COORD_ARRAY = 0x8078;
pub const GL_EDGE_FLAG_ARRAY = 0x8079;
pub const GL_VERTEX_ARRAY_SIZE = 0x807A;
pub const GL_VERTEX_ARRAY_TYPE = 0x807B;
pub const GL_VERTEX_ARRAY_STRIDE = 0x807C;
pub const GL_NORMAL_ARRAY_TYPE = 0x807E;
pub const GL_NORMAL_ARRAY_STRIDE = 0x807F;
pub const GL_COLOR_ARRAY_SIZE = 0x8081;
pub const GL_COLOR_ARRAY_TYPE = 0x8082;
pub const GL_COLOR_ARRAY_STRIDE = 0x8083;
pub const GL_INDEX_ARRAY_TYPE = 0x8085;
pub const GL_INDEX_ARRAY_STRIDE = 0x8086;
pub const GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088;
pub const GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089;
pub const GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A;
pub const GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C;
pub const GL_VERTEX_ARRAY_POINTER = 0x808E;
pub const GL_NORMAL_ARRAY_POINTER = 0x808F;
pub const GL_COLOR_ARRAY_POINTER = 0x8090;
pub const GL_INDEX_ARRAY_POINTER = 0x8091;
pub const GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092;
pub const GL_EDGE_FLAG_ARRAY_POINTER = 0x8093;
pub const GL_V2F = 0x2A20;
pub const GL_V3F = 0x2A21;
pub const GL_C4UB_V2F = 0x2A22;
pub const GL_C4UB_V3F = 0x2A23;
pub const GL_C3F_V3F = 0x2A24;
pub const GL_N3F_V3F = 0x2A25;
pub const GL_C4F_N3F_V3F = 0x2A26;
pub const GL_T2F_V3F = 0x2A27;
pub const GL_T4F_V4F = 0x2A28;
pub const GL_T2F_C4UB_V3F = 0x2A29;
pub const GL_T2F_C3F_V3F = 0x2A2A;
pub const GL_T2F_N3F_V3F = 0x2A2B;
pub const GL_T2F_C4F_N3F_V3F = 0x2A2C;
pub const GL_T4F_C4F_N3F_V4F = 0x2A2D;
pub const GL_MATRIX_MODE = 0x0BA0;
pub const GL_MODELVIEW = 0x1700;
pub const GL_PROJECTION = 0x1701;
pub const GL_TEXTURE = 0x1702;
pub const GL_POINT_SMOOTH = 0x0B10;
pub const GL_POINT_SIZE = 0x0B11;
pub const GL_POINT_SIZE_GRANULARITY = 0x0B13;
pub const GL_POINT_SIZE_RANGE = 0x0B12;
pub const GL_LINE_SMOOTH = 0x0B20;
pub const GL_LINE_STIPPLE = 0x0B24;
pub const GL_LINE_STIPPLE_PATTERN = 0x0B25;
pub const GL_LINE_STIPPLE_REPEAT = 0x0B26;
pub const GL_LINE_WIDTH = 0x0B21;
pub const GL_LINE_WIDTH_GRANULARITY = 0x0B23;
pub const GL_LINE_WIDTH_RANGE = 0x0B22;
pub const GL_POINT = 0x1B00;
pub const GL_LINE = 0x1B01;
pub const GL_FILL = 0x1B02;
pub const GL_CW = 0x0900;
pub const GL_CCW = 0x0901;
pub const GL_FRONT = 0x0404;
pub const GL_BACK = 0x0405;
pub const GL_POLYGON_MODE = 0x0B40;
pub const GL_POLYGON_SMOOTH = 0x0B41;
pub const GL_POLYGON_STIPPLE = 0x0B42;
pub const GL_EDGE_FLAG = 0x0B43;
pub const GL_CULL_FACE = 0x0B44;
pub const GL_CULL_FACE_MODE = 0x0B45;
pub const GL_FRONT_FACE = 0x0B46;
pub const GL_POLYGON_OFFSET_FACTOR = 0x8038;
pub const GL_POLYGON_OFFSET_UNITS = 0x2A00;
pub const GL_POLYGON_OFFSET_POINT = 0x2A01;
pub const GL_POLYGON_OFFSET_LINE = 0x2A02;
pub const GL_POLYGON_OFFSET_FILL = 0x8037;
pub const GL_COMPILE = 0x1300;
pub const GL_COMPILE_AND_EXECUTE = 0x1301;
pub const GL_LIST_BASE = 0x0B32;
pub const GL_LIST_INDEX = 0x0B33;
pub const GL_LIST_MODE = 0x0B30;
pub const GL_NEVER = 0x0200;
pub const GL_LESS = 0x0201;
pub const GL_EQUAL = 0x0202;
pub const GL_LEQUAL = 0x0203;
pub const GL_GREATER = 0x0204;
pub const GL_NOTEQUAL = 0x0205;
pub const GL_GEQUAL = 0x0206;
pub const GL_ALWAYS = 0x0207;
pub const GL_DEPTH_TEST = 0x0B71;
pub const GL_DEPTH_BITS = 0x0D56;
pub const GL_DEPTH_CLEAR_VALUE = 0x0B73;
pub const GL_DEPTH_FUNC = 0x0B74;
pub const GL_DEPTH_RANGE = 0x0B70;
pub const GL_DEPTH_WRITEMASK = 0x0B72;
pub const GL_DEPTH_COMPONENT = 0x1902;
pub const GL_LIGHTING = 0x0B50;
pub const GL_LIGHT0 = 0x4000;
pub const GL_LIGHT1 = 0x4001;
pub const GL_LIGHT2 = 0x4002;
pub const GL_LIGHT3 = 0x4003;
pub const GL_LIGHT4 = 0x4004;
pub const GL_LIGHT5 = 0x4005;
pub const GL_LIGHT6 = 0x4006;
pub const GL_LIGHT7 = 0x4007;
pub const GL_SPOT_EXPONENT = 0x1205;
pub const GL_SPOT_CUTOFF = 0x1206;
pub const GL_CONSTANT_ATTENUATION = 0x1207;
pub const GL_LINEAR_ATTENUATION = 0x1208;
pub const GL_QUADRATIC_ATTENUATION = 0x1209;
pub const GL_AMBIENT = 0x1200;
pub const GL_DIFFUSE = 0x1201;
pub const GL_SPECULAR = 0x1202;
pub const GL_SHININESS = 0x1601;
pub const GL_EMISSION = 0x1600;
pub const GL_POSITION = 0x1203;
pub const GL_SPOT_DIRECTION = 0x1204;
pub const GL_AMBIENT_AND_DIFFUSE = 0x1602;
pub const GL_COLOR_INDEXES = 0x1603;
pub const GL_LIGHT_MODEL_TWO_SIDE = 0x0B52;
pub const GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51;
pub const GL_LIGHT_MODEL_AMBIENT = 0x0B53;
pub const GL_FRONT_AND_BACK = 0x0408;
pub const GL_SHADE_MODEL = 0x0B54;
pub const GL_FLAT = 0x1D00;
pub const GL_SMOOTH = 0x1D01;
pub const GL_COLOR_MATERIAL = 0x0B57;
pub const GL_COLOR_MATERIAL_FACE = 0x0B55;
pub const GL_COLOR_MATERIAL_PARAMETER = 0x0B56;
pub const GL_NORMALIZE = 0x0BA1;
pub const GL_CLIP_PLANE0 = 0x3000;
pub const GL_CLIP_PLANE1 = 0x3001;
pub const GL_CLIP_PLANE2 = 0x3002;
pub const GL_CLIP_PLANE3 = 0x3003;
pub const GL_CLIP_PLANE4 = 0x3004;
pub const GL_CLIP_PLANE5 = 0x3005;
pub const GL_ACCUM_RED_BITS = 0x0D58;
pub const GL_ACCUM_GREEN_BITS = 0x0D59;
pub const GL_ACCUM_BLUE_BITS = 0x0D5A;
pub const GL_ACCUM_ALPHA_BITS = 0x0D5B;
pub const GL_ACCUM_CLEAR_VALUE = 0x0B80;
pub const GL_ACCUM = 0x0100;
pub const GL_ADD = 0x0104;
pub const GL_LOAD = 0x0101;
pub const GL_MULT = 0x0103;
pub const GL_RETURN = 0x0102;
pub const GL_ALPHA_TEST = 0x0BC0;
pub const GL_ALPHA_TEST_REF = 0x0BC2;
pub const GL_ALPHA_TEST_FUNC = 0x0BC1;
pub const GL_BLEND = 0x0BE2;
pub const GL_BLEND_SRC = 0x0BE1;
pub const GL_BLEND_DST = 0x0BE0;
pub const GL_ZERO = 0;
pub const GL_ONE = 1;
pub const GL_SRC_COLOR = 0x0300;
pub const GL_ONE_MINUS_SRC_COLOR = 0x0301;
pub const GL_SRC_ALPHA = 0x0302;
pub const GL_ONE_MINUS_SRC_ALPHA = 0x0303;
pub const GL_DST_ALPHA = 0x0304;
pub const GL_ONE_MINUS_DST_ALPHA = 0x0305;
pub const GL_DST_COLOR = 0x0306;
pub const GL_ONE_MINUS_DST_COLOR = 0x0307;
pub const GL_SRC_ALPHA_SATURATE = 0x0308;
pub const GL_FEEDBACK = 0x1C01;
pub const GL_RENDER = 0x1C00;
pub const GL_SELECT = 0x1C02;
pub const GL_2D = 0x0600;
pub const GL_3D = 0x0601;
pub const GL_3D_COLOR = 0x0602;
pub const GL_3D_COLOR_TEXTURE = 0x0603;
pub const GL_4D_COLOR_TEXTURE = 0x0604;
pub const GL_POINT_TOKEN = <PASSWORD>;
pub const GL_LINE_TOKEN = <PASSWORD>;
pub const GL_LINE_RESET_TOKEN = <PASSWORD>;
pub const GL_POLYGON_TOKEN = <PASSWORD>;
pub const GL_BITMAP_TOKEN = <PASSWORD>;
pub const GL_DRAW_PIXEL_TOKEN = <PASSWORD>;
pub const GL_COPY_PIXEL_TOKEN = <PASSWORD>;
pub const GL_PASS_THROUGH_TOKEN = 0x<PASSWORD>;
pub const GL_FEEDBACK_BUFFER_POINTER = 0x0DF0;
pub const GL_FEEDBACK_BUFFER_SIZE = 0x0DF1;
pub const GL_FEEDBACK_BUFFER_TYPE = 0x0DF2;
pub const GL_SELECTION_BUFFER_POINTER = 0x0DF3;
pub const GL_SELECTION_BUFFER_SIZE = 0x0DF4;
pub const GL_FOG = 0x0B60;
pub const GL_FOG_MODE = 0x0B65;
pub const GL_FOG_DENSITY = 0x0B62;
pub const GL_FOG_COLOR = 0x0B66;
pub const GL_FOG_INDEX = 0x0B61;
pub const GL_FOG_START = 0x0B63;
pub const GL_FOG_END = 0x0B64;
pub const GL_LINEAR = 0x2601;
pub const GL_EXP = 0x0800;
pub const GL_EXP2 = 0x0801;
pub const GL_LOGIC_OP = 0x0BF1;
pub const GL_INDEX_LOGIC_OP = 0x0BF1;
pub const GL_COLOR_LOGIC_OP = 0x0BF2;
pub const GL_LOGIC_OP_MODE = 0x0BF0;
pub const GL_CLEAR = 0x1500;
pub const GL_SET = 0x150F;
pub const GL_COPY = 0x1503;
pub const GL_COPY_INVERTED = 0x150C;
pub const GL_NOOP = 0x1505;
pub const GL_INVERT = 0x150A;
pub const GL_AND = 0x1501;
pub const GL_NAND = 0x150E;
pub const GL_OR = 0x1507;
pub const GL_NOR = 0x1508;
pub const GL_XOR = 0x1506;
pub const GL_EQUIV = 0x1509;
pub const GL_AND_REVERSE = 0x1502;
pub const GL_AND_INVERTED = 0x1504;
pub const GL_OR_REVERSE = 0x150B;
pub const GL_OR_INVERTED = 0x150D;
pub const GL_STENCIL_BITS = 0x0D57;
pub const GL_STENCIL_TEST = 0x0B90;
pub const GL_STENCIL_CLEAR_VALUE = 0x0B91;
pub const GL_STENCIL_FUNC = 0x0B92;
pub const GL_STENCIL_VALUE_MASK = 0x0B93;
pub const GL_STENCIL_FAIL = 0x0B94;
pub const GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95;
pub const GL_STENCIL_PASS_DEPTH_PASS = 0x0B96;
pub const GL_STENCIL_REF = 0x0B97;
pub const GL_STENCIL_WRITEMASK = 0x0B98;
pub const GL_STENCIL_INDEX = 0x1901;
pub const GL_KEEP = 0x1E00;
pub const GL_REPLACE = 0x1E01;
pub const GL_INCR = 0x1E02;
pub const GL_DECR = 0x1E03;
pub const GL_NONE = 0;
pub const GL_LEFT = 0x0406;
pub const GL_RIGHT = 0x0407;
pub const GL_FRONT_LEFT = 0x0400;
pub const GL_FRONT_RIGHT = 0x0401;
pub const GL_BACK_LEFT = 0x0402;
pub const GL_BACK_RIGHT = 0x0403;
pub const GL_AUX0 = 0x0409;
pub const GL_AUX1 = 0x040A;
pub const GL_AUX2 = 0x040B;
pub const GL_AUX3 = 0x040C;
pub const GL_COLOR_INDEX = 0x1900;
pub const GL_RED = 0x1903;
pub const GL_GREEN = 0x1904;
pub const GL_BLUE = 0x1905;
pub const GL_ALPHA = 0x1906;
pub const GL_LUMINANCE = 0x1909;
pub const GL_LUMINANCE_ALPHA = 0x190A;
pub const GL_ALPHA_BITS = 0x0D55;
pub const GL_RED_BITS = 0x0D52;
pub const GL_GREEN_BITS = 0x0D53;
pub const GL_BLUE_BITS = 0x0D54;
pub const GL_INDEX_BITS = 0x0D51;
pub const GL_SUBPIXEL_BITS = 0x0D50;
pub const GL_AUX_BUFFERS = 0x0C00;
pub const GL_READ_BUFFER = 0x0C02;
pub const GL_DRAW_BUFFER = 0x0C01;
pub const GL_DOUBLEBUFFER = 0x0C32;
pub const GL_STEREO = 0x0C33;
pub const GL_BITMAP = 0x1A00;
pub const GL_COLOR = 0x1800;
pub const GL_DEPTH = 0x1801;
pub const GL_STENCIL = 0x1802;
pub const GL_DITHER = 0x0BD0;
pub const GL_RGB = 0x1907;
pub const GL_RGBA = 0x1908;
pub const GL_MAX_LIST_NESTING = 0x0B31;
pub const GL_MAX_EVAL_ORDER = 0x0D30;
pub const GL_MAX_LIGHTS = 0x0D31;
pub const GL_MAX_CLIP_PLANES = 0x0D32;
pub const GL_MAX_TEXTURE_SIZE = 0x0D33;
pub const GL_MAX_PIXEL_MAP_TABLE = 0x0D34;
pub const GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35;
pub const GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36;
pub const GL_MAX_NAME_STACK_DEPTH = 0x0D37;
pub const GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38;
pub const GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39;
pub const GL_MAX_VIEWPORT_DIMS = 0x0D3A;
pub const GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B;
pub const GL_ATTRIB_STACK_DEPTH = 0x0BB0;
pub const GL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1;
pub const GL_COLOR_CLEAR_VALUE = 0x0C22;
pub const GL_COLOR_WRITEMASK = 0x0C23;
pub const GL_CURRENT_INDEX = 0x0B01;
pub const GL_CURRENT_COLOR = 0x0B00;
pub const GL_CURRENT_NORMAL = 0x0B02;
pub const GL_CURRENT_RASTER_COLOR = 0x0B04;
pub const GL_CURRENT_RASTER_DISTANCE = 0x0B09;
pub const GL_CURRENT_RASTER_INDEX = 0x0B05;
pub const GL_CURRENT_RASTER_POSITION = 0x0B07;
pub const GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06;
pub const GL_CURRENT_RASTER_POSITION_VALID = 0x0B08;
pub const GL_CURRENT_TEXTURE_COORDS = 0x0B03;
pub const GL_INDEX_CLEAR_VALUE = 0x0C20;
pub const GL_INDEX_MODE = 0x0C30;
pub const GL_INDEX_WRITEMASK = 0x0C21;
pub const GL_MODELVIEW_MATRIX = 0x0BA6;
pub const GL_MODELVIEW_STACK_DEPTH = 0x0BA3;
pub const GL_NAME_STACK_DEPTH = 0x0D70;
pub const GL_PROJECTION_MATRIX = 0x0BA7;
pub const GL_PROJECTION_STACK_DEPTH = 0x0BA4;
pub const GL_RENDER_MODE = 0x0C40;
pub const GL_RGBA_MODE = 0x0C31;
pub const GL_TEXTURE_MATRIX = 0x0BA8;
pub const GL_TEXTURE_STACK_DEPTH = 0x0BA5;
pub const GL_VIEWPORT = 0x0BA2;
pub const GL_AUTO_NORMAL = 0x0D80;
pub const GL_MAP1_COLOR_4 = 0x0D90;
pub const GL_MAP1_INDEX = 0x0D91;
pub const GL_MAP1_NORMAL = 0x0D92;
pub const GL_MAP1_TEXTURE_COORD_1 = 0x0D93;
pub const GL_MAP1_TEXTURE_COORD_2 = 0x0D94;
pub const GL_MAP1_TEXTURE_COORD_3 = 0x0D95;
pub const GL_MAP1_TEXTURE_COORD_4 = 0x0D96;
pub const GL_MAP1_VERTEX_3 = 0x0D97;
pub const GL_MAP1_VERTEX_4 = 0x0D98;
pub const GL_MAP2_COLOR_4 = 0x0DB0;
pub const GL_MAP2_INDEX = 0x0DB1;
pub const GL_MAP2_NORMAL = 0x0DB2;
pub const GL_MAP2_TEXTURE_COORD_1 = 0x0DB3;
pub const GL_MAP2_TEXTURE_COORD_2 = 0x0DB4;
pub const GL_MAP2_TEXTURE_COORD_3 = 0x0DB5;
pub const GL_MAP2_TEXTURE_COORD_4 = 0x0DB6;
pub const GL_MAP2_VERTEX_3 = 0x0DB7;
pub const GL_MAP2_VERTEX_4 = 0x0DB8;
pub const GL_MAP1_GRID_DOMAIN = 0x0DD0;
pub const GL_MAP1_GRID_SEGMENTS = 0x0DD1;
pub const GL_MAP2_GRID_DOMAIN = 0x0DD2;
pub const GL_MAP2_GRID_SEGMENTS = 0x0DD3;
pub const GL_COEFF = 0x0A00;
pub const GL_ORDER = 0x0A01;
pub const GL_DOMAIN = 0x0A02;
pub const GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50;
pub const GL_POINT_SMOOTH_HINT = 0x0C51;
pub const GL_LINE_SMOOTH_HINT = 0x0C52;
pub const GL_POLYGON_SMOOTH_HINT = 0x0C53;
pub const GL_FOG_HINT = 0x0C54;
pub const GL_DONT_CARE = 0x1100;
pub const GL_FASTEST = 0x1101;
pub const GL_NICEST = 0x1102;
pub const GL_SCISSOR_BOX = 0x0C10;
pub const GL_SCISSOR_TEST = 0x0C11;
pub const GL_MAP_COLOR = 0x0D10;
pub const GL_MAP_STENCIL = 0x0D11;
pub const GL_INDEX_SHIFT = 0x0D12;
pub const GL_INDEX_OFFSET = 0x0D13;
pub const GL_RED_SCALE = 0x0D14;
pub const GL_RED_BIAS = 0x0D15;
pub const GL_GREEN_SCALE = 0x0D18;
pub const GL_GREEN_BIAS = 0x0D19;
pub const GL_BLUE_SCALE = 0x0D1A;
pub const GL_BLUE_BIAS = 0x0D1B;
pub const GL_ALPHA_SCALE = 0x0D1C;
pub const GL_ALPHA_BIAS = 0x0D1D;
pub const GL_DEPTH_SCALE = 0x0D1E;
pub const GL_DEPTH_BIAS = 0x0D1F;
pub const GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1;
pub const GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0;
pub const GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2;
pub const GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3;
pub const GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4;
pub const GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5;
pub const GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6;
pub const GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7;
pub const GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8;
pub const GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9;
pub const GL_PIXEL_MAP_S_TO_S = 0x0C71;
pub const GL_PIXEL_MAP_I_TO_I = 0x0C70;
pub const GL_PIXEL_MAP_I_TO_R = 0x0C72;
pub const GL_PIXEL_MAP_I_TO_G = 0x0C73;
pub const GL_PIXEL_MAP_I_TO_B = 0x0C74;
pub const GL_PIXEL_MAP_I_TO_A = 0x0C75;
pub const GL_PIXEL_MAP_R_TO_R = 0x0C76;
pub const GL_PIXEL_MAP_G_TO_G = 0x0C77;
pub const GL_PIXEL_MAP_B_TO_B = 0x0C78;
pub const GL_PIXEL_MAP_A_TO_A = 0x0C79;
pub const GL_PACK_ALIGNMENT = 0x0D05;
pub const GL_PACK_LSB_FIRST = 0x0D01;
pub const GL_PACK_ROW_LENGTH = 0x0D02;
pub const GL_PACK_SKIP_PIXELS = 0x0D04;
pub const GL_PACK_SKIP_ROWS = 0x0D03;
pub const GL_PACK_SWAP_BYTES = 0x0D00;
pub const GL_UNPACK_ALIGNMENT = 0x0CF5;
pub const GL_UNPACK_LSB_FIRST = 0x0CF1;
pub const GL_UNPACK_ROW_LENGTH = 0x0CF2;
pub const GL_UNPACK_SKIP_PIXELS = 0x0CF4;
pub const GL_UNPACK_SKIP_ROWS = 0x0CF3;
pub const GL_UNPACK_SWAP_BYTES = 0x0CF0;
pub const GL_ZOOM_X = 0x0D16;
pub const GL_ZOOM_Y = 0x0D17;
pub const GL_TEXTURE_ENV = 0x2300;
pub const GL_TEXTURE_ENV_MODE = 0x2200;
pub const GL_TEXTURE_1D = 0x0DE0;
pub const GL_TEXTURE_2D = 0x0DE1;
pub const GL_TEXTURE_WRAP_S = 0x2802;
pub const GL_TEXTURE_WRAP_T = 0x2803;
pub const GL_TEXTURE_MAG_FILTER = 0x2800;
pub const GL_TEXTURE_MIN_FILTER = 0x2801;
pub const GL_TEXTURE_ENV_COLOR = 0x2201;
pub const GL_TEXTURE_GEN_S = 0x0C60;
pub const GL_TEXTURE_GEN_T = 0x0C61;
pub const GL_TEXTURE_GEN_R = 0x0C62;
pub const GL_TEXTURE_GEN_Q = 0x0C63;
pub const GL_TEXTURE_GEN_MODE = 0x2500;
pub const GL_TEXTURE_BORDER_COLOR = 0x1004;
pub const GL_TEXTURE_WIDTH = 0x1000;
pub const GL_TEXTURE_HEIGHT = 0x1001;
pub const GL_TEXTURE_BORDER = 0x1005;
pub const GL_TEXTURE_COMPONENTS = 0x1003;
pub const GL_TEXTURE_RED_SIZE = 0x805C;
pub const GL_TEXTURE_GREEN_SIZE = 0x805D;
pub const GL_TEXTURE_BLUE_SIZE = 0x805E;
pub const GL_TEXTURE_ALPHA_SIZE = 0x805F;
pub const GL_TEXTURE_LUMINANCE_SIZE = 0x8060;
pub const GL_TEXTURE_INTENSITY_SIZE = 0x8061;
pub const GL_NEAREST_MIPMAP_NEAREST = 0x2700;
pub const GL_NEAREST_MIPMAP_LINEAR = 0x2702;
pub const GL_LINEAR_MIPMAP_NEAREST = 0x2701;
pub const GL_LINEAR_MIPMAP_LINEAR = 0x2703;
pub const GL_OBJECT_LINEAR = 0x2401;
pub const GL_OBJECT_PLANE = 0x2501;
pub const GL_EYE_LINEAR = 0x2400;
pub const GL_EYE_PLANE = 0x2502;
pub const GL_SPHERE_MAP = 0x2402;
pub const GL_DECAL = 0x2101;
pub const GL_MODULATE = 0x2100;
pub const GL_NEAREST = 0x2600;
pub const GL_REPEAT = 0x2901;
pub const GL_CLAMP = 0x2900;
pub const GL_S = 0x2000;
pub const GL_T = 0x2001;
pub const GL_R = 0x2002;
pub const GL_Q = 0x2003;
pub const GL_VENDOR = 0x1F00;
pub const GL_RENDERER = 0x1F01;
pub const GL_VERSION = 0x1F02;
pub const GL_EXTENSIONS = 0x1F03;
pub const GL_NO_ERROR = 0;
pub const GL_INVALID_ENUM = 0x0500;
pub const GL_INVALID_VALUE = 0x0501;
pub const GL_INVALID_OPERATION = 0x0502;
pub const GL_STACK_OVERFLOW = 0x0503;
pub const GL_STACK_UNDERFLOW = 0x0504;
pub const GL_OUT_OF_MEMORY = 0x0505;
pub const GL_CURRENT_BIT = 0x00000001;
pub const GL_POINT_BIT = 0x00000002;
pub const GL_LINE_BIT = 0x00000004;
pub const GL_POLYGON_BIT = 0x00000008;
pub const GL_POLYGON_STIPPLE_BIT = 0x00000010;
pub const GL_PIXEL_MODE_BIT = 0x00000020;
pub const GL_LIGHTING_BIT = 0x00000040;
pub const GL_FOG_BIT = 0x00000080;
pub const GL_DEPTH_BUFFER_BIT = 0x00000100;
pub const GL_ACCUM_BUFFER_BIT = 0x00000200;
pub const GL_STENCIL_BUFFER_BIT = 0x00000400;
pub const GL_VIEWPORT_BIT = 0x00000800;
pub const GL_TRANSFORM_BIT = 0x00001000;
pub const GL_ENABLE_BIT = 0x00002000;
pub const GL_COLOR_BUFFER_BIT = 0x00004000;
pub const GL_HINT_BIT = 0x00008000;
pub const GL_EVAL_BIT = 0x00010000;
pub const GL_LIST_BIT = 0x00020000;
pub const GL_TEXTURE_BIT = 0x00040000;
pub const GL_SCISSOR_BIT = 0x00080000;
pub const GL_ALL_ATTRIB_BITS = 0xFFFFFFFF;
pub const GL_PROXY_TEXTURE_1D = 0x8063;
pub const GL_PROXY_TEXTURE_2D = 0x8064;
pub const GL_TEXTURE_PRIORITY = 0x8066;
pub const GL_TEXTURE_RESIDENT = 0x8067;
pub const GL_TEXTURE_BINDING_1D = 0x8068;
pub const GL_TEXTURE_BINDING_2D = 0x8069;
pub const GL_TEXTURE_INTERNAL_FORMAT = 0x1003;
pub const GL_ALPHA4 = 0x803B;
pub const GL_ALPHA8 = 0x803C;
pub const GL_ALPHA12 = 0x803D;
pub const GL_ALPHA16 = 0x803E;
pub const GL_LUMINANCE4 = 0x803F;
pub const GL_LUMINANCE8 = 0x8040;
pub const GL_LUMINANCE12 = 0x8041;
pub const GL_LUMINANCE16 = 0x8042;
pub const GL_LUMINANCE4_ALPHA4 = 0x8043;
pub const GL_LUMINANCE6_ALPHA2 = 0x8044;
pub const GL_LUMINANCE8_ALPHA8 = 0x8045;
pub const GL_LUMINANCE12_ALPHA4 = 0x8046;
pub const GL_LUMINANCE12_ALPHA12 = 0x8047;
pub const GL_LUMINANCE16_ALPHA16 = 0x8048;
pub const GL_INTENSITY = 0x8049;
pub const GL_INTENSITY4 = 0x804A;
pub const GL_INTENSITY8 = 0x804B;
pub const GL_INTENSITY12 = 0x804C;
pub const GL_INTENSITY16 = 0x804D;
pub const GL_R3_G3_B2 = 0x2A10;
pub const GL_RGB4 = 0x804F;
pub const GL_RGB5 = 0x8050;
pub const GL_RGB8 = 0x8051;
pub const GL_RGB10 = 0x8052;
pub const GL_RGB12 = 0x8053;
pub const GL_RGB16 = 0x8054;
pub const GL_RGBA2 = 0x8055;
pub const GL_RGBA4 = 0x8056;
pub const GL_RGB5_A1 = 0x8057;
pub const GL_RGBA8 = 0x8058;
pub const GL_RGB10_A2 = 0x8059;
pub const GL_RGBA12 = 0x805A;
pub const GL_RGBA16 = 0x805B;
pub const GL_CLIENT_PIXEL_STORE_BIT = 0x00000001;
pub const GL_CLIENT_VERTEX_ARRAY_BIT = 0x00000002;
pub const GL_ALL_CLIENT_ATTRIB_BITS = 0xFFFFFFFF;
pub const GL_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF;
pub const GL_RESCALE_NORMAL = 0x803A;
pub const GL_CLAMP_TO_EDGE = 0x812F;
pub const GL_MAX_ELEMENTS_VERTICES = 0x80E8;
pub const GL_MAX_ELEMENTS_INDICES = 0x80E9;
pub const GL_BGR = 0x80E0;
pub const GL_BGRA = 0x80E1;
pub const GL_UNSIGNED_BYTE_3_3_2 = 0x8032;
pub const GL_UNSIGNED_BYTE_2_3_3_REV = 0x8362;
pub const GL_UNSIGNED_SHORT_5_6_5 = 0x8363;
pub const GL_UNSIGNED_SHORT_5_6_5_REV = 0x8364;
pub const GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033;
pub const GL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365;
pub const GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034;
pub const GL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366;
pub const GL_UNSIGNED_INT_8_8_8_8 = 0x8035;
pub const GL_UNSIGNED_INT_8_8_8_8_REV = 0x8367;
pub const GL_UNSIGNED_INT_10_10_10_2 = 0x8036;
pub const GL_UNSIGNED_INT_2_10_10_10_REV = 0x8368;
pub const GL_LIGHT_MODEL_COLOR_CONTROL = 0x81F8;
pub const GL_SINGLE_COLOR = 0x81F9;
pub const GL_SEPARATE_SPECULAR_COLOR = 0x81FA;
pub const GL_TEXTURE_MIN_LOD = 0x813A;
pub const GL_TEXTURE_MAX_LOD = 0x813B;
pub const GL_TEXTURE_BASE_LEVEL = 0x813C;
pub const GL_TEXTURE_MAX_LEVEL = 0x813D;
pub const GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12;
pub const GL_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13;
pub const GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22;
pub const GL_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23;
pub const GL_ALIASED_POINT_SIZE_RANGE = 0x846D;
pub const GL_ALIASED_LINE_WIDTH_RANGE = 0x846E;
pub const GL_PACK_SKIP_IMAGES = 0x806B;
pub const GL_PACK_IMAGE_HEIGHT = 0x806C;
pub const GL_UNPACK_SKIP_IMAGES = 0x806D;
pub const GL_UNPACK_IMAGE_HEIGHT = 0x806E;
pub const GL_TEXTURE_3D = 0x806F;
pub const GL_PROXY_TEXTURE_3D = 0x8070;
pub const GL_TEXTURE_DEPTH = 0x8071;
pub const GL_TEXTURE_WRAP_R = 0x8072;
pub const GL_MAX_3D_TEXTURE_SIZE = 0x8073;
pub const GL_TEXTURE_BINDING_3D = 0x806A;
pub const GL_CONSTANT_COLOR = 0x8001;
pub const GL_ONE_MINUS_CONSTANT_COLOR = 0x8002;
pub const GL_CONSTANT_ALPHA = 0x8003;
pub const GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004;
pub const GL_COLOR_TABLE = 0x80D0;
pub const GL_POST_CONVOLUTION_COLOR_TABLE = 0x80D1;
pub const GL_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2;
pub const GL_PROXY_COLOR_TABLE = 0x80D3;
pub const GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4;
pub const GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5;
pub const GL_COLOR_TABLE_SCALE = 0x80D6;
pub const GL_COLOR_TABLE_BIAS = 0x80D7;
pub const GL_COLOR_TABLE_FORMAT = 0x80D8;
pub const GL_COLOR_TABLE_WIDTH = 0x80D9;
pub const GL_COLOR_TABLE_RED_SIZE = 0x80DA;
pub const GL_COLOR_TABLE_GREEN_SIZE = 0x80DB;
pub const GL_COLOR_TABLE_BLUE_SIZE = 0x80DC;
pub const GL_COLOR_TABLE_ALPHA_SIZE = 0x80DD;
pub const GL_COLOR_TABLE_LUMINANCE_SIZE = 0x80DE;
pub const GL_COLOR_TABLE_INTENSITY_SIZE = 0x80DF;
pub const GL_CONVOLUTION_1D = 0x8010;
pub const GL_CONVOLUTION_2D = 0x8011;
pub const GL_SEPARABLE_2D = 0x8012;
pub const GL_CONVOLUTION_BORDER_MODE = 0x8013;
pub const GL_CONVOLUTION_FILTER_SCALE = 0x8014;
pub const GL_CONVOLUTION_FILTER_BIAS = 0x8015;
pub const GL_REDUCE = 0x8016;
pub const GL_CONVOLUTION_FORMAT = 0x8017;
pub const GL_CONVOLUTION_WIDTH = 0x8018;
pub const GL_CONVOLUTION_HEIGHT = 0x8019;
pub const GL_MAX_CONVOLUTION_WIDTH = 0x801A;
pub const GL_MAX_CONVOLUTION_HEIGHT = 0x801B;
pub const GL_POST_CONVOLUTION_RED_SCALE = 0x801C;
pub const GL_POST_CONVOLUTION_GREEN_SCALE = 0x801D;
pub const GL_POST_CONVOLUTION_BLUE_SCALE = 0x801E;
pub const GL_POST_CONVOLUTION_ALPHA_SCALE = 0x801F;
pub const GL_POST_CONVOLUTION_RED_BIAS = 0x8020;
pub const GL_POST_CONVOLUTION_GREEN_BIAS = 0x8021;
pub const GL_POST_CONVOLUTION_BLUE_BIAS = 0x8022;
pub const GL_POST_CONVOLUTION_ALPHA_BIAS = 0x8023;
pub const GL_CONSTANT_BORDER = 0x8151;
pub const GL_REPLICATE_BORDER = 0x8153;
pub const GL_CONVOLUTION_BORDER_COLOR = 0x8154;
pub const GL_COLOR_MATRIX = 0x80B1;
pub const GL_COLOR_MATRIX_STACK_DEPTH = 0x80B2;
pub const GL_MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3;
pub const GL_POST_COLOR_MATRIX_RED_SCALE = 0x80B4;
pub const GL_POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5;
pub const GL_POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6;
pub const GL_POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7;
pub const GL_POST_COLOR_MATRIX_RED_BIAS = 0x80B8;
pub const GL_POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9;
pub const GL_POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA;
pub const GL_POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB;
pub const GL_HISTOGRAM = 0x8024;
pub const GL_PROXY_HISTOGRAM = 0x8025;
pub const GL_HISTOGRAM_WIDTH = 0x8026;
pub const GL_HISTOGRAM_FORMAT = 0x8027;
pub const GL_HISTOGRAM_RED_SIZE = 0x8028;
pub const GL_HISTOGRAM_GREEN_SIZE = 0x8029;
pub const GL_HISTOGRAM_BLUE_SIZE = 0x802A;
pub const GL_HISTOGRAM_ALPHA_SIZE = 0x802B;
pub const GL_HISTOGRAM_LUMINANCE_SIZE = 0x802C;
pub const GL_HISTOGRAM_SINK = 0x802D;
pub const GL_MINMAX = 0x802E;
pub const GL_MINMAX_FORMAT = 0x802F;
pub const GL_MINMAX_SINK = 0x8030;
pub const GL_TABLE_TOO_LARGE = 0x8031;
pub const GL_BLEND_EQUATION = 0x8009;
pub const GL_MIN = 0x8007;
pub const GL_MAX = 0x8008;
pub const GL_FUNC_ADD = 0x8006;
pub const GL_FUNC_SUBTRACT = 0x800A;
pub const GL_FUNC_REVERSE_SUBTRACT = 0x800B;
pub const GL_BLEND_COLOR = 0x8005;
pub const GL_TEXTURE0 = 0x84C0;
pub const GL_TEXTURE1 = 0x84C1;
pub const GL_TEXTURE2 = 0x84C2;
pub const GL_TEXTURE3 = 0x84C3;
pub const GL_TEXTURE4 = 0x84C4;
pub const GL_TEXTURE5 = 0x84C5;
pub const GL_TEXTURE6 = 0x84C6;
pub const GL_TEXTURE7 = 0x84C7;
pub const GL_TEXTURE8 = 0x84C8;
pub const GL_TEXTURE9 = 0x84C9;
pub const GL_TEXTURE10 = 0x84CA;
pub const GL_TEXTURE11 = 0x84CB;
pub const GL_TEXTURE12 = 0x84CC;
pub const GL_TEXTURE13 = 0x84CD;
pub const GL_TEXTURE14 = 0x84CE;
pub const GL_TEXTURE15 = 0x84CF;
pub const GL_TEXTURE16 = 0x84D0;
pub const GL_TEXTURE17 = 0x84D1;
pub const GL_TEXTURE18 = 0x84D2;
pub const GL_TEXTURE19 = 0x84D3;
pub const GL_TEXTURE20 = 0x84D4;
pub const GL_TEXTURE21 = 0x84D5;
pub const GL_TEXTURE22 = 0x84D6;
pub const GL_TEXTURE23 = 0x84D7;
pub const GL_TEXTURE24 = 0x84D8;
pub const GL_TEXTURE25 = 0x84D9;
pub const GL_TEXTURE26 = 0x84DA;
pub const GL_TEXTURE27 = 0x84DB;
pub const GL_TEXTURE28 = 0x84DC;
pub const GL_TEXTURE29 = 0x84DD;
pub const GL_TEXTURE30 = 0x84DE;
pub const GL_TEXTURE31 = 0x84DF;
pub const GL_ACTIVE_TEXTURE = 0x84E0;
pub const GL_CLIENT_ACTIVE_TEXTURE = 0x84E1;
pub const GL_MAX_TEXTURE_UNITS = 0x84E2;
pub const GL_NORMAL_MAP = 0x8511;
pub const GL_REFLECTION_MAP = 0x8512;
pub const GL_TEXTURE_CUBE_MAP = 0x8513;
pub const GL_TEXTURE_BINDING_CUBE_MAP = 0x8514;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A;
pub const GL_PROXY_TEXTURE_CUBE_MAP = 0x851B;
pub const GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C;
pub const GL_COMPRESSED_ALPHA = 0x84E9;
pub const GL_COMPRESSED_LUMINANCE = 0x84EA;
pub const GL_COMPRESSED_LUMINANCE_ALPHA = 0x84EB;
pub const GL_COMPRESSED_INTENSITY = 0x84EC;
pub const GL_COMPRESSED_RGB = 0x84ED;
pub const GL_COMPRESSED_RGBA = 0x84EE;
pub const GL_TEXTURE_COMPRESSION_HINT = 0x84EF;
pub const GL_TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0;
pub const GL_TEXTURE_COMPRESSED = 0x86A1;
pub const GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
pub const GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3;
pub const GL_MULTISAMPLE = 0x809D;
pub const GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E;
pub const GL_SAMPLE_ALPHA_TO_ONE = 0x809F;
pub const GL_SAMPLE_COVERAGE = 0x80A0;
pub const GL_SAMPLE_BUFFERS = 0x80A8;
pub const GL_SAMPLES = 0x80A9;
pub const GL_SAMPLE_COVERAGE_VALUE = 0x80AA;
pub const GL_SAMPLE_COVERAGE_INVERT = 0x80AB;
pub const GL_MULTISAMPLE_BIT = 0x20000000;
pub const GL_TRANSPOSE_MODELVIEW_MATRIX = 0x84E3;
pub const GL_TRANSPOSE_PROJECTION_MATRIX = 0x84E4;
pub const GL_TRANSPOSE_TEXTURE_MATRIX = 0x84E5;
pub const GL_TRANSPOSE_COLOR_MATRIX = 0x84E6;
pub const GL_COMBINE = 0x8570;
pub const GL_COMBINE_RGB = 0x8571;
pub const GL_COMBINE_ALPHA = 0x8572;
pub const GL_SOURCE0_RGB = 0x8580;
pub const GL_SOURCE1_RGB = 0x8581;
pub const GL_SOURCE2_RGB = 0x8582;
pub const GL_SOURCE0_ALPHA = 0x8588;
pub const GL_SOURCE1_ALPHA = 0x8589;
pub const GL_SOURCE2_ALPHA = 0x858A;
pub const GL_OPERAND0_RGB = 0x8590;
pub const GL_OPERAND1_RGB = 0x8591;
pub const GL_OPERAND2_RGB = 0x8592;
pub const GL_OPERAND0_ALPHA = 0x8598;
pub const GL_OPERAND1_ALPHA = 0x8599;
pub const GL_OPERAND2_ALPHA = 0x859A;
pub const GL_RGB_SCALE = 0x8573;
pub const GL_ADD_SIGNED = 0x8574;
pub const GL_INTERPOLATE = 0x8575;
pub const GL_SUBTRACT = 0x84E7;
pub const GL_CONSTANT = 0x8576;
pub const GL_PRIMARY_COLOR = 0x8577;
pub const GL_PREVIOUS = 0x8578;
pub const GL_DOT3_RGB = 0x86AE;
pub const GL_DOT3_RGBA = 0x86AF;
pub const GL_CLAMP_TO_BORDER = 0x812D;
pub const GL_ARB_multitexture = 1;
pub const GL_TEXTURE0_ARB = 0x84C0;
pub const GL_TEXTURE1_ARB = 0x84C1;
pub const GL_TEXTURE2_ARB = 0x84C2;
pub const GL_TEXTURE3_ARB = 0x84C3;
pub const GL_TEXTURE4_ARB = 0x84C4;
pub const GL_TEXTURE5_ARB = 0x84C5;
pub const GL_TEXTURE6_ARB = 0x84C6;
pub const GL_TEXTURE7_ARB = 0x84C7;
pub const GL_TEXTURE8_ARB = 0x84C8;
pub const GL_TEXTURE9_ARB = 0x84C9;
pub const GL_TEXTURE10_ARB = 0x84CA;
pub const GL_TEXTURE11_ARB = 0x84CB;
pub const GL_TEXTURE12_ARB = 0x84CC;
pub const GL_TEXTURE13_ARB = 0x84CD;
pub const GL_TEXTURE14_ARB = 0x84CE;
pub const GL_TEXTURE15_ARB = 0x84CF;
pub const GL_TEXTURE16_ARB = 0x84D0;
pub const GL_TEXTURE17_ARB = 0x84D1;
pub const GL_TEXTURE18_ARB = 0x84D2;
pub const GL_TEXTURE19_ARB = 0x84D3;
pub const GL_TEXTURE20_ARB = 0x84D4;
pub const GL_TEXTURE21_ARB = 0x84D5;
pub const GL_TEXTURE22_ARB = 0x84D6;
pub const GL_TEXTURE23_ARB = 0x84D7;
pub const GL_TEXTURE24_ARB = 0x84D8;
pub const GL_TEXTURE25_ARB = 0x84D9;
pub const GL_TEXTURE26_ARB = 0x84DA;
pub const GL_TEXTURE27_ARB = 0x84DB;
pub const GL_TEXTURE28_ARB = 0x84DC;
pub const GL_TEXTURE29_ARB = 0x84DD;
pub const GL_TEXTURE30_ARB = 0x84DE;
pub const GL_TEXTURE31_ARB = 0x84DF;
pub const GL_ACTIVE_TEXTURE_ARB = 0x84E0;
pub const GL_CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1;
pub const GL_MAX_TEXTURE_UNITS_ARB = 0x84E2;
pub const __gl_glext_h_ = 1;
pub const GL_GLEXT_VERSION = 20190805;
pub const KHRONOS_SUPPORT_INT64 = 1;
pub const KHRONOS_SUPPORT_FLOAT = 1;
pub const KHRONOS_MAX_ENUM = 0x7FFFFFFF;
pub const GL_VERSION_1_4 = 1;
pub const GL_BLEND_DST_RGB = 0x80C8;
pub const GL_BLEND_SRC_RGB = 0x80C9;
pub const GL_BLEND_DST_ALPHA = 0x80CA;
pub const GL_BLEND_SRC_ALPHA = 0x80CB;
pub const GL_POINT_FADE_THRESHOLD_SIZE = 0x8128;
pub const GL_DEPTH_COMPONENT16 = 0x81A5;
pub const GL_DEPTH_COMPONENT24 = 0x81A6;
pub const GL_DEPTH_COMPONENT32 = 0x81A7;
pub const GL_MIRRORED_REPEAT = 0x8370;
pub const GL_MAX_TEXTURE_LOD_BIAS = 0x84FD;
pub const GL_TEXTURE_LOD_BIAS = 0x8501;
pub const GL_INCR_WRAP = 0x8507;
pub const GL_DECR_WRAP = 0x8508;
pub const GL_TEXTURE_DEPTH_SIZE = 0x884A;
pub const GL_TEXTURE_COMPARE_MODE = 0x884C;
pub const GL_TEXTURE_COMPARE_FUNC = 0x884D;
pub const GL_POINT_SIZE_MIN = 0x8126;
pub const GL_POINT_SIZE_MAX = 0x8127;
pub const GL_POINT_DISTANCE_ATTENUATION = 0x8129;
pub const GL_GENERATE_MIPMAP = 0x8191;
pub const GL_GENERATE_MIPMAP_HINT = 0x8192;
pub const GL_FOG_COORDINATE_SOURCE = 0x8450;
pub const GL_FOG_COORDINATE = 0x8451;
pub const GL_FRAGMENT_DEPTH = 0x8452;
pub const GL_CURRENT_FOG_COORDINATE = 0x8453;
pub const GL_FOG_COORDINATE_ARRAY_TYPE = 0x8454;
pub const GL_FOG_COORDINATE_ARRAY_STRIDE = 0x8455;
pub const GL_FOG_COORDINATE_ARRAY_POINTER = 0x8456;
pub const GL_FOG_COORDINATE_ARRAY = 0x8457;
pub const GL_COLOR_SUM = 0x8458;
pub const GL_CURRENT_SECONDARY_COLOR = 0x8459;
pub const GL_SECONDARY_COLOR_ARRAY_SIZE = 0x845A;
pub const GL_SECONDARY_COLOR_ARRAY_TYPE = 0x845B;
pub const GL_SECONDARY_COLOR_ARRAY_STRIDE = 0x845C;
pub const GL_SECONDARY_COLOR_ARRAY_POINTER = 0x845D;
pub const GL_SECONDARY_COLOR_ARRAY = 0x845E;
pub const GL_TEXTURE_FILTER_CONTROL = 0x8500;
pub const GL_DEPTH_TEXTURE_MODE = 0x884B;
pub const GL_COMPARE_R_TO_TEXTURE = 0x884E;
pub const GL_VERSION_1_5 = 1;
pub const GL_BUFFER_SIZE = 0x8764;
pub const GL_BUFFER_USAGE = 0x8765;
pub const GL_QUERY_COUNTER_BITS = 0x8864;
pub const GL_CURRENT_QUERY = 0x8865;
pub const GL_QUERY_RESULT = 0x8866;
pub const GL_QUERY_RESULT_AVAILABLE = 0x8867;
pub const GL_ARRAY_BUFFER = 0x8892;
pub const GL_ELEMENT_ARRAY_BUFFER = 0x8893;
pub const GL_ARRAY_BUFFER_BINDING = 0x8894;
pub const GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895;
pub const GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;
pub const GL_READ_ONLY = 0x88B8;
pub const GL_WRITE_ONLY = 0x88B9;
pub const GL_READ_WRITE = 0x88BA;
pub const GL_BUFFER_ACCESS = 0x88BB;
pub const GL_BUFFER_MAPPED = 0x88BC;
pub const GL_BUFFER_MAP_POINTER = 0x88BD;
pub const GL_STREAM_DRAW = 0x88E0;
pub const GL_STREAM_READ = 0x88E1;
pub const GL_STREAM_COPY = 0x88E2;
pub const GL_STATIC_DRAW = 0x88E4;
pub const GL_STATIC_READ = 0x88E5;
pub const GL_STATIC_COPY = 0x88E6;
pub const GL_DYNAMIC_DRAW = 0x88E8;
pub const GL_DYNAMIC_READ = 0x88E9;
pub const GL_DYNAMIC_COPY = 0x88EA;
pub const GL_SAMPLES_PASSED = 0x8914;
pub const GL_SRC1_ALPHA = 0x8589;
pub const GL_VERTEX_ARRAY_BUFFER_BINDING = 0x8896;
pub const GL_NORMAL_ARRAY_BUFFER_BINDING = 0x8897;
pub const GL_COLOR_ARRAY_BUFFER_BINDING = 0x8898;
pub const GL_INDEX_ARRAY_BUFFER_BINDING = 0x8899;
pub const GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A;
pub const GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B;
pub const GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C;
pub const GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D;
pub const GL_WEIGHT_ARRAY_BUFFER_BINDING = 0x889E;
pub const GL_FOG_COORD_SRC = 0x8450;
pub const GL_FOG_COORD = 0x8451;
pub const GL_CURRENT_FOG_COORD = 0x8453;
pub const GL_FOG_COORD_ARRAY_TYPE = 0x8454;
pub const GL_FOG_COORD_ARRAY_STRIDE = 0x8455;
pub const GL_FOG_COORD_ARRAY_POINTER = 0x8456;
pub const GL_FOG_COORD_ARRAY = 0x8457;
pub const GL_FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D;
pub const GL_SRC0_RGB = 0x8580;
pub const GL_SRC1_RGB = 0x8581;
pub const GL_SRC2_RGB = 0x8582;
pub const GL_SRC0_ALPHA = 0x8588;
pub const GL_SRC2_ALPHA = 0x858A;
pub const GL_VERSION_2_0 = 1;
pub const GL_BLEND_EQUATION_RGB = 0x8009;
pub const GL_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622;
pub const GL_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623;
pub const GL_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624;
pub const GL_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625;
pub const GL_CURRENT_VERTEX_ATTRIB = 0x8626;
pub const GL_VERTEX_PROGRAM_POINT_SIZE = 0x8642;
pub const GL_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645;
pub const GL_STENCIL_BACK_FUNC = 0x8800;
pub const GL_STENCIL_BACK_FAIL = 0x8801;
pub const GL_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802;
pub const GL_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803;
pub const GL_MAX_DRAW_BUFFERS = 0x8824;
pub const GL_DRAW_BUFFER0 = 0x8825;
pub const GL_DRAW_BUFFER1 = 0x8826;
pub const GL_DRAW_BUFFER2 = 0x8827;
pub const GL_DRAW_BUFFER3 = 0x8828;
pub const GL_DRAW_BUFFER4 = 0x8829;
pub const GL_DRAW_BUFFER5 = 0x882A;
pub const GL_DRAW_BUFFER6 = 0x882B;
pub const GL_DRAW_BUFFER7 = 0x882C;
pub const GL_DRAW_BUFFER8 = 0x882D;
pub const GL_DRAW_BUFFER9 = 0x882E;
pub const GL_DRAW_BUFFER10 = 0x882F;
pub const GL_DRAW_BUFFER11 = 0x8830;
pub const GL_DRAW_BUFFER12 = 0x8831;
pub const GL_DRAW_BUFFER13 = 0x8832;
pub const GL_DRAW_BUFFER14 = 0x8833;
pub const GL_DRAW_BUFFER15 = 0x8834;
pub const GL_BLEND_EQUATION_ALPHA = 0x883D;
pub const GL_MAX_VERTEX_ATTRIBS = 0x8869;
pub const GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A;
pub const GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872;
pub const GL_FRAGMENT_SHADER = 0x8B30;
pub const GL_VERTEX_SHADER = 0x8B31;
pub const GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49;
pub const GL_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A;
pub const GL_MAX_VARYING_FLOATS = 0x8B4B;
pub const GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C;
pub const GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;
pub const GL_SHADER_TYPE = 0x8B4F;
pub const GL_FLOAT_VEC2 = 0x8B50;
pub const GL_FLOAT_VEC3 = 0x8B51;
pub const GL_FLOAT_VEC4 = 0x8B52;
pub const GL_INT_VEC2 = 0x8B53;
pub const GL_INT_VEC3 = 0x8B54;
pub const GL_INT_VEC4 = 0x8B55;
pub const GL_BOOL = 0x8B56;
pub const GL_BOOL_VEC2 = 0x8B57;
pub const GL_BOOL_VEC3 = 0x8B58;
pub const GL_BOOL_VEC4 = 0x8B59;
pub const GL_FLOAT_MAT2 = 0x8B5A;
pub const GL_FLOAT_MAT3 = 0x8B5B;
pub const GL_FLOAT_MAT4 = 0x8B5C;
pub const GL_SAMPLER_1D = 0x8B5D;
pub const GL_SAMPLER_2D = 0x8B5E;
pub const GL_SAMPLER_3D = 0x8B5F;
pub const GL_SAMPLER_CUBE = 0x8B60;
pub const GL_SAMPLER_1D_SHADOW = 0x8B61;
pub const GL_SAMPLER_2D_SHADOW = 0x8B62;
pub const GL_DELETE_STATUS = 0x8B80;
pub const GL_COMPILE_STATUS = 0x8B81;
pub const GL_LINK_STATUS = 0x8B82;
pub const GL_VALIDATE_STATUS = 0x8B83;
pub const GL_INFO_LOG_LENGTH = 0x8B84;
pub const GL_ATTACHED_SHADERS = 0x8B85;
pub const GL_ACTIVE_UNIFORMS = 0x8B86;
pub const GL_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87;
pub const GL_SHADER_SOURCE_LENGTH = 0x8B88;
pub const GL_ACTIVE_ATTRIBUTES = 0x8B89;
pub const GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A;
pub const GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B;
pub const GL_SHADING_LANGUAGE_VERSION = 0x8B8C;
pub const GL_CURRENT_PROGRAM = 0x8B8D;
pub const GL_POINT_SPRITE_COORD_ORIGIN = 0x8CA0;
pub const GL_LOWER_LEFT = 0x8CA1;
pub const GL_UPPER_LEFT = 0x8CA2;
pub const GL_STENCIL_BACK_REF = 0x8CA3;
pub const GL_STENCIL_BACK_VALUE_MASK = 0x8CA4;
pub const GL_STENCIL_BACK_WRITEMASK = 0x8CA5;
pub const GL_VERTEX_PROGRAM_TWO_SIDE = 0x8643;
pub const GL_POINT_SPRITE = 0x8861;
pub const GL_COORD_REPLACE = 0x8862;
pub const GL_MAX_TEXTURE_COORDS = 0x8871;
pub const GL_VERSION_2_1 = 1;
pub const GL_PIXEL_PACK_BUFFER = 0x88EB;
pub const GL_PIXEL_UNPACK_BUFFER = 0x88EC;
pub const GL_PIXEL_PACK_BUFFER_BINDING = 0x88ED;
pub const GL_PIXEL_UNPACK_BUFFER_BINDING = 0x88EF;
pub const GL_FLOAT_MAT2x3 = 0x8B65;
pub const GL_FLOAT_MAT2x4 = 0x8B66;
pub const GL_FLOAT_MAT3x2 = 0x8B67;
pub const GL_FLOAT_MAT3x4 = 0x8B68;
pub const GL_FLOAT_MAT4x2 = 0x8B69;
pub const GL_FLOAT_MAT4x3 = 0x8B6A;
pub const GL_SRGB = 0x8C40;
pub const GL_SRGB8 = 0x8C41;
pub const GL_SRGB_ALPHA = 0x8C42;
pub const GL_SRGB8_ALPHA8 = 0x8C43;
pub const GL_COMPRESSED_SRGB = 0x8C48;
pub const GL_COMPRESSED_SRGB_ALPHA = 0x8C49;
pub const GL_CURRENT_RASTER_SECONDARY_COLOR = 0x845F;
pub const GL_SLUMINANCE_ALPHA = 0x8C44;
pub const GL_SLUMINANCE8_ALPHA8 = 0x8C45;
pub const GL_SLUMINANCE = 0x8C46;
pub const GL_SLUMINANCE8 = 0x8C47;
pub const GL_COMPRESSED_SLUMINANCE = 0x8C4A;
pub const GL_COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B;
pub const GL_VERSION_3_0 = 1;
pub const GL_COMPARE_REF_TO_TEXTURE = 0x884E;
pub const GL_CLIP_DISTANCE0 = 0x3000;
pub const GL_CLIP_DISTANCE1 = 0x3001;
pub const GL_CLIP_DISTANCE2 = 0x3002;
pub const GL_CLIP_DISTANCE3 = 0x3003;
pub const GL_CLIP_DISTANCE4 = 0x3004;
pub const GL_CLIP_DISTANCE5 = 0x3005;
pub const GL_CLIP_DISTANCE6 = 0x3006;
pub const GL_CLIP_DISTANCE7 = 0x3007;
pub const GL_MAX_CLIP_DISTANCES = 0x0D32;
pub const GL_MAJOR_VERSION = 0x821B;
pub const GL_MINOR_VERSION = 0x821C;
pub const GL_NUM_EXTENSIONS = 0x821D;
pub const GL_CONTEXT_FLAGS = 0x821E;
pub const GL_COMPRESSED_RED = 0x8225;
pub const GL_COMPRESSED_RG = 0x8226;
pub const GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001;
pub const GL_RGBA32F = 0x8814;
pub const GL_RGB32F = 0x8815;
pub const GL_RGBA16F = 0x881A;
pub const GL_RGB16F = 0x881B;
pub const GL_VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD;
pub const GL_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF;
pub const GL_MIN_PROGRAM_TEXEL_OFFSET = 0x8904;
pub const GL_MAX_PROGRAM_TEXEL_OFFSET = 0x8905;
pub const GL_CLAMP_READ_COLOR = 0x891C;
pub const GL_FIXED_ONLY = 0x891D;
pub const GL_MAX_VARYING_COMPONENTS = 0x8B4B;
pub const GL_TEXTURE_1D_ARRAY = 0x8C18;
pub const GL_PROXY_TEXTURE_1D_ARRAY = 0x8C19;
pub const GL_TEXTURE_2D_ARRAY = 0x8C1A;
pub const GL_PROXY_TEXTURE_2D_ARRAY = 0x8C1B;
pub const GL_TEXTURE_BINDING_1D_ARRAY = 0x8C1C;
pub const GL_TEXTURE_BINDING_2D_ARRAY = 0x8C1D;
pub const GL_R11F_G11F_B10F = 0x8C3A;
pub const GL_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B;
pub const GL_RGB9_E5 = 0x8C3D;
pub const GL_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E;
pub const GL_TEXTURE_SHARED_SIZE = 0x8C3F;
pub const GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F;
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80;
pub const GL_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85;
pub const GL_PRIMITIVES_GENERATED = 0x8C87;
pub const GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88;
pub const GL_RASTERIZER_DISCARD = 0x8C89;
pub const GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A;
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B;
pub const GL_INTERLEAVED_ATTRIBS = 0x8C8C;
pub const GL_SEPARATE_ATTRIBS = 0x8C8D;
pub const GL_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F;
pub const GL_RGBA32UI = 0x8D70;
pub const GL_RGB32UI = 0x8D71;
pub const GL_RGBA16UI = 0x8D76;
pub const GL_RGB16UI = 0x8D77;
pub const GL_RGBA8UI = 0x8D7C;
pub const GL_RGB8UI = 0x8D7D;
pub const GL_RGBA32I = 0x8D82;
pub const GL_RGB32I = 0x8D83;
pub const GL_RGBA16I = 0x8D88;
pub const GL_RGB16I = 0x8D89;
pub const GL_RGBA8I = 0x8D8E;
pub const GL_RGB8I = 0x8D8F;
pub const GL_RED_INTEGER = 0x8D94;
pub const GL_GREEN_INTEGER = 0x8D95;
pub const GL_BLUE_INTEGER = 0x8D96;
pub const GL_RGB_INTEGER = 0x8D98;
pub const GL_RGBA_INTEGER = 0x8D99;
pub const GL_BGR_INTEGER = 0x8D9A;
pub const GL_BGRA_INTEGER = 0x8D9B;
pub const GL_SAMPLER_1D_ARRAY = 0x8DC0;
pub const GL_SAMPLER_2D_ARRAY = 0x8DC1;
pub const GL_SAMPLER_1D_ARRAY_SHADOW = 0x8DC3;
pub const GL_SAMPLER_2D_ARRAY_SHADOW = 0x8DC4;
pub const GL_SAMPLER_CUBE_SHADOW = 0x8DC5;
pub const GL_UNSIGNED_INT_VEC2 = 0x8DC6;
pub const GL_UNSIGNED_INT_VEC3 = 0x8DC7;
pub const GL_UNSIGNED_INT_VEC4 = 0x8DC8;
pub const GL_INT_SAMPLER_1D = 0x8DC9;
pub const GL_INT_SAMPLER_2D = 0x8DCA;
pub const GL_INT_SAMPLER_3D = 0x8DCB;
pub const GL_INT_SAMPLER_CUBE = 0x8DCC;
pub const GL_INT_SAMPLER_1D_ARRAY = 0x8DCE;
pub const GL_INT_SAMPLER_2D_ARRAY = 0x8DCF;
pub const GL_UNSIGNED_INT_SAMPLER_1D = 0x8DD1;
pub const GL_UNSIGNED_INT_SAMPLER_2D = 0x8DD2;
pub const GL_UNSIGNED_INT_SAMPLER_3D = 0x8DD3;
pub const GL_UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4;
pub const GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6;
pub const GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7;
pub const GL_QUERY_WAIT = 0x8E13;
pub const GL_QUERY_NO_WAIT = 0x8E14;
pub const GL_QUERY_BY_REGION_WAIT = 0x8E15;
pub const GL_QUERY_BY_REGION_NO_WAIT = 0x8E16;
pub const GL_BUFFER_ACCESS_FLAGS = 0x911F;
pub const GL_BUFFER_MAP_LENGTH = 0x9120;
pub const GL_BUFFER_MAP_OFFSET = 0x9121;
pub const GL_DEPTH_COMPONENT32F = 0x8CAC;
pub const GL_DEPTH32F_STENCIL8 = 0x8CAD;
pub const GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD;
pub const GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506;
pub const GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210;
pub const GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211;
pub const GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212;
pub const GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213;
pub const GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214;
pub const GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215;
pub const GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216;
pub const GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217;
pub const GL_FRAMEBUFFER_DEFAULT = 0x8218;
pub const GL_FRAMEBUFFER_UNDEFINED = 0x8219;
pub const GL_DEPTH_STENCIL_ATTACHMENT = 0x821A;
pub const GL_MAX_RENDERBUFFER_SIZE = 0x84E8;
pub const GL_DEPTH_STENCIL = 0x84F9;
pub const GL_UNSIGNED_INT_24_8 = 0x84FA;
pub const GL_DEPTH24_STENCIL8 = 0x88F0;
pub const GL_TEXTURE_STENCIL_SIZE = 0x88F1;
pub const GL_TEXTURE_RED_TYPE = 0x8C10;
pub const GL_TEXTURE_GREEN_TYPE = 0x8C11;
pub const GL_TEXTURE_BLUE_TYPE = 0x8C12;
pub const GL_TEXTURE_ALPHA_TYPE = 0x8C13;
pub const GL_TEXTURE_DEPTH_TYPE = 0x8C16;
pub const GL_UNSIGNED_NORMALIZED = 0x8C17;
pub const GL_FRAMEBUFFER_BINDING = 0x8CA6;
pub const GL_DRAW_FRAMEBUFFER_BINDING = 0x8CA6;
pub const GL_RENDERBUFFER_BINDING = 0x8CA7;
pub const GL_READ_FRAMEBUFFER = 0x8CA8;
pub const GL_DRAW_FRAMEBUFFER = 0x8CA9;
pub const GL_READ_FRAMEBUFFER_BINDING = 0x8CAA;
pub const GL_RENDERBUFFER_SAMPLES = 0x8CAB;
pub const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0;
pub const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4;
pub const GL_FRAMEBUFFER_COMPLETE = 0x8CD5;
pub const GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6;
pub const GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;
pub const GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB;
pub const GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC;
pub const GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD;
pub const GL_MAX_COLOR_ATTACHMENTS = 0x8CDF;
pub const GL_COLOR_ATTACHMENT0 = 0x8CE0;
pub const GL_COLOR_ATTACHMENT1 = 0x8CE1;
pub const GL_COLOR_ATTACHMENT2 = 0x8CE2;
pub const GL_COLOR_ATTACHMENT3 = 0x8CE3;
pub const GL_COLOR_ATTACHMENT4 = 0x8CE4;
pub const GL_COLOR_ATTACHMENT5 = 0x8CE5;
pub const GL_COLOR_ATTACHMENT6 = 0x8CE6;
pub const GL_COLOR_ATTACHMENT7 = 0x8CE7;
pub const GL_COLOR_ATTACHMENT8 = 0x8CE8;
pub const GL_COLOR_ATTACHMENT9 = 0x8CE9;
pub const GL_COLOR_ATTACHMENT10 = 0x8CEA;
pub const GL_COLOR_ATTACHMENT11 = 0x8CEB;
pub const GL_COLOR_ATTACHMENT12 = 0x8CEC;
pub const GL_COLOR_ATTACHMENT13 = 0x8CED;
pub const GL_COLOR_ATTACHMENT14 = 0x8CEE;
pub const GL_COLOR_ATTACHMENT15 = 0x8CEF;
pub const GL_COLOR_ATTACHMENT16 = 0x8CF0;
pub const GL_COLOR_ATTACHMENT17 = 0x8CF1;
pub const GL_COLOR_ATTACHMENT18 = 0x8CF2;
pub const GL_COLOR_ATTACHMENT19 = 0x8CF3;
pub const GL_COLOR_ATTACHMENT20 = 0x8CF4;
pub const GL_COLOR_ATTACHMENT21 = 0x8CF5;
pub const GL_COLOR_ATTACHMENT22 = 0x8CF6;
pub const GL_COLOR_ATTACHMENT23 = 0x8CF7;
pub const GL_COLOR_ATTACHMENT24 = 0x8CF8;
pub const GL_COLOR_ATTACHMENT25 = 0x8CF9;
pub const GL_COLOR_ATTACHMENT26 = 0x8CFA;
pub const GL_COLOR_ATTACHMENT27 = 0x8CFB;
pub const GL_COLOR_ATTACHMENT28 = 0x8CFC;
pub const GL_COLOR_ATTACHMENT29 = 0x8CFD;
pub const GL_COLOR_ATTACHMENT30 = 0x8CFE;
pub const GL_COLOR_ATTACHMENT31 = 0x8CFF;
pub const GL_DEPTH_ATTACHMENT = 0x8D00;
pub const GL_STENCIL_ATTACHMENT = 0x8D20;
pub const GL_FRAMEBUFFER = 0x8D40;
pub const GL_RENDERBUFFER = 0x8D41;
pub const GL_RENDERBUFFER_WIDTH = 0x8D42;
pub const GL_RENDERBUFFER_HEIGHT = 0x8D43;
pub const GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44;
pub const GL_STENCIL_INDEX1 = 0x8D46;
pub const GL_STENCIL_INDEX4 = 0x8D47;
pub const GL_STENCIL_INDEX8 = 0x8D48;
pub const GL_STENCIL_INDEX16 = 0x8D49;
pub const GL_RENDERBUFFER_RED_SIZE = 0x8D50;
pub const GL_RENDERBUFFER_GREEN_SIZE = 0x8D51;
pub const GL_RENDERBUFFER_BLUE_SIZE = 0x8D52;
pub const GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53;
pub const GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54;
pub const GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55;
pub const GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56;
pub const GL_MAX_SAMPLES = 0x8D57;
pub const GL_INDEX = 0x8222;
pub const GL_TEXTURE_LUMINANCE_TYPE = 0x8C14;
pub const GL_TEXTURE_INTENSITY_TYPE = 0x8C15;
pub const GL_FRAMEBUFFER_SRGB = 0x8DB9;
pub const GL_HALF_FLOAT = 0x140B;
pub const GL_MAP_READ_BIT = 0x0001;
pub const GL_MAP_WRITE_BIT = 0x0002;
pub const GL_MAP_INVALIDATE_RANGE_BIT = 0x0004;
pub const GL_MAP_INVALIDATE_BUFFER_BIT = 0x0008;
pub const GL_MAP_FLUSH_EXPLICIT_BIT = 0x0010;
pub const GL_MAP_UNSYNCHRONIZED_BIT = 0x0020;
pub const GL_COMPRESSED_RED_RGTC1 = 0x8DBB;
pub const GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC;
pub const GL_COMPRESSED_RG_RGTC2 = 0x8DBD;
pub const GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE;
pub const GL_RG = 0x8227;
pub const GL_RG_INTEGER = 0x8228;
pub const GL_R8 = 0x8229;
pub const GL_R16 = 0x822A;
pub const GL_RG8 = 0x822B;
pub const GL_RG16 = 0x822C;
pub const GL_R16F = 0x822D;
pub const GL_R32F = 0x822E;
pub const GL_RG16F = 0x822F;
pub const GL_RG32F = 0x8230;
pub const GL_R8I = 0x8231;
pub const GL_R8UI = 0x8232;
pub const GL_R16I = 0x8233;
pub const GL_R16UI = 0x8234;
pub const GL_R32I = 0x8235;
pub const GL_R32UI = 0x8236;
pub const GL_RG8I = 0x8237;
pub const GL_RG8UI = 0x8238;
pub const GL_RG16I = 0x8239;
pub const GL_RG16UI = 0x823A;
pub const GL_RG32I = 0x823B;
pub const GL_RG32UI = 0x823C;
pub const GL_VERTEX_ARRAY_BINDING = 0x85B5;
pub const GL_CLAMP_VERTEX_COLOR = 0x891A;
pub const GL_CLAMP_FRAGMENT_COLOR = 0x891B;
pub const GL_ALPHA_INTEGER = 0x8D97;
pub const GL_VERSION_3_1 = 1;
pub const GL_SAMPLER_2D_RECT = 0x8B63;
pub const GL_SAMPLER_2D_RECT_SHADOW = 0x8B64;
pub const GL_SAMPLER_BUFFER = 0x8DC2;
pub const GL_INT_SAMPLER_2D_RECT = 0x8DCD;
pub const GL_INT_SAMPLER_BUFFER = 0x8DD0;
pub const GL_UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5;
pub const GL_UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8;
pub const GL_TEXTURE_BUFFER = 0x8C2A;
pub const GL_MAX_TEXTURE_BUFFER_SIZE = 0x8C2B;
pub const GL_TEXTURE_BINDING_BUFFER = 0x8C2C;
pub const GL_TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D;
pub const GL_TEXTURE_RECTANGLE = 0x84F5;
pub const GL_TEXTURE_BINDING_RECTANGLE = 0x84F6;
pub const GL_PROXY_TEXTURE_RECTANGLE = 0x84F7;
pub const GL_MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8;
pub const GL_R8_SNORM = 0x8F94;
pub const GL_RG8_SNORM = 0x8F95;
pub const GL_RGB8_SNORM = 0x8F96;
pub const GL_RGBA8_SNORM = 0x8F97;
pub const GL_R16_SNORM = 0x8F98;
pub const GL_RG16_SNORM = 0x8F99;
pub const GL_RGB16_SNORM = 0x8F9A;
pub const GL_RGBA16_SNORM = 0x8F9B;
pub const GL_SIGNED_NORMALIZED = 0x8F9C;
pub const GL_PRIMITIVE_RESTART = 0x8F9D;
pub const GL_PRIMITIVE_RESTART_INDEX = 0x8F9E;
pub const GL_COPY_READ_BUFFER = 0x8F36;
pub const GL_COPY_WRITE_BUFFER = 0x8F37;
pub const GL_UNIFORM_BUFFER = 0x8A11;
pub const GL_UNIFORM_BUFFER_BINDING = 0x8A28;
pub const GL_UNIFORM_BUFFER_START = 0x8A29;
pub const GL_UNIFORM_BUFFER_SIZE = 0x8A2A;
pub const GL_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B;
pub const GL_MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C;
pub const GL_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D;
pub const GL_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E;
pub const GL_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F;
pub const GL_MAX_UNIFORM_BLOCK_SIZE = 0x8A30;
pub const GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31;
pub const GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32;
pub const GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33;
pub const GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34;
pub const GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35;
pub const GL_ACTIVE_UNIFORM_BLOCKS = 0x8A36;
pub const GL_UNIFORM_TYPE = 0x8A37;
pub const GL_UNIFORM_SIZE = 0x8A38;
pub const GL_UNIFORM_NAME_LENGTH = 0x8A39;
pub const GL_UNIFORM_BLOCK_INDEX = 0x8A3A;
pub const GL_UNIFORM_OFFSET = 0x8A3B;
pub const GL_UNIFORM_ARRAY_STRIDE = 0x8A3C;
pub const GL_UNIFORM_MATRIX_STRIDE = 0x8A3D;
pub const GL_UNIFORM_IS_ROW_MAJOR = 0x8A3E;
pub const GL_UNIFORM_BLOCK_BINDING = 0x8A3F;
pub const GL_UNIFORM_BLOCK_DATA_SIZE = 0x8A40;
pub const GL_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41;
pub const GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42;
pub const GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46;
pub const GL_INVALID_INDEX = @as(c_uint, 0xFFFFFFFF);
pub const GL_VERSION_3_2 = 1;
pub const GL_CONTEXT_CORE_PROFILE_BIT = 0x00000001;
pub const GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002;
pub const GL_LINES_ADJACENCY = 0x000A;
pub const GL_LINE_STRIP_ADJACENCY = 0x000B;
pub const GL_TRIANGLES_ADJACENCY = 0x000C;
pub const GL_TRIANGLE_STRIP_ADJACENCY = 0x000D;
pub const GL_PROGRAM_POINT_SIZE = 0x8642;
pub const GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29;
pub const GL_FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7;
pub const GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8;
pub const GL_GEOMETRY_SHADER = 0x8DD9;
pub const GL_GEOMETRY_VERTICES_OUT = 0x8916;
pub const GL_GEOMETRY_INPUT_TYPE = 0x8917;
pub const GL_GEOMETRY_OUTPUT_TYPE = 0x8918;
pub const GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF;
pub const GL_MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0;
pub const GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1;
pub const GL_MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122;
pub const GL_MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123;
pub const GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124;
pub const GL_MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125;
pub const GL_CONTEXT_PROFILE_MASK = 0x9126;
pub const GL_DEPTH_CLAMP = 0x864F;
pub const GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C;
pub const GL_FIRST_VERTEX_CONVENTION = 0x8E4D;
pub const GL_LAST_VERTEX_CONVENTION = 0x8E4E;
pub const GL_PROVOKING_VERTEX = 0x8E4F;
pub const GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F;
pub const GL_MAX_SERVER_WAIT_TIMEOUT = 0x9111;
pub const GL_OBJECT_TYPE = 0x9112;
pub const GL_SYNC_CONDITION = 0x9113;
pub const GL_SYNC_STATUS = 0x9114;
pub const GL_SYNC_FLAGS = 0x9115;
pub const GL_SYNC_FENCE = 0x9116;
pub const GL_SYNC_GPU_COMMANDS_COMPLETE = 0x9117;
pub const GL_UNSIGNALED = 0x9118;
pub const GL_SIGNALED = 0x9119;
pub const GL_ALREADY_SIGNALED = 0x911A;
pub const GL_TIMEOUT_EXPIRED = 0x911B;
pub const GL_CONDITION_SATISFIED = 0x911C;
pub const GL_WAIT_FAILED = 0x911D;
pub const GL_TIMEOUT_IGNORED = @as(c_ulonglong, 0xFFFFFFFFFFFFFFFF);
pub const GL_SYNC_FLUSH_COMMANDS_BIT = 0x00000001;
pub const GL_SAMPLE_POSITION = 0x8E50;
pub const GL_SAMPLE_MASK = 0x8E51;
pub const GL_SAMPLE_MASK_VALUE = 0x8E52;
pub const GL_MAX_SAMPLE_MASK_WORDS = 0x8E59;
pub const GL_TEXTURE_2D_MULTISAMPLE = 0x9100;
pub const GL_PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101;
pub const GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102;
pub const GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103;
pub const GL_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104;
pub const GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105;
pub const GL_TEXTURE_SAMPLES = 0x9106;
pub const GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107;
pub const GL_SAMPLER_2D_MULTISAMPLE = 0x9108;
pub const GL_INT_SAMPLER_2D_MULTISAMPLE = 0x9109;
pub const GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A;
pub const GL_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B;
pub const GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C;
pub const GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D;
pub const GL_MAX_COLOR_TEXTURE_SAMPLES = 0x910E;
pub const GL_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F;
pub const GL_MAX_INTEGER_SAMPLES = 0x9110;
pub const GL_VERSION_3_3 = 1;
pub const GL_VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE;
pub const GL_SRC1_COLOR = 0x88F9;
pub const GL_ONE_MINUS_SRC1_COLOR = 0x88FA;
pub const GL_ONE_MINUS_SRC1_ALPHA = 0x88FB;
pub const GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC;
pub const GL_ANY_SAMPLES_PASSED = 0x8C2F;
pub const GL_SAMPLER_BINDING = 0x8919;
pub const GL_RGB10_A2UI = 0x906F;
pub const GL_TEXTURE_SWIZZLE_R = 0x8E42;
pub const GL_TEXTURE_SWIZZLE_G = 0x8E43;
pub const GL_TEXTURE_SWIZZLE_B = 0x8E44;
pub const GL_TEXTURE_SWIZZLE_A = 0x8E45;
pub const GL_TEXTURE_SWIZZLE_RGBA = 0x8E46;
pub const GL_TIME_ELAPSED = 0x88BF;
pub const GL_TIMESTAMP = 0x8E28;
pub const GL_INT_2_10_10_10_REV = 0x8D9F;
pub const GL_VERSION_4_0 = 1;
pub const GL_SAMPLE_SHADING = 0x8C36;
pub const GL_MIN_SAMPLE_SHADING_VALUE = 0x8C37;
pub const GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E;
pub const GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F;
pub const GL_TEXTURE_CUBE_MAP_ARRAY = 0x9009;
pub const GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A;
pub const GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B;
pub const GL_SAMPLER_CUBE_MAP_ARRAY = 0x900C;
pub const GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D;
pub const GL_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E;
pub const GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F;
pub const GL_DRAW_INDIRECT_BUFFER = 0x8F3F;
pub const GL_DRAW_INDIRECT_BUFFER_BINDING = 0x8F43;
pub const GL_GEOMETRY_SHADER_INVOCATIONS = 0x887F;
pub const GL_MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A;
pub const GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B;
pub const GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C;
pub const GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D;
pub const GL_MAX_VERTEX_STREAMS = 0x8E71;
pub const GL_DOUBLE_VEC2 = 0x8FFC;
pub const GL_DOUBLE_VEC3 = 0x8FFD;
pub const GL_DOUBLE_VEC4 = 0x8FFE;
pub const GL_DOUBLE_MAT2 = 0x8F46;
pub const GL_DOUBLE_MAT3 = 0x8F47;
pub const GL_DOUBLE_MAT4 = 0x8F48;
pub const GL_DOUBLE_MAT2x3 = 0x8F49;
pub const GL_DOUBLE_MAT2x4 = 0x8F4A;
pub const GL_DOUBLE_MAT3x2 = 0x8F4B;
pub const GL_DOUBLE_MAT3x4 = 0x8F4C;
pub const GL_DOUBLE_MAT4x2 = 0x8F4D;
pub const GL_DOUBLE_MAT4x3 = 0x8F4E;
pub const GL_ACTIVE_SUBROUTINES = 0x8DE5;
pub const GL_ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6;
pub const GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47;
pub const GL_ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48;
pub const GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49;
pub const GL_MAX_SUBROUTINES = 0x8DE7;
pub const GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8;
pub const GL_NUM_COMPATIBLE_SUBROUTINES = 0x8E4A;
pub const GL_COMPATIBLE_SUBROUTINES = 0x8E4B;
pub const GL_PATCHES = 0x000E;
pub const GL_PATCH_VERTICES = 0x8E72;
pub const GL_PATCH_DEFAULT_INNER_LEVEL = 0x8E73;
pub const GL_PATCH_DEFAULT_OUTER_LEVEL = 0x8E74;
pub const GL_TESS_CONTROL_OUTPUT_VERTICES = 0x8E75;
pub const GL_TESS_GEN_MODE = 0x8E76;
pub const GL_TESS_GEN_SPACING = 0x8E77;
pub const GL_TESS_GEN_VERTEX_ORDER = 0x8E78;
pub const GL_TESS_GEN_POINT_MODE = 0x8E79;
pub const GL_ISOLINES = 0x8E7A;
pub const GL_FRACTIONAL_ODD = 0x8E7B;
pub const GL_FRACTIONAL_EVEN = 0x8E7C;
pub const GL_MAX_PATCH_VERTICES = 0x8E7D;
pub const GL_MAX_TESS_GEN_LEVEL = 0x8E7E;
pub const GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F;
pub const GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80;
pub const GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81;
pub const GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82;
pub const GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83;
pub const GL_MAX_TESS_PATCH_COMPONENTS = 0x8E84;
pub const GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85;
pub const GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86;
pub const GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89;
pub const GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A;
pub const GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C;
pub const GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D;
pub const GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E;
pub const GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1;
pub const GL_TESS_EVALUATION_SHADER = 0x8E87;
pub const GL_TESS_CONTROL_SHADER = 0x8E88;
pub const GL_TRANSFORM_FEEDBACK = 0x8E22;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24;
pub const GL_TRANSFORM_FEEDBACK_BINDING = 0x8E25;
pub const GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70;
pub const GL_VERSION_4_1 = 1;
pub const GL_FIXED = 0x140C;
pub const GL_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A;
pub const GL_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B;
pub const GL_LOW_FLOAT = 0x8DF0;
pub const GL_MEDIUM_FLOAT = 0x8DF1;
pub const GL_HIGH_FLOAT = 0x8DF2;
pub const GL_LOW_INT = 0x8DF3;
pub const GL_MEDIUM_INT = 0x8DF4;
pub const GL_HIGH_INT = 0x8DF5;
pub const GL_SHADER_COMPILER = 0x8DFA;
pub const GL_SHADER_BINARY_FORMATS = 0x8DF8;
pub const GL_NUM_SHADER_BINARY_FORMATS = 0x8DF9;
pub const GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB;
pub const GL_MAX_VARYING_VECTORS = 0x8DFC;
pub const GL_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD;
pub const GL_RGB565 = 0x8D62;
pub const GL_PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257;
pub const GL_PROGRAM_BINARY_LENGTH = 0x8741;
pub const GL_NUM_PROGRAM_BINARY_FORMATS = 0x87FE;
pub const GL_PROGRAM_BINARY_FORMATS = 0x87FF;
pub const GL_VERTEX_SHADER_BIT = 0x00000001;
pub const GL_FRAGMENT_SHADER_BIT = 0x00000002;
pub const GL_GEOMETRY_SHADER_BIT = 0x00000004;
pub const GL_TESS_CONTROL_SHADER_BIT = 0x00000008;
pub const GL_TESS_EVALUATION_SHADER_BIT = 0x00000010;
pub const GL_ALL_SHADER_BITS = 0xFFFFFFFF;
pub const GL_PROGRAM_SEPARABLE = 0x8258;
pub const GL_ACTIVE_PROGRAM = 0x8259;
pub const GL_PROGRAM_PIPELINE_BINDING = 0x825A;
pub const GL_MAX_VIEWPORTS = 0x825B;
pub const GL_VIEWPORT_SUBPIXEL_BITS = 0x825C;
pub const GL_VIEWPORT_BOUNDS_RANGE = 0x825D;
pub const GL_LAYER_PROVOKING_VERTEX = 0x825E;
pub const GL_VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F;
pub const GL_UNDEFINED_VERTEX = 0x8260;
pub const GL_VERSION_4_2 = 1;
pub const GL_COPY_READ_BUFFER_BINDING = 0x8F36;
pub const GL_COPY_WRITE_BUFFER_BINDING = 0x8F37;
pub const GL_TRANSFORM_FEEDBACK_ACTIVE = 0x8E24;
pub const GL_TRANSFORM_FEEDBACK_PAUSED = 0x8E23;
pub const GL_UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127;
pub const GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128;
pub const GL_UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129;
pub const GL_UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A;
pub const GL_PACK_COMPRESSED_BLOCK_WIDTH = 0x912B;
pub const GL_PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C;
pub const GL_PACK_COMPRESSED_BLOCK_DEPTH = 0x912D;
pub const GL_PACK_COMPRESSED_BLOCK_SIZE = 0x912E;
pub const GL_NUM_SAMPLE_COUNTS = 0x9380;
pub const GL_MIN_MAP_BUFFER_ALIGNMENT = 0x90BC;
pub const GL_ATOMIC_COUNTER_BUFFER = 0x92C0;
pub const GL_ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1;
pub const GL_ATOMIC_COUNTER_BUFFER_START = 0x92C2;
pub const GL_ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3;
pub const GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4;
pub const GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5;
pub const GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6;
pub const GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7;
pub const GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8;
pub const GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9;
pub const GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA;
pub const GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB;
pub const GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC;
pub const GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD;
pub const GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE;
pub const GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF;
pub const GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0;
pub const GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1;
pub const GL_MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2;
pub const GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3;
pub const GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4;
pub const GL_MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5;
pub const GL_MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6;
pub const GL_MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7;
pub const GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8;
pub const GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC;
pub const GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9;
pub const GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA;
pub const GL_UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB;
pub const GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001;
pub const GL_ELEMENT_ARRAY_BARRIER_BIT = 0x00000002;
pub const GL_UNIFORM_BARRIER_BIT = 0x00000004;
pub const GL_TEXTURE_FETCH_BARRIER_BIT = 0x00000008;
pub const GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020;
pub const GL_COMMAND_BARRIER_BIT = 0x00000040;
pub const GL_PIXEL_BUFFER_BARRIER_BIT = 0x00000080;
pub const GL_TEXTURE_UPDATE_BARRIER_BIT = 0x00000100;
pub const GL_BUFFER_UPDATE_BARRIER_BIT = 0x00000200;
pub const GL_FRAMEBUFFER_BARRIER_BIT = 0x00000400;
pub const GL_TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800;
pub const GL_ATOMIC_COUNTER_BARRIER_BIT = 0x00001000;
pub const GL_ALL_BARRIER_BITS = 0xFFFFFFFF;
pub const GL_MAX_IMAGE_UNITS = 0x8F38;
pub const GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39;
pub const GL_IMAGE_BINDING_NAME = 0x8F3A;
pub const GL_IMAGE_BINDING_LEVEL = 0x8F3B;
pub const GL_IMAGE_BINDING_LAYERED = 0x8F3C;
pub const GL_IMAGE_BINDING_LAYER = 0x8F3D;
pub const GL_IMAGE_BINDING_ACCESS = 0x8F3E;
pub const GL_IMAGE_1D = 0x904C;
pub const GL_IMAGE_2D = 0x904D;
pub const GL_IMAGE_3D = 0x904E;
pub const GL_IMAGE_2D_RECT = 0x904F;
pub const GL_IMAGE_CUBE = 0x9050;
pub const GL_IMAGE_BUFFER = 0x9051;
pub const GL_IMAGE_1D_ARRAY = 0x9052;
pub const GL_IMAGE_2D_ARRAY = 0x9053;
pub const GL_IMAGE_CUBE_MAP_ARRAY = 0x9054;
pub const GL_IMAGE_2D_MULTISAMPLE = 0x9055;
pub const GL_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056;
pub const GL_INT_IMAGE_1D = 0x9057;
pub const GL_INT_IMAGE_2D = 0x9058;
pub const GL_INT_IMAGE_3D = 0x9059;
pub const GL_INT_IMAGE_2D_RECT = 0x905A;
pub const GL_INT_IMAGE_CUBE = 0x905B;
pub const GL_INT_IMAGE_BUFFER = 0x905C;
pub const GL_INT_IMAGE_1D_ARRAY = 0x905D;
pub const GL_INT_IMAGE_2D_ARRAY = 0x905E;
pub const GL_INT_IMAGE_CUBE_MAP_ARRAY = 0x905F;
pub const GL_INT_IMAGE_2D_MULTISAMPLE = 0x9060;
pub const GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061;
pub const GL_UNSIGNED_INT_IMAGE_1D = 0x9062;
pub const GL_UNSIGNED_INT_IMAGE_2D = 0x9063;
pub const GL_UNSIGNED_INT_IMAGE_3D = 0x9064;
pub const GL_UNSIGNED_INT_IMAGE_2D_RECT = 0x9065;
pub const GL_UNSIGNED_INT_IMAGE_CUBE = 0x9066;
pub const GL_UNSIGNED_INT_IMAGE_BUFFER = 0x9067;
pub const GL_UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068;
pub const GL_UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069;
pub const GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A;
pub const GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B;
pub const GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C;
pub const GL_MAX_IMAGE_SAMPLES = 0x906D;
pub const GL_IMAGE_BINDING_FORMAT = 0x906E;
pub const GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7;
pub const GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8;
pub const GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9;
pub const GL_MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA;
pub const GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB;
pub const GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC;
pub const GL_MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD;
pub const GL_MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE;
pub const GL_MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF;
pub const GL_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C;
pub const GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D;
pub const GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E;
pub const GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F;
pub const GL_TEXTURE_IMMUTABLE_FORMAT = 0x912F;
pub const GL_VERSION_4_3 = 1;
pub const GL_NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9;
pub const GL_VERTEX_ATTRIB_ARRAY_LONG = 0x874E;
pub const GL_COMPRESSED_RGB8_ETC2 = 0x9274;
pub const GL_COMPRESSED_SRGB8_ETC2 = 0x9275;
pub const GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276;
pub const GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277;
pub const GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279;
pub const GL_COMPRESSED_R11_EAC = 0x9270;
pub const GL_COMPRESSED_SIGNED_R11_EAC = 0x9271;
pub const GL_COMPRESSED_RG11_EAC = 0x9272;
pub const GL_COMPRESSED_SIGNED_RG11_EAC = 0x9273;
pub const GL_PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69;
pub const GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A;
pub const GL_MAX_ELEMENT_INDEX = 0x8D6B;
pub const GL_COMPUTE_SHADER = 0x91B9;
pub const GL_MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB;
pub const GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC;
pub const GL_MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD;
pub const GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262;
pub const GL_MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263;
pub const GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264;
pub const GL_MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265;
pub const GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266;
pub const GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB;
pub const GL_MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE;
pub const GL_MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF;
pub const GL_COMPUTE_WORK_GROUP_SIZE = 0x8267;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC;
pub const GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED;
pub const GL_DISPATCH_INDIRECT_BUFFER = 0x90EE;
pub const GL_DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF;
pub const GL_COMPUTE_SHADER_BIT = 0x00000020;
pub const GL_DEBUG_OUTPUT_SYNCHRONOUS = 0x8242;
pub const GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243;
pub const GL_DEBUG_CALLBACK_FUNCTION = 0x8244;
pub const GL_DEBUG_CALLBACK_USER_PARAM = 0x8245;
pub const GL_DEBUG_SOURCE_API = 0x8246;
pub const GL_DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247;
pub const GL_DEBUG_SOURCE_SHADER_COMPILER = 0x8248;
pub const GL_DEBUG_SOURCE_THIRD_PARTY = 0x8249;
pub const GL_DEBUG_SOURCE_APPLICATION = 0x824A;
pub const GL_DEBUG_SOURCE_OTHER = 0x824B;
pub const GL_DEBUG_TYPE_ERROR = 0x824C;
pub const GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D;
pub const GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E;
pub const GL_DEBUG_TYPE_PORTABILITY = 0x824F;
pub const GL_DEBUG_TYPE_PERFORMANCE = 0x8250;
pub const GL_DEBUG_TYPE_OTHER = 0x8251;
pub const GL_MAX_DEBUG_MESSAGE_LENGTH = 0x9143;
pub const GL_MAX_DEBUG_LOGGED_MESSAGES = 0x9144;
pub const GL_DEBUG_LOGGED_MESSAGES = 0x9145;
pub const GL_DEBUG_SEVERITY_HIGH = 0x9146;
pub const GL_DEBUG_SEVERITY_MEDIUM = 0x9147;
pub const GL_DEBUG_SEVERITY_LOW = 0x9148;
pub const GL_DEBUG_TYPE_MARKER = 0x8268;
pub const GL_DEBUG_TYPE_PUSH_GROUP = 0x8269;
pub const GL_DEBUG_TYPE_POP_GROUP = 0x826A;
pub const GL_DEBUG_SEVERITY_NOTIFICATION = 0x826B;
pub const GL_MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C;
pub const GL_DEBUG_GROUP_STACK_DEPTH = 0x826D;
pub const GL_BUFFER = 0x82E0;
pub const GL_SHADER = 0x82E1;
pub const GL_PROGRAM = 0x82E2;
pub const GL_QUERY = 0x82E3;
pub const GL_PROGRAM_PIPELINE = 0x82E4;
pub const GL_SAMPLER = 0x82E6;
pub const GL_MAX_LABEL_LENGTH = 0x82E8;
pub const GL_DEBUG_OUTPUT = 0x92E0;
pub const GL_CONTEXT_FLAG_DEBUG_BIT = 0x00000002;
pub const GL_MAX_UNIFORM_LOCATIONS = 0x826E;
pub const GL_FRAMEBUFFER_DEFAULT_WIDTH = 0x9310;
pub const GL_FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311;
pub const GL_FRAMEBUFFER_DEFAULT_LAYERS = 0x9312;
pub const GL_FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313;
pub const GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314;
pub const GL_MAX_FRAMEBUFFER_WIDTH = 0x9315;
pub const GL_MAX_FRAMEBUFFER_HEIGHT = 0x9316;
pub const GL_MAX_FRAMEBUFFER_LAYERS = 0x9317;
pub const GL_MAX_FRAMEBUFFER_SAMPLES = 0x9318;
pub const GL_INTERNALFORMAT_SUPPORTED = 0x826F;
pub const GL_INTERNALFORMAT_PREFERRED = 0x8270;
pub const GL_INTERNALFORMAT_RED_SIZE = 0x8271;
pub const GL_INTERNALFORMAT_GREEN_SIZE = 0x8272;
pub const GL_INTERNALFORMAT_BLUE_SIZE = 0x8273;
pub const GL_INTERNALFORMAT_ALPHA_SIZE = 0x8274;
pub const GL_INTERNALFORMAT_DEPTH_SIZE = 0x8275;
pub const GL_INTERNALFORMAT_STENCIL_SIZE = 0x8276;
pub const GL_INTERNALFORMAT_SHARED_SIZE = 0x8277;
pub const GL_INTERNALFORMAT_RED_TYPE = 0x8278;
pub const GL_INTERNALFORMAT_GREEN_TYPE = 0x8279;
pub const GL_INTERNALFORMAT_BLUE_TYPE = 0x827A;
pub const GL_INTERNALFORMAT_ALPHA_TYPE = 0x827B;
pub const GL_INTERNALFORMAT_DEPTH_TYPE = 0x827C;
pub const GL_INTERNALFORMAT_STENCIL_TYPE = 0x827D;
pub const GL_MAX_WIDTH = 0x827E;
pub const GL_MAX_HEIGHT = 0x827F;
pub const GL_MAX_DEPTH = 0x8280;
pub const GL_MAX_LAYERS = 0x8281;
pub const GL_MAX_COMBINED_DIMENSIONS = 0x8282;
pub const GL_COLOR_COMPONENTS = 0x8283;
pub const GL_DEPTH_COMPONENTS = 0x8284;
pub const GL_STENCIL_COMPONENTS = 0x8285;
pub const GL_COLOR_RENDERABLE = 0x8286;
pub const GL_DEPTH_RENDERABLE = 0x8287;
pub const GL_STENCIL_RENDERABLE = 0x8288;
pub const GL_FRAMEBUFFER_RENDERABLE = 0x8289;
pub const GL_FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A;
pub const GL_FRAMEBUFFER_BLEND = 0x828B;
pub const GL_READ_PIXELS = 0x828C;
pub const GL_READ_PIXELS_FORMAT = 0x828D;
pub const GL_READ_PIXELS_TYPE = 0x828E;
pub const GL_TEXTURE_IMAGE_FORMAT = 0x828F;
pub const GL_TEXTURE_IMAGE_TYPE = 0x8290;
pub const GL_GET_TEXTURE_IMAGE_FORMAT = 0x8291;
pub const GL_GET_TEXTURE_IMAGE_TYPE = 0x8292;
pub const GL_MIPMAP = 0x8293;
pub const GL_MANUAL_GENERATE_MIPMAP = 0x8294;
pub const GL_AUTO_GENERATE_MIPMAP = 0x8295;
pub const GL_COLOR_ENCODING = 0x8296;
pub const GL_SRGB_READ = 0x8297;
pub const GL_SRGB_WRITE = 0x8298;
pub const GL_FILTER = 0x829A;
pub const GL_VERTEX_TEXTURE = 0x829B;
pub const GL_TESS_CONTROL_TEXTURE = 0x829C;
pub const GL_TESS_EVALUATION_TEXTURE = 0x829D;
pub const GL_GEOMETRY_TEXTURE = 0x829E;
pub const GL_FRAGMENT_TEXTURE = 0x829F;
pub const GL_COMPUTE_TEXTURE = 0x82A0;
pub const GL_TEXTURE_SHADOW = 0x82A1;
pub const GL_TEXTURE_GATHER = 0x82A2;
pub const GL_TEXTURE_GATHER_SHADOW = 0x82A3;
pub const GL_SHADER_IMAGE_LOAD = 0x82A4;
pub const GL_SHADER_IMAGE_STORE = 0x82A5;
pub const GL_SHADER_IMAGE_ATOMIC = 0x82A6;
pub const GL_IMAGE_TEXEL_SIZE = 0x82A7;
pub const GL_IMAGE_COMPATIBILITY_CLASS = 0x82A8;
pub const GL_IMAGE_PIXEL_FORMAT = 0x82A9;
pub const GL_IMAGE_PIXEL_TYPE = 0x82AA;
pub const GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC;
pub const GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD;
pub const GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE;
pub const GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF;
pub const GL_TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1;
pub const GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2;
pub const GL_TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3;
pub const GL_CLEAR_BUFFER = 0x82B4;
pub const GL_TEXTURE_VIEW = 0x82B5;
pub const GL_VIEW_COMPATIBILITY_CLASS = 0x82B6;
pub const GL_FULL_SUPPORT = 0x82B7;
pub const GL_CAVEAT_SUPPORT = 0x82B8;
pub const GL_IMAGE_CLASS_4_X_32 = 0x82B9;
pub const GL_IMAGE_CLASS_2_X_32 = 0x82BA;
pub const GL_IMAGE_CLASS_1_X_32 = 0x82BB;
pub const GL_IMAGE_CLASS_4_X_16 = 0x82BC;
pub const GL_IMAGE_CLASS_2_X_16 = 0x82BD;
pub const GL_IMAGE_CLASS_1_X_16 = 0x82BE;
pub const GL_IMAGE_CLASS_4_X_8 = 0x82BF;
pub const GL_IMAGE_CLASS_2_X_8 = 0x82C0;
pub const GL_IMAGE_CLASS_1_X_8 = 0x82C1;
pub const GL_IMAGE_CLASS_11_11_10 = 0x82C2;
pub const GL_IMAGE_CLASS_10_10_10_2 = 0x82C3;
pub const GL_VIEW_CLASS_128_BITS = 0x82C4;
pub const GL_VIEW_CLASS_96_BITS = 0x82C5;
pub const GL_VIEW_CLASS_64_BITS = 0x82C6;
pub const GL_VIEW_CLASS_48_BITS = 0x82C7;
pub const GL_VIEW_CLASS_32_BITS = 0x82C8;
pub const GL_VIEW_CLASS_24_BITS = 0x82C9;
pub const GL_VIEW_CLASS_16_BITS = 0x82CA;
pub const GL_VIEW_CLASS_8_BITS = 0x82CB;
pub const GL_VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC;
pub const GL_VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD;
pub const GL_VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE;
pub const GL_VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF;
pub const GL_VIEW_CLASS_RGTC1_RED = 0x82D0;
pub const GL_VIEW_CLASS_RGTC2_RG = 0x82D1;
pub const GL_VIEW_CLASS_BPTC_UNORM = 0x82D2;
pub const GL_VIEW_CLASS_BPTC_FLOAT = 0x82D3;
pub const GL_UNIFORM = 0x92E1;
pub const GL_UNIFORM_BLOCK = 0x92E2;
pub const GL_PROGRAM_INPUT = 0x92E3;
pub const GL_PROGRAM_OUTPUT = 0x92E4;
pub const GL_BUFFER_VARIABLE = 0x92E5;
pub const GL_SHADER_STORAGE_BLOCK = 0x92E6;
pub const GL_VERTEX_SUBROUTINE = 0x92E8;
pub const GL_TESS_CONTROL_SUBROUTINE = 0x92E9;
pub const GL_TESS_EVALUATION_SUBROUTINE = 0x92EA;
pub const GL_GEOMETRY_SUBROUTINE = 0x92EB;
pub const GL_FRAGMENT_SUBROUTINE = 0x92EC;
pub const GL_COMPUTE_SUBROUTINE = 0x92ED;
pub const GL_VERTEX_SUBROUTINE_UNIFORM = 0x92EE;
pub const GL_TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF;
pub const GL_TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0;
pub const GL_GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1;
pub const GL_FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2;
pub const GL_COMPUTE_SUBROUTINE_UNIFORM = 0x92F3;
pub const GL_TRANSFORM_FEEDBACK_VARYING = 0x92F4;
pub const GL_ACTIVE_RESOURCES = 0x92F5;
pub const GL_MAX_NAME_LENGTH = 0x92F6;
pub const GL_MAX_NUM_ACTIVE_VARIABLES = 0x92F7;
pub const GL_MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8;
pub const GL_NAME_LENGTH = 0x92F9;
pub const GL_TYPE = 0x92FA;
pub const GL_ARRAY_SIZE = 0x92FB;
pub const GL_OFFSET = 0x92FC;
pub const GL_BLOCK_INDEX = 0x92FD;
pub const GL_ARRAY_STRIDE = 0x92FE;
pub const GL_MATRIX_STRIDE = 0x92FF;
pub const GL_IS_ROW_MAJOR = 0x9300;
pub const GL_ATOMIC_COUNTER_BUFFER_INDEX = 0x9301;
pub const GL_BUFFER_BINDING = 0x9302;
pub const GL_BUFFER_DATA_SIZE = 0x9303;
pub const GL_NUM_ACTIVE_VARIABLES = 0x9304;
pub const GL_ACTIVE_VARIABLES = 0x9305;
pub const GL_REFERENCED_BY_VERTEX_SHADER = 0x9306;
pub const GL_REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307;
pub const GL_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308;
pub const GL_REFERENCED_BY_GEOMETRY_SHADER = 0x9309;
pub const GL_REFERENCED_BY_FRAGMENT_SHADER = 0x930A;
pub const GL_REFERENCED_BY_COMPUTE_SHADER = 0x930B;
pub const GL_TOP_LEVEL_ARRAY_SIZE = 0x930C;
pub const GL_TOP_LEVEL_ARRAY_STRIDE = 0x930D;
pub const GL_LOCATION = 0x930E;
pub const GL_LOCATION_INDEX = 0x930F;
pub const GL_IS_PER_PATCH = 0x92E7;
pub const GL_SHADER_STORAGE_BUFFER = 0x90D2;
pub const GL_SHADER_STORAGE_BUFFER_BINDING = 0x90D3;
pub const GL_SHADER_STORAGE_BUFFER_START = 0x90D4;
pub const GL_SHADER_STORAGE_BUFFER_SIZE = 0x90D5;
pub const GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6;
pub const GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7;
pub const GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8;
pub const GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9;
pub const GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA;
pub const GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB;
pub const GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC;
pub const GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD;
pub const GL_MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE;
pub const GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF;
pub const GL_SHADER_STORAGE_BARRIER_BIT = 0x00002000;
pub const GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39;
pub const GL_DEPTH_STENCIL_TEXTURE_MODE = 0x90EA;
pub const GL_TEXTURE_BUFFER_OFFSET = 0x919D;
pub const GL_TEXTURE_BUFFER_SIZE = 0x919E;
pub const GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F;
pub const GL_TEXTURE_VIEW_MIN_LEVEL = 0x82DB;
pub const GL_TEXTURE_VIEW_NUM_LEVELS = 0x82DC;
pub const GL_TEXTURE_VIEW_MIN_LAYER = 0x82DD;
pub const GL_TEXTURE_VIEW_NUM_LAYERS = 0x82DE;
pub const GL_TEXTURE_IMMUTABLE_LEVELS = 0x82DF;
pub const GL_VERTEX_ATTRIB_BINDING = 0x82D4;
pub const GL_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5;
pub const GL_VERTEX_BINDING_DIVISOR = 0x82D6;
pub const GL_VERTEX_BINDING_OFFSET = 0x82D7;
pub const GL_VERTEX_BINDING_STRIDE = 0x82D8;
pub const GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9;
pub const GL_MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA;
pub const GL_VERTEX_BINDING_BUFFER = 0x8F4F;
pub const GL_DISPLAY_LIST = 0x82E7;
pub const GL_VERSION_4_4 = 1;
pub const GL_MAX_VERTEX_ATTRIB_STRIDE = 0x82E5;
pub const GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221;
pub const GL_TEXTURE_BUFFER_BINDING = 0x8C2A;
pub const GL_MAP_PERSISTENT_BIT = 0x0040;
pub const GL_MAP_COHERENT_BIT = 0x0080;
pub const GL_DYNAMIC_STORAGE_BIT = 0x0100;
pub const GL_CLIENT_STORAGE_BIT = 0x0200;
pub const GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000;
pub const GL_BUFFER_IMMUTABLE_STORAGE = 0x821F;
pub const GL_BUFFER_STORAGE_FLAGS = 0x8220;
pub const GL_CLEAR_TEXTURE = 0x9365;
pub const GL_LOCATION_COMPONENT = 0x934A;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C;
pub const GL_QUERY_BUFFER = 0x9192;
pub const GL_QUERY_BUFFER_BARRIER_BIT = 0x00008000;
pub const GL_QUERY_BUFFER_BINDING = 0x9193;
pub const GL_QUERY_RESULT_NO_WAIT = 0x9194;
pub const GL_MIRROR_CLAMP_TO_EDGE = 0x8743;
pub const GL_VERSION_4_5 = 1;
pub const GL_CONTEXT_LOST = 0x0507;
pub const GL_NEGATIVE_ONE_TO_ONE = 0x935E;
pub const GL_ZERO_TO_ONE = 0x935F;
pub const GL_CLIP_ORIGIN = 0x935C;
pub const GL_CLIP_DEPTH_MODE = 0x935D;
pub const GL_QUERY_WAIT_INVERTED = 0x8E17;
pub const GL_QUERY_NO_WAIT_INVERTED = 0x8E18;
pub const GL_QUERY_BY_REGION_WAIT_INVERTED = 0x8E19;
pub const GL_QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A;
pub const GL_MAX_CULL_DISTANCES = 0x82F9;
pub const GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA;
pub const GL_TEXTURE_TARGET = 0x1006;
pub const GL_QUERY_TARGET = 0x82EA;
pub const GL_GUILTY_CONTEXT_RESET = 0x8253;
pub const GL_INNOCENT_CONTEXT_RESET = 0x8254;
pub const GL_UNKNOWN_CONTEXT_RESET = 0x8255;
pub const GL_RESET_NOTIFICATION_STRATEGY = 0x8256;
pub const GL_LOSE_CONTEXT_ON_RESET = 0x8252;
pub const GL_NO_RESET_NOTIFICATION = 0x8261;
pub const GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004;
pub const GL_CONTEXT_RELEASE_BEHAVIOR = 0x82FB;
pub const GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC;
pub const GL_VERSION_4_6 = 1;
pub const GL_SHADER_BINARY_FORMAT_SPIR_V = 0x9551;
pub const GL_SPIR_V_BINARY = 0x9552;
pub const GL_PARAMETER_BUFFER = 0x80EE;
pub const GL_PARAMETER_BUFFER_BINDING = 0x80EF;
pub const GL_CONTEXT_FLAG_NO_ERROR_BIT = 0x00000008;
pub const GL_VERTICES_SUBMITTED = 0x82EE;
pub const GL_PRIMITIVES_SUBMITTED = 0x82EF;
pub const GL_VERTEX_SHADER_INVOCATIONS = 0x82F0;
pub const GL_TESS_CONTROL_SHADER_PATCHES = 0x82F1;
pub const GL_TESS_EVALUATION_SHADER_INVOCATIONS = 0x82F2;
pub const GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED = 0x82F3;
pub const GL_FRAGMENT_SHADER_INVOCATIONS = 0x82F4;
pub const GL_COMPUTE_SHADER_INVOCATIONS = 0x82F5;
pub const GL_CLIPPING_INPUT_PRIMITIVES = 0x82F6;
pub const GL_CLIPPING_OUTPUT_PRIMITIVES = 0x82F7;
pub const GL_POLYGON_OFFSET_CLAMP = 0x8E1B;
pub const GL_SPIR_V_EXTENSIONS = 0x9553;
pub const GL_NUM_SPIR_V_EXTENSIONS = 0x9554;
pub const GL_TEXTURE_MAX_ANISOTROPY = 0x84FE;
pub const GL_MAX_TEXTURE_MAX_ANISOTROPY = 0x84FF;
pub const GL_TRANSFORM_FEEDBACK_OVERFLOW = 0x82EC;
pub const GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW = 0x82ED;
pub const GL_ARB_ES2_compatibility = 1;
pub const GL_ARB_ES3_1_compatibility = 1;
pub const GL_ARB_ES3_2_compatibility = 1;
pub const GL_PRIMITIVE_BOUNDING_BOX_ARB = 0x92BE;
pub const GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB = 0x9381;
pub const GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB = 0x9382;
pub const GL_ARB_ES3_compatibility = 1;
pub const GL_ARB_arrays_of_arrays = 1;
pub const GL_ARB_base_instance = 1;
pub const GL_ARB_bindless_texture = 1;
pub const GL_UNSIGNED_INT64_ARB = 0x140F;
pub const GL_ARB_blend_func_extended = 1;
pub const GL_ARB_buffer_storage = 1;
pub const GL_ARB_cl_event = 1;
pub const GL_SYNC_CL_EVENT_ARB = 0x8240;
pub const GL_SYNC_CL_EVENT_COMPLETE_ARB = 0x8241;
pub const GL_ARB_clear_buffer_object = 1;
pub const GL_ARB_clear_texture = 1;
pub const GL_ARB_clip_control = 1;
pub const GL_ARB_color_buffer_float = 1;
pub const GL_RGBA_FLOAT_MODE_ARB = 0x8820;
pub const GL_CLAMP_VERTEX_COLOR_ARB = 0x891A;
pub const GL_CLAMP_FRAGMENT_COLOR_ARB = 0x891B;
pub const GL_CLAMP_READ_COLOR_ARB = 0x891C;
pub const GL_FIXED_ONLY_ARB = 0x891D;
pub const GL_ARB_compatibility = 1;
pub const GL_ARB_compressed_texture_pixel_storage = 1;
pub const GL_ARB_compute_shader = 1;
pub const GL_ARB_compute_variable_group_size = 1;
pub const GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = 0x9344;
pub const GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = 0x90EB;
pub const GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = 0x9345;
pub const GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = 0x91BF;
pub const GL_ARB_conditional_render_inverted = 1;
pub const GL_ARB_conservative_depth = 1;
pub const GL_ARB_copy_buffer = 1;
pub const GL_ARB_copy_image = 1;
pub const GL_ARB_cull_distance = 1;
pub const GL_ARB_debug_output = 1;
pub const GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242;
pub const GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243;
pub const GL_DEBUG_CALLBACK_FUNCTION_ARB = 0x8244;
pub const GL_DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245;
pub const GL_DEBUG_SOURCE_API_ARB = 0x8246;
pub const GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247;
pub const GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248;
pub const GL_DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249;
pub const GL_DEBUG_SOURCE_APPLICATION_ARB = 0x824A;
pub const GL_DEBUG_SOURCE_OTHER_ARB = 0x824B;
pub const GL_DEBUG_TYPE_ERROR_ARB = 0x824C;
pub const GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D;
pub const GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E;
pub const GL_DEBUG_TYPE_PORTABILITY_ARB = 0x824F;
pub const GL_DEBUG_TYPE_PERFORMANCE_ARB = 0x8250;
pub const GL_DEBUG_TYPE_OTHER_ARB = 0x8251;
pub const GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143;
pub const GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144;
pub const GL_DEBUG_LOGGED_MESSAGES_ARB = 0x9145;
pub const GL_DEBUG_SEVERITY_HIGH_ARB = 0x9146;
pub const GL_DEBUG_SEVERITY_MEDIUM_ARB = 0x9147;
pub const GL_DEBUG_SEVERITY_LOW_ARB = 0x9148;
pub const GL_ARB_depth_buffer_float = 1;
pub const GL_ARB_depth_clamp = 1;
pub const GL_ARB_depth_texture = 1;
pub const GL_DEPTH_COMPONENT16_ARB = 0x81A5;
pub const GL_DEPTH_COMPONENT24_ARB = 0x81A6;
pub const GL_DEPTH_COMPONENT32_ARB = 0x81A7;
pub const GL_TEXTURE_DEPTH_SIZE_ARB = 0x884A;
pub const GL_DEPTH_TEXTURE_MODE_ARB = 0x884B;
pub const GL_ARB_derivative_control = 1;
pub const GL_ARB_direct_state_access = 1;
pub const GL_ARB_draw_buffers = 1;
pub const GL_MAX_DRAW_BUFFERS_ARB = 0x8824;
pub const GL_DRAW_BUFFER0_ARB = 0x8825;
pub const GL_DRAW_BUFFER1_ARB = 0x8826;
pub const GL_DRAW_BUFFER2_ARB = 0x8827;
pub const GL_DRAW_BUFFER3_ARB = 0x8828;
pub const GL_DRAW_BUFFER4_ARB = 0x8829;
pub const GL_DRAW_BUFFER5_ARB = 0x882A;
pub const GL_DRAW_BUFFER6_ARB = 0x882B;
pub const GL_DRAW_BUFFER7_ARB = 0x882C;
pub const GL_DRAW_BUFFER8_ARB = 0x882D;
pub const GL_DRAW_BUFFER9_ARB = 0x882E;
pub const GL_DRAW_BUFFER10_ARB = 0x882F;
pub const GL_DRAW_BUFFER11_ARB = 0x8830;
pub const GL_DRAW_BUFFER12_ARB = 0x8831;
pub const GL_DRAW_BUFFER13_ARB = 0x8832;
pub const GL_DRAW_BUFFER14_ARB = 0x8833;
pub const GL_DRAW_BUFFER15_ARB = 0x8834;
pub const GL_ARB_draw_buffers_blend = 1;
pub const GL_ARB_draw_elements_base_vertex = 1;
pub const GL_ARB_draw_indirect = 1;
pub const GL_ARB_draw_instanced = 1;
pub const GL_ARB_enhanced_layouts = 1;
pub const GL_ARB_explicit_attrib_location = 1;
pub const GL_ARB_explicit_uniform_location = 1;
pub const GL_ARB_fragment_coord_conventions = 1;
pub const GL_ARB_fragment_layer_viewport = 1;
pub const GL_ARB_fragment_program = 1;
pub const GL_FRAGMENT_PROGRAM_ARB = 0x8804;
pub const GL_PROGRAM_FORMAT_ASCII_ARB = 0x8875;
pub const GL_PROGRAM_LENGTH_ARB = 0x8627;
pub const GL_PROGRAM_FORMAT_ARB = 0x8876;
pub const GL_PROGRAM_BINDING_ARB = 0x8677;
pub const GL_PROGRAM_INSTRUCTIONS_ARB = 0x88A0;
pub const GL_MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1;
pub const GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2;
pub const GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3;
pub const GL_PROGRAM_TEMPORARIES_ARB = 0x88A4;
pub const GL_MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5;
pub const GL_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6;
pub const GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7;
pub const GL_PROGRAM_PARAMETERS_ARB = 0x88A8;
pub const GL_MAX_PROGRAM_PARAMETERS_ARB = 0x88A9;
pub const GL_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA;
pub const GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB;
pub const GL_PROGRAM_ATTRIBS_ARB = 0x88AC;
pub const GL_MAX_PROGRAM_ATTRIBS_ARB = 0x88AD;
pub const GL_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE;
pub const GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF;
pub const GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4;
pub const GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5;
pub const GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6;
pub const GL_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805;
pub const GL_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806;
pub const GL_PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807;
pub const GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808;
pub const GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809;
pub const GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A;
pub const GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B;
pub const GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C;
pub const GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D;
pub const GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E;
pub const GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F;
pub const GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810;
pub const GL_PROGRAM_STRING_ARB = 0x8628;
pub const GL_PROGRAM_ERROR_POSITION_ARB = 0x864B;
pub const GL_CURRENT_MATRIX_ARB = 0x8641;
pub const GL_TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7;
pub const GL_CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640;
pub const GL_MAX_PROGRAM_MATRICES_ARB = 0x862F;
pub const GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E;
pub const GL_MAX_TEXTURE_COORDS_ARB = 0x8871;
pub const GL_MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872;
pub const GL_PROGRAM_ERROR_STRING_ARB = 0x8874;
pub const GL_MATRIX0_ARB = 0x88C0;
pub const GL_MATRIX1_ARB = 0x88C1;
pub const GL_MATRIX2_ARB = 0x88C2;
pub const GL_MATRIX3_ARB = 0x88C3;
pub const GL_MATRIX4_ARB = 0x88C4;
pub const GL_MATRIX5_ARB = 0x88C5;
pub const GL_MATRIX6_ARB = 0x88C6;
pub const GL_MATRIX7_ARB = 0x88C7;
pub const GL_MATRIX8_ARB = 0x88C8;
pub const GL_MATRIX9_ARB = 0x88C9;
pub const GL_MATRIX10_ARB = 0x88CA;
pub const GL_MATRIX11_ARB = 0x88CB;
pub const GL_MATRIX12_ARB = 0x88CC;
pub const GL_MATRIX13_ARB = 0x88CD;
pub const GL_MATRIX14_ARB = 0x88CE;
pub const GL_MATRIX15_ARB = 0x88CF;
pub const GL_MATRIX16_ARB = 0x88D0;
pub const GL_MATRIX17_ARB = 0x88D1;
pub const GL_MATRIX18_ARB = 0x88D2;
pub const GL_MATRIX19_ARB = 0x88D3;
pub const GL_MATRIX20_ARB = 0x88D4;
pub const GL_MATRIX21_ARB = 0x88D5;
pub const GL_MATRIX22_ARB = 0x88D6;
pub const GL_MATRIX23_ARB = 0x88D7;
pub const GL_MATRIX24_ARB = 0x88D8;
pub const GL_MATRIX25_ARB = 0x88D9;
pub const GL_MATRIX26_ARB = 0x88DA;
pub const GL_MATRIX27_ARB = 0x88DB;
pub const GL_MATRIX28_ARB = 0x88DC;
pub const GL_MATRIX29_ARB = 0x88DD;
pub const GL_MATRIX30_ARB = 0x88DE;
pub const GL_MATRIX31_ARB = 0x88DF;
pub const GL_ARB_fragment_program_shadow = 1;
pub const GL_ARB_fragment_shader = 1;
pub const GL_FRAGMENT_SHADER_ARB = 0x8B30;
pub const GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49;
pub const GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B;
pub const GL_ARB_fragment_shader_interlock = 1;
pub const GL_ARB_framebuffer_no_attachments = 1;
pub const GL_ARB_framebuffer_object = 1;
pub const GL_ARB_framebuffer_sRGB = 1;
pub const GL_ARB_geometry_shader4 = 1;
pub const GL_LINES_ADJACENCY_ARB = 0x000A;
pub const GL_LINE_STRIP_ADJACENCY_ARB = 0x000B;
pub const GL_TRIANGLES_ADJACENCY_ARB = 0x000C;
pub const GL_TRIANGLE_STRIP_ADJACENCY_ARB = 0x000D;
pub const GL_PROGRAM_POINT_SIZE_ARB = 0x8642;
pub const GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 0x8C29;
pub const GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 0x8DA7;
pub const GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 0x8DA8;
pub const GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 0x8DA9;
pub const GL_GEOMETRY_SHADER_ARB = 0x8DD9;
pub const GL_GEOMETRY_VERTICES_OUT_ARB = 0x8DDA;
pub const GL_GEOMETRY_INPUT_TYPE_ARB = 0x8DDB;
pub const GL_GEOMETRY_OUTPUT_TYPE_ARB = 0x8DDC;
pub const GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 0x8DDD;
pub const GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = 0x8DDE;
pub const GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 0x8DDF;
pub const GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 0x8DE0;
pub const GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 0x8DE1;
pub const GL_ARB_get_program_binary = 1;
pub const GL_ARB_get_texture_sub_image = 1;
pub const GL_ARB_gl_spirv = 1;
pub const GL_SHADER_BINARY_FORMAT_SPIR_V_ARB = 0x9551;
pub const GL_SPIR_V_BINARY_ARB = 0x9552;
pub const GL_ARB_gpu_shader5 = 1;
pub const GL_ARB_gpu_shader_fp64 = 1;
pub const GL_ARB_gpu_shader_int64 = 1;
pub const GL_INT64_ARB = 0x140E;
pub const GL_INT64_VEC2_ARB = 0x8FE9;
pub const GL_INT64_VEC3_ARB = 0x8FEA;
pub const GL_INT64_VEC4_ARB = 0x8FEB;
pub const GL_UNSIGNED_INT64_VEC2_ARB = 0x8FF5;
pub const GL_UNSIGNED_INT64_VEC3_ARB = 0x8FF6;
pub const GL_UNSIGNED_INT64_VEC4_ARB = 0x8FF7;
pub const GL_ARB_half_float_pixel = 1;
pub const GL_HALF_FLOAT_ARB = 0x140B;
pub const GL_ARB_half_float_vertex = 1;
pub const GL_ARB_indirect_parameters = 1;
pub const GL_PARAMETER_BUFFER_ARB = 0x80EE;
pub const GL_PARAMETER_BUFFER_BINDING_ARB = 0x80EF;
pub const GL_ARB_instanced_arrays = 1;
pub const GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = 0x88FE;
pub const GL_ARB_internalformat_query = 1;
pub const GL_ARB_internalformat_query2 = 1;
pub const GL_SRGB_DECODE_ARB = 0x8299;
pub const GL_VIEW_CLASS_EAC_R11 = 0x9383;
pub const GL_VIEW_CLASS_EAC_RG11 = 0x9384;
pub const GL_VIEW_CLASS_ETC2_RGB = 0x9385;
pub const GL_VIEW_CLASS_ETC2_RGBA = 0x9386;
pub const GL_VIEW_CLASS_ETC2_EAC_RGBA = 0x9387;
pub const GL_VIEW_CLASS_ASTC_4x4_RGBA = 0x9388;
pub const GL_VIEW_CLASS_ASTC_5x4_RGBA = 0x9389;
pub const GL_VIEW_CLASS_ASTC_5x5_RGBA = 0x938A;
pub const GL_VIEW_CLASS_ASTC_6x5_RGBA = 0x938B;
pub const GL_VIEW_CLASS_ASTC_6x6_RGBA = 0x938C;
pub const GL_VIEW_CLASS_ASTC_8x5_RGBA = 0x938D;
pub const GL_VIEW_CLASS_ASTC_8x6_RGBA = 0x938E;
pub const GL_VIEW_CLASS_ASTC_8x8_RGBA = 0x938F;
pub const GL_VIEW_CLASS_ASTC_10x5_RGBA = 0x9390;
pub const GL_VIEW_CLASS_ASTC_10x6_RGBA = 0x9391;
pub const GL_VIEW_CLASS_ASTC_10x8_RGBA = 0x9392;
pub const GL_VIEW_CLASS_ASTC_10x10_RGBA = 0x9393;
pub const GL_VIEW_CLASS_ASTC_12x10_RGBA = 0x9394;
pub const GL_VIEW_CLASS_ASTC_12x12_RGBA = 0x9395;
pub const GL_ARB_invalidate_subdata = 1;
pub const GL_ARB_map_buffer_alignment = 1;
pub const GL_ARB_map_buffer_range = 1;
pub const GL_ARB_matrix_palette = 1;
pub const GL_MATRIX_PALETTE_ARB = 0x8840;
pub const GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841;
pub const GL_MAX_PALETTE_MATRICES_ARB = 0x8842;
pub const GL_CURRENT_PALETTE_MATRIX_ARB = 0x8843;
pub const GL_MATRIX_INDEX_ARRAY_ARB = 0x8844;
pub const GL_CURRENT_MATRIX_INDEX_ARB = 0x8845;
pub const GL_MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846;
pub const GL_MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847;
pub const GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848;
pub const GL_MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849;
pub const GL_ARB_multi_bind = 1;
pub const GL_ARB_multi_draw_indirect = 1;
pub const GL_ARB_multisample = 1;
pub const GL_MULTISAMPLE_ARB = 0x809D;
pub const GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E;
pub const GL_SAMPLE_ALPHA_TO_ONE_ARB = 0x809F;
pub const GL_SAMPLE_COVERAGE_ARB = 0x80A0;
pub const GL_SAMPLE_BUFFERS_ARB = 0x80A8;
pub const GL_SAMPLES_ARB = 0x80A9;
pub const GL_SAMPLE_COVERAGE_VALUE_ARB = 0x80AA;
pub const GL_SAMPLE_COVERAGE_INVERT_ARB = 0x80AB;
pub const GL_MULTISAMPLE_BIT_ARB = 0x20000000;
pub const GL_ARB_occlusion_query = 1;
pub const GL_QUERY_COUNTER_BITS_ARB = 0x8864;
pub const GL_CURRENT_QUERY_ARB = 0x8865;
pub const GL_QUERY_RESULT_ARB = 0x8866;
pub const GL_QUERY_RESULT_AVAILABLE_ARB = 0x8867;
pub const GL_SAMPLES_PASSED_ARB = 0x8914;
pub const GL_ARB_occlusion_query2 = 1;
pub const GL_ARB_parallel_shader_compile = 1;
pub const GL_MAX_SHADER_COMPILER_THREADS_ARB = 0x91B0;
pub const GL_COMPLETION_STATUS_ARB = 0x91B1;
pub const GL_ARB_pipeline_statistics_query = 1;
pub const GL_VERTICES_SUBMITTED_ARB = 0x82EE;
pub const GL_PRIMITIVES_SUBMITTED_ARB = 0x82EF;
pub const GL_VERTEX_SHADER_INVOCATIONS_ARB = 0x82F0;
pub const GL_TESS_CONTROL_SHADER_PATCHES_ARB = 0x82F1;
pub const GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB = 0x82F2;
pub const GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = 0x82F3;
pub const GL_FRAGMENT_SHADER_INVOCATIONS_ARB = 0x82F4;
pub const GL_COMPUTE_SHADER_INVOCATIONS_ARB = 0x82F5;
pub const GL_CLIPPING_INPUT_PRIMITIVES_ARB = 0x82F6;
pub const GL_CLIPPING_OUTPUT_PRIMITIVES_ARB = 0x82F7;
pub const GL_ARB_pixel_buffer_object = 1;
pub const GL_PIXEL_PACK_BUFFER_ARB = 0x88EB;
pub const GL_PIXEL_UNPACK_BUFFER_ARB = 0x88EC;
pub const GL_PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED;
pub const GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF;
pub const GL_ARB_point_parameters = 1;
pub const GL_POINT_SIZE_MIN_ARB = 0x8126;
pub const GL_POINT_SIZE_MAX_ARB = 0x8127;
pub const GL_POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128;
pub const GL_POINT_DISTANCE_ATTENUATION_ARB = 0x8129;
pub const GL_ARB_point_sprite = 1;
pub const GL_POINT_SPRITE_ARB = 0x8861;
pub const GL_COORD_REPLACE_ARB = 0x8862;
pub const GL_ARB_polygon_offset_clamp = 1;
pub const GL_ARB_post_depth_coverage = 1;
pub const GL_ARB_program_interface_query = 1;
pub const GL_ARB_provoking_vertex = 1;
pub const GL_ARB_query_buffer_object = 1;
pub const GL_ARB_robust_buffer_access_behavior = 1;
pub const GL_ARB_robustness = 1;
pub const GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = 0x00000004;
pub const GL_LOSE_CONTEXT_ON_RESET_ARB = 0x8252;
pub const GL_GUILTY_CONTEXT_RESET_ARB = 0x8253;
pub const GL_INNOCENT_CONTEXT_RESET_ARB = 0x8254;
pub const GL_UNKNOWN_CONTEXT_RESET_ARB = 0x8255;
pub const GL_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256;
pub const GL_NO_RESET_NOTIFICATION_ARB = 0x8261;
pub const GL_ARB_robustness_isolation = 1;
pub const GL_ARB_sample_locations = 1;
pub const GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB = 0x933D;
pub const GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB = 0x933E;
pub const GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB = 0x933F;
pub const GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB = 0x9340;
pub const GL_SAMPLE_LOCATION_ARB = 0x8E50;
pub const GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB = 0x9341;
pub const GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB = 0x9342;
pub const GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB = 0x9343;
pub const GL_ARB_sample_shading = 1;
pub const GL_SAMPLE_SHADING_ARB = 0x8C36;
pub const GL_MIN_SAMPLE_SHADING_VALUE_ARB = 0x8C37;
pub const GL_ARB_sampler_objects = 1;
pub const GL_ARB_seamless_cube_map = 1;
pub const GL_ARB_seamless_cubemap_per_texture = 1;
pub const GL_ARB_separate_shader_objects = 1;
pub const GL_ARB_shader_atomic_counter_ops = 1;
pub const GL_ARB_shader_atomic_counters = 1;
pub const GL_ARB_shader_ballot = 1;
pub const GL_ARB_shader_bit_encoding = 1;
pub const GL_ARB_shader_clock = 1;
pub const GL_ARB_shader_draw_parameters = 1;
pub const GL_ARB_shader_group_vote = 1;
pub const GL_ARB_shader_image_load_store = 1;
pub const GL_ARB_shader_image_size = 1;
pub const GL_ARB_shader_objects = 1;
pub const GL_PROGRAM_OBJECT_ARB = 0x8B40;
pub const GL_SHADER_OBJECT_ARB = 0x8B48;
pub const GL_OBJECT_TYPE_ARB = 0x8B4E;
pub const GL_OBJECT_SUBTYPE_ARB = 0x8B4F;
pub const GL_FLOAT_VEC2_ARB = 0x8B50;
pub const GL_FLOAT_VEC3_ARB = 0x8B51;
pub const GL_FLOAT_VEC4_ARB = 0x8B52;
pub const GL_INT_VEC2_ARB = 0x8B53;
pub const GL_INT_VEC3_ARB = 0x8B54;
pub const GL_INT_VEC4_ARB = 0x8B55;
pub const GL_BOOL_ARB = 0x8B56;
pub const GL_BOOL_VEC2_ARB = 0x8B57;
pub const GL_BOOL_VEC3_ARB = 0x8B58;
pub const GL_BOOL_VEC4_ARB = 0x8B59;
pub const GL_FLOAT_MAT2_ARB = 0x8B5A;
pub const GL_FLOAT_MAT3_ARB = 0x8B5B;
pub const GL_FLOAT_MAT4_ARB = 0x8B5C;
pub const GL_SAMPLER_1D_ARB = 0x8B5D;
pub const GL_SAMPLER_2D_ARB = 0x8B5E;
pub const GL_SAMPLER_3D_ARB = 0x8B5F;
pub const GL_SAMPLER_CUBE_ARB = 0x8B60;
pub const GL_SAMPLER_1D_SHADOW_ARB = 0x8B61;
pub const GL_SAMPLER_2D_SHADOW_ARB = 0x8B62;
pub const GL_SAMPLER_2D_RECT_ARB = 0x8B63;
pub const GL_SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64;
pub const GL_OBJECT_DELETE_STATUS_ARB = 0x8B80;
pub const GL_OBJECT_COMPILE_STATUS_ARB = 0x8B81;
pub const GL_OBJECT_LINK_STATUS_ARB = 0x8B82;
pub const GL_OBJECT_VALIDATE_STATUS_ARB = 0x8B83;
pub const GL_OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84;
pub const GL_OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85;
pub const GL_OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86;
pub const GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87;
pub const GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88;
pub const GL_ARB_shader_precision = 1;
pub const GL_ARB_shader_stencil_export = 1;
pub const GL_ARB_shader_storage_buffer_object = 1;
pub const GL_ARB_shader_subroutine = 1;
pub const GL_ARB_shader_texture_image_samples = 1;
pub const GL_ARB_shader_texture_lod = 1;
pub const GL_ARB_shader_viewport_layer_array = 1;
pub const GL_ARB_shading_language_100 = 1;
pub const GL_SHADING_LANGUAGE_VERSION_ARB = 0x8B8C;
pub const GL_ARB_shading_language_420pack = 1;
pub const GL_ARB_shading_language_include = 1;
pub const GL_SHADER_INCLUDE_ARB = 0x8DAE;
pub const GL_NAMED_STRING_LENGTH_ARB = 0x8DE9;
pub const GL_NAMED_STRING_TYPE_ARB = 0x8DEA;
pub const GL_ARB_shading_language_packing = 1;
pub const GL_ARB_shadow = 1;
pub const GL_TEXTURE_COMPARE_MODE_ARB = 0x884C;
pub const GL_TEXTURE_COMPARE_FUNC_ARB = 0x884D;
pub const GL_COMPARE_R_TO_TEXTURE_ARB = 0x884E;
pub const GL_ARB_shadow_ambient = 1;
pub const GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF;
pub const GL_ARB_sparse_buffer = 1;
pub const GL_SPARSE_STORAGE_BIT_ARB = 0x0400;
pub const GL_SPARSE_BUFFER_PAGE_SIZE_ARB = 0x82F8;
pub const GL_ARB_sparse_texture = 1;
pub const GL_TEXTURE_SPARSE_ARB = 0x91A6;
pub const GL_VIRTUAL_PAGE_SIZE_INDEX_ARB = 0x91A7;
pub const GL_NUM_SPARSE_LEVELS_ARB = 0x91AA;
pub const GL_NUM_VIRTUAL_PAGE_SIZES_ARB = 0x91A8;
pub const GL_VIRTUAL_PAGE_SIZE_X_ARB = 0x9195;
pub const GL_VIRTUAL_PAGE_SIZE_Y_ARB = 0x9196;
pub const GL_VIRTUAL_PAGE_SIZE_Z_ARB = 0x9197;
pub const GL_MAX_SPARSE_TEXTURE_SIZE_ARB = 0x9198;
pub const GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB = 0x9199;
pub const GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = 0x919A;
pub const GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = 0x91A9;
pub const GL_ARB_sparse_texture2 = 1;
pub const GL_ARB_sparse_texture_clamp = 1;
pub const GL_ARB_spirv_extensions = 1;
pub const GL_ARB_stencil_texturing = 1;
pub const GL_ARB_sync = 1;
pub const GL_ARB_tessellation_shader = 1;
pub const GL_ARB_texture_barrier = 1;
pub const GL_ARB_texture_border_clamp = 1;
pub const GL_CLAMP_TO_BORDER_ARB = 0x812D;
pub const GL_ARB_texture_buffer_object = 1;
pub const GL_TEXTURE_BUFFER_ARB = 0x8C2A;
pub const GL_MAX_TEXTURE_BUFFER_SIZE_ARB = 0x8C2B;
pub const GL_TEXTURE_BINDING_BUFFER_ARB = 0x8C2C;
pub const GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 0x8C2D;
pub const GL_TEXTURE_BUFFER_FORMAT_ARB = 0x8C2E;
pub const GL_ARB_texture_buffer_object_rgb32 = 1;
pub const GL_ARB_texture_buffer_range = 1;
pub const GL_ARB_texture_compression = 1;
pub const GL_COMPRESSED_ALPHA_ARB = 0x84E9;
pub const GL_COMPRESSED_LUMINANCE_ARB = 0x84EA;
pub const GL_COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB;
pub const GL_COMPRESSED_INTENSITY_ARB = 0x84EC;
pub const GL_COMPRESSED_RGB_ARB = 0x84ED;
pub const GL_COMPRESSED_RGBA_ARB = 0x84EE;
pub const GL_TEXTURE_COMPRESSION_HINT_ARB = 0x84EF;
pub const GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0;
pub const GL_TEXTURE_COMPRESSED_ARB = 0x86A1;
pub const GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2;
pub const GL_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3;
pub const GL_ARB_texture_compression_bptc = 1;
pub const GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = 0x8E8C;
pub const GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = 0x8E8D;
pub const GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = 0x8E8E;
pub const GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = 0x8E8F;
pub const GL_ARB_texture_compression_rgtc = 1;
pub const GL_ARB_texture_cube_map = 1;
pub const GL_NORMAL_MAP_ARB = 0x8511;
pub const GL_REFLECTION_MAP_ARB = 0x8512;
pub const GL_TEXTURE_CUBE_MAP_ARB = 0x8513;
pub const GL_TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A;
pub const GL_PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B;
pub const GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C;
pub const GL_ARB_texture_cube_map_array = 1;
pub const GL_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x9009;
pub const GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = 0x900A;
pub const GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x900B;
pub const GL_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900C;
pub const GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = 0x900D;
pub const GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900E;
pub const GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900F;
pub const GL_ARB_texture_env_add = 1;
pub const GL_ARB_texture_env_combine = 1;
pub const GL_COMBINE_ARB = 0x8570;
pub const GL_COMBINE_RGB_ARB = 0x8571;
pub const GL_COMBINE_ALPHA_ARB = 0x8572;
pub const GL_SOURCE0_RGB_ARB = 0x8580;
pub const GL_SOURCE1_RGB_ARB = 0x8581;
pub const GL_SOURCE2_RGB_ARB = 0x8582;
pub const GL_SOURCE0_ALPHA_ARB = 0x8588;
pub const GL_SOURCE1_ALPHA_ARB = 0x8589;
pub const GL_SOURCE2_ALPHA_ARB = 0x858A;
pub const GL_OPERAND0_RGB_ARB = 0x8590;
pub const GL_OPERAND1_RGB_ARB = 0x8591;
pub const GL_OPERAND2_RGB_ARB = 0x8592;
pub const GL_OPERAND0_ALPHA_ARB = 0x8598;
pub const GL_OPERAND1_ALPHA_ARB = 0x8599;
pub const GL_OPERAND2_ALPHA_ARB = 0x859A;
pub const GL_RGB_SCALE_ARB = 0x8573;
pub const GL_ADD_SIGNED_ARB = 0x8574;
pub const GL_INTERPOLATE_ARB = 0x8575;
pub const GL_SUBTRACT_ARB = 0x84E7;
pub const GL_CONSTANT_ARB = 0x8576;
pub const GL_PRIMARY_COLOR_ARB = 0x8577;
pub const GL_PREVIOUS_ARB = 0x8578;
pub const GL_ARB_texture_env_crossbar = 1;
pub const GL_ARB_texture_env_dot3 = 1;
pub const GL_DOT3_RGB_ARB = 0x86AE;
pub const GL_DOT3_RGBA_ARB = 0x86AF;
pub const GL_ARB_texture_filter_anisotropic = 1;
pub const GL_ARB_texture_filter_minmax = 1;
pub const GL_TEXTURE_REDUCTION_MODE_ARB = 0x9366;
pub const GL_WEIGHTED_AVERAGE_ARB = 0x9367;
pub const GL_ARB_texture_float = 1;
pub const GL_TEXTURE_RED_TYPE_ARB = 0x8C10;
pub const GL_TEXTURE_GREEN_TYPE_ARB = 0x8C11;
pub const GL_TEXTURE_BLUE_TYPE_ARB = 0x8C12;
pub const GL_TEXTURE_ALPHA_TYPE_ARB = 0x8C13;
pub const GL_TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14;
pub const GL_TEXTURE_INTENSITY_TYPE_ARB = 0x8C15;
pub const GL_TEXTURE_DEPTH_TYPE_ARB = 0x8C16;
pub const GL_UNSIGNED_NORMALIZED_ARB = 0x8C17;
pub const GL_RGBA32F_ARB = 0x8814;
pub const GL_RGB32F_ARB = 0x8815;
pub const GL_ALPHA32F_ARB = 0x8816;
pub const GL_INTENSITY32F_ARB = 0x8817;
pub const GL_LUMINANCE32F_ARB = 0x8818;
pub const GL_LUMINANCE_ALPHA32F_ARB = 0x8819;
pub const GL_RGBA16F_ARB = 0x881A;
pub const GL_RGB16F_ARB = 0x881B;
pub const GL_ALPHA16F_ARB = 0x881C;
pub const GL_INTENSITY16F_ARB = 0x881D;
pub const GL_LUMINANCE16F_ARB = 0x881E;
pub const GL_LUMINANCE_ALPHA16F_ARB = 0x881F;
pub const GL_ARB_texture_gather = 1;
pub const GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5E;
pub const GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5F;
pub const GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB = 0x8F9F;
pub const GL_ARB_texture_mirror_clamp_to_edge = 1;
pub const GL_ARB_texture_mirrored_repeat = 1;
pub const GL_MIRRORED_REPEAT_ARB = 0x8370;
pub const GL_ARB_texture_multisample = 1;
pub const GL_ARB_texture_non_power_of_two = 1;
pub const GL_ARB_texture_query_levels = 1;
pub const GL_ARB_texture_query_lod = 1;
pub const GL_ARB_texture_rectangle = 1;
pub const GL_TEXTURE_RECTANGLE_ARB = 0x84F5;
pub const GL_TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6;
pub const GL_PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7;
pub const GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8;
pub const GL_ARB_texture_rg = 1;
pub const GL_ARB_texture_rgb10_a2ui = 1;
pub const GL_ARB_texture_stencil8 = 1;
pub const GL_ARB_texture_storage = 1;
pub const GL_ARB_texture_storage_multisample = 1;
pub const GL_ARB_texture_swizzle = 1;
pub const GL_ARB_texture_view = 1;
pub const GL_ARB_timer_query = 1;
pub const GL_ARB_transform_feedback2 = 1;
pub const GL_ARB_transform_feedback3 = 1;
pub const GL_ARB_transform_feedback_instanced = 1;
pub const GL_ARB_transform_feedback_overflow_query = 1;
pub const GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB = 0x82EC;
pub const GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = 0x82ED;
pub const GL_ARB_transpose_matrix = 1;
pub const GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3;
pub const GL_TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4;
pub const GL_TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5;
pub const GL_TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6;
pub const GL_ARB_uniform_buffer_object = 1;
pub const GL_ARB_vertex_array_bgra = 1;
pub const GL_ARB_vertex_array_object = 1;
pub const GL_ARB_vertex_attrib_64bit = 1;
pub const GL_ARB_vertex_attrib_binding = 1;
pub const GL_ARB_vertex_blend = 1;
pub const GL_MAX_VERTEX_UNITS_ARB = 0x86A4;
pub const GL_ACTIVE_VERTEX_UNITS_ARB = 0x86A5;
pub const GL_WEIGHT_SUM_UNITY_ARB = 0x86A6;
pub const GL_VERTEX_BLEND_ARB = 0x86A7;
pub const GL_CURRENT_WEIGHT_ARB = 0x86A8;
pub const GL_WEIGHT_ARRAY_TYPE_ARB = 0x86A9;
pub const GL_WEIGHT_ARRAY_STRIDE_ARB = 0x86AA;
pub const GL_WEIGHT_ARRAY_SIZE_ARB = 0x86AB;
pub const GL_WEIGHT_ARRAY_POINTER_ARB = 0x86AC;
pub const GL_WEIGHT_ARRAY_ARB = 0x86AD;
pub const GL_MODELVIEW0_ARB = 0x1700;
pub const GL_MODELVIEW1_ARB = 0x850A;
pub const GL_MODELVIEW2_ARB = 0x8722;
pub const GL_MODELVIEW3_ARB = 0x8723;
pub const GL_MODELVIEW4_ARB = 0x8724;
pub const GL_MODELVIEW5_ARB = 0x8725;
pub const GL_MODELVIEW6_ARB = 0x8726;
pub const GL_MODELVIEW7_ARB = 0x8727;
pub const GL_MODELVIEW8_ARB = 0x8728;
pub const GL_MODELVIEW9_ARB = 0x8729;
pub const GL_MODELVIEW10_ARB = 0x872A;
pub const GL_MODELVIEW11_ARB = 0x872B;
pub const GL_MODELVIEW12_ARB = 0x872C;
pub const GL_MODELVIEW13_ARB = 0x872D;
pub const GL_MODELVIEW14_ARB = 0x872E;
pub const GL_MODELVIEW15_ARB = 0x872F;
pub const GL_MODELVIEW16_ARB = 0x8730;
pub const GL_MODELVIEW17_ARB = 0x8731;
pub const GL_MODELVIEW18_ARB = 0x8732;
pub const GL_MODELVIEW19_ARB = 0x8733;
pub const GL_MODELVIEW20_ARB = 0x8734;
pub const GL_MODELVIEW21_ARB = 0x8735;
pub const GL_MODELVIEW22_ARB = 0x8736;
pub const GL_MODELVIEW23_ARB = 0x8737;
pub const GL_MODELVIEW24_ARB = 0x8738;
pub const GL_MODELVIEW25_ARB = 0x8739;
pub const GL_MODELVIEW26_ARB = 0x873A;
pub const GL_MODELVIEW27_ARB = 0x873B;
pub const GL_MODELVIEW28_ARB = 0x873C;
pub const GL_MODELVIEW29_ARB = 0x873D;
pub const GL_MODELVIEW30_ARB = 0x873E;
pub const GL_MODELVIEW31_ARB = 0x873F;
pub const GL_ARB_vertex_buffer_object = 1;
pub const GL_BUFFER_SIZE_ARB = 0x8764;
pub const GL_BUFFER_USAGE_ARB = 0x8765;
pub const GL_ARRAY_BUFFER_ARB = 0x8892;
pub const GL_ELEMENT_ARRAY_BUFFER_ARB = 0x8893;
pub const GL_ARRAY_BUFFER_BINDING_ARB = 0x8894;
pub const GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895;
pub const GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896;
pub const GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897;
pub const GL_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898;
pub const GL_INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899;
pub const GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A;
pub const GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B;
pub const GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C;
pub const GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D;
pub const GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E;
pub const GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F;
pub const GL_READ_ONLY_ARB = 0x88B8;
pub const GL_WRITE_ONLY_ARB = 0x88B9;
pub const GL_READ_WRITE_ARB = 0x88BA;
pub const GL_BUFFER_ACCESS_ARB = 0x88BB;
pub const GL_BUFFER_MAPPED_ARB = 0x88BC;
pub const GL_BUFFER_MAP_POINTER_ARB = 0x88BD;
pub const GL_STREAM_DRAW_ARB = 0x88E0;
pub const GL_STREAM_READ_ARB = 0x88E1;
pub const GL_STREAM_COPY_ARB = 0x88E2;
pub const GL_STATIC_DRAW_ARB = 0x88E4;
pub const GL_STATIC_READ_ARB = 0x88E5;
pub const GL_STATIC_COPY_ARB = 0x88E6;
pub const GL_DYNAMIC_DRAW_ARB = 0x88E8;
pub const GL_DYNAMIC_READ_ARB = 0x88E9;
pub const GL_DYNAMIC_COPY_ARB = 0x88EA;
pub const GL_ARB_vertex_program = 1;
pub const GL_COLOR_SUM_ARB = 0x8458;
pub const GL_VERTEX_PROGRAM_ARB = 0x8620;
pub const GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622;
pub const GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623;
pub const GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624;
pub const GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625;
pub const GL_CURRENT_VERTEX_ATTRIB_ARB = 0x8626;
pub const GL_VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642;
pub const GL_VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643;
pub const GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645;
pub const GL_MAX_VERTEX_ATTRIBS_ARB = 0x8869;
pub const GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A;
pub const GL_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0;
pub const GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1;
pub const GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2;
pub const GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3;
pub const GL_ARB_vertex_shader = 1;
pub const GL_VERTEX_SHADER_ARB = 0x8B31;
pub const GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A;
pub const GL_MAX_VARYING_FLOATS_ARB = 0x8B4B;
pub const GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C;
pub const GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D;
pub const GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89;
pub const GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A;
pub const GL_ARB_vertex_type_10f_11f_11f_rev = 1;
pub const GL_ARB_vertex_type_2_10_10_10_rev = 1;
pub const GL_ARB_viewport_array = 1;
pub const GL_ARB_window_pos = 1;
pub const GL_KHR_blend_equation_advanced = 1;
pub const GL_MULTIPLY_KHR = 0x9294;
pub const GL_SCREEN_KHR = 0x9295;
pub const GL_OVERLAY_KHR = 0x9296;
pub const GL_DARKEN_KHR = 0x9297;
pub const GL_LIGHTEN_KHR = 0x9298;
pub const GL_COLORDODGE_KHR = 0x9299;
pub const GL_COLORBURN_KHR = 0x929A;
pub const GL_HARDLIGHT_KHR = 0x929B;
pub const GL_SOFTLIGHT_KHR = 0x929C;
pub const GL_DIFFERENCE_KHR = 0x929E;
pub const GL_EXCLUSION_KHR = 0x92A0;
pub const GL_HSL_HUE_KHR = 0x92AD;
pub const GL_HSL_SATURATION_KHR = 0x92AE;
pub const GL_HSL_COLOR_KHR = 0x92AF;
pub const GL_HSL_LUMINOSITY_KHR = 0x92B0;
pub const GL_KHR_blend_equation_advanced_coherent = 1;
pub const GL_BLEND_ADVANCED_COHERENT_KHR = 0x9285;
pub const GL_KHR_context_flush_control = 1;
pub const GL_KHR_debug = 1;
pub const GL_KHR_no_error = 1;
pub const GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR = 0x00000008;
pub const GL_KHR_parallel_shader_compile = 1;
pub const GL_MAX_SHADER_COMPILER_THREADS_KHR = 0x91B0;
pub const GL_COMPLETION_STATUS_KHR = 0x91B1;
pub const GL_KHR_robust_buffer_access_behavior = 1;
pub const GL_KHR_robustness = 1;
pub const GL_CONTEXT_ROBUST_ACCESS = 0x90F3;
pub const GL_KHR_shader_subgroup = 1;
pub const GL_SUBGROUP_SIZE_KHR = 0x9532;
pub const GL_SUBGROUP_SUPPORTED_STAGES_KHR = 0x9533;
pub const GL_SUBGROUP_SUPPORTED_FEATURES_KHR = 0x9534;
pub const GL_SUBGROUP_QUAD_ALL_STAGES_KHR = 0x9535;
pub const GL_SUBGROUP_FEATURE_BASIC_BIT_KHR = 0x00000001;
pub const GL_SUBGROUP_FEATURE_VOTE_BIT_KHR = 0x00000002;
pub const GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR = 0x00000004;
pub const GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR = 0x00000008;
pub const GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR = 0x00000010;
pub const GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR = 0x00000020;
pub const GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR = 0x00000040;
pub const GL_SUBGROUP_FEATURE_QUAD_BIT_KHR = 0x00000080;
pub const GL_KHR_texture_compression_astc_hdr = 1;
pub const GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0;
pub const GL_COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1;
pub const GL_COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2;
pub const GL_COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3;
pub const GL_COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4;
pub const GL_COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5;
pub const GL_COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6;
pub const GL_COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7;
pub const GL_COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8;
pub const GL_COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9;
pub const GL_COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA;
pub const GL_COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB;
pub const GL_COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC;
pub const GL_COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC;
pub const GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD;
pub const GL_KHR_texture_compression_astc_ldr = 1;
pub const GL_KHR_texture_compression_astc_sliced_3d = 1;
pub const GL_OES_byte_coordinates = 1;
pub const GL_OES_compressed_paletted_texture = 1;
pub const GL_PALETTE4_RGB8_OES = 0x8B90;
pub const GL_PALETTE4_RGBA8_OES = 0x8B91;
pub const GL_PALETTE4_R5_G6_B5_OES = 0x8B92;
pub const GL_PALETTE4_RGBA4_OES = 0x8B93;
pub const GL_PALETTE4_RGB5_A1_OES = 0x8B94;
pub const GL_PALETTE8_RGB8_OES = 0x8B95;
pub const GL_PALETTE8_RGBA8_OES = 0x8B96;
pub const GL_PALETTE8_R5_G6_B5_OES = 0x8B97;
pub const GL_PALETTE8_RGBA4_OES = 0x8B98;
pub const GL_PALETTE8_RGB5_A1_OES = 0x8B99;
pub const GL_OES_fixed_point = 1;
pub const GL_FIXED_OES = 0x140C;
pub const GL_OES_query_matrix = 1;
pub const GL_OES_read_format = 1;
pub const GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A;
pub const GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B;
pub const GL_OES_single_precision = 1;
pub const GL_3DFX_multisample = 1;
pub const GL_MULTISAMPLE_3DFX = 0x86B2;
pub const GL_SAMPLE_BUFFERS_3DFX = 0x86B3;
pub const GL_SAMPLES_3DFX = 0x86B4;
pub const GL_MULTISAMPLE_BIT_3DFX = 0x20000000;
pub const GL_3DFX_tbuffer = 1;
pub const GL_3DFX_texture_compression_FXT1 = 1;
pub const GL_COMPRESSED_RGB_FXT1_3DFX = 0x86B0;
pub const GL_COMPRESSED_RGBA_FXT1_3DFX = 0x86B1;
pub const GL_AMD_blend_minmax_factor = 1;
pub const GL_FACTOR_MIN_AMD = 0x901C;
pub const GL_FACTOR_MAX_AMD = 0x901D;
pub const GL_AMD_conservative_depth = 1;
pub const GL_AMD_debug_output = 1;
pub const GL_MAX_DEBUG_MESSAGE_LENGTH_AMD = 0x9143;
pub const GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = 0x9144;
pub const GL_DEBUG_LOGGED_MESSAGES_AMD = 0x9145;
pub const GL_DEBUG_SEVERITY_HIGH_AMD = 0x9146;
pub const GL_DEBUG_SEVERITY_MEDIUM_AMD = 0x9147;
pub const GL_DEBUG_SEVERITY_LOW_AMD = 0x9148;
pub const GL_DEBUG_CATEGORY_API_ERROR_AMD = 0x9149;
pub const GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = 0x914A;
pub const GL_DEBUG_CATEGORY_DEPRECATION_AMD = 0x914B;
pub const GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = 0x914C;
pub const GL_DEBUG_CATEGORY_PERFORMANCE_AMD = 0x914D;
pub const GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = 0x914E;
pub const GL_DEBUG_CATEGORY_APPLICATION_AMD = 0x914F;
pub const GL_DEBUG_CATEGORY_OTHER_AMD = 0x9150;
pub const GL_AMD_depth_clamp_separate = 1;
pub const GL_DEPTH_CLAMP_NEAR_AMD = 0x901E;
pub const GL_DEPTH_CLAMP_FAR_AMD = 0x901F;
pub const GL_AMD_draw_buffers_blend = 1;
pub const GL_AMD_framebuffer_multisample_advanced = 1;
pub const GL_RENDERBUFFER_STORAGE_SAMPLES_AMD = 0x91B2;
pub const GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD = 0x91B3;
pub const GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD = 0x91B4;
pub const GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD = 0x91B5;
pub const GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD = 0x91B6;
pub const GL_SUPPORTED_MULTISAMPLE_MODES_AMD = 0x91B7;
pub const GL_AMD_framebuffer_sample_positions = 1;
pub const GL_SUBSAMPLE_DISTANCE_AMD = 0x883F;
pub const GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD = 0x91AE;
pub const GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD = 0x91AF;
pub const GL_ALL_PIXELS_AMD = 0xFFFFFFFF;
pub const GL_AMD_gcn_shader = 1;
pub const GL_AMD_gpu_shader_half_float = 1;
pub const GL_FLOAT16_NV = 0x8FF8;
pub const GL_FLOAT16_VEC2_NV = 0x8FF9;
pub const GL_FLOAT16_VEC3_NV = 0x8FFA;
pub const GL_FLOAT16_VEC4_NV = 0x8FFB;
pub const GL_FLOAT16_MAT2_AMD = 0x91C5;
pub const GL_FLOAT16_MAT3_AMD = 0x91C6;
pub const GL_FLOAT16_MAT4_AMD = 0x91C7;
pub const GL_FLOAT16_MAT2x3_AMD = 0x91C8;
pub const GL_FLOAT16_MAT2x4_AMD = 0x91C9;
pub const GL_FLOAT16_MAT3x2_AMD = 0x91CA;
pub const GL_FLOAT16_MAT3x4_AMD = 0x91CB;
pub const GL_FLOAT16_MAT4x2_AMD = 0x91CC;
pub const GL_FLOAT16_MAT4x3_AMD = 0x91CD;
pub const GL_AMD_gpu_shader_int16 = 1;
pub const GL_AMD_gpu_shader_int64 = 1;
pub const GL_INT64_NV = 0x140E;
pub const GL_UNSIGNED_INT64_NV = 0x140F;
pub const GL_INT8_NV = 0x8FE0;
pub const GL_INT8_VEC2_NV = 0x8FE1;
pub const GL_INT8_VEC3_NV = 0x8FE2;
pub const GL_INT8_VEC4_NV = 0x8FE3;
pub const GL_INT16_NV = 0x8FE4;
pub const GL_INT16_VEC2_NV = 0x8FE5;
pub const GL_INT16_VEC3_NV = 0x8FE6;
pub const GL_INT16_VEC4_NV = 0x8FE7;
pub const GL_INT64_VEC2_NV = 0x8FE9;
pub const GL_INT64_VEC3_NV = 0x8FEA;
pub const GL_INT64_VEC4_NV = 0x8FEB;
pub const GL_UNSIGNED_INT8_NV = 0x8FEC;
pub const GL_UNSIGNED_INT8_VEC2_NV = 0x8FED;
pub const GL_UNSIGNED_INT8_VEC3_NV = 0x8FEE;
pub const GL_UNSIGNED_INT8_VEC4_NV = 0x8FEF;
pub const GL_UNSIGNED_INT16_NV = 0x8FF0;
pub const GL_UNSIGNED_INT16_VEC2_NV = 0x8FF1;
pub const GL_UNSIGNED_INT16_VEC3_NV = 0x8FF2;
pub const GL_UNSIGNED_INT16_VEC4_NV = 0x8FF3;
pub const GL_UNSIGNED_INT64_VEC2_NV = 0x8FF5;
pub const GL_UNSIGNED_INT64_VEC3_NV = 0x8FF6;
pub const GL_UNSIGNED_INT64_VEC4_NV = 0x8FF7;
pub const GL_AMD_interleaved_elements = 1;
pub const GL_VERTEX_ELEMENT_SWIZZLE_AMD = 0x91A4;
pub const GL_VERTEX_ID_SWIZZLE_AMD = 0x91A5;
pub const GL_AMD_multi_draw_indirect = 1;
pub const GL_AMD_name_gen_delete = 1;
pub const GL_DATA_BUFFER_AMD = 0x9151;
pub const GL_PERFORMANCE_MONITOR_AMD = 0x9152;
pub const GL_QUERY_OBJECT_AMD = 0x9153;
pub const GL_VERTEX_ARRAY_OBJECT_AMD = 0x9154;
pub const GL_SAMPLER_OBJECT_AMD = 0x9155;
pub const GL_AMD_occlusion_query_event = 1;
pub const GL_OCCLUSION_QUERY_EVENT_MASK_AMD = 0x874F;
pub const GL_QUERY_DEPTH_PASS_EVENT_BIT_AMD = 0x00000001;
pub const GL_QUERY_DEPTH_FAIL_EVENT_BIT_AMD = 0x00000002;
pub const GL_QUERY_STENCIL_FAIL_EVENT_BIT_AMD = 0x00000004;
pub const GL_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD = 0x00000008;
pub const GL_QUERY_ALL_EVENT_BITS_AMD = 0xFFFFFFFF;
pub const GL_AMD_performance_monitor = 1;
pub const GL_COUNTER_TYPE_AMD = 0x8BC0;
pub const GL_COUNTER_RANGE_AMD = 0x8BC1;
pub const GL_UNSIGNED_INT64_AMD = 0x8BC2;
pub const GL_PERCENTAGE_AMD = 0x8BC3;
pub const GL_PERFMON_RESULT_AVAILABLE_AMD = 0x8BC4;
pub const GL_PERFMON_RESULT_SIZE_AMD = 0x8BC5;
pub const GL_PERFMON_RESULT_AMD = 0x8BC6;
pub const GL_AMD_pinned_memory = 1;
pub const GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD = 0x9160;
pub const GL_AMD_query_buffer_object = 1;
pub const GL_QUERY_BUFFER_AMD = 0x9192;
pub const GL_QUERY_BUFFER_BINDING_AMD = 0x9193;
pub const GL_QUERY_RESULT_NO_WAIT_AMD = 0x9194;
pub const GL_AMD_sample_positions = 1;
pub const GL_AMD_seamless_cubemap_per_texture = 1;
pub const GL_AMD_shader_atomic_counter_ops = 1;
pub const GL_AMD_shader_ballot = 1;
pub const GL_AMD_shader_explicit_vertex_parameter = 1;
pub const GL_AMD_shader_gpu_shader_half_float_fetch = 1;
pub const GL_AMD_shader_image_load_store_lod = 1;
pub const GL_AMD_shader_stencil_export = 1;
pub const GL_AMD_shader_trinary_minmax = 1;
pub const GL_AMD_sparse_texture = 1;
pub const GL_VIRTUAL_PAGE_SIZE_X_AMD = 0x9195;
pub const GL_VIRTUAL_PAGE_SIZE_Y_AMD = 0x9196;
pub const GL_VIRTUAL_PAGE_SIZE_Z_AMD = 0x9197;
pub const GL_MAX_SPARSE_TEXTURE_SIZE_AMD = 0x9198;
pub const GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD = 0x9199;
pub const GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS = 0x919A;
pub const GL_MIN_SPARSE_LEVEL_AMD = 0x919B;
pub const GL_MIN_LOD_WARNING_AMD = 0x919C;
pub const GL_TEXTURE_STORAGE_SPARSE_BIT_AMD = 0x00000001;
pub const GL_AMD_stencil_operation_extended = 1;
pub const GL_SET_AMD = 0x874A;
pub const GL_REPLACE_VALUE_AMD = 0x874B;
pub const GL_STENCIL_OP_VALUE_AMD = 0x874C;
pub const GL_STENCIL_BACK_OP_VALUE_AMD = 0x874D;
pub const GL_AMD_texture_gather_bias_lod = 1;
pub const GL_AMD_texture_texture4 = 1;
pub const GL_AMD_transform_feedback3_lines_triangles = 1;
pub const GL_AMD_transform_feedback4 = 1;
pub const GL_STREAM_RASTERIZATION_AMD = 0x91A0;
pub const GL_AMD_vertex_shader_layer = 1;
pub const GL_AMD_vertex_shader_tessellator = 1;
pub const GL_SAMPLER_BUFFER_AMD = 0x9001;
pub const GL_INT_SAMPLER_BUFFER_AMD = 0x9002;
pub const GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = 0x9003;
pub const GL_TESSELLATION_MODE_AMD = 0x9004;
pub const GL_TESSELLATION_FACTOR_AMD = 0x9005;
pub const GL_DISCRETE_AMD = 0x9006;
pub const GL_CONTINUOUS_AMD = 0x9007;
pub const GL_AMD_vertex_shader_viewport_index = 1;
pub const GL_APPLE_aux_depth_stencil = 1;
pub const GL_AUX_DEPTH_STENCIL_APPLE = 0x8A14;
pub const GL_APPLE_client_storage = 1;
pub const GL_UNPACK_CLIENT_STORAGE_APPLE = 0x85B2;
pub const GL_APPLE_element_array = 1;
pub const GL_ELEMENT_ARRAY_APPLE = 0x8A0C;
pub const GL_ELEMENT_ARRAY_TYPE_APPLE = 0x8A0D;
pub const GL_ELEMENT_ARRAY_POINTER_APPLE = 0x8A0E;
pub const GL_APPLE_fence = 1;
pub const GL_DRAW_PIXELS_APPLE = 0x8A0A;
pub const GL_FENCE_APPLE = 0x8A0B;
pub const GL_APPLE_float_pixels = 1;
pub const GL_HALF_APPLE = 0x140B;
pub const GL_RGBA_FLOAT32_APPLE = 0x8814;
pub const GL_RGB_FLOAT32_APPLE = 0x8815;
pub const GL_ALPHA_FLOAT32_APPLE = 0x8816;
pub const GL_INTENSITY_FLOAT32_APPLE = 0x8817;
pub const GL_LUMINANCE_FLOAT32_APPLE = 0x8818;
pub const GL_LUMINANCE_ALPHA_FLOAT32_APPLE = 0x8819;
pub const GL_RGBA_FLOAT16_APPLE = 0x881A;
pub const GL_RGB_FLOAT16_APPLE = 0x881B;
pub const GL_ALPHA_FLOAT16_APPLE = 0x881C;
pub const GL_INTENSITY_FLOAT16_APPLE = 0x881D;
pub const GL_LUMINANCE_FLOAT16_APPLE = 0x881E;
pub const GL_LUMINANCE_ALPHA_FLOAT16_APPLE = 0x881F;
pub const GL_COLOR_FLOAT_APPLE = 0x8A0F;
pub const GL_APPLE_flush_buffer_range = 1;
pub const GL_BUFFER_SERIALIZED_MODIFY_APPLE = 0x8A12;
pub const GL_BUFFER_FLUSHING_UNMAP_APPLE = 0x8A13;
pub const GL_APPLE_object_purgeable = 1;
pub const GL_BUFFER_OBJECT_APPLE = 0x85B3;
pub const GL_RELEASED_APPLE = 0x8A19;
pub const GL_VOLATILE_APPLE = 0x8A1A;
pub const GL_RETAINED_APPLE = 0x8A1B;
pub const GL_UNDEFINED_APPLE = 0x8A1C;
pub const GL_PURGEABLE_APPLE = 0x8A1D;
pub const GL_APPLE_rgb_422 = 1;
pub const GL_RGB_422_APPLE = 0x8A1F;
pub const GL_UNSIGNED_SHORT_8_8_APPLE = 0x85BA;
pub const GL_UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB;
pub const GL_RGB_RAW_422_APPLE = 0x8A51;
pub const GL_APPLE_row_bytes = 1;
pub const GL_PACK_ROW_BYTES_APPLE = 0x8A15;
pub const GL_UNPACK_ROW_BYTES_APPLE = 0x8A16;
pub const GL_APPLE_specular_vector = 1;
pub const GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0;
pub const GL_APPLE_texture_range = 1;
pub const GL_TEXTURE_RANGE_LENGTH_APPLE = 0x85B7;
pub const GL_TEXTURE_RANGE_POINTER_APPLE = 0x85B8;
pub const GL_TEXTURE_STORAGE_HINT_APPLE = 0x85BC;
pub const GL_STORAGE_PRIVATE_APPLE = 0x85BD;
pub const GL_STORAGE_CACHED_APPLE = 0x85BE;
pub const GL_STORAGE_SHARED_APPLE = 0x85BF;
pub const GL_APPLE_transform_hint = 1;
pub const GL_TRANSFORM_HINT_APPLE = 0x85B1;
pub const GL_APPLE_vertex_array_object = 1;
pub const GL_VERTEX_ARRAY_BINDING_APPLE = 0x85B5;
pub const GL_APPLE_vertex_array_range = 1;
pub const GL_VERTEX_ARRAY_RANGE_APPLE = 0x851D;
pub const GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E;
pub const GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F;
pub const GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521;
pub const GL_STORAGE_CLIENT_APPLE = 0x85B4;
pub const GL_APPLE_vertex_program_evaluators = 1;
pub const GL_VERTEX_ATTRIB_MAP1_APPLE = 0x8A00;
pub const GL_VERTEX_ATTRIB_MAP2_APPLE = 0x8A01;
pub const GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = 0x8A02;
pub const GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = 0x8A03;
pub const GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = 0x8A04;
pub const GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = 0x8A05;
pub const GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = 0x8A06;
pub const GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = 0x8A07;
pub const GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = 0x8A08;
pub const GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = 0x8A09;
pub const GL_APPLE_ycbcr_422 = 1;
pub const GL_YCBCR_422_APPLE = 0x85B9;
pub const GL_ATI_draw_buffers = 1;
pub const GL_MAX_DRAW_BUFFERS_ATI = 0x8824;
pub const GL_DRAW_BUFFER0_ATI = 0x8825;
pub const GL_DRAW_BUFFER1_ATI = 0x8826;
pub const GL_DRAW_BUFFER2_ATI = 0x8827;
pub const GL_DRAW_BUFFER3_ATI = 0x8828;
pub const GL_DRAW_BUFFER4_ATI = 0x8829;
pub const GL_DRAW_BUFFER5_ATI = 0x882A;
pub const GL_DRAW_BUFFER6_ATI = 0x882B;
pub const GL_DRAW_BUFFER7_ATI = 0x882C;
pub const GL_DRAW_BUFFER8_ATI = 0x882D;
pub const GL_DRAW_BUFFER9_ATI = 0x882E;
pub const GL_DRAW_BUFFER10_ATI = 0x882F;
pub const GL_DRAW_BUFFER11_ATI = 0x8830;
pub const GL_DRAW_BUFFER12_ATI = 0x8831;
pub const GL_DRAW_BUFFER13_ATI = 0x8832;
pub const GL_DRAW_BUFFER14_ATI = 0x8833;
pub const GL_DRAW_BUFFER15_ATI = 0x8834;
pub const GL_ATI_element_array = 1;
pub const GL_ELEMENT_ARRAY_ATI = 0x8768;
pub const GL_ELEMENT_ARRAY_TYPE_ATI = 0x8769;
pub const GL_ELEMENT_ARRAY_POINTER_ATI = 0x876A;
pub const GL_ATI_envmap_bumpmap = 1;
pub const GL_BUMP_ROT_MATRIX_ATI = 0x8775;
pub const GL_BUMP_ROT_MATRIX_SIZE_ATI = 0x8776;
pub const GL_BUMP_NUM_TEX_UNITS_ATI = 0x8777;
pub const GL_BUMP_TEX_UNITS_ATI = 0x8778;
pub const GL_DUDV_ATI = 0x8779;
pub const GL_DU8DV8_ATI = 0x877A;
pub const GL_BUMP_ENVMAP_ATI = 0x877B;
pub const GL_BUMP_TARGET_ATI = 0x877C;
pub const GL_ATI_fragment_shader = 1;
pub const GL_FRAGMENT_SHADER_ATI = 0x8920;
pub const GL_REG_0_ATI = 0x8921;
pub const GL_REG_1_ATI = 0x8922;
pub const GL_REG_2_ATI = 0x8923;
pub const GL_REG_3_ATI = 0x8924;
pub const GL_REG_4_ATI = 0x8925;
pub const GL_REG_5_ATI = 0x8926;
pub const GL_REG_6_ATI = 0x8927;
pub const GL_REG_7_ATI = 0x8928;
pub const GL_REG_8_ATI = 0x8929;
pub const GL_REG_9_ATI = 0x892A;
pub const GL_REG_10_ATI = 0x892B;
pub const GL_REG_11_ATI = 0x892C;
pub const GL_REG_12_ATI = 0x892D;
pub const GL_REG_13_ATI = 0x892E;
pub const GL_REG_14_ATI = 0x892F;
pub const GL_REG_15_ATI = 0x8930;
pub const GL_REG_16_ATI = 0x8931;
pub const GL_REG_17_ATI = 0x8932;
pub const GL_REG_18_ATI = 0x8933;
pub const GL_REG_19_ATI = 0x8934;
pub const GL_REG_20_ATI = 0x8935;
pub const GL_REG_21_ATI = 0x8936;
pub const GL_REG_22_ATI = 0x8937;
pub const GL_REG_23_ATI = 0x8938;
pub const GL_REG_24_ATI = 0x8939;
pub const GL_REG_25_ATI = 0x893A;
pub const GL_REG_26_ATI = 0x893B;
pub const GL_REG_27_ATI = 0x893C;
pub const GL_REG_28_ATI = 0x893D;
pub const GL_REG_29_ATI = 0x893E;
pub const GL_REG_30_ATI = 0x893F;
pub const GL_REG_31_ATI = 0x8940;
pub const GL_CON_0_ATI = 0x8941;
pub const GL_CON_1_ATI = 0x8942;
pub const GL_CON_2_ATI = 0x8943;
pub const GL_CON_3_ATI = 0x8944;
pub const GL_CON_4_ATI = 0x8945;
pub const GL_CON_5_ATI = 0x8946;
pub const GL_CON_6_ATI = 0x8947;
pub const GL_CON_7_ATI = 0x8948;
pub const GL_CON_8_ATI = 0x8949;
pub const GL_CON_9_ATI = 0x894A;
pub const GL_CON_10_ATI = 0x894B;
pub const GL_CON_11_ATI = 0x894C;
pub const GL_CON_12_ATI = 0x894D;
pub const GL_CON_13_ATI = 0x894E;
pub const GL_CON_14_ATI = 0x894F;
pub const GL_CON_15_ATI = 0x8950;
pub const GL_CON_16_ATI = 0x8951;
pub const GL_CON_17_ATI = 0x8952;
pub const GL_CON_18_ATI = 0x8953;
pub const GL_CON_19_ATI = 0x8954;
pub const GL_CON_20_ATI = 0x8955;
pub const GL_CON_21_ATI = 0x8956;
pub const GL_CON_22_ATI = 0x8957;
pub const GL_CON_23_ATI = 0x8958;
pub const GL_CON_24_ATI = 0x8959;
pub const GL_CON_25_ATI = 0x895A;
pub const GL_CON_26_ATI = 0x895B;
pub const GL_CON_27_ATI = 0x895C;
pub const GL_CON_28_ATI = 0x895D;
pub const GL_CON_29_ATI = 0x895E;
pub const GL_CON_30_ATI = 0x895F;
pub const GL_CON_31_ATI = 0x8960;
pub const GL_MOV_ATI = 0x8961;
pub const GL_ADD_ATI = 0x8963;
pub const GL_MUL_ATI = 0x8964;
pub const GL_SUB_ATI = 0x8965;
pub const GL_DOT3_ATI = 0x8966;
pub const GL_DOT4_ATI = 0x8967;
pub const GL_MAD_ATI = 0x8968;
pub const GL_LERP_ATI = 0x8969;
pub const GL_CND_ATI = 0x896A;
pub const GL_CND0_ATI = 0x896B;
pub const GL_DOT2_ADD_ATI = 0x896C;
pub const GL_SECONDARY_INTERPOLATOR_ATI = 0x896D;
pub const GL_NUM_FRAGMENT_REGISTERS_ATI = 0x896E;
pub const GL_NUM_FRAGMENT_CONSTANTS_ATI = 0x896F;
pub const GL_NUM_PASSES_ATI = 0x8970;
pub const GL_NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971;
pub const GL_NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972;
pub const GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973;
pub const GL_NUM_LOOPBACK_COMPONENTS_ATI = 0x8974;
pub const GL_COLOR_ALPHA_PAIRING_ATI = 0x8975;
pub const GL_SWIZZLE_STR_ATI = 0x8976;
pub const GL_SWIZZLE_STQ_ATI = 0x8977;
pub const GL_SWIZZLE_STR_DR_ATI = 0x8978;
pub const GL_SWIZZLE_STQ_DQ_ATI = 0x8979;
pub const GL_SWIZZLE_STRQ_ATI = 0x897A;
pub const GL_SWIZZLE_STRQ_DQ_ATI = 0x897B;
pub const GL_RED_BIT_ATI = 0x00000001;
pub const GL_GREEN_BIT_ATI = 0x00000002;
pub const GL_BLUE_BIT_ATI = 0x00000004;
pub const GL_2X_BIT_ATI = 0x00000001;
pub const GL_4X_BIT_ATI = 0x00000002;
pub const GL_8X_BIT_ATI = 0x00000004;
pub const GL_HALF_BIT_ATI = 0x00000008;
pub const GL_QUARTER_BIT_ATI = 0x00000010;
pub const GL_EIGHTH_BIT_ATI = 0x00000020;
pub const GL_SATURATE_BIT_ATI = 0x00000040;
pub const GL_COMP_BIT_ATI = 0x00000002;
pub const GL_NEGATE_BIT_ATI = 0x00000004;
pub const GL_BIAS_BIT_ATI = 0x00000008;
pub const GL_ATI_map_object_buffer = 1;
pub const GL_ATI_meminfo = 1;
pub const GL_VBO_FREE_MEMORY_ATI = 0x87FB;
pub const GL_TEXTURE_FREE_MEMORY_ATI = 0x87FC;
pub const GL_RENDERBUFFER_FREE_MEMORY_ATI = 0x87FD;
pub const GL_ATI_pixel_format_float = 1;
pub const GL_RGBA_FLOAT_MODE_ATI = 0x8820;
pub const GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835;
pub const GL_ATI_pn_triangles = 1;
pub const GL_PN_TRIANGLES_ATI = 0x87F0;
pub const GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1;
pub const GL_PN_TRIANGLES_POINT_MODE_ATI = 0x87F2;
pub const GL_PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3;
pub const GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4;
pub const GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5;
pub const GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6;
pub const GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7;
pub const GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8;
pub const GL_ATI_separate_stencil = 1;
pub const GL_STENCIL_BACK_FUNC_ATI = 0x8800;
pub const GL_STENCIL_BACK_FAIL_ATI = 0x8801;
pub const GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802;
pub const GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803;
pub const GL_ATI_text_fragment_shader = 1;
pub const GL_TEXT_FRAGMENT_SHADER_ATI = 0x8200;
pub const GL_ATI_texture_env_combine3 = 1;
pub const GL_MODULATE_ADD_ATI = 0x8744;
pub const GL_MODULATE_SIGNED_ADD_ATI = 0x8745;
pub const GL_MODULATE_SUBTRACT_ATI = 0x8746;
pub const GL_ATI_texture_float = 1;
pub const GL_RGBA_FLOAT32_ATI = 0x8814;
pub const GL_RGB_FLOAT32_ATI = 0x8815;
pub const GL_ALPHA_FLOAT32_ATI = 0x8816;
pub const GL_INTENSITY_FLOAT32_ATI = 0x8817;
pub const GL_LUMINANCE_FLOAT32_ATI = 0x8818;
pub const GL_LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819;
pub const GL_RGBA_FLOAT16_ATI = 0x881A;
pub const GL_RGB_FLOAT16_ATI = 0x881B;
pub const GL_ALPHA_FLOAT16_ATI = 0x881C;
pub const GL_INTENSITY_FLOAT16_ATI = 0x881D;
pub const GL_LUMINANCE_FLOAT16_ATI = 0x881E;
pub const GL_LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F;
pub const GL_ATI_texture_mirror_once = 1;
pub const GL_MIRROR_CLAMP_ATI = 0x8742;
pub const GL_MIRROR_CLAMP_TO_EDGE_ATI = 0x8743;
pub const GL_ATI_vertex_array_object = 1;
pub const GL_STATIC_ATI = 0x8760;
pub const GL_DYNAMIC_ATI = 0x8761;
pub const GL_PRESERVE_ATI = 0x8762;
pub const GL_DISCARD_ATI = 0x8763;
pub const GL_OBJECT_BUFFER_SIZE_ATI = 0x8764;
pub const GL_OBJECT_BUFFER_USAGE_ATI = 0x8765;
pub const GL_ARRAY_OBJECT_BUFFER_ATI = 0x8766;
pub const GL_ARRAY_OBJECT_OFFSET_ATI = 0x8767;
pub const GL_ATI_vertex_attrib_array_object = 1;
pub const GL_ATI_vertex_streams = 1;
pub const GL_MAX_VERTEX_STREAMS_ATI = 0x876B;
pub const GL_VERTEX_STREAM0_ATI = 0x876C;
pub const GL_VERTEX_STREAM1_ATI = 0x876D;
pub const GL_VERTEX_STREAM2_ATI = 0x876E;
pub const GL_VERTEX_STREAM3_ATI = 0x876F;
pub const GL_VERTEX_STREAM4_ATI = 0x8770;
pub const GL_VERTEX_STREAM5_ATI = 0x8771;
pub const GL_VERTEX_STREAM6_ATI = 0x8772;
pub const GL_VERTEX_STREAM7_ATI = 0x8773;
pub const GL_VERTEX_SOURCE_ATI = 0x8774;
pub const GL_EXT_422_pixels = 1;
pub const GL_422_EXT = 0x80CC;
pub const GL_422_REV_EXT = 0x80CD;
pub const GL_422_AVERAGE_EXT = 0x80CE;
pub const GL_422_REV_AVERAGE_EXT = 0x80CF;
pub const GL_EXT_EGL_image_storage = 1;
pub const GL_EXT_abgr = 1;
pub const GL_ABGR_EXT = 0x8000;
pub const GL_EXT_bgra = 1;
pub const GL_BGR_EXT = 0x80E0;
pub const GL_BGRA_EXT = 0x80E1;
pub const GL_EXT_bindable_uniform = 1;
pub const GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2;
pub const GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3;
pub const GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4;
pub const GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED;
pub const GL_UNIFORM_BUFFER_EXT = 0x8DEE;
pub const GL_UNIFORM_BUFFER_BINDING_EXT = 0x8DEF;
pub const GL_EXT_blend_color = 1;
pub const GL_CONSTANT_COLOR_EXT = 0x8001;
pub const GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002;
pub const GL_CONSTANT_ALPHA_EXT = 0x8003;
pub const GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004;
pub const GL_BLEND_COLOR_EXT = 0x8005;
pub const GL_EXT_blend_equation_separate = 1;
pub const GL_BLEND_EQUATION_RGB_EXT = 0x8009;
pub const GL_BLEND_EQUATION_ALPHA_EXT = 0x883D;
pub const GL_EXT_blend_func_separate = 1;
pub const GL_BLEND_DST_RGB_EXT = 0x80C8;
pub const GL_BLEND_SRC_RGB_EXT = 0x80C9;
pub const GL_BLEND_DST_ALPHA_EXT = 0x80CA;
pub const GL_BLEND_SRC_ALPHA_EXT = 0x80CB;
pub const GL_EXT_blend_logic_op = 1;
pub const GL_EXT_blend_minmax = 1;
pub const GL_MIN_EXT = 0x8007;
pub const GL_MAX_EXT = 0x8008;
pub const GL_FUNC_ADD_EXT = 0x8006;
pub const GL_BLEND_EQUATION_EXT = 0x8009;
pub const GL_EXT_blend_subtract = 1;
pub const GL_FUNC_SUBTRACT_EXT = 0x800A;
pub const GL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B;
pub const GL_EXT_clip_volume_hint = 1;
pub const GL_CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0;
pub const GL_EXT_cmyka = 1;
pub const GL_CMYK_EXT = 0x800C;
pub const GL_CMYKA_EXT = 0x800D;
pub const GL_PACK_CMYK_HINT_EXT = 0x800E;
pub const GL_UNPACK_CMYK_HINT_EXT = 0x800F;
pub const GL_EXT_color_subtable = 1;
pub const GL_EXT_compiled_vertex_array = 1;
pub const GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8;
pub const GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9;
pub const GL_EXT_convolution = 1;
pub const GL_CONVOLUTION_1D_EXT = 0x8010;
pub const GL_CONVOLUTION_2D_EXT = 0x8011;
pub const GL_SEPARABLE_2D_EXT = 0x8012;
pub const GL_CONVOLUTION_BORDER_MODE_EXT = 0x8013;
pub const GL_CONVOLUTION_FILTER_SCALE_EXT = 0x8014;
pub const GL_CONVOLUTION_FILTER_BIAS_EXT = 0x8015;
pub const GL_REDUCE_EXT = 0x8016;
pub const GL_CONVOLUTION_FORMAT_EXT = 0x8017;
pub const GL_CONVOLUTION_WIDTH_EXT = 0x8018;
pub const GL_CONVOLUTION_HEIGHT_EXT = 0x8019;
pub const GL_MAX_CONVOLUTION_WIDTH_EXT = 0x801A;
pub const GL_MAX_CONVOLUTION_HEIGHT_EXT = 0x801B;
pub const GL_POST_CONVOLUTION_RED_SCALE_EXT = 0x801C;
pub const GL_POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D;
pub const GL_POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E;
pub const GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F;
pub const GL_POST_CONVOLUTION_RED_BIAS_EXT = 0x8020;
pub const GL_POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021;
pub const GL_POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022;
pub const GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023;
pub const GL_EXT_coordinate_frame = 1;
pub const GL_TANGENT_ARRAY_EXT = 0x8439;
pub const GL_BINORMAL_ARRAY_EXT = 0x843A;
pub const GL_CURRENT_TANGENT_EXT = 0x843B;
pub const GL_CURRENT_BINORMAL_EXT = 0x843C;
pub const GL_TANGENT_ARRAY_TYPE_EXT = 0x843E;
pub const GL_TANGENT_ARRAY_STRIDE_EXT = 0x843F;
pub const GL_BINORMAL_ARRAY_TYPE_EXT = 0x8440;
pub const GL_BINORMAL_ARRAY_STRIDE_EXT = 0x8441;
pub const GL_TANGENT_ARRAY_POINTER_EXT = 0x8442;
pub const GL_BINORMAL_ARRAY_POINTER_EXT = 0x8443;
pub const GL_MAP1_TANGENT_EXT = 0x8444;
pub const GL_MAP2_TANGENT_EXT = 0x8445;
pub const GL_MAP1_BINORMAL_EXT = 0x8446;
pub const GL_MAP2_BINORMAL_EXT = 0x8447;
pub const GL_EXT_copy_texture = 1;
pub const GL_EXT_cull_vertex = 1;
pub const GL_CULL_VERTEX_EXT = 0x81AA;
pub const GL_CULL_VERTEX_EYE_POSITION_EXT = 0x81AB;
pub const GL_CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC;
pub const GL_EXT_debug_label = 1;
pub const GL_PROGRAM_PIPELINE_OBJECT_EXT = 0x8A4F;
pub const GL_PROGRAM_OBJECT_EXT = 0x8B40;
pub const GL_SHADER_OBJECT_EXT = 0x8B48;
pub const GL_BUFFER_OBJECT_EXT = 0x9151;
pub const GL_QUERY_OBJECT_EXT = 0x9153;
pub const GL_VERTEX_ARRAY_OBJECT_EXT = 0x9154;
pub const GL_EXT_debug_marker = 1;
pub const GL_EXT_depth_bounds_test = 1;
pub const GL_DEPTH_BOUNDS_TEST_EXT = 0x8890;
pub const GL_DEPTH_BOUNDS_EXT = 0x8891;
pub const GL_EXT_direct_state_access = 1;
pub const GL_PROGRAM_MATRIX_EXT = 0x8E2D;
pub const GL_TRANSPOSE_PROGRAM_MATRIX_EXT = 0x8E2E;
pub const GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = 0x8E2F;
pub const GL_EXT_draw_buffers2 = 1;
pub const GL_EXT_draw_instanced = 1;
pub const GL_EXT_draw_range_elements = 1;
pub const GL_MAX_ELEMENTS_VERTICES_EXT = 0x80E8;
pub const GL_MAX_ELEMENTS_INDICES_EXT = 0x80E9;
pub const GL_EXT_external_buffer = 1;
pub const GL_EXT_fog_coord = 1;
pub const GL_FOG_COORDINATE_SOURCE_EXT = 0x8450;
pub const GL_FOG_COORDINATE_EXT = 0x8451;
pub const GL_FRAGMENT_DEPTH_EXT = 0x8452;
pub const GL_CURRENT_FOG_COORDINATE_EXT = 0x8453;
pub const GL_FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454;
pub const GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455;
pub const GL_FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456;
pub const GL_FOG_COORDINATE_ARRAY_EXT = 0x8457;
pub const GL_EXT_framebuffer_blit = 1;
pub const GL_READ_FRAMEBUFFER_EXT = 0x8CA8;
pub const GL_DRAW_FRAMEBUFFER_EXT = 0x8CA9;
pub const GL_DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CA6;
pub const GL_READ_FRAMEBUFFER_BINDING_EXT = 0x8CAA;
pub const GL_EXT_framebuffer_multisample = 1;
pub const GL_RENDERBUFFER_SAMPLES_EXT = 0x8CAB;
pub const GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56;
pub const GL_MAX_SAMPLES_EXT = 0x8D57;
pub const GL_EXT_framebuffer_multisample_blit_scaled = 1;
pub const GL_SCALED_RESOLVE_FASTEST_EXT = 0x90BA;
pub const GL_SCALED_RESOLVE_NICEST_EXT = 0x90BB;
pub const GL_EXT_framebuffer_object = 1;
pub const GL_INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506;
pub const GL_MAX_RENDERBUFFER_SIZE_EXT = 0x84E8;
pub const GL_FRAMEBUFFER_BINDING_EXT = 0x8CA6;
pub const GL_RENDERBUFFER_BINDING_EXT = 0x8CA7;
pub const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0;
pub const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4;
pub const GL_FRAMEBUFFER_COMPLETE_EXT = 0x8CD5;
pub const GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6;
pub const GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7;
pub const GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9;
pub const GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA;
pub const GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB;
pub const GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC;
pub const GL_FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD;
pub const GL_MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF;
pub const GL_COLOR_ATTACHMENT0_EXT = 0x8CE0;
pub const GL_COLOR_ATTACHMENT1_EXT = 0x8CE1;
pub const GL_COLOR_ATTACHMENT2_EXT = 0x8CE2;
pub const GL_COLOR_ATTACHMENT3_EXT = 0x8CE3;
pub const GL_COLOR_ATTACHMENT4_EXT = 0x8CE4;
pub const GL_COLOR_ATTACHMENT5_EXT = 0x8CE5;
pub const GL_COLOR_ATTACHMENT6_EXT = 0x8CE6;
pub const GL_COLOR_ATTACHMENT7_EXT = 0x8CE7;
pub const GL_COLOR_ATTACHMENT8_EXT = 0x8CE8;
pub const GL_COLOR_ATTACHMENT9_EXT = 0x8CE9;
pub const GL_COLOR_ATTACHMENT10_EXT = 0x8CEA;
pub const GL_COLOR_ATTACHMENT11_EXT = 0x8CEB;
pub const GL_COLOR_ATTACHMENT12_EXT = 0x8CEC;
pub const GL_COLOR_ATTACHMENT13_EXT = 0x8CED;
pub const GL_COLOR_ATTACHMENT14_EXT = 0x8CEE;
pub const GL_COLOR_ATTACHMENT15_EXT = 0x8CEF;
pub const GL_DEPTH_ATTACHMENT_EXT = 0x8D00;
pub const GL_STENCIL_ATTACHMENT_EXT = 0x8D20;
pub const GL_FRAMEBUFFER_EXT = 0x8D40;
pub const GL_RENDERBUFFER_EXT = 0x8D41;
pub const GL_RENDERBUFFER_WIDTH_EXT = 0x8D42;
pub const GL_RENDERBUFFER_HEIGHT_EXT = 0x8D43;
pub const GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44;
pub const GL_STENCIL_INDEX1_EXT = 0x8D46;
pub const GL_STENCIL_INDEX4_EXT = 0x8D47;
pub const GL_STENCIL_INDEX8_EXT = 0x8D48;
pub const GL_STENCIL_INDEX16_EXT = 0x8D49;
pub const GL_RENDERBUFFER_RED_SIZE_EXT = 0x8D50;
pub const GL_RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51;
pub const GL_RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52;
pub const GL_RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53;
pub const GL_RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54;
pub const GL_RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55;
pub const GL_EXT_framebuffer_sRGB = 1;
pub const GL_FRAMEBUFFER_SRGB_EXT = 0x8DB9;
pub const GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA;
pub const GL_EXT_geometry_shader4 = 1;
pub const GL_GEOMETRY_SHADER_EXT = 0x8DD9;
pub const GL_GEOMETRY_VERTICES_OUT_EXT = 0x8DDA;
pub const GL_GEOMETRY_INPUT_TYPE_EXT = 0x8DDB;
pub const GL_GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC;
pub const GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29;
pub const GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD;
pub const GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE;
pub const GL_MAX_VARYING_COMPONENTS_EXT = 0x8B4B;
pub const GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF;
pub const GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0;
pub const GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1;
pub const GL_LINES_ADJACENCY_EXT = 0x000A;
pub const GL_LINE_STRIP_ADJACENCY_EXT = 0x000B;
pub const GL_TRIANGLES_ADJACENCY_EXT = 0x000C;
pub const GL_TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D;
pub const GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8;
pub const GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9;
pub const GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4;
pub const GL_PROGRAM_POINT_SIZE_EXT = 0x8642;
pub const GL_EXT_gpu_program_parameters = 1;
pub const GL_EXT_gpu_shader4 = 1;
pub const GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = 0x88FD;
pub const GL_SAMPLER_1D_ARRAY_EXT = 0x8DC0;
pub const GL_SAMPLER_2D_ARRAY_EXT = 0x8DC1;
pub const GL_SAMPLER_BUFFER_EXT = 0x8DC2;
pub const GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3;
pub const GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4;
pub const GL_SAMPLER_CUBE_SHADOW_EXT = 0x8DC5;
pub const GL_UNSIGNED_INT_VEC2_EXT = 0x8DC6;
pub const GL_UNSIGNED_INT_VEC3_EXT = 0x8DC7;
pub const GL_UNSIGNED_INT_VEC4_EXT = 0x8DC8;
pub const GL_INT_SAMPLER_1D_EXT = 0x8DC9;
pub const GL_INT_SAMPLER_2D_EXT = 0x8DCA;
pub const GL_INT_SAMPLER_3D_EXT = 0x8DCB;
pub const GL_INT_SAMPLER_CUBE_EXT = 0x8DCC;
pub const GL_INT_SAMPLER_2D_RECT_EXT = 0x8DCD;
pub const GL_INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE;
pub const GL_INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF;
pub const GL_INT_SAMPLER_BUFFER_EXT = 0x8DD0;
pub const GL_UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1;
pub const GL_UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2;
pub const GL_UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3;
pub const GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4;
pub const GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5;
pub const GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6;
pub const GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7;
pub const GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8;
pub const GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = 0x8904;
pub const GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = 0x8905;
pub const GL_EXT_histogram = 1;
pub const GL_HISTOGRAM_EXT = 0x8024;
pub const GL_PROXY_HISTOGRAM_EXT = 0x8025;
pub const GL_HISTOGRAM_WIDTH_EXT = 0x8026;
pub const GL_HISTOGRAM_FORMAT_EXT = 0x8027;
pub const GL_HISTOGRAM_RED_SIZE_EXT = 0x8028;
pub const GL_HISTOGRAM_GREEN_SIZE_EXT = 0x8029;
pub const GL_HISTOGRAM_BLUE_SIZE_EXT = 0x802A;
pub const GL_HISTOGRAM_ALPHA_SIZE_EXT = 0x802B;
pub const GL_HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C;
pub const GL_HISTOGRAM_SINK_EXT = 0x802D;
pub const GL_MINMAX_EXT = 0x802E;
pub const GL_MINMAX_FORMAT_EXT = 0x802F;
pub const GL_MINMAX_SINK_EXT = 0x8030;
pub const GL_TABLE_TOO_LARGE_EXT = 0x8031;
pub const GL_EXT_index_array_formats = 1;
pub const GL_IUI_V2F_EXT = 0x81AD;
pub const GL_IUI_V3F_EXT = 0x81AE;
pub const GL_IUI_N3F_V2F_EXT = 0x81AF;
pub const GL_IUI_N3F_V3F_EXT = 0x81B0;
pub const GL_T2F_IUI_V2F_EXT = 0x81B1;
pub const GL_T2F_IUI_V3F_EXT = 0x81B2;
pub const GL_T2F_IUI_N3F_V2F_EXT = 0x81B3;
pub const GL_T2F_IUI_N3F_V3F_EXT = 0x81B4;
pub const GL_EXT_index_func = 1;
pub const GL_INDEX_TEST_EXT = 0x81B5;
pub const GL_INDEX_TEST_FUNC_EXT = 0x81B6;
pub const GL_INDEX_TEST_REF_EXT = 0x81B7;
pub const GL_EXT_index_material = 1;
pub const GL_INDEX_MATERIAL_EXT = 0x81B8;
pub const GL_INDEX_MATERIAL_PARAMETER_EXT = 0x81B9;
pub const GL_INDEX_MATERIAL_FACE_EXT = 0x81BA;
pub const GL_EXT_index_texture = 1;
pub const GL_EXT_light_texture = 1;
pub const GL_FRAGMENT_MATERIAL_EXT = 0x8349;
pub const GL_FRAGMENT_NORMAL_EXT = 0x834A;
pub const GL_FRAGMENT_COLOR_EXT = 0x834C;
pub const GL_ATTENUATION_EXT = 0x834D;
pub const GL_SHADOW_ATTENUATION_EXT = 0x834E;
pub const GL_TEXTURE_APPLICATION_MODE_EXT = 0x834F;
pub const GL_TEXTURE_LIGHT_EXT = 0x8350;
pub const GL_TEXTURE_MATERIAL_FACE_EXT = 0x8351;
pub const GL_TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352;
pub const GL_EXT_memory_object = 1;
pub const GL_TEXTURE_TILING_EXT = 0x9580;
pub const GL_DEDICATED_MEMORY_OBJECT_EXT = 0x9581;
pub const GL_PROTECTED_MEMORY_OBJECT_EXT = 0x959B;
pub const GL_NUM_TILING_TYPES_EXT = 0x9582;
pub const GL_TILING_TYPES_EXT = 0x9583;
pub const GL_OPTIMAL_TILING_EXT = 0x9584;
pub const GL_LINEAR_TILING_EXT = 0x9585;
pub const GL_NUM_DEVICE_UUIDS_EXT = 0x9596;
pub const GL_DEVICE_UUID_EXT = 0x9597;
pub const GL_DRIVER_UUID_EXT = 0x9598;
pub const GL_UUID_SIZE_EXT = 16;
pub const GL_EXT_memory_object_fd = 1;
pub const GL_HANDLE_TYPE_OPAQUE_FD_EXT = 0x9586;
pub const GL_EXT_memory_object_win32 = 1;
pub const GL_HANDLE_TYPE_OPAQUE_WIN32_EXT = 0x9587;
pub const GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT = 0x9588;
pub const GL_DEVICE_LUID_EXT = 0x9599;
pub const GL_DEVICE_NODE_MASK_EXT = 0x959A;
pub const GL_LUID_SIZE_EXT = 8;
pub const GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT = 0x9589;
pub const GL_HANDLE_TYPE_D3D12_RESOURCE_EXT = 0x958A;
pub const GL_HANDLE_TYPE_D3D11_IMAGE_EXT = 0x958B;
pub const GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT = 0x958C;
pub const GL_EXT_misc_attribute = 1;
pub const GL_EXT_multi_draw_arrays = 1;
pub const GL_EXT_multisample = 1;
pub const GL_MULTISAMPLE_EXT = 0x809D;
pub const GL_SAMPLE_ALPHA_TO_MASK_EXT = 0x809E;
pub const GL_SAMPLE_ALPHA_TO_ONE_EXT = 0x809F;
pub const GL_SAMPLE_MASK_EXT = 0x80A0;
pub const GL_1PASS_EXT = 0x80A1;
pub const GL_2PASS_0_EXT = 0x80A2;
pub const GL_2PASS_1_EXT = 0x80A3;
pub const GL_4PASS_0_EXT = 0x80A4;
pub const GL_4PASS_1_EXT = 0x80A5;
pub const GL_4PASS_2_EXT = 0x80A6;
pub const GL_4PASS_3_EXT = 0x80A7;
pub const GL_SAMPLE_BUFFERS_EXT = 0x80A8;
pub const GL_SAMPLES_EXT = 0x80A9;
pub const GL_SAMPLE_MASK_VALUE_EXT = 0x80AA;
pub const GL_SAMPLE_MASK_INVERT_EXT = 0x80AB;
pub const GL_SAMPLE_PATTERN_EXT = 0x80AC;
pub const GL_MULTISAMPLE_BIT_EXT = 0x20000000;
pub const GL_EXT_multiview_tessellation_geometry_shader = 1;
pub const GL_EXT_multiview_texture_multisample = 1;
pub const GL_EXT_multiview_timer_query = 1;
pub const GL_EXT_packed_depth_stencil = 1;
pub const GL_DEPTH_STENCIL_EXT = 0x84F9;
pub const GL_UNSIGNED_INT_24_8_EXT = 0x84FA;
pub const GL_DEPTH24_STENCIL8_EXT = 0x88F0;
pub const GL_TEXTURE_STENCIL_SIZE_EXT = 0x88F1;
pub const GL_EXT_packed_float = 1;
pub const GL_R11F_G11F_B10F_EXT = 0x8C3A;
pub const GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B;
pub const GL_RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C;
pub const GL_EXT_packed_pixels = 1;
pub const GL_UNSIGNED_BYTE_3_3_2_EXT = 0x8032;
pub const GL_UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033;
pub const GL_UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034;
pub const GL_UNSIGNED_INT_8_8_8_8_EXT = 0x8035;
pub const GL_UNSIGNED_INT_10_10_10_2_EXT = 0x8036;
pub const GL_EXT_paletted_texture = 1;
pub const GL_COLOR_INDEX1_EXT = 0x80E2;
pub const GL_COLOR_INDEX2_EXT = 0x80E3;
pub const GL_COLOR_INDEX4_EXT = 0x80E4;
pub const GL_COLOR_INDEX8_EXT = 0x80E5;
pub const GL_COLOR_INDEX12_EXT = 0x80E6;
pub const GL_COLOR_INDEX16_EXT = 0x80E7;
pub const GL_TEXTURE_INDEX_SIZE_EXT = 0x80ED;
pub const GL_EXT_pixel_buffer_object = 1;
pub const GL_PIXEL_PACK_BUFFER_EXT = 0x88EB;
pub const GL_PIXEL_UNPACK_BUFFER_EXT = 0x88EC;
pub const GL_PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED;
pub const GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF;
pub const GL_EXT_pixel_transform = 1;
pub const GL_PIXEL_TRANSFORM_2D_EXT = 0x8330;
pub const GL_PIXEL_MAG_FILTER_EXT = 0x8331;
pub const GL_PIXEL_MIN_FILTER_EXT = 0x8332;
pub const GL_PIXEL_CUBIC_WEIGHT_EXT = 0x8333;
pub const GL_CUBIC_EXT = 0x8334;
pub const GL_AVERAGE_EXT = 0x8335;
pub const GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336;
pub const GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337;
pub const GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338;
pub const GL_EXT_pixel_transform_color_table = 1;
pub const GL_EXT_point_parameters = 1;
pub const GL_POINT_SIZE_MIN_EXT = 0x8126;
pub const GL_POINT_SIZE_MAX_EXT = 0x8127;
pub const GL_POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128;
pub const GL_DISTANCE_ATTENUATION_EXT = 0x8129;
pub const GL_EXT_polygon_offset = 1;
pub const GL_POLYGON_OFFSET_EXT = 0x8037;
pub const GL_POLYGON_OFFSET_FACTOR_EXT = 0x8038;
pub const GL_POLYGON_OFFSET_BIAS_EXT = 0x8039;
pub const GL_EXT_polygon_offset_clamp = 1;
pub const GL_POLYGON_OFFSET_CLAMP_EXT = 0x8E1B;
pub const GL_EXT_post_depth_coverage = 1;
pub const GL_EXT_provoking_vertex = 1;
pub const GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = 0x8E4C;
pub const GL_FIRST_VERTEX_CONVENTION_EXT = 0x8E4D;
pub const GL_LAST_VERTEX_CONVENTION_EXT = 0x8E4E;
pub const GL_PROVOKING_VERTEX_EXT = 0x8E4F;
pub const GL_EXT_raster_multisample = 1;
pub const GL_RASTER_MULTISAMPLE_EXT = 0x9327;
pub const GL_RASTER_SAMPLES_EXT = 0x9328;
pub const GL_MAX_RASTER_SAMPLES_EXT = 0x9329;
pub const GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT = 0x932A;
pub const GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT = 0x932B;
pub const GL_EFFECTIVE_RASTER_SAMPLES_EXT = 0x932C;
pub const GL_EXT_rescale_normal = 1;
pub const GL_RESCALE_NORMAL_EXT = 0x803A;
pub const GL_EXT_secondary_color = 1;
pub const GL_COLOR_SUM_EXT = 0x8458;
pub const GL_CURRENT_SECONDARY_COLOR_EXT = 0x8459;
pub const GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A;
pub const GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B;
pub const GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C;
pub const GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D;
pub const GL_SECONDARY_COLOR_ARRAY_EXT = 0x845E;
pub const GL_EXT_semaphore = 1;
pub const GL_LAYOUT_GENERAL_EXT = 0x958D;
pub const GL_LAYOUT_COLOR_ATTACHMENT_EXT = 0x958E;
pub const GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT = 0x958F;
pub const GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT = 0x9590;
pub const GL_LAYOUT_SHADER_READ_ONLY_EXT = 0x9591;
pub const GL_LAYOUT_TRANSFER_SRC_EXT = 0x9592;
pub const GL_LAYOUT_TRANSFER_DST_EXT = 0x9593;
pub const GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT = 0x9530;
pub const GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT = 0x9531;
pub const GL_EXT_semaphore_fd = 1;
pub const GL_EXT_semaphore_win32 = 1;
pub const GL_HANDLE_TYPE_D3D12_FENCE_EXT = 0x9594;
pub const GL_D3D12_FENCE_VALUE_EXT = 0x9595;
pub const GL_EXT_separate_shader_objects = 1;
pub const GL_ACTIVE_PROGRAM_EXT = 0x8B8D;
pub const GL_EXT_separate_specular_color = 1;
pub const GL_LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8;
pub const GL_SINGLE_COLOR_EXT = 0x81F9;
pub const GL_SEPARATE_SPECULAR_COLOR_EXT = 0x81FA;
pub const GL_EXT_shader_framebuffer_fetch = 1;
pub const GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT = 0x8A52;
pub const GL_EXT_shader_framebuffer_fetch_non_coherent = 1;
pub const GL_EXT_shader_image_load_formatted = 1;
pub const GL_EXT_shader_image_load_store = 1;
pub const GL_MAX_IMAGE_UNITS_EXT = 0x8F38;
pub const GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = 0x8F39;
pub const GL_IMAGE_BINDING_NAME_EXT = 0x8F3A;
pub const GL_IMAGE_BINDING_LEVEL_EXT = 0x8F3B;
pub const GL_IMAGE_BINDING_LAYERED_EXT = 0x8F3C;
pub const GL_IMAGE_BINDING_LAYER_EXT = 0x8F3D;
pub const GL_IMAGE_BINDING_ACCESS_EXT = 0x8F3E;
pub const GL_IMAGE_1D_EXT = 0x904C;
pub const GL_IMAGE_2D_EXT = 0x904D;
pub const GL_IMAGE_3D_EXT = 0x904E;
pub const GL_IMAGE_2D_RECT_EXT = 0x904F;
pub const GL_IMAGE_CUBE_EXT = 0x9050;
pub const GL_IMAGE_BUFFER_EXT = 0x9051;
pub const GL_IMAGE_1D_ARRAY_EXT = 0x9052;
pub const GL_IMAGE_2D_ARRAY_EXT = 0x9053;
pub const GL_IMAGE_CUBE_MAP_ARRAY_EXT = 0x9054;
pub const GL_IMAGE_2D_MULTISAMPLE_EXT = 0x9055;
pub const GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9056;
pub const GL_INT_IMAGE_1D_EXT = 0x9057;
pub const GL_INT_IMAGE_2D_EXT = 0x9058;
pub const GL_INT_IMAGE_3D_EXT = 0x9059;
pub const GL_INT_IMAGE_2D_RECT_EXT = 0x905A;
pub const GL_INT_IMAGE_CUBE_EXT = 0x905B;
pub const GL_INT_IMAGE_BUFFER_EXT = 0x905C;
pub const GL_INT_IMAGE_1D_ARRAY_EXT = 0x905D;
pub const GL_INT_IMAGE_2D_ARRAY_EXT = 0x905E;
pub const GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x905F;
pub const GL_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x9060;
pub const GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9061;
pub const GL_UNSIGNED_INT_IMAGE_1D_EXT = 0x9062;
pub const GL_UNSIGNED_INT_IMAGE_2D_EXT = 0x9063;
pub const GL_UNSIGNED_INT_IMAGE_3D_EXT = 0x9064;
pub const GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = 0x9065;
pub const GL_UNSIGNED_INT_IMAGE_CUBE_EXT = 0x9066;
pub const GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = 0x9067;
pub const GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = 0x9068;
pub const GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = 0x9069;
pub const GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x906A;
pub const GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x906B;
pub const GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x906C;
pub const GL_MAX_IMAGE_SAMPLES_EXT = 0x906D;
pub const GL_IMAGE_BINDING_FORMAT_EXT = 0x906E;
pub const GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = 0x00000001;
pub const GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = 0x00000002;
pub const GL_UNIFORM_BARRIER_BIT_EXT = 0x00000004;
pub const GL_TEXTURE_FETCH_BARRIER_BIT_EXT = 0x00000008;
pub const GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = 0x00000020;
pub const GL_COMMAND_BARRIER_BIT_EXT = 0x00000040;
pub const GL_PIXEL_BUFFER_BARRIER_BIT_EXT = 0x00000080;
pub const GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = 0x00000100;
pub const GL_BUFFER_UPDATE_BARRIER_BIT_EXT = 0x00000200;
pub const GL_FRAMEBUFFER_BARRIER_BIT_EXT = 0x00000400;
pub const GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = 0x00000800;
pub const GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = 0x00001000;
pub const GL_ALL_BARRIER_BITS_EXT = 0xFFFFFFFF;
pub const GL_EXT_shader_integer_mix = 1;
pub const GL_EXT_shadow_funcs = 1;
pub const GL_EXT_shared_texture_palette = 1;
pub const GL_SHARED_TEXTURE_PALETTE_EXT = 0x81FB;
pub const GL_EXT_sparse_texture2 = 1;
pub const GL_EXT_stencil_clear_tag = 1;
pub const GL_STENCIL_TAG_BITS_EXT = 0x88F2;
pub const GL_STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3;
pub const GL_EXT_stencil_two_side = 1;
pub const GL_STENCIL_TEST_TWO_SIDE_EXT = 0x8910;
pub const GL_ACTIVE_STENCIL_FACE_EXT = 0x8911;
pub const GL_EXT_stencil_wrap = 1;
pub const GL_INCR_WRAP_EXT = 0x8507;
pub const GL_DECR_WRAP_EXT = 0x8508;
pub const GL_EXT_subtexture = 1;
pub const GL_EXT_texture = 1;
pub const GL_ALPHA4_EXT = 0x803B;
pub const GL_ALPHA8_EXT = 0x803C;
pub const GL_ALPHA12_EXT = 0x803D;
pub const GL_ALPHA16_EXT = 0x803E;
pub const GL_LUMINANCE4_EXT = 0x803F;
pub const GL_LUMINANCE8_EXT = 0x8040;
pub const GL_LUMINANCE12_EXT = 0x8041;
pub const GL_LUMINANCE16_EXT = 0x8042;
pub const GL_LUMINANCE4_ALPHA4_EXT = 0x8043;
pub const GL_LUMINANCE6_ALPHA2_EXT = 0x8044;
pub const GL_LUMINANCE8_ALPHA8_EXT = 0x8045;
pub const GL_LUMINANCE12_ALPHA4_EXT = 0x8046;
pub const GL_LUMINANCE12_ALPHA12_EXT = 0x8047;
pub const GL_LUMINANCE16_ALPHA16_EXT = 0x8048;
pub const GL_INTENSITY_EXT = 0x8049;
pub const GL_INTENSITY4_EXT = 0x804A;
pub const GL_INTENSITY8_EXT = 0x804B;
pub const GL_INTENSITY12_EXT = 0x804C;
pub const GL_INTENSITY16_EXT = 0x804D;
pub const GL_RGB2_EXT = 0x804E;
pub const GL_RGB4_EXT = 0x804F;
pub const GL_RGB5_EXT = 0x8050;
pub const GL_RGB8_EXT = 0x8051;
pub const GL_RGB10_EXT = 0x8052;
pub const GL_RGB12_EXT = 0x8053;
pub const GL_RGB16_EXT = 0x8054;
pub const GL_RGBA2_EXT = 0x8055;
pub const GL_RGBA4_EXT = 0x8056;
pub const GL_RGB5_A1_EXT = 0x8057;
pub const GL_RGBA8_EXT = 0x8058;
pub const GL_RGB10_A2_EXT = 0x8059;
pub const GL_RGBA12_EXT = 0x805A;
pub const GL_RGBA16_EXT = 0x805B;
pub const GL_TEXTURE_RED_SIZE_EXT = 0x805C;
pub const GL_TEXTURE_GREEN_SIZE_EXT = 0x805D;
pub const GL_TEXTURE_BLUE_SIZE_EXT = 0x805E;
pub const GL_TEXTURE_ALPHA_SIZE_EXT = 0x805F;
pub const GL_TEXTURE_LUMINANCE_SIZE_EXT = 0x8060;
pub const GL_TEXTURE_INTENSITY_SIZE_EXT = 0x8061;
pub const GL_REPLACE_EXT = 0x8062;
pub const GL_PROXY_TEXTURE_1D_EXT = 0x8063;
pub const GL_PROXY_TEXTURE_2D_EXT = 0x8064;
pub const GL_TEXTURE_TOO_LARGE_EXT = 0x8065;
pub const GL_EXT_texture3D = 1;
pub const GL_PACK_SKIP_IMAGES_EXT = 0x806B;
pub const GL_PACK_IMAGE_HEIGHT_EXT = 0x806C;
pub const GL_UNPACK_SKIP_IMAGES_EXT = 0x806D;
pub const GL_UNPACK_IMAGE_HEIGHT_EXT = 0x806E;
pub const GL_TEXTURE_3D_EXT = 0x806F;
pub const GL_PROXY_TEXTURE_3D_EXT = 0x8070;
pub const GL_TEXTURE_DEPTH_EXT = 0x8071;
pub const GL_TEXTURE_WRAP_R_EXT = 0x8072;
pub const GL_MAX_3D_TEXTURE_SIZE_EXT = 0x8073;
pub const GL_EXT_texture_array = 1;
pub const GL_TEXTURE_1D_ARRAY_EXT = 0x8C18;
pub const GL_PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19;
pub const GL_TEXTURE_2D_ARRAY_EXT = 0x8C1A;
pub const GL_PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B;
pub const GL_TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C;
pub const GL_TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D;
pub const GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF;
pub const GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E;
pub const GL_EXT_texture_buffer_object = 1;
pub const GL_TEXTURE_BUFFER_EXT = 0x8C2A;
pub const GL_MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B;
pub const GL_TEXTURE_BINDING_BUFFER_EXT = 0x8C2C;
pub const GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D;
pub const GL_TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E;
pub const GL_EXT_texture_compression_latc = 1;
pub const GL_COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70;
pub const GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71;
pub const GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72;
pub const GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73;
pub const GL_EXT_texture_compression_rgtc = 1;
pub const GL_COMPRESSED_RED_RGTC1_EXT = 0x8DBB;
pub const GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC;
pub const GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD;
pub const GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE;
pub const GL_EXT_texture_compression_s3tc = 1;
pub const GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0;
pub const GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1;
pub const GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2;
pub const GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3;
pub const GL_EXT_texture_cube_map = 1;
pub const GL_NORMAL_MAP_EXT = 0x8511;
pub const GL_REFLECTION_MAP_EXT = 0x8512;
pub const GL_TEXTURE_CUBE_MAP_EXT = 0x8513;
pub const GL_TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518;
pub const GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519;
pub const GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A;
pub const GL_PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B;
pub const GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C;
pub const GL_EXT_texture_env_add = 1;
pub const GL_EXT_texture_env_combine = 1;
pub const GL_COMBINE_EXT = 0x8570;
pub const GL_COMBINE_RGB_EXT = 0x8571;
pub const GL_COMBINE_ALPHA_EXT = 0x8572;
pub const GL_RGB_SCALE_EXT = 0x8573;
pub const GL_ADD_SIGNED_EXT = 0x8574;
pub const GL_INTERPOLATE_EXT = 0x8575;
pub const GL_CONSTANT_EXT = 0x8576;
pub const GL_PRIMARY_COLOR_EXT = 0x8577;
pub const GL_PREVIOUS_EXT = 0x8578;
pub const GL_SOURCE0_RGB_EXT = 0x8580;
pub const GL_SOURCE1_RGB_EXT = 0x8581;
pub const GL_SOURCE2_RGB_EXT = 0x8582;
pub const GL_SOURCE0_ALPHA_EXT = 0x8588;
pub const GL_SOURCE1_ALPHA_EXT = 0x8589;
pub const GL_SOURCE2_ALPHA_EXT = 0x858A;
pub const GL_OPERAND0_RGB_EXT = 0x8590;
pub const GL_OPERAND1_RGB_EXT = 0x8591;
pub const GL_OPERAND2_RGB_EXT = 0x8592;
pub const GL_OPERAND0_ALPHA_EXT = 0x8598;
pub const GL_OPERAND1_ALPHA_EXT = 0x8599;
pub const GL_OPERAND2_ALPHA_EXT = 0x859A;
pub const GL_EXT_texture_env_dot3 = 1;
pub const GL_DOT3_RGB_EXT = 0x8740;
pub const GL_DOT3_RGBA_EXT = 0x8741;
pub const GL_EXT_texture_filter_anisotropic = 1;
pub const GL_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE;
pub const GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF;
pub const GL_EXT_texture_filter_minmax = 1;
pub const GL_TEXTURE_REDUCTION_MODE_EXT = 0x9366;
pub const GL_WEIGHTED_AVERAGE_EXT = 0x9367;
pub const GL_EXT_texture_integer = 1;
pub const GL_RGBA32UI_EXT = 0x8D70;
pub const GL_RGB32UI_EXT = 0x8D71;
pub const GL_ALPHA32UI_EXT = 0x8D72;
pub const GL_INTENSITY32UI_EXT = 0x8D73;
pub const GL_LUMINANCE32UI_EXT = 0x8D74;
pub const GL_LUMINANCE_ALPHA32UI_EXT = 0x8D75;
pub const GL_RGBA16UI_EXT = 0x8D76;
pub const GL_RGB16UI_EXT = 0x8D77;
pub const GL_ALPHA16UI_EXT = 0x8D78;
pub const GL_INTENSITY16UI_EXT = 0x8D79;
pub const GL_LUMINANCE16UI_EXT = 0x8D7A;
pub const GL_LUMINANCE_ALPHA16UI_EXT = 0x8D7B;
pub const GL_RGBA8UI_EXT = 0x8D7C;
pub const GL_RGB8UI_EXT = 0x8D7D;
pub const GL_ALPHA8UI_EXT = 0x8D7E;
pub const GL_INTENSITY8UI_EXT = 0x8D7F;
pub const GL_LUMINANCE8UI_EXT = 0x8D80;
pub const GL_LUMINANCE_ALPHA8UI_EXT = 0x8D81;
pub const GL_RGBA32I_EXT = 0x8D82;
pub const GL_RGB32I_EXT = 0x8D83;
pub const GL_ALPHA32I_EXT = 0x8D84;
pub const GL_INTENSITY32I_EXT = 0x8D85;
pub const GL_LUMINANCE32I_EXT = 0x8D86;
pub const GL_LUMINANCE_ALPHA32I_EXT = 0x8D87;
pub const GL_RGBA16I_EXT = 0x8D88;
pub const GL_RGB16I_EXT = 0x8D89;
pub const GL_ALPHA16I_EXT = 0x8D8A;
pub const GL_INTENSITY16I_EXT = 0x8D8B;
pub const GL_LUMINANCE16I_EXT = 0x8D8C;
pub const GL_LUMINANCE_ALPHA16I_EXT = 0x8D8D;
pub const GL_RGBA8I_EXT = 0x8D8E;
pub const GL_RGB8I_EXT = 0x8D8F;
pub const GL_ALPHA8I_EXT = 0x8D90;
pub const GL_INTENSITY8I_EXT = 0x8D91;
pub const GL_LUMINANCE8I_EXT = 0x8D92;
pub const GL_LUMINANCE_ALPHA8I_EXT = 0x8D93;
pub const GL_RED_INTEGER_EXT = 0x8D94;
pub const GL_GREEN_INTEGER_EXT = 0x8D95;
pub const GL_BLUE_INTEGER_EXT = 0x8D96;
pub const GL_ALPHA_INTEGER_EXT = 0x8D97;
pub const GL_RGB_INTEGER_EXT = 0x8D98;
pub const GL_RGBA_INTEGER_EXT = 0x8D99;
pub const GL_BGR_INTEGER_EXT = 0x8D9A;
pub const GL_BGRA_INTEGER_EXT = 0x8D9B;
pub const GL_LUMINANCE_INTEGER_EXT = 0x8D9C;
pub const GL_LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D;
pub const GL_RGBA_INTEGER_MODE_EXT = 0x8D9E;
pub const GL_EXT_texture_lod_bias = 1;
pub const GL_MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD;
pub const GL_TEXTURE_FILTER_CONTROL_EXT = 0x8500;
pub const GL_TEXTURE_LOD_BIAS_EXT = 0x8501;
pub const GL_EXT_texture_mirror_clamp = 1;
pub const GL_MIRROR_CLAMP_EXT = 0x8742;
pub const GL_MIRROR_CLAMP_TO_EDGE_EXT = 0x8743;
pub const GL_MIRROR_CLAMP_TO_BORDER_EXT = 0x8912;
pub const GL_EXT_texture_object = 1;
pub const GL_TEXTURE_PRIORITY_EXT = 0x8066;
pub const GL_TEXTURE_RESIDENT_EXT = 0x8067;
pub const GL_TEXTURE_1D_BINDING_EXT = 0x8068;
pub const GL_TEXTURE_2D_BINDING_EXT = 0x8069;
pub const GL_TEXTURE_3D_BINDING_EXT = 0x806A;
pub const GL_EXT_texture_perturb_normal = 1;
pub const GL_PERTURB_EXT = 0x85AE;
pub const GL_TEXTURE_NORMAL_EXT = 0x85AF;
pub const GL_EXT_texture_sRGB = 1;
pub const GL_SRGB_EXT = 0x8C40;
pub const GL_SRGB8_EXT = 0x8C41;
pub const GL_SRGB_ALPHA_EXT = 0x8C42;
pub const GL_SRGB8_ALPHA8_EXT = 0x8C43;
pub const GL_SLUMINANCE_ALPHA_EXT = 0x8C44;
pub const GL_SLUMINANCE8_ALPHA8_EXT = 0x8C45;
pub const GL_SLUMINANCE_EXT = 0x8C46;
pub const GL_SLUMINANCE8_EXT = 0x8C47;
pub const GL_COMPRESSED_SRGB_EXT = 0x8C48;
pub const GL_COMPRESSED_SRGB_ALPHA_EXT = 0x8C49;
pub const GL_COMPRESSED_SLUMINANCE_EXT = 0x8C4A;
pub const GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B;
pub const GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C;
pub const GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D;
pub const GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E;
pub const GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F;
pub const GL_EXT_texture_sRGB_R8 = 1;
pub const GL_SR8_EXT = 0x8FBD;
pub const GL_EXT_texture_sRGB_decode = 1;
pub const GL_TEXTURE_SRGB_DECODE_EXT = 0x8A48;
pub const GL_DECODE_EXT = 0x8A49;
pub const GL_SKIP_DECODE_EXT = 0x8A4A;
pub const GL_EXT_texture_shadow_lod = 1;
pub const GL_EXT_texture_shared_exponent = 1;
pub const GL_RGB9_E5_EXT = 0x8C3D;
pub const GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E;
pub const GL_TEXTURE_SHARED_SIZE_EXT = 0x8C3F;
pub const GL_EXT_texture_snorm = 1;
pub const GL_ALPHA_SNORM = 0x9010;
pub const GL_LUMINANCE_SNORM = 0x9011;
pub const GL_LUMINANCE_ALPHA_SNORM = 0x9012;
pub const GL_INTENSITY_SNORM = 0x9013;
pub const GL_ALPHA8_SNORM = 0x9014;
pub const GL_LUMINANCE8_SNORM = 0x9015;
pub const GL_LUMINANCE8_ALPHA8_SNORM = 0x9016;
pub const GL_INTENSITY8_SNORM = 0x9017;
pub const GL_ALPHA16_SNORM = 0x9018;
pub const GL_LUMINANCE16_SNORM = 0x9019;
pub const GL_LUMINANCE16_ALPHA16_SNORM = 0x901A;
pub const GL_INTENSITY16_SNORM = 0x901B;
pub const GL_RED_SNORM = 0x8F90;
pub const GL_RG_SNORM = 0x8F91;
pub const GL_RGB_SNORM = 0x8F92;
pub const GL_RGBA_SNORM = 0x8F93;
pub const GL_EXT_texture_swizzle = 1;
pub const GL_TEXTURE_SWIZZLE_R_EXT = 0x8E42;
pub const GL_TEXTURE_SWIZZLE_G_EXT = 0x8E43;
pub const GL_TEXTURE_SWIZZLE_B_EXT = 0x8E44;
pub const GL_TEXTURE_SWIZZLE_A_EXT = 0x8E45;
pub const GL_TEXTURE_SWIZZLE_RGBA_EXT = 0x8E46;
pub const GL_EXT_timer_query = 1;
pub const GL_TIME_ELAPSED_EXT = 0x88BF;
pub const GL_EXT_transform_feedback = 1;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_EXT = 0x8C8E;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = 0x8C84;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = 0x8C85;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = 0x8C8F;
pub const GL_INTERLEAVED_ATTRIBS_EXT = 0x8C8C;
pub const GL_SEPARATE_ATTRIBS_EXT = 0x8C8D;
pub const GL_PRIMITIVES_GENERATED_EXT = 0x8C87;
pub const GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = 0x8C88;
pub const GL_RASTERIZER_DISCARD_EXT = 0x8C89;
pub const GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = 0x8C8A;
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = 0x8C8B;
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = 0x8C80;
pub const GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = 0x8C83;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = 0x8C7F;
pub const GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = 0x8C76;
pub const GL_EXT_vertex_array = 1;
pub const GL_VERTEX_ARRAY_EXT = 0x8074;
pub const GL_NORMAL_ARRAY_EXT = 0x8075;
pub const GL_COLOR_ARRAY_EXT = 0x8076;
pub const GL_INDEX_ARRAY_EXT = 0x8077;
pub const GL_TEXTURE_COORD_ARRAY_EXT = 0x8078;
pub const GL_EDGE_FLAG_ARRAY_EXT = 0x8079;
pub const GL_VERTEX_ARRAY_SIZE_EXT = 0x807A;
pub const GL_VERTEX_ARRAY_TYPE_EXT = 0x807B;
pub const GL_VERTEX_ARRAY_STRIDE_EXT = 0x807C;
pub const GL_VERTEX_ARRAY_COUNT_EXT = 0x807D;
pub const GL_NORMAL_ARRAY_TYPE_EXT = 0x807E;
pub const GL_NORMAL_ARRAY_STRIDE_EXT = 0x807F;
pub const GL_NORMAL_ARRAY_COUNT_EXT = 0x8080;
pub const GL_COLOR_ARRAY_SIZE_EXT = 0x8081;
pub const GL_COLOR_ARRAY_TYPE_EXT = 0x8082;
pub const GL_COLOR_ARRAY_STRIDE_EXT = 0x8083;
pub const GL_COLOR_ARRAY_COUNT_EXT = 0x8084;
pub const GL_INDEX_ARRAY_TYPE_EXT = 0x8085;
pub const GL_INDEX_ARRAY_STRIDE_EXT = 0x8086;
pub const GL_INDEX_ARRAY_COUNT_EXT = 0x8087;
pub const GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088;
pub const GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089;
pub const GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A;
pub const GL_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B;
pub const GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C;
pub const GL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D;
pub const GL_VERTEX_ARRAY_POINTER_EXT = 0x808E;
pub const GL_NORMAL_ARRAY_POINTER_EXT = 0x808F;
pub const GL_COLOR_ARRAY_POINTER_EXT = 0x8090;
pub const GL_INDEX_ARRAY_POINTER_EXT = 0x8091;
pub const GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092;
pub const GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093;
pub const GL_EXT_vertex_array_bgra = 1;
pub const GL_EXT_vertex_attrib_64bit = 1;
pub const GL_DOUBLE_VEC2_EXT = 0x8FFC;
pub const GL_DOUBLE_VEC3_EXT = 0x8FFD;
pub const GL_DOUBLE_VEC4_EXT = 0x8FFE;
pub const GL_DOUBLE_MAT2_EXT = 0x8F46;
pub const GL_DOUBLE_MAT3_EXT = 0x8F47;
pub const GL_DOUBLE_MAT4_EXT = 0x8F48;
pub const GL_DOUBLE_MAT2x3_EXT = 0x8F49;
pub const GL_DOUBLE_MAT2x4_EXT = 0x8F4A;
pub const GL_DOUBLE_MAT3x2_EXT = 0x8F4B;
pub const GL_DOUBLE_MAT3x4_EXT = 0x8F4C;
pub const GL_DOUBLE_MAT4x2_EXT = 0x8F4D;
pub const GL_DOUBLE_MAT4x3_EXT = 0x8F4E;
pub const GL_EXT_vertex_shader = 1;
pub const GL_VERTEX_SHADER_EXT = 0x8780;
pub const GL_VERTEX_SHADER_BINDING_EXT = 0x8781;
pub const GL_OP_INDEX_EXT = 0x8782;
pub const GL_OP_NEGATE_EXT = 0x8783;
pub const GL_OP_DOT3_EXT = 0x8784;
pub const GL_OP_DOT4_EXT = 0x8785;
pub const GL_OP_MUL_EXT = 0x8786;
pub const GL_OP_ADD_EXT = 0x8787;
pub const GL_OP_MADD_EXT = 0x8788;
pub const GL_OP_FRAC_EXT = 0x8789;
pub const GL_OP_MAX_EXT = 0x878A;
pub const GL_OP_MIN_EXT = 0x878B;
pub const GL_OP_SET_GE_EXT = 0x878C;
pub const GL_OP_SET_LT_EXT = 0x878D;
pub const GL_OP_CLAMP_EXT = 0x878E;
pub const GL_OP_FLOOR_EXT = 0x878F;
pub const GL_OP_ROUND_EXT = 0x8790;
pub const GL_OP_EXP_BASE_2_EXT = 0x8791;
pub const GL_OP_LOG_BASE_2_EXT = 0x8792;
pub const GL_OP_POWER_EXT = 0x8793;
pub const GL_OP_RECIP_EXT = 0x8794;
pub const GL_OP_RECIP_SQRT_EXT = 0x8795;
pub const GL_OP_SUB_EXT = 0x8796;
pub const GL_OP_CROSS_PRODUCT_EXT = 0x8797;
pub const GL_OP_MULTIPLY_MATRIX_EXT = 0x8798;
pub const GL_OP_MOV_EXT = 0x8799;
pub const GL_OUTPUT_VERTEX_EXT = 0x879A;
pub const GL_OUTPUT_COLOR0_EXT = 0x879B;
pub const GL_OUTPUT_COLOR1_EXT = 0x879C;
pub const GL_OUTPUT_TEXTURE_COORD0_EXT = 0x879D;
pub const GL_OUTPUT_TEXTURE_COORD1_EXT = 0x879E;
pub const GL_OUTPUT_TEXTURE_COORD2_EXT = 0x879F;
pub const GL_OUTPUT_TEXTURE_COORD3_EXT = 0x87A0;
pub const GL_OUTPUT_TEXTURE_COORD4_EXT = 0x87A1;
pub const GL_OUTPUT_TEXTURE_COORD5_EXT = 0x87A2;
pub const GL_OUTPUT_TEXTURE_COORD6_EXT = 0x87A3;
pub const GL_OUTPUT_TEXTURE_COORD7_EXT = 0x87A4;
pub const GL_OUTPUT_TEXTURE_COORD8_EXT = 0x87A5;
pub const GL_OUTPUT_TEXTURE_COORD9_EXT = 0x87A6;
pub const GL_OUTPUT_TEXTURE_COORD10_EXT = 0x87A7;
pub const GL_OUTPUT_TEXTURE_COORD11_EXT = 0x87A8;
pub const GL_OUTPUT_TEXTURE_COORD12_EXT = 0x87A9;
pub const GL_OUTPUT_TEXTURE_COORD13_EXT = 0x87AA;
pub const GL_OUTPUT_TEXTURE_COORD14_EXT = 0x87AB;
pub const GL_OUTPUT_TEXTURE_COORD15_EXT = 0x87AC;
pub const GL_OUTPUT_TEXTURE_COORD16_EXT = 0x87AD;
pub const GL_OUTPUT_TEXTURE_COORD17_EXT = 0x87AE;
pub const GL_OUTPUT_TEXTURE_COORD18_EXT = 0x87AF;
pub const GL_OUTPUT_TEXTURE_COORD19_EXT = 0x87B0;
pub const GL_OUTPUT_TEXTURE_COORD20_EXT = 0x87B1;
pub const GL_OUTPUT_TEXTURE_COORD21_EXT = 0x87B2;
pub const GL_OUTPUT_TEXTURE_COORD22_EXT = 0x87B3;
pub const GL_OUTPUT_TEXTURE_COORD23_EXT = 0x87B4;
pub const GL_OUTPUT_TEXTURE_COORD24_EXT = 0x87B5;
pub const GL_OUTPUT_TEXTURE_COORD25_EXT = 0x87B6;
pub const GL_OUTPUT_TEXTURE_COORD26_EXT = 0x87B7;
pub const GL_OUTPUT_TEXTURE_COORD27_EXT = 0x87B8;
pub const GL_OUTPUT_TEXTURE_COORD28_EXT = 0x87B9;
pub const GL_OUTPUT_TEXTURE_COORD29_EXT = 0x87BA;
pub const GL_OUTPUT_TEXTURE_COORD30_EXT = 0x87BB;
pub const GL_OUTPUT_TEXTURE_COORD31_EXT = 0x87BC;
pub const GL_OUTPUT_FOG_EXT = 0x87BD;
pub const GL_SCALAR_EXT = 0x87BE;
pub const GL_VECTOR_EXT = 0x87BF;
pub const GL_MATRIX_EXT = 0x87C0;
pub const GL_VARIANT_EXT = 0x87C1;
pub const GL_INVARIANT_EXT = 0x87C2;
pub const GL_LOCAL_CONSTANT_EXT = 0x87C3;
pub const GL_LOCAL_EXT = 0x87C4;
pub const GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5;
pub const GL_MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6;
pub const GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7;
pub const GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8;
pub const GL_MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9;
pub const GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA;
pub const GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB;
pub const GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC;
pub const GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD;
pub const GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE;
pub const GL_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF;
pub const GL_VERTEX_SHADER_VARIANTS_EXT = 0x87D0;
pub const GL_VERTEX_SHADER_INVARIANTS_EXT = 0x87D1;
pub const GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2;
pub const GL_VERTEX_SHADER_LOCALS_EXT = 0x87D3;
pub const GL_VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4;
pub const GL_X_EXT = 0x87D5;
pub const GL_Y_EXT = 0x87D6;
pub const GL_Z_EXT = 0x87D7;
pub const GL_W_EXT = 0x87D8;
pub const GL_NEGATIVE_X_EXT = 0x87D9;
pub const GL_NEGATIVE_Y_EXT = 0x87DA;
pub const GL_NEGATIVE_Z_EXT = 0x87DB;
pub const GL_NEGATIVE_W_EXT = 0x87DC;
pub const GL_ZERO_EXT = 0x87DD;
pub const GL_ONE_EXT = 0x87DE;
pub const GL_NEGATIVE_ONE_EXT = 0x87DF;
pub const GL_NORMALIZED_RANGE_EXT = 0x87E0;
pub const GL_FULL_RANGE_EXT = 0x87E1;
pub const GL_CURRENT_VERTEX_EXT = 0x87E2;
pub const GL_MVP_MATRIX_EXT = 0x87E3;
pub const GL_VARIANT_VALUE_EXT = 0x87E4;
pub const GL_VARIANT_DATATYPE_EXT = 0x87E5;
pub const GL_VARIANT_ARRAY_STRIDE_EXT = 0x87E6;
pub const GL_VARIANT_ARRAY_TYPE_EXT = 0x87E7;
pub const GL_VARIANT_ARRAY_EXT = 0x87E8;
pub const GL_VARIANT_ARRAY_POINTER_EXT = 0x87E9;
pub const GL_INVARIANT_VALUE_EXT = 0x87EA;
pub const GL_INVARIANT_DATATYPE_EXT = 0x87EB;
pub const GL_LOCAL_CONSTANT_VALUE_EXT = 0x87EC;
pub const GL_LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED;
pub const GL_EXT_vertex_weighting = 1;
pub const GL_MODELVIEW0_STACK_DEPTH_EXT = 0x0BA3;
pub const GL_MODELVIEW1_STACK_DEPTH_EXT = 0x8502;
pub const GL_MODELVIEW0_MATRIX_EXT = 0x0BA6;
pub const GL_MODELVIEW1_MATRIX_EXT = 0x8506;
pub const GL_VERTEX_WEIGHTING_EXT = 0x8509;
pub const GL_MODELVIEW0_EXT = 0x1700;
pub const GL_MODELVIEW1_EXT = 0x850A;
pub const GL_CURRENT_VERTEX_WEIGHT_EXT = 0x850B;
pub const GL_VERTEX_WEIGHT_ARRAY_EXT = 0x850C;
pub const GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D;
pub const GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E;
pub const GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F;
pub const GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510;
pub const GL_EXT_win32_keyed_mutex = 1;
pub const GL_EXT_window_rectangles = 1;
pub const GL_INCLUSIVE_EXT = 0x8F10;
pub const GL_EXCLUSIVE_EXT = 0x8F11;
pub const GL_WINDOW_RECTANGLE_EXT = 0x8F12;
pub const GL_WINDOW_RECTANGLE_MODE_EXT = 0x8F13;
pub const GL_MAX_WINDOW_RECTANGLES_EXT = 0x8F14;
pub const GL_NUM_WINDOW_RECTANGLES_EXT = 0x8F15;
pub const GL_EXT_x11_sync_object = 1;
pub const GL_SYNC_X11_FENCE_EXT = 0x90E1;
pub const GL_GREMEDY_frame_terminator = 1;
pub const GL_GREMEDY_string_marker = 1;
pub const GL_HP_convolution_border_modes = 1;
pub const GL_IGNORE_BORDER_HP = 0x8150;
pub const GL_CONSTANT_BORDER_HP = 0x8151;
pub const GL_REPLICATE_BORDER_HP = 0x8153;
pub const GL_CONVOLUTION_BORDER_COLOR_HP = 0x8154;
pub const GL_HP_image_transform = 1;
pub const GL_IMAGE_SCALE_X_HP = 0x8155;
pub const GL_IMAGE_SCALE_Y_HP = 0x8156;
pub const GL_IMAGE_TRANSLATE_X_HP = 0x8157;
pub const GL_IMAGE_TRANSLATE_Y_HP = 0x8158;
pub const GL_IMAGE_ROTATE_ANGLE_HP = 0x8159;
pub const GL_IMAGE_ROTATE_ORIGIN_X_HP = 0x815A;
pub const GL_IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B;
pub const GL_IMAGE_MAG_FILTER_HP = 0x815C;
pub const GL_IMAGE_MIN_FILTER_HP = 0x815D;
pub const GL_IMAGE_CUBIC_WEIGHT_HP = 0x815E;
pub const GL_CUBIC_HP = 0x815F;
pub const GL_AVERAGE_HP = 0x8160;
pub const GL_IMAGE_TRANSFORM_2D_HP = 0x8161;
pub const GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162;
pub const GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163;
pub const GL_HP_occlusion_test = 1;
pub const GL_OCCLUSION_TEST_HP = 0x8165;
pub const GL_OCCLUSION_TEST_RESULT_HP = 0x8166;
pub const GL_HP_texture_lighting = 1;
pub const GL_TEXTURE_LIGHTING_MODE_HP = 0x8167;
pub const GL_TEXTURE_POST_SPECULAR_HP = 0x8168;
pub const GL_TEXTURE_PRE_SPECULAR_HP = 0x8169;
pub const GL_IBM_cull_vertex = 1;
pub const GL_CULL_VERTEX_IBM = 103050;
pub const GL_IBM_multimode_draw_arrays = 1;
pub const GL_IBM_rasterpos_clip = 1;
pub const GL_RASTER_POSITION_UNCLIPPED_IBM = 0x19262;
pub const GL_IBM_static_data = 1;
pub const GL_ALL_STATIC_DATA_IBM = 103060;
pub const GL_STATIC_VERTEX_ARRAY_IBM = 103061;
pub const GL_IBM_texture_mirrored_repeat = 1;
pub const GL_MIRRORED_REPEAT_IBM = 0x8370;
pub const GL_IBM_vertex_array_lists = 1;
pub const GL_VERTEX_ARRAY_LIST_IBM = 103070;
pub const GL_NORMAL_ARRAY_LIST_IBM = 103071;
pub const GL_COLOR_ARRAY_LIST_IBM = 103072;
pub const GL_INDEX_ARRAY_LIST_IBM = 103073;
pub const GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074;
pub const GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075;
pub const GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076;
pub const GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077;
pub const GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080;
pub const GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081;
pub const GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082;
pub const GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083;
pub const GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084;
pub const GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085;
pub const GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086;
pub const GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087;
pub const GL_INGR_blend_func_separate = 1;
pub const GL_INGR_color_clamp = 1;
pub const GL_RED_MIN_CLAMP_INGR = 0x8560;
pub const GL_GREEN_MIN_CLAMP_INGR = 0x8561;
pub const GL_BLUE_MIN_CLAMP_INGR = 0x8562;
pub const GL_ALPHA_MIN_CLAMP_INGR = 0x8563;
pub const GL_RED_MAX_CLAMP_INGR = 0x8564;
pub const GL_GREEN_MAX_CLAMP_INGR = 0x8565;
pub const GL_BLUE_MAX_CLAMP_INGR = 0x8566;
pub const GL_ALPHA_MAX_CLAMP_INGR = 0x8567;
pub const GL_INGR_interlace_read = 1;
pub const GL_INTERLACE_READ_INGR = 0x8568;
pub const GL_INTEL_blackhole_render = 1;
pub const GL_BLACKHOLE_RENDER_INTEL = 0x83FC;
pub const GL_INTEL_conservative_rasterization = 1;
pub const GL_CONSERVATIVE_RASTERIZATION_INTEL = 0x83FE;
pub const GL_INTEL_fragment_shader_ordering = 1;
pub const GL_INTEL_framebuffer_CMAA = 1;
pub const GL_INTEL_map_texture = 1;
pub const GL_TEXTURE_MEMORY_LAYOUT_INTEL = 0x83FF;
pub const GL_LAYOUT_DEFAULT_INTEL = 0;
pub const GL_LAYOUT_LINEAR_INTEL = 1;
pub const GL_LAYOUT_LINEAR_CPU_CACHED_INTEL = 2;
pub const GL_INTEL_parallel_arrays = 1;
pub const GL_PARALLEL_ARRAYS_INTEL = 0x83F4;
pub const GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5;
pub const GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6;
pub const GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7;
pub const GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8;
pub const GL_INTEL_performance_query = 1;
pub const GL_PERFQUERY_SINGLE_CONTEXT_INTEL = 0x00000000;
pub const GL_PERFQUERY_GLOBAL_CONTEXT_INTEL = 0x00000001;
pub const GL_PERFQUERY_WAIT_INTEL = 0x83FB;
pub const GL_PERFQUERY_FLUSH_INTEL = 0x83FA;
pub const GL_PERFQUERY_DONOT_FLUSH_INTEL = 0x83F9;
pub const GL_PERFQUERY_COUNTER_EVENT_INTEL = 0x94F0;
pub const GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL = 0x94F1;
pub const GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL = 0x94F2;
pub const GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL = 0x94F3;
pub const GL_PERFQUERY_COUNTER_RAW_INTEL = 0x94F4;
pub const GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL = 0x94F5;
pub const GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL = 0x94F8;
pub const GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL = 0x94F9;
pub const GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL = 0x94FA;
pub const GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL = 0x94FB;
pub const GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL = 0x94FC;
pub const GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL = 0x94FD;
pub const GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL = 0x94FE;
pub const GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL = 0x94FF;
pub const GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL = 0x9500;
pub const GL_MESAX_texture_stack = 1;
pub const GL_TEXTURE_1D_STACK_MESAX = 0x8759;
pub const GL_TEXTURE_2D_STACK_MESAX = 0x875A;
pub const GL_PROXY_TEXTURE_1D_STACK_MESAX = 0x875B;
pub const GL_PROXY_TEXTURE_2D_STACK_MESAX = 0x875C;
pub const GL_TEXTURE_1D_STACK_BINDING_MESAX = 0x875D;
pub const GL_TEXTURE_2D_STACK_BINDING_MESAX = 0x875E;
pub const GL_MESA_framebuffer_flip_y = 1;
pub const GL_FRAMEBUFFER_FLIP_Y_MESA = 0x8BBB;
pub const GL_MESA_pack_invert = 1;
pub const GL_PACK_INVERT_MESA = 0x8758;
pub const GL_MESA_program_binary_formats = 1;
pub const GL_PROGRAM_BINARY_FORMAT_MESA = 0x875F;
pub const GL_MESA_resize_buffers = 1;
pub const GL_MESA_shader_integer_functions = 1;
pub const GL_MESA_tile_raster_order = 1;
pub const GL_TILE_RASTER_ORDER_FIXED_MESA = 0x8BB8;
pub const GL_TILE_RASTER_ORDER_INCREASING_X_MESA = 0x8BB9;
pub const GL_TILE_RASTER_ORDER_INCREASING_Y_MESA = 0x8BBA;
pub const GL_MESA_window_pos = 1;
pub const GL_MESA_ycbcr_texture = 1;
pub const GL_UNSIGNED_SHORT_8_8_MESA = 0x85BA;
pub const GL_UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB;
pub const GL_YCBCR_MESA = 0x8757;
pub const GL_NVX_blend_equation_advanced_multi_draw_buffers = 1;
pub const GL_NVX_conditional_render = 1;
pub const GL_NVX_gpu_memory_info = 1;
pub const GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = 0x9047;
pub const GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = 0x9048;
pub const GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX = 0x9049;
pub const GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX = 0x904A;
pub const GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX = 0x904B;
pub const GL_NVX_gpu_multicast2 = 1;
pub const GL_UPLOAD_GPU_MASK_NVX = 0x954A;
pub const GL_NVX_linked_gpu_multicast = 1;
pub const GL_LGPU_SEPARATE_STORAGE_BIT_NVX = 0x0800;
pub const GL_MAX_LGPU_GPUS_NVX = 0x92BA;
pub const GL_NVX_progress_fence = 1;
pub const GL_NV_alpha_to_coverage_dither_control = 1;
pub const GL_ALPHA_TO_COVERAGE_DITHER_DEFAULT_NV = 0x934D;
pub const GL_ALPHA_TO_COVERAGE_DITHER_ENABLE_NV = 0x934E;
pub const GL_ALPHA_TO_COVERAGE_DITHER_DISABLE_NV = 0x934F;
pub const GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV = 0x92BF;
pub const GL_NV_bindless_multi_draw_indirect = 1;
pub const GL_NV_bindless_multi_draw_indirect_count = 1;
pub const GL_NV_bindless_texture = 1;
pub const GL_NV_blend_equation_advanced = 1;
pub const GL_BLEND_OVERLAP_NV = 0x9281;
pub const GL_BLEND_PREMULTIPLIED_SRC_NV = 0x9280;
pub const GL_BLUE_NV = 0x1905;
pub const GL_COLORBURN_NV = 0x929A;
pub const GL_COLORDODGE_NV = 0x9299;
pub const GL_CONJOINT_NV = 0x9284;
pub const GL_CONTRAST_NV = 0x92A1;
pub const GL_DARKEN_NV = 0x9297;
pub const GL_DIFFERENCE_NV = 0x929E;
pub const GL_DISJOINT_NV = 0x9283;
pub const GL_DST_ATOP_NV = 0x928F;
pub const GL_DST_IN_NV = 0x928B;
pub const GL_DST_NV = 0x9287;
pub const GL_DST_OUT_NV = 0x928D;
pub const GL_DST_OVER_NV = 0x9289;
pub const GL_EXCLUSION_NV = 0x92A0;
pub const GL_GREEN_NV = 0x1904;
pub const GL_HARDLIGHT_NV = 0x929B;
pub const GL_HARDMIX_NV = 0x92A9;
pub const GL_HSL_COLOR_NV = 0x92AF;
pub const GL_HSL_HUE_NV = 0x92AD;
pub const GL_HSL_LUMINOSITY_NV = 0x92B0;
pub const GL_HSL_SATURATION_NV = 0x92AE;
pub const GL_INVERT_OVG_NV = 0x92B4;
pub const GL_INVERT_RGB_NV = 0x92A3;
pub const GL_LIGHTEN_NV = 0x9298;
pub const GL_LINEARBURN_NV = 0x92A5;
pub const GL_LINEARDODGE_NV = 0x92A4;
pub const GL_LINEARLIGHT_NV = 0x92A7;
pub const GL_MINUS_CLAMPED_NV = 0x92B3;
pub const GL_MINUS_NV = 0x929F;
pub const GL_MULTIPLY_NV = 0x9294;
pub const GL_OVERLAY_NV = 0x9296;
pub const GL_PINLIGHT_NV = 0x92A8;
pub const GL_PLUS_CLAMPED_ALPHA_NV = 0x92B2;
pub const GL_PLUS_CLAMPED_NV = 0x92B1;
pub const GL_PLUS_DARKER_NV = 0x9292;
pub const GL_PLUS_NV = 0x9291;
pub const GL_RED_NV = 0x1903;
pub const GL_SCREEN_NV = 0x9295;
pub const GL_SOFTLIGHT_NV = 0x929C;
pub const GL_SRC_ATOP_NV = 0x928E;
pub const GL_SRC_IN_NV = 0x928A;
pub const GL_SRC_NV = 0x9286;
pub const GL_SRC_OUT_NV = 0x928C;
pub const GL_SRC_OVER_NV = 0x9288;
pub const GL_UNCORRELATED_NV = 0x9282;
pub const GL_VIVIDLIGHT_NV = 0x92A6;
pub const GL_XOR_NV = 0x1506;
pub const GL_NV_blend_equation_advanced_coherent = 1;
pub const GL_BLEND_ADVANCED_COHERENT_NV = 0x9285;
pub const GL_NV_blend_minmax_factor = 1;
pub const GL_NV_blend_square = 1;
pub const GL_NV_clip_space_w_scaling = 1;
pub const GL_VIEWPORT_POSITION_W_SCALE_NV = 0x937C;
pub const GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV = 0x937D;
pub const GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV = 0x937E;
pub const GL_NV_command_list = 1;
pub const GL_TERMINATE_SEQUENCE_COMMAND_NV = 0x0000;
pub const GL_NOP_COMMAND_NV = 0x0001;
pub const GL_DRAW_ELEMENTS_COMMAND_NV = 0x0002;
pub const GL_DRAW_ARRAYS_COMMAND_NV = 0x0003;
pub const GL_DRAW_ELEMENTS_STRIP_COMMAND_NV = 0x0004;
pub const GL_DRAW_ARRAYS_STRIP_COMMAND_NV = 0x0005;
pub const GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV = 0x0006;
pub const GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV = 0x0007;
pub const GL_ELEMENT_ADDRESS_COMMAND_NV = 0x0008;
pub const GL_ATTRIBUTE_ADDRESS_COMMAND_NV = 0x0009;
pub const GL_UNIFORM_ADDRESS_COMMAND_NV = 0x000A;
pub const GL_BLEND_COLOR_COMMAND_NV = 0x000B;
pub const GL_STENCIL_REF_COMMAND_NV = 0x000C;
pub const GL_LINE_WIDTH_COMMAND_NV = 0x000D;
pub const GL_POLYGON_OFFSET_COMMAND_NV = 0x000E;
pub const GL_ALPHA_REF_COMMAND_NV = 0x000F;
pub const GL_VIEWPORT_COMMAND_NV = 0x0010;
pub const GL_SCISSOR_COMMAND_NV = 0x0011;
pub const GL_FRONT_FACE_COMMAND_NV = 0x0012;
pub const GL_NV_compute_program5 = 1;
pub const GL_COMPUTE_PROGRAM_NV = 0x90FB;
pub const GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV = 0x90FC;
pub const GL_NV_compute_shader_derivatives = 1;
pub const GL_NV_conditional_render = 1;
pub const GL_QUERY_WAIT_NV = 0x8E13;
pub const GL_QUERY_NO_WAIT_NV = 0x8E14;
pub const GL_QUERY_BY_REGION_WAIT_NV = 0x8E15;
pub const GL_QUERY_BY_REGION_NO_WAIT_NV = 0x8E16;
pub const GL_NV_conservative_raster = 1;
pub const GL_CONSERVATIVE_RASTERIZATION_NV = 0x9346;
pub const GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV = 0x9347;
pub const GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV = 0x9348;
pub const GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV = 0x9349;
pub const GL_NV_conservative_raster_dilate = 1;
pub const GL_CONSERVATIVE_RASTER_DILATE_NV = 0x9379;
pub const GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV = 0x937A;
pub const GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV = 0x937B;
pub const GL_NV_conservative_raster_pre_snap = 1;
pub const GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV = 0x9550;
pub const GL_NV_conservative_raster_pre_snap_triangles = 1;
pub const GL_CONSERVATIVE_RASTER_MODE_NV = 0x954D;
pub const GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV = 0x954E;
pub const GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV = 0x954F;
pub const GL_NV_conservative_raster_underestimation = 1;
pub const GL_NV_copy_depth_to_color = 1;
pub const GL_DEPTH_STENCIL_TO_RGBA_NV = 0x886E;
pub const GL_DEPTH_STENCIL_TO_BGRA_NV = 0x886F;
pub const GL_NV_copy_image = 1;
pub const GL_NV_deep_texture3D = 1;
pub const GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV = 0x90D0;
pub const GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV = 0x90D1;
pub const GL_NV_depth_buffer_float = 1;
pub const GL_DEPTH_COMPONENT32F_NV = 0x8DAB;
pub const GL_DEPTH32F_STENCIL8_NV = 0x8DAC;
pub const GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD;
pub const GL_DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF;
pub const GL_NV_depth_clamp = 1;
pub const GL_DEPTH_CLAMP_NV = 0x864F;
pub const GL_NV_draw_texture = 1;
pub const GL_NV_draw_vulkan_image = 1;
pub const GL_NV_evaluators = 1;
pub const GL_EVAL_2D_NV = 0x86C0;
pub const GL_EVAL_TRIANGULAR_2D_NV = 0x86C1;
pub const GL_MAP_TESSELLATION_NV = 0x86C2;
pub const GL_MAP_ATTRIB_U_ORDER_NV = 0x86C3;
pub const GL_MAP_ATTRIB_V_ORDER_NV = 0x86C4;
pub const GL_EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5;
pub const GL_EVAL_VERTEX_ATTRIB0_NV = 0x86C6;
pub const GL_EVAL_VERTEX_ATTRIB1_NV = 0x86C7;
pub const GL_EVAL_VERTEX_ATTRIB2_NV = 0x86C8;
pub const GL_EVAL_VERTEX_ATTRIB3_NV = 0x86C9;
pub const GL_EVAL_VERTEX_ATTRIB4_NV = 0x86CA;
pub const GL_EVAL_VERTEX_ATTRIB5_NV = 0x86CB;
pub const GL_EVAL_VERTEX_ATTRIB6_NV = 0x86CC;
pub const GL_EVAL_VERTEX_ATTRIB7_NV = 0x86CD;
pub const GL_EVAL_VERTEX_ATTRIB8_NV = 0x86CE;
pub const GL_EVAL_VERTEX_ATTRIB9_NV = 0x86CF;
pub const GL_EVAL_VERTEX_ATTRIB10_NV = 0x86D0;
pub const GL_EVAL_VERTEX_ATTRIB11_NV = 0x86D1;
pub const GL_EVAL_VERTEX_ATTRIB12_NV = 0x86D2;
pub const GL_EVAL_VERTEX_ATTRIB13_NV = 0x86D3;
pub const GL_EVAL_VERTEX_ATTRIB14_NV = 0x86D4;
pub const GL_EVAL_VERTEX_ATTRIB15_NV = 0x86D5;
pub const GL_MAX_MAP_TESSELLATION_NV = 0x86D6;
pub const GL_MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7;
pub const GL_NV_explicit_multisample = 1;
pub const GL_SAMPLE_POSITION_NV = 0x8E50;
pub const GL_SAMPLE_MASK_NV = 0x8E51;
pub const GL_SAMPLE_MASK_VALUE_NV = 0x8E52;
pub const GL_TEXTURE_BINDING_RENDERBUFFER_NV = 0x8E53;
pub const GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = 0x8E54;
pub const GL_TEXTURE_RENDERBUFFER_NV = 0x8E55;
pub const GL_SAMPLER_RENDERBUFFER_NV = 0x8E56;
pub const GL_INT_SAMPLER_RENDERBUFFER_NV = 0x8E57;
pub const GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = 0x8E58;
pub const GL_MAX_SAMPLE_MASK_WORDS_NV = 0x8E59;
pub const GL_NV_fence = 1;
pub const GL_ALL_COMPLETED_NV = 0x84F2;
pub const GL_FENCE_STATUS_NV = 0x84F3;
pub const GL_FENCE_CONDITION_NV = 0x84F4;
pub const GL_NV_fill_rectangle = 1;
pub const GL_FILL_RECTANGLE_NV = 0x933C;
pub const GL_NV_float_buffer = 1;
pub const GL_FLOAT_R_NV = 0x8880;
pub const GL_FLOAT_RG_NV = 0x8881;
pub const GL_FLOAT_RGB_NV = 0x8882;
pub const GL_FLOAT_RGBA_NV = 0x8883;
pub const GL_FLOAT_R16_NV = 0x8884;
pub const GL_FLOAT_R32_NV = 0x8885;
pub const GL_FLOAT_RG16_NV = 0x8886;
pub const GL_FLOAT_RG32_NV = 0x8887;
pub const GL_FLOAT_RGB16_NV = 0x8888;
pub const GL_FLOAT_RGB32_NV = 0x8889;
pub const GL_FLOAT_RGBA16_NV = 0x888A;
pub const GL_FLOAT_RGBA32_NV = 0x888B;
pub const GL_TEXTURE_FLOAT_COMPONENTS_NV = 0x888C;
pub const GL_FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D;
pub const GL_FLOAT_RGBA_MODE_NV = 0x888E;
pub const GL_NV_fog_distance = 1;
pub const GL_FOG_DISTANCE_MODE_NV = 0x855A;
pub const GL_EYE_RADIAL_NV = 0x855B;
pub const GL_EYE_PLANE_ABSOLUTE_NV = 0x855C;
pub const GL_NV_fragment_coverage_to_color = 1;
pub const GL_FRAGMENT_COVERAGE_TO_COLOR_NV = 0x92DD;
pub const GL_FRAGMENT_COVERAGE_COLOR_NV = 0x92DE;
pub const GL_NV_fragment_program = 1;
pub const GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868;
pub const GL_FRAGMENT_PROGRAM_NV = 0x8870;
pub const GL_MAX_TEXTURE_COORDS_NV = 0x8871;
pub const GL_MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872;
pub const GL_FRAGMENT_PROGRAM_BINDING_NV = 0x8873;
pub const GL_PROGRAM_ERROR_STRING_NV = 0x8874;
pub const GL_NV_fragment_program2 = 1;
pub const GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4;
pub const GL_MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5;
pub const GL_MAX_PROGRAM_IF_DEPTH_NV = 0x88F6;
pub const GL_MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7;
pub const GL_MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8;
pub const GL_NV_fragment_program4 = 1;
pub const GL_NV_fragment_program_option = 1;
pub const GL_NV_fragment_shader_barycentric = 1;
pub const GL_NV_fragment_shader_interlock = 1;
pub const GL_NV_framebuffer_mixed_samples = 1;
pub const GL_COVERAGE_MODULATION_TABLE_NV = 0x9331;
pub const GL_COLOR_SAMPLES_NV = 0x8E20;
pub const GL_DEPTH_SAMPLES_NV = 0x932D;
pub const GL_STENCIL_SAMPLES_NV = 0x932E;
pub const GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV = 0x932F;
pub const GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV = 0x9330;
pub const GL_COVERAGE_MODULATION_NV = 0x9332;
pub const GL_COVERAGE_MODULATION_TABLE_SIZE_NV = 0x9333;
pub const GL_NV_framebuffer_multisample_coverage = 1;
pub const GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB;
pub const GL_RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10;
pub const GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11;
pub const GL_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12;
pub const GL_NV_geometry_program4 = 1;
pub const GL_GEOMETRY_PROGRAM_NV = 0x8C26;
pub const GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27;
pub const GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28;
pub const GL_NV_geometry_shader4 = 1;
pub const GL_NV_geometry_shader_passthrough = 1;
pub const GL_NV_gpu_multicast = 1;
pub const GL_PER_GPU_STORAGE_BIT_NV = 0x0800;
pub const GL_MULTICAST_GPUS_NV = 0x92BA;
pub const GL_RENDER_GPU_MASK_NV = 0x9558;
pub const GL_PER_GPU_STORAGE_NV = 0x9548;
pub const GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV = 0x9549;
pub const GL_NV_gpu_program4 = 1;
pub const GL_MIN_PROGRAM_TEXEL_OFFSET_NV = 0x8904;
pub const GL_MAX_PROGRAM_TEXEL_OFFSET_NV = 0x8905;
pub const GL_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906;
pub const GL_PROGRAM_RESULT_COMPONENTS_NV = 0x8907;
pub const GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908;
pub const GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909;
pub const GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5;
pub const GL_MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6;
pub const GL_NV_gpu_program5 = 1;
pub const GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = 0x8E5A;
pub const GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = 0x8E5B;
pub const GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = 0x8E5C;
pub const GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = 0x8E5D;
pub const GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 0x8E5E;
pub const GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 0x8E5F;
pub const GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = 0x8F44;
pub const GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = 0x8F45;
pub const GL_NV_gpu_program5_mem_extended = 1;
pub const GL_NV_gpu_shader5 = 1;
pub const GL_NV_half_float = 1;
pub const GL_HALF_FLOAT_NV = 0x140B;
pub const GL_NV_internalformat_sample_query = 1;
pub const GL_MULTISAMPLES_NV = 0x9371;
pub const GL_SUPERSAMPLE_SCALE_X_NV = 0x9372;
pub const GL_SUPERSAMPLE_SCALE_Y_NV = 0x9373;
pub const GL_CONFORMANT_NV = 0x9374;
pub const GL_NV_light_max_exponent = 1;
pub const GL_MAX_SHININESS_NV = 0x8504;
pub const GL_MAX_SPOT_EXPONENT_NV = 0x8505;
pub const GL_NV_memory_attachment = 1;
pub const GL_ATTACHED_MEMORY_OBJECT_NV = 0x95A4;
pub const GL_ATTACHED_MEMORY_OFFSET_NV = 0x95A5;
pub const GL_MEMORY_ATTACHABLE_ALIGNMENT_NV = 0x95A6;
pub const GL_MEMORY_ATTACHABLE_SIZE_NV = 0x95A7;
pub const GL_MEMORY_ATTACHABLE_NV = 0x95A8;
pub const GL_DETACHED_MEMORY_INCARNATION_NV = 0x95A9;
pub const GL_DETACHED_TEXTURES_NV = 0x95AA;
pub const GL_DETACHED_BUFFERS_NV = 0x95AB;
pub const GL_MAX_DETACHED_TEXTURES_NV = 0x95AC;
pub const GL_MAX_DETACHED_BUFFERS_NV = 0x95AD;
pub const GL_NV_mesh_shader = 1;
pub const GL_MESH_SHADER_NV = 0x9559;
pub const GL_TASK_SHADER_NV = 0x955A;
pub const GL_MAX_MESH_UNIFORM_BLOCKS_NV = 0x8E60;
pub const GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV = 0x8E61;
pub const GL_MAX_MESH_IMAGE_UNIFORMS_NV = 0x8E62;
pub const GL_MAX_MESH_UNIFORM_COMPONENTS_NV = 0x8E63;
pub const GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV = 0x8E64;
pub const GL_MAX_MESH_ATOMIC_COUNTERS_NV = 0x8E65;
pub const GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV = 0x8E66;
pub const GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV = 0x8E67;
pub const GL_MAX_TASK_UNIFORM_BLOCKS_NV = 0x8E68;
pub const GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV = 0x8E69;
pub const GL_MAX_TASK_IMAGE_UNIFORMS_NV = 0x8E6A;
pub const GL_MAX_TASK_UNIFORM_COMPONENTS_NV = 0x8E6B;
pub const GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV = 0x8E6C;
pub const GL_MAX_TASK_ATOMIC_COUNTERS_NV = 0x8E6D;
pub const GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV = 0x8E6E;
pub const GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV = 0x8E6F;
pub const GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV = 0x95A2;
pub const GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV = 0x95A3;
pub const GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV = 0x9536;
pub const GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV = 0x9537;
pub const GL_MAX_MESH_OUTPUT_VERTICES_NV = 0x9538;
pub const GL_MAX_MESH_OUTPUT_PRIMITIVES_NV = 0x9539;
pub const GL_MAX_TASK_OUTPUT_COUNT_NV = 0x953A;
pub const GL_MAX_DRAW_MESH_TASKS_COUNT_NV = 0x953D;
pub const GL_MAX_MESH_VIEWS_NV = 0x9557;
pub const GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV = 0x92DF;
pub const GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV = 0x9543;
pub const GL_MAX_MESH_WORK_GROUP_SIZE_NV = 0x953B;
pub const GL_MAX_TASK_WORK_GROUP_SIZE_NV = 0x953C;
pub const GL_MESH_WORK_GROUP_SIZE_NV = 0x953E;
pub const GL_TASK_WORK_GROUP_SIZE_NV = 0x953F;
pub const GL_MESH_VERTICES_OUT_NV = 0x9579;
pub const GL_MESH_PRIMITIVES_OUT_NV = 0x957A;
pub const GL_MESH_OUTPUT_TYPE_NV = 0x957B;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV = 0x959C;
pub const GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV = 0x959D;
pub const GL_REFERENCED_BY_MESH_SHADER_NV = 0x95A0;
pub const GL_REFERENCED_BY_TASK_SHADER_NV = 0x95A1;
pub const GL_MESH_SHADER_BIT_NV = 0x00000040;
pub const GL_TASK_SHADER_BIT_NV = 0x00000080;
pub const GL_MESH_SUBROUTINE_NV = 0x957C;
pub const GL_TASK_SUBROUTINE_NV = 0x957D;
pub const GL_MESH_SUBROUTINE_UNIFORM_NV = 0x957E;
pub const GL_TASK_SUBROUTINE_UNIFORM_NV = 0x957F;
pub const GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV = 0x959E;
pub const GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV = 0x959F;
pub const GL_NV_multisample_coverage = 1;
pub const GL_NV_multisample_filter_hint = 1;
pub const GL_MULTISAMPLE_FILTER_HINT_NV = 0x8534;
pub const GL_NV_occlusion_query = 1;
pub const GL_PIXEL_COUNTER_BITS_NV = 0x8864;
pub const GL_CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865;
pub const GL_PIXEL_COUNT_NV = 0x8866;
pub const GL_PIXEL_COUNT_AVAILABLE_NV = 0x8867;
pub const GL_NV_packed_depth_stencil = 1;
pub const GL_DEPTH_STENCIL_NV = 0x84F9;
pub const GL_UNSIGNED_INT_24_8_NV = 0x84FA;
pub const GL_NV_parameter_buffer_object = 1;
pub const GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0;
pub const GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1;
pub const GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2;
pub const GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3;
pub const GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4;
pub const GL_NV_parameter_buffer_object2 = 1;
pub const GL_NV_path_rendering = 1;
pub const GL_PATH_FORMAT_SVG_NV = 0x9070;
pub const GL_PATH_FORMAT_PS_NV = 0x9071;
pub const GL_STANDARD_FONT_NAME_NV = 0x9072;
pub const GL_SYSTEM_FONT_NAME_NV = 0x9073;
pub const GL_FILE_NAME_NV = 0x9074;
pub const GL_PATH_STROKE_WIDTH_NV = 0x9075;
pub const GL_PATH_END_CAPS_NV = 0x9076;
pub const GL_PATH_INITIAL_END_CAP_NV = 0x9077;
pub const GL_PATH_TERMINAL_END_CAP_NV = 0x9078;
pub const GL_PATH_JOIN_STYLE_NV = 0x9079;
pub const GL_PATH_MITER_LIMIT_NV = 0x907A;
pub const GL_PATH_DASH_CAPS_NV = 0x907B;
pub const GL_PATH_INITIAL_DASH_CAP_NV = 0x907C;
pub const GL_PATH_TERMINAL_DASH_CAP_NV = 0x907D;
pub const GL_PATH_DASH_OFFSET_NV = 0x907E;
pub const GL_PATH_CLIENT_LENGTH_NV = 0x907F;
pub const GL_PATH_FILL_MODE_NV = 0x9080;
pub const GL_PATH_FILL_MASK_NV = 0x9081;
pub const GL_PATH_FILL_COVER_MODE_NV = 0x9082;
pub const GL_PATH_STROKE_COVER_MODE_NV = 0x9083;
pub const GL_PATH_STROKE_MASK_NV = 0x9084;
pub const GL_COUNT_UP_NV = 0x9088;
pub const GL_COUNT_DOWN_NV = 0x9089;
pub const GL_PATH_OBJECT_BOUNDING_BOX_NV = 0x908A;
pub const GL_CONVEX_HULL_NV = 0x908B;
pub const GL_BOUNDING_BOX_NV = 0x908D;
pub const GL_TRANSLATE_X_NV = 0x908E;
pub const GL_TRANSLATE_Y_NV = 0x908F;
pub const GL_TRANSLATE_2D_NV = 0x9090;
pub const GL_TRANSLATE_3D_NV = 0x9091;
pub const GL_AFFINE_2D_NV = 0x9092;
pub const GL_AFFINE_3D_NV = 0x9094;
pub const GL_TRANSPOSE_AFFINE_2D_NV = 0x9096;
pub const GL_TRANSPOSE_AFFINE_3D_NV = 0x9098;
pub const GL_UTF8_NV = 0x909A;
pub const GL_UTF16_NV = 0x909B;
pub const GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV = 0x909C;
pub const GL_PATH_COMMAND_COUNT_NV = 0x909D;
pub const GL_PATH_COORD_COUNT_NV = 0x909E;
pub const GL_PATH_DASH_ARRAY_COUNT_NV = 0x909F;
pub const GL_PATH_COMPUTED_LENGTH_NV = 0x90A0;
pub const GL_PATH_FILL_BOUNDING_BOX_NV = 0x90A1;
pub const GL_PATH_STROKE_BOUNDING_BOX_NV = 0x90A2;
pub const GL_SQUARE_NV = 0x90A3;
pub const GL_ROUND_NV = 0x90A4;
pub const GL_TRIANGULAR_NV = 0x90A5;
pub const GL_BEVEL_NV = 0x90A6;
pub const GL_MITER_REVERT_NV = 0x90A7;
pub const GL_MITER_TRUNCATE_NV = 0x90A8;
pub const GL_SKIP_MISSING_GLYPH_NV = 0x90A9;
pub const GL_USE_MISSING_GLYPH_NV = 0x90AA;
pub const GL_PATH_ERROR_POSITION_NV = 0x90AB;
pub const GL_ACCUM_ADJACENT_PAIRS_NV = 0x90AD;
pub const GL_ADJACENT_PAIRS_NV = 0x90AE;
pub const GL_FIRST_TO_REST_NV = 0x90AF;
pub const GL_PATH_GEN_MODE_NV = 0x90B0;
pub const GL_PATH_GEN_COEFF_NV = 0x90B1;
pub const GL_PATH_GEN_COMPONENTS_NV = 0x90B3;
pub const GL_PATH_STENCIL_FUNC_NV = 0x90B7;
pub const GL_PATH_STENCIL_REF_NV = 0x90B8;
pub const GL_PATH_STENCIL_VALUE_MASK_NV = 0x90B9;
pub const GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = 0x90BD;
pub const GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = 0x90BE;
pub const GL_PATH_COVER_DEPTH_FUNC_NV = 0x90BF;
pub const GL_PATH_DASH_OFFSET_RESET_NV = 0x90B4;
pub const GL_MOVE_TO_RESETS_NV = 0x90B5;
pub const GL_MOVE_TO_CONTINUES_NV = 0x90B6;
pub const GL_CLOSE_PATH_NV = 0x00;
pub const GL_MOVE_TO_NV = 0x02;
pub const GL_RELATIVE_MOVE_TO_NV = 0x03;
pub const GL_LINE_TO_NV = 0x04;
pub const GL_RELATIVE_LINE_TO_NV = 0x05;
pub const GL_HORIZONTAL_LINE_TO_NV = 0x06;
pub const GL_RELATIVE_HORIZONTAL_LINE_TO_NV = 0x07;
pub const GL_VERTICAL_LINE_TO_NV = 0x08;
pub const GL_RELATIVE_VERTICAL_LINE_TO_NV = 0x09;
pub const GL_QUADRATIC_CURVE_TO_NV = 0x0A;
pub const GL_RELATIVE_QUADRATIC_CURVE_TO_NV = 0x0B;
pub const GL_CUBIC_CURVE_TO_NV = 0x0C;
pub const GL_RELATIVE_CUBIC_CURVE_TO_NV = 0x0D;
pub const GL_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0E;
pub const GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0F;
pub const GL_SMOOTH_CUBIC_CURVE_TO_NV = 0x10;
pub const GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = 0x11;
pub const GL_SMALL_CCW_ARC_TO_NV = 0x12;
pub const GL_RELATIVE_SMALL_CCW_ARC_TO_NV = 0x13;
pub const GL_SMALL_CW_ARC_TO_NV = 0x14;
pub const GL_RELATIVE_SMALL_CW_ARC_TO_NV = 0x15;
pub const GL_LARGE_CCW_ARC_TO_NV = 0x16;
pub const GL_RELATIVE_LARGE_CCW_ARC_TO_NV = 0x17;
pub const GL_LARGE_CW_ARC_TO_NV = 0x18;
pub const GL_RELATIVE_LARGE_CW_ARC_TO_NV = 0x19;
pub const GL_RESTART_PATH_NV = 0xF0;
pub const GL_DUP_FIRST_CUBIC_CURVE_TO_NV = 0xF2;
pub const GL_DUP_LAST_CUBIC_CURVE_TO_NV = 0xF4;
pub const GL_RECT_NV = 0xF6;
pub const GL_CIRCULAR_CCW_ARC_TO_NV = 0xF8;
pub const GL_CIRCULAR_CW_ARC_TO_NV = 0xFA;
pub const GL_CIRCULAR_TANGENT_ARC_TO_NV = 0xFC;
pub const GL_ARC_TO_NV = 0xFE;
pub const GL_RELATIVE_ARC_TO_NV = 0xFF;
pub const GL_BOLD_BIT_NV = 0x01;
pub const GL_ITALIC_BIT_NV = 0x02;
pub const GL_GLYPH_WIDTH_BIT_NV = 0x01;
pub const GL_GLYPH_HEIGHT_BIT_NV = 0x02;
pub const GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV = 0x04;
pub const GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = 0x08;
pub const GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = 0x10;
pub const GL_GLYPH_VERTICAL_BEARING_X_BIT_NV = 0x20;
pub const GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV = 0x40;
pub const GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = 0x80;
pub const GL_GLYPH_HAS_KERNING_BIT_NV = 0x100;
pub const GL_FONT_X_MIN_BOUNDS_BIT_NV = 0x00010000;
pub const GL_FONT_Y_MIN_BOUNDS_BIT_NV = 0x00020000;
pub const GL_FONT_X_MAX_BOUNDS_BIT_NV = 0x00040000;
pub const GL_FONT_Y_MAX_BOUNDS_BIT_NV = 0x00080000;
pub const GL_FONT_UNITS_PER_EM_BIT_NV = 0x00100000;
pub const GL_FONT_ASCENDER_BIT_NV = 0x00200000;
pub const GL_FONT_DESCENDER_BIT_NV = 0x00400000;
pub const GL_FONT_HEIGHT_BIT_NV = 0x00800000;
pub const GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV = 0x01000000;
pub const GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV = 0x02000000;
pub const GL_FONT_UNDERLINE_POSITION_BIT_NV = 0x04000000;
pub const GL_FONT_UNDERLINE_THICKNESS_BIT_NV = 0x08000000;
pub const GL_FONT_HAS_KERNING_BIT_NV = 0x10000000;
pub const GL_ROUNDED_RECT_NV = 0xE8;
pub const GL_RELATIVE_ROUNDED_RECT_NV = 0xE9;
pub const GL_ROUNDED_RECT2_NV = 0xEA;
pub const GL_RELATIVE_ROUNDED_RECT2_NV = 0xEB;
pub const GL_ROUNDED_RECT4_NV = 0xEC;
pub const GL_RELATIVE_ROUNDED_RECT4_NV = 0xED;
pub const GL_ROUNDED_RECT8_NV = 0xEE;
pub const GL_RELATIVE_ROUNDED_RECT8_NV = 0xEF;
pub const GL_RELATIVE_RECT_NV = 0xF7;
pub const GL_FONT_GLYPHS_AVAILABLE_NV = 0x9368;
pub const GL_FONT_TARGET_UNAVAILABLE_NV = 0x9369;
pub const GL_FONT_UNAVAILABLE_NV = 0x936A;
pub const GL_FONT_UNINTELLIGIBLE_NV = 0x936B;
pub const GL_CONIC_CURVE_TO_NV = 0x1A;
pub const GL_RELATIVE_CONIC_CURVE_TO_NV = 0x1B;
pub const GL_FONT_NUM_GLYPH_INDICES_BIT_NV = 0x20000000;
pub const GL_STANDARD_FONT_FORMAT_NV = 0x936C;
pub const GL_2_BYTES_NV = 0x1407;
pub const GL_3_BYTES_NV = 0x1408;
pub const GL_4_BYTES_NV = 0x1409;
pub const GL_EYE_LINEAR_NV = 0x2400;
pub const GL_OBJECT_LINEAR_NV = 0x2401;
pub const GL_CONSTANT_NV = 0x8576;
pub const GL_PATH_FOG_GEN_MODE_NV = 0x90AC;
pub const GL_PRIMARY_COLOR_NV = 0x852C;
pub const GL_SECONDARY_COLOR_NV = 0x852D;
pub const GL_PATH_GEN_COLOR_FORMAT_NV = 0x90B2;
pub const GL_PATH_PROJECTION_NV = 0x1701;
pub const GL_PATH_MODELVIEW_NV = 0x1700;
pub const GL_PATH_MODELVIEW_STACK_DEPTH_NV = 0x0BA3;
pub const GL_PATH_MODELVIEW_MATRIX_NV = 0x0BA6;
pub const GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV = 0x0D36;
pub const GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV = 0x84E3;
pub const GL_PATH_PROJECTION_STACK_DEPTH_NV = 0x0BA4;
pub const GL_PATH_PROJECTION_MATRIX_NV = 0x0BA7;
pub const GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV = 0x0D38;
pub const GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV = 0x84E4;
pub const GL_FRAGMENT_INPUT_NV = 0x936D;
pub const GL_NV_path_rendering_shared_edge = 1;
pub const GL_SHARED_EDGE_NV = 0xC0;
pub const GL_NV_pixel_data_range = 1;
pub const GL_WRITE_PIXEL_DATA_RANGE_NV = 0x8878;
pub const GL_READ_PIXEL_DATA_RANGE_NV = 0x8879;
pub const GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A;
pub const GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B;
pub const GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C;
pub const GL_READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D;
pub const GL_NV_point_sprite = 1;
pub const GL_POINT_SPRITE_NV = 0x8861;
pub const GL_COORD_REPLACE_NV = 0x8862;
pub const GL_POINT_SPRITE_R_MODE_NV = 0x8863;
pub const GL_NV_present_video = 1;
pub const GL_FRAME_NV = 0x8E26;
pub const GL_FIELDS_NV = 0x8E27;
pub const GL_CURRENT_TIME_NV = 0x8E28;
pub const GL_NUM_FILL_STREAMS_NV = 0x8E29;
pub const GL_PRESENT_TIME_NV = 0x8E2A;
pub const GL_PRESENT_DURATION_NV = 0x8E2B;
pub const GL_NV_primitive_restart = 1;
pub const GL_PRIMITIVE_RESTART_NV = 0x8558;
pub const GL_PRIMITIVE_RESTART_INDEX_NV = 0x8559;
pub const GL_NV_query_resource = 1;
pub const GL_QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV = 0x9540;
pub const GL_QUERY_RESOURCE_MEMTYPE_VIDMEM_NV = 0x9542;
pub const GL_QUERY_RESOURCE_SYS_RESERVED_NV = 0x9544;
pub const GL_QUERY_RESOURCE_TEXTURE_NV = 0x9545;
pub const GL_QUERY_RESOURCE_RENDERBUFFER_NV = 0x9546;
pub const GL_QUERY_RESOURCE_BUFFEROBJECT_NV = 0x9547;
pub const GL_NV_query_resource_tag = 1;
pub const GL_NV_register_combiners = 1;
pub const GL_REGISTER_COMBINERS_NV = 0x8522;
pub const GL_VARIABLE_A_NV = 0x8523;
pub const GL_VARIABLE_B_NV = 0x8524;
pub const GL_VARIABLE_C_NV = 0x8525;
pub const GL_VARIABLE_D_NV = 0x8526;
pub const GL_VARIABLE_E_NV = 0x8527;
pub const GL_VARIABLE_F_NV = 0x8528;
pub const GL_VARIABLE_G_NV = 0x8529;
pub const GL_CONSTANT_COLOR0_NV = 0x852A;
pub const GL_CONSTANT_COLOR1_NV = 0x852B;
pub const GL_SPARE0_NV = 0x852E;
pub const GL_SPARE1_NV = 0x852F;
pub const GL_DISCARD_NV = 0x8530;
pub const GL_E_TIMES_F_NV = 0x8531;
pub const GL_SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532;
pub const GL_UNSIGNED_IDENTITY_NV = 0x8536;
pub const GL_UNSIGNED_INVERT_NV = 0x8537;
pub const GL_EXPAND_NORMAL_NV = 0x8538;
pub const GL_EXPAND_NEGATE_NV = 0x8539;
pub const GL_HALF_BIAS_NORMAL_NV = 0x853A;
pub const GL_HALF_BIAS_NEGATE_NV = 0x853B;
pub const GL_SIGNED_IDENTITY_NV = 0x853C;
pub const GL_SIGNED_NEGATE_NV = 0x853D;
pub const GL_SCALE_BY_TWO_NV = 0x853E;
pub const GL_SCALE_BY_FOUR_NV = 0x853F;
pub const GL_SCALE_BY_ONE_HALF_NV = 0x8540;
pub const GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541;
pub const GL_COMBINER_INPUT_NV = 0x8542;
pub const GL_COMBINER_MAPPING_NV = 0x8543;
pub const GL_COMBINER_COMPONENT_USAGE_NV = 0x8544;
pub const GL_COMBINER_AB_DOT_PRODUCT_NV = 0x8545;
pub const GL_COMBINER_CD_DOT_PRODUCT_NV = 0x8546;
pub const GL_COMBINER_MUX_SUM_NV = 0x8547;
pub const GL_COMBINER_SCALE_NV = 0x8548;
pub const GL_COMBINER_BIAS_NV = 0x8549;
pub const GL_COMBINER_AB_OUTPUT_NV = 0x854A;
pub const GL_COMBINER_CD_OUTPUT_NV = 0x854B;
pub const GL_COMBINER_SUM_OUTPUT_NV = 0x854C;
pub const GL_MAX_GENERAL_COMBINERS_NV = 0x854D;
pub const GL_NUM_GENERAL_COMBINERS_NV = 0x854E;
pub const GL_COLOR_SUM_CLAMP_NV = 0x854F;
pub const GL_COMBINER0_NV = 0x8550;
pub const GL_COMBINER1_NV = 0x8551;
pub const GL_COMBINER2_NV = 0x8552;
pub const GL_COMBINER3_NV = 0x8553;
pub const GL_COMBINER4_NV = 0x8554;
pub const GL_COMBINER5_NV = 0x8555;
pub const GL_COMBINER6_NV = 0x8556;
pub const GL_COMBINER7_NV = 0x8557;
pub const GL_NV_register_combiners2 = 1;
pub const GL_PER_STAGE_CONSTANTS_NV = 0x8535;
pub const GL_NV_representative_fragment_test = 1;
pub const GL_REPRESENTATIVE_FRAGMENT_TEST_NV = 0x937F;
pub const GL_NV_robustness_video_memory_purge = 1;
pub const GL_PURGED_CONTEXT_RESET_NV = 0x92BB;
pub const GL_NV_sample_locations = 1;
pub const GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV = 0x933D;
pub const GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV = 0x933E;
pub const GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV = 0x933F;
pub const GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV = 0x9340;
pub const GL_SAMPLE_LOCATION_NV = 0x8E50;
pub const GL_PROGRAMMABLE_SAMPLE_LOCATION_NV = 0x9341;
pub const GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV = 0x9342;
pub const GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV = 0x9343;
pub const GL_NV_sample_mask_override_coverage = 1;
pub const GL_NV_scissor_exclusive = 1;
pub const GL_SCISSOR_TEST_EXCLUSIVE_NV = 0x9555;
pub const GL_SCISSOR_BOX_EXCLUSIVE_NV = 0x9556;
pub const GL_NV_shader_atomic_counters = 1;
pub const GL_NV_shader_atomic_float = 1;
pub const GL_NV_shader_atomic_float64 = 1;
pub const GL_NV_shader_atomic_fp16_vector = 1;
pub const GL_NV_shader_atomic_int64 = 1;
pub const GL_NV_shader_buffer_load = 1;
pub const GL_BUFFER_GPU_ADDRESS_NV = 0x8F1D;
pub const GL_GPU_ADDRESS_NV = 0x8F34;
pub const GL_MAX_SHADER_BUFFER_ADDRESS_NV = 0x8F35;
pub const GL_NV_shader_buffer_store = 1;
pub const GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = 0x00000010;
pub const GL_NV_shader_storage_buffer_object = 1;
pub const GL_NV_shader_subgroup_partitioned = 1;
pub const GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100;
pub const GL_NV_shader_texture_footprint = 1;
pub const GL_NV_shader_thread_group = 1;
pub const GL_WARP_SIZE_NV = 0x9339;
pub const GL_WARPS_PER_SM_NV = 0x933A;
pub const GL_SM_COUNT_NV = 0x933B;
pub const GL_NV_shader_thread_shuffle = 1;
pub const GL_NV_shading_rate_image = 1;
pub const GL_SHADING_RATE_IMAGE_NV = 0x9563;
pub const GL_SHADING_RATE_NO_INVOCATIONS_NV = 0x9564;
pub const GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0x9565;
pub const GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 0x9566;
pub const GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 0x9567;
pub const GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 0x9568;
pub const GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 0x9569;
pub const GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 0x956A;
pub const GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 0x956B;
pub const GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 0x956C;
pub const GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 0x956D;
pub const GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 0x956E;
pub const GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 0x956F;
pub const GL_SHADING_RATE_IMAGE_BINDING_NV = 0x955B;
pub const GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV = 0x955C;
pub const GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV = 0x955D;
pub const GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV = 0x955E;
pub const GL_MAX_COARSE_FRAGMENT_SAMPLES_NV = 0x955F;
pub const GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV = 0x95AE;
pub const GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV = 0x95AF;
pub const GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV = 0x95B0;
pub const GL_NV_stereo_view_rendering = 1;
pub const GL_NV_tessellation_program5 = 1;
pub const GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = 0x86D8;
pub const GL_TESS_CONTROL_PROGRAM_NV = 0x891E;
pub const GL_TESS_EVALUATION_PROGRAM_NV = 0x891F;
pub const GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = 0x8C74;
pub const GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = 0x8C75;
pub const GL_NV_texgen_emboss = 1;
pub const GL_EMBOSS_LIGHT_NV = 0x855D;
pub const GL_EMBOSS_CONSTANT_NV = 0x855E;
pub const GL_EMBOSS_MAP_NV = 0x855F;
pub const GL_NV_texgen_reflection = 1;
pub const GL_NORMAL_MAP_NV = 0x8511;
pub const GL_REFLECTION_MAP_NV = 0x8512;
pub const GL_NV_texture_barrier = 1;
pub const GL_NV_texture_compression_vtc = 1;
pub const GL_NV_texture_env_combine4 = 1;
pub const GL_COMBINE4_NV = 0x8503;
pub const GL_SOURCE3_RGB_NV = 0x8583;
pub const GL_SOURCE3_ALPHA_NV = 0x858B;
pub const GL_OPERAND3_RGB_NV = 0x8593;
pub const GL_OPERAND3_ALPHA_NV = 0x859B;
pub const GL_NV_texture_expand_normal = 1;
pub const GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F;
pub const GL_NV_texture_multisample = 1;
pub const GL_TEXTURE_COVERAGE_SAMPLES_NV = 0x9045;
pub const GL_TEXTURE_COLOR_SAMPLES_NV = 0x9046;
pub const GL_NV_texture_rectangle = 1;
pub const GL_TEXTURE_RECTANGLE_NV = 0x84F5;
pub const GL_TEXTURE_BINDING_RECTANGLE_NV = 0x84F6;
pub const GL_PROXY_TEXTURE_RECTANGLE_NV = 0x84F7;
pub const GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8;
pub const GL_NV_texture_rectangle_compressed = 1;
pub const GL_NV_texture_shader = 1;
pub const GL_OFFSET_TEXTURE_RECTANGLE_NV = 0x864C;
pub const GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D;
pub const GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E;
pub const GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9;
pub const GL_UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA;
pub const GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB;
pub const GL_DSDT_MAG_INTENSITY_NV = 0x86DC;
pub const GL_SHADER_CONSISTENT_NV = 0x86DD;
pub const GL_TEXTURE_SHADER_NV = 0x86DE;
pub const GL_SHADER_OPERATION_NV = 0x86DF;
pub const GL_CULL_MODES_NV = 0x86E0;
pub const GL_OFFSET_TEXTURE_MATRIX_NV = 0x86E1;
pub const GL_OFFSET_TEXTURE_SCALE_NV = 0x86E2;
pub const GL_OFFSET_TEXTURE_BIAS_NV = 0x86E3;
pub const GL_OFFSET_TEXTURE_2D_MATRIX_NV = 0x86E1;
pub const GL_OFFSET_TEXTURE_2D_SCALE_NV = 0x86E2;
pub const GL_OFFSET_TEXTURE_2D_BIAS_NV = 0x86E3;
pub const GL_PREVIOUS_TEXTURE_INPUT_NV = 0x86E4;
pub const GL_CONST_EYE_NV = 0x86E5;
pub const GL_PASS_THROUGH_NV = 0x86E6;
pub const GL_CULL_FRAGMENT_NV = 0x86E7;
pub const GL_OFFSET_TEXTURE_2D_NV = 0x86E8;
pub const GL_DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9;
pub const GL_DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA;
pub const GL_DOT_PRODUCT_NV = 0x86EC;
pub const GL_DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED;
pub const GL_DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE;
pub const GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0;
pub const GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1;
pub const GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2;
pub const GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3;
pub const GL_HILO_NV = 0x86F4;
pub const GL_DSDT_NV = 0x86F5;
pub const GL_DSDT_MAG_NV = 0x86F6;
pub const GL_DSDT_MAG_VIB_NV = 0x86F7;
pub const GL_HILO16_NV = 0x86F8;
pub const GL_SIGNED_HILO_NV = 0x86F9;
pub const GL_SIGNED_HILO16_NV = 0x86FA;
pub const GL_SIGNED_RGBA_NV = 0x86FB;
pub const GL_SIGNED_RGBA8_NV = 0x86FC;
pub const GL_SIGNED_RGB_NV = 0x86FE;
pub const GL_SIGNED_RGB8_NV = 0x86FF;
pub const GL_SIGNED_LUMINANCE_NV = 0x8701;
pub const GL_SIGNED_LUMINANCE8_NV = 0x8702;
pub const GL_SIGNED_LUMINANCE_ALPHA_NV = 0x8703;
pub const GL_SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704;
pub const GL_SIGNED_ALPHA_NV = 0x8705;
pub const GL_SIGNED_ALPHA8_NV = 0x8706;
pub const GL_SIGNED_INTENSITY_NV = 0x8707;
pub const GL_SIGNED_INTENSITY8_NV = 0x8708;
pub const GL_DSDT8_NV = 0x8709;
pub const GL_DSDT8_MAG8_NV = 0x870A;
pub const GL_DSDT8_MAG8_INTENSITY8_NV = 0x870B;
pub const GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C;
pub const GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D;
pub const GL_HI_SCALE_NV = 0x870E;
pub const GL_LO_SCALE_NV = 0x870F;
pub const GL_DS_SCALE_NV = 0x8710;
pub const GL_DT_SCALE_NV = 0x8711;
pub const GL_MAGNITUDE_SCALE_NV = 0x8712;
pub const GL_VIBRANCE_SCALE_NV = 0x8713;
pub const GL_HI_BIAS_NV = 0x8714;
pub const GL_LO_BIAS_NV = 0x8715;
pub const GL_DS_BIAS_NV = 0x8716;
pub const GL_DT_BIAS_NV = 0x8717;
pub const GL_MAGNITUDE_BIAS_NV = 0x8718;
pub const GL_VIBRANCE_BIAS_NV = 0x8719;
pub const GL_TEXTURE_BORDER_VALUES_NV = 0x871A;
pub const GL_TEXTURE_HI_SIZE_NV = 0x871B;
pub const GL_TEXTURE_LO_SIZE_NV = 0x871C;
pub const GL_TEXTURE_DS_SIZE_NV = 0x871D;
pub const GL_TEXTURE_DT_SIZE_NV = 0x871E;
pub const GL_TEXTURE_MAG_SIZE_NV = 0x871F;
pub const GL_NV_texture_shader2 = 1;
pub const GL_DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF;
pub const GL_NV_texture_shader3 = 1;
pub const GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850;
pub const GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851;
pub const GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852;
pub const GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853;
pub const GL_OFFSET_HILO_TEXTURE_2D_NV = 0x8854;
pub const GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855;
pub const GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856;
pub const GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857;
pub const GL_DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858;
pub const GL_DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859;
pub const GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A;
pub const GL_DOT_PRODUCT_PASS_THROUGH_NV = 0x885B;
pub const GL_DOT_PRODUCT_TEXTURE_1D_NV = 0x885C;
pub const GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D;
pub const GL_HILO8_NV = 0x885E;
pub const GL_SIGNED_HILO8_NV = 0x885F;
pub const GL_FORCE_BLUE_TO_ONE_NV = 0x8860;
pub const GL_NV_transform_feedback = 1;
pub const GL_BACK_PRIMARY_COLOR_NV = 0x8C77;
pub const GL_BACK_SECONDARY_COLOR_NV = 0x8C78;
pub const GL_TEXTURE_COORD_NV = 0x8C79;
pub const GL_CLIP_DISTANCE_NV = 0x8C7A;
pub const GL_VERTEX_ID_NV = 0x8C7B;
pub const GL_PRIMITIVE_ID_NV = 0x8C7C;
pub const GL_GENERIC_ATTRIB_NV = 0x8C7D;
pub const GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F;
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80;
pub const GL_ACTIVE_VARYINGS_NV = 0x8C81;
pub const GL_ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82;
pub const GL_TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85;
pub const GL_TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86;
pub const GL_PRIMITIVES_GENERATED_NV = 0x8C87;
pub const GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88;
pub const GL_RASTERIZER_DISCARD_NV = 0x8C89;
pub const GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = 0x8C8A;
pub const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B;
pub const GL_INTERLEAVED_ATTRIBS_NV = 0x8C8C;
pub const GL_SEPARATE_ATTRIBS_NV = 0x8C8D;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F;
pub const GL_LAYER_NV = 0x8DAA;
pub const GL_NEXT_BUFFER_NV = -2;
pub const GL_SKIP_COMPONENTS4_NV = -3;
pub const GL_SKIP_COMPONENTS3_NV = -4;
pub const GL_SKIP_COMPONENTS2_NV = -5;
pub const GL_SKIP_COMPONENTS1_NV = -6;
pub const GL_NV_transform_feedback2 = 1;
pub const GL_TRANSFORM_FEEDBACK_NV = 0x8E22;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = 0x8E23;
pub const GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = 0x8E24;
pub const GL_TRANSFORM_FEEDBACK_BINDING_NV = 0x8E25;
pub const GL_NV_uniform_buffer_unified_memory = 1;
pub const GL_UNIFORM_BUFFER_UNIFIED_NV = 0x936E;
pub const GL_UNIFORM_BUFFER_ADDRESS_NV = 0x936F;
pub const GL_UNIFORM_BUFFER_LENGTH_NV = 0x9370;
pub const GL_NV_vdpau_interop = 1;
pub const GL_SURFACE_STATE_NV = 0x86EB;
pub const GL_SURFACE_REGISTERED_NV = 0x86FD;
pub const GL_SURFACE_MAPPED_NV = 0x8700;
pub const GL_WRITE_DISCARD_NV = 0x88BE;
pub const GL_NV_vdpau_interop2 = 1;
pub const GL_NV_vertex_array_range = 1;
pub const GL_VERTEX_ARRAY_RANGE_NV = 0x851D;
pub const GL_VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E;
pub const GL_VERTEX_ARRAY_RANGE_VALID_NV = 0x851F;
pub const GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520;
pub const GL_VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521;
pub const GL_NV_vertex_array_range2 = 1;
pub const GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533;
pub const GL_NV_vertex_attrib_integer_64bit = 1;
pub const GL_NV_vertex_buffer_unified_memory = 1;
pub const GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 0x8F1E;
pub const GL_ELEMENT_ARRAY_UNIFIED_NV = 0x8F1F;
pub const GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 0x8F20;
pub const GL_VERTEX_ARRAY_ADDRESS_NV = 0x8F21;
pub const GL_NORMAL_ARRAY_ADDRESS_NV = 0x8F22;
pub const GL_COLOR_ARRAY_ADDRESS_NV = 0x8F23;
pub const GL_INDEX_ARRAY_ADDRESS_NV = 0x8F24;
pub const GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = 0x8F25;
pub const GL_EDGE_FLAG_ARRAY_ADDRESS_NV = 0x8F26;
pub const GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = 0x8F27;
pub const GL_FOG_COORD_ARRAY_ADDRESS_NV = 0x8F28;
pub const GL_ELEMENT_ARRAY_ADDRESS_NV = 0x8F29;
pub const GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = 0x8F2A;
pub const GL_VERTEX_ARRAY_LENGTH_NV = 0x8F2B;
pub const GL_NORMAL_ARRAY_LENGTH_NV = 0x8F2C;
pub const GL_COLOR_ARRAY_LENGTH_NV = 0x8F2D;
pub const GL_INDEX_ARRAY_LENGTH_NV = 0x8F2E;
pub const GL_TEXTURE_COORD_ARRAY_LENGTH_NV = 0x8F2F;
pub const GL_EDGE_FLAG_ARRAY_LENGTH_NV = 0x8F30;
pub const GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = 0x8F31;
pub const GL_FOG_COORD_ARRAY_LENGTH_NV = 0x8F32;
pub const GL_ELEMENT_ARRAY_LENGTH_NV = 0x8F33;
pub const GL_DRAW_INDIRECT_UNIFIED_NV = 0x8F40;
pub const GL_DRAW_INDIRECT_ADDRESS_NV = 0x8F41;
pub const GL_DRAW_INDIRECT_LENGTH_NV = 0x8F42;
pub const GL_NV_vertex_program = 1;
pub const GL_VERTEX_PROGRAM_NV = 0x8620;
pub const GL_VERTEX_STATE_PROGRAM_NV = 0x8621;
pub const GL_ATTRIB_ARRAY_SIZE_NV = 0x8623;
pub const GL_ATTRIB_ARRAY_STRIDE_NV = 0x8624;
pub const GL_ATTRIB_ARRAY_TYPE_NV = 0x8625;
pub const GL_CURRENT_ATTRIB_NV = 0x8626;
pub const GL_PROGRAM_LENGTH_NV = 0x8627;
pub const GL_PROGRAM_STRING_NV = 0x8628;
pub const GL_MODELVIEW_PROJECTION_NV = 0x8629;
pub const GL_IDENTITY_NV = 0x862A;
pub const GL_INVERSE_NV = 0x862B;
pub const GL_TRANSPOSE_NV = 0x862C;
pub const GL_INVERSE_TRANSPOSE_NV = 0x862D;
pub const GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E;
pub const GL_MAX_TRACK_MATRICES_NV = 0x862F;
pub const GL_MATRIX0_NV = 0x8630;
pub const GL_MATRIX1_NV = 0x8631;
pub const GL_MATRIX2_NV = 0x8632;
pub const GL_MATRIX3_NV = 0x8633;
pub const GL_MATRIX4_NV = 0x8634;
pub const GL_MATRIX5_NV = 0x8635;
pub const GL_MATRIX6_NV = 0x8636;
pub const GL_MATRIX7_NV = 0x8637;
pub const GL_CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640;
pub const GL_CURRENT_MATRIX_NV = 0x8641;
pub const GL_VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642;
pub const GL_VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643;
pub const GL_PROGRAM_PARAMETER_NV = 0x8644;
pub const GL_ATTRIB_ARRAY_POINTER_NV = 0x8645;
pub const GL_PROGRAM_TARGET_NV = 0x8646;
pub const GL_PROGRAM_RESIDENT_NV = 0x8647;
pub const GL_TRACK_MATRIX_NV = 0x8648;
pub const GL_TRACK_MATRIX_TRANSFORM_NV = 0x8649;
pub const GL_VERTEX_PROGRAM_BINDING_NV = 0x864A;
pub const GL_PROGRAM_ERROR_POSITION_NV = 0x864B;
pub const GL_VERTEX_ATTRIB_ARRAY0_NV = 0x8650;
pub const GL_VERTEX_ATTRIB_ARRAY1_NV = 0x8651;
pub const GL_VERTEX_ATTRIB_ARRAY2_NV = 0x8652;
pub const GL_VERTEX_ATTRIB_ARRAY3_NV = 0x8653;
pub const GL_VERTEX_ATTRIB_ARRAY4_NV = 0x8654;
pub const GL_VERTEX_ATTRIB_ARRAY5_NV = 0x8655;
pub const GL_VERTEX_ATTRIB_ARRAY6_NV = 0x8656;
pub const GL_VERTEX_ATTRIB_ARRAY7_NV = 0x8657;
pub const GL_VERTEX_ATTRIB_ARRAY8_NV = 0x8658;
pub const GL_VERTEX_ATTRIB_ARRAY9_NV = 0x8659;
pub const GL_VERTEX_ATTRIB_ARRAY10_NV = 0x865A;
pub const GL_VERTEX_ATTRIB_ARRAY11_NV = 0x865B;
pub const GL_VERTEX_ATTRIB_ARRAY12_NV = 0x865C;
pub const GL_VERTEX_ATTRIB_ARRAY13_NV = 0x865D;
pub const GL_VERTEX_ATTRIB_ARRAY14_NV = 0x865E;
pub const GL_VERTEX_ATTRIB_ARRAY15_NV = 0x865F;
pub const GL_MAP1_VERTEX_ATTRIB0_4_NV = 0x8660;
pub const GL_MAP1_VERTEX_ATTRIB1_4_NV = 0x8661;
pub const GL_MAP1_VERTEX_ATTRIB2_4_NV = 0x8662;
pub const GL_MAP1_VERTEX_ATTRIB3_4_NV = 0x8663;
pub const GL_MAP1_VERTEX_ATTRIB4_4_NV = 0x8664;
pub const GL_MAP1_VERTEX_ATTRIB5_4_NV = 0x8665;
pub const GL_MAP1_VERTEX_ATTRIB6_4_NV = 0x8666;
pub const GL_MAP1_VERTEX_ATTRIB7_4_NV = 0x8667;
pub const GL_MAP1_VERTEX_ATTRIB8_4_NV = 0x8668;
pub const GL_MAP1_VERTEX_ATTRIB9_4_NV = 0x8669;
pub const GL_MAP1_VERTEX_ATTRIB10_4_NV = 0x866A;
pub const GL_MAP1_VERTEX_ATTRIB11_4_NV = 0x866B;
pub const GL_MAP1_VERTEX_ATTRIB12_4_NV = 0x866C;
pub const GL_MAP1_VERTEX_ATTRIB13_4_NV = 0x866D;
pub const GL_MAP1_VERTEX_ATTRIB14_4_NV = 0x866E;
pub const GL_MAP1_VERTEX_ATTRIB15_4_NV = 0x866F;
pub const GL_MAP2_VERTEX_ATTRIB0_4_NV = 0x8670;
pub const GL_MAP2_VERTEX_ATTRIB1_4_NV = 0x8671;
pub const GL_MAP2_VERTEX_ATTRIB2_4_NV = 0x8672;
pub const GL_MAP2_VERTEX_ATTRIB3_4_NV = 0x8673;
pub const GL_MAP2_VERTEX_ATTRIB4_4_NV = 0x8674;
pub const GL_MAP2_VERTEX_ATTRIB5_4_NV = 0x8675;
pub const GL_MAP2_VERTEX_ATTRIB6_4_NV = 0x8676;
pub const GL_MAP2_VERTEX_ATTRIB7_4_NV = 0x8677;
pub const GL_MAP2_VERTEX_ATTRIB8_4_NV = 0x8678;
pub const GL_MAP2_VERTEX_ATTRIB9_4_NV = 0x8679;
pub const GL_MAP2_VERTEX_ATTRIB10_4_NV = 0x867A;
pub const GL_MAP2_VERTEX_ATTRIB11_4_NV = 0x867B;
pub const GL_MAP2_VERTEX_ATTRIB12_4_NV = 0x867C;
pub const GL_MAP2_VERTEX_ATTRIB13_4_NV = 0x867D;
pub const GL_MAP2_VERTEX_ATTRIB14_4_NV = 0x867E;
pub const GL_MAP2_VERTEX_ATTRIB15_4_NV = 0x867F;
pub const GL_NV_vertex_program1_1 = 1;
pub const GL_NV_vertex_program2 = 1;
pub const GL_NV_vertex_program2_option = 1;
pub const GL_NV_vertex_program3 = 1;
pub const GL_NV_vertex_program4 = 1;
pub const GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD;
pub const GL_NV_video_capture = 1;
pub const GL_VIDEO_BUFFER_NV = 0x9020;
pub const GL_VIDEO_BUFFER_BINDING_NV = 0x9021;
pub const GL_FIELD_UPPER_NV = 0x9022;
pub const GL_FIELD_LOWER_NV = 0x9023;
pub const GL_NUM_VIDEO_CAPTURE_STREAMS_NV = 0x9024;
pub const GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = 0x9025;
pub const GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = 0x9026;
pub const GL_LAST_VIDEO_CAPTURE_STATUS_NV = 0x9027;
pub const GL_VIDEO_BUFFER_PITCH_NV = 0x9028;
pub const GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = 0x9029;
pub const GL_VIDEO_COLOR_CONVERSION_MAX_NV = 0x902A;
pub const GL_VIDEO_COLOR_CONVERSION_MIN_NV = 0x902B;
pub const GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = 0x902C;
pub const GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = 0x902D;
pub const GL_PARTIAL_SUCCESS_NV = 0x902E;
pub const GL_SUCCESS_NV = 0x902F;
pub const GL_FAILURE_NV = 0x9030;
pub const GL_YCBYCR8_422_NV = 0x9031;
pub const GL_YCBAYCR8A_4224_NV = 0x9032;
pub const GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = 0x9033;
pub const GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = 0x9034;
pub const GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = 0x9035;
pub const GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = 0x9036;
pub const GL_Z4Y12Z4CB12Z4CR12_444_NV = 0x9037;
pub const GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = 0x9038;
pub const GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = 0x9039;
pub const GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = 0x903A;
pub const GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = 0x903B;
pub const GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = 0x903C;
pub const GL_NV_viewport_array2 = 1;
pub const GL_NV_viewport_swizzle = 1;
pub const GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV = 0x9350;
pub const GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV = 0x9351;
pub const GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV = 0x9352;
pub const GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV = 0x9353;
pub const GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV = 0x9354;
pub const GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV = 0x9355;
pub const GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV = 0x9356;
pub const GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV = 0x9357;
pub const GL_VIEWPORT_SWIZZLE_X_NV = 0x9358;
pub const GL_VIEWPORT_SWIZZLE_Y_NV = 0x9359;
pub const GL_VIEWPORT_SWIZZLE_Z_NV = 0x935A;
pub const GL_VIEWPORT_SWIZZLE_W_NV = 0x935B;
pub const GL_OML_interlace = 1;
pub const GL_INTERLACE_OML = 0x8980;
pub const GL_INTERLACE_READ_OML = 0x8981;
pub const GL_OML_resample = 1;
pub const GL_PACK_RESAMPLE_OML = 0x8984;
pub const GL_UNPACK_RESAMPLE_OML = 0x8985;
pub const GL_RESAMPLE_REPLICATE_OML = 0x8986;
pub const GL_RESAMPLE_ZERO_FILL_OML = 0x8987;
pub const GL_RESAMPLE_AVERAGE_OML = 0x8988;
pub const GL_RESAMPLE_DECIMATE_OML = 0x8989;
pub const GL_OML_subsample = 1;
pub const GL_FORMAT_SUBSAMPLE_24_24_OML = 0x8982;
pub const GL_FORMAT_SUBSAMPLE_244_244_OML = 0x8983;
pub const GL_OVR_multiview = 1;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR = 0x9630;
pub const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR = 0x9632;
pub const GL_MAX_VIEWS_OVR = 0x9631;
pub const GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR = 0x9633;
pub const GL_OVR_multiview2 = 1;
pub const GL_PGI_misc_hints = 1;
pub const GL_PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8;
pub const GL_CONSERVE_MEMORY_HINT_PGI = 0x1A1FD;
pub const GL_RECLAIM_MEMORY_HINT_PGI = 0x1A1FE;
pub const GL_NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202;
pub const GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203;
pub const GL_NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204;
pub const GL_ALWAYS_FAST_HINT_PGI = 0x1A20C;
pub const GL_ALWAYS_SOFT_HINT_PGI = 0x1A20D;
pub const GL_ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E;
pub const GL_ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F;
pub const GL_ALLOW_DRAW_FRG_HINT_PGI = 0x1A210;
pub const GL_ALLOW_DRAW_MEM_HINT_PGI = 0x1A211;
pub const GL_STRICT_DEPTHFUNC_HINT_PGI = 0x1A216;
pub const GL_STRICT_LIGHTING_HINT_PGI = 0x1A217;
pub const GL_STRICT_SCISSOR_HINT_PGI = 0x1A218;
pub const GL_FULL_STIPPLE_HINT_PGI = 0x1A219;
pub const GL_CLIP_NEAR_HINT_PGI = 0x1A220;
pub const GL_CLIP_FAR_HINT_PGI = 0x1A221;
pub const GL_WIDE_LINE_HINT_PGI = 0x1A222;
pub const GL_BACK_NORMALS_HINT_PGI = 0x1A223;
pub const GL_PGI_vertex_hints = 1;
pub const GL_VERTEX_DATA_HINT_PGI = 0x1A22A;
pub const GL_VERTEX_CONSISTENT_HINT_PGI = 0x1A22B;
pub const GL_MATERIAL_SIDE_HINT_PGI = 0x1A22C;
pub const GL_MAX_VERTEX_HINT_PGI = 0x1A22D;
pub const GL_COLOR3_BIT_PGI = 0x00010000;
pub const GL_COLOR4_BIT_PGI = 0x00020000;
pub const GL_EDGEFLAG_BIT_PGI = 0x00040000;
pub const GL_INDEX_BIT_PGI = 0x00080000;
pub const GL_MAT_AMBIENT_BIT_PGI = 0x00100000;
pub const GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000;
pub const GL_MAT_DIFFUSE_BIT_PGI = 0x00400000;
pub const GL_MAT_EMISSION_BIT_PGI = 0x00800000;
pub const GL_MAT_COLOR_INDEXES_BIT_PGI = 0x01000000;
pub const GL_MAT_SHININESS_BIT_PGI = 0x02000000;
pub const GL_MAT_SPECULAR_BIT_PGI = 0x04000000;
pub const GL_NORMAL_BIT_PGI = 0x08000000;
pub const GL_TEXCOORD1_BIT_PGI = 0x10000000;
pub const GL_TEXCOORD2_BIT_PGI = 0x20000000;
pub const GL_TEXCOORD3_BIT_PGI = 0x40000000;
pub const GL_TEXCOORD4_BIT_PGI = 0x80000000;
pub const GL_VERTEX23_BIT_PGI = 0x00000004;
pub const GL_VERTEX4_BIT_PGI = 0x00000008;
pub const GL_REND_screen_coordinates = 1;
pub const GL_SCREEN_COORDINATES_REND = 0x8490;
pub const GL_INVERTED_SCREEN_W_REND = 0x8491;
pub const GL_S3_s3tc = 1;
pub const GL_RGB_S3TC = 0x83A0;
pub const GL_RGB4_S3TC = 0x83A1;
pub const GL_RGBA_S3TC = 0x83A2;
pub const GL_RGBA4_S3TC = 0x83A3;
pub const GL_RGBA_DXT5_S3TC = 0x83A4;
pub const GL_RGBA4_DXT5_S3TC = 0x83A5;
pub const GL_SGIS_detail_texture = 1;
pub const GL_DETAIL_TEXTURE_2D_SGIS = 0x8095;
pub const GL_DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096;
pub const GL_LINEAR_DETAIL_SGIS = 0x8097;
pub const GL_LINEAR_DETAIL_ALPHA_SGIS = 0x8098;
pub const GL_LINEAR_DETAIL_COLOR_SGIS = 0x8099;
pub const GL_DETAIL_TEXTURE_LEVEL_SGIS = 0x809A;
pub const GL_DETAIL_TEXTURE_MODE_SGIS = 0x809B;
pub const GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C;
pub const GL_SGIS_fog_function = 1;
pub const GL_FOG_FUNC_SGIS = 0x812A;
pub const GL_FOG_FUNC_POINTS_SGIS = 0x812B;
pub const GL_MAX_FOG_FUNC_POINTS_SGIS = 0x812C;
pub const GL_SGIS_generate_mipmap = 1;
pub const GL_GENERATE_MIPMAP_SGIS = 0x8191;
pub const GL_GENERATE_MIPMAP_HINT_SGIS = 0x8192;
pub const GL_SGIS_multisample = 1;
pub const GL_MULTISAMPLE_SGIS = 0x809D;
pub const GL_SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E;
pub const GL_SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F;
pub const GL_SAMPLE_MASK_SGIS = 0x80A0;
pub const GL_1PASS_SGIS = 0x80A1;
pub const GL_2PASS_0_SGIS = 0x80A2;
pub const GL_2PASS_1_SGIS = 0x80A3;
pub const GL_4PASS_0_SGIS = 0x80A4;
pub const GL_4PASS_1_SGIS = 0x80A5;
pub const GL_4PASS_2_SGIS = 0x80A6;
pub const GL_4PASS_3_SGIS = 0x80A7;
pub const GL_SAMPLE_BUFFERS_SGIS = 0x80A8;
pub const GL_SAMPLES_SGIS = 0x80A9;
pub const GL_SAMPLE_MASK_VALUE_SGIS = 0x80AA;
pub const GL_SAMPLE_MASK_INVERT_SGIS = 0x80AB;
pub const GL_SAMPLE_PATTERN_SGIS = 0x80AC;
pub const GL_SGIS_pixel_texture = 1;
pub const GL_PIXEL_TEXTURE_SGIS = 0x8353;
pub const GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354;
pub const GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355;
pub const GL_PIXEL_GROUP_COLOR_SGIS = 0x8356;
pub const GL_SGIS_point_line_texgen = 1;
pub const GL_EYE_DISTANCE_TO_POINT_SGIS = 0x81F0;
pub const GL_OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1;
pub const GL_EYE_DISTANCE_TO_LINE_SGIS = 0x81F2;
pub const GL_OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3;
pub const GL_EYE_POINT_SGIS = 0x81F4;
pub const GL_OBJECT_POINT_SGIS = 0x81F5;
pub const GL_EYE_LINE_SGIS = 0x81F6;
pub const GL_OBJECT_LINE_SGIS = 0x81F7;
pub const GL_SGIS_point_parameters = 1;
pub const GL_POINT_SIZE_MIN_SGIS = 0x8126;
pub const GL_POINT_SIZE_MAX_SGIS = 0x8127;
pub const GL_POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128;
pub const GL_DISTANCE_ATTENUATION_SGIS = 0x8129;
pub const GL_SGIS_sharpen_texture = 1;
pub const GL_LINEAR_SHARPEN_SGIS = 0x80AD;
pub const GL_LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE;
pub const GL_LINEAR_SHARPEN_COLOR_SGIS = 0x80AF;
pub const GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0;
pub const GL_SGIS_texture4D = 1;
pub const GL_PACK_SKIP_VOLUMES_SGIS = 0x8130;
pub const GL_PACK_IMAGE_DEPTH_SGIS = 0x8131;
pub const GL_UNPACK_SKIP_VOLUMES_SGIS = 0x8132;
pub const GL_UNPACK_IMAGE_DEPTH_SGIS = 0x8133;
pub const GL_TEXTURE_4D_SGIS = 0x8134;
pub const GL_PROXY_TEXTURE_4D_SGIS = 0x8135;
pub const GL_TEXTURE_4DSIZE_SGIS = 0x8136;
pub const GL_TEXTURE_WRAP_Q_SGIS = 0x8137;
pub const GL_MAX_4D_TEXTURE_SIZE_SGIS = 0x8138;
pub const GL_TEXTURE_4D_BINDING_SGIS = 0x814F;
pub const GL_SGIS_texture_border_clamp = 1;
pub const GL_CLAMP_TO_BORDER_SGIS = 0x812D;
pub const GL_SGIS_texture_color_mask = 1;
pub const GL_TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF;
pub const GL_SGIS_texture_edge_clamp = 1;
pub const GL_CLAMP_TO_EDGE_SGIS = 0x812F;
pub const GL_SGIS_texture_filter4 = 1;
pub const GL_FILTER4_SGIS = 0x8146;
pub const GL_TEXTURE_FILTER4_SIZE_SGIS = 0x8147;
pub const GL_SGIS_texture_lod = 1;
pub const GL_TEXTURE_MIN_LOD_SGIS = 0x813A;
pub const GL_TEXTURE_MAX_LOD_SGIS = 0x813B;
pub const GL_TEXTURE_BASE_LEVEL_SGIS = 0x813C;
pub const GL_TEXTURE_MAX_LEVEL_SGIS = 0x813D;
pub const GL_SGIS_texture_select = 1;
pub const GL_DUAL_ALPHA4_SGIS = 0x8110;
pub const GL_DUAL_ALPHA8_SGIS = 0x8111;
pub const GL_DUAL_ALPHA12_SGIS = 0x8112;
pub const GL_DUAL_ALPHA16_SGIS = 0x8113;
pub const GL_DUAL_LUMINANCE4_SGIS = 0x8114;
pub const GL_DUAL_LUMINANCE8_SGIS = 0x8115;
pub const GL_DUAL_LUMINANCE12_SGIS = 0x8116;
pub const GL_DUAL_LUMINANCE16_SGIS = 0x8117;
pub const GL_DUAL_INTENSITY4_SGIS = 0x8118;
pub const GL_DUAL_INTENSITY8_SGIS = 0x8119;
pub const GL_DUAL_INTENSITY12_SGIS = 0x811A;
pub const GL_DUAL_INTENSITY16_SGIS = 0x811B;
pub const GL_DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C;
pub const GL_DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D;
pub const GL_QUAD_ALPHA4_SGIS = 0x811E;
pub const GL_QUAD_ALPHA8_SGIS = 0x811F;
pub const GL_QUAD_LUMINANCE4_SGIS = 0x8120;
pub const GL_QUAD_LUMINANCE8_SGIS = 0x8121;
pub const GL_QUAD_INTENSITY4_SGIS = 0x8122;
pub const GL_QUAD_INTENSITY8_SGIS = 0x8123;
pub const GL_DUAL_TEXTURE_SELECT_SGIS = 0x8124;
pub const GL_QUAD_TEXTURE_SELECT_SGIS = 0x8125;
pub const GL_SGIX_async = 1;
pub const GL_ASYNC_MARKER_SGIX = 0x8329;
pub const GL_SGIX_async_histogram = 1;
pub const GL_ASYNC_HISTOGRAM_SGIX = 0x832C;
pub const GL_MAX_ASYNC_HISTOGRAM_SGIX = 0x832D;
pub const GL_SGIX_async_pixel = 1;
pub const GL_ASYNC_TEX_IMAGE_SGIX = 0x835C;
pub const GL_ASYNC_DRAW_PIXELS_SGIX = 0x835D;
pub const GL_ASYNC_READ_PIXELS_SGIX = 0x835E;
pub const GL_MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F;
pub const GL_MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360;
pub const GL_MAX_ASYNC_READ_PIXELS_SGIX = 0x8361;
pub const GL_SGIX_blend_alpha_minmax = 1;
pub const GL_ALPHA_MIN_SGIX = 0x8320;
pub const GL_ALPHA_MAX_SGIX = 0x8321;
pub const GL_SGIX_calligraphic_fragment = 1;
pub const GL_CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183;
pub const GL_SGIX_clipmap = 1;
pub const GL_LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170;
pub const GL_TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171;
pub const GL_TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172;
pub const GL_TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173;
pub const GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174;
pub const GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175;
pub const GL_TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176;
pub const GL_MAX_CLIPMAP_DEPTH_SGIX = 0x8177;
pub const GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178;
pub const GL_NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D;
pub const GL_NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E;
pub const GL_LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F;
pub const GL_SGIX_convolution_accuracy = 1;
pub const GL_CONVOLUTION_HINT_SGIX = 0x8316;
pub const GL_SGIX_depth_pass_instrument = 1;
pub const GL_SGIX_depth_texture = 1;
pub const GL_DEPTH_COMPONENT16_SGIX = 0x81A5;
pub const GL_DEPTH_COMPONENT24_SGIX = 0x81A6;
pub const GL_DEPTH_COMPONENT32_SGIX = 0x81A7;
pub const GL_SGIX_flush_raster = 1;
pub const GL_SGIX_fog_offset = 1;
pub const GL_FOG_OFFSET_SGIX = 0x8198;
pub const GL_FOG_OFFSET_VALUE_SGIX = 0x8199;
pub const GL_SGIX_fragment_lighting = 1;
pub const GL_FRAGMENT_LIGHTING_SGIX = 0x8400;
pub const GL_FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401;
pub const GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402;
pub const GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403;
pub const GL_MAX_FRAGMENT_LIGHTS_SGIX = 0x8404;
pub const GL_MAX_ACTIVE_LIGHTS_SGIX = 0x8405;
pub const GL_CURRENT_RASTER_NORMAL_SGIX = 0x8406;
pub const GL_LIGHT_ENV_MODE_SGIX = 0x8407;
pub const GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408;
pub const GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409;
pub const GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A;
pub const GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B;
pub const GL_FRAGMENT_LIGHT0_SGIX = 0x840C;
pub const GL_FRAGMENT_LIGHT1_SGIX = 0x840D;
pub const GL_FRAGMENT_LIGHT2_SGIX = 0x840E;
pub const GL_FRAGMENT_LIGHT3_SGIX = 0x840F;
pub const GL_FRAGMENT_LIGHT4_SGIX = 0x8410;
pub const GL_FRAGMENT_LIGHT5_SGIX = 0x8411;
pub const GL_FRAGMENT_LIGHT6_SGIX = 0x8412;
pub const GL_FRAGMENT_LIGHT7_SGIX = 0x8413;
pub const GL_SGIX_framezoom = 1;
pub const GL_FRAMEZOOM_SGIX = 0x818B;
pub const GL_FRAMEZOOM_FACTOR_SGIX = 0x818C;
pub const GL_MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D;
pub const GL_SGIX_igloo_interface = 1;
pub const GL_SGIX_instruments = 1;
pub const GL_INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180;
pub const GL_INSTRUMENT_MEASUREMENTS_SGIX = 0x8181;
pub const GL_SGIX_interlace = 1;
pub const GL_INTERLACE_SGIX = 0x8094;
pub const GL_SGIX_ir_instrument1 = 1;
pub const GL_IR_INSTRUMENT1_SGIX = 0x817F;
pub const GL_SGIX_list_priority = 1;
pub const GL_LIST_PRIORITY_SGIX = 0x8182;
pub const GL_SGIX_pixel_texture = 1;
pub const GL_PIXEL_TEX_GEN_SGIX = 0x8139;
pub const GL_PIXEL_TEX_GEN_MODE_SGIX = 0x832B;
pub const GL_SGIX_pixel_tiles = 1;
pub const GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E;
pub const GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F;
pub const GL_PIXEL_TILE_WIDTH_SGIX = 0x8140;
pub const GL_PIXEL_TILE_HEIGHT_SGIX = 0x8141;
pub const GL_PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142;
pub const GL_PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143;
pub const GL_PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144;
pub const GL_PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145;
pub const GL_SGIX_polynomial_ffd = 1;
pub const GL_TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001;
pub const GL_GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002;
pub const GL_GEOMETRY_DEFORMATION_SGIX = 0x8194;
pub const GL_TEXTURE_DEFORMATION_SGIX = 0x8195;
pub const GL_DEFORMATIONS_MASK_SGIX = 0x8196;
pub const GL_MAX_DEFORMATION_ORDER_SGIX = 0x8197;
pub const GL_SGIX_reference_plane = 1;
pub const GL_REFERENCE_PLANE_SGIX = 0x817D;
pub const GL_REFERENCE_PLANE_EQUATION_SGIX = 0x817E;
pub const GL_SGIX_resample = 1;
pub const GL_PACK_RESAMPLE_SGIX = 0x842E;
pub const GL_UNPACK_RESAMPLE_SGIX = 0x842F;
pub const GL_RESAMPLE_REPLICATE_SGIX = 0x8433;
pub const GL_RESAMPLE_ZERO_FILL_SGIX = 0x8434;
pub const GL_RESAMPLE_DECIMATE_SGIX = 0x8430;
pub const GL_SGIX_scalebias_hint = 1;
pub const GL_SCALEBIAS_HINT_SGIX = 0x8322;
pub const GL_SGIX_shadow = 1;
pub const GL_TEXTURE_COMPARE_SGIX = 0x819A;
pub const GL_TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B;
pub const GL_TEXTURE_LEQUAL_R_SGIX = 0x819C;
pub const GL_TEXTURE_GEQUAL_R_SGIX = 0x819D;
pub const GL_SGIX_shadow_ambient = 1;
pub const GL_SHADOW_AMBIENT_SGIX = 0x80BF;
pub const GL_SGIX_sprite = 1;
pub const GL_SPRITE_SGIX = 0x8148;
pub const GL_SPRITE_MODE_SGIX = 0x8149;
pub const GL_SPRITE_AXIS_SGIX = 0x814A;
pub const GL_SPRITE_TRANSLATION_SGIX = 0x814B;
pub const GL_SPRITE_AXIAL_SGIX = 0x814C;
pub const GL_SPRITE_OBJECT_ALIGNED_SGIX = 0x814D;
pub const GL_SPRITE_EYE_ALIGNED_SGIX = 0x814E;
pub const GL_SGIX_subsample = 1;
pub const GL_PACK_SUBSAMPLE_RATE_SGIX = 0x85A0;
pub const GL_UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1;
pub const GL_PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2;
pub const GL_PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3;
pub const GL_PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4;
pub const GL_SGIX_tag_sample_buffer = 1;
pub const GL_SGIX_texture_add_env = 1;
pub const GL_TEXTURE_ENV_BIAS_SGIX = 0x80BE;
pub const GL_SGIX_texture_coordinate_clamp = 1;
pub const GL_TEXTURE_MAX_CLAMP_S_SGIX = 0x8369;
pub const GL_TEXTURE_MAX_CLAMP_T_SGIX = 0x836A;
pub const GL_TEXTURE_MAX_CLAMP_R_SGIX = 0x836B;
pub const GL_SGIX_texture_lod_bias = 1;
pub const GL_TEXTURE_LOD_BIAS_S_SGIX = 0x818E;
pub const GL_TEXTURE_LOD_BIAS_T_SGIX = 0x818F;
pub const GL_TEXTURE_LOD_BIAS_R_SGIX = 0x8190;
pub const GL_SGIX_texture_multi_buffer = 1;
pub const GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E;
pub const GL_SGIX_texture_scale_bias = 1;
pub const GL_POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179;
pub const GL_POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A;
pub const GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B;
pub const GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C;
pub const GL_SGIX_vertex_preclip = 1;
pub const GL_VERTEX_PRECLIP_SGIX = 0x83EE;
pub const GL_VERTEX_PRECLIP_HINT_SGIX = 0x83EF;
pub const GL_SGIX_ycrcb = 1;
pub const GL_YCRCB_422_SGIX = 0x81BB;
pub const GL_YCRCB_444_SGIX = 0x81BC;
pub const GL_SGIX_ycrcb_subsample = 1;
pub const GL_SGIX_ycrcba = 1;
pub const GL_YCRCB_SGIX = 0x8318;
pub const GL_YCRCBA_SGIX = 0x8319;
pub const GL_SGI_color_matrix = 1;
pub const GL_COLOR_MATRIX_SGI = 0x80B1;
pub const GL_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2;
pub const GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3;
pub const GL_POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4;
pub const GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5;
pub const GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6;
pub const GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7;
pub const GL_POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8;
pub const GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9;
pub const GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA;
pub const GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB;
pub const GL_SGI_color_table = 1;
pub const GL_COLOR_TABLE_SGI = 0x80D0;
pub const GL_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1;
pub const GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2;
pub const GL_PROXY_COLOR_TABLE_SGI = 0x80D3;
pub const GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4;
pub const GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5;
pub const GL_COLOR_TABLE_SCALE_SGI = 0x80D6;
pub const GL_COLOR_TABLE_BIAS_SGI = 0x80D7;
pub const GL_COLOR_TABLE_FORMAT_SGI = 0x80D8;
pub const GL_COLOR_TABLE_WIDTH_SGI = 0x80D9;
pub const GL_COLOR_TABLE_RED_SIZE_SGI = 0x80DA;
pub const GL_COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB;
pub const GL_COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC;
pub const GL_COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD;
pub const GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE;
pub const GL_COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF;
pub const GL_SGI_texture_color_table = 1;
pub const GL_TEXTURE_COLOR_TABLE_SGI = 0x80BC;
pub const GL_PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD;
pub const GL_SUNX_constant_data = 1;
pub const GL_UNPACK_CONSTANT_DATA_SUNX = 0x81D5;
pub const GL_TEXTURE_CONSTANT_DATA_SUNX = 0x81D6;
pub const GL_SUN_convolution_border_modes = 1;
pub const GL_WRAP_BORDER_SUN = 0x81D4;
pub const GL_SUN_global_alpha = 1;
pub const GL_GLOBAL_ALPHA_SUN = 0x81D9;
pub const GL_GLOBAL_ALPHA_FACTOR_SUN = 0x81DA;
pub const GL_SUN_mesh_array = 1;
pub const GL_QUAD_MESH_SUN = 0x8614;
pub const GL_TRIANGLE_MESH_SUN = 0x8615;
pub const GL_SUN_slice_accum = 1;
pub const GL_SLICE_ACCUM_SUN = 0x85CC;
pub const GL_SUN_triangle_list = 1;
pub const GL_RESTART_SUN = 0x0001;
pub const GL_REPLACE_MIDDLE_SUN = 0x0002;
pub const GL_REPLACE_OLDEST_SUN = 0x0003;
pub const GL_TRIANGLE_LIST_SUN = 0x81D7;
pub const GL_REPLACEMENT_CODE_SUN = 0x81D8;
pub const GL_REPLACEMENT_CODE_ARRAY_SUN = 0x85C0;
pub const GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1;
pub const GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2;
pub const GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3;
pub const GL_R1UI_V3F_SUN = 0x85C4;
pub const GL_R1UI_C4UB_V3F_SUN = 0x85C5;
pub const GL_R1UI_C3F_V3F_SUN = 0x85C6;
pub const GL_R1UI_N3F_V3F_SUN = 0x85C7;
pub const GL_R1UI_C4F_N3F_V3F_SUN = 0x85C8;
pub const GL_R1UI_T2F_V3F_SUN = 0x85C9;
pub const GL_R1UI_T2F_N3F_V3F_SUN = 0x85CA;
pub const GL_R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB;
pub const GL_SUN_vertex = 1;
pub const GL_WIN_phong_shading = 1;
pub const GL_PHONG_WIN = 0x80EA;
pub const GL_PHONG_HINT_WIN = 0x80EB;
pub const GL_WIN_specular_fog = 1;
pub const GL_FOG_SPECULAR_TEXTURE_WIN = 0x80EC;
pub const GL_MESA_packed_depth_stencil = 1;
pub const GL_DEPTH_STENCIL_MESA = 0x8750;
pub const GL_UNSIGNED_INT_24_8_MESA = 0x8751;
pub const GL_UNSIGNED_INT_8_24_REV_MESA = 0x8752;
pub const GL_UNSIGNED_SHORT_15_1_MESA = 0x8753;
pub const GL_UNSIGNED_SHORT_1_15_REV_MESA = 0x8754;
pub const GL_ATI_blend_equation_separate = 1;
pub const GL_ALPHA_BLEND_EQUATION_ATI = 0x883D;
pub const GL_OES_EGL_image = 1;
pub const VERSION_MAJOR = 3;
pub const VERSION_MINOR = 3;
pub const VERSION_REVISION = 2;
pub const TRUE = 1;
pub const FALSE = 0;
pub const RELEASE = 0;
pub const PRESS = 1;
pub const REPEAT = 2;
pub const HAT_CENTERED = 0;
pub const HAT_UP = 1;
pub const HAT_RIGHT = 2;
pub const HAT_DOWN = 4;
pub const HAT_LEFT = 8;
pub const HAT_RIGHT_UP = HAT_RIGHT | HAT_UP;
pub const HAT_RIGHT_DOWN = HAT_RIGHT | HAT_DOWN;
pub const HAT_LEFT_UP = HAT_LEFT | HAT_UP;
pub const HAT_LEFT_DOWN = HAT_LEFT | HAT_DOWN;
pub const KEY_UNKNOWN = -1;
pub const KEY_SPACE = 32;
pub const KEY_APOSTROPHE = 39;
pub const KEY_COMMA = 44;
pub const KEY_MINUS = 45;
pub const KEY_PERIOD = 46;
pub const KEY_SLASH = 47;
pub const KEY_0 = 48;
pub const KEY_1 = 49;
pub const KEY_2 = 50;
pub const KEY_3 = 51;
pub const KEY_4 = 52;
pub const KEY_5 = 53;
pub const KEY_6 = 54;
pub const KEY_7 = 55;
pub const KEY_8 = 56;
pub const KEY_9 = 57;
pub const KEY_SEMICOLON = 59;
pub const KEY_EQUAL = 61;
pub const KEY_A = 65;
pub const KEY_B = 66;
pub const KEY_C = 67;
pub const KEY_D = 68;
pub const KEY_E = 69;
pub const KEY_F = 70;
pub const KEY_G = 71;
pub const KEY_H = 72;
pub const KEY_I = 73;
pub const KEY_J = 74;
pub const KEY_K = 75;
pub const KEY_L = 76;
pub const KEY_M = 77;
pub const KEY_N = 78;
pub const KEY_O = 79;
pub const KEY_P = 80;
pub const KEY_Q = 81;
pub const KEY_R = 82;
pub const KEY_S = 83;
pub const KEY_T = 84;
pub const KEY_U = 85;
pub const KEY_V = 86;
pub const KEY_W = 87;
pub const KEY_X = 88;
pub const KEY_Y = 89;
pub const KEY_Z = 90;
pub const KEY_LEFT_BRACKET = 91;
pub const KEY_BACKSLASH = 92;
pub const KEY_RIGHT_BRACKET = 93;
pub const KEY_GRAVE_ACCENT = 96;
pub const KEY_WORLD_1 = 161;
pub const KEY_WORLD_2 = 162;
pub const KEY_ESCAPE = 256;
pub const KEY_ENTER = 257;
pub const KEY_TAB = 258;
pub const KEY_BACKSPACE = 259;
pub const KEY_INSERT = 260;
pub const KEY_DELETE = 261;
pub const KEY_RIGHT = 262;
pub const KEY_LEFT = 263;
pub const KEY_DOWN = 264;
pub const KEY_UP = 265;
pub const KEY_PAGE_UP = 266;
pub const KEY_PAGE_DOWN = 267;
pub const KEY_HOME = 268;
pub const KEY_END = 269;
pub const KEY_CAPS_LOCK = 280;
pub const KEY_SCROLL_LOCK = 281;
pub const KEY_NUM_LOCK = 282;
pub const KEY_PRINT_SCREEN = 283;
pub const KEY_PAUSE = 284;
pub const KEY_F1 = 290;
pub const KEY_F2 = 291;
pub const KEY_F3 = 292;
pub const KEY_F4 = 293;
pub const KEY_F5 = 294;
pub const KEY_F6 = 295;
pub const KEY_F7 = 296;
pub const KEY_F8 = 297;
pub const KEY_F9 = 298;
pub const KEY_F10 = 299;
pub const KEY_F11 = 300;
pub const KEY_F12 = 301;
pub const KEY_F13 = 302;
pub const KEY_F14 = 303;
pub const KEY_F15 = 304;
pub const KEY_F16 = 305;
pub const KEY_F17 = 306;
pub const KEY_F18 = 307;
pub const KEY_F19 = 308;
pub const KEY_F20 = 309;
pub const KEY_F21 = 310;
pub const KEY_F22 = 311;
pub const KEY_F23 = 312;
pub const KEY_F24 = 313;
pub const KEY_F25 = 314;
pub const KEY_KP_0 = 320;
pub const KEY_KP_1 = 321;
pub const KEY_KP_2 = 322;
pub const KEY_KP_3 = 323;
pub const KEY_KP_4 = 324;
pub const KEY_KP_5 = 325;
pub const KEY_KP_6 = 326;
pub const KEY_KP_7 = 327;
pub const KEY_KP_8 = 328;
pub const KEY_KP_9 = 329;
pub const KEY_KP_DECIMAL = 330;
pub const KEY_KP_DIVIDE = 331;
pub const KEY_KP_MULTIPLY = 332;
pub const KEY_KP_SUBTRACT = 333;
pub const KEY_KP_ADD = 334;
pub const KEY_KP_ENTER = 335;
pub const KEY_KP_EQUAL = 336;
pub const KEY_LEFT_SHIFT = 340;
pub const KEY_LEFT_CONTROL = 341;
pub const KEY_LEFT_ALT = 342;
pub const KEY_LEFT_SUPER = 343;
pub const KEY_RIGHT_SHIFT = 344;
pub const KEY_RIGHT_CONTROL = 345;
pub const KEY_RIGHT_ALT = 346;
pub const KEY_RIGHT_SUPER = 347;
pub const KEY_MENU = 348;
pub const KEY_LAST = KEY_MENU;
pub const MOD_SHIFT = 0x0001;
pub const MOD_CONTROL = 0x0002;
pub const MOD_ALT = 0x0004;
pub const MOD_SUPER = 0x0008;
pub const MOD_CAPS_LOCK = 0x0010;
pub const MOD_NUM_LOCK = 0x0020;
pub const MOUSE_BUTTON_1 = 0;
pub const MOUSE_BUTTON_2 = 1;
pub const MOUSE_BUTTON_3 = 2;
pub const MOUSE_BUTTON_4 = 3;
pub const MOUSE_BUTTON_5 = 4;
pub const MOUSE_BUTTON_6 = 5;
pub const MOUSE_BUTTON_7 = 6;
pub const MOUSE_BUTTON_8 = 7;
pub const MOUSE_BUTTON_LAST = MOUSE_BUTTON_8;
pub const MOUSE_BUTTON_LEFT = MOUSE_BUTTON_1;
pub const MOUSE_BUTTON_RIGHT = MOUSE_BUTTON_2;
pub const MOUSE_BUTTON_MIDDLE = MOUSE_BUTTON_3;
pub const JOYSTICK_1 = 0;
pub const JOYSTICK_2 = 1;
pub const JOYSTICK_3 = 2;
pub const JOYSTICK_4 = 3;
pub const JOYSTICK_5 = 4;
pub const JOYSTICK_6 = 5;
pub const JOYSTICK_7 = 6;
pub const JOYSTICK_8 = 7;
pub const JOYSTICK_9 = 8;
pub const JOYSTICK_10 = 9;
pub const JOYSTICK_11 = 10;
pub const JOYSTICK_12 = 11;
pub const JOYSTICK_13 = 12;
pub const JOYSTICK_14 = 13;
pub const JOYSTICK_15 = 14;
pub const JOYSTICK_16 = 15;
pub const JOYSTICK_LAST = JOYSTICK_16;
pub const GAMEPAD_BUTTON_A = 0;
pub const GAMEPAD_BUTTON_B = 1;
pub const GAMEPAD_BUTTON_X = 2;
pub const GAMEPAD_BUTTON_Y = 3;
pub const GAMEPAD_BUTTON_LEFT_BUMPER = 4;
pub const GAMEPAD_BUTTON_RIGHT_BUMPER = 5;
pub const GAMEPAD_BUTTON_BACK = 6;
pub const GAMEPAD_BUTTON_START = 7;
pub const GAMEPAD_BUTTON_GUIDE = 8;
pub const GAMEPAD_BUTTON_LEFT_THUMB = 9;
pub const GAMEPAD_BUTTON_RIGHT_THUMB = 10;
pub const GAMEPAD_BUTTON_DPAD_UP = 11;
pub const GAMEPAD_BUTTON_DPAD_RIGHT = 12;
pub const GAMEPAD_BUTTON_DPAD_DOWN = 13;
pub const GAMEPAD_BUTTON_DPAD_LEFT = 14;
pub const GAMEPAD_BUTTON_LAST = GAMEPAD_BUTTON_DPAD_LEFT;
pub const GAMEPAD_BUTTON_CROSS = GAMEPAD_BUTTON_A;
pub const GAMEPAD_BUTTON_CIRCLE = GAMEPAD_BUTTON_B;
pub const GAMEPAD_BUTTON_SQUARE = GAMEPAD_BUTTON_X;
pub const GAMEPAD_BUTTON_TRIANGLE = GAMEPAD_BUTTON_Y;
pub const GAMEPAD_AXIS_LEFT_X = 0;
pub const GAMEPAD_AXIS_LEFT_Y = 1;
pub const GAMEPAD_AXIS_RIGHT_X = 2;
pub const GAMEPAD_AXIS_RIGHT_Y = 3;
pub const GAMEPAD_AXIS_LEFT_TRIGGER = 4;
pub const GAMEPAD_AXIS_RIGHT_TRIGGER = 5;
pub const GAMEPAD_AXIS_LAST = GAMEPAD_AXIS_RIGHT_TRIGGER;
pub const NO_ERROR = 0;
pub const NOT_INITIALIZED = 0x00010001;
pub const NO_CURRENT_CONTEXT = 0x00010002;
pub const INVALID_ENUM = 0x00010003;
pub const INVALID_VALUE = 0x00010004;
pub const OUT_OF_MEMORY = 0x00010005;
pub const API_UNAVAILABLE = 0x00010006;
pub const VERSION_UNAVAILABLE = 0x00010007;
pub const PLATFORM_ERROR = 0x00010008;
pub const FORMAT_UNAVAILABLE = 0x00010009;
pub const NO_WINDOW_CONTEXT = 0x0001000A;
pub const FOCUSED = 0x00020001;
pub const ICONIFIED = 0x00020002;
pub const RESIZABLE = 0x00020003;
pub const VISIBLE = 0x00020004;
pub const DECORATED = 0x00020005;
pub const AUTO_ICONIFY = 0x00020006;
pub const FLOATING = 0x00020007;
pub const MAXIMIZED = 0x00020008;
pub const CENTER_CURSOR = 0x00020009;
pub const TRANSPARENT_FRAMEBUFFER = 0x0002000A;
pub const HOVERED = 0x0002000B;
pub const FOCUS_ON_SHOW = 0x0002000C;
pub const RED_BITS = 0x00021001;
pub const GREEN_BITS = 0x00021002;
pub const BLUE_BITS = 0x00021003;
pub const ALPHA_BITS = 0x00021004;
pub const DEPTH_BITS = 0x00021005;
pub const STENCIL_BITS = 0x00021006;
pub const ACCUM_RED_BITS = 0x00021007;
pub const ACCUM_GREEN_BITS = 0x00021008;
pub const ACCUM_BLUE_BITS = 0x00021009;
pub const ACCUM_ALPHA_BITS = 0x0002100A;
pub const AUX_BUFFERS = 0x0002100B;
pub const STEREO = 0x0002100C;
pub const SAMPLES = 0x0002100D;
pub const SRGB_CAPABLE = 0x0002100E;
pub const REFRESH_RATE = 0x0002100F;
pub const DOUBLEBUFFER = 0x00021010;
pub const CLIENT_API = 0x00022001;
pub const CONTEXT_VERSION_MAJOR = 0x00022002;
pub const CONTEXT_VERSION_MINOR = 0x00022003;
pub const CONTEXT_REVISION = 0x00022004;
pub const CONTEXT_ROBUSTNESS = 0x00022005;
pub const OPENGL_FORWARD_COMPAT = 0x00022006;
pub const OPENGL_DEBUG_CONTEXT = 0x00022007;
pub const OPENGL_PROFILE = 0x00022008;
pub const CONTEXT_RELEASE_BEHAVIOR = 0x00022009;
pub const CONTEXT_NO_ERROR = 0x0002200A;
pub const CONTEXT_CREATION_API = 0x0002200B;
pub const SCALE_TO_MONITOR = 0x0002200C;
pub const COCOA_RETINA_FRAMEBUFFER = 0x00023001;
pub const COCOA_FRAME_NAME = 0x00023002;
pub const COCOA_GRAPHICS_SWITCHING = 0x00023003;
pub const X11_CLASS_NAME = 0x00024001;
pub const X11_INSTANCE_NAME = 0x00024002;
pub const NO_API = 0;
pub const OPENGL_API = 0x00030001;
pub const OPENGL_ES_API = 0x00030002;
pub const NO_ROBUSTNESS = 0;
pub const NO_RESET_NOTIFICATION = 0x00031001;
pub const LOSE_CONTEXT_ON_RESET = 0x00031002;
pub const OPENGL_ANY_PROFILE = 0;
pub const OPENGL_CORE_PROFILE = 0x00032001;
pub const OPENGL_COMPAT_PROFILE = 0x00032002;
pub const CURSOR = 0x00033001;
pub const STICKY_KEYS = 0x00033002;
pub const STICKY_MOUSE_BUTTONS = 0x00033003;
pub const LOCK_KEY_MODS = 0x00033004;
pub const RAW_MOUSE_MOTION = 0x00033005;
pub const CURSOR_NORMAL = 0x00034001;
pub const CURSOR_HIDDEN = 0x00034002;
pub const CURSOR_DISABLED = 0x00034003;
pub const ANY_RELEASE_BEHAVIOR = 0;
pub const RELEASE_BEHAVIOR_FLUSH = 0x00035001;
pub const RELEASE_BEHAVIOR_NONE = 0x00035002;
pub const NATIVE_CONTEXT_API = 0x00036001;
pub const EGL_CONTEXT_API = 0x00036002;
pub const OSMESA_CONTEXT_API = 0x00036003;
pub const ARROW_CURSOR = 0x00036001;
pub const IBEAM_CURSOR = 0x00036002;
pub const CROSSHAIR_CURSOR = 0x00036003;
pub const HAND_CURSOR = 0x00036004;
pub const HRESIZE_CURSOR = 0x00036005;
pub const VRESIZE_CURSOR = 0x00036006;
pub const CONNECTED = 0x00040001;
pub const DISCONNECTED = 0x00040002;
pub const JOYSTICK_HAT_BUTTONS = 0x00050001;
pub const COCOA_CHDIR_RESOURCES = 0x00051001;
pub const COCOA_MENUBAR = 0x00051002;
pub const DONT_CARE = -1;
pub const __GLsync = struct___GLsync;
pub const _cl_context = struct__cl_context;
pub const _cl_event = struct__cl_event; | src/lib/glfw3.zig |
pub usingnamespace @cImport({
@cDefine("GLFW_INCLUDE_GLEXT", "");
@cInclude("GLFW/glfw3.h");
@cInclude("fmod.h");
@cInclude("stb_image.h");
@cInclude("stb_perlin.h");
});
pub var glCreateTextures: @typeInfo(PFNGLCREATETEXTURESPROC).Optional.child = undefined;
pub var glTextureStorage2D: @typeInfo(PFNGLTEXTURESTORAGE2DPROC).Optional.child = undefined;
pub var glTextureStorage2DMultisample: @typeInfo(PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC).Optional.child = undefined;
pub var glTextureParameteri: @typeInfo(PFNGLTEXTUREPARAMETERIPROC).Optional.child = undefined;
pub var glTextureParameterf: @typeInfo(PFNGLTEXTUREPARAMETERFPROC).Optional.child = undefined;
pub var glTextureParameterfv: @typeInfo(PFNGLTEXTUREPARAMETERFVPROC).Optional.child = undefined;
pub var glTextureSubImage2D: @typeInfo(PFNGLTEXTURESUBIMAGE2DPROC).Optional.child = undefined;
pub var glDrawTextureNV: @typeInfo(PFNGLDRAWTEXTURENVPROC).Optional.child = undefined;
pub var glMatrixLoadIdentityEXT: @typeInfo(PFNGLMATRIXLOADIDENTITYEXTPROC).Optional.child = undefined;
pub var glMatrixOrthoEXT: @typeInfo(PFNGLMATRIXORTHOEXTPROC).Optional.child = undefined;
pub var glCreateFramebuffers: @typeInfo(PFNGLCREATEFRAMEBUFFERSPROC).Optional.child = undefined;
pub var glDeleteFramebuffers: @typeInfo(PFNGLDELETEFRAMEBUFFERSPROC).Optional.child = undefined;
pub var glBindFramebuffer: @typeInfo(PFNGLBINDFRAMEBUFFERPROC).Optional.child = undefined;
pub var glNamedFramebufferTexture: @typeInfo(PFNGLNAMEDFRAMEBUFFERTEXTUREPROC).Optional.child = undefined;
pub var glBlitNamedFramebuffer: @typeInfo(PFNGLBLITNAMEDFRAMEBUFFERPROC).Optional.child = undefined;
pub var glClearNamedFramebufferfv: @typeInfo(PFNGLCLEARNAMEDFRAMEBUFFERFVPROC).Optional.child = undefined;
pub var glClearNamedFramebufferfi: @typeInfo(PFNGLCLEARNAMEDFRAMEBUFFERFIPROC).Optional.child = undefined;
pub var glDebugMessageCallback: @typeInfo(PFNGLDEBUGMESSAGECALLBACKPROC).Optional.child = undefined;
pub var glUseProgram: @typeInfo(PFNGLUSEPROGRAMPROC).Optional.child = undefined;
pub var glUseProgramStages: @typeInfo(PFNGLUSEPROGRAMSTAGESPROC).Optional.child = undefined;
pub var glCreateShaderProgramv: @typeInfo(PFNGLCREATESHADERPROGRAMVPROC).Optional.child = undefined;
pub var glDeleteProgram: @typeInfo(PFNGLDELETEPROGRAMPROC).Optional.child = undefined;
pub var glCreateProgramPipelines: @typeInfo(PFNGLCREATEPROGRAMPIPELINESPROC).Optional.child = undefined;
pub var glBindProgramPipeline: @typeInfo(PFNGLBINDPROGRAMPIPELINEPROC).Optional.child = undefined;
pub var glStencilFillPathNV: @typeInfo(PFNGLSTENCILFILLPATHNVPROC).Optional.child = undefined;
pub var glStencilStrokePathNV: @typeInfo(PFNGLSTENCILSTROKEPATHNVPROC).Optional.child = undefined;
pub var glCoverFillPathNV: @typeInfo(PFNGLCOVERFILLPATHNVPROC).Optional.child = undefined;
pub var glCoverStrokePathNV: @typeInfo(PFNGLCOVERSTROKEPATHNVPROC).Optional.child = undefined;
pub var glStencilThenCoverFillPathNV: @typeInfo(PFNGLSTENCILTHENCOVERFILLPATHNVPROC).Optional.child = undefined;
pub var glStencilThenCoverStrokePathNV: @typeInfo(PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC).Optional.child = undefined;
pub var glPathCommandsNV: @typeInfo(PFNGLPATHCOMMANDSNVPROC).Optional.child = undefined;
pub var glPathParameteriNV: @typeInfo(PFNGLPATHPARAMETERINVPROC).Optional.child = undefined;
pub var glPathParameterivNV: @typeInfo(PFNGLPATHPARAMETERIVNVPROC).Optional.child = undefined;
pub var glPathParameterfNV: @typeInfo(PFNGLPATHPARAMETERFNVPROC).Optional.child = undefined;
pub var glPathParameterfvNV: @typeInfo(PFNGLPATHPARAMETERFVNVPROC).Optional.child = undefined;
pub fn initOpenGlEntryPoints() void {
glCreateTextures = @ptrCast(@TypeOf(glCreateTextures), glfwGetProcAddress("glCreateTextures").?);
glTextureStorage2D = @ptrCast(@TypeOf(glTextureStorage2D), glfwGetProcAddress("glTextureStorage2D").?);
glTextureStorage2DMultisample = @ptrCast(
@TypeOf(glTextureStorage2DMultisample),
glfwGetProcAddress("glTextureStorage2DMultisample").?,
);
glTextureParameteri = @ptrCast(@TypeOf(glTextureParameteri), glfwGetProcAddress("glTextureParameteri").?);
glTextureParameterf = @ptrCast(@TypeOf(glTextureParameterf), glfwGetProcAddress("glTextureParameterf").?);
glTextureParameterfv = @ptrCast(@TypeOf(glTextureParameterfv), glfwGetProcAddress("glTextureParameterfv").?);
glTextureSubImage2D = @ptrCast(@TypeOf(glTextureSubImage2D), glfwGetProcAddress("glTextureSubImage2D").?);
glDrawTextureNV = @ptrCast(@TypeOf(glDrawTextureNV), glfwGetProcAddress("glDrawTextureNV").?);
glMatrixLoadIdentityEXT = @ptrCast(@TypeOf(glMatrixLoadIdentityEXT), glfwGetProcAddress("glMatrixLoadIdentityEXT").?);
glMatrixOrthoEXT = @ptrCast(@TypeOf(glMatrixOrthoEXT), glfwGetProcAddress("glMatrixOrthoEXT").?);
glCreateFramebuffers = @ptrCast(@TypeOf(glCreateFramebuffers), glfwGetProcAddress("glCreateFramebuffers").?);
glDeleteFramebuffers = @ptrCast(@TypeOf(glDeleteFramebuffers), glfwGetProcAddress("glDeleteFramebuffers").?);
glBindFramebuffer = @ptrCast(@TypeOf(glBindFramebuffer), glfwGetProcAddress("glBindFramebuffer").?);
glNamedFramebufferTexture = @ptrCast(
@TypeOf(glNamedFramebufferTexture),
glfwGetProcAddress("glNamedFramebufferTexture").?,
);
glBlitNamedFramebuffer = @ptrCast(@TypeOf(glBlitNamedFramebuffer), glfwGetProcAddress("glBlitNamedFramebuffer").?);
glClearNamedFramebufferfv = @ptrCast(
@TypeOf(glClearNamedFramebufferfv),
glfwGetProcAddress("glClearNamedFramebufferfv").?,
);
glClearNamedFramebufferfi = @ptrCast(
@TypeOf(glClearNamedFramebufferfi),
glfwGetProcAddress("glClearNamedFramebufferfi").?,
);
glDebugMessageCallback = @ptrCast(@TypeOf(glDebugMessageCallback), glfwGetProcAddress("glDebugMessageCallback").?);
glUseProgram = @ptrCast(@TypeOf(glUseProgram), glfwGetProcAddress("glUseProgram").?);
glUseProgramStages = @ptrCast(@TypeOf(glUseProgramStages), glfwGetProcAddress("glUseProgramStages").?);
glCreateShaderProgramv = @ptrCast(@TypeOf(glCreateShaderProgramv), glfwGetProcAddress("glCreateShaderProgramv").?);
glDeleteProgram = @ptrCast(@TypeOf(glDeleteProgram), glfwGetProcAddress("glDeleteProgram").?);
glCreateProgramPipelines = @ptrCast(@TypeOf(glCreateProgramPipelines), glfwGetProcAddress("glCreateProgramPipelines").?);
glBindProgramPipeline = @ptrCast(@TypeOf(glBindProgramPipeline), glfwGetProcAddress("glBindProgramPipeline").?);
glStencilFillPathNV = @ptrCast(@TypeOf(glStencilFillPathNV), glfwGetProcAddress("glStencilFillPathNV").?);
glStencilStrokePathNV = @ptrCast(@TypeOf(glStencilStrokePathNV), glfwGetProcAddress("glStencilStrokePathNV").?);
glCoverFillPathNV = @ptrCast(@TypeOf(glCoverFillPathNV), glfwGetProcAddress("glCoverFillPathNV").?);
glCoverStrokePathNV = @ptrCast(@TypeOf(glCoverStrokePathNV), glfwGetProcAddress("glCoverStrokePathNV").?);
glStencilThenCoverFillPathNV = @ptrCast(
@TypeOf(glStencilThenCoverFillPathNV),
glfwGetProcAddress("glStencilThenCoverFillPathNV").?,
);
glStencilThenCoverStrokePathNV = @ptrCast(
@TypeOf(glStencilThenCoverStrokePathNV),
glfwGetProcAddress("glStencilThenCoverStrokePathNV").?,
);
glPathCommandsNV = @ptrCast(@TypeOf(glPathCommandsNV), glfwGetProcAddress("glPathCommandsNV").?);
glPathParameteriNV = @ptrCast(@TypeOf(glPathParameteriNV), glfwGetProcAddress("glPathParameteriNV").?);
glPathParameterivNV = @ptrCast(@TypeOf(glPathParameterivNV), glfwGetProcAddress("glPathParameterivNV").?);
glPathParameterfNV = @ptrCast(@TypeOf(glPathParameterfNV), glfwGetProcAddress("glPathParameterfNV").?);
glPathParameterfvNV = @ptrCast(@TypeOf(glPathParameterfvNV), glfwGetProcAddress("glPathParameterfvNV").?);
} | src/c.zig |
const std = @import("std");
const panic = std.debug.panic;
const builtin = @import("builtin");
const warn = std.debug.warn;
const join = std.fs.path.join;
const pi = std.math.pi;
const sin = std.math.sin;
const cos = std.math.cos;
usingnamespace @import("c.zig");
const Camera = @import("camera.zig").Camera;
const Shader = @import("shader.zig").Shader;
const glm = @import("glm.zig");
const Mat4 = glm.Mat4;
const Vec3 = glm.Vec3;
const vec3 = glm.vec3;
const clamp = glm.clamp;
const translation = glm.translation;
const rotation = glm.rotation;
const scale = glm.scale;
const perspective = glm.perspective;
const lookAt = glm.lookAt;
// settings
const SCR_WIDTH: u32 = 1920;
const SCR_HEIGHT: u32 = 1080;
// camera
var camera = Camera.default();
var lastX: f32 = 1920.0 / 2.0;
var lastY: f32 = 1080.0 / 2.0;
var firstMouse = true;
// timing
var deltaTime: f32 = 0.0;
var lastFrame: f32 = 0.0;
pub fn main() !void {
camera.movementSpeed = 10.0;
const allocator = std.heap.page_allocator;
// Shader paths
const backgroundFragPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_background.frag" });
const backgroundVertPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_background.vert" });
const brdfFragPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_brdf.frag" });
const brdfVertPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_brdf.vert" });
const cubemapVertPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_cubemap.vert" });
const equirectFragPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_equirectangular_to_cubemap.frag" });
const irradianceFragPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_irradiance_convolution.frag" });
const pbrFragPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_pbr.frag" });
const pbrVertPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_pbr.vert" });
const prefilterFragPath = try join(allocator, &[_][]const u8{ "shaders", "6_2_2_prefilter.frag" });
const ok = glfwInit();
if (ok == 0) {
panic("Failed to initialise GLFW\n", .{});
}
defer glfwTerminate();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
// glfw: initialize and configure
var window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "Learn OpenGL", null, null);
if (window == null) {
panic("Failed to create GLFW window\n", .{});
}
glfwMakeContextCurrent(window);
const resizeCallback = glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
const posCallback = glfwSetCursorPosCallback(window, mouse_callback);
const scrollCallback = glfwSetScrollCallback(window, scroll_callback);
// tell GLFW to capture our mouse
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// glad: load all OpenGL function pointers
if (gladLoadGLLoader(@ptrCast(GLADloadproc, glfwGetProcAddress)) == 0) {
panic("Failed to initialise GLAD\n", .{});
}
glEnable(GL_DEPTH_TEST);
// set depth function to less than AND equal for skybox depth trick.
glDepthFunc(GL_LEQUAL);
// enable seamless cubemap sampling for lower mip levels in the pre-filter map.
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
const cube = Cube.init();
const sphere = Sphere.init();
const quad = Quad.init();
// build and compile shaders
const pbrShader = try Shader.init(allocator, pbrVertPath, pbrFragPath);
const equirectangularToCubemapShader = try Shader.init(allocator, cubemapVertPath, equirectFragPath);
const irradianceShader = try Shader.init(allocator, cubemapVertPath, irradianceFragPath);
const prefilterShader = try Shader.init(allocator, cubemapVertPath, prefilterFragPath);
const brdfShader = try Shader.init(allocator, brdfVertPath, brdfFragPath);
const backgroundShader = try Shader.init(allocator, backgroundVertPath, backgroundFragPath);
pbrShader.use();
pbrShader.setInt("irradianceMap", 0);
pbrShader.setInt("prefilterMap", 1);
pbrShader.setInt("brdfLUT", 2);
pbrShader.setVec3("albedo", vec3(0.5, 0.0, 0.0));
pbrShader.setFloat("ao", 1.0);
backgroundShader.use();
backgroundShader.setInt("environmentMap", 0);
// lights
const lightPositions = [_]Vec3{
vec3(-10.0, 10.0, 10.0),
vec3(10.0, 10.0, 10.0),
vec3(-10.0, -10.0, 10.0),
vec3(10.0, -10.0, 10.0),
};
const lightColors = [_]Vec3{
vec3(300.0, 300.0, 300.0),
vec3(300.0, 300.0, 300.0),
vec3(300.0, 300.0, 300.0),
vec3(300.0, 300.0, 300.0),
};
const nrRows = 7;
const nrColumns = 7;
const spacing: f32 = 2.5;
// pbr: setup framebuffer
var captureFBO: c_uint = undefined;
var captureRBO: c_uint = undefined;
glGenFramebuffers(1, &captureFBO);
glGenRenderbuffers(1, &captureRBO);
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
glBindRenderbuffer(GL_RENDERBUFFER, captureRBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 512, 512);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, captureRBO);
// pbr: load the HDR environment map
var width: c_int = undefined;
var height: c_int = undefined;
var nrComponents: c_int = undefined;
stbi_set_flip_vertically_on_load(1);
const data = stbi_loadf("textures/newport_loft.hdr", &width, &height, &nrComponents, 0);
if (data == null) {
panic("Failed to load HDR Image\n", .{});
}
var hdrTexture: c_uint = undefined;
glGenTextures(1, &hdrTexture);
glBindTexture(GL_TEXTURE_2D, hdrTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, width, height, 0, GL_RGB, GL_FLOAT, data); // note how we specify the texture's data value to be float
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// pbr: setup cubemap to render to and attach to framebuffer
var envCubemap: c_uint = undefined;
glGenTextures(1, &envCubemap);
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
var i: c_uint = 0;
while (i < 6) : (i += 1) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 512, 512, 0, GL_RGB, GL_FLOAT, null);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // enable pre-filter mipmap sampling (combatting visible dots artifact)
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// pbr: set up projection and view matrices for capturing data onto the 6 cubemap face directions
const captureProjection = perspective(pi / 2.0, 1.0, 0.1, 10.0);
const captureViews = [_]Mat4{
lookAt(vec3(0.0, 0.0, 0.0), vec3(1.0, 0.0, 0.0), vec3(0.0, -1.0, 0.0)),
lookAt(vec3(0.0, 0.0, 0.0), vec3(-1.0, 0.0, 0.0), vec3(0.0, -1.0, 0.0)),
lookAt(vec3(0.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0), vec3(0.0, 0.0, 1.0)),
lookAt(vec3(0.0, 0.0, 0.0), vec3(0.0, -1.0, 0.0), vec3(0.0, 0.0, -1.0)),
lookAt(vec3(0.0, 0.0, 0.0), vec3(0.0, 0.0, 1.0), vec3(0.0, -1.0, 0.0)),
lookAt(vec3(0.0, 0.0, 0.0), vec3(0.0, 0.0, -1.0), vec3(0.0, -1.0, 0.0)),
};
// pbr: convert HDR equirectangular environment map to cubemap equivalent
equirectangularToCubemapShader.use();
equirectangularToCubemapShader.setInt("equirectangularMap", 0);
equirectangularToCubemapShader.setMat4("projection", captureProjection);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, hdrTexture);
glViewport(0, 0, 512, 512); // don't forget to configure the viewport to the capture dimensions.
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
i = 0;
while (i < 6) : (i += 1) {
equirectangularToCubemapShader.setMat4("view", captureViews[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, envCubemap, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
cube.render();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// then let OpenGL generate mipmaps from first mip face (combatting visible dots artifact)
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
// pbr: create an irradiance cubemap, and re-scale capture FBO to irradiance scale.
var irradianceMap: c_uint = undefined;
glGenTextures(1, &irradianceMap);
glBindTexture(GL_TEXTURE_CUBE_MAP, irradianceMap);
i = 0;
while (i < 6) : (i += 1) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 32, 32, 0, GL_RGB, GL_FLOAT, null);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
glBindRenderbuffer(GL_RENDERBUFFER, captureRBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 32, 32);
// pbr: solve diffuse integral by convolution to create an irradiance (cube)map.
irradianceShader.use();
irradianceShader.setInt("environmentMap", 0);
irradianceShader.setMat4("projection", captureProjection);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
glViewport(0, 0, 32, 32); // don't forget to configure the viewport to the capture dimensions.
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
i = 0;
while (i < 6) : (i += 1) {
irradianceShader.setMat4("view", captureViews[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, irradianceMap, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
cube.render();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// pbr: create a pre-filter cubemap, and re-scale capture FBO to pre-filter scale.
var prefilterMap: c_uint = undefined;
glGenTextures(1, &prefilterMap);
glBindTexture(GL_TEXTURE_CUBE_MAP, prefilterMap);
i = 0;
while (i < 6) : (i += 1) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, 128, 128, 0, GL_RGB, GL_FLOAT, null);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // be sure to set minifcation filter to mip_linear
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// generate mipmaps for the cubemap so OpenGL automatically allocates the required memory.
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
// pbr: run a quasi monte-carlo simulation on the environment lighting to create a prefilter (cube)map.
prefilterShader.use();
prefilterShader.setInt("environmentMap", 0);
prefilterShader.setMat4("projection", captureProjection);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
var mip: c_uint = 0;
while (mip < 5) : (mip += 1) {
// reisze framebuffer according to mip-level size.
const okayThen: c_uint = 128;
const mipWidth: c_uint = okayThen >> @intCast(u5, mip);
const mipHeight: c_uint = okayThen >> @intCast(u5, mip);
glBindRenderbuffer(GL_RENDERBUFFER, captureRBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, @intCast(c_int, mipWidth), @intCast(c_int, mipHeight));
glViewport(0, 0, @intCast(c_int, mipWidth), @intCast(c_int, mipHeight));
const roughness = @intToFloat(f32, mip) / @intToFloat(f32, 5 - 1);
prefilterShader.setFloat("roughness", roughness);
i = 0;
while (i < 6) : (i += 1) {
prefilterShader.setMat4("view", captureViews[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, prefilterMap, @intCast(c_int, mip));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
cube.render();
}
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// pbr: generate a 2D LUT from the BRDF equations used.
var brdfLUTTexture: c_uint = undefined;
glGenTextures(1, &brdfLUTTexture);
// pre-allocate enough memory for the LUT texture.
glBindTexture(GL_TEXTURE_2D, brdfLUTTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RG16F, 512, 512, 0, GL_RG, GL_FLOAT, null);
// be sure to set wrapping mode to GL_CLAMP_TO_EDGE
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// then re-configure capture framebuffer object and render screen-space quad with BRDF shader.
glBindFramebuffer(GL_FRAMEBUFFER, captureFBO);
glBindRenderbuffer(GL_RENDERBUFFER, captureRBO);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 512, 512);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, brdfLUTTexture, 0);
glViewport(0, 0, 512, 512);
brdfShader.use();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
quad.render();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// then before rendering, configure the viewport to the original framebuffer's screen dimensions
var scrWidth: c_int = undefined;
var scrHeight: c_int = undefined;
glfwGetFramebufferSize(window, &scrWidth, &scrHeight);
glViewport(0, 0, scrWidth, scrHeight);
// render loop
while (glfwWindowShouldClose(window) == 0) {
// initialize static shader uniforms before rendering
const projection = perspective(camera.zoom / 180.0 * pi, @intToFloat(f32, SCR_WIDTH) / @intToFloat(f32, SCR_HEIGHT), 0.1, 100.0);
pbrShader.use();
pbrShader.setMat4("projection", projection);
backgroundShader.use();
backgroundShader.setMat4("projection", projection);
// per-frame time logic
const currentFrame = @floatCast(f32, glfwGetTime());
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// input
processInput(window);
// render
glClearColor(0.2, 0.3, 0.3, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// render scene, supplying the convoluted irradiance map to the final shader.
pbrShader.use();
const view = camera.getViewMatrix();
pbrShader.setMat4("view", view);
pbrShader.setVec3("camPos", camera.position);
// bind pre-computed IBL data
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, irradianceMap);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, prefilterMap);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, brdfLUTTexture);
// render rows*column number of spheres with material properties defined by textures (they all have the same material properties)
var row: i32 = 0;
while (row < nrRows) : (row += 1) {
pbrShader.setFloat("metallic", @intToFloat(f32, row) / @intToFloat(f32, nrRows));
var col: i32 = 0;
while (col < nrColumns) : (col += 1) {
// we clamp the roughness to 0.025 - 1.0 as perfectly smooth surfaces (roughness of 0.0) tend to look a bit off
// on direct lighting.
pbrShader.setFloat("roughness", clamp(@intToFloat(f32, col) / @intToFloat(f32, nrColumns), 0.05, 1.0));
const model = translation(vec3(
@intToFloat(f32, col - (nrColumns / 2)) * spacing,
@intToFloat(f32, row - (nrRows / 2)) * spacing,
-2.0,
));
pbrShader.setMat4("model", model);
sphere.render();
}
}
// render light source (simply re-render sphere at light positions)
// this looks a bit off as we use the same shader, but it'll make their positions obvious and
// keeps the codeprint small.
// I am done
const posNames = [_][:0]const u8{
"lightPositions[0]",
"lightPositions[1]",
"lightPositions[2]",
"lightPositions[3]",
};
const colNames = [_][:0]const u8{
"lightColors[0]",
"lightColors[1]",
"lightColors[2]",
"lightColors[3]",
};
i = 0;
while (i < lightPositions.len) : (i += 1) {
const newPos = lightPositions[i].add(vec3(sin(@floatCast(f32, glfwGetTime()) * 5.0 - @intToFloat(f32, i)) * 5.0, 0.0, 0.0));
// const newPos = lightPositions[i];
pbrShader.setVec3(posNames[i], newPos);
pbrShader.setVec3(colNames[i], lightColors[i]);
const model = translation(newPos).matmul(scale(vec3(0.5, 0.5, 0.5)));
pbrShader.setMat4("model", model);
sphere.render();
}
// render skybox (render as last to prevent overdraw)
backgroundShader.use();
backgroundShader.setMat4("view", view);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, envCubemap);
// glBindTexture(GL_TEXTURE_CUBE_MAP, irradianceMap); // display irradiance map
// glBindTexture(GL_TEXTURE_CUBE_MAP, prefilterMap); // display prefilter map
cube.render();
// render BRDF map to screen
// brdfShader.use();
// quad.render();
// glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
glfwSwapBuffers(window);
glfwPollEvents();
}
}
// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
pub fn processInput(window: ?*GLFWwindow) callconv(.C) void {
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
glfwSetWindowShouldClose(window, 1);
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
camera.processKeyboard(.Forward, deltaTime);
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
camera.processKeyboard(.Backward, deltaTime);
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
camera.processKeyboard(.Left, deltaTime);
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
camera.processKeyboard(.Right, deltaTime);
}
// glfw: whenever the window size changed (by OS or user resize) this callback function executes
pub fn framebuffer_size_callback(window: ?*GLFWwindow, width: c_int, height: c_int) callconv(.C) void {
// make sure the viewport matches the new window dimensions; note that width and
// height will be significantly larger than specified on retina displays.
glViewport(0, 0, width, height);
}
// glfw: whenever the mouse moves, this callback is called
pub fn mouse_callback(window: ?*GLFWwindow, xpos: f64, ypos: f64) callconv(.C) void {
if (firstMouse) {
lastX = @floatCast(f32, xpos);
lastY = @floatCast(f32, ypos);
firstMouse = false;
}
const xoffset = @floatCast(f32, xpos) - lastX;
const yoffset = lastY - @floatCast(f32, ypos); // reversed since y-coordinates go from bottom to top
lastX = @floatCast(f32, xpos);
lastY = @floatCast(f32, ypos);
camera.processMouseMovement(xoffset, yoffset);
}
// glfw: whenever the mouse scroll wheel scrolls, this callback is called
pub fn scroll_callback(window: ?*GLFWwindow, xoffset: f64, yoffset: f64) callconv(.C) void {
camera.processMouseScroll(@floatCast(f32, yoffset));
}
// 64x64 segment UV Sphere
const Sphere = struct {
vao: c_uint,
vbo: c_uint,
ebo: c_uint,
len: c_uint,
/// Initialise the sphere on the GPU
pub fn init() Sphere {
var vao: c_uint = undefined;
var vbo: c_uint = undefined;
var ebo: c_uint = undefined;
glGenVertexArrays(1, &vao);
glGenBuffers(1, &vbo);
glGenBuffers(1, &ebo);
const X_SEGMENTS = 256;
const Y_SEGMENTS = 256;
const numVertices = 8 * (X_SEGMENTS + 1) * (Y_SEGMENTS + 1);
const numElements = 2 * (X_SEGMENTS + 1) * Y_SEGMENTS;
// Stack allocated vertex, element buffers
var vertices: [numVertices]f32 = undefined;
var elements: [numElements]u32 = undefined;
var i: u32 = 0;
var y: u32 = 0;
while (y <= Y_SEGMENTS) : (y += 1) {
var x: u32 = 0;
while (x <= X_SEGMENTS) : (x += 1) {
const xSegment = @intToFloat(f32, x) / @intToFloat(f32, X_SEGMENTS);
const ySegment = @intToFloat(f32, y) / @intToFloat(f32, Y_SEGMENTS);
const xPos = cos(xSegment * 2.0 * pi) * sin(ySegment * pi);
const yPos = cos(ySegment * pi);
const zPos = sin(xSegment * 2.0 * pi) * sin(ySegment * pi);
vertices[i + 0] = xPos;
vertices[i + 1] = yPos;
vertices[i + 2] = zPos;
vertices[i + 3] = xSegment;
vertices[i + 4] = ySegment;
vertices[i + 5] = xPos;
vertices[i + 6] = yPos;
vertices[i + 7] = zPos;
i += 8;
}
}
i = 0;
y = 0;
while (y < Y_SEGMENTS) : (y += 1) {
if (y % 2 == 0) {
var x: u32 = 0;
while (x <= X_SEGMENTS) : (x += 1) {
elements[i + 0] = y * (X_SEGMENTS + 1) + x;
elements[i + 1] = (y + 1) * (X_SEGMENTS + 1) + x;
i += 2;
}
} else {
var x: u32 = X_SEGMENTS + 1;
while (x > 0) : (x -= 1) {
elements[i + 0] = (y + 1) * (X_SEGMENTS + 1) + x - 1;
elements[i + 1] = y * (X_SEGMENTS + 1) + x - 1;
i += 2;
}
}
}
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, numVertices * @sizeOf(f32), &vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, numElements * @sizeOf(u32), &elements, GL_STATIC_DRAW);
const stride = (3 + 2 + 3) * @sizeOf(f32);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, null);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, stride, @intToPtr(*c_void, 3 * @sizeOf(f32)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, stride, @intToPtr(*c_void, 5 * @sizeOf(f32)));
glEnableVertexAttribArray(2);
return Sphere{ .vao = vao, .vbo = vbo, .ebo = ebo, .len = numElements };
}
/// Render the sphere
pub fn render(self: Sphere) void {
glBindVertexArray(self.vao);
glDrawElements(GL_TRIANGLE_STRIP, @intCast(c_int, self.len), GL_UNSIGNED_INT, null);
// glBindVertexArray(0);
}
};
/// A Cube in three dimensions
const Cube = struct {
vao: c_uint,
vbo: c_uint,
/// Initialise the cube on the GPU
pub fn init() Cube {
var vao: c_uint = undefined;
var vbo: c_uint = undefined;
const vertices = [_]f32{
// back face
-1.0, -1.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0, // bottom-left
1.0, 1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 1.0, // top-right
1.0, -1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.0, // bottom-right
1.0, 1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 1.0, // top-right
-1.0, -1.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0, // bottom-left
-1.0, 1.0, -1.0, 0.0, 0.0, -1.0, 0.0, 1.0, // top-left
// front face
-1.0, -1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, // bottom-left
1.0, -1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, // bottom-right
1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, // top-right
1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, // top-right
-1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, // top-left
-1.0, -1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, // bottom-left
// left face
-1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 1.0, 0.0, // top-right
-1.0, 1.0, -1.0, -1.0, 0.0, 0.0, 1.0, 1.0, // top-left
-1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 1.0, // bottom-left
-1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 1.0, // bottom-left
-1.0, -1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 0.0, // bottom-right
-1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 1.0, 0.0, // top-right
// right face
1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, // top-left
1.0, -1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 1.0, // bottom-right
1.0, 1.0, -1.0, 1.0, 0.0, 0.0, 1.0, 1.0, // top-right
1.0, -1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 1.0, // bottom-right
1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, // top-left
1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, // bottom-left
// bottom face
-1.0, -1.0, -1.0, 0.0, -1.0, 0.0, 0.0, 1.0, // top-right
1.0, -1.0, -1.0, 0.0, -1.0, 0.0, 1.0, 1.0, // top-left
1.0, -1.0, 1.0, 0.0, -1.0, 0.0, 1.0, 0.0, // bottom-left
1.0, -1.0, 1.0, 0.0, -1.0, 0.0, 1.0, 0.0, // bottom-left
-1.0, -1.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, // bottom-right
-1.0, -1.0, -1.0, 0.0, -1.0, 0.0, 0.0, 1.0, // top-right
// top face
-1.0, 1.0, -1.0, 0.0, 1.0, 0.0, 0.0, 1.0, // top-left
1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, // bottom-right
1.0, 1.0, -1.0, 0.0, 1.0, 0.0, 1.0, 1.0, // top-right
1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, // bottom-right
-1.0, 1.0, -1.0, 0.0, 1.0, 0.0, 0.0, 1.0, // top-left
-1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, // bottom-left
};
glGenVertexArrays(1, &vao);
glGenBuffers(1, &vbo);
// fill buffer
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, vertices.len * @sizeOf(f32), &vertices, GL_STATIC_DRAW);
// link vertex attributes
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * @sizeOf(f32), null);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * @sizeOf(f32), @intToPtr(*c_void, 3 * @sizeOf(f32)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * @sizeOf(f32), @intToPtr(*c_void, 6 * @sizeOf(f32)));
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
return Cube{ .vao = vao, .vbo = vbo };
}
/// Render the cube
pub fn render(self: Cube) void {
glBindVertexArray(self.vao);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
}
};
/// A 1x1 XY quad
const Quad = struct {
vao: c_uint,
vbo: c_uint,
/// Initialise the quad on the GPU
pub fn init() Quad {
var vao: c_uint = undefined;
var vbo: c_uint = undefined;
const quadVertices = [_]f32{
// positions // texture Coords
-1.0, 1.0, 0.0, 0.0, 1.0,
-1.0, -1.0, 0.0, 0.0, 0.0,
1.0, 1.0, 0.0, 1.0, 1.0,
1.0, -1.0, 0.0, 1.0, 0.0,
};
glGenVertexArrays(1, &vao);
glGenBuffers(1, &vbo);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, quadVertices.len * @sizeOf(f32), &quadVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * @sizeOf(f32), null);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * @sizeOf(f32), @intToPtr(*c_void, 3 * @sizeOf(f32)));
return Quad{ .vao = vao, .vbo = vbo };
}
/// Render the quad
pub fn render(self: Quad) void {
glBindVertexArray(self.vao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
}
}; | src/6_2_2_ibl_specular.zig |
const builtin = @import("builtin");
const std = @import("std");
const alsa = @import("zig-alsa");
pub const AlsaPlaybackInterface = @This();
stream: *alsa.snd_pcm_t,
num_channels: u32,
sample_rate: u32,
bits_per_sample: u32,
buffer_frames: alsa.snd_pcm_uframes_t,
write_cursor: usize = 0,
read_cursor: usize = 0,
pub fn init(requested_sample_rate: u32, buffer_frames_requested: usize) !AlsaPlaybackInterface {
var stream: *alsa.snd_pcm_t = undefined;
_ = try alsa.checkError(alsa.snd_pcm_open(
@ptrCast(*?*alsa.snd_pcm_t, &stream),
"default",
alsa.snd_pcm_stream_t.PLAYBACK,
alsa.SND_PCM_ASYNC,
));
// hardware configuration...
var hw_params: *alsa.snd_pcm_hw_params_t = undefined;
_ = try alsa.checkError(
alsa.snd_pcm_hw_params_malloc(
@ptrCast(*?*alsa.snd_pcm_hw_params_t, &hw_params),
),
);
defer alsa.snd_pcm_hw_params_free(hw_params);
_ = try alsa.checkError(alsa.snd_pcm_hw_params_any(stream, hw_params));
_ = try alsa.checkError(alsa.snd_pcm_hw_params_set_rate_resample(
stream,
hw_params,
1,
));
_ = try alsa.checkError(alsa.snd_pcm_hw_params_set_access(
stream,
hw_params,
alsa.snd_pcm_access_t.RW_INTERLEAVED,
));
_ = try alsa.checkError(alsa.snd_pcm_hw_params_set_format(
stream,
hw_params,
switch (builtin.target.cpu.arch.endian()) {
.Little => alsa.snd_pcm_format_t.FLOAT_LE,
.Big => alsa.snd_pcm_format_t.FLOAT_BE,
},
));
const num_channels = 2;
_ = try alsa.checkError(alsa.snd_pcm_hw_params_set_channels(
stream,
hw_params,
num_channels,
));
var sample_rate: c_uint = requested_sample_rate;
_ = try alsa.checkError(alsa.snd_pcm_hw_params_set_rate_near(
stream,
hw_params,
&sample_rate,
null,
));
var buf_frames: c_ulong = buffer_frames_requested;
_ = try alsa.checkError(alsa.snd_pcm_hw_params_set_buffer_size_near(
stream,
hw_params,
&buf_frames,
));
_ = try alsa.checkError(alsa.snd_pcm_hw_params(stream, hw_params));
std.log.debug("alsa buffer size: {} frames", .{buf_frames});
// software configuration...
// var sw_params: ?*alsa.snd_pcm_sw_params_t = null;
// _ = try alsa.checkError(alsa.snd_pcm_sw_params_malloc(&sw_params));
// defer alsa.snd_pcm_sw_params_free(sw_params);
// _ = try alsa.checkError(alsa.snd_pcm_sw_params_set_start_threshold(
// stream,
// sw_params,
// sample_rate / num_channels / target_framerate,
// ));
return AlsaPlaybackInterface{
.stream = stream,
.num_channels = num_channels,
.sample_rate = sample_rate,
.bits_per_sample = num_channels * @sizeOf(f32),
.buffer_frames = buf_frames,
};
}
pub fn deinit(self: *AlsaPlaybackInterface) void {
_ = alsa.snd_pcm_close(self.stream);
}
pub fn start(self: *AlsaPlaybackInterface) !void {
_ = try alsa.checkError(alsa.snd_pcm_start(self.stream));
}
pub fn stop(self: *AlsaPlaybackInterface) !void {
_ = try alsa.checkError(alsa.snd_pcm_drain(self.stream));
}
pub fn prepare(self: *AlsaPlaybackInterface) !void {
_ = try alsa.checkError(alsa.snd_pcm_prepare(self.stream));
}
pub fn waitBufferReady(self: AlsaPlaybackInterface) !void {
const res = try alsa.checkError(alsa.snd_pcm_wait(self.stream, -1));
switch (res) {
0 => return error.TimedOut,
1 => {},
else => {
std.log.warn("unexpected snd_pcm_wait return value {}", .{res});
},
}
}
pub fn getBufferFramesAvailable(self: *AlsaPlaybackInterface) !usize {
const avail = try alsa.checkError(alsa.snd_pcm_avail_update(self.stream));
return @intCast(usize, avail);
}
pub fn getBufferFramesRewindable(self: *AlsaPlaybackInterface) !usize {
return try alsa.checkError(alsa.snd_pcm_rewindable(self.stream));
}
pub fn rewindBuffer(self: *AlsaPlaybackInterface, frames: usize) !usize {
const dist = try alsa.checkError(alsa.snd_pcm_rewind(
self.stream,
@intCast(alsa.snd_pcm_sframes_t, frames),
));
self.write_cursor -= dist;
return dist;
}
pub fn writeSamples(self: *AlsaPlaybackInterface, samples: []f32) bool {
const res = alsa.snd_pcm_writei(self.stream, samples.ptr, samples.len / self.num_channels);
return (res >= 0);
}
pub fn getLatency(self: *AlsaPlaybackInterface) !usize {
var io_latency: alsa.snd_pcm_sframes_t = undefined;
_ = try alsa.checkError(alsa.snd_pcm_delay(self.stream, &io_latency));
return self.write_cursor - self.read_cursor + @intCast(usize, io_latency);
} | modules/platform/src/linux/AlsaPlaybackInterface.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/day04.txt");
const int = u8;
const BingoCard = struct {
const Self = @This();
vals: [5][5]int,
checked: [5][5]bool,
score: ?u64 = null,
pub fn init(lines: [5]Str) !Self {
var card: Self = .{
.vals = [1][5]int{[1]int{0} ** 5} ** 5,
.checked = [1][5]bool{[1]bool{false} ** 5} ** 5,
};
for (lines) |line, i| {
var nums = util.strtok(line, " ");
var j: usize = 0;
while (j < 5) : (j += 1) {
var n: int = try parseInt(int, nums.next().?, 10);
card.vals[i][j] = n;
//print("added {d}\n", .{n});
}
}
return card;
}
pub fn mark(self: *Self, n: int) void {
// find occurances of n on the board and check the off
var i: u3 = 0;
while (i < self.vals.len) : (i += 1) {
var j: u3 = 0;
while (j < self.vals.len) : (j += 1) {
if (self.vals[i][j] == n)
self.checked[i][j] = true;
}
}
// check for bingo
if (self.bingo()) {
self.score = self.calc_score(n);
//print("bingo! placing {d} score {d}\n", .{ n, self.score });
}
}
pub fn bingo(self: Self) bool {
if (self.score != null) {
// already scored
return true;
}
var i: u3 = 0;
var all: bool = true;
// horizontal
while (i < self.vals.len) : (i += 1) {
var j: u3 = 0;
all = true;
while (j < self.vals.len) : (j += 1) {
if (!self.checked[i][j]) {
all = false;
break;
}
}
if (all) return true;
}
// vertical
i = 0;
while (i < self.vals.len) : (i += 1) {
all = true;
var j: u3 = 0;
while (j < self.vals.len) : (j += 1) {
if (!self.checked[j][i]) {
all = false;
break;
}
}
if (all) return true;
}
// // down & right
// i = 0;
// all = true;
// while (i < self.vals.len) : (i += 1) {
// if (!self.checked[i][i]) {
// all = false;
// break;
// }
// }
// if (all) return true;
// // up & right
// i = 0;
// all = true;
// while (i < self.vals.len) : (i += 1) {
// if (!self.checked[i][self.vals.len - 1 - i]) {
// all = false;
// break;
// }
// }
return all;
}
fn calc_score(self: Self, final_num: int) u64 {
var s: u64 = 0;
// sum of all unmarked numbers
var i: u3 = 0;
var unchecked: usize = 0;
while (i < 5) : (i += 1) {
var j: u3 = 0;
while (j < 5) : (j += 1) {
if (!self.checked[i][j]) {
s += self.vals[i][j];
unchecked += 1;
}
}
}
// print("scoring {d} unchecked total of {d} score {d}\n", .{ unchecked, s, s * final_num });
return s * final_num;
}
fn show(self: Self) void {
var i: u3 = 0;
while (i < 5) : (i += 1) {
var j: u3 = 0;
while (j < 5) : (j += 1) {
var sigil: u8 = if (self.checked[i][j]) '<' else ' ';
print("{d:2}{c}", .{ self.vals[i][j], sigil });
}
print("\n", .{});
}
print("\n", .{});
}
};
const BingoCardList = List(BingoCard);
fn load_cards() !BingoCardList {
var cards = BingoCardList.init(gpa);
var blocks = split(u8, data, "\n\n");
// skip first block, which is numbers
_ = blocks.next().?;
// load cards
while (blocks.next()) |block| {
var lines = split(u8, block, "\n");
var new_card = try BingoCard.init(.{
lines.next().?,
lines.next().?,
lines.next().?,
lines.next().?,
lines.next().?,
});
try cards.append(new_card);
//print("Loaded: \n", .{});
//new_card.show();
}
return cards;
}
fn load_nums() Str {
var lines = split(u8, data, "\n");
return lines.next().?;
}
pub fn main() !void {
var cards = try load_cards();
// print("Loaded {d} cards.\n", .{cards.items.len});
defer cards.deinit();
//for (cards.items) |card| {
// card.show();
//}
// okay, now iter over numbers
var num_iter = split(u8, load_nums(), ",");
var bingos: usize = 0;
while (num_iter.next()) |num_text| {
var n = try parseInt(int, num_text, 10);
print("Placing {d}\n", .{n});
var marked = false;
while (!marked) {
for (cards.items) |*next_card, card_i| {
var card = next_card;
card.mark(n);
if (card.score) |score| {
bingos += 1;
print("Found bingo #{d} with score {d}\n", .{ bingos, score });
card.show();
_ = cards.swapRemove(card_i);
print("{d} cards still playing.\n", .{cards.items.len});
break;
}
} else {
marked = true;
}
}
}
}
// 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/day04.zig |
const std = @import("std");
const json = std.json;
const debug = std.debug;
const log = std.log;
const assert = debug.assert;
const mem = std.mem;
const os = std.os;
const io = std.io;
const version = @import("version.zig");
// used for sleep, and other, it may be removed
// to relax libC needs
const c = @cImport({
@cInclude("stdio.h");
@cInclude("unistd.h");
@cInclude("signal.h");
@cInclude("time.h");
@cInclude("string.h");
});
const leveldb = @import("leveldb.zig");
const mqtt = @import("mqttlib.zig");
const processlib = @import("processlib.zig");
const topics = @import("topics.zig");
const toml = @import("toml");
const clap = @import("clap");
// profiling, to check performance on functions
// this is mocked in the build.zig (activate this tracy library)
const tracy = @import("tracy");
const stdoutFile = std.io.getStdOut();
const out = std.fs.File.writer(stdoutFile);
const Verbose = false;
// This structure defines the process informations
// with live agent running, this permit to track the process and
// relaunch it if needed
//
const AdditionalProcessInformation = struct {
// pid is to track the process while running
pid: ?i32 = undefined,
// process identifier attributed by IOTMonitor, to track existing processes
// processIdentifier: []const u8 = "",
exec: []const u8 = "",
// last time the process is restarted
lastRestarted: c.time_t = null,
// number of time, the process is restarted
restartedCount: u64 = 0,
};
const MonitoringInfo = struct {
// name of the device
name: []const u8 = "",
watchTopics: []const u8,
nextContact: c.time_t,
timeoutValue: u32 = 30,
stateTopics: ?[]const u8 = null,
helloTopic: ?[]const u8 = null,
helloTopicCount: u64 = 0,
allocator: mem.Allocator,
// in case of process informations,
// used to relaunch or not the process, permitting to
// take a process out of the monitoring, and then reintegrate it
enabled: bool = true,
associatedProcessInformation: ?*AdditionalProcessInformation = null,
fn init(allocator: mem.Allocator) !*MonitoringInfo {
const device = try allocator.create(MonitoringInfo);
device.allocator = allocator;
device.stateTopics = null;
device.helloTopic = null;
device.helloTopicCount = 0;
device.timeoutValue = 30;
device.associatedProcessInformation = null;
device.enabled = true;
return device;
}
fn deinit(self: *MonitoringInfo) void {
self.allocator.destroy(self);
}
fn updateNextContact(device: *MonitoringInfo) !void {
_ = c.time(&device.*.nextContact);
device.*.nextContact = device.*.nextContact + @intCast(c_long, device.*.timeoutValue);
}
fn hasExpired(device: *MonitoringInfo) !bool {
var currentTime: c.time_t = undefined;
_ = c.time(¤tTime);
const diff = c.difftime(currentTime, device.*.nextContact);
if (diff > 0) return true;
return false;
}
};
fn stripLastWildCard(watchValue: []const u8) ![]const u8 {
assert(watchValue.len > 0);
if (watchValue[watchValue.len - 1] == '#') {
return watchValue[0 .. watchValue.len - 2];
}
return watchValue;
}
test "test update time" {
var d = MonitoringInfo{
.timeoutValue = 1,
.watchTopics = "",
.nextContact = undefined,
.allocator = undefined,
.helloTopic = undefined,
.stateTopics = undefined,
.associatedProcessInformation = undefined,
};
try d.updateNextContact();
_ = c.sleep(3);
debug.assert(try d.hasExpired());
d.timeoutValue = 20;
try d.updateNextContact();
_ = c.sleep(3);
debug.assert(!try d.hasExpired());
}
pub fn secureZero(comptime T: type, s: []T) void {
// NOTE: We do not use a volatile slice cast here since LLVM cannot
// see that it can be replaced by a memset.
const ptr = @ptrCast([*]volatile u8, s.ptr);
const length = s.len * @sizeOf(T);
// add 0 at the end of the alloc array
@memset(ptr, 0, length);
}
// parse the device info,
// device must have a watch topics
fn parseDevice(allocator: mem.Allocator, name: []const u8, entry: *toml.Table) !*MonitoringInfo {
const device = try MonitoringInfo.init(allocator);
errdefer device.deinit();
const allocName = try allocator.alloc(u8, name.len + 1);
secureZero(u8, allocName);
std.mem.copy(u8, allocName, name);
device.name = allocName;
if (entry.keys.get("exec")) |exec| {
const execValue = exec.String;
assert(execValue.len > 0);
const execCommand = try allocator.allocSentinel(u8, execValue.len, 0);
mem.copy(u8, execCommand, execValue);
const additionalStructure = try allocator.create(AdditionalProcessInformation);
additionalStructure.exec = execCommand;
additionalStructure.pid = null;
additionalStructure.lastRestarted = 0;
additionalStructure.restartedCount = 0;
device.associatedProcessInformation = additionalStructure;
}
if (entry.keys.get("watchTopics")) |watch| {
// there may have a wildcard at the end
// strip it to compare to the received topic
const watchValue = watch.String;
assert(watchValue.len > 0);
device.watchTopics = try stripLastWildCard(watchValue);
if (Verbose) {
_ = try out.print("add {} to device {} \n", .{ device.name, device.watchTopics });
}
} else {
return error.DEVICE_MUST_HAVE_A_WATCH_TOPIC;
}
if (entry.keys.get("stateTopics")) |watch| {
// there may have a wildcard at the end
// strip it to compare to the received topic
const watchValue = watch.String;
assert(watchValue.len > 0);
device.stateTopics = try stripLastWildCard(watchValue);
if (Verbose) {
_ = try out.print("add {} to device {} \n", .{ device.name, device.stateTopics });
}
}
if (entry.keys.get("helloTopic")) |hello| {
const helloValue = hello.String;
assert(helloValue.len > 0);
device.helloTopic = helloValue;
if (Verbose) {
_ = try out.print("hello topic for device {s}\n", .{device.helloTopic});
}
}
if (entry.keys.get("watchTimeOut")) |timeout| {
const timeOutValue = timeout.Integer;
device.timeoutValue = @intCast(u32, timeOutValue);
if (Verbose) {
_ = try out.print("watch timeout for topic for device {}\n", .{device.helloTopic});
}
}
try device.updateNextContact();
return device;
}
const Config = struct { clientId: []u8, mqttBroker: []u8, user: []u8, password: []u8, clientid: []u8, mqttIotmonitorBaseTopic: []u8 };
const HttpServerConfig = struct { activateHttp: bool = true, listenAddress: []const u8, port: u16 = 8079 };
var MqttConfig: *Config = undefined;
var HttpConfig: *HttpServerConfig = undefined;
fn parseTomlConfig(allocator: mem.Allocator, _alldevices: *AllDevices, filename: []const u8) !void {
const t = tracy.trace(@src());
defer t.end();
// getting config parameters
var parser: toml.Parser = undefined;
defer parser.deinit();
var config = try toml.parseFile(allocator, filename, &parser); // no custom parser
defer config.deinit();
var it = config.keys.iterator();
while (it.next()) |e| {
// get table value
switch (e.value_ptr.*) {
toml.Value.Table => |table| {
if (table.name.len >= 7) {
const DEVICEPREFIX = "device_";
const AGENTPREFIX = "agent_";
const isDevice = mem.eql(u8, table.name.ptr[0..DEVICEPREFIX.len], DEVICEPREFIX);
const isAgent = mem.eql(u8, table.name.ptr[0..AGENTPREFIX.len], AGENTPREFIX);
if (isDevice or isAgent) {
if (Verbose) {
try out.print("device found :{}\n", .{table.name.*});
}
var prefixlen = AGENTPREFIX.len;
if (isDevice) prefixlen = DEVICEPREFIX.len;
const dev = try parseDevice(allocator, table.name.ptr[prefixlen..table.name.len], table);
if (Verbose) {
try out.print("add {} to device list, with watch {} and state {} \n", .{ dev.name, dev.watchTopics, dev.stateTopics });
}
_ = try _alldevices.put(dev.name, dev);
} else {
try out.print("bad prefix for section :{s} , only device_ or agent_ accepted, skipped \n", .{e.key_ptr});
}
}
},
toml.Value.None, toml.Value.String, toml.Value.Boolean, toml.Value.Integer, toml.Value.Array, toml.Value.ManyTables => continue,
}
}
const conf = try allocator.create(Config);
if (config.keys.get("mqtt")) |mqttconfig| {
if (mqttconfig.Table.keys.get("serverAddress")) |configAdd| {
conf.mqttBroker = try allocator.alloc(u8, configAdd.String.len);
mem.copy(u8, conf.mqttBroker, configAdd.String);
} else {
return error.noKeyServerAddress;
}
if (mqttconfig.Table.keys.get("user")) |u| {
conf.user = try allocator.alloc(u8, u.String.len);
mem.copy(u8, conf.user, u.String);
} else {
return error.ConfigNoUser;
}
if (mqttconfig.Table.keys.get("password")) |p| {
conf.password = try allocator.alloc(u8, p.String.len);
mem.copy(u8, conf.password, p.String);
} else {
return error.ConfigNoPassword;
}
if (mqttconfig.Table.keys.get("clientid")) |cid| {
conf.clientid = try allocator.alloc(u8, cid.String.len);
mem.copy(u8, conf.clientid, cid.String);
try out.print("Using {s} as clientid \n", .{conf.clientid});
} else {
conf.clientid = try allocator.alloc(u8, "iotmonitor".len);
mem.copy(u8, conf.clientid, "iotmonitor");
}
const topicBase = if (mqttconfig.Table.keys.get("baseTopic")) |baseTopic| baseTopic.String else "home/monitoring";
conf.mqttIotmonitorBaseTopic = try allocator.alloc(u8, topicBase.len + 1);
conf.mqttIotmonitorBaseTopic[topicBase.len] = 0;
mem.copy(u8, conf.mqttIotmonitorBaseTopic, topicBase[0..topicBase.len]);
} else {
return error.ConfigNoMqttSection;
}
const httpconf = try allocator.create(HttpServerConfig);
if (config.keys.get("http")) |httpconfig| {
httpconf.*.activateHttp = true;
if (httpconfig.Table.keys.get("bind")) |baddr| {
httpconf.listenAddress = baddr.String;
} else {
httpconf.listenAddress = "127.0.0.1";
}
if (httpconfig.Table.keys.get("port")) |port| {
httpconf.*.port = @intCast(u16, port.Integer);
} else {
httpconf.*.port = 8079;
}
}
HttpConfig = httpconf;
MqttConfig = conf;
}
// MQTT call back to handle the error handling and not
// send the error to C paho library
fn _external_callback(topic: []u8, message: []u8) void {
callback(topic, message) catch {
@panic("error in the callback");
};
}
// MQTT Callback implementation
fn callback(topic: []u8, message: []u8) !void {
const t = tracy.trace(@src());
defer t.end();
// MQTT callback
if (Verbose) {
try out.print("on topic {}\n", .{topic});
try out.print(" message arrived {}\n", .{message});
try out.writeAll(topic);
try out.writeAll("\n");
}
// look for all devices
var iterator = alldevices.iterator();
// device loop
while (iterator.next()) |e| {
const deviceInfo = e.value_ptr.*;
if (Verbose) {
try out.print("evaluate {} with {} \n", .{ deviceInfo.stateTopics, topic });
}
const watchTopic = deviceInfo.watchTopics;
const storeTopic = deviceInfo.stateTopics;
const helloTopic = deviceInfo.helloTopic;
if (storeTopic) |store| {
if (try topics.doesTopicBelongTo(topic, store)) |_| {
// always store topic, even if the monitoring is not enabled
// store sub topic in leveldb
// trigger the refresh for timeout
if (Verbose) {
try out.print("sub topic to store value :{}, in {}\n", .{ message, topic });
try out.print("length {}\n", .{topic.len});
}
db.put(topic, message) catch |errStorage| {
log.warn("fail to store message {s} for topic {s}, on database with error {} \n", .{ message, topic, errStorage });
};
}
}
if (helloTopic) |hello| {
if (mem.eql(u8, topic, hello)) {
if (Verbose) {
try out.print("device started, put all state informations \n", .{});
}
// count the number of hello topic
//
//
deviceInfo.helloTopicCount += 1;
// iterate on db, on state topic
const itstorage = try db.iterator();
// itstorage is an allocated pointer
defer globalAllocator.destroy(itstorage);
defer itstorage.deinit();
itstorage.first();
while (itstorage.isValid()) {
var storedTopic = itstorage.iterKey();
if (storedTopic) |storedTopicValue| {
defer globalAllocator.destroy(storedTopicValue);
if (storedTopicValue.len >= topic.len) {
const slice = storedTopicValue.*;
if (mem.eql(u8, slice[0..topic.len], topic[0..])) {
if (deviceInfo.enabled) {
// send the state only if the monitoring is enabled
var stateTopic = itstorage.iterValue();
if (stateTopic) |stateTopicValue| {
if (Verbose) {
try out.print("sending state {} to topic {}\n", .{ stateTopic.?.*, slice });
}
defer globalAllocator.destroy(stateTopicValue);
const topicWithSentinel = try globalAllocator.allocSentinel(u8, storedTopicValue.*.len, 0);
defer globalAllocator.free(topicWithSentinel);
mem.copy(u8, topicWithSentinel[0..], storedTopicValue.*);
// resend state
cnx.publish(topicWithSentinel, stateTopicValue.*) catch |errorMqtt| {
log.warn("ERROR {} fail to publish initial state on topic {}", .{ errorMqtt, topicWithSentinel });
try out.print(".. state restoring done, listening mqtt topics\n", .{});
};
}
}
}
}
}
itstorage.next();
}
}
} // hello
if (try topics.doesTopicBelongTo(topic, watchTopic)) |_| {
// trigger the timeout for the iot element
try deviceInfo.updateNextContact();
}
}
if (Verbose) {
try out.print("end of callback \n", .{});
}
}
// global types
const AllDevices = std.StringHashMap(*MonitoringInfo);
const DiskHash = leveldb.LevelDBHashArray(u8, u8);
// global variables
var globalAllocator = std.heap.c_allocator;
var alldevices: AllDevices = undefined;
var db: *DiskHash = undefined;
test "read whole database" {
var arena = std.heap.ArenaAllocator.init(std.heap.c_allocator);
defer arena.deinit();
globalAllocator = &arena.allocator;
db = try DiskHash.init(globalAllocator);
const filename = "iotdb.leveldb";
_ = try db.open(filename);
defer db.close();
const iterator = try db.iterator();
defer globalAllocator.destroy(iterator);
defer iterator.deinit();
log.warn("Dump the iot database \n", .{});
iterator.first();
while (iterator.isValid()) {
const optReadKey = iterator.iterKey();
if (optReadKey) |k| {
defer globalAllocator.destroy(k);
const optReadValue = iterator.iterValue();
if (optReadValue) |v| {
log.warn(" key :{} value: {}\n", .{ k.*, v.* });
defer globalAllocator.destroy(v);
}
}
iterator.next();
}
}
// main connection for subscription
var cnx: *mqtt.MqttCnx = undefined;
var cpt: u32 = 0;
const MAGICPROCSSHEADER = "IOTMONITORMAGIC_";
const MAGIC_BUFFER_SIZE = 16 * 1024;
const LAUNCH_COMMAND_LINE_BUFFER_SIZE = 16 * 1024;
fn launchProcess(monitoringInfo: *MonitoringInfo) !void {
assert(monitoringInfo.associatedProcessInformation != null);
const associatedProcessInformation = monitoringInfo.*.associatedProcessInformation.?.*;
const pid = try os.fork();
if (pid == 0) {
// detach from parent, this permit the process to live independently from
// its parent
_ = c.setsid();
const bufferMagic = try globalAllocator.allocSentinel(u8, MAGIC_BUFFER_SIZE, 0);
defer globalAllocator.free(bufferMagic);
_ = c.sprintf(bufferMagic.ptr, "%s%s", MAGICPROCSSHEADER, monitoringInfo.name.ptr);
const commandLineBuffer = try globalAllocator.allocSentinel(u8, LAUNCH_COMMAND_LINE_BUFFER_SIZE, 0);
defer globalAllocator.free(commandLineBuffer);
const exec = associatedProcessInformation.exec;
_ = c.sprintf(commandLineBuffer.ptr, "echo %s;%s;echo END", bufferMagic.ptr, exec.ptr);
// launch here a bash to have a silent process identification
const argv = [_][]const u8{
"/bin/bash",
"-c",
commandLineBuffer[0..c.strlen(commandLineBuffer)],
};
var m = std.BufMap.init(globalAllocator);
// may add additional information about the process ...
try m.put("IOTMONITORMAGIC", bufferMagic[0..c.strlen(bufferMagic)]);
// execute the process
std.process.execve(globalAllocator, &argv, &m) catch {
unreachable;
};
// if succeeded the process is replaced
} else {
try out.print("process launched, pid : {}\n", .{pid});
monitoringInfo.*.associatedProcessInformation.?.pid = pid;
monitoringInfo.*.associatedProcessInformation.?.restartedCount += 1;
_ = c.time(&monitoringInfo.*.associatedProcessInformation.?.lastRestarted);
// launch mqtt restart information process in monitoring
try publishProcessStarted(monitoringInfo);
}
}
test "test_launch_process" {
globalAllocator = std.heap.c_allocator;
alldevices = AllDevices.init(globalAllocator);
var processInfo = AdditionalProcessInformation{
.exec = "sleep 20",
.pid = undefined,
};
var d = MonitoringInfo{
.timeoutValue = 1,
.name = "MYPROCESS",
.watchTopics = "",
.nextContact = undefined,
.allocator = undefined,
.helloTopic = undefined,
.stateTopics = undefined,
.associatedProcessInformation = &processInfo,
};
// try launchProcess(&d);
// const pid: i32 = d.associatedProcessInformation.?.*.pid.?;
// debug.warn("pid launched : {}\n", .{pid});
try alldevices.put(d.name, &d);
// var p: processlib.ProcessInformation = .{};
// const processFound = try processlib.getProcessInformations(pid, &p);
// assert(processFound);
try processlib.listProcesses(handleCheckAgent);
}
fn handleCheckAgent(processInformation: *processlib.ProcessInformation) void {
// iterate over the devices, to check which device belong to this process
// information
var it = alldevices.iterator();
while (it.next()) |deviceInfo| {
const device = deviceInfo.value_ptr.*;
// not on optional
if (device.associatedProcessInformation) |infos| {
// check if process has the magic Key in the process list
var itCmdLine = processInformation.iterator();
while (itCmdLine.next()) |a| {
if (Verbose) {
out.print("look in {}\n", .{a.ptr}) catch unreachable;
}
const bufferMagic = globalAllocator.allocSentinel(u8, MAGIC_BUFFER_SIZE, 0) catch unreachable;
defer globalAllocator.free(bufferMagic);
_ = c.sprintf(bufferMagic.ptr, "%s%s", MAGICPROCSSHEADER, device.name.ptr);
const p = c.strstr(a.ptr, bufferMagic.ptr);
if (Verbose) {
out.print("found {}\n", .{p}) catch unreachable;
}
if (p != null) {
// found in arguments, remember the pid
// of the process
infos.*.pid = processInformation.*.pid;
if (Verbose) {
out.print("process {} is monitored pid found\n", .{infos.pid}) catch unreachable;
}
break;
}
if (Verbose) {
out.writeAll("next ..\n") catch unreachable;
}
}
} else {
continue;
}
}
}
fn runAllMissings() !void {
// once all the process have been browsed,
// run all missing processes
var it = alldevices.iterator();
while (it.next()) |deviceinfo| {
const device = deviceinfo.value_ptr.*;
if (device.associatedProcessInformation) |processinfo| {
// this is a process monitored
if (device.enabled) {
if (processinfo.*.pid == null) {
out.print("running ...{s} \n", .{device.name}) catch unreachable;
// no pid associated to the info
//
launchProcess(device) catch {
@panic("fail to run process");
};
}
} else {
// monitoring not enabled on the process
}
}
}
}
fn checkProcessesAndRunMissing() !void {
const t = tracy.trace(@src());
defer t.end();
// RAZ pid infos
var it = alldevices.iterator();
while (it.next()) |deviceInfo| {
const device = deviceInfo.value_ptr.*;
if (device.associatedProcessInformation) |infos| {
infos.pid = null;
}
}
// list all process for wrapping
try processlib.listProcesses(handleCheckAgent);
try runAllMissings();
}
// this function publish a watchdog for the iotmonitor process
// this permit to check if the monitoring is up
fn publishWatchDog() !void {
const t = tracy.trace(@src());
defer t.end();
var topicBufferPayload = try globalAllocator.alloc(u8, 512);
defer globalAllocator.free(topicBufferPayload);
secureZero(u8, topicBufferPayload);
_ = c.sprintf(topicBufferPayload.ptr, "%s/up", MqttConfig.mqttIotmonitorBaseTopic.ptr);
var bufferPayload = try globalAllocator.alloc(u8, 512);
defer globalAllocator.free(bufferPayload);
secureZero(u8, bufferPayload);
cpt = (cpt + 1) % 1_000_000;
_ = c.sprintf(bufferPayload.ptr, "%d", cpt);
const payloadLength = c.strlen(bufferPayload.ptr);
cnx.publish(topicBufferPayload.ptr, bufferPayload[0..payloadLength]) catch {
log.warn("cannot publish watchdog message, will retryi \n", .{});
};
}
fn publishProcessStarted(mi: *MonitoringInfo) !void {
const t = tracy.trace(@src());
defer t.end();
var topicBufferPayload = try globalAllocator.alloc(u8, 512);
defer globalAllocator.free(topicBufferPayload);
secureZero(u8, topicBufferPayload);
_ = c.sprintf(topicBufferPayload.ptr, "%s/startedprocess/%s", MqttConfig.mqttIotmonitorBaseTopic.ptr, mi.name.ptr);
var bufferPayload = try globalAllocator.alloc(u8, 512);
defer globalAllocator.free(bufferPayload);
secureZero(u8, bufferPayload);
_ = c.sprintf(bufferPayload.ptr, "%d", mi.*.associatedProcessInformation.?.lastRestarted);
const payloadLength = c.strlen(bufferPayload.ptr);
cnx.publish(topicBufferPayload.ptr, bufferPayload[0..payloadLength]) catch {
log.warn("cannot publish watchdog message, will retryi \n", .{});
};
}
// this publish on the mqtt broker the process informations
//
fn publishDeviceMonitoringInfos(device: *MonitoringInfo) !void {
var topicBufferPayload = try globalAllocator.alloc(u8, 512);
defer globalAllocator.free(topicBufferPayload);
secureZero(u8, topicBufferPayload);
_ = c.sprintf(topicBufferPayload.ptr, "%s/helloTopicCount/%s", MqttConfig.mqttIotmonitorBaseTopic.ptr, device.*.name.ptr);
var bufferPayload = try globalAllocator.alloc(u8, 512);
defer globalAllocator.free(bufferPayload);
secureZero(u8, bufferPayload);
_ = c.sprintf(bufferPayload.ptr, "%u", device.helloTopicCount);
const payloadLen = c.strlen(bufferPayload.ptr);
cnx.publish(topicBufferPayload.ptr, bufferPayload[0..payloadLen]) catch {
log.warn("cannot publish timeout message for device {} , will retry \n", .{device.name});
};
}
// this function pulish a mqtt message for a device that is not publishing
// it mqtt messages
fn publishDeviceTimeOut(device: *MonitoringInfo) !void {
var topicBufferPayload = try globalAllocator.alloc(u8, 512);
defer globalAllocator.free(topicBufferPayload);
secureZero(u8, topicBufferPayload);
_ = c.sprintf(topicBufferPayload.ptr, "%s/expired/%s", MqttConfig.mqttIotmonitorBaseTopic.ptr, device.*.name.ptr);
var bufferPayload = try globalAllocator.alloc(u8, 512);
defer globalAllocator.free(bufferPayload);
secureZero(u8, bufferPayload);
_ = c.sprintf(bufferPayload.ptr, "%d", device.nextContact);
const payloadLen = c.strlen(bufferPayload.ptr);
cnx.publish(topicBufferPayload.ptr, bufferPayload[0..payloadLen]) catch {
log.warn("cannot publish timeout message for device {} , will retry \n", .{device.name});
};
}
const JSONStatus = struct {
name: []const u8,
enabled: bool = true,
expired: bool,
};
fn indexHandler(req: Request, res: Response) !void {
_ = req;
const t = tracy.trace(@src());
defer t.end();
var iterator = alldevices.iterator();
try res.setType("application/json");
try res.body.writeAll("[");
var hasone = false;
while (iterator.next()) |e| {
const deviceInfo = e.value_ptr.*;
if (hasone) {
try res.body.writeAll(",");
}
const j = JSONStatus{ .name = deviceInfo.name[0 .. deviceInfo.name.len - 1], .enabled = deviceInfo.enabled, .expired = try deviceInfo.hasExpired() };
// create a json response associated
try json.stringify(j, json.StringifyOptions{}, res.body);
hasone = true;
}
try res.body.writeAll("]");
// try res.write("IotMonitor version 0.2.2");
}
const Address = std.net.Address;
const routez = @import("routez");
const Request = routez.Request;
const Response = routez.Response;
const Server = routez.Server;
const Thread = std.Thread;
var server: Server = undefined;
var addr: Address = undefined;
// http server context
const ServerCtx = struct {};
pub fn startServer(context: ServerCtx) void {
_ = context;
server.listen(addr) catch {
@panic("cannot start listening http server");
};
}
// main procedure
pub fn main() !void {
const params = comptime [_]clap.Param(clap.Help){
clap.parseParam("-h, --help Display this help") catch unreachable,
clap.parseParam("-v, --version Display version") catch unreachable,
clap.parseParam("<TOML CONFIG FILE>...") catch unreachable,
};
var diag = clap.Diagnostic{};
var args = clap.parse(clap.Help, ¶ms, .{ .diagnostic = &diag }) catch |err| {
// Report useful error and exit
diag.report(io.getStdErr().writer(), err) catch {};
return err;
};
defer args.deinit();
if (args.flag("--help")) {
debug.print("\n", .{});
debug.print("start the iotmonitor deamon, usage :\n", .{});
debug.print(" iotmonitor [optional config.toml filepath]\n", .{});
debug.print("\n", .{});
return;
}
if (args.flag("--version")) {
debug.print("{s}", .{version.version});
return;
}
try out.writeAll("IotMonitor start, version ");
try out.writeAll(version.version);
try out.writeAll("\n");
// default
const defaultConfigFile = "config.toml";
var configurationFile = try globalAllocator.alloc(u8, defaultConfigFile.len);
mem.copy(u8, configurationFile, defaultConfigFile);
var arg_index: u32 = 0;
for (args.positionals()) |pos| {
debug.print("{s}\n", .{pos});
debug.print("{}\n", .{pos.len});
if (arg_index == 0) {
globalAllocator.free(configurationFile);
configurationFile = try globalAllocator.alloc(u8, pos.len);
mem.copy(u8, configurationFile, pos);
}
arg_index += 1;
}
try out.writeAll("Reading ");
try out.writeAll(configurationFile);
try out.writeAll(" file\n");
// Friendly error if the file does not exists
var openedtestfile = std.os.open(configurationFile, 0, 0) catch {
try out.writeAll("Cannot open file ");
try out.writeAll(configurationFile);
try out.writeAll("\n");
return;
};
std.os.close(openedtestfile);
alldevices = AllDevices.init(globalAllocator);
try parseTomlConfig(globalAllocator, &alldevices, configurationFile);
try out.writeAll("Opening database\n");
db = try DiskHash.init(&globalAllocator);
const filename = "iotdb.leveldb";
_ = try db.open(filename);
defer db.close();
// connecting to MQTT
var serverAddress: []const u8 = MqttConfig.mqttBroker;
var userName: []const u8 = MqttConfig.user;
var password: []const u8 = <PASSWORD>;
var clientid: []const u8 = MqttConfig.clientid;
try out.writeAll("Connecting to mqtt ..\n");
try out.print(" connecting to \"{s}\" with user \"{s}\" and clientid \"{s}\"\n", .{ serverAddress, userName, clientid });
cnx = try mqtt.MqttCnx.init(&globalAllocator, serverAddress, clientid, userName, password);
if (HttpConfig.activateHttp) {
try out.print("Start embedded http server on port {} \n", .{HttpConfig.*.port});
server = Server.init(
globalAllocator,
.{},
.{routez.all("/", indexHandler)},
);
addr = try Address.parseIp(HttpConfig.*.listenAddress, HttpConfig.*.port);
const threadConfig: Thread.SpawnConfig = .{};
const threadHandle = try Thread.spawn(threadConfig, startServer, .{.{}});
_ = threadHandle;
try out.print("Http server thread launched\n", .{});
}
try out.print("Checking running monitored processes\n", .{});
try checkProcessesAndRunMissing();
try out.print("Restoring saved states topics ... \n", .{});
// read all elements in database, then redefine the state for all
const it = try db.iterator();
defer globalAllocator.destroy(it);
defer it.deinit();
it.first();
while (it.isValid()) {
const r = it.iterKey();
if (r) |subject| {
defer globalAllocator.destroy(subject);
const v = it.iterValue();
if (v) |value| {
defer globalAllocator.destroy(value);
try out.print("Sending initial stored state {s} to {s}\n", .{ value.*, subject.* });
const topicWithSentinel = try globalAllocator.allocSentinel(u8, subject.*.len, 0);
defer globalAllocator.free(topicWithSentinel);
mem.copy(u8, topicWithSentinel[0..], subject.*);
// if failed, stop the process
cnx.publish(topicWithSentinel, value.*) catch |e| {
log.warn("ERROR {} fail to publish initial state on topic {s}", .{ e, topicWithSentinel });
try out.print(".. State restoring done, listening mqtt topics\n", .{});
};
}
}
it.next();
}
try out.print(".. State restoring done, listening mqtt topics\n", .{});
cnx.callBack = _external_callback;
// register to all, it may be huge, and probably not scaling
_ = try cnx.register("#");
while (true) { // main loop
_ = c.sleep(1); // every 1 seconds
{
// if activated trace this function
const t = tracy.trace(@src());
defer t.end();
// check process that has falled down, and must be restarted
try checkProcessesAndRunMissing();
// watchdog
try publishWatchDog();
var iterator = alldevices.iterator();
while (iterator.next()) |e| {
// publish message
const deviceInfo = e.value_ptr.*;
if (deviceInfo.enabled) {
// if the device is enabled
const hasExpired = try deviceInfo.hasExpired();
if (hasExpired) {
try publishDeviceTimeOut(deviceInfo);
}
try publishDeviceMonitoringInfos(deviceInfo);
}
}
}
}
log.warn("ended", .{});
return;
} | iotmonitor.zig |
const std = @import("std");
pub const Allocator = std.mem.Allocator;
pub const List = std.ArrayList;
pub const Map = std.AutoHashMap;
pub const StrMap = std.StringHashMap;
pub const BitSet = std.DynamicBitSet;
pub const Str = []const u8;
pub var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
pub const gpa = &gpa_impl.allocator;
// Input-handling errors.
pub const Error = error{InvalidInput};
// Basic point for a 2D integral grid.
pub fn Point(comptime T: type) type {
return struct {
const Self = @This();
x: T = 0,
y: T = 0,
/// Given known grid width, maps a location to a unique 1D array index that represents its location.
pub fn toIndex(self: Self, width: u32) usize {
return xyToIndex(self.x, self.y, width);
}
/// Given known grid width, maps a location to a unique 1D array index that represents its location.
pub fn xyToIndex(x: T, y: T, width: u32) usize {
return width * @intCast(u32, y) + @intCast(u32, x);
}
/// Given known grid width, and an index in a 1D array mapped via toIndex, gets the Point that
/// represents its location.
pub fn fromIndex(index: usize, width: u32) Self {
return Self{ .x = @intCast(T, index % width), .y = @intCast(T, index / width) };
}
/// Adds the two given points together and returns a new point.
pub fn add(p1: Point(T), p2: Point(T)) Point(T) {
return .{ .x = p1.x + p2.x, .y = p1.y + p2.y };
}
pub fn subtract(p1: Point(T), p2: Point(T)) Point(T) {
return .{ .x = p1.x - p2.x, .y = p1.y - p2.y };
}
};
}
pub const cardinalNeighbors = [_]Point(i32){
.{ .x = 0, .y = -1 }, // Up
.{ .x = 1, .y = 0 }, // Right
.{ .x = 0, .y = 1 }, // Down
.{ .x = -1, .y = 0 }, // Left
};
pub const eightWayNeighbors = [_]Point(i32){
.{ .x = 0, .y = -1 }, // Up
.{ .x = 1, .y = -1 }, // UpRight
.{ .x = 1, .y = 0 }, // Right
.{ .x = 1, .y = 1 }, // DownRight
.{ .x = 0, .y = 1 }, // Down
.{ .x = -1, .y = 1 }, // DownLeft
.{ .x = -1, .y = 0 }, // Left
.{ .x = -1, .y = -1 }, // UpLeft
};
/// Basic bearings of lines
pub const LineType = enum {
Horizontal,
Vertical,
Diagonal,
};
/// 3D integer point
pub fn Point3d(comptime T: type) type {
return struct {
x: T,
y: T,
z: T,
};
}
/// Line consisting of 2 points
pub fn Line(comptime T: type) type {
return struct {
const Self = @This();
start: Point(T),
end: Point(T),
pub fn getType(self: Self) LineType {
if (self.start.x == self.end.x) return .Vertical;
if (self.start.y == self.end.y) return .Horizontal;
return .Diagonal;
}
};
}
/// Represents nodes in a graph of items that are of type T.
pub fn GraphNode(comptime T: type) type {
return struct {
const Self = @This();
/// The value this node represents.
value: T,
/// The vertices this node is (unidirectionally) connected to.
edges: List(*Self),
/// Creates a node for the given value with no edges.
pub fn init(value: T, allocator: *Allocator) Self {
return Self{
.value = value,
.edges = List(*Self).init(allocator),
};
}
/// Deinitializes the node.
pub fn deinit(self: *Self) void {
self.edges.deinit();
}
};
}
/// A graph structure supporting arbitrary value types for nodes.
///
/// Currently, the graph depends on either std.StringHashMap or std.AutoHashMap as applicable,
/// and does not allow the specification of custom contexts. This could change in the future.
pub fn Graph(comptime T: type) type {
return struct {
const Self = @This();
/// Type for nodes in the graph
pub const Node = GraphNode(T);
/// Hash type used to map vertex values to their corresponding vertices
pub const VertexMap = switch (T) {
[]const u8 => StrMap(*Node),
else => Map(T, *Node),
};
/// Map of values to the vertex representing that value, if any such vertex exists.
vertices: VertexMap,
/// Allocator used for maintaining the graph.
allocator: *Allocator,
/// Initializes a graph which will use the given allocator.
pub fn init(allocator: *Allocator) Self {
return Self{
.vertices = VertexMap.init(allocator),
.allocator = allocator,
};
}
/// Deinitializes the graph, deallocating all of its vertices in the process.
pub fn deinit(self: *Self) void {
// Deinitialize vertices and free them
var it = self.vertices.valueIterator();
while (it.next()) |vertexPtr| {
vertexPtr.*.*.deinit();
self.allocator.destroy(vertexPtr.*);
}
// Free vertex map
self.vertices.deinit();
}
/// Gets the vertex representing the given value, if one exists. If no vertex exists, it
/// creates and adds a vertex to represent the given value, and returns that one.
pub fn getOrAddVertex(self: *Self, value: T) !*Node {
const result = try self.vertices.getOrPut(value);
if (!result.found_existing) {
result.value_ptr.* = try self.allocator.create(Node);
errdefer result.value_ptr.*.deinit();
result.value_ptr.*.* = Node.init(value, self.allocator);
}
return result.value_ptr.*;
}
// Adds an edge between the given vertices, creating vertices as needed. The edge will be
// bidirectional is specified.
pub fn addEdge(self: *Self, from_vertex: T, to_vertex: T, bidirectional: bool) !void {
// Get or add vertices defined by the edge
const from_node = try self.getOrAddVertex(from_vertex);
const to_node = try self.getOrAddVertex(to_vertex);
// Add edges as needed
try from_node.edges.append(to_node);
if (bidirectional) try to_node.edges.append(from_node);
}
};
}
/// Returns the first integer larger than or equal to x, casted to an integer of the given type.
pub fn ceilCast(comptime T: type, x: anytype) T {
return @floatToInt(T, std.math.ceil(x));
}
/// Errors returned by the find algorithm.
pub const FindError = error{
/// Element that was searched for could not be found
NotFound,
};
// Searches slice for element, using std.meta.eql for comparison. Returns index of element if found,
// or error if not found.
pub fn find(comptime T: type, slice: []const T, element: T) !usize {
for (slice) |elem, idx| {
if (std.meta.eql(elem, element)) return idx;
}
return error.NotFound;
}
/// Searches the slice for element, using std.meta.eql for comparison. Returns true if element
/// is found, false otherwise.
pub fn contains(comptime T: type, slice: []const T, element: T) bool {
_ = find(T, slice, element) catch {
return false;
};
return true;
}
/// Use with std.sort.sort to sort a list of slices in descending order based on their length.
/// Similar to std.sort.asc.
pub fn sliceLenDesc(comptime T: type) fn (void, []const T, []const T) bool {
const impl = struct {
fn inner(context: void, a: []const T, b: []const T) bool {
_ = context;
return a.len > b.len;
}
};
return impl.inner;
}
/// Utilizes a closed-form solution to find a geometric sum of all terms between 1 and n.
///
/// For example, for n = 3, the function returns 1 + 2 + 3 = 6 via the standard closed-form solution
/// n * (n-1) / 2.
pub fn geometricSummation(n: anytype) @TypeOf(n) {
return @floatToInt(@TypeOf(n), @intToFloat(f32, n) * (@intToFloat(f32, n) + 1.0) / 2.0);
}
// Useful stdlib functions
pub const tokenize = std.mem.tokenize;
pub const split = std.mem.split;
pub const indexOf = std.mem.indexOfScalar;
pub const indexOfAny = std.mem.indexOfAny;
pub const indexOfStr = std.mem.indexOfPosLinear;
pub const lastIndexOf = std.mem.lastIndexOfScalar;
pub const lastIndexOfAny = std.mem.lastIndexOfAny;
pub const lastIndexOfStr = std.mem.lastIndexOfLinear;
pub const trim = std.mem.trim;
pub const sliceMin = std.mem.min;
pub const sliceMax = std.mem.max;
pub const parseInt = std.fmt.parseInt;
pub const parseFloat = std.fmt.parseFloat;
pub const min = std.math.min;
pub const min3 = std.math.min3;
pub const max = std.math.max;
pub const max3 = std.math.max3;
pub const absInt = std.math.absInt;
pub const absCast = std.math.absCast;
pub const print = std.debug.print;
pub const assert = std.debug.assert;
pub const sort = std.sort.sort;
pub const asc = std.sort.asc;
pub const desc = std.sort.desc; | src/util.zig |
const std = @import("std");
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const Arena = std.heap.ArenaAllocator;
const testing = std.testing;
const Lexer = @import("Lexer.zig");
const Token = @import("Token.zig");
const ast = @import("ast.zig");
const Node = ast.Node;
const Tree = ast.Tree;
const Errors = @import("error.zig").Errors;
//! This is where the `Parser` will parse all tokens, which are
//! parsed by the `Lexer`, into an AST tree.
/// Precendence represent the order of importance
/// The higher the value, the earlier it will be executed
/// This means a function call will be executed before a prefix,
/// and the product will be calculated before the sum.
///
/// Note that the order of these is important to determine the precedence in binary operations
const Precedence = enum(u4) {
lowest,
range,
@"or",
@"and",
assign,
equals,
less_greater,
bitwise_or,
bitwise_xor,
bitwise_and,
shift,
sum,
product,
prefix,
call,
index,
/// Returns the integer value of the enum
fn val(self: Precedence) u4 {
return @enumToInt(self);
}
};
/// Determines the Precendence based on the given Token Type
fn findPrecedence(token_type: Token.TokenType) Precedence {
return switch (token_type) {
.double_period => .range,
.@"or" => .@"or",
.@"and" => .@"and",
.assign, .equal_add, .equal_sub, .equal_mul, .equal_div => .assign,
.equal, .not_equal => .equals,
.less_than, .greater_than, .less_than_equal, .greater_than_equal => .less_greater,
.ampersand => .bitwise_and,
.pipe => .bitwise_or,
.caret => .bitwise_xor,
.shift_left, .shift_right => .shift,
.plus, .minus => .sum,
.slash, .asterisk, .percent => .product,
.left_parenthesis => .call,
.left_bracket => .index,
.period => .index,
else => .lowest,
};
}
/// Parses source code into an AST tree
pub fn parse(allocator: *Allocator, source: []const u8, err: *Errors) Parser.Error!Tree {
var lexer = Lexer.init(source);
var arena = std.heap.ArenaAllocator.init(allocator);
errdefer arena.deinit();
var parser = Parser{
.current_token = lexer.next(),
.peek_token = lexer.next(),
.allocator = &arena.allocator,
.lexer = &lexer,
.source = source,
.err = err,
.depth = 0,
};
var nodes = ArrayList(Node).init(parser.allocator);
errdefer nodes.deinit();
while (!parser.currentIsType(.eof)) : (parser.next()) {
try nodes.append(try parser.parseStatement());
}
return Tree{
.nodes = nodes.toOwnedSlice(),
.arena = arena.state,
.allocator = allocator,
};
}
/// Parser retrieves tokens from our Lexer and turns them into
/// nodes to create an AST.
pub const Parser = struct {
/// Current token that has been parsed
current_token: Token,
/// The next token that will be set as current when calling .next() or .expectPeek()
peek_token: Token,
allocator: *Allocator,
/// Lexer that tokenized all tokens and is used to retrieve the next token
lexer: *Lexer,
/// Original source code. Memory is not owned by the parser.
source: []const u8,
/// List of errors that can be filled with Parser errors
err: *Errors,
/// Current scope depth. Increased and decreased by blocks
depth: usize,
pub const Error = error{
ParserError,
OutOfMemory,
Overflow,
InvalidCharacter,
};
/// Returns `Error.ParserError` and appends an error message to the `errors` list.
fn fail(self: *Parser, comptime msg: []const u8, index: usize, args: anytype) Error {
try self.err.add(msg, index, .err, args);
return Error.ParserError;
}
/// Sets the current token to the peek token and retrieves a new
/// token from the Lexer and sets its value to the peak token.
fn next(self: *Parser) void {
self.current_token = self.peek_token;
self.peek_token = self.lexer.next();
}
/// Parses the statement into a node
fn parseStatement(self: *Parser) Error!Node {
return switch (self.current_token.token_type) {
.comment => self.parseComment(),
.constant, .mutable, .@"pub" => self.parseDeclaration(),
.@"return" => self.parseReturn(),
.@"switch" => self.parseSwitchStatement(),
.while_loop => self.parseWhile(),
.for_loop => self.parseFor(),
.@"break" => self.parseBreak(),
.@"continue" => self.parseContinue(),
else => self.parseExpressionStatement(),
};
}
/// Parses a declaration
fn parseDeclaration(self: *Parser) Error!Node {
const is_pub = if (self.currentIsType(.@"pub")) blk: {
if (self.depth > 0) {
return self.fail(
"Public declaration not allowed outside global scope",
self.current_token.start,
.{},
);
}
self.next();
break :blk true;
} else false;
const decl = try self.allocator.create(Node.Declaration);
decl.* = .{
.token = self.current_token,
.name = undefined,
.value = undefined,
.type_def = null,
.mutable = self.currentIsType(.mutable),
.is_pub = is_pub,
};
try self.expectPeek(.identifier);
decl.name = try self.parseIdentifier();
if (self.peekIsType(.colon)) {
self.next();
self.next();
decl.type_def = try self.parseTypeExpression();
}
try self.expectPeek(.assign);
self.next();
decl.value = try self.parseExpression(.lowest);
if (decl.value == .func_lit)
decl.value.func_lit.name = decl.name.identifier.value;
return Node{ .declaration = decl };
}
/// Parses a return statement
fn parseReturn(self: *Parser) Error!Node {
const ret = try self.allocator.create(Node.Return);
ret.* = .{ .token = self.current_token, .value = undefined };
self.next();
ret.value = try self.parseExpression(.lowest);
return Node{ .@"return" = ret };
}
/// Parses the current token as an Identifier
fn parseIdentifier(self: *Parser) Error!Node {
const identifier = try self.allocator.create(Node.Identifier);
const val = try self.allocator.dupe(u8, self.source[self.current_token.start..self.current_token.end]);
identifier.* = .{ .token = self.current_token, .value = val };
return Node{ .identifier = identifier };
}
/// Parses an expression statement, determines which expression to parse based on the token
fn parseExpressionStatement(self: *Parser) Error!Node {
const statement = try self.allocator.create(Node.Expression);
statement.* = .{ .token = self.current_token, .value = try self.parseExpression(.lowest) };
return Node{ .expression = statement };
}
/// Determines the correct expression type based on the current token type
fn parseExpression(self: *Parser, prec: Precedence) Error!Node {
var left = switch (self.current_token.token_type) {
.identifier => try self.parseIdentifier(),
.integer => try self.parseIntegerLiteral(),
.string => try self.parseStringLiteral(),
.bang => try self.parsePrefixExpression(),
.minus => try self.parsePrefixExpression(),
.tilde => try self.parsePrefixExpression(),
.import => try self.parseImportExpression(),
.@"true", .@"false" => try self.parseBoolean(),
.@"if" => try self.parseIfExpression(),
.left_parenthesis => try self.parseGroupedExpression(),
.function => try self.parseFunctionLiteral(true),
.left_bracket => try self.parseDataStructure(false),
.nil => try self.parseNil(),
.@"enum" => try self.parseEnum(),
else => return self.fail("Unexpected token: {}", self.current_token.start, .{self.current_token.token_type}),
};
while (prec.val() < findPrecedence(self.peek_token.token_type).val()) {
left = switch (self.peek_token.token_type) {
.left_parenthesis => blk: {
self.next();
break :blk try self.parseCallExpression(left);
},
.left_bracket, .period => blk: {
self.next();
break :blk try self.parseIndexExpression(left);
},
.assign => blk: {
self.next();
break :blk try self.parseAssignment(left);
},
.double_period => blk: {
self.next();
break :blk try self.parseRange(left);
},
.plus,
.minus,
.slash,
.asterisk,
.percent,
.ampersand,
.pipe,
.caret,
.equal,
.not_equal,
.less_than,
.greater_than,
.less_than_equal,
.greater_than_equal,
.shift_left,
.shift_right,
.@"and",
.@"or",
.equal_add,
.equal_sub,
.equal_mul,
.equal_div,
=> blk: {
self.next();
break :blk try self.parseInfixExpression(left);
},
else => return left,
};
}
return left;
}
/// Parses the current token into a prefix, errors if current token is not a prefix token
fn parsePrefixExpression(self: *Parser) Error!Node {
const expression = try self.allocator.create(Node.Prefix);
expression.* = .{
.token = self.current_token,
.operator = Node.Prefix.Op.fromToken(self.current_token),
.right = undefined,
};
self.next();
expression.right = try self.parseExpression(.prefix);
return Node{ .prefix = expression };
}
/// Parses the current token into an infix expression
fn parseInfixExpression(self: *Parser, left: Node) Error!Node {
const expression = try self.allocator.create(Node.Infix);
expression.* = .{
.token = self.current_token,
.operator = Node.Infix.Op.fromToken(self.current_token),
.left = left,
.right = undefined,
};
const prec = findPrecedence(self.current_token.token_type);
self.next();
expression.right = try self.parseExpression(prec);
return Node{ .infix = expression };
}
/// Parses the current token into an integer literal node
fn parseIntegerLiteral(self: *Parser) Error!Node {
const literal = try self.allocator.create(Node.IntegerLiteral);
const string_number = self.source[self.current_token.start..self.current_token.end];
const value = try std.fmt.parseInt(usize, string_number, 10);
literal.* = .{ .token = self.current_token, .value = value };
return Node{ .int_lit = literal };
}
/// Parses the current token into a string literal
fn parseStringLiteral(self: *Parser) Error!Node {
const literal = try self.allocator.create(Node.StringLiteral);
const token = self.current_token;
literal.* = .{ .token = token, .value = try self.allocator.dupe(u8, self.source[token.start..token.end]) };
return Node{ .string_lit = literal };
}
/// Parses an expression into a boolean node
fn parseBoolean(self: *Parser) !Node {
const boolean = try self.allocator.create(Node.Bool);
boolean.* = .{
.token = self.current_token,
.value = self.currentIsType(.@"true"),
};
return Node{ .boolean = boolean };
}
/// Parses expressions into a grouped expression
fn parseGroupedExpression(self: *Parser) Error!Node {
self.next();
const exp = try self.parseExpression(.lowest);
try self.expectPeek(.right_parenthesis);
return exp;
}
/// Parses the expression into an if expression,
/// captures the condition and block statements.
fn parseIfExpression(self: *Parser) Error!Node {
const exp = try self.allocator.create(Node.IfExpression);
exp.* = .{
.token = self.current_token,
.condition = undefined,
.true_pong = undefined,
.false_pong = undefined,
};
self.next();
exp.condition = try self.parseExpression(.lowest);
try self.expectPeek(.left_brace);
exp.true_pong = try self.parseBlockStatement();
if (self.peekIsType(.@"else")) {
self.next();
if (self.peekIsType(.@"if")) {
self.next();
exp.false_pong = try self.parseStatement();
return Node{ .if_expression = exp };
}
try self.expectPeek(.left_brace);
exp.false_pong = try self.parseBlockStatement();
}
return Node{ .if_expression = exp };
}
/// Parses the tokens into a `Node.BlockStatement` until a right brace is found
/// Indirectly asserts a closing bracket is found
/// Parse statements using this function do not have to assert for it.
fn parseBlockStatement(self: *Parser) !Node {
self.depth += 1;
defer self.depth -= 1;
const block = try self.allocator.create(Node.BlockStatement);
block.* = .{
.token = self.current_token,
.nodes = undefined,
};
var list = ArrayList(Node).init(self.allocator);
errdefer list.deinit();
self.next(); //skip '{' token
while (!self.currentIsType(.right_brace) and !self.currentIsType(.eof)) {
const exp = try self.parseStatement();
try list.append(exp);
self.next();
}
block.nodes = list.toOwnedSlice();
return Node{ .block_statement = block };
}
/// Parses current tokens into a function literal.
/// Returns errors if no left parenthesis or brace is found.
fn parseFunctionLiteral(self: *Parser, parse_body: bool) Error!Node {
const func = try self.allocator.create(Node.FunctionLiteral);
func.* = .{
.token = self.current_token,
.params = undefined,
.body = null,
.ret_type = undefined,
.name = null,
};
try self.expectPeek(.left_parenthesis);
func.params = try self.parseFunctionParameters();
self.next();
func.ret_type = try self.parseTypeExpression();
if (parse_body) {
try self.expectPeek(.left_brace);
func.body = try self.parseBlockStatement();
}
return Node{ .func_lit = func };
}
/// Parses the tokens into a list of nodes representing the parameters
/// of a function literal.
fn parseFunctionParameters(self: *Parser) Error![]Node {
var list = ArrayList(Node).init(self.allocator);
errdefer list.deinit();
self.next();
if (self.currentIsType(.right_parenthesis)) {
return list.toOwnedSlice();
}
try list.append(try self.parseArgument());
while (self.peekIsType(.comma)) {
self.next();
self.next();
try list.append(try self.parseArgument());
}
try self.expectPeek(.right_parenthesis);
return list.toOwnedSlice();
}
/// Parses an argument that contains an identifier Node and its type
fn parseArgument(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.FunctionArgument);
node.* = .{
.token = self.current_token,
.value = try self.allocator.dupe(u8, self.source[self.current_token.start..self.current_token.end]),
.arg_type = undefined,
};
try self.expectPeek(.colon);
self.next();
node.arg_type = try self.parseTypeExpression();
return Node{ .func_arg = node };
}
/// Parses the current token into a call expression
/// Accepts a function node
fn parseCallExpression(self: *Parser, func: Node) Error!Node {
const call = try self.allocator.create(Node.CallExpression);
call.* = .{
.token = self.current_token,
.function = func,
.arguments = try self.parseArguments(.right_parenthesis),
};
return Node{ .call_expression = call };
}
/// Parses the next set of tokens into argument nodes
fn parseArguments(self: *Parser, comptime end_type: Token.TokenType) Error![]Node {
var list = ArrayList(Node).init(self.allocator);
errdefer list.deinit();
// no arguments
if (self.peekIsType(end_type)) {
self.next();
return list.toOwnedSlice();
}
self.next();
try list.append(try self.parseExpression(.lowest));
while (self.peekIsType(.comma)) {
self.next();
self.next();
try list.append(try self.parseExpression(.lowest));
}
try self.expectPeek(end_type);
return list.toOwnedSlice();
}
/// Parses the token into an `ArrayLiteral`
fn parseDataStructure(self: *Parser, is_type_defintion: bool) Error!Node {
const ds = try self.allocator.create(Node.DataStructure);
ds.* = .{
.token = self.current_token,
.d_type = .array,
.value = null,
.type_def_key = undefined,
.type_def_value = null,
.len = null,
};
if (!self.peekIsType(.right_bracket)) {
self.next();
ds.len = try self.parseIntegerLiteral();
}
try self.expectPeek(.right_bracket);
self.next();
ds.type_def_key = try self.parseTypeExpression();
if (self.peekIsType(.colon)) {
self.next();
self.next();
ds.type_def_value = try self.parseTypeExpression();
ds.d_type = .map;
}
// if this is a type declaration, i.e fn(x: []int) then don't parse arguments
if (!is_type_defintion) {
try self.expectPeek(.left_brace);
ds.value = if (ds.d_type == .array)
try self.parseArguments(.right_brace)
else
try self.parseMap();
if (ds.len) |len|
if (ds.value.?.len != len.int_lit.value)
return self.fail(
"Expected size {} but found size {}",
self.current_token.start,
.{ ds.value.?.len, len.int_lit.value },
);
}
return Node{ .data_structure = ds };
}
/// Parses the map key:value pairs into a list of Nodes
fn parseMap(self: *Parser) Error![]Node {
var pairs = std.ArrayList(Node).init(self.allocator);
while (!self.peekIsType(.right_brace)) {
self.next();
const pair = try self.parsePair();
try pairs.append(pair);
if (!self.peekIsType(.right_brace))
try self.expectPeek(.comma);
}
try self.expectPeek(.right_brace);
return pairs.toOwnedSlice();
}
/// Parses the next token into a Key Value `MapPair`
fn parsePair(self: *Parser) Error!Node {
const pair = try self.allocator.create(Node.MapPair);
pair.* = .{ .token = self.current_token, .key = try self.parseExpression(.lowest), .value = undefined };
try self.expectPeek(.colon);
// skip over colon
self.next();
pair.value = try self.parseExpression(.lowest);
return Node{ .map_pair = pair };
}
/// Parses the selector to retreive a value from an Array or Map
fn parseIndexExpression(self: *Parser, left: Node) Error!Node {
const token = self.current_token;
self.next();
const index_node = if (token.token_type == .period) blk: {
if (!self.currentIsType(.identifier))
return self.fail("Expected identifier", self.current_token.start, .{});
break :blk try self.parseStringLiteral();
} else if (!self.currentIsType(.colon))
try self.parseExpression(.lowest)
else
null;
if (token.token_type != .period) {
if (self.currentIsType(.colon) or self.peekIsType(.colon))
return self.parseSliceExpression(token, left, index_node);
try self.expectPeek(.right_bracket);
}
const index = try self.allocator.create(Node.IndexExpression);
index.* = .{ .token = token, .left = left, .index = index_node.? };
return Node{ .index = index };
}
/// Parses a while token into a while node
fn parseWhile(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.WhileLoop);
node.* = .{
.token = self.current_token,
.condition = undefined,
.block = undefined,
};
self.next();
node.condition = try self.parseExpression(.lowest);
try self.expectPeek(.left_brace);
// parseBlockStatement already asserts for a closing bracket, so return after parsing
node.block = try self.parseBlockStatement();
return Node{ .while_loop = node };
}
/// Parses a for expression
fn parseFor(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.ForLoop);
node.* = .{
.token = self.current_token,
.iter = undefined,
.capture = undefined,
.index = undefined,
.block = undefined,
};
self.next();
node.capture = try self.parseIdentifier();
// Check if index capture exists i.e. for x, i: range {}
if (self.peekIsType(.comma)) {
self.next(); // skip comma
self.next(); // next identifier
node.index = try self.parseIdentifier();
}
try self.expectPeek(.colon);
self.next();
node.iter = try self.parseExpression(.lowest);
try self.expectPeek(.left_brace);
node.block = try self.parseBlockStatement();
return Node{ .for_loop = node };
}
/// Parses the current expression as an assignment. Compiler does checking for mutating
fn parseAssignment(self: *Parser, left: Node) Error!Node {
if (left != .identifier and left != .index)
return self.fail("Expected identifier or index", self.current_token.start, .{});
const node = try self.allocator.create(Node.Assignment);
node.* = .{
.token = self.peek_token,
.left = left,
.right = undefined,
};
self.next();
node.right = try self.parseExpression(.lowest);
return Node{ .assignment = node };
}
/// Parses an expression into a `Node.Range` i.e. 0..5
fn parseRange(self: *Parser, left: Node) Error!Node {
const range = try self.allocator.create(Node.Range);
range.* = .{
.token = self.current_token,
.left = left,
.right = undefined,
};
self.next();
range.right = try self.parseExpression(.lowest);
return Node{ .range = range };
}
/// Parses a comment token into a `Comment` node
fn parseComment(self: *Parser) Error!Node {
const comment = try self.allocator.create(Node.Comment);
const token = self.current_token;
comment.* = .{
.token = self.current_token,
.value = self.source[token.start..token.end],
};
return Node{ .comment = comment };
}
/// Literal Nil value parsing
fn parseNil(self: *Parser) Error!Node {
const nil = try self.allocator.create(Node.Nil);
nil.* = .{
.token = self.current_token,
};
return Node{ .nil = nil };
}
/// Constructs a `Break` node
fn parseBreak(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.Break);
node.* = .{
.token = self.current_token,
};
return Node{ .@"break" = node };
}
/// Constructs a `Continue` node
fn parseContinue(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.Continue);
node.* = .{
.token = self.current_token,
};
return Node{ .@"continue" = node };
}
/// Parses an enum statement
fn parseEnum(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.EnumLiteral);
var enums = std.ArrayList(Node).init(self.allocator);
node.* = .{
.token = self.current_token,
.nodes = undefined,
};
try self.expectPeek(.left_brace);
self.next();
try enums.append(try self.parseIdentifier());
while (self.peekIsType(.comma)) {
self.next();
self.next();
try enums.append(try self.parseIdentifier());
}
try self.expectPeek(.right_brace);
node.nodes = enums.toOwnedSlice();
return Node{ .@"enum" = node };
}
/// Parses the import expression i.e. const std = import("std")
fn parseImportExpression(self: *Parser) Error!Node {
const import = try self.allocator.create(Node.Import);
import.* = .{ .token = self.current_token, .value = undefined };
try self.expectPeek(.left_parenthesis);
self.next();
import.value = try self.parseExpression(.lowest);
try self.expectPeek(.right_parenthesis);
return Node{ .import = import };
}
/// Parses a switch statement into the `Switch` `Node`.
fn parseSwitchStatement(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.SwitchLiteral);
node.* = .{ .token = self.current_token, .capture = undefined, .prongs = undefined };
try self.expectPeek(.left_parenthesis);
self.next();
node.capture = try self.parseExpression(.lowest);
try self.expectPeek(.right_parenthesis);
try self.expectPeek(.left_brace);
self.next();
var prongs = std.ArrayList(Node).init(self.allocator);
try prongs.append(try self.parseSwitchProng());
while (self.peekIsType(.comma)) {
self.next();
self.next();
try prongs.append(try self.parseSwitchProng());
}
node.prongs = prongs.toOwnedSlice();
try self.expectPeek(.right_brace);
return Node{ .switch_statement = node };
}
/// Parses a switch prong i.e. x: 5 + 5 into a `Node.SwitchProng`
fn parseSwitchProng(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.SwitchProng);
node.* = .{ .token = undefined, .left = try self.parseExpression(.lowest), .right = undefined };
try self.expectPeek(.colon);
node.token = self.current_token;
self.next();
node.right = if (self.currentIsType(.left_brace))
try self.parseBlockStatement()
else
try self.parseExpressionStatement();
return Node{ .switch_prong = node };
}
/// Parses a type literal into a `Node.TypeDef` `Node`.
/// i.e. parses const x: bool = true where 'bool' is the type expression
fn parseTypeExpression(self: *Parser) Error!Node {
const node = try self.allocator.create(Node.TypeDef);
node.* = .{ .token = self.current_token, .value = null };
switch (self.current_token.token_type) {
.bool_type, .int_type, .string_type, .void_type => {},
.left_bracket => node.value = try self.parseDataStructure(true),
.function => node.value = try self.parseFunctionLiteral(false),
.query => node.value = blk: {
self.next();
break :blk try self.parseTypeExpression();
},
else => return self.fail("Unexpected token, expected a type definition", self.current_token.start, .{}),
}
return Node{ .type_def = node };
}
/// Parses a slice expression into `Node.SliceExpression`
/// i.e. Parses list[0:5], [:5] or [0:] to create a new slice from an array
fn parseSliceExpression(self: *Parser, token: Token, left: Node, start: ?Node) Error!Node {
const node = try self.allocator.create(Node.SliceExpression);
node.* = .{ .token = token, .left = left, .start = start, .end = null };
if (self.peekIsType(.colon)) self.next();
if (!self.peekIsType(.right_bracket)) {
self.next();
node.end = try self.parseExpression(.lowest);
}
try self.expectPeek(.right_bracket);
return Node{ .slice = node };
}
/// Determines if the next token is the expected token or not.
/// Incase the next token is the wanted token, retun true and retrieve next token.
fn expectPeek(self: *Parser, comptime token_type: Token.TokenType) !void {
if (self.peekIsType(token_type)) {
self.next();
return;
}
return self.fail(
"Expected token '" ++ Token.fmtString(token_type) ++ "'",
self.peek_token.start,
.{},
);
}
/// Helper function to check if the peek token is of given type
fn peekIsType(self: Parser, token_type: Token.TokenType) bool {
return self.peek_token.token_type == token_type;
}
/// Helper function to check if the current token is of given type
fn currentIsType(self: Parser, token_type: Token.TokenType) bool {
return self.current_token.token_type == token_type;
}
};
test "Parse Declaration" {
var allocator = testing.allocator;
const test_cases = .{
.{ .input = "const x = 5", .id = "x", .expected = 5, .mutable = false, .is_pub = false },
.{ .input = "mut y = 50", .id = "y", .expected = 50, .mutable = true, .is_pub = false },
.{ .input = "mut x = 2 const y = 5", .id = "y", .expected = 5, .mutable = false, .is_pub = false },
.{ .input = "pub const x = 2 pub const y = 5", .id = "y", .expected = 5, .mutable = false, .is_pub = true },
};
inline for (test_cases) |case| {
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, case.input, &errors);
defer tree.deinit();
const node = tree.nodes[tree.nodes.len - 1].declaration;
try testing.expectEqualSlices(u8, case.id, node.name.identifier.value);
try testing.expect(case.expected == node.value.int_lit.value);
try testing.expect(case.mutable == node.mutable);
try testing.expect(case.is_pub == node.is_pub);
}
}
test "Parse public declaration outside global scope" {
var allocator = testing.allocator;
const input = "if(1<2){ pub const x = 2 }";
var errors = Errors.init(allocator);
defer errors.deinit();
try testing.expectError(Parser.Error.ParserError, parse(allocator, input, &errors));
try testing.expectEqual(@as(usize, 1), errors.list.items.len);
}
test "Parse Return statment" {
const test_cases = .{
.{ .input = "return 5", .expected = 5 },
.{ .input = "return foo", .expected = "foo" },
.{ .input = "return true", .expected = true },
};
var allocator = testing.allocator;
inline for (test_cases) |case| {
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, case.input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const node = tree.nodes[0].@"return".value;
switch (@typeInfo(@TypeOf(case.expected))) {
.ComptimeInt => try testing.expectEqual(@intCast(usize, case.expected), node.int_lit.value),
.Pointer => try testing.expectEqualSlices(u8, case.expected, node.identifier.value),
.Bool => try testing.expectEqual(case.expected, node.boolean.value),
else => @panic("Unexpected type"),
}
}
}
test "Parse identifier expression" {
const input = "foobar";
var allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const identifier = tree.nodes[0].expression.value.identifier;
try testing.expect(identifier.token.token_type == .identifier);
try testing.expectEqualSlices(u8, identifier.value, input);
}
test "Parse integer literal" {
const input = "124";
var allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const literal = tree.nodes[0].expression.value.int_lit;
try testing.expect(literal.token.token_type == .integer);
try testing.expect(literal.value == 124);
}
test "Parse prefix expressions" {
const VarValue = union {
int: usize,
string: []const u8,
boolean: bool,
};
const TestCase = struct {
input: []const u8,
operator: Node.Prefix.Op,
expected: VarValue,
};
const test_cases = &[_]TestCase{
.{ .input = "-5", .operator = .minus, .expected = VarValue{ .int = 5 } },
.{ .input = "!25", .operator = .bang, .expected = VarValue{ .int = 25 } },
.{ .input = "!foobar", .operator = .bang, .expected = VarValue{ .string = "foobar" } },
.{ .input = "-foobar", .operator = .minus, .expected = VarValue{ .string = "foobar" } },
.{ .input = "!true", .operator = .bang, .expected = VarValue{ .boolean = true } },
.{ .input = "!false", .operator = .bang, .expected = VarValue{ .boolean = false } },
};
const allocator = testing.allocator;
for (test_cases) |case| {
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, case.input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const prefix = tree.nodes[0].expression.value.prefix;
switch (prefix.right) {
.int_lit => |int| try testing.expect(case.expected.int == int.value),
.identifier => |id| try testing.expectEqualSlices(u8, case.expected.string, id.value),
.boolean => |boolean| try testing.expect(case.expected.boolean == boolean.value),
else => @panic("Unexpected Node"),
}
try testing.expectEqual(case.operator, prefix.operator);
}
}
test "Parse infix expressions - integer" {
const TestCase = struct {
input: []const u8,
left: usize,
operator: Node.Infix.Op,
right: usize,
};
const test_cases = &[_]TestCase{
.{ .input = "10 + 10", .left = 10, .operator = .add, .right = 10 },
.{ .input = "10 - 10", .left = 10, .operator = .sub, .right = 10 },
.{ .input = "10 * 10", .left = 10, .operator = .multiply, .right = 10 },
.{ .input = "10 / 10", .left = 10, .operator = .divide, .right = 10 },
.{ .input = "10 > 10", .left = 10, .operator = .greater_than, .right = 10 },
.{ .input = "10 < 10", .left = 10, .operator = .less_than, .right = 10 },
.{ .input = "10 == 10", .left = 10, .operator = .equal, .right = 10 },
.{ .input = "10 != 10", .left = 10, .operator = .not_equal, .right = 10 },
};
const allocator = testing.allocator;
for (test_cases) |case| {
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, case.input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const node: Node = tree.nodes[0];
const infix: *Node.Infix = node.expression.value.infix;
try testing.expectEqual(case.operator, infix.operator);
try testing.expectEqual(case.left, infix.left.int_lit.value);
try testing.expectEqual(case.right, infix.right.int_lit.value);
}
}
test "Parse infix expressions - identifier" {
const allocator = testing.allocator;
const input = "foobar + foobarz";
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const node: Node = tree.nodes[0];
const infix: *Node.Infix = node.expression.value.infix;
try testing.expectEqualSlices(u8, "foobar", infix.left.identifier.value);
try testing.expectEqualSlices(u8, "foobarz", infix.right.identifier.value);
try testing.expect(infix.operator == .add);
}
test "Parse infix expressions - boolean" {
const allocator = testing.allocator;
const input = "true == true";
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const node: Node = tree.nodes[0];
const infix: *Node.Infix = node.expression.value.infix;
try testing.expectEqual(true, infix.left.boolean.value);
try testing.expectEqual(true, infix.right.boolean.value);
try testing.expect(infix.operator == .equal);
}
test "Boolean expression" {
const allocator = testing.allocator;
const input = "true";
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
try testing.expect(tree.nodes[0].expression.value == .boolean);
}
test "If expression" {
const allocator = testing.allocator;
const input = "if x < y { x }";
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const if_exp = tree.nodes[0].expression.value.if_expression;
try testing.expect(if_exp.true_pong.block_statement.nodes[0] == .expression);
try testing.expectEqualSlices(
u8,
if_exp.true_pong.block_statement.nodes[0].expression.value.identifier.value,
"x",
);
}
test "If else expression" {
const allocator = testing.allocator;
const input = "if x < y { x } else { y }";
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const if_exp = tree.nodes[0].expression.value.if_expression;
try testing.expect(if_exp.true_pong.block_statement.nodes[0] == .expression);
try testing.expectEqualSlices(
u8,
if_exp.true_pong.block_statement.nodes[0].expression.value.identifier.value,
"x",
);
try testing.expect(if_exp.false_pong != null);
try testing.expect(if_exp.false_pong.?.block_statement.nodes[0] == .expression);
try testing.expectEqualSlices(
u8,
if_exp.false_pong.?.block_statement.nodes[0].expression.value.identifier.value,
"y",
);
}
test "If else-if expression" {
const allocator = testing.allocator;
const input = "if x < y { x } else if x == 0 { y } else { z }";
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const if_exp = tree.nodes[0].expression.value.if_expression;
try testing.expect(if_exp.true_pong.block_statement.nodes[0] == .expression);
try testing.expectEqualSlices(
u8,
if_exp.true_pong.block_statement.nodes[0].expression.value.identifier.value,
"x",
);
try testing.expect(if_exp.false_pong != null);
try testing.expect(if_exp.false_pong.?.expression.value.if_expression.false_pong != null);
}
test "Function literal" {
const input = "fn(x: int, y: int) fn(x: int) int { x + y }";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = parse(allocator, input, &errors) catch |err| {
try errors.write(input, std.io.getStdErr().writer());
return err;
};
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const func = tree.nodes[0].expression.value.func_lit;
try testing.expect(func.params.len == 2);
try testing.expectEqualSlices(u8, func.params[0].func_arg.value, "x");
try testing.expectEqualSlices(u8, func.params[1].func_arg.value, "y");
const body = func.body.?.block_statement.nodes[0];
const infix = body.expression.value.infix;
try testing.expectEqual(infix.operator, .add);
try testing.expectEqualSlices(u8, infix.left.identifier.value, "x");
try testing.expectEqualSlices(u8, infix.right.identifier.value, "y");
}
test "Function parameters" {
const test_cases = .{
.{ .input = "fn() void {}", .expected = &[_][]const u8{} },
.{ .input = "fn(x: int) void {}", .expected = &[_][]const u8{"x"} },
.{ .input = "fn(x: int, y: int, z: int) void {}", .expected = &[_][]const u8{ "x", "y", "z" } },
};
const allocator = testing.allocator;
inline for (test_cases) |case| {
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, case.input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const func = tree.nodes[0].expression.value.func_lit;
try testing.expect(func.params.len == case.expected.len);
inline for (case.expected) |exp, i| {
try testing.expectEqualSlices(u8, exp, func.params[i].func_arg.value);
}
}
}
test "Call expression" {
const input = "add(1, 2 * 3, 4 + 5)";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const call = tree.nodes[0].expression.value.call_expression;
try testing.expectEqualSlices(u8, call.function.identifier.value, "add");
try testing.expect(call.arguments.len == 3);
try testing.expect(call.arguments[0].int_lit.value == 1);
try testing.expectEqual(call.arguments[1].infix.operator, .multiply);
try testing.expect(call.arguments[2].infix.right.int_lit.value == 5);
}
test "String expression" {
const input = "\"Hello, world\"";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const string = tree.nodes[0].expression.value.string_lit;
try testing.expectEqualSlices(u8, "Hello, world", string.value);
}
test "Member expression" {
const input = "foo.bar";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const index = tree.nodes[0].expression.value.index;
try testing.expectEqualSlices(u8, "bar", index.index.string_lit.value);
try testing.expectEqualSlices(u8, "foo", index.left.identifier.value);
try testing.expect(index.token.token_type == .period);
}
test "Array literal" {
const input = "[]int{1, 2 * 2, 3 + 3}";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const array = tree.nodes[0].expression.value.data_structure;
try testing.expect(array.value.?.len == 3);
try testing.expect(array.value.?[0].int_lit.value == 1);
try testing.expect(array.value.?[1].infix.operator == .multiply);
}
test "Array index" {
const input = "array[1]";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const index = tree.nodes[0].expression.value.index;
try testing.expect(index.left == .identifier);
try testing.expect(index.index.int_lit.value == 1);
}
test "Map Literal" {
const Type = @import("Value.zig").Type;
const input = "[]string:int{\"foo\": 1, \"bar\": 5}";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const map = tree.nodes[0].expression.value.data_structure;
try testing.expect(map.value.?.len == 2);
const expected = .{
.{ .key = "foo", .value = 1 },
.{ .key = "bar", .value = 5 },
};
inline for (expected) |case, i| {
const pair: *Node.MapPair = map.value.?[i].map_pair;
try testing.expectEqualSlices(u8, case.key, pair.key.string_lit.value);
try testing.expect(case.value == pair.value.int_lit.value);
}
try testing.expectEqual(Type.map, tree.nodes[0].getType().?);
try testing.expectEqual(Type.string, tree.nodes[0].getInnerType().?);
try testing.expectEqual(Type.integer, map.type_def_value.?.getInnerType().?);
}
test "While loop" {
const input = "while x < y { x }";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const loop = tree.nodes[0].while_loop;
try testing.expect(loop.condition.infix.operator == .less_than);
try testing.expect(loop.block.block_statement.nodes.len == 1);
try testing.expectEqualStrings("x", loop.block.block_statement.nodes[0].expression.value.identifier.value);
}
test "Assignment" {
var allocator = testing.allocator;
const test_cases = .{
.{ .input = "x = 5", .id = "x", .expected = 5 },
.{ .input = "y = 50", .id = "y", .expected = 50 },
.{ .input = "x = 2 y = 5", .id = "y", .expected = 5 },
};
inline for (test_cases) |case, i| {
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, case.input, &errors);
defer tree.deinit();
const node = tree.nodes[tree.nodes.len - 1].expression.value.assignment;
try testing.expectEqualSlices(u8, case.id, node.left.identifier.value);
try testing.expect(case.expected == node.right.int_lit.value);
}
}
test "Comment expression" {
const input = "//This is a comment";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const comment = tree.nodes[0].comment;
try testing.expectEqualStrings("This is a comment", comment.value);
}
test "For loop" {
const input = "for id, i: x { id }";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const loop = tree.nodes[0].for_loop;
try testing.expect(loop.index != null);
try testing.expectEqualStrings("x", loop.iter.identifier.value);
try testing.expectEqualStrings("id", loop.capture.identifier.value);
try testing.expectEqualStrings("i", loop.index.?.identifier.value);
try testing.expect(loop.block.block_statement.nodes.len == 1);
try testing.expectEqualStrings("id", loop.block.block_statement.nodes[0].expression.value.identifier.value);
}
test "Enum" {
const input = "enum{value, another_value, third_value }";
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const enum_val = tree.nodes[0].expression.value.@"enum";
try testing.expect(enum_val.nodes.len == 3);
try testing.expectEqualStrings("value", enum_val.nodes[0].identifier.value);
try testing.expectEqualStrings("another_value", enum_val.nodes[1].identifier.value);
try testing.expectEqualStrings("third_value", enum_val.nodes[2].identifier.value);
}
test "Enum" {
const input =
\\switch(5){
\\ 1: 1 + 1,
\\ 2: {
\\ if (true) {
\\ 1 + 2
\\ }
\\ },
\\ 3: 2 + 2
\\}
;
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const tree = try parse(allocator, input, &errors);
defer tree.deinit();
try testing.expect(tree.nodes.len == 1);
const switch_stmt = tree.nodes[0].switch_statement;
try testing.expect(switch_stmt.capture == .int_lit);
try testing.expect(switch_stmt.prongs.len == 3);
for (switch_stmt.prongs) |p, i| {
try testing.expectEqual(@as(u64, i + 1), p.switch_prong.left.int_lit.value);
}
try testing.expect(switch_stmt.prongs[1].switch_prong.right == .block_statement);
}
test "Type definitions" {
const Type = @import("Value.zig").Type;
const cases = [_][]const u8{
"fn(x: int, y: int)void{}",
"const x: int = 10",
"fn(x: []int)fn()string{}",
"mut y: ?int = nil",
};
const allocator = testing.allocator;
var errors = Errors.init(allocator);
defer errors.deinit();
const function = try parse(allocator, cases[0], &errors);
defer function.deinit();
const func_type = function.nodes[0].getInnerType();
const arg_type = function.nodes[0].expression.value.func_lit.params[0].getType();
try testing.expectEqual(Type._void, func_type.?);
try testing.expectEqual(Type.integer, arg_type.?);
const declaration = try parse(allocator, cases[1], &errors);
defer declaration.deinit();
const decl_type = declaration.nodes[0].getType();
try testing.expectEqual(Type.integer, decl_type.?);
const array = try parse(allocator, cases[2], &errors);
defer array.deinit();
const array_type = array.nodes[0].expression.value.func_lit.params[0].getType();
const scalar_type = array.nodes[0].expression.value.func_lit.params[0].getInnerType();
const ret_type = array.nodes[0].getInnerType();
try testing.expectEqual(Type.list, array_type.?);
try testing.expectEqual(Type.integer, scalar_type.?);
try testing.expectEqual(Type.string, ret_type.?);
const optional = try parse(allocator, cases[3], &errors);
defer optional.deinit();
const optional_type = optional.nodes[0].getType();
const optional_child_type = optional.nodes[0].getInnerType();
try testing.expectEqual(Type.optional, optional_type.?);
try testing.expectEqual(Type.integer, optional_child_type.?);
}
test "Parse slice expression" {
const cases = .{
.{ .input = "const list = []int{1,2,3} const slice = list[1:2]", .expected = .{ 1, 2 } },
.{ .input = "const list = []int{1,2,3} const slice = list[0:]", .expected = .{ 0, null } },
.{ .input = "const list = []int{1,2,3} const slice = list[:1]", .expected = .{ null, 1 } },
};
inline for (cases) |case| {
var errors = Errors.init(testing.allocator);
defer errors.deinit();
const parsed = try parse(testing.allocator, case.input, &errors);
defer parsed.deinit();
const node = parsed.nodes[1].declaration.value.slice;
try testing.expectEqual(@as(?u64, case.expected[0]), if (node.start) |n| n.int_lit.value else null);
try testing.expectEqual(@as(?u64, case.expected[1]), if (node.end) |n| n.int_lit.value else null);
}
} | src/parser.zig |
pub const WM_CAP_START = @as(u32, 1024);
pub const MODM_USER = @as(u32, 16384);
pub const MIDM_USER = @as(u32, 16384);
pub const MODM_MAPPER = @as(u32, 8192);
pub const MIDM_MAPPER = @as(u32, 8192);
pub const MODM_INIT = @as(u32, 100);
pub const MIDM_INIT = @as(u32, 100);
pub const MODM_INIT_EX = @as(u32, 104);
pub const MIDM_INIT_EX = @as(u32, 104);
pub const DRV_MCI_FIRST = @as(u32, 2048);
pub const ACMDM_BASE = @as(u32, 24576);
pub const ICM_RESERVED = @as(u32, 20480);
pub const MIXERCONTROL_CONTROLTYPE_CUSTOM = @as(u32, 0);
pub const MIXERCONTROL_CONTROLTYPE_BOOLEANMETER = @as(u32, 268500992);
pub const MIXERCONTROL_CONTROLTYPE_SIGNEDMETER = @as(u32, 268566528);
pub const MIXERCONTROL_CONTROLTYPE_PEAKMETER = @as(u32, 268566529);
pub const MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER = @as(u32, 268632064);
pub const MIXERCONTROL_CONTROLTYPE_BOOLEAN = @as(u32, 536936448);
pub const MIXERCONTROL_CONTROLTYPE_ONOFF = @as(u32, 536936449);
pub const MIXERCONTROL_CONTROLTYPE_MUTE = @as(u32, 536936450);
pub const MIXERCONTROL_CONTROLTYPE_MONO = @as(u32, 536936451);
pub const MIXERCONTROL_CONTROLTYPE_LOUDNESS = @as(u32, 536936452);
pub const MIXERCONTROL_CONTROLTYPE_STEREOENH = @as(u32, 536936453);
pub const MIXERCONTROL_CONTROLTYPE_BASS_BOOST = @as(u32, 536945271);
pub const MIXERCONTROL_CONTROLTYPE_BUTTON = @as(u32, 553713664);
pub const MIXERCONTROL_CONTROLTYPE_DECIBELS = @as(u32, 805568512);
pub const MIXERCONTROL_CONTROLTYPE_SIGNED = @as(u32, 805437440);
pub const MIXERCONTROL_CONTROLTYPE_UNSIGNED = @as(u32, 805502976);
pub const MIXERCONTROL_CONTROLTYPE_PERCENT = @as(u32, 805634048);
pub const MIXERCONTROL_CONTROLTYPE_SLIDER = @as(u32, 1073872896);
pub const MIXERCONTROL_CONTROLTYPE_PAN = @as(u32, 1073872897);
pub const MIXERCONTROL_CONTROLTYPE_QSOUNDPAN = @as(u32, 1073872898);
pub const MIXERCONTROL_CONTROLTYPE_FADER = @as(u32, 1342373888);
pub const MIXERCONTROL_CONTROLTYPE_VOLUME = @as(u32, 1342373889);
pub const MIXERCONTROL_CONTROLTYPE_BASS = @as(u32, 1342373890);
pub const MIXERCONTROL_CONTROLTYPE_TREBLE = @as(u32, 1342373891);
pub const MIXERCONTROL_CONTROLTYPE_EQUALIZER = @as(u32, 1342373892);
pub const MIXERCONTROL_CONTROLTYPE_SINGLESELECT = @as(u32, 1879113728);
pub const MIXERCONTROL_CONTROLTYPE_MUX = @as(u32, 1879113729);
pub const MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT = @as(u32, 1895890944);
pub const MIXERCONTROL_CONTROLTYPE_MIXER = @as(u32, 1895890945);
pub const MIXERCONTROL_CONTROLTYPE_MICROTIME = @as(u32, 1610809344);
pub const MIXERCONTROL_CONTROLTYPE_MILLITIME = @as(u32, 1627586560);
pub const WAVE_MAPPER = @as(u32, 4294967295);
pub const MCI_TEST = @as(i32, 32);
pub const MCI_CAPTURE = @as(u32, 2160);
pub const MCI_MONITOR = @as(u32, 2161);
pub const MCI_RESERVE = @as(u32, 2162);
pub const MCI_SETAUDIO = @as(u32, 2163);
pub const MCI_SIGNAL = @as(u32, 2165);
pub const MCI_SETVIDEO = @as(u32, 2166);
pub const MCI_QUALITY = @as(u32, 2167);
pub const MCI_LIST = @as(u32, 2168);
pub const MCI_UNDO = @as(u32, 2169);
pub const MCI_CONFIGURE = @as(u32, 2170);
pub const MCI_RESTORE = @as(u32, 2171);
pub const MCI_ON = @as(u32, 1);
pub const MCI_OFF = @as(u32, 0);
pub const MCI_DGV_FILE_MODE_SAVING = @as(u32, 1);
pub const MCI_DGV_FILE_MODE_LOADING = @as(u32, 2);
pub const MCI_DGV_FILE_MODE_EDITING = @as(u32, 3);
pub const MCI_DGV_FILE_MODE_IDLE = @as(u32, 4);
pub const MCI_ON_S = @as(i32, 32768);
pub const MCI_OFF_S = @as(i32, 32769);
pub const MCI_DGV_FILE_S = @as(i32, 32770);
pub const MCI_DGV_INPUT_S = @as(i32, 32771);
pub const MCI_DGV_FILE_MODE_SAVING_S = @as(i32, 32772);
pub const MCI_DGV_FILE_MODE_LOADING_S = @as(i32, 32773);
pub const MCI_DGV_FILE_MODE_EDITING_S = @as(i32, 32774);
pub const MCI_DGV_FILE_MODE_IDLE_S = @as(i32, 32775);
pub const MCI_DGV_SETVIDEO_SRC_NTSC_S = @as(i32, 32784);
pub const MCI_DGV_SETVIDEO_SRC_RGB_S = @as(i32, 32785);
pub const MCI_DGV_SETVIDEO_SRC_SVIDEO_S = @as(i32, 32786);
pub const MCI_DGV_SETVIDEO_SRC_PAL_S = @as(i32, 32787);
pub const MCI_DGV_SETVIDEO_SRC_SECAM_S = @as(i32, 32788);
pub const MCI_DGV_SETVIDEO_SRC_GENERIC_S = @as(i32, 32789);
pub const MCI_DGV_SETAUDIO_SRC_LEFT_S = @as(i32, 32800);
pub const MCI_DGV_SETAUDIO_SRC_RIGHT_S = @as(i32, 32801);
pub const MCI_DGV_SETAUDIO_SRC_AVERAGE_S = @as(i32, 32802);
pub const MCI_DGV_SETAUDIO_SRC_STEREO_S = @as(i32, 32803);
pub const MM_MCISIGNAL = @as(u32, 971);
pub const MCIERR_DGV_DEVICE_LIMIT = @as(u32, 512);
pub const MCIERR_DGV_IOERR = @as(u32, 513);
pub const MCIERR_DGV_WORKSPACE_EMPTY = @as(u32, 514);
pub const MCIERR_DGV_DISK_FULL = @as(u32, 515);
pub const MCIERR_DGV_DEVICE_MEMORY_FULL = @as(u32, 516);
pub const MCIERR_DGV_BAD_CLIPBOARD_RANGE = @as(u32, 517);
pub const MCI_DGV_METHOD_PRE = @as(i32, 40960);
pub const MCI_DGV_METHOD_POST = @as(i32, 40961);
pub const MCI_DGV_METHOD_DIRECT = @as(i32, 40962);
pub const MCI_DGV_FF_AVSS = @as(i32, 16384);
pub const MCI_DGV_FF_AVI = @as(i32, 16385);
pub const MCI_DGV_FF_DIB = @as(i32, 16386);
pub const MCI_DGV_FF_RDIB = @as(i32, 16387);
pub const MCI_DGV_FF_JPEG = @as(i32, 16388);
pub const MCI_DGV_FF_RJPEG = @as(i32, 16389);
pub const MCI_DGV_FF_JFIF = @as(i32, 16390);
pub const MCI_DGV_FF_MPEG = @as(i32, 16391);
pub const MCI_DGV_GETDEVCAPS_CAN_LOCK = @as(i32, 16384);
pub const MCI_DGV_GETDEVCAPS_CAN_STRETCH = @as(i32, 16385);
pub const MCI_DGV_GETDEVCAPS_CAN_FREEZE = @as(i32, 16386);
pub const MCI_DGV_GETDEVCAPS_MAX_WINDOWS = @as(i32, 16387);
pub const MCI_DGV_GETDEVCAPS_CAN_REVERSE = @as(i32, 16388);
pub const MCI_DGV_GETDEVCAPS_HAS_STILL = @as(i32, 16389);
pub const MCI_DGV_GETDEVCAPS_PALETTES = @as(i32, 16390);
pub const MCI_DGV_GETDEVCAPS_CAN_STR_IN = @as(i32, 16392);
pub const MCI_DGV_GETDEVCAPS_CAN_TEST = @as(i32, 16393);
pub const MCI_DGV_GETDEVCAPS_MAXIMUM_RATE = @as(i32, 16394);
pub const MCI_DGV_GETDEVCAPS_MINIMUM_RATE = @as(i32, 16395);
pub const MCI_DGV_CAPTURE_AS = @as(i32, 65536);
pub const MCI_DGV_CAPTURE_AT = @as(i32, 131072);
pub const MCI_DGV_COPY_AT = @as(i32, 65536);
pub const MCI_DGV_COPY_AUDIO_STREAM = @as(i32, 131072);
pub const MCI_DGV_COPY_VIDEO_STREAM = @as(i32, 262144);
pub const MCI_DGV_CUE_INPUT = @as(i32, 65536);
pub const MCI_DGV_CUE_OUTPUT = @as(i32, 131072);
pub const MCI_DGV_CUE_NOSHOW = @as(i32, 262144);
pub const MCI_DGV_CUT_AT = @as(i32, 65536);
pub const MCI_DGV_CUT_AUDIO_STREAM = @as(i32, 131072);
pub const MCI_DGV_CUT_VIDEO_STREAM = @as(i32, 262144);
pub const MCI_DGV_DELETE_AT = @as(i32, 65536);
pub const MCI_DGV_DELETE_AUDIO_STREAM = @as(i32, 131072);
pub const MCI_DGV_DELETE_VIDEO_STREAM = @as(i32, 262144);
pub const MCI_DGV_FREEZE_AT = @as(i32, 65536);
pub const MCI_DGV_FREEZE_OUTSIDE = @as(i32, 131072);
pub const MCI_DGV_INFO_TEXT = @as(i32, 65536);
pub const MCI_DGV_INFO_ITEM = @as(i32, 131072);
pub const MCI_INFO_VERSION = @as(i32, 1024);
pub const MCI_DGV_INFO_USAGE = @as(i32, 16384);
pub const MCI_DGV_INFO_AUDIO_QUALITY = @as(i32, 16385);
pub const MCI_DGV_INFO_STILL_QUALITY = @as(i32, 16386);
pub const MCI_DGV_INFO_VIDEO_QUALITY = @as(i32, 16387);
pub const MCI_DGV_INFO_AUDIO_ALG = @as(i32, 16388);
pub const MCI_DGV_INFO_STILL_ALG = @as(i32, 16389);
pub const MCI_DGV_INFO_VIDEO_ALG = @as(i32, 16390);
pub const MCI_DGV_LIST_ITEM = @as(i32, 65536);
pub const MCI_DGV_LIST_COUNT = @as(i32, 131072);
pub const MCI_DGV_LIST_NUMBER = @as(i32, 262144);
pub const MCI_DGV_LIST_ALG = @as(i32, 524288);
pub const MCI_DGV_LIST_AUDIO_ALG = @as(i32, 16384);
pub const MCI_DGV_LIST_AUDIO_QUALITY = @as(i32, 16385);
pub const MCI_DGV_LIST_AUDIO_STREAM = @as(i32, 16386);
pub const MCI_DGV_LIST_STILL_ALG = @as(i32, 16387);
pub const MCI_DGV_LIST_STILL_QUALITY = @as(i32, 16388);
pub const MCI_DGV_LIST_VIDEO_ALG = @as(i32, 16389);
pub const MCI_DGV_LIST_VIDEO_QUALITY = @as(i32, 16390);
pub const MCI_DGV_LIST_VIDEO_STREAM = @as(i32, 16391);
pub const MCI_DGV_LIST_VIDEO_SOURCE = @as(i32, 16392);
pub const MCI_DGV_MONITOR_METHOD = @as(i32, 65536);
pub const MCI_DGV_MONITOR_SOURCE = @as(i32, 131072);
pub const MCI_DGV_MONITOR_INPUT = @as(i32, 16384);
pub const MCI_DGV_MONITOR_FILE = @as(i32, 16385);
pub const MCI_DGV_OPEN_WS = @as(i32, 65536);
pub const MCI_DGV_OPEN_PARENT = @as(i32, 131072);
pub const MCI_DGV_OPEN_NOSTATIC = @as(i32, 262144);
pub const MCI_DGV_OPEN_16BIT = @as(i32, 524288);
pub const MCI_DGV_OPEN_32BIT = @as(i32, 1048576);
pub const MCI_DGV_PASTE_AT = @as(i32, 65536);
pub const MCI_DGV_PASTE_AUDIO_STREAM = @as(i32, 131072);
pub const MCI_DGV_PASTE_VIDEO_STREAM = @as(i32, 262144);
pub const MCI_DGV_PASTE_INSERT = @as(i32, 524288);
pub const MCI_DGV_PASTE_OVERWRITE = @as(i32, 1048576);
pub const MCI_DGV_PLAY_REPEAT = @as(i32, 65536);
pub const MCI_DGV_PLAY_REVERSE = @as(i32, 131072);
pub const MCI_DGV_RECT = @as(i32, 65536);
pub const MCI_DGV_PUT_SOURCE = @as(i32, 131072);
pub const MCI_DGV_PUT_DESTINATION = @as(i32, 262144);
pub const MCI_DGV_PUT_FRAME = @as(i32, 524288);
pub const MCI_DGV_PUT_VIDEO = @as(i32, 1048576);
pub const MCI_DGV_PUT_WINDOW = @as(i32, 2097152);
pub const MCI_DGV_PUT_CLIENT = @as(i32, 4194304);
pub const MCI_QUALITY_ITEM = @as(i32, 65536);
pub const MCI_QUALITY_NAME = @as(i32, 131072);
pub const MCI_QUALITY_ALG = @as(i32, 262144);
pub const MCI_QUALITY_DIALOG = @as(i32, 524288);
pub const MCI_QUALITY_HANDLE = @as(i32, 1048576);
pub const MCI_QUALITY_ITEM_AUDIO = @as(i32, 16384);
pub const MCI_QUALITY_ITEM_STILL = @as(i32, 16385);
pub const MCI_QUALITY_ITEM_VIDEO = @as(i32, 16386);
pub const MCI_DGV_REALIZE_NORM = @as(i32, 65536);
pub const MCI_DGV_REALIZE_BKGD = @as(i32, 131072);
pub const MCI_DGV_RECORD_HOLD = @as(i32, 131072);
pub const MCI_DGV_RECORD_AUDIO_STREAM = @as(i32, 262144);
pub const MCI_DGV_RECORD_VIDEO_STREAM = @as(i32, 524288);
pub const MCI_DGV_RESERVE_IN = @as(i32, 65536);
pub const MCI_DGV_RESERVE_SIZE = @as(i32, 131072);
pub const MCI_DGV_RESTORE_FROM = @as(i32, 65536);
pub const MCI_DGV_RESTORE_AT = @as(i32, 131072);
pub const MCI_DGV_SAVE_ABORT = @as(i32, 131072);
pub const MCI_DGV_SAVE_KEEPRESERVE = @as(i32, 262144);
pub const MCI_DGV_SET_SEEK_EXACTLY = @as(i32, 65536);
pub const MCI_DGV_SET_SPEED = @as(i32, 131072);
pub const MCI_DGV_SET_STILL = @as(i32, 262144);
pub const MCI_DGV_SET_FILEFORMAT = @as(i32, 524288);
pub const MCI_DGV_SETAUDIO_OVER = @as(i32, 65536);
pub const MCI_DGV_SETAUDIO_CLOCKTIME = @as(i32, 131072);
pub const MCI_DGV_SETAUDIO_ALG = @as(i32, 262144);
pub const MCI_DGV_SETAUDIO_QUALITY = @as(i32, 524288);
pub const MCI_DGV_SETAUDIO_RECORD = @as(i32, 1048576);
pub const MCI_DGV_SETAUDIO_LEFT = @as(i32, 2097152);
pub const MCI_DGV_SETAUDIO_RIGHT = @as(i32, 4194304);
pub const MCI_DGV_SETAUDIO_ITEM = @as(i32, 8388608);
pub const MCI_DGV_SETAUDIO_VALUE = @as(i32, 16777216);
pub const MCI_DGV_SETAUDIO_INPUT = @as(i32, 33554432);
pub const MCI_DGV_SETAUDIO_OUTPUT = @as(i32, 67108864);
pub const MCI_DGV_SETAUDIO_TREBLE = @as(i32, 16384);
pub const MCI_DGV_SETAUDIO_BASS = @as(i32, 16385);
pub const MCI_DGV_SETAUDIO_VOLUME = @as(i32, 16386);
pub const MCI_DGV_SETAUDIO_STREAM = @as(i32, 16387);
pub const MCI_DGV_SETAUDIO_SOURCE = @as(i32, 16388);
pub const MCI_DGV_SETAUDIO_SAMPLESPERSEC = @as(i32, 16389);
pub const MCI_DGV_SETAUDIO_AVGBYTESPERSEC = @as(i32, 16390);
pub const MCI_DGV_SETAUDIO_BLOCKALIGN = @as(i32, 16391);
pub const MCI_DGV_SETAUDIO_BITSPERSAMPLE = @as(i32, 16392);
pub const MCI_DGV_SETAUDIO_SOURCE_STEREO = @as(i32, 0);
pub const MCI_DGV_SETAUDIO_SOURCE_LEFT = @as(i32, 1);
pub const MCI_DGV_SETAUDIO_SOURCE_RIGHT = @as(i32, 2);
pub const MCI_DGV_SETAUDIO_SOURCE_AVERAGE = @as(i32, 16384);
pub const MCI_DGV_SETVIDEO_QUALITY = @as(i32, 65536);
pub const MCI_DGV_SETVIDEO_ALG = @as(i32, 131072);
pub const MCI_DGV_SETVIDEO_CLOCKTIME = @as(i32, 262144);
pub const MCI_DGV_SETVIDEO_SRC_NUMBER = @as(i32, 524288);
pub const MCI_DGV_SETVIDEO_ITEM = @as(i32, 1048576);
pub const MCI_DGV_SETVIDEO_OVER = @as(i32, 2097152);
pub const MCI_DGV_SETVIDEO_RECORD = @as(i32, 4194304);
pub const MCI_DGV_SETVIDEO_STILL = @as(i32, 8388608);
pub const MCI_DGV_SETVIDEO_VALUE = @as(i32, 16777216);
pub const MCI_DGV_SETVIDEO_INPUT = @as(i32, 33554432);
pub const MCI_DGV_SETVIDEO_OUTPUT = @as(i32, 67108864);
pub const MCI_DGV_SETVIDEO_SRC_NTSC = @as(i32, 16384);
pub const MCI_DGV_SETVIDEO_SRC_RGB = @as(i32, 16385);
pub const MCI_DGV_SETVIDEO_SRC_SVIDEO = @as(i32, 16386);
pub const MCI_DGV_SETVIDEO_SRC_PAL = @as(i32, 16387);
pub const MCI_DGV_SETVIDEO_SRC_SECAM = @as(i32, 16388);
pub const MCI_DGV_SETVIDEO_SRC_GENERIC = @as(i32, 16389);
pub const MCI_DGV_SETVIDEO_BRIGHTNESS = @as(i32, 16384);
pub const MCI_DGV_SETVIDEO_COLOR = @as(i32, 16385);
pub const MCI_DGV_SETVIDEO_CONTRAST = @as(i32, 16386);
pub const MCI_DGV_SETVIDEO_TINT = @as(i32, 16387);
pub const MCI_DGV_SETVIDEO_SHARPNESS = @as(i32, 16388);
pub const MCI_DGV_SETVIDEO_GAMMA = @as(i32, 16389);
pub const MCI_DGV_SETVIDEO_STREAM = @as(i32, 16390);
pub const MCI_DGV_SETVIDEO_PALHANDLE = @as(i32, 16391);
pub const MCI_DGV_SETVIDEO_FRAME_RATE = @as(i32, 16392);
pub const MCI_DGV_SETVIDEO_SOURCE = @as(i32, 16393);
pub const MCI_DGV_SETVIDEO_KEY_INDEX = @as(i32, 16394);
pub const MCI_DGV_SETVIDEO_KEY_COLOR = @as(i32, 16395);
pub const MCI_DGV_SETVIDEO_BITSPERPEL = @as(i32, 16396);
pub const MCI_DGV_SIGNAL_AT = @as(i32, 65536);
pub const MCI_DGV_SIGNAL_EVERY = @as(i32, 131072);
pub const MCI_DGV_SIGNAL_USERVAL = @as(i32, 262144);
pub const MCI_DGV_SIGNAL_CANCEL = @as(i32, 524288);
pub const MCI_DGV_SIGNAL_POSITION = @as(i32, 1048576);
pub const MCI_DGV_STATUS_NOMINAL = @as(i32, 131072);
pub const MCI_DGV_STATUS_REFERENCE = @as(i32, 262144);
pub const MCI_DGV_STATUS_LEFT = @as(i32, 524288);
pub const MCI_DGV_STATUS_RIGHT = @as(i32, 1048576);
pub const MCI_DGV_STATUS_DISKSPACE = @as(i32, 2097152);
pub const MCI_DGV_STATUS_INPUT = @as(i32, 4194304);
pub const MCI_DGV_STATUS_OUTPUT = @as(i32, 8388608);
pub const MCI_DGV_STATUS_RECORD = @as(i32, 16777216);
pub const MCI_DGV_STATUS_AUDIO_INPUT = @as(i32, 16384);
pub const MCI_DGV_STATUS_HWND = @as(i32, 16385);
pub const MCI_DGV_STATUS_SPEED = @as(i32, 16387);
pub const MCI_DGV_STATUS_HPAL = @as(i32, 16388);
pub const MCI_DGV_STATUS_BRIGHTNESS = @as(i32, 16389);
pub const MCI_DGV_STATUS_COLOR = @as(i32, 16390);
pub const MCI_DGV_STATUS_CONTRAST = @as(i32, 16391);
pub const MCI_DGV_STATUS_FILEFORMAT = @as(i32, 16392);
pub const MCI_DGV_STATUS_AUDIO_SOURCE = @as(i32, 16393);
pub const MCI_DGV_STATUS_GAMMA = @as(i32, 16394);
pub const MCI_DGV_STATUS_MONITOR = @as(i32, 16395);
pub const MCI_DGV_STATUS_MONITOR_METHOD = @as(i32, 16396);
pub const MCI_DGV_STATUS_FRAME_RATE = @as(i32, 16398);
pub const MCI_DGV_STATUS_BASS = @as(i32, 16399);
pub const MCI_DGV_STATUS_SIZE = @as(i32, 16400);
pub const MCI_DGV_STATUS_SEEK_EXACTLY = @as(i32, 16401);
pub const MCI_DGV_STATUS_SHARPNESS = @as(i32, 16402);
pub const MCI_DGV_STATUS_SMPTE = @as(i32, 16403);
pub const MCI_DGV_STATUS_AUDIO = @as(i32, 16404);
pub const MCI_DGV_STATUS_TINT = @as(i32, 16405);
pub const MCI_DGV_STATUS_TREBLE = @as(i32, 16406);
pub const MCI_DGV_STATUS_UNSAVED = @as(i32, 16407);
pub const MCI_DGV_STATUS_VIDEO = @as(i32, 16408);
pub const MCI_DGV_STATUS_VOLUME = @as(i32, 16409);
pub const MCI_DGV_STATUS_AUDIO_RECORD = @as(i32, 16410);
pub const MCI_DGV_STATUS_VIDEO_SOURCE = @as(i32, 16411);
pub const MCI_DGV_STATUS_VIDEO_RECORD = @as(i32, 16412);
pub const MCI_DGV_STATUS_STILL_FILEFORMAT = @as(i32, 16413);
pub const MCI_DGV_STATUS_VIDEO_SRC_NUM = @as(i32, 16414);
pub const MCI_DGV_STATUS_FILE_MODE = @as(i32, 16415);
pub const MCI_DGV_STATUS_FILE_COMPLETION = @as(i32, 16416);
pub const MCI_DGV_STATUS_WINDOW_VISIBLE = @as(i32, 16417);
pub const MCI_DGV_STATUS_WINDOW_MINIMIZED = @as(i32, 16418);
pub const MCI_DGV_STATUS_WINDOW_MAXIMIZED = @as(i32, 16419);
pub const MCI_DGV_STATUS_KEY_INDEX = @as(i32, 16420);
pub const MCI_DGV_STATUS_KEY_COLOR = @as(i32, 16421);
pub const MCI_DGV_STATUS_PAUSE_MODE = @as(i32, 16422);
pub const MCI_DGV_STATUS_SAMPLESPERSEC = @as(i32, 16423);
pub const MCI_DGV_STATUS_AVGBYTESPERSEC = @as(i32, 16424);
pub const MCI_DGV_STATUS_BLOCKALIGN = @as(i32, 16425);
pub const MCI_DGV_STATUS_BITSPERSAMPLE = @as(i32, 16426);
pub const MCI_DGV_STATUS_BITSPERPEL = @as(i32, 16427);
pub const MCI_DGV_STATUS_FORWARD = @as(i32, 16428);
pub const MCI_DGV_STATUS_AUDIO_STREAM = @as(i32, 16429);
pub const MCI_DGV_STATUS_VIDEO_STREAM = @as(i32, 16430);
pub const MCI_DGV_STEP_REVERSE = @as(i32, 65536);
pub const MCI_DGV_STEP_FRAMES = @as(i32, 131072);
pub const MCI_DGV_STOP_HOLD = @as(i32, 65536);
pub const MCI_DGV_UPDATE_HDC = @as(i32, 131072);
pub const MCI_DGV_UPDATE_PAINT = @as(i32, 262144);
pub const MCI_DGV_WHERE_SOURCE = @as(i32, 131072);
pub const MCI_DGV_WHERE_DESTINATION = @as(i32, 262144);
pub const MCI_DGV_WHERE_FRAME = @as(i32, 524288);
pub const MCI_DGV_WHERE_VIDEO = @as(i32, 1048576);
pub const MCI_DGV_WHERE_WINDOW = @as(i32, 2097152);
pub const MCI_DGV_WHERE_MAX = @as(i32, 4194304);
pub const MCI_DGV_WINDOW_HWND = @as(i32, 65536);
pub const MCI_DGV_WINDOW_STATE = @as(i32, 262144);
pub const MCI_DGV_WINDOW_TEXT = @as(i32, 524288);
pub const MCI_DGV_WINDOW_DEFAULT = @as(i32, 0);
pub const MM_MICROSOFT = @as(u32, 1);
pub const MM_CREATIVE = @as(u32, 2);
pub const MM_MEDIAVISION = @as(u32, 3);
pub const MM_FUJITSU = @as(u32, 4);
pub const MM_PRAGMATRAX = @as(u32, 5);
pub const MM_CYRIX = @as(u32, 6);
pub const MM_PHILIPS_SPEECH_PROCESSING = @as(u32, 7);
pub const MM_NETXL = @as(u32, 8);
pub const MM_ZYXEL = @as(u32, 9);
pub const MM_BECUBED = @as(u32, 10);
pub const MM_AARDVARK = @as(u32, 11);
pub const MM_BINTEC = @as(u32, 12);
pub const MM_HEWLETT_PACKARD = @as(u32, 13);
pub const MM_ACULAB = @as(u32, 14);
pub const MM_FAITH = @as(u32, 15);
pub const MM_MITEL = @as(u32, 16);
pub const MM_QUANTUM3D = @as(u32, 17);
pub const MM_SNI = @as(u32, 18);
pub const MM_EMU = @as(u32, 19);
pub const MM_ARTISOFT = @as(u32, 20);
pub const MM_TURTLE_BEACH = @as(u32, 21);
pub const MM_IBM = @as(u32, 22);
pub const MM_VOCALTEC = @as(u32, 23);
pub const MM_ROLAND = @as(u32, 24);
pub const MM_DSP_SOLUTIONS = @as(u32, 25);
pub const MM_NEC = @as(u32, 26);
pub const MM_ATI = @as(u32, 27);
pub const MM_WANGLABS = @as(u32, 28);
pub const MM_TANDY = @as(u32, 29);
pub const MM_VOYETRA = @as(u32, 30);
pub const MM_ANTEX = @as(u32, 31);
pub const MM_ICL_PS = @as(u32, 32);
pub const MM_INTEL = @as(u32, 33);
pub const MM_GRAVIS = @as(u32, 34);
pub const MM_VAL = @as(u32, 35);
pub const MM_INTERACTIVE = @as(u32, 36);
pub const MM_YAMAHA = @as(u32, 37);
pub const MM_EVEREX = @as(u32, 38);
pub const MM_ECHO = @as(u32, 39);
pub const MM_SIERRA = @as(u32, 40);
pub const MM_CAT = @as(u32, 41);
pub const MM_APPS = @as(u32, 42);
pub const MM_DSP_GROUP = @as(u32, 43);
pub const MM_MELABS = @as(u32, 44);
pub const MM_COMPUTER_FRIENDS = @as(u32, 45);
pub const MM_ESS = @as(u32, 46);
pub const MM_AUDIOFILE = @as(u32, 47);
pub const MM_MOTOROLA = @as(u32, 48);
pub const MM_CANOPUS = @as(u32, 49);
pub const MM_EPSON = @as(u32, 50);
pub const MM_TRUEVISION = @as(u32, 51);
pub const MM_AZTECH = @as(u32, 52);
pub const MM_VIDEOLOGIC = @as(u32, 53);
pub const MM_SCALACS = @as(u32, 54);
pub const MM_KORG = @as(u32, 55);
pub const MM_APT = @as(u32, 56);
pub const MM_ICS = @as(u32, 57);
pub const MM_ITERATEDSYS = @as(u32, 58);
pub const MM_METHEUS = @as(u32, 59);
pub const MM_LOGITECH = @as(u32, 60);
pub const MM_WINNOV = @as(u32, 61);
pub const MM_NCR = @as(u32, 62);
pub const MM_EXAN = @as(u32, 63);
pub const MM_AST = @as(u32, 64);
pub const MM_WILLOWPOND = @as(u32, 65);
pub const MM_SONICFOUNDRY = @as(u32, 66);
pub const MM_VITEC = @as(u32, 67);
pub const MM_MOSCOM = @as(u32, 68);
pub const MM_SILICONSOFT = @as(u32, 69);
pub const MM_TERRATEC = @as(u32, 70);
pub const MM_MEDIASONIC = @as(u32, 71);
pub const MM_SANYO = @as(u32, 72);
pub const MM_SUPERMAC = @as(u32, 73);
pub const MM_AUDIOPT = @as(u32, 74);
pub const MM_NOGATECH = @as(u32, 75);
pub const MM_SPEECHCOMP = @as(u32, 76);
pub const MM_AHEAD = @as(u32, 77);
pub const MM_DOLBY = @as(u32, 78);
pub const MM_OKI = @as(u32, 79);
pub const MM_AURAVISION = @as(u32, 80);
pub const MM_OLIVETTI = @as(u32, 81);
pub const MM_IOMAGIC = @as(u32, 82);
pub const MM_MATSUSHITA = @as(u32, 83);
pub const MM_CONTROLRES = @as(u32, 84);
pub const MM_XEBEC = @as(u32, 85);
pub const MM_NEWMEDIA = @as(u32, 86);
pub const MM_NMS = @as(u32, 87);
pub const MM_LYRRUS = @as(u32, 88);
pub const MM_COMPUSIC = @as(u32, 89);
pub const MM_OPTI = @as(u32, 90);
pub const MM_ADLACC = @as(u32, 91);
pub const MM_COMPAQ = @as(u32, 92);
pub const MM_DIALOGIC = @as(u32, 93);
pub const MM_INSOFT = @as(u32, 94);
pub const MM_MPTUS = @as(u32, 95);
pub const MM_WEITEK = @as(u32, 96);
pub const MM_LERNOUT_AND_HAUSPIE = @as(u32, 97);
pub const MM_QCIAR = @as(u32, 98);
pub const MM_APPLE = @as(u32, 99);
pub const MM_DIGITAL = @as(u32, 100);
pub const MM_MOTU = @as(u32, 101);
pub const MM_WORKBIT = @as(u32, 102);
pub const MM_OSITECH = @as(u32, 103);
pub const MM_MIRO = @as(u32, 104);
pub const MM_CIRRUSLOGIC = @as(u32, 105);
pub const MM_ISOLUTION = @as(u32, 106);
pub const MM_HORIZONS = @as(u32, 107);
pub const MM_CONCEPTS = @as(u32, 108);
pub const MM_VTG = @as(u32, 109);
pub const MM_RADIUS = @as(u32, 110);
pub const MM_ROCKWELL = @as(u32, 111);
pub const MM_XYZ = @as(u32, 112);
pub const MM_OPCODE = @as(u32, 113);
pub const MM_VOXWARE = @as(u32, 114);
pub const MM_NORTHERN_TELECOM = @as(u32, 115);
pub const MM_APICOM = @as(u32, 116);
pub const MM_GRANDE = @as(u32, 117);
pub const MM_ADDX = @as(u32, 118);
pub const MM_WILDCAT = @as(u32, 119);
pub const MM_RHETOREX = @as(u32, 120);
pub const MM_BROOKTREE = @as(u32, 121);
pub const MM_ENSONIQ = @as(u32, 125);
pub const MM_FAST = @as(u32, 126);
pub const MM_NVIDIA = @as(u32, 127);
pub const MM_OKSORI = @as(u32, 128);
pub const MM_DIACOUSTICS = @as(u32, 129);
pub const MM_GULBRANSEN = @as(u32, 130);
pub const MM_KAY_ELEMETRICS = @as(u32, 131);
pub const MM_CRYSTAL = @as(u32, 132);
pub const MM_SPLASH_STUDIOS = @as(u32, 133);
pub const MM_QUARTERDECK = @as(u32, 134);
pub const MM_TDK = @as(u32, 135);
pub const MM_DIGITAL_AUDIO_LABS = @as(u32, 136);
pub const MM_SEERSYS = @as(u32, 137);
pub const MM_PICTURETEL = @as(u32, 138);
pub const MM_ATT_MICROELECTRONICS = @as(u32, 139);
pub const MM_OSPREY = @as(u32, 140);
pub const MM_MEDIATRIX = @as(u32, 141);
pub const MM_SOUNDESIGNS = @as(u32, 142);
pub const MM_ALDIGITAL = @as(u32, 143);
pub const MM_SPECTRUM_SIGNAL_PROCESSING = @as(u32, 144);
pub const MM_ECS = @as(u32, 145);
pub const MM_AMD = @as(u32, 146);
pub const MM_COREDYNAMICS = @as(u32, 147);
pub const MM_CANAM = @as(u32, 148);
pub const MM_SOFTSOUND = @as(u32, 149);
pub const MM_NORRIS = @as(u32, 150);
pub const MM_DDD = @as(u32, 151);
pub const MM_EUPHONICS = @as(u32, 152);
pub const MM_PRECEPT = @as(u32, 153);
pub const MM_CRYSTAL_NET = @as(u32, 154);
pub const MM_CHROMATIC = @as(u32, 155);
pub const MM_VOICEINFO = @as(u32, 156);
pub const MM_VIENNASYS = @as(u32, 157);
pub const MM_CONNECTIX = @as(u32, 158);
pub const MM_GADGETLABS = @as(u32, 159);
pub const MM_FRONTIER = @as(u32, 160);
pub const MM_VIONA = @as(u32, 161);
pub const MM_CASIO = @as(u32, 162);
pub const MM_DIAMONDMM = @as(u32, 163);
pub const MM_S3 = @as(u32, 164);
pub const MM_DVISION = @as(u32, 165);
pub const MM_NETSCAPE = @as(u32, 166);
pub const MM_SOUNDSPACE = @as(u32, 167);
pub const MM_VANKOEVERING = @as(u32, 168);
pub const MM_QTEAM = @as(u32, 169);
pub const MM_ZEFIRO = @as(u32, 170);
pub const MM_STUDER = @as(u32, 171);
pub const MM_FRAUNHOFER_IIS = @as(u32, 172);
pub const MM_QUICKNET = @as(u32, 173);
pub const MM_ALARIS = @as(u32, 174);
pub const MM_SICRESOURCE = @as(u32, 175);
pub const MM_NEOMAGIC = @as(u32, 176);
pub const MM_MERGING_TECHNOLOGIES = @as(u32, 177);
pub const MM_XIRLINK = @as(u32, 178);
pub const MM_COLORGRAPH = @as(u32, 179);
pub const MM_OTI = @as(u32, 180);
pub const MM_AUREAL = @as(u32, 181);
pub const MM_VIVO = @as(u32, 182);
pub const MM_SHARP = @as(u32, 183);
pub const MM_LUCENT = @as(u32, 184);
pub const MM_ATT = @as(u32, 185);
pub const MM_SUNCOM = @as(u32, 186);
pub const MM_SORVIS = @as(u32, 187);
pub const MM_INVISION = @as(u32, 188);
pub const MM_BERKOM = @as(u32, 189);
pub const MM_MARIAN = @as(u32, 190);
pub const MM_DPSINC = @as(u32, 191);
pub const MM_BCB = @as(u32, 192);
pub const MM_MOTIONPIXELS = @as(u32, 193);
pub const MM_QDESIGN = @as(u32, 194);
pub const MM_NMP = @as(u32, 195);
pub const MM_DATAFUSION = @as(u32, 196);
pub const MM_DUCK = @as(u32, 197);
pub const MM_FTR = @as(u32, 198);
pub const MM_BERCOS = @as(u32, 199);
pub const MM_ONLIVE = @as(u32, 200);
pub const MM_SIEMENS_SBC = @as(u32, 201);
pub const MM_TERALOGIC = @as(u32, 202);
pub const MM_PHONET = @as(u32, 203);
pub const MM_WINBOND = @as(u32, 204);
pub const MM_VIRTUALMUSIC = @as(u32, 205);
pub const MM_ENET = @as(u32, 206);
pub const MM_GUILLEMOT = @as(u32, 207);
pub const MM_EMAGIC = @as(u32, 208);
pub const MM_MWM = @as(u32, 209);
pub const MM_PACIFICRESEARCH = @as(u32, 210);
pub const MM_SIPROLAB = @as(u32, 211);
pub const MM_LYNX = @as(u32, 212);
pub const MM_SPECTRUM_PRODUCTIONS = @as(u32, 213);
pub const MM_DICTAPHONE = @as(u32, 214);
pub const MM_QUALCOMM = @as(u32, 215);
pub const MM_RZS = @as(u32, 216);
pub const MM_AUDIOSCIENCE = @as(u32, 217);
pub const MM_PINNACLE = @as(u32, 218);
pub const MM_EES = @as(u32, 219);
pub const MM_HAFTMANN = @as(u32, 220);
pub const MM_LUCID = @as(u32, 221);
pub const MM_HEADSPACE = @as(u32, 222);
pub const MM_UNISYS = @as(u32, 223);
pub const MM_LUMINOSITI = @as(u32, 224);
pub const MM_ACTIVEVOICE = @as(u32, 225);
pub const MM_DTS = @as(u32, 226);
pub const MM_DIGIGRAM = @as(u32, 227);
pub const MM_SOFTLAB_NSK = @as(u32, 228);
pub const MM_FORTEMEDIA = @as(u32, 229);
pub const MM_SONORUS = @as(u32, 230);
pub const MM_ARRAY = @as(u32, 231);
pub const MM_DATARAN = @as(u32, 232);
pub const MM_I_LINK = @as(u32, 233);
pub const MM_SELSIUS_SYSTEMS = @as(u32, 234);
pub const MM_ADMOS = @as(u32, 235);
pub const MM_LEXICON = @as(u32, 236);
pub const MM_SGI = @as(u32, 237);
pub const MM_IPI = @as(u32, 238);
pub const MM_ICE = @as(u32, 239);
pub const MM_VQST = @as(u32, 240);
pub const MM_ETEK = @as(u32, 241);
pub const MM_CS = @as(u32, 242);
pub const MM_ALESIS = @as(u32, 243);
pub const MM_INTERNET = @as(u32, 244);
pub const MM_SONY = @as(u32, 245);
pub const MM_HYPERACTIVE = @as(u32, 246);
pub const MM_UHER_INFORMATIC = @as(u32, 247);
pub const MM_SYDEC_NV = @as(u32, 248);
pub const MM_FLEXION = @as(u32, 249);
pub const MM_VIA = @as(u32, 250);
pub const MM_MICRONAS = @as(u32, 251);
pub const MM_ANALOGDEVICES = @as(u32, 252);
pub const MM_HP = @as(u32, 253);
pub const MM_MATROX_DIV = @as(u32, 254);
pub const MM_QUICKAUDIO = @as(u32, 255);
pub const MM_YOUCOM = @as(u32, 256);
pub const MM_RICHMOND = @as(u32, 257);
pub const MM_IODD = @as(u32, 258);
pub const MM_ICCC = @as(u32, 259);
pub const MM_3COM = @as(u32, 260);
pub const MM_MALDEN = @as(u32, 261);
pub const MM_3DFX = @as(u32, 262);
pub const MM_MINDMAKER = @as(u32, 263);
pub const MM_TELEKOL = @as(u32, 264);
pub const MM_ST_MICROELECTRONICS = @as(u32, 265);
pub const MM_ALGOVISION = @as(u32, 266);
pub const MM_UNMAPPED = @as(u32, 65535);
pub const MM_MIDI_MAPPER = @as(u32, 1);
pub const MM_WAVE_MAPPER = @as(u32, 2);
pub const MM_SNDBLST_MIDIOUT = @as(u32, 3);
pub const MM_SNDBLST_MIDIIN = @as(u32, 4);
pub const MM_SNDBLST_SYNTH = @as(u32, 5);
pub const MM_SNDBLST_WAVEOUT = @as(u32, 6);
pub const MM_SNDBLST_WAVEIN = @as(u32, 7);
pub const MM_ADLIB = @as(u32, 9);
pub const MM_MPU401_MIDIOUT = @as(u32, 10);
pub const MM_MPU401_MIDIIN = @as(u32, 11);
pub const MM_PC_JOYSTICK = @as(u32, 12);
pub const MM_PCSPEAKER_WAVEOUT = @as(u32, 13);
pub const MM_MSFT_WSS_WAVEIN = @as(u32, 14);
pub const MM_MSFT_WSS_WAVEOUT = @as(u32, 15);
pub const MM_MSFT_WSS_FMSYNTH_STEREO = @as(u32, 16);
pub const MM_MSFT_WSS_MIXER = @as(u32, 17);
pub const MM_MSFT_WSS_OEM_WAVEIN = @as(u32, 18);
pub const MM_MSFT_WSS_OEM_WAVEOUT = @as(u32, 19);
pub const MM_MSFT_WSS_OEM_FMSYNTH_STEREO = @as(u32, 20);
pub const MM_MSFT_WSS_AUX = @as(u32, 21);
pub const MM_MSFT_WSS_OEM_AUX = @as(u32, 22);
pub const MM_MSFT_GENERIC_WAVEIN = @as(u32, 23);
pub const MM_MSFT_GENERIC_WAVEOUT = @as(u32, 24);
pub const MM_MSFT_GENERIC_MIDIIN = @as(u32, 25);
pub const MM_MSFT_GENERIC_MIDIOUT = @as(u32, 26);
pub const MM_MSFT_GENERIC_MIDISYNTH = @as(u32, 27);
pub const MM_MSFT_GENERIC_AUX_LINE = @as(u32, 28);
pub const MM_MSFT_GENERIC_AUX_MIC = @as(u32, 29);
pub const MM_MSFT_GENERIC_AUX_CD = @as(u32, 30);
pub const MM_MSFT_WSS_OEM_MIXER = @as(u32, 31);
pub const MM_MSFT_MSACM = @as(u32, 32);
pub const MM_MSFT_ACM_MSADPCM = @as(u32, 33);
pub const MM_MSFT_ACM_IMAADPCM = @as(u32, 34);
pub const MM_MSFT_ACM_MSFILTER = @as(u32, 35);
pub const MM_MSFT_ACM_GSM610 = @as(u32, 36);
pub const MM_MSFT_ACM_G711 = @as(u32, 37);
pub const MM_MSFT_ACM_PCM = @as(u32, 38);
pub const MM_WSS_SB16_WAVEIN = @as(u32, 39);
pub const MM_WSS_SB16_WAVEOUT = @as(u32, 40);
pub const MM_WSS_SB16_MIDIIN = @as(u32, 41);
pub const MM_WSS_SB16_MIDIOUT = @as(u32, 42);
pub const MM_WSS_SB16_SYNTH = @as(u32, 43);
pub const MM_WSS_SB16_AUX_LINE = @as(u32, 44);
pub const MM_WSS_SB16_AUX_CD = @as(u32, 45);
pub const MM_WSS_SB16_MIXER = @as(u32, 46);
pub const MM_WSS_SBPRO_WAVEIN = @as(u32, 47);
pub const MM_WSS_SBPRO_WAVEOUT = @as(u32, 48);
pub const MM_WSS_SBPRO_MIDIIN = @as(u32, 49);
pub const MM_WSS_SBPRO_MIDIOUT = @as(u32, 50);
pub const MM_WSS_SBPRO_SYNTH = @as(u32, 51);
pub const MM_WSS_SBPRO_AUX_LINE = @as(u32, 52);
pub const MM_WSS_SBPRO_AUX_CD = @as(u32, 53);
pub const MM_WSS_SBPRO_MIXER = @as(u32, 54);
pub const MM_MSFT_WSS_NT_WAVEIN = @as(u32, 55);
pub const MM_MSFT_WSS_NT_WAVEOUT = @as(u32, 56);
pub const MM_MSFT_WSS_NT_FMSYNTH_STEREO = @as(u32, 57);
pub const MM_MSFT_WSS_NT_MIXER = @as(u32, 58);
pub const MM_MSFT_WSS_NT_AUX = @as(u32, 59);
pub const MM_MSFT_SB16_WAVEIN = @as(u32, 60);
pub const MM_MSFT_SB16_WAVEOUT = @as(u32, 61);
pub const MM_MSFT_SB16_MIDIIN = @as(u32, 62);
pub const MM_MSFT_SB16_MIDIOUT = @as(u32, 63);
pub const MM_MSFT_SB16_SYNTH = @as(u32, 64);
pub const MM_MSFT_SB16_AUX_LINE = @as(u32, 65);
pub const MM_MSFT_SB16_AUX_CD = @as(u32, 66);
pub const MM_MSFT_SB16_MIXER = @as(u32, 67);
pub const MM_MSFT_SBPRO_WAVEIN = @as(u32, 68);
pub const MM_MSFT_SBPRO_WAVEOUT = @as(u32, 69);
pub const MM_MSFT_SBPRO_MIDIIN = @as(u32, 70);
pub const MM_MSFT_SBPRO_MIDIOUT = @as(u32, 71);
pub const MM_MSFT_SBPRO_SYNTH = @as(u32, 72);
pub const MM_MSFT_SBPRO_AUX_LINE = @as(u32, 73);
pub const MM_MSFT_SBPRO_AUX_CD = @as(u32, 74);
pub const MM_MSFT_SBPRO_MIXER = @as(u32, 75);
pub const MM_MSFT_MSOPL_SYNTH = @as(u32, 76);
pub const MM_MSFT_VMDMS_LINE_WAVEIN = @as(u32, 80);
pub const MM_MSFT_VMDMS_LINE_WAVEOUT = @as(u32, 81);
pub const MM_MSFT_VMDMS_HANDSET_WAVEIN = @as(u32, 82);
pub const MM_MSFT_VMDMS_HANDSET_WAVEOUT = @as(u32, 83);
pub const MM_MSFT_VMDMW_LINE_WAVEIN = @as(u32, 84);
pub const MM_MSFT_VMDMW_LINE_WAVEOUT = @as(u32, 85);
pub const MM_MSFT_VMDMW_HANDSET_WAVEIN = @as(u32, 86);
pub const MM_MSFT_VMDMW_HANDSET_WAVEOUT = @as(u32, 87);
pub const MM_MSFT_VMDMW_MIXER = @as(u32, 88);
pub const MM_MSFT_VMDM_GAME_WAVEOUT = @as(u32, 89);
pub const MM_MSFT_VMDM_GAME_WAVEIN = @as(u32, 90);
pub const MM_MSFT_ACM_MSNAUDIO = @as(u32, 91);
pub const MM_MSFT_ACM_MSG723 = @as(u32, 92);
pub const MM_MSFT_ACM_MSRT24 = @as(u32, 93);
pub const MM_MSFT_WDMAUDIO_WAVEOUT = @as(u32, 100);
pub const MM_MSFT_WDMAUDIO_WAVEIN = @as(u32, 101);
pub const MM_MSFT_WDMAUDIO_MIDIOUT = @as(u32, 102);
pub const MM_MSFT_WDMAUDIO_MIDIIN = @as(u32, 103);
pub const MM_MSFT_WDMAUDIO_MIXER = @as(u32, 104);
pub const MM_MSFT_WDMAUDIO_AUX = @as(u32, 105);
pub const MM_CREATIVE_SB15_WAVEIN = @as(u32, 1);
pub const MM_CREATIVE_SB20_WAVEIN = @as(u32, 2);
pub const MM_CREATIVE_SBPRO_WAVEIN = @as(u32, 3);
pub const MM_CREATIVE_SBP16_WAVEIN = @as(u32, 4);
pub const MM_CREATIVE_PHNBLST_WAVEIN = @as(u32, 5);
pub const MM_CREATIVE_SB15_WAVEOUT = @as(u32, 101);
pub const MM_CREATIVE_SB20_WAVEOUT = @as(u32, 102);
pub const MM_CREATIVE_SBPRO_WAVEOUT = @as(u32, 103);
pub const MM_CREATIVE_SBP16_WAVEOUT = @as(u32, 104);
pub const MM_CREATIVE_PHNBLST_WAVEOUT = @as(u32, 105);
pub const MM_CREATIVE_MIDIOUT = @as(u32, 201);
pub const MM_CREATIVE_MIDIIN = @as(u32, 202);
pub const MM_CREATIVE_FMSYNTH_MONO = @as(u32, 301);
pub const MM_CREATIVE_FMSYNTH_STEREO = @as(u32, 302);
pub const MM_CREATIVE_MIDI_AWE32 = @as(u32, 303);
pub const MM_CREATIVE_AUX_CD = @as(u32, 401);
pub const MM_CREATIVE_AUX_LINE = @as(u32, 402);
pub const MM_CREATIVE_AUX_MIC = @as(u32, 403);
pub const MM_CREATIVE_AUX_MASTER = @as(u32, 404);
pub const MM_CREATIVE_AUX_PCSPK = @as(u32, 405);
pub const MM_CREATIVE_AUX_WAVE = @as(u32, 406);
pub const MM_CREATIVE_AUX_MIDI = @as(u32, 407);
pub const MM_CREATIVE_SBPRO_MIXER = @as(u32, 408);
pub const MM_CREATIVE_SB16_MIXER = @as(u32, 409);
pub const MM_MEDIAVISION_PROAUDIO = @as(u32, 16);
pub const MM_PROAUD_MIDIOUT = @as(u32, 17);
pub const MM_PROAUD_MIDIIN = @as(u32, 18);
pub const MM_PROAUD_SYNTH = @as(u32, 19);
pub const MM_PROAUD_WAVEOUT = @as(u32, 20);
pub const MM_PROAUD_WAVEIN = @as(u32, 21);
pub const MM_PROAUD_MIXER = @as(u32, 22);
pub const MM_PROAUD_AUX = @as(u32, 23);
pub const MM_MEDIAVISION_THUNDER = @as(u32, 32);
pub const MM_THUNDER_SYNTH = @as(u32, 35);
pub const MM_THUNDER_WAVEOUT = @as(u32, 36);
pub const MM_THUNDER_WAVEIN = @as(u32, 37);
pub const MM_THUNDER_AUX = @as(u32, 39);
pub const MM_MEDIAVISION_TPORT = @as(u32, 64);
pub const MM_TPORT_WAVEOUT = @as(u32, 65);
pub const MM_TPORT_WAVEIN = @as(u32, 66);
pub const MM_TPORT_SYNTH = @as(u32, 67);
pub const MM_MEDIAVISION_PROAUDIO_PLUS = @as(u32, 80);
pub const MM_PROAUD_PLUS_MIDIOUT = @as(u32, 81);
pub const MM_PROAUD_PLUS_MIDIIN = @as(u32, 82);
pub const MM_PROAUD_PLUS_SYNTH = @as(u32, 83);
pub const MM_PROAUD_PLUS_WAVEOUT = @as(u32, 84);
pub const MM_PROAUD_PLUS_WAVEIN = @as(u32, 85);
pub const MM_PROAUD_PLUS_MIXER = @as(u32, 86);
pub const MM_PROAUD_PLUS_AUX = @as(u32, 87);
pub const MM_MEDIAVISION_PROAUDIO_16 = @as(u32, 96);
pub const MM_PROAUD_16_MIDIOUT = @as(u32, 97);
pub const MM_PROAUD_16_MIDIIN = @as(u32, 98);
pub const MM_PROAUD_16_SYNTH = @as(u32, 99);
pub const MM_PROAUD_16_WAVEOUT = @as(u32, 100);
pub const MM_PROAUD_16_WAVEIN = @as(u32, 101);
pub const MM_PROAUD_16_MIXER = @as(u32, 102);
pub const MM_PROAUD_16_AUX = @as(u32, 103);
pub const MM_MEDIAVISION_PROSTUDIO_16 = @as(u32, 96);
pub const MM_STUDIO_16_MIDIOUT = @as(u32, 97);
pub const MM_STUDIO_16_MIDIIN = @as(u32, 98);
pub const MM_STUDIO_16_SYNTH = @as(u32, 99);
pub const MM_STUDIO_16_WAVEOUT = @as(u32, 100);
pub const MM_STUDIO_16_WAVEIN = @as(u32, 101);
pub const MM_STUDIO_16_MIXER = @as(u32, 102);
pub const MM_STUDIO_16_AUX = @as(u32, 103);
pub const MM_MEDIAVISION_CDPC = @as(u32, 112);
pub const MM_CDPC_MIDIOUT = @as(u32, 113);
pub const MM_CDPC_MIDIIN = @as(u32, 114);
pub const MM_CDPC_SYNTH = @as(u32, 115);
pub const MM_CDPC_WAVEOUT = @as(u32, 116);
pub const MM_CDPC_WAVEIN = @as(u32, 117);
pub const MM_CDPC_MIXER = @as(u32, 118);
pub const MM_CDPC_AUX = @as(u32, 119);
pub const MM_MEDIAVISION_OPUS1208 = @as(u32, 128);
pub const MM_OPUS401_MIDIOUT = @as(u32, 129);
pub const MM_OPUS401_MIDIIN = @as(u32, 130);
pub const MM_OPUS1208_SYNTH = @as(u32, 131);
pub const MM_OPUS1208_WAVEOUT = @as(u32, 132);
pub const MM_OPUS1208_WAVEIN = @as(u32, 133);
pub const MM_OPUS1208_MIXER = @as(u32, 134);
pub const MM_OPUS1208_AUX = @as(u32, 135);
pub const MM_MEDIAVISION_OPUS1216 = @as(u32, 144);
pub const MM_OPUS1216_MIDIOUT = @as(u32, 145);
pub const MM_OPUS1216_MIDIIN = @as(u32, 146);
pub const MM_OPUS1216_SYNTH = @as(u32, 147);
pub const MM_OPUS1216_WAVEOUT = @as(u32, 148);
pub const MM_OPUS1216_WAVEIN = @as(u32, 149);
pub const MM_OPUS1216_MIXER = @as(u32, 150);
pub const MM_OPUS1216_AUX = @as(u32, 151);
pub const MM_CYRIX_XASYNTH = @as(u32, 1);
pub const MM_CYRIX_XAMIDIIN = @as(u32, 2);
pub const MM_CYRIX_XAMIDIOUT = @as(u32, 3);
pub const MM_CYRIX_XAWAVEIN = @as(u32, 4);
pub const MM_CYRIX_XAWAVEOUT = @as(u32, 5);
pub const MM_CYRIX_XAAUX = @as(u32, 6);
pub const MM_CYRIX_XAMIXER = @as(u32, 7);
pub const MM_PHILIPS_ACM_LPCBB = @as(u32, 1);
pub const MM_NETXL_XLVIDEO = @as(u32, 1);
pub const MM_ZYXEL_ACM_ADPCM = @as(u32, 1);
pub const MM_AARDVARK_STUDIO12_WAVEOUT = @as(u32, 1);
pub const MM_AARDVARK_STUDIO12_WAVEIN = @as(u32, 2);
pub const MM_AARDVARK_STUDIO88_WAVEOUT = @as(u32, 3);
pub const MM_AARDVARK_STUDIO88_WAVEIN = @as(u32, 4);
pub const MM_BINTEC_TAPI_WAVE = @as(u32, 1);
pub const MM_HEWLETT_PACKARD_CU_CODEC = @as(u32, 1);
pub const MM_MITEL_TALKTO_LINE_WAVEOUT = @as(u32, 100);
pub const MM_MITEL_TALKTO_LINE_WAVEIN = @as(u32, 101);
pub const MM_MITEL_TALKTO_HANDSET_WAVEOUT = @as(u32, 102);
pub const MM_MITEL_TALKTO_HANDSET_WAVEIN = @as(u32, 103);
pub const MM_MITEL_TALKTO_BRIDGED_WAVEOUT = @as(u32, 104);
pub const MM_MITEL_TALKTO_BRIDGED_WAVEIN = @as(u32, 105);
pub const MM_MITEL_MPA_HANDSET_WAVEOUT = @as(u32, 200);
pub const MM_MITEL_MPA_HANDSET_WAVEIN = @as(u32, 201);
pub const MM_MITEL_MPA_HANDSFREE_WAVEOUT = @as(u32, 202);
pub const MM_MITEL_MPA_HANDSFREE_WAVEIN = @as(u32, 203);
pub const MM_MITEL_MPA_LINE1_WAVEOUT = @as(u32, 204);
pub const MM_MITEL_MPA_LINE1_WAVEIN = @as(u32, 205);
pub const MM_MITEL_MPA_LINE2_WAVEOUT = @as(u32, 206);
pub const MM_MITEL_MPA_LINE2_WAVEIN = @as(u32, 207);
pub const MM_MITEL_MEDIAPATH_WAVEOUT = @as(u32, 300);
pub const MM_MITEL_MEDIAPATH_WAVEIN = @as(u32, 301);
pub const MM_SNI_ACM_G721 = @as(u32, 1);
pub const MM_EMU_APSSYNTH = @as(u32, 1);
pub const MM_EMU_APSMIDIIN = @as(u32, 2);
pub const MM_EMU_APSMIDIOUT = @as(u32, 3);
pub const MM_EMU_APSWAVEIN = @as(u32, 4);
pub const MM_EMU_APSWAVEOUT = @as(u32, 5);
pub const MM_ARTISOFT_SBWAVEIN = @as(u32, 1);
pub const MM_ARTISOFT_SBWAVEOUT = @as(u32, 2);
pub const MM_TBS_TROPEZ_WAVEIN = @as(u32, 37);
pub const MM_TBS_TROPEZ_WAVEOUT = @as(u32, 38);
pub const MM_TBS_TROPEZ_AUX1 = @as(u32, 39);
pub const MM_TBS_TROPEZ_AUX2 = @as(u32, 40);
pub const MM_TBS_TROPEZ_LINE = @as(u32, 41);
pub const MM_MMOTION_WAVEAUX = @as(u32, 1);
pub const MM_MMOTION_WAVEOUT = @as(u32, 2);
pub const MM_MMOTION_WAVEIN = @as(u32, 3);
pub const MM_IBM_PCMCIA_WAVEIN = @as(u32, 11);
pub const MM_IBM_PCMCIA_WAVEOUT = @as(u32, 12);
pub const MM_IBM_PCMCIA_SYNTH = @as(u32, 13);
pub const MM_IBM_PCMCIA_MIDIIN = @as(u32, 14);
pub const MM_IBM_PCMCIA_MIDIOUT = @as(u32, 15);
pub const MM_IBM_PCMCIA_AUX = @as(u32, 16);
pub const MM_IBM_THINKPAD200 = @as(u32, 17);
pub const MM_IBM_MWAVE_WAVEIN = @as(u32, 18);
pub const MM_IBM_MWAVE_WAVEOUT = @as(u32, 19);
pub const MM_IBM_MWAVE_MIXER = @as(u32, 20);
pub const MM_IBM_MWAVE_MIDIIN = @as(u32, 21);
pub const MM_IBM_MWAVE_MIDIOUT = @as(u32, 22);
pub const MM_IBM_MWAVE_AUX = @as(u32, 23);
pub const MM_IBM_WC_MIDIOUT = @as(u32, 30);
pub const MM_IBM_WC_WAVEOUT = @as(u32, 31);
pub const MM_IBM_WC_MIXEROUT = @as(u32, 33);
pub const MM_VOCALTEC_WAVEOUT = @as(u32, 1);
pub const MM_VOCALTEC_WAVEIN = @as(u32, 2);
pub const MM_ROLAND_RAP10_MIDIOUT = @as(u32, 10);
pub const MM_ROLAND_RAP10_MIDIIN = @as(u32, 11);
pub const MM_ROLAND_RAP10_SYNTH = @as(u32, 12);
pub const MM_ROLAND_RAP10_WAVEOUT = @as(u32, 13);
pub const MM_ROLAND_RAP10_WAVEIN = @as(u32, 14);
pub const MM_ROLAND_MPU401_MIDIOUT = @as(u32, 15);
pub const MM_ROLAND_MPU401_MIDIIN = @as(u32, 16);
pub const MM_ROLAND_SMPU_MIDIOUTA = @as(u32, 17);
pub const MM_ROLAND_SMPU_MIDIOUTB = @as(u32, 18);
pub const MM_ROLAND_SMPU_MIDIINA = @as(u32, 19);
pub const MM_ROLAND_SMPU_MIDIINB = @as(u32, 20);
pub const MM_ROLAND_SC7_MIDIOUT = @as(u32, 21);
pub const MM_ROLAND_SC7_MIDIIN = @as(u32, 22);
pub const MM_ROLAND_SERIAL_MIDIOUT = @as(u32, 23);
pub const MM_ROLAND_SERIAL_MIDIIN = @as(u32, 24);
pub const MM_ROLAND_SCP_MIDIOUT = @as(u32, 38);
pub const MM_ROLAND_SCP_MIDIIN = @as(u32, 39);
pub const MM_ROLAND_SCP_WAVEOUT = @as(u32, 40);
pub const MM_ROLAND_SCP_WAVEIN = @as(u32, 41);
pub const MM_ROLAND_SCP_MIXER = @as(u32, 42);
pub const MM_ROLAND_SCP_AUX = @as(u32, 48);
pub const MM_DSP_SOLUTIONS_WAVEOUT = @as(u32, 1);
pub const MM_DSP_SOLUTIONS_WAVEIN = @as(u32, 2);
pub const MM_DSP_SOLUTIONS_SYNTH = @as(u32, 3);
pub const MM_DSP_SOLUTIONS_AUX = @as(u32, 4);
pub const MM_NEC_73_86_SYNTH = @as(u32, 5);
pub const MM_NEC_73_86_WAVEOUT = @as(u32, 6);
pub const MM_NEC_73_86_WAVEIN = @as(u32, 7);
pub const MM_NEC_26_SYNTH = @as(u32, 9);
pub const MM_NEC_MPU401_MIDIOUT = @as(u32, 10);
pub const MM_NEC_MPU401_MIDIIN = @as(u32, 11);
pub const MM_NEC_JOYSTICK = @as(u32, 12);
pub const MM_WANGLABS_WAVEIN1 = @as(u32, 1);
pub const MM_WANGLABS_WAVEOUT1 = @as(u32, 2);
pub const MM_TANDY_VISWAVEIN = @as(u32, 1);
pub const MM_TANDY_VISWAVEOUT = @as(u32, 2);
pub const MM_TANDY_VISBIOSSYNTH = @as(u32, 3);
pub const MM_TANDY_SENS_MMAWAVEIN = @as(u32, 4);
pub const MM_TANDY_SENS_MMAWAVEOUT = @as(u32, 5);
pub const MM_TANDY_SENS_MMAMIDIIN = @as(u32, 6);
pub const MM_TANDY_SENS_MMAMIDIOUT = @as(u32, 7);
pub const MM_TANDY_SENS_VISWAVEOUT = @as(u32, 8);
pub const MM_TANDY_PSSJWAVEIN = @as(u32, 9);
pub const MM_TANDY_PSSJWAVEOUT = @as(u32, 10);
pub const MM_ANTEX_SX12_WAVEIN = @as(u32, 1);
pub const MM_ANTEX_SX12_WAVEOUT = @as(u32, 2);
pub const MM_ANTEX_SX15_WAVEIN = @as(u32, 3);
pub const MM_ANTEX_SX15_WAVEOUT = @as(u32, 4);
pub const MM_ANTEX_VP625_WAVEIN = @as(u32, 5);
pub const MM_ANTEX_VP625_WAVEOUT = @as(u32, 6);
pub const MM_ANTEX_AUDIOPORT22_WAVEIN = @as(u32, 7);
pub const MM_ANTEX_AUDIOPORT22_WAVEOUT = @as(u32, 8);
pub const MM_ANTEX_AUDIOPORT22_FEEDTHRU = @as(u32, 9);
pub const MM_INTELOPD_WAVEIN = @as(u32, 1);
pub const MM_INTELOPD_WAVEOUT = @as(u32, 101);
pub const MM_INTELOPD_AUX = @as(u32, 401);
pub const MM_INTEL_NSPMODEMLINEIN = @as(u32, 501);
pub const MM_INTEL_NSPMODEMLINEOUT = @as(u32, 502);
pub const MM_VAL_MICROKEY_AP_WAVEIN = @as(u32, 1);
pub const MM_VAL_MICROKEY_AP_WAVEOUT = @as(u32, 2);
pub const MM_INTERACTIVE_WAVEIN = @as(u32, 69);
pub const MM_INTERACTIVE_WAVEOUT = @as(u32, 69);
pub const MM_YAMAHA_GSS_SYNTH = @as(u32, 1);
pub const MM_YAMAHA_GSS_WAVEOUT = @as(u32, 2);
pub const MM_YAMAHA_GSS_WAVEIN = @as(u32, 3);
pub const MM_YAMAHA_GSS_MIDIOUT = @as(u32, 4);
pub const MM_YAMAHA_GSS_MIDIIN = @as(u32, 5);
pub const MM_YAMAHA_GSS_AUX = @as(u32, 6);
pub const MM_YAMAHA_SERIAL_MIDIOUT = @as(u32, 7);
pub const MM_YAMAHA_SERIAL_MIDIIN = @as(u32, 8);
pub const MM_YAMAHA_OPL3SA_WAVEOUT = @as(u32, 16);
pub const MM_YAMAHA_OPL3SA_WAVEIN = @as(u32, 17);
pub const MM_YAMAHA_OPL3SA_FMSYNTH = @as(u32, 18);
pub const MM_YAMAHA_OPL3SA_YSYNTH = @as(u32, 19);
pub const MM_YAMAHA_OPL3SA_MIDIOUT = @as(u32, 20);
pub const MM_YAMAHA_OPL3SA_MIDIIN = @as(u32, 21);
pub const MM_YAMAHA_OPL3SA_MIXER = @as(u32, 23);
pub const MM_YAMAHA_OPL3SA_JOYSTICK = @as(u32, 24);
pub const MM_YAMAHA_YMF724LEG_MIDIOUT = @as(u32, 25);
pub const MM_YAMAHA_YMF724LEG_MIDIIN = @as(u32, 26);
pub const MM_YAMAHA_YMF724_WAVEOUT = @as(u32, 27);
pub const MM_YAMAHA_YMF724_WAVEIN = @as(u32, 28);
pub const MM_YAMAHA_YMF724_MIDIOUT = @as(u32, 29);
pub const MM_YAMAHA_YMF724_AUX = @as(u32, 30);
pub const MM_YAMAHA_YMF724_MIXER = @as(u32, 31);
pub const MM_YAMAHA_YMF724LEG_FMSYNTH = @as(u32, 32);
pub const MM_YAMAHA_YMF724LEG_MIXER = @as(u32, 33);
pub const MM_YAMAHA_SXG_MIDIOUT = @as(u32, 34);
pub const MM_YAMAHA_SXG_WAVEOUT = @as(u32, 35);
pub const MM_YAMAHA_SXG_MIXER = @as(u32, 36);
pub const MM_YAMAHA_ACXG_WAVEIN = @as(u32, 37);
pub const MM_YAMAHA_ACXG_WAVEOUT = @as(u32, 38);
pub const MM_YAMAHA_ACXG_MIDIOUT = @as(u32, 39);
pub const MM_YAMAHA_ACXG_MIXER = @as(u32, 40);
pub const MM_YAMAHA_ACXG_AUX = @as(u32, 41);
pub const MM_EVEREX_CARRIER = @as(u32, 1);
pub const MM_ECHO_SYNTH = @as(u32, 1);
pub const MM_ECHO_WAVEOUT = @as(u32, 2);
pub const MM_ECHO_WAVEIN = @as(u32, 3);
pub const MM_ECHO_MIDIOUT = @as(u32, 4);
pub const MM_ECHO_MIDIIN = @as(u32, 5);
pub const MM_ECHO_AUX = @as(u32, 6);
pub const MM_SIERRA_ARIA_MIDIOUT = @as(u32, 20);
pub const MM_SIERRA_ARIA_MIDIIN = @as(u32, 21);
pub const MM_SIERRA_ARIA_SYNTH = @as(u32, 22);
pub const MM_SIERRA_ARIA_WAVEOUT = @as(u32, 23);
pub const MM_SIERRA_ARIA_WAVEIN = @as(u32, 24);
pub const MM_SIERRA_ARIA_AUX = @as(u32, 25);
pub const MM_SIERRA_ARIA_AUX2 = @as(u32, 32);
pub const MM_SIERRA_QUARTET_WAVEIN = @as(u32, 80);
pub const MM_SIERRA_QUARTET_WAVEOUT = @as(u32, 81);
pub const MM_SIERRA_QUARTET_MIDIIN = @as(u32, 82);
pub const MM_SIERRA_QUARTET_MIDIOUT = @as(u32, 83);
pub const MM_SIERRA_QUARTET_SYNTH = @as(u32, 84);
pub const MM_SIERRA_QUARTET_AUX_CD = @as(u32, 85);
pub const MM_SIERRA_QUARTET_AUX_LINE = @as(u32, 86);
pub const MM_SIERRA_QUARTET_AUX_MODEM = @as(u32, 87);
pub const MM_SIERRA_QUARTET_MIXER = @as(u32, 88);
pub const MM_CAT_WAVEOUT = @as(u32, 1);
pub const MM_DSP_GROUP_TRUESPEECH = @as(u32, 1);
pub const MM_MELABS_MIDI2GO = @as(u32, 1);
pub const MM_ESS_AMWAVEOUT = @as(u32, 1);
pub const MM_ESS_AMWAVEIN = @as(u32, 2);
pub const MM_ESS_AMAUX = @as(u32, 3);
pub const MM_ESS_AMSYNTH = @as(u32, 4);
pub const MM_ESS_AMMIDIOUT = @as(u32, 5);
pub const MM_ESS_AMMIDIIN = @as(u32, 6);
pub const MM_ESS_MIXER = @as(u32, 7);
pub const MM_ESS_AUX_CD = @as(u32, 8);
pub const MM_ESS_MPU401_MIDIOUT = @as(u32, 9);
pub const MM_ESS_MPU401_MIDIIN = @as(u32, 10);
pub const MM_ESS_ES488_WAVEOUT = @as(u32, 16);
pub const MM_ESS_ES488_WAVEIN = @as(u32, 17);
pub const MM_ESS_ES488_MIXER = @as(u32, 18);
pub const MM_ESS_ES688_WAVEOUT = @as(u32, 19);
pub const MM_ESS_ES688_WAVEIN = @as(u32, 20);
pub const MM_ESS_ES688_MIXER = @as(u32, 21);
pub const MM_ESS_ES1488_WAVEOUT = @as(u32, 22);
pub const MM_ESS_ES1488_WAVEIN = @as(u32, 23);
pub const MM_ESS_ES1488_MIXER = @as(u32, 24);
pub const MM_ESS_ES1688_WAVEOUT = @as(u32, 25);
pub const MM_ESS_ES1688_WAVEIN = @as(u32, 26);
pub const MM_ESS_ES1688_MIXER = @as(u32, 27);
pub const MM_ESS_ES1788_WAVEOUT = @as(u32, 28);
pub const MM_ESS_ES1788_WAVEIN = @as(u32, 29);
pub const MM_ESS_ES1788_MIXER = @as(u32, 30);
pub const MM_ESS_ES1888_WAVEOUT = @as(u32, 31);
pub const MM_ESS_ES1888_WAVEIN = @as(u32, 32);
pub const MM_ESS_ES1888_MIXER = @as(u32, 33);
pub const MM_ESS_ES1868_WAVEOUT = @as(u32, 34);
pub const MM_ESS_ES1868_WAVEIN = @as(u32, 35);
pub const MM_ESS_ES1868_MIXER = @as(u32, 36);
pub const MM_ESS_ES1878_WAVEOUT = @as(u32, 37);
pub const MM_ESS_ES1878_WAVEIN = @as(u32, 38);
pub const MM_ESS_ES1878_MIXER = @as(u32, 39);
pub const MM_CANOPUS_ACM_DVREX = @as(u32, 1);
pub const MM_EPS_FMSND = @as(u32, 1);
pub const MM_TRUEVISION_WAVEIN1 = @as(u32, 1);
pub const MM_TRUEVISION_WAVEOUT1 = @as(u32, 2);
pub const MM_AZTECH_MIDIOUT = @as(u32, 3);
pub const MM_AZTECH_MIDIIN = @as(u32, 4);
pub const MM_AZTECH_WAVEIN = @as(u32, 17);
pub const MM_AZTECH_WAVEOUT = @as(u32, 18);
pub const MM_AZTECH_FMSYNTH = @as(u32, 20);
pub const MM_AZTECH_MIXER = @as(u32, 21);
pub const MM_AZTECH_PRO16_WAVEIN = @as(u32, 33);
pub const MM_AZTECH_PRO16_WAVEOUT = @as(u32, 34);
pub const MM_AZTECH_PRO16_FMSYNTH = @as(u32, 38);
pub const MM_AZTECH_DSP16_WAVEIN = @as(u32, 65);
pub const MM_AZTECH_DSP16_WAVEOUT = @as(u32, 66);
pub const MM_AZTECH_DSP16_FMSYNTH = @as(u32, 68);
pub const MM_AZTECH_DSP16_WAVESYNTH = @as(u32, 70);
pub const MM_AZTECH_NOVA16_WAVEIN = @as(u32, 71);
pub const MM_AZTECH_NOVA16_WAVEOUT = @as(u32, 72);
pub const MM_AZTECH_NOVA16_MIXER = @as(u32, 73);
pub const MM_AZTECH_WASH16_WAVEIN = @as(u32, 74);
pub const MM_AZTECH_WASH16_WAVEOUT = @as(u32, 75);
pub const MM_AZTECH_WASH16_MIXER = @as(u32, 76);
pub const MM_AZTECH_AUX_CD = @as(u32, 401);
pub const MM_AZTECH_AUX_LINE = @as(u32, 402);
pub const MM_AZTECH_AUX_MIC = @as(u32, 403);
pub const MM_AZTECH_AUX = @as(u32, 404);
pub const MM_VIDEOLOGIC_MSWAVEIN = @as(u32, 1);
pub const MM_VIDEOLOGIC_MSWAVEOUT = @as(u32, 2);
pub const MM_KORG_PCIF_MIDIOUT = @as(u32, 1);
pub const MM_KORG_PCIF_MIDIIN = @as(u32, 2);
pub const MM_KORG_1212IO_MSWAVEIN = @as(u32, 3);
pub const MM_KORG_1212IO_MSWAVEOUT = @as(u32, 4);
pub const MM_APT_ACE100CD = @as(u32, 1);
pub const MM_ICS_WAVEDECK_WAVEOUT = @as(u32, 1);
pub const MM_ICS_WAVEDECK_WAVEIN = @as(u32, 2);
pub const MM_ICS_WAVEDECK_MIXER = @as(u32, 3);
pub const MM_ICS_WAVEDECK_AUX = @as(u32, 4);
pub const MM_ICS_WAVEDECK_SYNTH = @as(u32, 5);
pub const MM_ICS_WAVEDEC_SB_WAVEOUT = @as(u32, 6);
pub const MM_ICS_WAVEDEC_SB_WAVEIN = @as(u32, 7);
pub const MM_ICS_WAVEDEC_SB_FM_MIDIOUT = @as(u32, 8);
pub const MM_ICS_WAVEDEC_SB_MPU401_MIDIOUT = @as(u32, 9);
pub const MM_ICS_WAVEDEC_SB_MPU401_MIDIIN = @as(u32, 10);
pub const MM_ICS_WAVEDEC_SB_MIXER = @as(u32, 11);
pub const MM_ICS_WAVEDEC_SB_AUX = @as(u32, 12);
pub const MM_ICS_2115_LITE_MIDIOUT = @as(u32, 13);
pub const MM_ICS_2120_LITE_MIDIOUT = @as(u32, 14);
pub const MM_ITERATEDSYS_FUFCODEC = @as(u32, 1);
pub const MM_METHEUS_ZIPPER = @as(u32, 1);
pub const MM_WINNOV_CAVIAR_WAVEIN = @as(u32, 1);
pub const MM_WINNOV_CAVIAR_WAVEOUT = @as(u32, 2);
pub const MM_WINNOV_CAVIAR_VIDC = @as(u32, 3);
pub const MM_WINNOV_CAVIAR_CHAMPAGNE = @as(u32, 4);
pub const MM_WINNOV_CAVIAR_YUV8 = @as(u32, 5);
pub const MM_NCR_BA_WAVEIN = @as(u32, 1);
pub const MM_NCR_BA_WAVEOUT = @as(u32, 2);
pub const MM_NCR_BA_SYNTH = @as(u32, 3);
pub const MM_NCR_BA_AUX = @as(u32, 4);
pub const MM_NCR_BA_MIXER = @as(u32, 5);
pub const MM_AST_MODEMWAVE_WAVEIN = @as(u32, 13);
pub const MM_AST_MODEMWAVE_WAVEOUT = @as(u32, 14);
pub const MM_WILLOWPOND_FMSYNTH_STEREO = @as(u32, 20);
pub const MM_WILLOWPOND_MPU401 = @as(u32, 21);
pub const MM_WILLOWPOND_SNDPORT_WAVEIN = @as(u32, 100);
pub const MM_WILLOWPOND_SNDPORT_WAVEOUT = @as(u32, 101);
pub const MM_WILLOWPOND_SNDPORT_MIXER = @as(u32, 102);
pub const MM_WILLOWPOND_SNDPORT_AUX = @as(u32, 103);
pub const MM_WILLOWPOND_PH_WAVEIN = @as(u32, 104);
pub const MM_WILLOWPOND_PH_WAVEOUT = @as(u32, 105);
pub const MM_WILLOWPOND_PH_MIXER = @as(u32, 106);
pub const MM_WILLOWPOND_PH_AUX = @as(u32, 107);
pub const MM_WILLOPOND_SNDCOMM_WAVEIN = @as(u32, 108);
pub const MM_WILLOWPOND_SNDCOMM_WAVEOUT = @as(u32, 109);
pub const MM_WILLOWPOND_SNDCOMM_MIXER = @as(u32, 110);
pub const MM_WILLOWPOND_SNDCOMM_AUX = @as(u32, 111);
pub const MM_WILLOWPOND_GENERIC_WAVEIN = @as(u32, 112);
pub const MM_WILLOWPOND_GENERIC_WAVEOUT = @as(u32, 113);
pub const MM_WILLOWPOND_GENERIC_MIXER = @as(u32, 114);
pub const MM_WILLOWPOND_GENERIC_AUX = @as(u32, 115);
pub const MM_VITEC_VMAKER = @as(u32, 1);
pub const MM_VITEC_VMPRO = @as(u32, 2);
pub const MM_MOSCOM_VPC2400_IN = @as(u32, 1);
pub const MM_MOSCOM_VPC2400_OUT = @as(u32, 2);
pub const MM_SILICONSOFT_SC1_WAVEIN = @as(u32, 1);
pub const MM_SILICONSOFT_SC1_WAVEOUT = @as(u32, 2);
pub const MM_SILICONSOFT_SC2_WAVEIN = @as(u32, 3);
pub const MM_SILICONSOFT_SC2_WAVEOUT = @as(u32, 4);
pub const MM_SILICONSOFT_SOUNDJR2_WAVEOUT = @as(u32, 5);
pub const MM_SILICONSOFT_SOUNDJR2PR_WAVEIN = @as(u32, 6);
pub const MM_SILICONSOFT_SOUNDJR2PR_WAVEOUT = @as(u32, 7);
pub const MM_SILICONSOFT_SOUNDJR3_WAVEOUT = @as(u32, 8);
pub const MM_TTEWS_WAVEIN = @as(u32, 1);
pub const MM_TTEWS_WAVEOUT = @as(u32, 2);
pub const MM_TTEWS_MIDIIN = @as(u32, 3);
pub const MM_TTEWS_MIDIOUT = @as(u32, 4);
pub const MM_TTEWS_MIDISYNTH = @as(u32, 5);
pub const MM_TTEWS_MIDIMONITOR = @as(u32, 6);
pub const MM_TTEWS_VMIDIIN = @as(u32, 7);
pub const MM_TTEWS_VMIDIOUT = @as(u32, 8);
pub const MM_TTEWS_AUX = @as(u32, 9);
pub const MM_TTEWS_MIXER = @as(u32, 10);
pub const MM_MEDIASONIC_ACM_G723 = @as(u32, 1);
pub const MM_MEDIASONIC_ICOM = @as(u32, 2);
pub const MM_ICOM_WAVEIN = @as(u32, 3);
pub const MM_ICOM_WAVEOUT = @as(u32, 4);
pub const MM_ICOM_MIXER = @as(u32, 5);
pub const MM_ICOM_AUX = @as(u32, 6);
pub const MM_ICOM_LINE = @as(u32, 7);
pub const MM_SANYO_ACM_LD_ADPCM = @as(u32, 1);
pub const MM_AHEAD_MULTISOUND = @as(u32, 1);
pub const MM_AHEAD_SOUNDBLASTER = @as(u32, 2);
pub const MM_AHEAD_PROAUDIO = @as(u32, 3);
pub const MM_AHEAD_GENERIC = @as(u32, 4);
pub const MM_OLIVETTI_WAVEIN = @as(u32, 1);
pub const MM_OLIVETTI_WAVEOUT = @as(u32, 2);
pub const MM_OLIVETTI_MIXER = @as(u32, 3);
pub const MM_OLIVETTI_AUX = @as(u32, 4);
pub const MM_OLIVETTI_MIDIIN = @as(u32, 5);
pub const MM_OLIVETTI_MIDIOUT = @as(u32, 6);
pub const MM_OLIVETTI_SYNTH = @as(u32, 7);
pub const MM_OLIVETTI_JOYSTICK = @as(u32, 8);
pub const MM_OLIVETTI_ACM_GSM = @as(u32, 9);
pub const MM_OLIVETTI_ACM_ADPCM = @as(u32, 10);
pub const MM_OLIVETTI_ACM_CELP = @as(u32, 11);
pub const MM_OLIVETTI_ACM_SBC = @as(u32, 12);
pub const MM_OLIVETTI_ACM_OPR = @as(u32, 13);
pub const MM_IOMAGIC_TEMPO_WAVEOUT = @as(u32, 1);
pub const MM_IOMAGIC_TEMPO_WAVEIN = @as(u32, 2);
pub const MM_IOMAGIC_TEMPO_SYNTH = @as(u32, 3);
pub const MM_IOMAGIC_TEMPO_MIDIOUT = @as(u32, 4);
pub const MM_IOMAGIC_TEMPO_MXDOUT = @as(u32, 5);
pub const MM_IOMAGIC_TEMPO_AUXOUT = @as(u32, 6);
pub const MM_MATSUSHITA_WAVEIN = @as(u32, 1);
pub const MM_MATSUSHITA_WAVEOUT = @as(u32, 2);
pub const MM_MATSUSHITA_FMSYNTH_STEREO = @as(u32, 3);
pub const MM_MATSUSHITA_MIXER = @as(u32, 4);
pub const MM_MATSUSHITA_AUX = @as(u32, 5);
pub const MM_NEWMEDIA_WAVJAMMER = @as(u32, 1);
pub const MM_LYRRUS_BRIDGE_GUITAR = @as(u32, 1);
pub const MM_OPTI_M16_FMSYNTH_STEREO = @as(u32, 1);
pub const MM_OPTI_M16_MIDIIN = @as(u32, 2);
pub const MM_OPTI_M16_MIDIOUT = @as(u32, 3);
pub const MM_OPTI_M16_WAVEIN = @as(u32, 4);
pub const MM_OPTI_M16_WAVEOUT = @as(u32, 5);
pub const MM_OPTI_M16_MIXER = @as(u32, 6);
pub const MM_OPTI_M16_AUX = @as(u32, 7);
pub const MM_OPTI_P16_FMSYNTH_STEREO = @as(u32, 16);
pub const MM_OPTI_P16_MIDIIN = @as(u32, 17);
pub const MM_OPTI_P16_MIDIOUT = @as(u32, 18);
pub const MM_OPTI_P16_WAVEIN = @as(u32, 19);
pub const MM_OPTI_P16_WAVEOUT = @as(u32, 20);
pub const MM_OPTI_P16_MIXER = @as(u32, 21);
pub const MM_OPTI_P16_AUX = @as(u32, 22);
pub const MM_OPTI_M32_WAVEIN = @as(u32, 32);
pub const MM_OPTI_M32_WAVEOUT = @as(u32, 33);
pub const MM_OPTI_M32_MIDIIN = @as(u32, 34);
pub const MM_OPTI_M32_MIDIOUT = @as(u32, 35);
pub const MM_OPTI_M32_SYNTH_STEREO = @as(u32, 36);
pub const MM_OPTI_M32_MIXER = @as(u32, 37);
pub const MM_OPTI_M32_AUX = @as(u32, 38);
pub const MM_COMPAQ_BB_WAVEIN = @as(u32, 1);
pub const MM_COMPAQ_BB_WAVEOUT = @as(u32, 2);
pub const MM_COMPAQ_BB_WAVEAUX = @as(u32, 3);
pub const MM_MPTUS_SPWAVEOUT = @as(u32, 1);
pub const MM_LERNOUT_ANDHAUSPIE_LHCODECACM = @as(u32, 1);
pub const MM_DIGITAL_AV320_WAVEIN = @as(u32, 1);
pub const MM_DIGITAL_AV320_WAVEOUT = @as(u32, 2);
pub const MM_DIGITAL_ACM_G723 = @as(u32, 3);
pub const MM_DIGITAL_ICM_H263 = @as(u32, 4);
pub const MM_DIGITAL_ICM_H261 = @as(u32, 5);
pub const MM_MOTU_MTP_MIDIOUT_ALL = @as(u32, 100);
pub const MM_MOTU_MTP_MIDIIN_1 = @as(u32, 101);
pub const MM_MOTU_MTP_MIDIOUT_1 = @as(u32, 101);
pub const MM_MOTU_MTP_MIDIIN_2 = @as(u32, 102);
pub const MM_MOTU_MTP_MIDIOUT_2 = @as(u32, 102);
pub const MM_MOTU_MTP_MIDIIN_3 = @as(u32, 103);
pub const MM_MOTU_MTP_MIDIOUT_3 = @as(u32, 103);
pub const MM_MOTU_MTP_MIDIIN_4 = @as(u32, 104);
pub const MM_MOTU_MTP_MIDIOUT_4 = @as(u32, 104);
pub const MM_MOTU_MTP_MIDIIN_5 = @as(u32, 105);
pub const MM_MOTU_MTP_MIDIOUT_5 = @as(u32, 105);
pub const MM_MOTU_MTP_MIDIIN_6 = @as(u32, 106);
pub const MM_MOTU_MTP_MIDIOUT_6 = @as(u32, 106);
pub const MM_MOTU_MTP_MIDIIN_7 = @as(u32, 107);
pub const MM_MOTU_MTP_MIDIOUT_7 = @as(u32, 107);
pub const MM_MOTU_MTP_MIDIIN_8 = @as(u32, 108);
pub const MM_MOTU_MTP_MIDIOUT_8 = @as(u32, 108);
pub const MM_MOTU_MTPII_MIDIOUT_ALL = @as(u32, 200);
pub const MM_MOTU_MTPII_MIDIIN_SYNC = @as(u32, 200);
pub const MM_MOTU_MTPII_MIDIIN_1 = @as(u32, 201);
pub const MM_MOTU_MTPII_MIDIOUT_1 = @as(u32, 201);
pub const MM_MOTU_MTPII_MIDIIN_2 = @as(u32, 202);
pub const MM_MOTU_MTPII_MIDIOUT_2 = @as(u32, 202);
pub const MM_MOTU_MTPII_MIDIIN_3 = @as(u32, 203);
pub const MM_MOTU_MTPII_MIDIOUT_3 = @as(u32, 203);
pub const MM_MOTU_MTPII_MIDIIN_4 = @as(u32, 204);
pub const MM_MOTU_MTPII_MIDIOUT_4 = @as(u32, 204);
pub const MM_MOTU_MTPII_MIDIIN_5 = @as(u32, 205);
pub const MM_MOTU_MTPII_MIDIOUT_5 = @as(u32, 205);
pub const MM_MOTU_MTPII_MIDIIN_6 = @as(u32, 206);
pub const MM_MOTU_MTPII_MIDIOUT_6 = @as(u32, 206);
pub const MM_MOTU_MTPII_MIDIIN_7 = @as(u32, 207);
pub const MM_MOTU_MTPII_MIDIOUT_7 = @as(u32, 207);
pub const MM_MOTU_MTPII_MIDIIN_8 = @as(u32, 208);
pub const MM_MOTU_MTPII_MIDIOUT_8 = @as(u32, 208);
pub const MM_MOTU_MTPII_NET_MIDIIN_1 = @as(u32, 209);
pub const MM_MOTU_MTPII_NET_MIDIOUT_1 = @as(u32, 209);
pub const MM_MOTU_MTPII_NET_MIDIIN_2 = @as(u32, 210);
pub const MM_MOTU_MTPII_NET_MIDIOUT_2 = @as(u32, 210);
pub const MM_MOTU_MTPII_NET_MIDIIN_3 = @as(u32, 211);
pub const MM_MOTU_MTPII_NET_MIDIOUT_3 = @as(u32, 211);
pub const MM_MOTU_MTPII_NET_MIDIIN_4 = @as(u32, 212);
pub const MM_MOTU_MTPII_NET_MIDIOUT_4 = @as(u32, 212);
pub const MM_MOTU_MTPII_NET_MIDIIN_5 = @as(u32, 213);
pub const MM_MOTU_MTPII_NET_MIDIOUT_5 = @as(u32, 213);
pub const MM_MOTU_MTPII_NET_MIDIIN_6 = @as(u32, 214);
pub const MM_MOTU_MTPII_NET_MIDIOUT_6 = @as(u32, 214);
pub const MM_MOTU_MTPII_NET_MIDIIN_7 = @as(u32, 215);
pub const MM_MOTU_MTPII_NET_MIDIOUT_7 = @as(u32, 215);
pub const MM_MOTU_MTPII_NET_MIDIIN_8 = @as(u32, 216);
pub const MM_MOTU_MTPII_NET_MIDIOUT_8 = @as(u32, 216);
pub const MM_MOTU_MXP_MIDIIN_MIDIOUT_ALL = @as(u32, 300);
pub const MM_MOTU_MXP_MIDIIN_SYNC = @as(u32, 300);
pub const MM_MOTU_MXP_MIDIIN_MIDIIN_1 = @as(u32, 301);
pub const MM_MOTU_MXP_MIDIIN_MIDIOUT_1 = @as(u32, 301);
pub const MM_MOTU_MXP_MIDIIN_MIDIIN_2 = @as(u32, 302);
pub const MM_MOTU_MXP_MIDIIN_MIDIOUT_2 = @as(u32, 302);
pub const MM_MOTU_MXP_MIDIIN_MIDIIN_3 = @as(u32, 303);
pub const MM_MOTU_MXP_MIDIIN_MIDIOUT_3 = @as(u32, 303);
pub const MM_MOTU_MXP_MIDIIN_MIDIIN_4 = @as(u32, 304);
pub const MM_MOTU_MXP_MIDIIN_MIDIOUT_4 = @as(u32, 304);
pub const MM_MOTU_MXP_MIDIIN_MIDIIN_5 = @as(u32, 305);
pub const MM_MOTU_MXP_MIDIIN_MIDIOUT_5 = @as(u32, 305);
pub const MM_MOTU_MXP_MIDIIN_MIDIIN_6 = @as(u32, 306);
pub const MM_MOTU_MXP_MIDIIN_MIDIOUT_6 = @as(u32, 306);
pub const MM_MOTU_MXPMPU_MIDIOUT_ALL = @as(u32, 400);
pub const MM_MOTU_MXPMPU_MIDIIN_SYNC = @as(u32, 400);
pub const MM_MOTU_MXPMPU_MIDIIN_1 = @as(u32, 401);
pub const MM_MOTU_MXPMPU_MIDIOUT_1 = @as(u32, 401);
pub const MM_MOTU_MXPMPU_MIDIIN_2 = @as(u32, 402);
pub const MM_MOTU_MXPMPU_MIDIOUT_2 = @as(u32, 402);
pub const MM_MOTU_MXPMPU_MIDIIN_3 = @as(u32, 403);
pub const MM_MOTU_MXPMPU_MIDIOUT_3 = @as(u32, 403);
pub const MM_MOTU_MXPMPU_MIDIIN_4 = @as(u32, 404);
pub const MM_MOTU_MXPMPU_MIDIOUT_4 = @as(u32, 404);
pub const MM_MOTU_MXPMPU_MIDIIN_5 = @as(u32, 405);
pub const MM_MOTU_MXPMPU_MIDIOUT_5 = @as(u32, 405);
pub const MM_MOTU_MXPMPU_MIDIIN_6 = @as(u32, 406);
pub const MM_MOTU_MXPMPU_MIDIOUT_6 = @as(u32, 406);
pub const MM_MOTU_MXN_MIDIOUT_ALL = @as(u32, 500);
pub const MM_MOTU_MXN_MIDIIN_SYNC = @as(u32, 500);
pub const MM_MOTU_MXN_MIDIIN_1 = @as(u32, 501);
pub const MM_MOTU_MXN_MIDIOUT_1 = @as(u32, 501);
pub const MM_MOTU_MXN_MIDIIN_2 = @as(u32, 502);
pub const MM_MOTU_MXN_MIDIOUT_2 = @as(u32, 502);
pub const MM_MOTU_MXN_MIDIIN_3 = @as(u32, 503);
pub const MM_MOTU_MXN_MIDIOUT_3 = @as(u32, 503);
pub const MM_MOTU_MXN_MIDIIN_4 = @as(u32, 504);
pub const MM_MOTU_MXN_MIDIOUT_4 = @as(u32, 504);
pub const MM_MOTU_FLYER_MIDI_IN_SYNC = @as(u32, 600);
pub const MM_MOTU_FLYER_MIDI_IN_A = @as(u32, 601);
pub const MM_MOTU_FLYER_MIDI_OUT_A = @as(u32, 601);
pub const MM_MOTU_FLYER_MIDI_IN_B = @as(u32, 602);
pub const MM_MOTU_FLYER_MIDI_OUT_B = @as(u32, 602);
pub const MM_MOTU_PKX_MIDI_IN_SYNC = @as(u32, 700);
pub const MM_MOTU_PKX_MIDI_IN_A = @as(u32, 701);
pub const MM_MOTU_PKX_MIDI_OUT_A = @as(u32, 701);
pub const MM_MOTU_PKX_MIDI_IN_B = @as(u32, 702);
pub const MM_MOTU_PKX_MIDI_OUT_B = @as(u32, 702);
pub const MM_MOTU_DTX_MIDI_IN_SYNC = @as(u32, 800);
pub const MM_MOTU_DTX_MIDI_IN_A = @as(u32, 801);
pub const MM_MOTU_DTX_MIDI_OUT_A = @as(u32, 801);
pub const MM_MOTU_DTX_MIDI_IN_B = @as(u32, 802);
pub const MM_MOTU_DTX_MIDI_OUT_B = @as(u32, 802);
pub const MM_MOTU_MTPAV_MIDIOUT_ALL = @as(u32, 900);
pub const MM_MOTU_MTPAV_MIDIIN_SYNC = @as(u32, 900);
pub const MM_MOTU_MTPAV_MIDIIN_1 = @as(u32, 901);
pub const MM_MOTU_MTPAV_MIDIOUT_1 = @as(u32, 901);
pub const MM_MOTU_MTPAV_MIDIIN_2 = @as(u32, 902);
pub const MM_MOTU_MTPAV_MIDIOUT_2 = @as(u32, 902);
pub const MM_MOTU_MTPAV_MIDIIN_3 = @as(u32, 903);
pub const MM_MOTU_MTPAV_MIDIOUT_3 = @as(u32, 903);
pub const MM_MOTU_MTPAV_MIDIIN_4 = @as(u32, 904);
pub const MM_MOTU_MTPAV_MIDIOUT_4 = @as(u32, 904);
pub const MM_MOTU_MTPAV_MIDIIN_5 = @as(u32, 905);
pub const MM_MOTU_MTPAV_MIDIOUT_5 = @as(u32, 905);
pub const MM_MOTU_MTPAV_MIDIIN_6 = @as(u32, 906);
pub const MM_MOTU_MTPAV_MIDIOUT_6 = @as(u32, 906);
pub const MM_MOTU_MTPAV_MIDIIN_7 = @as(u32, 907);
pub const MM_MOTU_MTPAV_MIDIOUT_7 = @as(u32, 907);
pub const MM_MOTU_MTPAV_MIDIIN_8 = @as(u32, 908);
pub const MM_MOTU_MTPAV_MIDIOUT_8 = @as(u32, 908);
pub const MM_MOTU_MTPAV_NET_MIDIIN_1 = @as(u32, 909);
pub const MM_MOTU_MTPAV_NET_MIDIOUT_1 = @as(u32, 909);
pub const MM_MOTU_MTPAV_NET_MIDIIN_2 = @as(u32, 910);
pub const MM_MOTU_MTPAV_NET_MIDIOUT_2 = @as(u32, 910);
pub const MM_MOTU_MTPAV_NET_MIDIIN_3 = @as(u32, 911);
pub const MM_MOTU_MTPAV_NET_MIDIOUT_3 = @as(u32, 911);
pub const MM_MOTU_MTPAV_NET_MIDIIN_4 = @as(u32, 912);
pub const MM_MOTU_MTPAV_NET_MIDIOUT_4 = @as(u32, 912);
pub const MM_MOTU_MTPAV_NET_MIDIIN_5 = @as(u32, 913);
pub const MM_MOTU_MTPAV_NET_MIDIOUT_5 = @as(u32, 913);
pub const MM_MOTU_MTPAV_NET_MIDIIN_6 = @as(u32, 914);
pub const MM_MOTU_MTPAV_NET_MIDIOUT_6 = @as(u32, 914);
pub const MM_MOTU_MTPAV_NET_MIDIIN_7 = @as(u32, 915);
pub const MM_MOTU_MTPAV_NET_MIDIOUT_7 = @as(u32, 915);
pub const MM_MOTU_MTPAV_NET_MIDIIN_8 = @as(u32, 916);
pub const MM_MOTU_MTPAV_NET_MIDIOUT_8 = @as(u32, 916);
pub const MM_MOTU_MTPAV_MIDIIN_ADAT = @as(u32, 917);
pub const MM_MOTU_MTPAV_MIDIOUT_ADAT = @as(u32, 917);
pub const MM_MOTU_MXPXT_MIDIIN_SYNC = @as(u32, 1000);
pub const MM_MOTU_MXPXT_MIDIOUT_ALL = @as(u32, 1000);
pub const MM_MOTU_MXPXT_MIDIIN_1 = @as(u32, 1001);
pub const MM_MOTU_MXPXT_MIDIOUT_1 = @as(u32, 1001);
pub const MM_MOTU_MXPXT_MIDIOUT_2 = @as(u32, 1002);
pub const MM_MOTU_MXPXT_MIDIIN_2 = @as(u32, 1002);
pub const MM_MOTU_MXPXT_MIDIIN_3 = @as(u32, 1003);
pub const MM_MOTU_MXPXT_MIDIOUT_3 = @as(u32, 1003);
pub const MM_MOTU_MXPXT_MIDIIN_4 = @as(u32, 1004);
pub const MM_MOTU_MXPXT_MIDIOUT_4 = @as(u32, 1004);
pub const MM_MOTU_MXPXT_MIDIIN_5 = @as(u32, 1005);
pub const MM_MOTU_MXPXT_MIDIOUT_5 = @as(u32, 1005);
pub const MM_MOTU_MXPXT_MIDIOUT_6 = @as(u32, 1006);
pub const MM_MOTU_MXPXT_MIDIIN_6 = @as(u32, 1006);
pub const MM_MOTU_MXPXT_MIDIOUT_7 = @as(u32, 1007);
pub const MM_MOTU_MXPXT_MIDIIN_7 = @as(u32, 1007);
pub const MM_MOTU_MXPXT_MIDIOUT_8 = @as(u32, 1008);
pub const MM_MOTU_MXPXT_MIDIIN_8 = @as(u32, 1008);
pub const MM_WORKBIT_MIXER = @as(u32, 1);
pub const MM_WORKBIT_WAVEOUT = @as(u32, 2);
pub const MM_WORKBIT_WAVEIN = @as(u32, 3);
pub const MM_WORKBIT_MIDIIN = @as(u32, 4);
pub const MM_WORKBIT_MIDIOUT = @as(u32, 5);
pub const MM_WORKBIT_FMSYNTH = @as(u32, 6);
pub const MM_WORKBIT_AUX = @as(u32, 7);
pub const MM_WORKBIT_JOYSTICK = @as(u32, 8);
pub const MM_OSITECH_TRUMPCARD = @as(u32, 1);
pub const MM_MIRO_MOVIEPRO = @as(u32, 1);
pub const MM_MIRO_VIDEOD1 = @as(u32, 2);
pub const MM_MIRO_VIDEODC1TV = @as(u32, 3);
pub const MM_MIRO_VIDEOTD = @as(u32, 4);
pub const MM_MIRO_DC30_WAVEOUT = @as(u32, 5);
pub const MM_MIRO_DC30_WAVEIN = @as(u32, 6);
pub const MM_MIRO_DC30_MIX = @as(u32, 7);
pub const MM_ISOLUTION_PASCAL = @as(u32, 1);
pub const MM_VOICEMIXER = @as(u32, 1);
pub const ROCKWELL_WA1_WAVEIN = @as(u32, 100);
pub const ROCKWELL_WA1_WAVEOUT = @as(u32, 101);
pub const ROCKWELL_WA1_SYNTH = @as(u32, 102);
pub const ROCKWELL_WA1_MIXER = @as(u32, 103);
pub const ROCKWELL_WA1_MPU401_IN = @as(u32, 104);
pub const ROCKWELL_WA1_MPU401_OUT = @as(u32, 105);
pub const ROCKWELL_WA2_WAVEIN = @as(u32, 200);
pub const ROCKWELL_WA2_WAVEOUT = @as(u32, 201);
pub const ROCKWELL_WA2_SYNTH = @as(u32, 202);
pub const ROCKWELL_WA2_MIXER = @as(u32, 203);
pub const ROCKWELL_WA2_MPU401_IN = @as(u32, 204);
pub const ROCKWELL_WA2_MPU401_OUT = @as(u32, 205);
pub const MM_VOXWARE_CODEC = @as(u32, 1);
pub const MM_NORTEL_MPXAC_WAVEIN = @as(u32, 1);
pub const MM_NORTEL_MPXAC_WAVEOUT = @as(u32, 2);
pub const MM_ADDX_PCTV_DIGITALMIX = @as(u32, 1);
pub const MM_ADDX_PCTV_WAVEIN = @as(u32, 2);
pub const MM_ADDX_PCTV_WAVEOUT = @as(u32, 3);
pub const MM_ADDX_PCTV_MIXER = @as(u32, 4);
pub const MM_ADDX_PCTV_AUX_CD = @as(u32, 5);
pub const MM_ADDX_PCTV_AUX_LINE = @as(u32, 6);
pub const MM_WILDCAT_AUTOSCOREMIDIIN = @as(u32, 1);
pub const MM_RHETOREX_WAVEIN = @as(u32, 1);
pub const MM_RHETOREX_WAVEOUT = @as(u32, 2);
pub const MM_BTV_WAVEIN = @as(u32, 1);
pub const MM_BTV_WAVEOUT = @as(u32, 2);
pub const MM_BTV_MIDIIN = @as(u32, 3);
pub const MM_BTV_MIDIOUT = @as(u32, 4);
pub const MM_BTV_MIDISYNTH = @as(u32, 5);
pub const MM_BTV_AUX_LINE = @as(u32, 6);
pub const MM_BTV_AUX_MIC = @as(u32, 7);
pub const MM_BTV_AUX_CD = @as(u32, 8);
pub const MM_BTV_DIGITALIN = @as(u32, 9);
pub const MM_BTV_DIGITALOUT = @as(u32, 10);
pub const MM_BTV_MIDIWAVESTREAM = @as(u32, 11);
pub const MM_BTV_MIXER = @as(u32, 12);
pub const MM_ENSONIQ_SOUNDSCAPE = @as(u32, 16);
pub const MM_SOUNDSCAPE_WAVEOUT = @as(u32, 17);
pub const MM_SOUNDSCAPE_WAVEOUT_AUX = @as(u32, 18);
pub const MM_SOUNDSCAPE_WAVEIN = @as(u32, 19);
pub const MM_SOUNDSCAPE_MIDIOUT = @as(u32, 20);
pub const MM_SOUNDSCAPE_MIDIIN = @as(u32, 21);
pub const MM_SOUNDSCAPE_SYNTH = @as(u32, 22);
pub const MM_SOUNDSCAPE_MIXER = @as(u32, 23);
pub const MM_SOUNDSCAPE_AUX = @as(u32, 24);
pub const MM_NVIDIA_WAVEOUT = @as(u32, 1);
pub const MM_NVIDIA_WAVEIN = @as(u32, 2);
pub const MM_NVIDIA_MIDIOUT = @as(u32, 3);
pub const MM_NVIDIA_MIDIIN = @as(u32, 4);
pub const MM_NVIDIA_GAMEPORT = @as(u32, 5);
pub const MM_NVIDIA_MIXER = @as(u32, 6);
pub const MM_NVIDIA_AUX = @as(u32, 7);
pub const MM_OKSORI_BASE = @as(u32, 0);
pub const MM_OKSORI_OSR8_WAVEOUT = @as(u32, 1);
pub const MM_OKSORI_OSR8_WAVEIN = @as(u32, 2);
pub const MM_OKSORI_OSR16_WAVEOUT = @as(u32, 3);
pub const MM_OKSORI_OSR16_WAVEIN = @as(u32, 4);
pub const MM_OKSORI_FM_OPL4 = @as(u32, 5);
pub const MM_OKSORI_MIX_MASTER = @as(u32, 6);
pub const MM_OKSORI_MIX_WAVE = @as(u32, 7);
pub const MM_OKSORI_MIX_FM = @as(u32, 8);
pub const MM_OKSORI_MIX_LINE = @as(u32, 9);
pub const MM_OKSORI_MIX_CD = @as(u32, 10);
pub const MM_OKSORI_MIX_MIC = @as(u32, 11);
pub const MM_OKSORI_MIX_ECHO = @as(u32, 12);
pub const MM_OKSORI_MIX_AUX1 = @as(u32, 13);
pub const MM_OKSORI_MIX_LINE1 = @as(u32, 14);
pub const MM_OKSORI_EXT_MIC1 = @as(u32, 15);
pub const MM_OKSORI_EXT_MIC2 = @as(u32, 16);
pub const MM_OKSORI_MIDIOUT = @as(u32, 17);
pub const MM_OKSORI_MIDIIN = @as(u32, 18);
pub const MM_OKSORI_MPEG_CDVISION = @as(u32, 19);
pub const MM_DIACOUSTICS_DRUM_ACTION = @as(u32, 1);
pub const MM_KAY_ELEMETRICS_CSL = @as(u32, 17152);
pub const MM_KAY_ELEMETRICS_CSL_DAT = @as(u32, 17160);
pub const MM_KAY_ELEMETRICS_CSL_4CHANNEL = @as(u32, 17161);
pub const MM_CRYSTAL_CS4232_WAVEIN = @as(u32, 1);
pub const MM_CRYSTAL_CS4232_WAVEOUT = @as(u32, 2);
pub const MM_CRYSTAL_CS4232_WAVEMIXER = @as(u32, 3);
pub const MM_CRYSTAL_CS4232_WAVEAUX_AUX1 = @as(u32, 4);
pub const MM_CRYSTAL_CS4232_WAVEAUX_AUX2 = @as(u32, 5);
pub const MM_CRYSTAL_CS4232_WAVEAUX_LINE = @as(u32, 6);
pub const MM_CRYSTAL_CS4232_WAVEAUX_MONO = @as(u32, 7);
pub const MM_CRYSTAL_CS4232_WAVEAUX_MASTER = @as(u32, 8);
pub const MM_CRYSTAL_CS4232_MIDIIN = @as(u32, 9);
pub const MM_CRYSTAL_CS4232_MIDIOUT = @as(u32, 10);
pub const MM_CRYSTAL_CS4232_INPUTGAIN_AUX1 = @as(u32, 13);
pub const MM_CRYSTAL_CS4232_INPUTGAIN_LOOP = @as(u32, 14);
pub const MM_CRYSTAL_SOUND_FUSION_WAVEIN = @as(u32, 21);
pub const MM_CRYSTAL_SOUND_FUSION_WAVEOUT = @as(u32, 22);
pub const MM_CRYSTAL_SOUND_FUSION_MIXER = @as(u32, 23);
pub const MM_CRYSTAL_SOUND_FUSION_MIDIIN = @as(u32, 24);
pub const MM_CRYSTAL_SOUND_FUSION_MIDIOUT = @as(u32, 25);
pub const MM_CRYSTAL_SOUND_FUSION_JOYSTICK = @as(u32, 26);
pub const MM_QUARTERDECK_LHWAVEIN = @as(u32, 0);
pub const MM_QUARTERDECK_LHWAVEOUT = @as(u32, 1);
pub const MM_TDK_MW_MIDI_SYNTH = @as(u32, 1);
pub const MM_TDK_MW_MIDI_IN = @as(u32, 2);
pub const MM_TDK_MW_MIDI_OUT = @as(u32, 3);
pub const MM_TDK_MW_WAVE_IN = @as(u32, 4);
pub const MM_TDK_MW_WAVE_OUT = @as(u32, 5);
pub const MM_TDK_MW_AUX = @as(u32, 6);
pub const MM_TDK_MW_MIXER = @as(u32, 10);
pub const MM_TDK_MW_AUX_MASTER = @as(u32, 100);
pub const MM_TDK_MW_AUX_BASS = @as(u32, 101);
pub const MM_TDK_MW_AUX_TREBLE = @as(u32, 102);
pub const MM_TDK_MW_AUX_MIDI_VOL = @as(u32, 103);
pub const MM_TDK_MW_AUX_WAVE_VOL = @as(u32, 104);
pub const MM_TDK_MW_AUX_WAVE_RVB = @as(u32, 105);
pub const MM_TDK_MW_AUX_WAVE_CHR = @as(u32, 106);
pub const MM_TDK_MW_AUX_VOL = @as(u32, 107);
pub const MM_TDK_MW_AUX_RVB = @as(u32, 108);
pub const MM_TDK_MW_AUX_CHR = @as(u32, 109);
pub const MM_DIGITAL_AUDIO_LABS_TC = @as(u32, 1);
pub const MM_DIGITAL_AUDIO_LABS_DOC = @as(u32, 2);
pub const MM_DIGITAL_AUDIO_LABS_V8 = @as(u32, 16);
pub const MM_DIGITAL_AUDIO_LABS_CPRO = @as(u32, 17);
pub const MM_DIGITAL_AUDIO_LABS_VP = @as(u32, 18);
pub const MM_DIGITAL_AUDIO_LABS_CDLX = @as(u32, 19);
pub const MM_DIGITAL_AUDIO_LABS_CTDIF = @as(u32, 20);
pub const MM_SEERSYS_SEERSYNTH = @as(u32, 1);
pub const MM_SEERSYS_SEERWAVE = @as(u32, 2);
pub const MM_SEERSYS_SEERMIX = @as(u32, 3);
pub const MM_SEERSYS_WAVESYNTH = @as(u32, 4);
pub const MM_SEERSYS_WAVESYNTH_WG = @as(u32, 5);
pub const MM_SEERSYS_REALITY = @as(u32, 6);
pub const MM_OSPREY_1000WAVEIN = @as(u32, 1);
pub const MM_OSPREY_1000WAVEOUT = @as(u32, 2);
pub const MM_SOUNDESIGNS_WAVEIN = @as(u32, 1);
pub const MM_SOUNDESIGNS_WAVEOUT = @as(u32, 2);
pub const MM_SSP_SNDFESWAVEIN = @as(u32, 1);
pub const MM_SSP_SNDFESWAVEOUT = @as(u32, 2);
pub const MM_SSP_SNDFESMIDIIN = @as(u32, 3);
pub const MM_SSP_SNDFESMIDIOUT = @as(u32, 4);
pub const MM_SSP_SNDFESSYNTH = @as(u32, 5);
pub const MM_SSP_SNDFESMIX = @as(u32, 6);
pub const MM_SSP_SNDFESAUX = @as(u32, 7);
pub const MM_ECS_AADF_MIDI_IN = @as(u32, 10);
pub const MM_ECS_AADF_MIDI_OUT = @as(u32, 11);
pub const MM_ECS_AADF_WAVE2MIDI_IN = @as(u32, 12);
pub const MM_AMD_INTERWAVE_WAVEIN = @as(u32, 1);
pub const MM_AMD_INTERWAVE_WAVEOUT = @as(u32, 2);
pub const MM_AMD_INTERWAVE_SYNTH = @as(u32, 3);
pub const MM_AMD_INTERWAVE_MIXER1 = @as(u32, 4);
pub const MM_AMD_INTERWAVE_MIXER2 = @as(u32, 5);
pub const MM_AMD_INTERWAVE_JOYSTICK = @as(u32, 6);
pub const MM_AMD_INTERWAVE_EX_CD = @as(u32, 7);
pub const MM_AMD_INTERWAVE_MIDIIN = @as(u32, 8);
pub const MM_AMD_INTERWAVE_MIDIOUT = @as(u32, 9);
pub const MM_AMD_INTERWAVE_AUX1 = @as(u32, 10);
pub const MM_AMD_INTERWAVE_AUX2 = @as(u32, 11);
pub const MM_AMD_INTERWAVE_AUX_MIC = @as(u32, 12);
pub const MM_AMD_INTERWAVE_AUX_CD = @as(u32, 13);
pub const MM_AMD_INTERWAVE_MONO_IN = @as(u32, 14);
pub const MM_AMD_INTERWAVE_MONO_OUT = @as(u32, 15);
pub const MM_AMD_INTERWAVE_EX_TELEPHONY = @as(u32, 16);
pub const MM_AMD_INTERWAVE_WAVEOUT_BASE = @as(u32, 17);
pub const MM_AMD_INTERWAVE_WAVEOUT_TREBLE = @as(u32, 18);
pub const MM_AMD_INTERWAVE_STEREO_ENHANCED = @as(u32, 19);
pub const MM_COREDYNAMICS_DYNAMIXHR = @as(u32, 1);
pub const MM_COREDYNAMICS_DYNASONIX_SYNTH = @as(u32, 2);
pub const MM_COREDYNAMICS_DYNASONIX_MIDI_IN = @as(u32, 3);
pub const MM_COREDYNAMICS_DYNASONIX_MIDI_OUT = @as(u32, 4);
pub const MM_COREDYNAMICS_DYNASONIX_WAVE_IN = @as(u32, 5);
pub const MM_COREDYNAMICS_DYNASONIX_WAVE_OUT = @as(u32, 6);
pub const MM_COREDYNAMICS_DYNASONIX_AUDIO_IN = @as(u32, 7);
pub const MM_COREDYNAMICS_DYNASONIX_AUDIO_OUT = @as(u32, 8);
pub const MM_COREDYNAMICS_DYNAGRAFX_VGA = @as(u32, 9);
pub const MM_COREDYNAMICS_DYNAGRAFX_WAVE_IN = @as(u32, 10);
pub const MM_COREDYNAMICS_DYNAGRAFX_WAVE_OUT = @as(u32, 11);
pub const MM_CANAM_CBXWAVEOUT = @as(u32, 1);
pub const MM_CANAM_CBXWAVEIN = @as(u32, 2);
pub const MM_SOFTSOUND_CODEC = @as(u32, 1);
pub const MM_NORRIS_VOICELINK = @as(u32, 1);
pub const MM_DDD_MIDILINK_MIDIIN = @as(u32, 1);
pub const MM_DDD_MIDILINK_MIDIOUT = @as(u32, 2);
pub const MM_EUPHONICS_AUX_CD = @as(u32, 1);
pub const MM_EUPHONICS_AUX_LINE = @as(u32, 2);
pub const MM_EUPHONICS_AUX_MASTER = @as(u32, 3);
pub const MM_EUPHONICS_AUX_MIC = @as(u32, 4);
pub const MM_EUPHONICS_AUX_MIDI = @as(u32, 5);
pub const MM_EUPHONICS_AUX_WAVE = @as(u32, 6);
pub const MM_EUPHONICS_FMSYNTH_MONO = @as(u32, 7);
pub const MM_EUPHONICS_FMSYNTH_STEREO = @as(u32, 8);
pub const MM_EUPHONICS_MIDIIN = @as(u32, 9);
pub const MM_EUPHONICS_MIDIOUT = @as(u32, 10);
pub const MM_EUPHONICS_MIXER = @as(u32, 11);
pub const MM_EUPHONICS_WAVEIN = @as(u32, 12);
pub const MM_EUPHONICS_WAVEOUT = @as(u32, 13);
pub const MM_EUPHONICS_EUSYNTH = @as(u32, 14);
pub const CRYSTAL_NET_SFM_CODEC = @as(u32, 1);
pub const MM_CHROMATIC_M1 = @as(u32, 1);
pub const MM_CHROMATIC_M1_WAVEIN = @as(u32, 2);
pub const MM_CHROMATIC_M1_WAVEOUT = @as(u32, 3);
pub const MM_CHROMATIC_M1_FMSYNTH = @as(u32, 4);
pub const MM_CHROMATIC_M1_MIXER = @as(u32, 5);
pub const MM_CHROMATIC_M1_AUX = @as(u32, 6);
pub const MM_CHROMATIC_M1_AUX_CD = @as(u32, 7);
pub const MM_CHROMATIC_M1_MIDIIN = @as(u32, 8);
pub const MM_CHROMATIC_M1_MIDIOUT = @as(u32, 9);
pub const MM_CHROMATIC_M1_WTSYNTH = @as(u32, 16);
pub const MM_CHROMATIC_M1_MPEGWAVEIN = @as(u32, 17);
pub const MM_CHROMATIC_M1_MPEGWAVEOUT = @as(u32, 18);
pub const MM_CHROMATIC_M2 = @as(u32, 19);
pub const MM_CHROMATIC_M2_WAVEIN = @as(u32, 20);
pub const MM_CHROMATIC_M2_WAVEOUT = @as(u32, 21);
pub const MM_CHROMATIC_M2_FMSYNTH = @as(u32, 22);
pub const MM_CHROMATIC_M2_MIXER = @as(u32, 23);
pub const MM_CHROMATIC_M2_AUX = @as(u32, 24);
pub const MM_CHROMATIC_M2_AUX_CD = @as(u32, 25);
pub const MM_CHROMATIC_M2_MIDIIN = @as(u32, 32);
pub const MM_CHROMATIC_M2_MIDIOUT = @as(u32, 33);
pub const MM_CHROMATIC_M2_WTSYNTH = @as(u32, 34);
pub const MM_CHROMATIC_M2_MPEGWAVEIN = @as(u32, 35);
pub const MM_CHROMATIC_M2_MPEGWAVEOUT = @as(u32, 36);
pub const MM_VIENNASYS_TSP_WAVE_DRIVER = @as(u32, 1);
pub const MM_CONNECTIX_VIDEC_CODEC = @as(u32, 1);
pub const MM_GADGETLABS_WAVE44_WAVEIN = @as(u32, 1);
pub const MM_GADGETLABS_WAVE44_WAVEOUT = @as(u32, 2);
pub const MM_GADGETLABS_WAVE42_WAVEIN = @as(u32, 3);
pub const MM_GADGETLABS_WAVE42_WAVEOUT = @as(u32, 4);
pub const MM_GADGETLABS_WAVE4_MIDIIN = @as(u32, 5);
pub const MM_GADGETLABS_WAVE4_MIDIOUT = @as(u32, 6);
pub const MM_FRONTIER_WAVECENTER_MIDIIN = @as(u32, 1);
pub const MM_FRONTIER_WAVECENTER_MIDIOUT = @as(u32, 2);
pub const MM_FRONTIER_WAVECENTER_WAVEIN = @as(u32, 3);
pub const MM_FRONTIER_WAVECENTER_WAVEOUT = @as(u32, 4);
pub const MM_VIONA_QVINPCI_MIXER = @as(u32, 1);
pub const MM_VIONA_QVINPCI_WAVEIN = @as(u32, 2);
pub const MM_VIONAQVINPCI_WAVEOUT = @as(u32, 3);
pub const MM_VIONA_BUSTER_MIXER = @as(u32, 4);
pub const MM_VIONA_CINEMASTER_MIXER = @as(u32, 5);
pub const MM_VIONA_CONCERTO_MIXER = @as(u32, 6);
pub const MM_CASIO_WP150_MIDIOUT = @as(u32, 1);
pub const MM_CASIO_WP150_MIDIIN = @as(u32, 2);
pub const MM_CASIO_LSG_MIDIOUT = @as(u32, 3);
pub const MM_DIMD_PLATFORM = @as(u32, 0);
pub const MM_DIMD_DIRSOUND = @as(u32, 1);
pub const MM_DIMD_VIRTMPU = @as(u32, 2);
pub const MM_DIMD_VIRTSB = @as(u32, 3);
pub const MM_DIMD_VIRTJOY = @as(u32, 4);
pub const MM_DIMD_WAVEIN = @as(u32, 5);
pub const MM_DIMD_WAVEOUT = @as(u32, 6);
pub const MM_DIMD_MIDIIN = @as(u32, 7);
pub const MM_DIMD_MIDIOUT = @as(u32, 8);
pub const MM_DIMD_AUX_LINE = @as(u32, 9);
pub const MM_DIMD_MIXER = @as(u32, 10);
pub const MM_DIMD_WSS_WAVEIN = @as(u32, 14);
pub const MM_DIMD_WSS_WAVEOUT = @as(u32, 15);
pub const MM_DIMD_WSS_MIXER = @as(u32, 17);
pub const MM_DIMD_WSS_AUX = @as(u32, 21);
pub const MM_DIMD_WSS_SYNTH = @as(u32, 76);
pub const MM_S3_WAVEOUT = @as(u32, 1);
pub const MM_S3_WAVEIN = @as(u32, 2);
pub const MM_S3_MIDIOUT = @as(u32, 3);
pub const MM_S3_MIDIIN = @as(u32, 4);
pub const MM_S3_FMSYNTH = @as(u32, 5);
pub const MM_S3_MIXER = @as(u32, 6);
pub const MM_S3_AUX = @as(u32, 7);
pub const MM_VKC_MPU401_MIDIIN = @as(u32, 256);
pub const MM_VKC_SERIAL_MIDIIN = @as(u32, 257);
pub const MM_VKC_MPU401_MIDIOUT = @as(u32, 512);
pub const MM_VKC_SERIAL_MIDIOUT = @as(u32, 513);
pub const MM_ZEFIRO_ZA2 = @as(u32, 2);
pub const MM_FHGIIS_MPEGLAYER3_DECODE = @as(u32, 9);
pub const MM_FHGIIS_MPEGLAYER3 = @as(u32, 10);
pub const MM_FHGIIS_MPEGLAYER3_LITE = @as(u32, 10);
pub const MM_FHGIIS_MPEGLAYER3_BASIC = @as(u32, 11);
pub const MM_FHGIIS_MPEGLAYER3_ADVANCED = @as(u32, 12);
pub const MM_FHGIIS_MPEGLAYER3_PROFESSIONAL = @as(u32, 13);
pub const MM_FHGIIS_MPEGLAYER3_ADVANCEDPLUS = @as(u32, 14);
pub const MM_QUICKNET_PJWAVEIN = @as(u32, 1);
pub const MM_QUICKNET_PJWAVEOUT = @as(u32, 2);
pub const MM_SICRESOURCE_SSO3D = @as(u32, 2);
pub const MM_SICRESOURCE_SSOW3DI = @as(u32, 3);
pub const MM_NEOMAGIC_SYNTH = @as(u32, 1);
pub const MM_NEOMAGIC_WAVEOUT = @as(u32, 2);
pub const MM_NEOMAGIC_WAVEIN = @as(u32, 3);
pub const MM_NEOMAGIC_MIDIOUT = @as(u32, 4);
pub const MM_NEOMAGIC_MIDIIN = @as(u32, 5);
pub const MM_NEOMAGIC_AUX = @as(u32, 6);
pub const MM_NEOMAGIC_MW3DX_WAVEOUT = @as(u32, 10);
pub const MM_NEOMAGIC_MW3DX_WAVEIN = @as(u32, 11);
pub const MM_NEOMAGIC_MW3DX_MIDIOUT = @as(u32, 12);
pub const MM_NEOMAGIC_MW3DX_MIDIIN = @as(u32, 13);
pub const MM_NEOMAGIC_MW3DX_FMSYNTH = @as(u32, 14);
pub const MM_NEOMAGIC_MW3DX_GMSYNTH = @as(u32, 15);
pub const MM_NEOMAGIC_MW3DX_MIXER = @as(u32, 16);
pub const MM_NEOMAGIC_MW3DX_AUX = @as(u32, 17);
pub const MM_NEOMAGIC_MWAVE_WAVEOUT = @as(u32, 20);
pub const MM_NEOMAGIC_MWAVE_WAVEIN = @as(u32, 21);
pub const MM_NEOMAGIC_MWAVE_MIDIOUT = @as(u32, 22);
pub const MM_NEOMAGIC_MWAVE_MIDIIN = @as(u32, 23);
pub const MM_NEOMAGIC_MWAVE_MIXER = @as(u32, 24);
pub const MM_NEOMAGIC_MWAVE_AUX = @as(u32, 25);
pub const MM_MERGING_MPEGL3 = @as(u32, 1);
pub const MM_XIRLINK_VISIONLINK = @as(u32, 1);
pub const MM_OTI_611WAVEIN = @as(u32, 5);
pub const MM_OTI_611WAVEOUT = @as(u32, 6);
pub const MM_OTI_611MIXER = @as(u32, 7);
pub const MM_OTI_611MIDIN = @as(u32, 18);
pub const MM_OTI_611MIDIOUT = @as(u32, 19);
pub const MM_AUREAL_AU8820 = @as(u32, 16);
pub const MM_AU8820_SYNTH = @as(u32, 17);
pub const MM_AU8820_WAVEOUT = @as(u32, 18);
pub const MM_AU8820_WAVEIN = @as(u32, 19);
pub const MM_AU8820_MIXER = @as(u32, 20);
pub const MM_AU8820_AUX = @as(u32, 21);
pub const MM_AU8820_MIDIOUT = @as(u32, 22);
pub const MM_AU8820_MIDIIN = @as(u32, 23);
pub const MM_AUREAL_AU8830 = @as(u32, 32);
pub const MM_AU8830_SYNTH = @as(u32, 33);
pub const MM_AU8830_WAVEOUT = @as(u32, 34);
pub const MM_AU8830_WAVEIN = @as(u32, 35);
pub const MM_AU8830_MIXER = @as(u32, 36);
pub const MM_AU8830_AUX = @as(u32, 37);
pub const MM_AU8830_MIDIOUT = @as(u32, 38);
pub const MM_AU8830_MIDIIN = @as(u32, 39);
pub const MM_VIVO_AUDIO_CODEC = @as(u32, 1);
pub const MM_SHARP_MDC_MIDI_SYNTH = @as(u32, 1);
pub const MM_SHARP_MDC_MIDI_IN = @as(u32, 2);
pub const MM_SHARP_MDC_MIDI_OUT = @as(u32, 3);
pub const MM_SHARP_MDC_WAVE_IN = @as(u32, 4);
pub const MM_SHARP_MDC_WAVE_OUT = @as(u32, 5);
pub const MM_SHARP_MDC_AUX = @as(u32, 6);
pub const MM_SHARP_MDC_MIXER = @as(u32, 10);
pub const MM_SHARP_MDC_AUX_MASTER = @as(u32, 100);
pub const MM_SHARP_MDC_AUX_BASS = @as(u32, 101);
pub const MM_SHARP_MDC_AUX_TREBLE = @as(u32, 102);
pub const MM_SHARP_MDC_AUX_MIDI_VOL = @as(u32, 103);
pub const MM_SHARP_MDC_AUX_WAVE_VOL = @as(u32, 104);
pub const MM_SHARP_MDC_AUX_WAVE_RVB = @as(u32, 105);
pub const MM_SHARP_MDC_AUX_WAVE_CHR = @as(u32, 106);
pub const MM_SHARP_MDC_AUX_VOL = @as(u32, 107);
pub const MM_SHARP_MDC_AUX_RVB = @as(u32, 108);
pub const MM_SHARP_MDC_AUX_CHR = @as(u32, 109);
pub const MM_LUCENT_ACM_G723 = @as(u32, 0);
pub const MM_ATT_G729A = @as(u32, 1);
pub const MM_MARIAN_ARC44WAVEIN = @as(u32, 1);
pub const MM_MARIAN_ARC44WAVEOUT = @as(u32, 2);
pub const MM_MARIAN_PRODIF24WAVEIN = @as(u32, 3);
pub const MM_MARIAN_PRODIF24WAVEOUT = @as(u32, 4);
pub const MM_MARIAN_ARC88WAVEIN = @as(u32, 5);
pub const MM_MARIAN_ARC88WAVEOUT = @as(u32, 6);
pub const MM_BCB_NETBOARD_10 = @as(u32, 1);
pub const MM_BCB_TT75_10 = @as(u32, 2);
pub const MM_MOTIONPIXELS_MVI2 = @as(u32, 1);
pub const MM_QDESIGN_ACM_MPEG = @as(u32, 1);
pub const MM_QDESIGN_ACM_QDESIGN_MUSIC = @as(u32, 2);
pub const MM_NMP_CCP_WAVEIN = @as(u32, 1);
pub const MM_NMP_CCP_WAVEOUT = @as(u32, 2);
pub const MM_NMP_ACM_AMR = @as(u32, 10);
pub const MM_DF_ACM_G726 = @as(u32, 1);
pub const MM_DF_ACM_GSM610 = @as(u32, 2);
pub const MM_BERCOS_WAVEIN = @as(u32, 1);
pub const MM_BERCOS_MIXER = @as(u32, 2);
pub const MM_BERCOS_WAVEOUT = @as(u32, 3);
pub const MM_ONLIVE_MPCODEC = @as(u32, 1);
pub const MM_PHONET_PP_WAVEOUT = @as(u32, 1);
pub const MM_PHONET_PP_WAVEIN = @as(u32, 2);
pub const MM_PHONET_PP_MIXER = @as(u32, 3);
pub const MM_FTR_ENCODER_WAVEIN = @as(u32, 1);
pub const MM_FTR_ACM = @as(u32, 2);
pub const MM_ENET_T2000_LINEIN = @as(u32, 1);
pub const MM_ENET_T2000_LINEOUT = @as(u32, 2);
pub const MM_ENET_T2000_HANDSETIN = @as(u32, 3);
pub const MM_ENET_T2000_HANDSETOUT = @as(u32, 4);
pub const MM_EMAGIC_UNITOR8 = @as(u32, 1);
pub const MM_SIPROLAB_ACELPNET = @as(u32, 1);
pub const MM_DICTAPHONE_G726 = @as(u32, 1);
pub const MM_RZS_ACM_TUBGSM = @as(u32, 1);
pub const MM_EES_PCMIDI14 = @as(u32, 1);
pub const MM_EES_PCMIDI14_IN = @as(u32, 2);
pub const MM_EES_PCMIDI14_OUT1 = @as(u32, 3);
pub const MM_EES_PCMIDI14_OUT2 = @as(u32, 4);
pub const MM_EES_PCMIDI14_OUT3 = @as(u32, 5);
pub const MM_EES_PCMIDI14_OUT4 = @as(u32, 6);
pub const MM_HAFTMANN_LPTDAC2 = @as(u32, 1);
pub const MM_LUCID_PCI24WAVEIN = @as(u32, 1);
pub const MM_LUCID_PCI24WAVEOUT = @as(u32, 2);
pub const MM_HEADSPACE_HAESYNTH = @as(u32, 1);
pub const MM_HEADSPACE_HAEWAVEOUT = @as(u32, 2);
pub const MM_HEADSPACE_HAEWAVEIN = @as(u32, 3);
pub const MM_HEADSPACE_HAEMIXER = @as(u32, 4);
pub const MM_UNISYS_ACM_NAP = @as(u32, 1);
pub const MM_LUMINOSITI_SCWAVEIN = @as(u32, 1);
pub const MM_LUMINOSITI_SCWAVEOUT = @as(u32, 2);
pub const MM_LUMINOSITI_SCWAVEMIX = @as(u32, 3);
pub const MM_ACTIVEVOICE_ACM_VOXADPCM = @as(u32, 1);
pub const MM_DTS_DS = @as(u32, 1);
pub const MM_SOFTLAB_NSK_FRW_WAVEIN = @as(u32, 1);
pub const MM_SOFTLAB_NSK_FRW_WAVEOUT = @as(u32, 2);
pub const MM_SOFTLAB_NSK_FRW_MIXER = @as(u32, 3);
pub const MM_SOFTLAB_NSK_FRW_AUX = @as(u32, 4);
pub const MM_FORTEMEDIA_WAVEIN = @as(u32, 1);
pub const MM_FORTEMEDIA_WAVEOUT = @as(u32, 2);
pub const MM_FORTEMEDIA_FMSYNC = @as(u32, 3);
pub const MM_FORTEMEDIA_MIXER = @as(u32, 4);
pub const MM_FORTEMEDIA_AUX = @as(u32, 5);
pub const MM_SONORUS_STUDIO = @as(u32, 1);
pub const MM_I_LINK_VOICE_CODER = @as(u32, 1);
pub const MM_SELSIUS_SYSTEMS_RTPWAVEOUT = @as(u32, 1);
pub const MM_SELSIUS_SYSTEMS_RTPWAVEIN = @as(u32, 2);
pub const MM_ADMOS_FM_SYNTH = @as(u32, 1);
pub const MM_ADMOS_QS3AMIDIOUT = @as(u32, 2);
pub const MM_ADMOS_QS3AMIDIIN = @as(u32, 3);
pub const MM_ADMOS_QS3AWAVEOUT = @as(u32, 4);
pub const MM_ADMOS_QS3AWAVEIN = @as(u32, 5);
pub const MM_LEXICON_STUDIO_WAVE_OUT = @as(u32, 1);
pub const MM_LEXICON_STUDIO_WAVE_IN = @as(u32, 2);
pub const MM_SGI_320_WAVEIN = @as(u32, 1);
pub const MM_SGI_320_WAVEOUT = @as(u32, 2);
pub const MM_SGI_320_MIXER = @as(u32, 3);
pub const MM_SGI_540_WAVEIN = @as(u32, 4);
pub const MM_SGI_540_WAVEOUT = @as(u32, 5);
pub const MM_SGI_540_MIXER = @as(u32, 6);
pub const MM_SGI_RAD_ADATMONO1_WAVEIN = @as(u32, 7);
pub const MM_SGI_RAD_ADATMONO2_WAVEIN = @as(u32, 8);
pub const MM_SGI_RAD_ADATMONO3_WAVEIN = @as(u32, 9);
pub const MM_SGI_RAD_ADATMONO4_WAVEIN = @as(u32, 10);
pub const MM_SGI_RAD_ADATMONO5_WAVEIN = @as(u32, 11);
pub const MM_SGI_RAD_ADATMONO6_WAVEIN = @as(u32, 12);
pub const MM_SGI_RAD_ADATMONO7_WAVEIN = @as(u32, 13);
pub const MM_SGI_RAD_ADATMONO8_WAVEIN = @as(u32, 14);
pub const MM_SGI_RAD_ADATSTEREO12_WAVEIN = @as(u32, 15);
pub const MM_SGI_RAD_ADATSTEREO34_WAVEIN = @as(u32, 16);
pub const MM_SGI_RAD_ADATSTEREO56_WAVEIN = @as(u32, 17);
pub const MM_SGI_RAD_ADATSTEREO78_WAVEIN = @as(u32, 18);
pub const MM_SGI_RAD_ADAT8CHAN_WAVEIN = @as(u32, 19);
pub const MM_SGI_RAD_ADATMONO1_WAVEOUT = @as(u32, 20);
pub const MM_SGI_RAD_ADATMONO2_WAVEOUT = @as(u32, 21);
pub const MM_SGI_RAD_ADATMONO3_WAVEOUT = @as(u32, 22);
pub const MM_SGI_RAD_ADATMONO4_WAVEOUT = @as(u32, 23);
pub const MM_SGI_RAD_ADATMONO5_WAVEOUT = @as(u32, 24);
pub const MM_SGI_RAD_ADATMONO6_WAVEOUT = @as(u32, 25);
pub const MM_SGI_RAD_ADATMONO7_WAVEOUT = @as(u32, 26);
pub const MM_SGI_RAD_ADATMONO8_WAVEOUT = @as(u32, 27);
pub const MM_SGI_RAD_ADATSTEREO12_WAVEOUT = @as(u32, 28);
pub const MM_SGI_RAD_ADATSTEREO32_WAVEOUT = @as(u32, 29);
pub const MM_SGI_RAD_ADATSTEREO56_WAVEOUT = @as(u32, 30);
pub const MM_SGI_RAD_ADATSTEREO78_WAVEOUT = @as(u32, 31);
pub const MM_SGI_RAD_ADAT8CHAN_WAVEOUT = @as(u32, 32);
pub const MM_SGI_RAD_AESMONO1_WAVEIN = @as(u32, 33);
pub const MM_SGI_RAD_AESMONO2_WAVEIN = @as(u32, 34);
pub const MM_SGI_RAD_AESSTEREO_WAVEIN = @as(u32, 35);
pub const MM_SGI_RAD_AESMONO1_WAVEOUT = @as(u32, 36);
pub const MM_SGI_RAD_AESMONO2_WAVEOUT = @as(u32, 37);
pub const MM_SGI_RAD_AESSTEREO_WAVEOUT = @as(u32, 38);
pub const MM_IPI_ACM_HSX = @as(u32, 1);
pub const MM_IPI_ACM_RPELP = @as(u32, 2);
pub const MM_IPI_WF_ASSS = @as(u32, 3);
pub const MM_IPI_AT_WAVEOUT = @as(u32, 4);
pub const MM_IPI_AT_WAVEIN = @as(u32, 5);
pub const MM_IPI_AT_MIXER = @as(u32, 6);
pub const MM_ICE_WAVEOUT = @as(u32, 1);
pub const MM_ICE_WAVEIN = @as(u32, 2);
pub const MM_ICE_MTWAVEOUT = @as(u32, 3);
pub const MM_ICE_MTWAVEIN = @as(u32, 4);
pub const MM_ICE_MIDIOUT1 = @as(u32, 5);
pub const MM_ICE_MIDIIN1 = @as(u32, 6);
pub const MM_ICE_MIDIOUT2 = @as(u32, 7);
pub const MM_ICE_MIDIIN2 = @as(u32, 8);
pub const MM_ICE_SYNTH = @as(u32, 9);
pub const MM_ICE_MIXER = @as(u32, 10);
pub const MM_ICE_AUX = @as(u32, 11);
pub const MM_VQST_VQC1 = @as(u32, 1);
pub const MM_VQST_VQC2 = @as(u32, 2);
pub const MM_ETEK_KWIKMIDI_MIDIIN = @as(u32, 1);
pub const MM_ETEK_KWIKMIDI_MIDIOUT = @as(u32, 2);
pub const MM_INTERNET_SSW_MIDIOUT = @as(u32, 10);
pub const MM_INTERNET_SSW_MIDIIN = @as(u32, 11);
pub const MM_INTERNET_SSW_WAVEOUT = @as(u32, 12);
pub const MM_INTERNET_SSW_WAVEIN = @as(u32, 13);
pub const MM_SONY_ACM_SCX = @as(u32, 1);
pub const MM_UH_ACM_ADPCM = @as(u32, 1);
pub const MM_SYDEC_NV_WAVEIN = @as(u32, 1);
pub const MM_SYDEC_NV_WAVEOUT = @as(u32, 2);
pub const MM_FLEXION_X300_WAVEIN = @as(u32, 1);
pub const MM_FLEXION_X300_WAVEOUT = @as(u32, 2);
pub const MM_VIA_WAVEOUT = @as(u32, 1);
pub const MM_VIA_WAVEIN = @as(u32, 2);
pub const MM_VIA_MIXER = @as(u32, 3);
pub const MM_VIA_AUX = @as(u32, 4);
pub const MM_VIA_MPU401_MIDIOUT = @as(u32, 5);
pub const MM_VIA_MPU401_MIDIIN = @as(u32, 6);
pub const MM_VIA_SWFM_SYNTH = @as(u32, 7);
pub const MM_VIA_WDM_WAVEOUT = @as(u32, 8);
pub const MM_VIA_WDM_WAVEIN = @as(u32, 9);
pub const MM_VIA_WDM_MIXER = @as(u32, 10);
pub const MM_VIA_WDM_MPU401_MIDIOUT = @as(u32, 11);
pub const MM_VIA_WDM_MPU401_MIDIIN = @as(u32, 12);
pub const MM_MICRONAS_SC4 = @as(u32, 1);
pub const MM_MICRONAS_CLP833 = @as(u32, 2);
pub const MM_HP_WAVEOUT = @as(u32, 1);
pub const MM_HP_WAVEIN = @as(u32, 2);
pub const MM_QUICKAUDIO_MINIMIDI = @as(u32, 1);
pub const MM_QUICKAUDIO_MAXIMIDI = @as(u32, 2);
pub const MM_ICCC_UNA3_WAVEIN = @as(u32, 1);
pub const MM_ICCC_UNA3_WAVEOUT = @as(u32, 2);
pub const MM_ICCC_UNA3_AUX = @as(u32, 3);
pub const MM_ICCC_UNA3_MIXER = @as(u32, 4);
pub const MM_3COM_CB_MIXER = @as(u32, 1);
pub const MM_3COM_CB_WAVEIN = @as(u32, 2);
pub const MM_3COM_CB_WAVEOUT = @as(u32, 3);
pub const MM_MINDMAKER_GC_WAVEIN = @as(u32, 1);
pub const MM_MINDMAKER_GC_WAVEOUT = @as(u32, 2);
pub const MM_MINDMAKER_GC_MIXER = @as(u32, 3);
pub const MM_TELEKOL_WAVEOUT = @as(u32, 1);
pub const MM_TELEKOL_WAVEIN = @as(u32, 2);
pub const MM_ALGOVISION_VB80WAVEOUT = @as(u32, 1);
pub const MM_ALGOVISION_VB80WAVEIN = @as(u32, 2);
pub const MM_ALGOVISION_VB80MIXER = @as(u32, 3);
pub const MM_ALGOVISION_VB80AUX = @as(u32, 4);
pub const MM_ALGOVISION_VB80AUX2 = @as(u32, 5);
pub const WAVE_FORMAT_UNKNOWN = @as(u32, 0);
pub const WAVE_FORMAT_ADPCM = @as(u32, 2);
pub const WAVE_FORMAT_IEEE_FLOAT = @as(u32, 3);
pub const WAVE_FORMAT_VSELP = @as(u32, 4);
pub const WAVE_FORMAT_IBM_CVSD = @as(u32, 5);
pub const WAVE_FORMAT_ALAW = @as(u32, 6);
pub const WAVE_FORMAT_MULAW = @as(u32, 7);
pub const WAVE_FORMAT_DTS = @as(u32, 8);
pub const WAVE_FORMAT_DRM = @as(u32, 9);
pub const WAVE_FORMAT_WMAVOICE9 = @as(u32, 10);
pub const WAVE_FORMAT_WMAVOICE10 = @as(u32, 11);
pub const WAVE_FORMAT_OKI_ADPCM = @as(u32, 16);
pub const WAVE_FORMAT_DVI_ADPCM = @as(u32, 17);
pub const WAVE_FORMAT_MEDIASPACE_ADPCM = @as(u32, 18);
pub const WAVE_FORMAT_SIERRA_ADPCM = @as(u32, 19);
pub const WAVE_FORMAT_G723_ADPCM = @as(u32, 20);
pub const WAVE_FORMAT_DIGISTD = @as(u32, 21);
pub const WAVE_FORMAT_DIGIFIX = @as(u32, 22);
pub const WAVE_FORMAT_DIALOGIC_OKI_ADPCM = @as(u32, 23);
pub const WAVE_FORMAT_MEDIAVISION_ADPCM = @as(u32, 24);
pub const WAVE_FORMAT_CU_CODEC = @as(u32, 25);
pub const WAVE_FORMAT_HP_DYN_VOICE = @as(u32, 26);
pub const WAVE_FORMAT_YAMAHA_ADPCM = @as(u32, 32);
pub const WAVE_FORMAT_SONARC = @as(u32, 33);
pub const WAVE_FORMAT_DSPGROUP_TRUESPEECH = @as(u32, 34);
pub const WAVE_FORMAT_ECHOSC1 = @as(u32, 35);
pub const WAVE_FORMAT_AUDIOFILE_AF36 = @as(u32, 36);
pub const WAVE_FORMAT_APTX = @as(u32, 37);
pub const WAVE_FORMAT_AUDIOFILE_AF10 = @as(u32, 38);
pub const WAVE_FORMAT_PROSODY_1612 = @as(u32, 39);
pub const WAVE_FORMAT_LRC = @as(u32, 40);
pub const WAVE_FORMAT_DOLBY_AC2 = @as(u32, 48);
pub const WAVE_FORMAT_GSM610 = @as(u32, 49);
pub const WAVE_FORMAT_MSNAUDIO = @as(u32, 50);
pub const WAVE_FORMAT_ANTEX_ADPCME = @as(u32, 51);
pub const WAVE_FORMAT_CONTROL_RES_VQLPC = @as(u32, 52);
pub const WAVE_FORMAT_DIGIREAL = @as(u32, 53);
pub const WAVE_FORMAT_DIGIADPCM = @as(u32, 54);
pub const WAVE_FORMAT_CONTROL_RES_CR10 = @as(u32, 55);
pub const WAVE_FORMAT_NMS_VBXADPCM = @as(u32, 56);
pub const WAVE_FORMAT_CS_IMAADPCM = @as(u32, 57);
pub const WAVE_FORMAT_ECHOSC3 = @as(u32, 58);
pub const WAVE_FORMAT_ROCKWELL_ADPCM = @as(u32, 59);
pub const WAVE_FORMAT_ROCKWELL_DIGITALK = @as(u32, 60);
pub const WAVE_FORMAT_XEBEC = @as(u32, 61);
pub const WAVE_FORMAT_G721_ADPCM = @as(u32, 64);
pub const WAVE_FORMAT_G728_CELP = @as(u32, 65);
pub const WAVE_FORMAT_MSG723 = @as(u32, 66);
pub const WAVE_FORMAT_INTEL_G723_1 = @as(u32, 67);
pub const WAVE_FORMAT_INTEL_G729 = @as(u32, 68);
pub const WAVE_FORMAT_SHARP_G726 = @as(u32, 69);
pub const WAVE_FORMAT_MPEG = @as(u32, 80);
pub const WAVE_FORMAT_RT24 = @as(u32, 82);
pub const WAVE_FORMAT_PAC = @as(u32, 83);
pub const WAVE_FORMAT_MPEGLAYER3 = @as(u32, 85);
pub const WAVE_FORMAT_LUCENT_G723 = @as(u32, 89);
pub const WAVE_FORMAT_CIRRUS = @as(u32, 96);
pub const WAVE_FORMAT_ESPCM = @as(u32, 97);
pub const WAVE_FORMAT_VOXWARE = @as(u32, 98);
pub const WAVE_FORMAT_CANOPUS_ATRAC = @as(u32, 99);
pub const WAVE_FORMAT_G726_ADPCM = @as(u32, 100);
pub const WAVE_FORMAT_G722_ADPCM = @as(u32, 101);
pub const WAVE_FORMAT_DSAT = @as(u32, 102);
pub const WAVE_FORMAT_DSAT_DISPLAY = @as(u32, 103);
pub const WAVE_FORMAT_VOXWARE_BYTE_ALIGNED = @as(u32, 105);
pub const WAVE_FORMAT_VOXWARE_AC8 = @as(u32, 112);
pub const WAVE_FORMAT_VOXWARE_AC10 = @as(u32, 113);
pub const WAVE_FORMAT_VOXWARE_AC16 = @as(u32, 114);
pub const WAVE_FORMAT_VOXWARE_AC20 = @as(u32, 115);
pub const WAVE_FORMAT_VOXWARE_RT24 = @as(u32, 116);
pub const WAVE_FORMAT_VOXWARE_RT29 = @as(u32, 117);
pub const WAVE_FORMAT_VOXWARE_RT29HW = @as(u32, 118);
pub const WAVE_FORMAT_VOXWARE_VR12 = @as(u32, 119);
pub const WAVE_FORMAT_VOXWARE_VR18 = @as(u32, 120);
pub const WAVE_FORMAT_VOXWARE_TQ40 = @as(u32, 121);
pub const WAVE_FORMAT_VOXWARE_SC3 = @as(u32, 122);
pub const WAVE_FORMAT_VOXWARE_SC3_1 = @as(u32, 123);
pub const WAVE_FORMAT_SOFTSOUND = @as(u32, 128);
pub const WAVE_FORMAT_VOXWARE_TQ60 = @as(u32, 129);
pub const WAVE_FORMAT_MSRT24 = @as(u32, 130);
pub const WAVE_FORMAT_G729A = @as(u32, 131);
pub const WAVE_FORMAT_MVI_MVI2 = @as(u32, 132);
pub const WAVE_FORMAT_DF_G726 = @as(u32, 133);
pub const WAVE_FORMAT_DF_GSM610 = @as(u32, 134);
pub const WAVE_FORMAT_ISIAUDIO = @as(u32, 136);
pub const WAVE_FORMAT_ONLIVE = @as(u32, 137);
pub const WAVE_FORMAT_MULTITUDE_FT_SX20 = @as(u32, 138);
pub const WAVE_FORMAT_INFOCOM_ITS_G721_ADPCM = @as(u32, 139);
pub const WAVE_FORMAT_CONVEDIA_G729 = @as(u32, 140);
pub const WAVE_FORMAT_CONGRUENCY = @as(u32, 141);
pub const WAVE_FORMAT_SBC24 = @as(u32, 145);
pub const WAVE_FORMAT_DOLBY_AC3_SPDIF = @as(u32, 146);
pub const WAVE_FORMAT_MEDIASONIC_G723 = @as(u32, 147);
pub const WAVE_FORMAT_PROSODY_8KBPS = @as(u32, 148);
pub const WAVE_FORMAT_ZYXEL_ADPCM = @as(u32, 151);
pub const WAVE_FORMAT_PHILIPS_LPCBB = @as(u32, 152);
pub const WAVE_FORMAT_PACKED = @as(u32, 153);
pub const WAVE_FORMAT_MALDEN_PHONYTALK = @as(u32, 160);
pub const WAVE_FORMAT_RACAL_RECORDER_GSM = @as(u32, 161);
pub const WAVE_FORMAT_RACAL_RECORDER_G720_A = @as(u32, 162);
pub const WAVE_FORMAT_RACAL_RECORDER_G723_1 = @as(u32, 163);
pub const WAVE_FORMAT_RACAL_RECORDER_TETRA_ACELP = @as(u32, 164);
pub const WAVE_FORMAT_NEC_AAC = @as(u32, 176);
pub const WAVE_FORMAT_RAW_AAC1 = @as(u32, 255);
pub const WAVE_FORMAT_RHETOREX_ADPCM = @as(u32, 256);
pub const WAVE_FORMAT_IRAT = @as(u32, 257);
pub const WAVE_FORMAT_VIVO_G723 = @as(u32, 273);
pub const WAVE_FORMAT_VIVO_SIREN = @as(u32, 274);
pub const WAVE_FORMAT_PHILIPS_CELP = @as(u32, 288);
pub const WAVE_FORMAT_PHILIPS_GRUNDIG = @as(u32, 289);
pub const WAVE_FORMAT_DIGITAL_G723 = @as(u32, 291);
pub const WAVE_FORMAT_SANYO_LD_ADPCM = @as(u32, 293);
pub const WAVE_FORMAT_SIPROLAB_ACEPLNET = @as(u32, 304);
pub const WAVE_FORMAT_SIPROLAB_ACELP4800 = @as(u32, 305);
pub const WAVE_FORMAT_SIPROLAB_ACELP8V3 = @as(u32, 306);
pub const WAVE_FORMAT_SIPROLAB_G729 = @as(u32, 307);
pub const WAVE_FORMAT_SIPROLAB_G729A = @as(u32, 308);
pub const WAVE_FORMAT_SIPROLAB_KELVIN = @as(u32, 309);
pub const WAVE_FORMAT_VOICEAGE_AMR = @as(u32, 310);
pub const WAVE_FORMAT_G726ADPCM = @as(u32, 320);
pub const WAVE_FORMAT_DICTAPHONE_CELP68 = @as(u32, 321);
pub const WAVE_FORMAT_DICTAPHONE_CELP54 = @as(u32, 322);
pub const WAVE_FORMAT_QUALCOMM_PUREVOICE = @as(u32, 336);
pub const WAVE_FORMAT_QUALCOMM_HALFRATE = @as(u32, 337);
pub const WAVE_FORMAT_TUBGSM = @as(u32, 341);
pub const WAVE_FORMAT_MSAUDIO1 = @as(u32, 352);
pub const WAVE_FORMAT_WMAUDIO2 = @as(u32, 353);
pub const WAVE_FORMAT_WMAUDIO3 = @as(u32, 354);
pub const WAVE_FORMAT_WMAUDIO_LOSSLESS = @as(u32, 355);
pub const WAVE_FORMAT_WMASPDIF = @as(u32, 356);
pub const WAVE_FORMAT_UNISYS_NAP_ADPCM = @as(u32, 368);
pub const WAVE_FORMAT_UNISYS_NAP_ULAW = @as(u32, 369);
pub const WAVE_FORMAT_UNISYS_NAP_ALAW = @as(u32, 370);
pub const WAVE_FORMAT_UNISYS_NAP_16K = @as(u32, 371);
pub const WAVE_FORMAT_SYCOM_ACM_SYC008 = @as(u32, 372);
pub const WAVE_FORMAT_SYCOM_ACM_SYC701_G726L = @as(u32, 373);
pub const WAVE_FORMAT_SYCOM_ACM_SYC701_CELP54 = @as(u32, 374);
pub const WAVE_FORMAT_SYCOM_ACM_SYC701_CELP68 = @as(u32, 375);
pub const WAVE_FORMAT_KNOWLEDGE_ADVENTURE_ADPCM = @as(u32, 376);
pub const WAVE_FORMAT_FRAUNHOFER_IIS_MPEG2_AAC = @as(u32, 384);
pub const WAVE_FORMAT_DTS_DS = @as(u32, 400);
pub const WAVE_FORMAT_CREATIVE_ADPCM = @as(u32, 512);
pub const WAVE_FORMAT_CREATIVE_FASTSPEECH8 = @as(u32, 514);
pub const WAVE_FORMAT_CREATIVE_FASTSPEECH10 = @as(u32, 515);
pub const WAVE_FORMAT_UHER_ADPCM = @as(u32, 528);
pub const WAVE_FORMAT_ULEAD_DV_AUDIO = @as(u32, 533);
pub const WAVE_FORMAT_ULEAD_DV_AUDIO_1 = @as(u32, 534);
pub const WAVE_FORMAT_QUARTERDECK = @as(u32, 544);
pub const WAVE_FORMAT_ILINK_VC = @as(u32, 560);
pub const WAVE_FORMAT_RAW_SPORT = @as(u32, 576);
pub const WAVE_FORMAT_ESST_AC3 = @as(u32, 577);
pub const WAVE_FORMAT_GENERIC_PASSTHRU = @as(u32, 585);
pub const WAVE_FORMAT_IPI_HSX = @as(u32, 592);
pub const WAVE_FORMAT_IPI_RPELP = @as(u32, 593);
pub const WAVE_FORMAT_CS2 = @as(u32, 608);
pub const WAVE_FORMAT_SONY_SCX = @as(u32, 624);
pub const WAVE_FORMAT_SONY_SCY = @as(u32, 625);
pub const WAVE_FORMAT_SONY_ATRAC3 = @as(u32, 626);
pub const WAVE_FORMAT_SONY_SPC = @as(u32, 627);
pub const WAVE_FORMAT_TELUM_AUDIO = @as(u32, 640);
pub const WAVE_FORMAT_TELUM_IA_AUDIO = @as(u32, 641);
pub const WAVE_FORMAT_NORCOM_VOICE_SYSTEMS_ADPCM = @as(u32, 645);
pub const WAVE_FORMAT_FM_TOWNS_SND = @as(u32, 768);
pub const WAVE_FORMAT_MICRONAS = @as(u32, 848);
pub const WAVE_FORMAT_MICRONAS_CELP833 = @as(u32, 849);
pub const WAVE_FORMAT_BTV_DIGITAL = @as(u32, 1024);
pub const WAVE_FORMAT_INTEL_MUSIC_CODER = @as(u32, 1025);
pub const WAVE_FORMAT_INDEO_AUDIO = @as(u32, 1026);
pub const WAVE_FORMAT_QDESIGN_MUSIC = @as(u32, 1104);
pub const WAVE_FORMAT_ON2_VP7_AUDIO = @as(u32, 1280);
pub const WAVE_FORMAT_ON2_VP6_AUDIO = @as(u32, 1281);
pub const WAVE_FORMAT_VME_VMPCM = @as(u32, 1664);
pub const WAVE_FORMAT_TPC = @as(u32, 1665);
pub const WAVE_FORMAT_LIGHTWAVE_LOSSLESS = @as(u32, 2222);
pub const WAVE_FORMAT_OLIGSM = @as(u32, 4096);
pub const WAVE_FORMAT_OLIADPCM = @as(u32, 4097);
pub const WAVE_FORMAT_OLICELP = @as(u32, 4098);
pub const WAVE_FORMAT_OLISBC = @as(u32, 4099);
pub const WAVE_FORMAT_OLIOPR = @as(u32, 4100);
pub const WAVE_FORMAT_LH_CODEC = @as(u32, 4352);
pub const WAVE_FORMAT_LH_CODEC_CELP = @as(u32, 4353);
pub const WAVE_FORMAT_LH_CODEC_SBC8 = @as(u32, 4354);
pub const WAVE_FORMAT_LH_CODEC_SBC12 = @as(u32, 4355);
pub const WAVE_FORMAT_LH_CODEC_SBC16 = @as(u32, 4356);
pub const WAVE_FORMAT_NORRIS = @as(u32, 5120);
pub const WAVE_FORMAT_ISIAUDIO_2 = @as(u32, 5121);
pub const WAVE_FORMAT_SOUNDSPACE_MUSICOMPRESS = @as(u32, 5376);
pub const WAVE_FORMAT_MPEG_ADTS_AAC = @as(u32, 5632);
pub const WAVE_FORMAT_MPEG_RAW_AAC = @as(u32, 5633);
pub const WAVE_FORMAT_MPEG_LOAS = @as(u32, 5634);
pub const WAVE_FORMAT_NOKIA_MPEG_ADTS_AAC = @as(u32, 5640);
pub const WAVE_FORMAT_NOKIA_MPEG_RAW_AAC = @as(u32, 5641);
pub const WAVE_FORMAT_VODAFONE_MPEG_ADTS_AAC = @as(u32, 5642);
pub const WAVE_FORMAT_VODAFONE_MPEG_RAW_AAC = @as(u32, 5643);
pub const WAVE_FORMAT_MPEG_HEAAC = @as(u32, 5648);
pub const WAVE_FORMAT_VOXWARE_RT24_SPEECH = @as(u32, 6172);
pub const WAVE_FORMAT_SONICFOUNDRY_LOSSLESS = @as(u32, 6513);
pub const WAVE_FORMAT_INNINGS_TELECOM_ADPCM = @as(u32, 6521);
pub const WAVE_FORMAT_LUCENT_SX8300P = @as(u32, 7175);
pub const WAVE_FORMAT_LUCENT_SX5363S = @as(u32, 7180);
pub const WAVE_FORMAT_CUSEEME = @as(u32, 7939);
pub const WAVE_FORMAT_NTCSOFT_ALF2CM_ACM = @as(u32, 8132);
pub const WAVE_FORMAT_DVM = @as(u32, 8192);
pub const WAVE_FORMAT_DTS2 = @as(u32, 8193);
pub const WAVE_FORMAT_MAKEAVIS = @as(u32, 13075);
pub const WAVE_FORMAT_DIVIO_MPEG4_AAC = @as(u32, 16707);
pub const WAVE_FORMAT_NOKIA_ADAPTIVE_MULTIRATE = @as(u32, 16897);
pub const WAVE_FORMAT_DIVIO_G726 = @as(u32, 16963);
pub const WAVE_FORMAT_LEAD_SPEECH = @as(u32, 17228);
pub const WAVE_FORMAT_LEAD_VORBIS = @as(u32, 22092);
pub const WAVE_FORMAT_WAVPACK_AUDIO = @as(u32, 22358);
pub const WAVE_FORMAT_ALAC = @as(u32, 27745);
pub const WAVE_FORMAT_OGG_VORBIS_MODE_1 = @as(u32, 26447);
pub const WAVE_FORMAT_OGG_VORBIS_MODE_2 = @as(u32, 26448);
pub const WAVE_FORMAT_OGG_VORBIS_MODE_3 = @as(u32, 26449);
pub const WAVE_FORMAT_OGG_VORBIS_MODE_1_PLUS = @as(u32, 26479);
pub const WAVE_FORMAT_OGG_VORBIS_MODE_2_PLUS = @as(u32, 26480);
pub const WAVE_FORMAT_OGG_VORBIS_MODE_3_PLUS = @as(u32, 26481);
pub const WAVE_FORMAT_3COM_NBX = @as(u32, 28672);
pub const WAVE_FORMAT_OPUS = @as(u32, 28751);
pub const WAVE_FORMAT_FAAD_AAC = @as(u32, 28781);
pub const WAVE_FORMAT_AMR_NB = @as(u32, 29537);
pub const WAVE_FORMAT_AMR_WB = @as(u32, 29538);
pub const WAVE_FORMAT_AMR_WP = @as(u32, 29539);
pub const WAVE_FORMAT_GSM_AMR_CBR = @as(u32, 31265);
pub const WAVE_FORMAT_GSM_AMR_VBR_SID = @as(u32, 31266);
pub const WAVE_FORMAT_COMVERSE_INFOSYS_G723_1 = @as(u32, 41216);
pub const WAVE_FORMAT_COMVERSE_INFOSYS_AVQSBC = @as(u32, 41217);
pub const WAVE_FORMAT_COMVERSE_INFOSYS_SBC = @as(u32, 41218);
pub const WAVE_FORMAT_SYMBOL_G729_A = @as(u32, 41219);
pub const WAVE_FORMAT_VOICEAGE_AMR_WB = @as(u32, 41220);
pub const WAVE_FORMAT_INGENIENT_G726 = @as(u32, 41221);
pub const WAVE_FORMAT_MPEG4_AAC = @as(u32, 41222);
pub const WAVE_FORMAT_ENCORE_G726 = @as(u32, 41223);
pub const WAVE_FORMAT_ZOLL_ASAO = @as(u32, 41224);
pub const WAVE_FORMAT_SPEEX_VOICE = @as(u32, 41225);
pub const WAVE_FORMAT_VIANIX_MASC = @as(u32, 41226);
pub const WAVE_FORMAT_WM9_SPECTRUM_ANALYZER = @as(u32, 41227);
pub const WAVE_FORMAT_WMF_SPECTRUM_ANAYZER = @as(u32, 41228);
pub const WAVE_FORMAT_GSM_610 = @as(u32, 41229);
pub const WAVE_FORMAT_GSM_620 = @as(u32, 41230);
pub const WAVE_FORMAT_GSM_660 = @as(u32, 41231);
pub const WAVE_FORMAT_GSM_690 = @as(u32, 41232);
pub const WAVE_FORMAT_GSM_ADAPTIVE_MULTIRATE_WB = @as(u32, 41233);
pub const WAVE_FORMAT_POLYCOM_G722 = @as(u32, 41234);
pub const WAVE_FORMAT_POLYCOM_G728 = @as(u32, 41235);
pub const WAVE_FORMAT_POLYCOM_G729_A = @as(u32, 41236);
pub const WAVE_FORMAT_POLYCOM_SIREN = @as(u32, 41237);
pub const WAVE_FORMAT_GLOBAL_IP_ILBC = @as(u32, 41238);
pub const WAVE_FORMAT_RADIOTIME_TIME_SHIFT_RADIO = @as(u32, 41239);
pub const WAVE_FORMAT_NICE_ACA = @as(u32, 41240);
pub const WAVE_FORMAT_NICE_ADPCM = @as(u32, 41241);
pub const WAVE_FORMAT_VOCORD_G721 = @as(u32, 41242);
pub const WAVE_FORMAT_VOCORD_G726 = @as(u32, 41243);
pub const WAVE_FORMAT_VOCORD_G722_1 = @as(u32, 41244);
pub const WAVE_FORMAT_VOCORD_G728 = @as(u32, 41245);
pub const WAVE_FORMAT_VOCORD_G729 = @as(u32, 41246);
pub const WAVE_FORMAT_VOCORD_G729_A = @as(u32, 41247);
pub const WAVE_FORMAT_VOCORD_G723_1 = @as(u32, 41248);
pub const WAVE_FORMAT_VOCORD_LBC = @as(u32, 41249);
pub const WAVE_FORMAT_NICE_G728 = @as(u32, 41250);
pub const WAVE_FORMAT_FRACE_TELECOM_G729 = @as(u32, 41251);
pub const WAVE_FORMAT_CODIAN = @as(u32, 41252);
pub const WAVE_FORMAT_FLAC = @as(u32, 61868);
pub const WAVE_FORMAT_DEVELOPMENT = @as(u32, 65535);
pub const WAVE_FORMAT_PCM = @as(u32, 1);
pub const ACM_MPEG_LAYER1 = @as(u32, 1);
pub const ACM_MPEG_LAYER2 = @as(u32, 2);
pub const ACM_MPEG_LAYER3 = @as(u32, 4);
pub const ACM_MPEG_STEREO = @as(u32, 1);
pub const ACM_MPEG_JOINTSTEREO = @as(u32, 2);
pub const ACM_MPEG_DUALCHANNEL = @as(u32, 4);
pub const ACM_MPEG_SINGLECHANNEL = @as(u32, 8);
pub const ACM_MPEG_PRIVATEBIT = @as(u32, 1);
pub const ACM_MPEG_COPYRIGHT = @as(u32, 2);
pub const ACM_MPEG_ORIGINALHOME = @as(u32, 4);
pub const ACM_MPEG_PROTECTIONBIT = @as(u32, 8);
pub const ACM_MPEG_ID_MPEG1 = @as(u32, 16);
pub const MPEGLAYER3_WFX_EXTRA_BYTES = @as(u32, 12);
pub const MPEGLAYER3_ID_UNKNOWN = @as(u32, 0);
pub const MPEGLAYER3_ID_MPEG = @as(u32, 1);
pub const MPEGLAYER3_ID_CONSTANTFRAMESIZE = @as(u32, 2);
pub const MM_MSFT_ACM_WMAUDIO = @as(u32, 39);
pub const WMAUDIO_BITS_PER_SAMPLE = @as(u32, 16);
pub const WMAUDIO_MAX_CHANNELS = @as(u32, 2);
pub const MM_MSFT_ACM_MSAUDIO1 = @as(u32, 39);
pub const MM_MSFT_ACM_WMAUDIO2 = @as(u32, 101);
pub const WAVE_FILTER_UNKNOWN = @as(u32, 0);
pub const WAVE_FILTER_DEVELOPMENT = @as(u32, 65535);
pub const WAVE_FILTER_VOLUME = @as(u32, 1);
pub const WAVE_FILTER_ECHO = @as(u32, 2);
pub const JPEG_PROCESS_BASELINE = @as(u32, 0);
pub const AVIIF_CONTROLFRAME = @as(i32, 512);
pub const JIFMK_SOF0 = @as(u32, 65472);
pub const JIFMK_SOF1 = @as(u32, 65473);
pub const JIFMK_SOF2 = @as(u32, 65474);
pub const JIFMK_SOF3 = @as(u32, 65475);
pub const JIFMK_SOF5 = @as(u32, 65477);
pub const JIFMK_SOF6 = @as(u32, 65478);
pub const JIFMK_SOF7 = @as(u32, 65479);
pub const JIFMK_JPG = @as(u32, 65480);
pub const JIFMK_SOF9 = @as(u32, 65481);
pub const JIFMK_SOF10 = @as(u32, 65482);
pub const JIFMK_SOF11 = @as(u32, 65483);
pub const JIFMK_SOF13 = @as(u32, 65485);
pub const JIFMK_SOF14 = @as(u32, 65486);
pub const JIFMK_SOF15 = @as(u32, 65487);
pub const JIFMK_DHT = @as(u32, 65476);
pub const JIFMK_DAC = @as(u32, 65484);
pub const JIFMK_RST0 = @as(u32, 65488);
pub const JIFMK_RST1 = @as(u32, 65489);
pub const JIFMK_RST2 = @as(u32, 65490);
pub const JIFMK_RST3 = @as(u32, 65491);
pub const JIFMK_RST4 = @as(u32, 65492);
pub const JIFMK_RST5 = @as(u32, 65493);
pub const JIFMK_RST6 = @as(u32, 65494);
pub const JIFMK_RST7 = @as(u32, 65495);
pub const JIFMK_SOI = @as(u32, 65496);
pub const JIFMK_EOI = @as(u32, 65497);
pub const JIFMK_SOS = @as(u32, 65498);
pub const JIFMK_DQT = @as(u32, 65499);
pub const JIFMK_DNL = @as(u32, 65500);
pub const JIFMK_DRI = @as(u32, 65501);
pub const JIFMK_DHP = @as(u32, 65502);
pub const JIFMK_EXP = @as(u32, 65503);
pub const JIFMK_APP0 = @as(u32, 65504);
pub const JIFMK_APP1 = @as(u32, 65505);
pub const JIFMK_APP2 = @as(u32, 65506);
pub const JIFMK_APP3 = @as(u32, 65507);
pub const JIFMK_APP4 = @as(u32, 65508);
pub const JIFMK_APP5 = @as(u32, 65509);
pub const JIFMK_APP6 = @as(u32, 65510);
pub const JIFMK_APP7 = @as(u32, 65511);
pub const JIFMK_JPG0 = @as(u32, 65520);
pub const JIFMK_JPG1 = @as(u32, 65521);
pub const JIFMK_JPG2 = @as(u32, 65522);
pub const JIFMK_JPG3 = @as(u32, 65523);
pub const JIFMK_JPG4 = @as(u32, 65524);
pub const JIFMK_JPG5 = @as(u32, 65525);
pub const JIFMK_JPG6 = @as(u32, 65526);
pub const JIFMK_JPG7 = @as(u32, 65527);
pub const JIFMK_JPG8 = @as(u32, 65528);
pub const JIFMK_JPG9 = @as(u32, 65529);
pub const JIFMK_JPG10 = @as(u32, 65530);
pub const JIFMK_JPG11 = @as(u32, 65531);
pub const JIFMK_JPG12 = @as(u32, 65532);
pub const JIFMK_JPG13 = @as(u32, 65533);
pub const JIFMK_COM = @as(u32, 65534);
pub const JIFMK_TEM = @as(u32, 65281);
pub const JIFMK_RES = @as(u32, 65282);
pub const JIFMK_00 = @as(u32, 65280);
pub const JIFMK_FF = @as(u32, 65535);
pub const JPEG_Y = @as(u32, 1);
pub const JPEG_YCbCr = @as(u32, 2);
pub const JPEG_RGB = @as(u32, 3);
pub const MIXERCONTROL_CONTROLTYPE_SRS_MTS = @as(u32, 536936454);
pub const MIXERCONTROL_CONTROLTYPE_SRS_ONOFF = @as(u32, 536936455);
pub const MIXERCONTROL_CONTROLTYPE_SRS_SYNTHSELECT = @as(u32, 536936456);
pub const SND_SYNC = @as(u32, 0);
pub const SND_ASYNC = @as(u32, 1);
pub const SND_NODEFAULT = @as(u32, 2);
pub const SND_MEMORY = @as(u32, 4);
pub const SND_LOOP = @as(u32, 8);
pub const SND_NOSTOP = @as(u32, 16);
pub const SND_NOWAIT = @as(i32, 8192);
pub const SND_ALIAS = @as(i32, 65536);
pub const SND_ALIAS_ID = @as(i32, 1114112);
pub const SND_FILENAME = @as(i32, 131072);
pub const SND_RESOURCE = @as(i32, 262148);
pub const SND_PURGE = @as(u32, 64);
pub const SND_APPLICATION = @as(u32, 128);
pub const SND_SENTRY = @as(i32, 524288);
pub const SND_RING = @as(i32, 1048576);
pub const SND_SYSTEM = @as(i32, 2097152);
pub const SND_ALIAS_START = @as(u32, 0);
pub const MAXPNAMELEN = @as(u32, 32);
pub const MAXERRORLENGTH = @as(u32, 256);
pub const TIME_MS = @as(u32, 1);
pub const TIME_SAMPLES = @as(u32, 2);
pub const TIME_BYTES = @as(u32, 4);
pub const TIME_SMPTE = @as(u32, 8);
pub const TIME_MIDI = @as(u32, 16);
pub const TIME_TICKS = @as(u32, 32);
pub const MM_JOY1MOVE = @as(u32, 928);
pub const MM_JOY2MOVE = @as(u32, 929);
pub const MM_JOY1ZMOVE = @as(u32, 930);
pub const MM_JOY2ZMOVE = @as(u32, 931);
pub const MM_JOY1BUTTONDOWN = @as(u32, 949);
pub const MM_JOY2BUTTONDOWN = @as(u32, 950);
pub const MM_JOY1BUTTONUP = @as(u32, 951);
pub const MM_JOY2BUTTONUP = @as(u32, 952);
pub const MM_MCINOTIFY = @as(u32, 953);
pub const MM_WOM_OPEN = @as(u32, 955);
pub const MM_WOM_CLOSE = @as(u32, 956);
pub const MM_WOM_DONE = @as(u32, 957);
pub const MM_WIM_OPEN = @as(u32, 958);
pub const MM_WIM_CLOSE = @as(u32, 959);
pub const MM_WIM_DATA = @as(u32, 960);
pub const MM_MIM_OPEN = @as(u32, 961);
pub const MM_MIM_CLOSE = @as(u32, 962);
pub const MM_MIM_DATA = @as(u32, 963);
pub const MM_MIM_LONGDATA = @as(u32, 964);
pub const MM_MIM_ERROR = @as(u32, 965);
pub const MM_MIM_LONGERROR = @as(u32, 966);
pub const MM_MOM_OPEN = @as(u32, 967);
pub const MM_MOM_CLOSE = @as(u32, 968);
pub const MM_MOM_DONE = @as(u32, 969);
pub const MM_STREAM_OPEN = @as(u32, 980);
pub const MM_STREAM_CLOSE = @as(u32, 981);
pub const MM_STREAM_DONE = @as(u32, 982);
pub const MM_STREAM_ERROR = @as(u32, 983);
pub const MM_MOM_POSITIONCB = @as(u32, 970);
pub const MM_MIM_MOREDATA = @as(u32, 972);
pub const MM_MIXM_LINE_CHANGE = @as(u32, 976);
pub const MM_MIXM_CONTROL_CHANGE = @as(u32, 977);
pub const MMSYSERR_BASE = @as(u32, 0);
pub const WAVERR_BASE = @as(u32, 32);
pub const MIDIERR_BASE = @as(u32, 64);
pub const TIMERR_BASE = @as(u32, 96);
pub const JOYERR_BASE = @as(u32, 160);
pub const MCIERR_BASE = @as(u32, 256);
pub const MIXERR_BASE = @as(u32, 1024);
pub const MCI_STRING_OFFSET = @as(u32, 512);
pub const MCI_VD_OFFSET = @as(u32, 1024);
pub const MCI_CD_OFFSET = @as(u32, 1088);
pub const MCI_WAVE_OFFSET = @as(u32, 1152);
pub const MCI_SEQ_OFFSET = @as(u32, 1216);
pub const MMSYSERR_NOERROR = @as(u32, 0);
pub const MMSYSERR_ERROR = @as(u32, 1);
pub const MMSYSERR_BADDEVICEID = @as(u32, 2);
pub const MMSYSERR_NOTENABLED = @as(u32, 3);
pub const MMSYSERR_ALLOCATED = @as(u32, 4);
pub const MMSYSERR_INVALHANDLE = @as(u32, 5);
pub const MMSYSERR_NODRIVER = @as(u32, 6);
pub const MMSYSERR_NOMEM = @as(u32, 7);
pub const MMSYSERR_NOTSUPPORTED = @as(u32, 8);
pub const MMSYSERR_BADERRNUM = @as(u32, 9);
pub const MMSYSERR_INVALFLAG = @as(u32, 10);
pub const MMSYSERR_INVALPARAM = @as(u32, 11);
pub const MMSYSERR_HANDLEBUSY = @as(u32, 12);
pub const MMSYSERR_INVALIDALIAS = @as(u32, 13);
pub const MMSYSERR_BADDB = @as(u32, 14);
pub const MMSYSERR_KEYNOTFOUND = @as(u32, 15);
pub const MMSYSERR_READERROR = @as(u32, 16);
pub const MMSYSERR_WRITEERROR = @as(u32, 17);
pub const MMSYSERR_DELETEERROR = @as(u32, 18);
pub const MMSYSERR_VALNOTFOUND = @as(u32, 19);
pub const MMSYSERR_NODRIVERCB = @as(u32, 20);
pub const MMSYSERR_MOREDATA = @as(u32, 21);
pub const MMSYSERR_LASTERROR = @as(u32, 21);
pub const VP_COMMAND_GET = @as(u32, 1);
pub const VP_COMMAND_SET = @as(u32, 2);
pub const VP_FLAGS_TV_MODE = @as(u32, 1);
pub const VP_FLAGS_TV_STANDARD = @as(u32, 2);
pub const VP_FLAGS_FLICKER = @as(u32, 4);
pub const VP_FLAGS_OVERSCAN = @as(u32, 8);
pub const VP_FLAGS_MAX_UNSCALED = @as(u32, 16);
pub const VP_FLAGS_POSITION = @as(u32, 32);
pub const VP_FLAGS_BRIGHTNESS = @as(u32, 64);
pub const VP_FLAGS_CONTRAST = @as(u32, 128);
pub const VP_FLAGS_COPYPROTECT = @as(u32, 256);
pub const VP_MODE_WIN_GRAPHICS = @as(u32, 1);
pub const VP_MODE_TV_PLAYBACK = @as(u32, 2);
pub const VP_TV_STANDARD_NTSC_M = @as(u32, 1);
pub const VP_TV_STANDARD_NTSC_M_J = @as(u32, 2);
pub const VP_TV_STANDARD_PAL_B = @as(u32, 4);
pub const VP_TV_STANDARD_PAL_D = @as(u32, 8);
pub const VP_TV_STANDARD_PAL_H = @as(u32, 16);
pub const VP_TV_STANDARD_PAL_I = @as(u32, 32);
pub const VP_TV_STANDARD_PAL_M = @as(u32, 64);
pub const VP_TV_STANDARD_PAL_N = @as(u32, 128);
pub const VP_TV_STANDARD_SECAM_B = @as(u32, 256);
pub const VP_TV_STANDARD_SECAM_D = @as(u32, 512);
pub const VP_TV_STANDARD_SECAM_G = @as(u32, 1024);
pub const VP_TV_STANDARD_SECAM_H = @as(u32, 2048);
pub const VP_TV_STANDARD_SECAM_K = @as(u32, 4096);
pub const VP_TV_STANDARD_SECAM_K1 = @as(u32, 8192);
pub const VP_TV_STANDARD_SECAM_L = @as(u32, 16384);
pub const VP_TV_STANDARD_WIN_VGA = @as(u32, 32768);
pub const VP_TV_STANDARD_NTSC_433 = @as(u32, 65536);
pub const VP_TV_STANDARD_PAL_G = @as(u32, 131072);
pub const VP_TV_STANDARD_PAL_60 = @as(u32, 262144);
pub const VP_TV_STANDARD_SECAM_L1 = @as(u32, 524288);
pub const VP_CP_TYPE_APS_TRIGGER = @as(u32, 1);
pub const VP_CP_TYPE_MACROVISION = @as(u32, 2);
pub const VP_CP_CMD_ACTIVATE = @as(u32, 1);
pub const VP_CP_CMD_DEACTIVATE = @as(u32, 2);
pub const VP_CP_CMD_CHANGE = @as(u32, 4);
pub const DRV_MAPPER_PREFERRED_INPUT_GET = @as(u32, 16384);
pub const DRV_MAPPER_PREFERRED_OUTPUT_GET = @as(u32, 16386);
pub const DRVM_MAPPER = @as(u32, 8192);
pub const DRVM_MAPPER_STATUS = @as(u32, 8192);
pub const WIDM_MAPPER_STATUS = @as(u32, 8192);
pub const WAVEIN_MAPPER_STATUS_DEVICE = @as(u32, 0);
pub const WAVEIN_MAPPER_STATUS_MAPPED = @as(u32, 1);
pub const WAVEIN_MAPPER_STATUS_FORMAT = @as(u32, 2);
pub const WODM_MAPPER_STATUS = @as(u32, 8192);
pub const WAVEOUT_MAPPER_STATUS_DEVICE = @as(u32, 0);
pub const WAVEOUT_MAPPER_STATUS_MAPPED = @as(u32, 1);
pub const WAVEOUT_MAPPER_STATUS_FORMAT = @as(u32, 2);
pub const ACMERR_BASE = @as(u32, 512);
pub const ACMERR_NOTPOSSIBLE = @as(u32, 512);
pub const ACMERR_BUSY = @as(u32, 513);
pub const ACMERR_UNPREPARED = @as(u32, 514);
pub const ACMERR_CANCELED = @as(u32, 515);
pub const ACM_METRIC_COUNT_DRIVERS = @as(u32, 1);
pub const ACM_METRIC_COUNT_CODECS = @as(u32, 2);
pub const ACM_METRIC_COUNT_CONVERTERS = @as(u32, 3);
pub const ACM_METRIC_COUNT_FILTERS = @as(u32, 4);
pub const ACM_METRIC_COUNT_DISABLED = @as(u32, 5);
pub const ACM_METRIC_COUNT_HARDWARE = @as(u32, 6);
pub const ACM_METRIC_COUNT_LOCAL_DRIVERS = @as(u32, 20);
pub const ACM_METRIC_COUNT_LOCAL_CODECS = @as(u32, 21);
pub const ACM_METRIC_COUNT_LOCAL_CONVERTERS = @as(u32, 22);
pub const ACM_METRIC_COUNT_LOCAL_FILTERS = @as(u32, 23);
pub const ACM_METRIC_COUNT_LOCAL_DISABLED = @as(u32, 24);
pub const ACM_METRIC_HARDWARE_WAVE_INPUT = @as(u32, 30);
pub const ACM_METRIC_HARDWARE_WAVE_OUTPUT = @as(u32, 31);
pub const ACM_METRIC_MAX_SIZE_FORMAT = @as(u32, 50);
pub const ACM_METRIC_MAX_SIZE_FILTER = @as(u32, 51);
pub const ACM_METRIC_DRIVER_SUPPORT = @as(u32, 100);
pub const ACM_METRIC_DRIVER_PRIORITY = @as(u32, 101);
pub const ACM_DRIVERENUMF_NOLOCAL = @as(i32, 1073741824);
pub const ACM_DRIVERENUMF_DISABLED = @as(i32, -2147483648);
pub const ACM_DRIVERADDF_NAME = @as(i32, 1);
pub const ACM_DRIVERADDF_FUNCTION = @as(i32, 3);
pub const ACM_DRIVERADDF_NOTIFYHWND = @as(i32, 4);
pub const ACM_DRIVERADDF_TYPEMASK = @as(i32, 7);
pub const ACM_DRIVERADDF_LOCAL = @as(i32, 0);
pub const ACM_DRIVERADDF_GLOBAL = @as(i32, 8);
pub const ACMDM_USER = @as(u32, 16384);
pub const ACMDM_RESERVED_LOW = @as(u32, 24576);
pub const ACMDM_RESERVED_HIGH = @as(u32, 28671);
pub const ACMDM_DRIVER_ABOUT = @as(u32, 24587);
pub const ACM_DRIVERPRIORITYF_ENABLE = @as(i32, 1);
pub const ACM_DRIVERPRIORITYF_DISABLE = @as(i32, 2);
pub const ACM_DRIVERPRIORITYF_ABLEMASK = @as(i32, 3);
pub const ACM_DRIVERPRIORITYF_BEGIN = @as(i32, 65536);
pub const ACM_DRIVERPRIORITYF_END = @as(i32, 131072);
pub const ACM_DRIVERPRIORITYF_DEFERMASK = @as(i32, 196608);
pub const ACMDRIVERDETAILS_SHORTNAME_CHARS = @as(u32, 32);
pub const ACMDRIVERDETAILS_LONGNAME_CHARS = @as(u32, 128);
pub const ACMDRIVERDETAILS_COPYRIGHT_CHARS = @as(u32, 80);
pub const ACMDRIVERDETAILS_LICENSING_CHARS = @as(u32, 128);
pub const ACMDRIVERDETAILS_FEATURES_CHARS = @as(u32, 512);
pub const ACMDRIVERDETAILS_SUPPORTF_CODEC = @as(i32, 1);
pub const ACMDRIVERDETAILS_SUPPORTF_CONVERTER = @as(i32, 2);
pub const ACMDRIVERDETAILS_SUPPORTF_FILTER = @as(i32, 4);
pub const ACMDRIVERDETAILS_SUPPORTF_HARDWARE = @as(i32, 8);
pub const ACMDRIVERDETAILS_SUPPORTF_ASYNC = @as(i32, 16);
pub const ACMDRIVERDETAILS_SUPPORTF_LOCAL = @as(i32, 1073741824);
pub const ACMDRIVERDETAILS_SUPPORTF_DISABLED = @as(i32, -2147483648);
pub const ACMFORMATTAGDETAILS_FORMATTAG_CHARS = @as(u32, 48);
pub const ACM_FORMATTAGDETAILSF_INDEX = @as(i32, 0);
pub const ACM_FORMATTAGDETAILSF_FORMATTAG = @as(i32, 1);
pub const ACM_FORMATTAGDETAILSF_LARGESTSIZE = @as(i32, 2);
pub const ACM_FORMATTAGDETAILSF_QUERYMASK = @as(i32, 15);
pub const ACMFORMATDETAILS_FORMAT_CHARS = @as(u32, 128);
pub const ACM_FORMATDETAILSF_INDEX = @as(i32, 0);
pub const ACM_FORMATDETAILSF_FORMAT = @as(i32, 1);
pub const ACM_FORMATDETAILSF_QUERYMASK = @as(i32, 15);
pub const ACM_FORMATENUMF_WFORMATTAG = @as(i32, 65536);
pub const ACM_FORMATENUMF_NCHANNELS = @as(i32, 131072);
pub const ACM_FORMATENUMF_NSAMPLESPERSEC = @as(i32, 262144);
pub const ACM_FORMATENUMF_WBITSPERSAMPLE = @as(i32, 524288);
pub const ACM_FORMATENUMF_CONVERT = @as(i32, 1048576);
pub const ACM_FORMATENUMF_SUGGEST = @as(i32, 2097152);
pub const ACM_FORMATENUMF_HARDWARE = @as(i32, 4194304);
pub const ACM_FORMATENUMF_INPUT = @as(i32, 8388608);
pub const ACM_FORMATENUMF_OUTPUT = @as(i32, 16777216);
pub const ACM_FORMATSUGGESTF_WFORMATTAG = @as(i32, 65536);
pub const ACM_FORMATSUGGESTF_NCHANNELS = @as(i32, 131072);
pub const ACM_FORMATSUGGESTF_NSAMPLESPERSEC = @as(i32, 262144);
pub const ACM_FORMATSUGGESTF_WBITSPERSAMPLE = @as(i32, 524288);
pub const ACM_FORMATSUGGESTF_TYPEMASK = @as(i32, 16711680);
pub const MM_ACM_FORMATCHOOSE = @as(u32, 32768);
pub const FORMATCHOOSE_MESSAGE = @as(u32, 0);
pub const FORMATCHOOSE_FORMATTAG_VERIFY = @as(u32, 0);
pub const FORMATCHOOSE_FORMAT_VERIFY = @as(u32, 1);
pub const FORMATCHOOSE_CUSTOM_VERIFY = @as(u32, 2);
pub const ACMFORMATCHOOSE_STYLEF_SHOWHELP = @as(i32, 4);
pub const ACMFORMATCHOOSE_STYLEF_ENABLEHOOK = @as(i32, 8);
pub const ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE = @as(i32, 16);
pub const ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = @as(i32, 32);
pub const ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT = @as(i32, 64);
pub const ACMFORMATCHOOSE_STYLEF_CONTEXTHELP = @as(i32, 128);
pub const ACMFILTERTAGDETAILS_FILTERTAG_CHARS = @as(u32, 48);
pub const ACM_FILTERTAGDETAILSF_INDEX = @as(i32, 0);
pub const ACM_FILTERTAGDETAILSF_FILTERTAG = @as(i32, 1);
pub const ACM_FILTERTAGDETAILSF_LARGESTSIZE = @as(i32, 2);
pub const ACM_FILTERTAGDETAILSF_QUERYMASK = @as(i32, 15);
pub const ACMFILTERDETAILS_FILTER_CHARS = @as(u32, 128);
pub const ACM_FILTERDETAILSF_INDEX = @as(i32, 0);
pub const ACM_FILTERDETAILSF_FILTER = @as(i32, 1);
pub const ACM_FILTERDETAILSF_QUERYMASK = @as(i32, 15);
pub const ACM_FILTERENUMF_DWFILTERTAG = @as(i32, 65536);
pub const MM_ACM_FILTERCHOOSE = @as(u32, 32768);
pub const FILTERCHOOSE_MESSAGE = @as(u32, 0);
pub const FILTERCHOOSE_FILTERTAG_VERIFY = @as(u32, 0);
pub const FILTERCHOOSE_FILTER_VERIFY = @as(u32, 1);
pub const FILTERCHOOSE_CUSTOM_VERIFY = @as(u32, 2);
pub const ACMFILTERCHOOSE_STYLEF_SHOWHELP = @as(i32, 4);
pub const ACMFILTERCHOOSE_STYLEF_ENABLEHOOK = @as(i32, 8);
pub const ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE = @as(i32, 16);
pub const ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = @as(i32, 32);
pub const ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT = @as(i32, 64);
pub const ACMFILTERCHOOSE_STYLEF_CONTEXTHELP = @as(i32, 128);
pub const ACMSTREAMHEADER_STATUSF_DONE = @as(i32, 65536);
pub const ACMSTREAMHEADER_STATUSF_PREPARED = @as(i32, 131072);
pub const ACMSTREAMHEADER_STATUSF_INQUEUE = @as(i32, 1048576);
pub const ACM_STREAMOPENF_QUERY = @as(u32, 1);
pub const ACM_STREAMOPENF_ASYNC = @as(u32, 2);
pub const ACM_STREAMOPENF_NONREALTIME = @as(u32, 4);
pub const ACM_STREAMSIZEF_SOURCE = @as(i32, 0);
pub const ACM_STREAMSIZEF_DESTINATION = @as(i32, 1);
pub const ACM_STREAMSIZEF_QUERYMASK = @as(i32, 15);
pub const ACM_STREAMCONVERTF_BLOCKALIGN = @as(u32, 4);
pub const ACM_STREAMCONVERTF_START = @as(u32, 16);
pub const ACM_STREAMCONVERTF_END = @as(u32, 32);
pub const WAVERR_BADFORMAT = @as(u32, 32);
pub const WAVERR_STILLPLAYING = @as(u32, 33);
pub const WAVERR_UNPREPARED = @as(u32, 34);
pub const WAVERR_SYNC = @as(u32, 35);
pub const WAVERR_LASTERROR = @as(u32, 35);
pub const WHDR_DONE = @as(u32, 1);
pub const WHDR_PREPARED = @as(u32, 2);
pub const WHDR_BEGINLOOP = @as(u32, 4);
pub const WHDR_ENDLOOP = @as(u32, 8);
pub const WHDR_INQUEUE = @as(u32, 16);
pub const WAVECAPS_PITCH = @as(u32, 1);
pub const WAVECAPS_PLAYBACKRATE = @as(u32, 2);
pub const WAVECAPS_VOLUME = @as(u32, 4);
pub const WAVECAPS_LRVOLUME = @as(u32, 8);
pub const WAVECAPS_SYNC = @as(u32, 16);
pub const WAVECAPS_SAMPLEACCURATE = @as(u32, 32);
pub const WAVE_INVALIDFORMAT = @as(u32, 0);
pub const WAVE_FORMAT_1M08 = @as(u32, 1);
pub const WAVE_FORMAT_1S08 = @as(u32, 2);
pub const WAVE_FORMAT_1M16 = @as(u32, 4);
pub const WAVE_FORMAT_1S16 = @as(u32, 8);
pub const WAVE_FORMAT_2M08 = @as(u32, 16);
pub const WAVE_FORMAT_2S08 = @as(u32, 32);
pub const WAVE_FORMAT_2M16 = @as(u32, 64);
pub const WAVE_FORMAT_2S16 = @as(u32, 128);
pub const WAVE_FORMAT_4M08 = @as(u32, 256);
pub const WAVE_FORMAT_4S08 = @as(u32, 512);
pub const WAVE_FORMAT_4M16 = @as(u32, 1024);
pub const WAVE_FORMAT_4S16 = @as(u32, 2048);
pub const WAVE_FORMAT_44M08 = @as(u32, 256);
pub const WAVE_FORMAT_44S08 = @as(u32, 512);
pub const WAVE_FORMAT_44M16 = @as(u32, 1024);
pub const WAVE_FORMAT_44S16 = @as(u32, 2048);
pub const WAVE_FORMAT_48M08 = @as(u32, 4096);
pub const WAVE_FORMAT_48S08 = @as(u32, 8192);
pub const WAVE_FORMAT_48M16 = @as(u32, 16384);
pub const WAVE_FORMAT_48S16 = @as(u32, 32768);
pub const WAVE_FORMAT_96M08 = @as(u32, 65536);
pub const WAVE_FORMAT_96S08 = @as(u32, 131072);
pub const WAVE_FORMAT_96M16 = @as(u32, 262144);
pub const WAVE_FORMAT_96S16 = @as(u32, 524288);
pub const MIDIERR_UNPREPARED = @as(u32, 64);
pub const MIDIERR_STILLPLAYING = @as(u32, 65);
pub const MIDIERR_NOMAP = @as(u32, 66);
pub const MIDIERR_NOTREADY = @as(u32, 67);
pub const MIDIERR_NODEVICE = @as(u32, 68);
pub const MIDIERR_INVALIDSETUP = @as(u32, 69);
pub const MIDIERR_BADOPENMODE = @as(u32, 70);
pub const MIDIERR_DONT_CONTINUE = @as(u32, 71);
pub const MIDIERR_LASTERROR = @as(u32, 71);
pub const MIDIPATCHSIZE = @as(u32, 128);
pub const MIDI_CACHE_ALL = @as(u32, 1);
pub const MIDI_CACHE_BESTFIT = @as(u32, 2);
pub const MIDI_CACHE_QUERY = @as(u32, 3);
pub const MIDI_UNCACHE = @as(u32, 4);
pub const MOD_MIDIPORT = @as(u32, 1);
pub const MOD_SYNTH = @as(u32, 2);
pub const MOD_SQSYNTH = @as(u32, 3);
pub const MOD_FMSYNTH = @as(u32, 4);
pub const MOD_MAPPER = @as(u32, 5);
pub const MOD_WAVETABLE = @as(u32, 6);
pub const MOD_SWSYNTH = @as(u32, 7);
pub const MIDICAPS_VOLUME = @as(u32, 1);
pub const MIDICAPS_LRVOLUME = @as(u32, 2);
pub const MIDICAPS_CACHE = @as(u32, 4);
pub const MIDICAPS_STREAM = @as(u32, 8);
pub const MHDR_DONE = @as(u32, 1);
pub const MHDR_PREPARED = @as(u32, 2);
pub const MHDR_INQUEUE = @as(u32, 4);
pub const MHDR_ISSTRM = @as(u32, 8);
pub const MEVT_F_SHORT = @as(i32, 0);
pub const MEVT_F_LONG = @as(i32, -2147483648);
pub const MEVT_F_CALLBACK = @as(i32, 1073741824);
pub const MIDISTRM_ERROR = @as(i32, -2);
pub const MIDIPROP_SET = @as(i32, -2147483648);
pub const MIDIPROP_GET = @as(i32, 1073741824);
pub const MIDIPROP_TIMEDIV = @as(i32, 1);
pub const MIDIPROP_TEMPO = @as(i32, 2);
pub const AUXCAPS_CDAUDIO = @as(u32, 1);
pub const AUXCAPS_AUXIN = @as(u32, 2);
pub const AUXCAPS_VOLUME = @as(u32, 1);
pub const AUXCAPS_LRVOLUME = @as(u32, 2);
pub const MIXER_SHORT_NAME_CHARS = @as(u32, 16);
pub const MIXER_LONG_NAME_CHARS = @as(u32, 64);
pub const MIXERR_INVALLINE = @as(u32, 1024);
pub const MIXERR_INVALCONTROL = @as(u32, 1025);
pub const MIXERR_INVALVALUE = @as(u32, 1026);
pub const MIXERR_LASTERROR = @as(u32, 1026);
pub const MIXER_OBJECTF_HANDLE = @as(i32, -2147483648);
pub const MIXER_OBJECTF_MIXER = @as(i32, 0);
pub const MIXER_OBJECTF_WAVEOUT = @as(i32, 268435456);
pub const MIXER_OBJECTF_WAVEIN = @as(i32, 536870912);
pub const MIXER_OBJECTF_MIDIOUT = @as(i32, 805306368);
pub const MIXER_OBJECTF_MIDIIN = @as(i32, 1073741824);
pub const MIXER_OBJECTF_AUX = @as(i32, 1342177280);
pub const MIXERLINE_LINEF_ACTIVE = @as(i32, 1);
pub const MIXERLINE_LINEF_DISCONNECTED = @as(i32, 32768);
pub const MIXERLINE_LINEF_SOURCE = @as(i32, -2147483648);
pub const MIXERLINE_COMPONENTTYPE_DST_FIRST = @as(i32, 0);
pub const MIXERLINE_COMPONENTTYPE_DST_LAST = @as(u32, 8);
pub const MIXERLINE_COMPONENTTYPE_SRC_FIRST = @as(i32, 4096);
pub const MIXERLINE_COMPONENTTYPE_SRC_LAST = @as(u32, 4106);
pub const MIXERLINE_TARGETTYPE_UNDEFINED = @as(u32, 0);
pub const MIXERLINE_TARGETTYPE_WAVEOUT = @as(u32, 1);
pub const MIXERLINE_TARGETTYPE_WAVEIN = @as(u32, 2);
pub const MIXERLINE_TARGETTYPE_MIDIOUT = @as(u32, 3);
pub const MIXERLINE_TARGETTYPE_MIDIIN = @as(u32, 4);
pub const MIXERLINE_TARGETTYPE_AUX = @as(u32, 5);
pub const MIXER_GETLINEINFOF_DESTINATION = @as(i32, 0);
pub const MIXER_GETLINEINFOF_SOURCE = @as(i32, 1);
pub const MIXER_GETLINEINFOF_LINEID = @as(i32, 2);
pub const MIXER_GETLINEINFOF_COMPONENTTYPE = @as(i32, 3);
pub const MIXER_GETLINEINFOF_TARGETTYPE = @as(i32, 4);
pub const MIXER_GETLINEINFOF_QUERYMASK = @as(i32, 15);
pub const MIXERCONTROL_CONTROLF_UNIFORM = @as(i32, 1);
pub const MIXERCONTROL_CONTROLF_MULTIPLE = @as(i32, 2);
pub const MIXERCONTROL_CONTROLF_DISABLED = @as(i32, -2147483648);
pub const MIXERCONTROL_CT_CLASS_MASK = @as(i32, -268435456);
pub const MIXERCONTROL_CT_CLASS_CUSTOM = @as(i32, 0);
pub const MIXERCONTROL_CT_CLASS_METER = @as(i32, 268435456);
pub const MIXERCONTROL_CT_CLASS_SWITCH = @as(i32, 536870912);
pub const MIXERCONTROL_CT_CLASS_NUMBER = @as(i32, 805306368);
pub const MIXERCONTROL_CT_CLASS_SLIDER = @as(i32, 1073741824);
pub const MIXERCONTROL_CT_CLASS_FADER = @as(i32, 1342177280);
pub const MIXERCONTROL_CT_CLASS_TIME = @as(i32, 1610612736);
pub const MIXERCONTROL_CT_CLASS_LIST = @as(i32, 1879048192);
pub const MIXERCONTROL_CT_SUBCLASS_MASK = @as(i32, 251658240);
pub const MIXERCONTROL_CT_SC_SWITCH_BOOLEAN = @as(i32, 0);
pub const MIXERCONTROL_CT_SC_SWITCH_BUTTON = @as(i32, 16777216);
pub const MIXERCONTROL_CT_SC_METER_POLLED = @as(i32, 0);
pub const MIXERCONTROL_CT_SC_TIME_MICROSECS = @as(i32, 0);
pub const MIXERCONTROL_CT_SC_TIME_MILLISECS = @as(i32, 16777216);
pub const MIXERCONTROL_CT_SC_LIST_SINGLE = @as(i32, 0);
pub const MIXERCONTROL_CT_SC_LIST_MULTIPLE = @as(i32, 16777216);
pub const MIXERCONTROL_CT_UNITS_MASK = @as(i32, 16711680);
pub const MIXERCONTROL_CT_UNITS_CUSTOM = @as(i32, 0);
pub const MIXERCONTROL_CT_UNITS_BOOLEAN = @as(i32, 65536);
pub const MIXERCONTROL_CT_UNITS_SIGNED = @as(i32, 131072);
pub const MIXERCONTROL_CT_UNITS_UNSIGNED = @as(i32, 196608);
pub const MIXERCONTROL_CT_UNITS_DECIBELS = @as(i32, 262144);
pub const MIXERCONTROL_CT_UNITS_PERCENT = @as(i32, 327680);
pub const MIXER_GETLINECONTROLSF_ALL = @as(i32, 0);
pub const MIXER_GETLINECONTROLSF_ONEBYID = @as(i32, 1);
pub const MIXER_GETLINECONTROLSF_ONEBYTYPE = @as(i32, 2);
pub const MIXER_GETLINECONTROLSF_QUERYMASK = @as(i32, 15);
pub const MIXER_GETCONTROLDETAILSF_VALUE = @as(i32, 0);
pub const MIXER_GETCONTROLDETAILSF_LISTTEXT = @as(i32, 1);
pub const MIXER_GETCONTROLDETAILSF_QUERYMASK = @as(i32, 15);
pub const MIXER_SETCONTROLDETAILSF_VALUE = @as(i32, 0);
pub const MIXER_SETCONTROLDETAILSF_CUSTOM = @as(i32, 1);
pub const MIXER_SETCONTROLDETAILSF_QUERYMASK = @as(i32, 15);
pub const ICVERSION = @as(u32, 260);
pub const BI_1632 = @as(u32, 842217009);
pub const ICERR_OK = @as(i32, 0);
pub const ICERR_DONTDRAW = @as(i32, 1);
pub const ICERR_NEWPALETTE = @as(i32, 2);
pub const ICERR_GOTOKEYFRAME = @as(i32, 3);
pub const ICERR_STOPDRAWING = @as(i32, 4);
pub const ICERR_UNSUPPORTED = @as(i32, -1);
pub const ICERR_BADFORMAT = @as(i32, -2);
pub const ICERR_MEMORY = @as(i32, -3);
pub const ICERR_INTERNAL = @as(i32, -4);
pub const ICERR_BADFLAGS = @as(i32, -5);
pub const ICERR_BADPARAM = @as(i32, -6);
pub const ICERR_BADSIZE = @as(i32, -7);
pub const ICERR_BADHANDLE = @as(i32, -8);
pub const ICERR_CANTUPDATE = @as(i32, -9);
pub const ICERR_ABORT = @as(i32, -10);
pub const ICERR_ERROR = @as(i32, -100);
pub const ICERR_BADBITDEPTH = @as(i32, -200);
pub const ICERR_BADIMAGESIZE = @as(i32, -201);
pub const ICERR_CUSTOM = @as(i32, -400);
pub const ICMODE_COMPRESS = @as(u32, 1);
pub const ICMODE_DECOMPRESS = @as(u32, 2);
pub const ICMODE_FASTDECOMPRESS = @as(u32, 3);
pub const ICMODE_QUERY = @as(u32, 4);
pub const ICMODE_FASTCOMPRESS = @as(u32, 5);
pub const ICMODE_DRAW = @as(u32, 8);
pub const ICMODE_INTERNALF_FUNCTION32 = @as(u32, 32768);
pub const ICMODE_INTERNALF_MASK = @as(u32, 32768);
pub const AVIIF_TWOCC = @as(i32, 2);
pub const ICQUALITY_LOW = @as(u32, 0);
pub const ICQUALITY_HIGH = @as(u32, 10000);
pub const ICQUALITY_DEFAULT = @as(i32, -1);
pub const ICM_USER = @as(u32, 16384);
pub const ICM_RESERVED_LOW = @as(u32, 20480);
pub const ICM_RESERVED_HIGH = @as(u32, 24576);
pub const ICM_GETSTATE = @as(u32, 20480);
pub const ICM_SETSTATE = @as(u32, 20481);
pub const ICM_GETINFO = @as(u32, 20482);
pub const ICM_CONFIGURE = @as(u32, 20490);
pub const ICM_ABOUT = @as(u32, 20491);
pub const ICM_GETERRORTEXT = @as(u32, 20492);
pub const ICM_GETFORMATNAME = @as(u32, 20500);
pub const ICM_ENUMFORMATS = @as(u32, 20501);
pub const ICM_GETDEFAULTQUALITY = @as(u32, 20510);
pub const ICM_GETQUALITY = @as(u32, 20511);
pub const ICM_SETQUALITY = @as(u32, 20512);
pub const ICM_SET = @as(u32, 20520);
pub const ICM_GET = @as(u32, 20521);
pub const ICM_COMPRESS_GET_FORMAT = @as(u32, 16388);
pub const ICM_COMPRESS_GET_SIZE = @as(u32, 16389);
pub const ICM_COMPRESS_QUERY = @as(u32, 16390);
pub const ICM_COMPRESS_BEGIN = @as(u32, 16391);
pub const ICM_COMPRESS = @as(u32, 16392);
pub const ICM_COMPRESS_END = @as(u32, 16393);
pub const ICM_DECOMPRESS_GET_FORMAT = @as(u32, 16394);
pub const ICM_DECOMPRESS_QUERY = @as(u32, 16395);
pub const ICM_DECOMPRESS_BEGIN = @as(u32, 16396);
pub const ICM_DECOMPRESS = @as(u32, 16397);
pub const ICM_DECOMPRESS_END = @as(u32, 16398);
pub const ICM_DECOMPRESS_SET_PALETTE = @as(u32, 16413);
pub const ICM_DECOMPRESS_GET_PALETTE = @as(u32, 16414);
pub const ICM_DRAW_QUERY = @as(u32, 16415);
pub const ICM_DRAW_BEGIN = @as(u32, 16399);
pub const ICM_DRAW_GET_PALETTE = @as(u32, 16400);
pub const ICM_DRAW_UPDATE = @as(u32, 16401);
pub const ICM_DRAW_START = @as(u32, 16402);
pub const ICM_DRAW_STOP = @as(u32, 16403);
pub const ICM_DRAW_BITS = @as(u32, 16404);
pub const ICM_DRAW_END = @as(u32, 16405);
pub const ICM_DRAW_GETTIME = @as(u32, 16416);
pub const ICM_DRAW = @as(u32, 16417);
pub const ICM_DRAW_WINDOW = @as(u32, 16418);
pub const ICM_DRAW_SETTIME = @as(u32, 16419);
pub const ICM_DRAW_REALIZE = @as(u32, 16420);
pub const ICM_DRAW_FLUSH = @as(u32, 16421);
pub const ICM_DRAW_RENDERBUFFER = @as(u32, 16422);
pub const ICM_DRAW_START_PLAY = @as(u32, 16423);
pub const ICM_DRAW_STOP_PLAY = @as(u32, 16424);
pub const ICM_DRAW_SUGGESTFORMAT = @as(u32, 16434);
pub const ICM_DRAW_CHANGEPALETTE = @as(u32, 16435);
pub const ICM_DRAW_IDLE = @as(u32, 16436);
pub const ICM_GETBUFFERSWANTED = @as(u32, 16425);
pub const ICM_GETDEFAULTKEYFRAMERATE = @as(u32, 16426);
pub const ICM_DECOMPRESSEX_BEGIN = @as(u32, 16444);
pub const ICM_DECOMPRESSEX_QUERY = @as(u32, 16445);
pub const ICM_DECOMPRESSEX = @as(u32, 16446);
pub const ICM_DECOMPRESSEX_END = @as(u32, 16447);
pub const ICM_COMPRESS_FRAMES_INFO = @as(u32, 16454);
pub const ICM_COMPRESS_FRAMES = @as(u32, 16455);
pub const ICM_SET_STATUS_PROC = @as(u32, 16456);
pub const VIDCF_QUALITY = @as(u32, 1);
pub const VIDCF_CRUNCH = @as(u32, 2);
pub const VIDCF_TEMPORAL = @as(u32, 4);
pub const VIDCF_COMPRESSFRAMES = @as(u32, 8);
pub const VIDCF_DRAW = @as(u32, 16);
pub const VIDCF_FASTTEMPORALC = @as(u32, 32);
pub const VIDCF_FASTTEMPORALD = @as(u32, 128);
pub const ICCOMPRESS_KEYFRAME = @as(i32, 1);
pub const ICCOMPRESSFRAMES_PADDING = @as(u32, 1);
pub const ICDECOMPRESS_HURRYUP = @as(i32, -2147483648);
pub const ICDECOMPRESS_UPDATE = @as(i32, 1073741824);
pub const ICDECOMPRESS_PREROLL = @as(i32, 536870912);
pub const ICDECOMPRESS_NULLFRAME = @as(i32, 268435456);
pub const ICDECOMPRESS_NOTKEYFRAME = @as(i32, 134217728);
pub const ICDRAW_QUERY = @as(i32, 1);
pub const ICDRAW_FULLSCREEN = @as(i32, 2);
pub const ICDRAW_HDC = @as(i32, 4);
pub const ICDRAW_ANIMATE = @as(i32, 8);
pub const ICDRAW_CONTINUE = @as(i32, 16);
pub const ICDRAW_MEMORYDC = @as(i32, 32);
pub const ICDRAW_UPDATING = @as(i32, 64);
pub const ICDRAW_RENDER = @as(i32, 128);
pub const ICDRAW_BUFFER = @as(i32, 256);
pub const ICDRAW_HURRYUP = @as(i32, -2147483648);
pub const ICDRAW_UPDATE = @as(i32, 1073741824);
pub const ICDRAW_PREROLL = @as(i32, 536870912);
pub const ICDRAW_NULLFRAME = @as(i32, 268435456);
pub const ICDRAW_NOTKEYFRAME = @as(i32, 134217728);
pub const ICINSTALL_UNICODE = @as(u32, 32768);
pub const ICINSTALL_FUNCTION = @as(u32, 1);
pub const ICINSTALL_DRIVER = @as(u32, 2);
pub const ICINSTALL_HDRV = @as(u32, 4);
pub const ICINSTALL_DRIVERW = @as(u32, 32770);
pub const ICMF_CONFIGURE_QUERY = @as(u32, 1);
pub const ICMF_ABOUT_QUERY = @as(u32, 1);
pub const ICMF_COMPVARS_VALID = @as(u32, 1);
pub const ICMF_CHOOSE_KEYFRAME = @as(u32, 1);
pub const ICMF_CHOOSE_DATARATE = @as(u32, 2);
pub const ICMF_CHOOSE_PREVIEW = @as(u32, 4);
pub const ICMF_CHOOSE_ALLCOMPRESSORS = @as(u32, 8);
pub const DDF_0001 = @as(u32, 1);
pub const DDF_UPDATE = @as(u32, 2);
pub const DDF_SAME_HDC = @as(u32, 4);
pub const DDF_SAME_DRAW = @as(u32, 8);
pub const DDF_DONTDRAW = @as(u32, 16);
pub const DDF_ANIMATE = @as(u32, 32);
pub const DDF_BUFFER = @as(u32, 64);
pub const DDF_JUSTDRAWIT = @as(u32, 128);
pub const DDF_FULLSCREEN = @as(u32, 256);
pub const DDF_BACKGROUNDPAL = @as(u32, 512);
pub const DDF_NOTKEYFRAME = @as(u32, 1024);
pub const DDF_HURRYUP = @as(u32, 2048);
pub const DDF_HALFTONE = @as(u32, 4096);
pub const DDF_2000 = @as(u32, 8192);
pub const PD_CAN_DRAW_DIB = @as(u32, 1);
pub const PD_CAN_STRETCHDIB = @as(u32, 2);
pub const PD_STRETCHDIB_1_1_OK = @as(u32, 4);
pub const PD_STRETCHDIB_1_2_OK = @as(u32, 8);
pub const PD_STRETCHDIB_1_N_OK = @as(u32, 16);
pub const AVIGETFRAMEF_BESTDISPLAYFMT = @as(u32, 1);
pub const AVISTREAMINFO_DISABLED = @as(u32, 1);
pub const AVISTREAMINFO_FORMATCHANGES = @as(u32, 65536);
pub const AVIFILEINFO_HASINDEX = @as(u32, 16);
pub const AVIFILEINFO_MUSTUSEINDEX = @as(u32, 32);
pub const AVIFILEINFO_ISINTERLEAVED = @as(u32, 256);
pub const AVIFILEINFO_WASCAPTUREFILE = @as(u32, 65536);
pub const AVIFILEINFO_COPYRIGHTED = @as(u32, 131072);
pub const AVIFILECAPS_CANREAD = @as(u32, 1);
pub const AVIFILECAPS_CANWRITE = @as(u32, 2);
pub const AVIFILECAPS_ALLKEYFRAMES = @as(u32, 16);
pub const AVIFILECAPS_NOCOMPRESSION = @as(u32, 32);
pub const AVICOMPRESSF_INTERLEAVE = @as(u32, 1);
pub const AVICOMPRESSF_DATARATE = @as(u32, 2);
pub const AVICOMPRESSF_KEYFRAMES = @as(u32, 4);
pub const AVICOMPRESSF_VALID = @as(u32, 8);
pub const CLSID_AVISimpleUnMarshal = Guid.initString("00020009-0000-0000-c000-000000000046");
pub const CLSID_AVIFile = Guid.initString("00020000-0000-0000-c000-000000000046");
pub const AVIFILEHANDLER_CANREAD = @as(u32, 1);
pub const AVIFILEHANDLER_CANWRITE = @as(u32, 2);
pub const AVIFILEHANDLER_CANACCEPTNONRGB = @as(u32, 4);
pub const AVISTREAMREAD_CONVENIENT = @as(i32, -1);
pub const FIND_DIR = @as(i32, 15);
pub const FIND_NEXT = @as(i32, 1);
pub const FIND_PREV = @as(i32, 4);
pub const FIND_FROM_START = @as(i32, 8);
pub const FIND_TYPE = @as(i32, 240);
pub const FIND_KEY = @as(i32, 16);
pub const FIND_ANY = @as(i32, 32);
pub const FIND_FORMAT = @as(i32, 64);
pub const FIND_RET = @as(i32, 61440);
pub const FIND_POS = @as(i32, 0);
pub const FIND_LENGTH = @as(i32, 4096);
pub const FIND_OFFSET = @as(i32, 8192);
pub const FIND_SIZE = @as(i32, 12288);
pub const FIND_INDEX = @as(i32, 16384);
pub const AVIERR_OK = @as(i32, 0);
pub const MCIWNDOPENF_NEW = @as(u32, 1);
pub const MCIWNDF_NOAUTOSIZEWINDOW = @as(u32, 1);
pub const MCIWNDF_NOPLAYBAR = @as(u32, 2);
pub const MCIWNDF_NOAUTOSIZEMOVIE = @as(u32, 4);
pub const MCIWNDF_NOMENU = @as(u32, 8);
pub const MCIWNDF_SHOWNAME = @as(u32, 16);
pub const MCIWNDF_SHOWPOS = @as(u32, 32);
pub const MCIWNDF_SHOWMODE = @as(u32, 64);
pub const MCIWNDF_SHOWALL = @as(u32, 112);
pub const MCIWNDF_NOTIFYMODE = @as(u32, 256);
pub const MCIWNDF_NOTIFYPOS = @as(u32, 512);
pub const MCIWNDF_NOTIFYSIZE = @as(u32, 1024);
pub const MCIWNDF_NOTIFYERROR = @as(u32, 4096);
pub const MCIWNDF_NOTIFYALL = @as(u32, 7936);
pub const MCIWNDF_NOTIFYANSI = @as(u32, 128);
pub const MCIWNDF_NOTIFYMEDIAA = @as(u32, 2176);
pub const MCIWNDF_NOTIFYMEDIAW = @as(u32, 2048);
pub const MCIWNDF_RECORD = @as(u32, 8192);
pub const MCIWNDF_NOERRORDLG = @as(u32, 16384);
pub const MCIWNDF_NOOPEN = @as(u32, 32768);
pub const MCIWNDM_GETDEVICEID = @as(u32, 1124);
pub const MCIWNDM_GETSTART = @as(u32, 1127);
pub const MCIWNDM_GETLENGTH = @as(u32, 1128);
pub const MCIWNDM_GETEND = @as(u32, 1129);
pub const MCIWNDM_EJECT = @as(u32, 1131);
pub const MCIWNDM_SETZOOM = @as(u32, 1132);
pub const MCIWNDM_GETZOOM = @as(u32, 1133);
pub const MCIWNDM_SETVOLUME = @as(u32, 1134);
pub const MCIWNDM_GETVOLUME = @as(u32, 1135);
pub const MCIWNDM_SETSPEED = @as(u32, 1136);
pub const MCIWNDM_GETSPEED = @as(u32, 1137);
pub const MCIWNDM_SETREPEAT = @as(u32, 1138);
pub const MCIWNDM_GETREPEAT = @as(u32, 1139);
pub const MCIWNDM_REALIZE = @as(u32, 1142);
pub const MCIWNDM_VALIDATEMEDIA = @as(u32, 1145);
pub const MCIWNDM_PLAYFROM = @as(u32, 1146);
pub const MCIWNDM_PLAYTO = @as(u32, 1147);
pub const MCIWNDM_GETPALETTE = @as(u32, 1150);
pub const MCIWNDM_SETPALETTE = @as(u32, 1151);
pub const MCIWNDM_SETTIMERS = @as(u32, 1153);
pub const MCIWNDM_SETACTIVETIMER = @as(u32, 1154);
pub const MCIWNDM_SETINACTIVETIMER = @as(u32, 1155);
pub const MCIWNDM_GETACTIVETIMER = @as(u32, 1156);
pub const MCIWNDM_GETINACTIVETIMER = @as(u32, 1157);
pub const MCIWNDM_CHANGESTYLES = @as(u32, 1159);
pub const MCIWNDM_GETSTYLES = @as(u32, 1160);
pub const MCIWNDM_GETALIAS = @as(u32, 1161);
pub const MCIWNDM_PLAYREVERSE = @as(u32, 1163);
pub const MCIWNDM_GET_SOURCE = @as(u32, 1164);
pub const MCIWNDM_PUT_SOURCE = @as(u32, 1165);
pub const MCIWNDM_GET_DEST = @as(u32, 1166);
pub const MCIWNDM_PUT_DEST = @as(u32, 1167);
pub const MCIWNDM_CAN_PLAY = @as(u32, 1168);
pub const MCIWNDM_CAN_WINDOW = @as(u32, 1169);
pub const MCIWNDM_CAN_RECORD = @as(u32, 1170);
pub const MCIWNDM_CAN_SAVE = @as(u32, 1171);
pub const MCIWNDM_CAN_EJECT = @as(u32, 1172);
pub const MCIWNDM_CAN_CONFIG = @as(u32, 1173);
pub const MCIWNDM_PALETTEKICK = @as(u32, 1174);
pub const MCIWNDM_OPENINTERFACE = @as(u32, 1175);
pub const MCIWNDM_SETOWNER = @as(u32, 1176);
pub const MCIWNDM_SENDSTRINGA = @as(u32, 1125);
pub const MCIWNDM_GETPOSITIONA = @as(u32, 1126);
pub const MCIWNDM_GETMODEA = @as(u32, 1130);
pub const MCIWNDM_SETTIMEFORMATA = @as(u32, 1143);
pub const MCIWNDM_GETTIMEFORMATA = @as(u32, 1144);
pub const MCIWNDM_GETFILENAMEA = @as(u32, 1148);
pub const MCIWNDM_GETDEVICEA = @as(u32, 1149);
pub const MCIWNDM_GETERRORA = @as(u32, 1152);
pub const MCIWNDM_NEWA = @as(u32, 1158);
pub const MCIWNDM_RETURNSTRINGA = @as(u32, 1162);
pub const MCIWNDM_OPENA = @as(u32, 1177);
pub const MCIWNDM_SENDSTRINGW = @as(u32, 1225);
pub const MCIWNDM_GETPOSITIONW = @as(u32, 1226);
pub const MCIWNDM_GETMODEW = @as(u32, 1230);
pub const MCIWNDM_SETTIMEFORMATW = @as(u32, 1243);
pub const MCIWNDM_GETTIMEFORMATW = @as(u32, 1244);
pub const MCIWNDM_GETFILENAMEW = @as(u32, 1248);
pub const MCIWNDM_GETDEVICEW = @as(u32, 1249);
pub const MCIWNDM_GETERRORW = @as(u32, 1252);
pub const MCIWNDM_NEWW = @as(u32, 1258);
pub const MCIWNDM_RETURNSTRINGW = @as(u32, 1262);
pub const MCIWNDM_OPENW = @as(u32, 1276);
pub const MCIWNDM_NOTIFYMODE = @as(u32, 1224);
pub const MCIWNDM_NOTIFYPOS = @as(u32, 1225);
pub const MCIWNDM_NOTIFYSIZE = @as(u32, 1226);
pub const MCIWNDM_NOTIFYMEDIA = @as(u32, 1227);
pub const MCIWNDM_NOTIFYERROR = @as(u32, 1229);
pub const MCIWND_START = @as(i32, -1);
pub const MCIWND_END = @as(i32, -2);
pub const DV_ERR_OK = @as(u32, 0);
pub const DV_ERR_BASE = @as(u32, 1);
pub const DV_ERR_BADFORMAT = @as(u32, 2);
pub const DV_ERR_STILLPLAYING = @as(u32, 3);
pub const DV_ERR_UNPREPARED = @as(u32, 4);
pub const DV_ERR_SYNC = @as(u32, 5);
pub const DV_ERR_TOOMANYCHANNELS = @as(u32, 6);
pub const DV_ERR_NOTDETECTED = @as(u32, 7);
pub const DV_ERR_BADINSTALL = @as(u32, 8);
pub const DV_ERR_CREATEPALETTE = @as(u32, 9);
pub const DV_ERR_SIZEFIELD = @as(u32, 10);
pub const DV_ERR_PARAM1 = @as(u32, 11);
pub const DV_ERR_PARAM2 = @as(u32, 12);
pub const DV_ERR_CONFIG1 = @as(u32, 13);
pub const DV_ERR_CONFIG2 = @as(u32, 14);
pub const DV_ERR_FLAGS = @as(u32, 15);
pub const DV_ERR_13 = @as(u32, 16);
pub const DV_ERR_NOTSUPPORTED = @as(u32, 17);
pub const DV_ERR_NOMEM = @as(u32, 18);
pub const DV_ERR_ALLOCATED = @as(u32, 19);
pub const DV_ERR_BADDEVICEID = @as(u32, 20);
pub const DV_ERR_INVALHANDLE = @as(u32, 21);
pub const DV_ERR_BADERRNUM = @as(u32, 22);
pub const DV_ERR_NO_BUFFERS = @as(u32, 23);
pub const DV_ERR_MEM_CONFLICT = @as(u32, 24);
pub const DV_ERR_IO_CONFLICT = @as(u32, 25);
pub const DV_ERR_DMA_CONFLICT = @as(u32, 26);
pub const DV_ERR_INT_CONFLICT = @as(u32, 27);
pub const DV_ERR_PROTECT_ONLY = @as(u32, 28);
pub const DV_ERR_LASTERROR = @as(u32, 28);
pub const DV_ERR_USER_MSG = @as(u32, 1001);
pub const MM_DRVM_OPEN = @as(u32, 976);
pub const MM_DRVM_CLOSE = @as(u32, 977);
pub const MM_DRVM_DATA = @as(u32, 978);
pub const MM_DRVM_ERROR = @as(u32, 979);
pub const VHDR_DONE = @as(u32, 1);
pub const VHDR_PREPARED = @as(u32, 2);
pub const VHDR_INQUEUE = @as(u32, 4);
pub const VHDR_KEYFRAME = @as(u32, 8);
pub const VHDR_VALID = @as(u32, 15);
pub const VCAPS_OVERLAY = @as(u32, 1);
pub const VCAPS_SRC_CAN_CLIP = @as(u32, 2);
pub const VCAPS_DST_CAN_CLIP = @as(u32, 4);
pub const VCAPS_CAN_SCALE = @as(u32, 8);
pub const VIDEO_EXTERNALIN = @as(u32, 1);
pub const VIDEO_EXTERNALOUT = @as(u32, 2);
pub const VIDEO_IN = @as(u32, 4);
pub const VIDEO_OUT = @as(u32, 8);
pub const VIDEO_DLG_QUERY = @as(u32, 16);
pub const VIDEO_CONFIGURE_QUERY = @as(u32, 32768);
pub const VIDEO_CONFIGURE_SET = @as(u32, 4096);
pub const VIDEO_CONFIGURE_GET = @as(u32, 8192);
pub const VIDEO_CONFIGURE_QUERYSIZE = @as(u32, 1);
pub const VIDEO_CONFIGURE_CURRENT = @as(u32, 16);
pub const VIDEO_CONFIGURE_NOMINAL = @as(u32, 32);
pub const VIDEO_CONFIGURE_MIN = @as(u32, 64);
pub const VIDEO_CONFIGURE_MAX = @as(u32, 128);
pub const DVM_USER = @as(u32, 16384);
pub const DVM_CONFIGURE_START = @as(u32, 4096);
pub const DVM_CONFIGURE_END = @as(u32, 8191);
pub const DVM_PALETTE = @as(u32, 4097);
pub const DVM_FORMAT = @as(u32, 4098);
pub const DVM_PALETTERGB555 = @as(u32, 4099);
pub const DVM_SRC_RECT = @as(u32, 4100);
pub const DVM_DST_RECT = @as(u32, 4101);
pub const WM_CAP_UNICODE_START = @as(u32, 1124);
pub const WM_CAP_GET_CAPSTREAMPTR = @as(u32, 1025);
pub const WM_CAP_SET_CALLBACK_ERRORW = @as(u32, 1126);
pub const WM_CAP_SET_CALLBACK_STATUSW = @as(u32, 1127);
pub const WM_CAP_SET_CALLBACK_ERRORA = @as(u32, 1026);
pub const WM_CAP_SET_CALLBACK_STATUSA = @as(u32, 1027);
pub const WM_CAP_SET_CALLBACK_YIELD = @as(u32, 1028);
pub const WM_CAP_SET_CALLBACK_FRAME = @as(u32, 1029);
pub const WM_CAP_SET_CALLBACK_VIDEOSTREAM = @as(u32, 1030);
pub const WM_CAP_SET_CALLBACK_WAVESTREAM = @as(u32, 1031);
pub const WM_CAP_GET_USER_DATA = @as(u32, 1032);
pub const WM_CAP_SET_USER_DATA = @as(u32, 1033);
pub const WM_CAP_DRIVER_CONNECT = @as(u32, 1034);
pub const WM_CAP_DRIVER_DISCONNECT = @as(u32, 1035);
pub const WM_CAP_DRIVER_GET_NAMEA = @as(u32, 1036);
pub const WM_CAP_DRIVER_GET_VERSIONA = @as(u32, 1037);
pub const WM_CAP_DRIVER_GET_NAMEW = @as(u32, 1136);
pub const WM_CAP_DRIVER_GET_VERSIONW = @as(u32, 1137);
pub const WM_CAP_DRIVER_GET_CAPS = @as(u32, 1038);
pub const WM_CAP_FILE_SET_CAPTURE_FILEA = @as(u32, 1044);
pub const WM_CAP_FILE_GET_CAPTURE_FILEA = @as(u32, 1045);
pub const WM_CAP_FILE_SAVEASA = @as(u32, 1047);
pub const WM_CAP_FILE_SAVEDIBA = @as(u32, 1049);
pub const WM_CAP_FILE_SET_CAPTURE_FILEW = @as(u32, 1144);
pub const WM_CAP_FILE_GET_CAPTURE_FILEW = @as(u32, 1145);
pub const WM_CAP_FILE_SAVEASW = @as(u32, 1147);
pub const WM_CAP_FILE_SAVEDIBW = @as(u32, 1149);
pub const WM_CAP_FILE_ALLOCATE = @as(u32, 1046);
pub const WM_CAP_FILE_SET_INFOCHUNK = @as(u32, 1048);
pub const WM_CAP_EDIT_COPY = @as(u32, 1054);
pub const WM_CAP_SET_AUDIOFORMAT = @as(u32, 1059);
pub const WM_CAP_GET_AUDIOFORMAT = @as(u32, 1060);
pub const WM_CAP_DLG_VIDEOFORMAT = @as(u32, 1065);
pub const WM_CAP_DLG_VIDEOSOURCE = @as(u32, 1066);
pub const WM_CAP_DLG_VIDEODISPLAY = @as(u32, 1067);
pub const WM_CAP_GET_VIDEOFORMAT = @as(u32, 1068);
pub const WM_CAP_SET_VIDEOFORMAT = @as(u32, 1069);
pub const WM_CAP_DLG_VIDEOCOMPRESSION = @as(u32, 1070);
pub const WM_CAP_SET_PREVIEW = @as(u32, 1074);
pub const WM_CAP_SET_OVERLAY = @as(u32, 1075);
pub const WM_CAP_SET_PREVIEWRATE = @as(u32, 1076);
pub const WM_CAP_SET_SCALE = @as(u32, 1077);
pub const WM_CAP_GET_STATUS = @as(u32, 1078);
pub const WM_CAP_SET_SCROLL = @as(u32, 1079);
pub const WM_CAP_GRAB_FRAME = @as(u32, 1084);
pub const WM_CAP_GRAB_FRAME_NOSTOP = @as(u32, 1085);
pub const WM_CAP_SEQUENCE = @as(u32, 1086);
pub const WM_CAP_SEQUENCE_NOFILE = @as(u32, 1087);
pub const WM_CAP_SET_SEQUENCE_SETUP = @as(u32, 1088);
pub const WM_CAP_GET_SEQUENCE_SETUP = @as(u32, 1089);
pub const WM_CAP_SET_MCI_DEVICEA = @as(u32, 1090);
pub const WM_CAP_GET_MCI_DEVICEA = @as(u32, 1091);
pub const WM_CAP_SET_MCI_DEVICEW = @as(u32, 1190);
pub const WM_CAP_GET_MCI_DEVICEW = @as(u32, 1191);
pub const WM_CAP_STOP = @as(u32, 1092);
pub const WM_CAP_ABORT = @as(u32, 1093);
pub const WM_CAP_SINGLE_FRAME_OPEN = @as(u32, 1094);
pub const WM_CAP_SINGLE_FRAME_CLOSE = @as(u32, 1095);
pub const WM_CAP_SINGLE_FRAME = @as(u32, 1096);
pub const WM_CAP_PAL_OPENA = @as(u32, 1104);
pub const WM_CAP_PAL_SAVEA = @as(u32, 1105);
pub const WM_CAP_PAL_OPENW = @as(u32, 1204);
pub const WM_CAP_PAL_SAVEW = @as(u32, 1205);
pub const WM_CAP_PAL_PASTE = @as(u32, 1106);
pub const WM_CAP_PAL_AUTOCREATE = @as(u32, 1107);
pub const WM_CAP_PAL_MANUALCREATE = @as(u32, 1108);
pub const WM_CAP_SET_CALLBACK_CAPCONTROL = @as(u32, 1109);
pub const AVSTREAMMASTER_AUDIO = @as(u32, 0);
pub const AVSTREAMMASTER_NONE = @as(u32, 1);
pub const CONTROLCALLBACK_PREROLL = @as(u32, 1);
pub const CONTROLCALLBACK_CAPTURING = @as(u32, 2);
pub const IDS_CAP_BEGIN = @as(u32, 300);
pub const IDS_CAP_END = @as(u32, 301);
pub const IDS_CAP_INFO = @as(u32, 401);
pub const IDS_CAP_OUTOFMEM = @as(u32, 402);
pub const IDS_CAP_FILEEXISTS = @as(u32, 403);
pub const IDS_CAP_ERRORPALOPEN = @as(u32, 404);
pub const IDS_CAP_ERRORPALSAVE = @as(u32, 405);
pub const IDS_CAP_ERRORDIBSAVE = @as(u32, 406);
pub const IDS_CAP_DEFAVIEXT = @as(u32, 407);
pub const IDS_CAP_DEFPALEXT = @as(u32, 408);
pub const IDS_CAP_CANTOPEN = @as(u32, 409);
pub const IDS_CAP_SEQ_MSGSTART = @as(u32, 410);
pub const IDS_CAP_SEQ_MSGSTOP = @as(u32, 411);
pub const IDS_CAP_VIDEDITERR = @as(u32, 412);
pub const IDS_CAP_READONLYFILE = @as(u32, 413);
pub const IDS_CAP_WRITEERROR = @as(u32, 414);
pub const IDS_CAP_NODISKSPACE = @as(u32, 415);
pub const IDS_CAP_SETFILESIZE = @as(u32, 416);
pub const IDS_CAP_SAVEASPERCENT = @as(u32, 417);
pub const IDS_CAP_DRIVER_ERROR = @as(u32, 418);
pub const IDS_CAP_WAVE_OPEN_ERROR = @as(u32, 419);
pub const IDS_CAP_WAVE_ALLOC_ERROR = @as(u32, 420);
pub const IDS_CAP_WAVE_PREPARE_ERROR = @as(u32, 421);
pub const IDS_CAP_WAVE_ADD_ERROR = @as(u32, 422);
pub const IDS_CAP_WAVE_SIZE_ERROR = @as(u32, 423);
pub const IDS_CAP_VIDEO_OPEN_ERROR = @as(u32, 424);
pub const IDS_CAP_VIDEO_ALLOC_ERROR = @as(u32, 425);
pub const IDS_CAP_VIDEO_PREPARE_ERROR = @as(u32, 426);
pub const IDS_CAP_VIDEO_ADD_ERROR = @as(u32, 427);
pub const IDS_CAP_VIDEO_SIZE_ERROR = @as(u32, 428);
pub const IDS_CAP_FILE_OPEN_ERROR = @as(u32, 429);
pub const IDS_CAP_FILE_WRITE_ERROR = @as(u32, 430);
pub const IDS_CAP_RECORDING_ERROR = @as(u32, 431);
pub const IDS_CAP_RECORDING_ERROR2 = @as(u32, 432);
pub const IDS_CAP_AVI_INIT_ERROR = @as(u32, 433);
pub const IDS_CAP_NO_FRAME_CAP_ERROR = @as(u32, 434);
pub const IDS_CAP_NO_PALETTE_WARN = @as(u32, 435);
pub const IDS_CAP_MCI_CONTROL_ERROR = @as(u32, 436);
pub const IDS_CAP_MCI_CANT_STEP_ERROR = @as(u32, 437);
pub const IDS_CAP_NO_AUDIO_CAP_ERROR = @as(u32, 438);
pub const IDS_CAP_AVI_DRAWDIB_ERROR = @as(u32, 439);
pub const IDS_CAP_COMPRESSOR_ERROR = @as(u32, 440);
pub const IDS_CAP_AUDIO_DROP_ERROR = @as(u32, 441);
pub const IDS_CAP_AUDIO_DROP_COMPERROR = @as(u32, 442);
pub const IDS_CAP_STAT_LIVE_MODE = @as(u32, 500);
pub const IDS_CAP_STAT_OVERLAY_MODE = @as(u32, 501);
pub const IDS_CAP_STAT_CAP_INIT = @as(u32, 502);
pub const IDS_CAP_STAT_CAP_FINI = @as(u32, 503);
pub const IDS_CAP_STAT_PALETTE_BUILD = @as(u32, 504);
pub const IDS_CAP_STAT_OPTPAL_BUILD = @as(u32, 505);
pub const IDS_CAP_STAT_I_FRAMES = @as(u32, 506);
pub const IDS_CAP_STAT_L_FRAMES = @as(u32, 507);
pub const IDS_CAP_STAT_CAP_L_FRAMES = @as(u32, 508);
pub const IDS_CAP_STAT_CAP_AUDIO = @as(u32, 509);
pub const IDS_CAP_STAT_VIDEOCURRENT = @as(u32, 510);
pub const IDS_CAP_STAT_VIDEOAUDIO = @as(u32, 511);
pub const IDS_CAP_STAT_VIDEOONLY = @as(u32, 512);
pub const IDS_CAP_STAT_FRAMESDROPPED = @as(u32, 513);
pub const JOYERR_NOERROR = @as(u32, 0);
pub const JOYERR_PARMS = @as(u32, 165);
pub const JOYERR_NOCANDO = @as(u32, 166);
pub const JOYERR_UNPLUGGED = @as(u32, 167);
pub const JOY_BUTTON1 = @as(u32, 1);
pub const JOY_BUTTON2 = @as(u32, 2);
pub const JOY_BUTTON3 = @as(u32, 4);
pub const JOY_BUTTON4 = @as(u32, 8);
pub const JOY_BUTTON1CHG = @as(u32, 256);
pub const JOY_BUTTON2CHG = @as(u32, 512);
pub const JOY_BUTTON3CHG = @as(u32, 1024);
pub const JOY_BUTTON4CHG = @as(u32, 2048);
pub const JOY_BUTTON5 = @as(i32, 16);
pub const JOY_BUTTON6 = @as(i32, 32);
pub const JOY_BUTTON7 = @as(i32, 64);
pub const JOY_BUTTON8 = @as(i32, 128);
pub const JOY_BUTTON9 = @as(i32, 256);
pub const JOY_BUTTON10 = @as(i32, 512);
pub const JOY_BUTTON11 = @as(i32, 1024);
pub const JOY_BUTTON12 = @as(i32, 2048);
pub const JOY_BUTTON13 = @as(i32, 4096);
pub const JOY_BUTTON14 = @as(i32, 8192);
pub const JOY_BUTTON15 = @as(i32, 16384);
pub const JOY_BUTTON16 = @as(i32, 32768);
pub const JOY_BUTTON17 = @as(i32, 65536);
pub const JOY_BUTTON18 = @as(i32, 131072);
pub const JOY_BUTTON19 = @as(i32, 262144);
pub const JOY_BUTTON20 = @as(i32, 524288);
pub const JOY_BUTTON21 = @as(i32, 1048576);
pub const JOY_BUTTON22 = @as(i32, 2097152);
pub const JOY_BUTTON23 = @as(i32, 4194304);
pub const JOY_BUTTON24 = @as(i32, 8388608);
pub const JOY_BUTTON25 = @as(i32, 16777216);
pub const JOY_BUTTON26 = @as(i32, 33554432);
pub const JOY_BUTTON27 = @as(i32, 67108864);
pub const JOY_BUTTON28 = @as(i32, 134217728);
pub const JOY_BUTTON29 = @as(i32, 268435456);
pub const JOY_BUTTON30 = @as(i32, 536870912);
pub const JOY_BUTTON31 = @as(i32, 1073741824);
pub const JOY_BUTTON32 = @as(i32, -2147483648);
pub const JOY_POVFORWARD = @as(u32, 0);
pub const JOY_POVRIGHT = @as(u32, 9000);
pub const JOY_POVBACKWARD = @as(u32, 18000);
pub const JOY_POVLEFT = @as(u32, 27000);
pub const JOY_RETURNX = @as(i32, 1);
pub const JOY_RETURNY = @as(i32, 2);
pub const JOY_RETURNZ = @as(i32, 4);
pub const JOY_RETURNR = @as(i32, 8);
pub const JOY_RETURNU = @as(i32, 16);
pub const JOY_RETURNV = @as(i32, 32);
pub const JOY_RETURNPOV = @as(i32, 64);
pub const JOY_RETURNBUTTONS = @as(i32, 128);
pub const JOY_RETURNRAWDATA = @as(i32, 256);
pub const JOY_RETURNPOVCTS = @as(i32, 512);
pub const JOY_RETURNCENTERED = @as(i32, 1024);
pub const JOY_USEDEADZONE = @as(i32, 2048);
pub const JOY_CAL_READALWAYS = @as(i32, 65536);
pub const JOY_CAL_READXYONLY = @as(i32, 131072);
pub const JOY_CAL_READ3 = @as(i32, 262144);
pub const JOY_CAL_READ4 = @as(i32, 524288);
pub const JOY_CAL_READXONLY = @as(i32, 1048576);
pub const JOY_CAL_READYONLY = @as(i32, 2097152);
pub const JOY_CAL_READ5 = @as(i32, 4194304);
pub const JOY_CAL_READ6 = @as(i32, 8388608);
pub const JOY_CAL_READZONLY = @as(i32, 16777216);
pub const JOY_CAL_READRONLY = @as(i32, 33554432);
pub const JOY_CAL_READUONLY = @as(i32, 67108864);
pub const JOY_CAL_READVONLY = @as(i32, 134217728);
pub const JOYSTICKID1 = @as(u32, 0);
pub const JOYSTICKID2 = @as(u32, 1);
pub const JOYCAPS_HASZ = @as(u32, 1);
pub const JOYCAPS_HASR = @as(u32, 2);
pub const JOYCAPS_HASU = @as(u32, 4);
pub const JOYCAPS_HASV = @as(u32, 8);
pub const JOYCAPS_HASPOV = @as(u32, 16);
pub const JOYCAPS_POV4DIR = @as(u32, 32);
pub const JOYCAPS_POVCTS = @as(u32, 64);
pub const DRV_LOAD = @as(u32, 1);
pub const DRV_ENABLE = @as(u32, 2);
pub const DRV_OPEN = @as(u32, 3);
pub const DRV_CLOSE = @as(u32, 4);
pub const DRV_DISABLE = @as(u32, 5);
pub const DRV_FREE = @as(u32, 6);
pub const DRV_CONFIGURE = @as(u32, 7);
pub const DRV_QUERYCONFIGURE = @as(u32, 8);
pub const DRV_INSTALL = @as(u32, 9);
pub const DRV_REMOVE = @as(u32, 10);
pub const DRV_RESERVED = @as(u32, 2048);
pub const DRV_USER = @as(u32, 16384);
pub const DCB_NOSWITCH = @as(u32, 8);
pub const DCB_TYPEMASK = @as(u32, 7);
pub const DCB_NULL = @as(u32, 0);
pub const DCB_WINDOW = @as(u32, 1);
pub const DCB_TASK = @as(u32, 2);
pub const DCB_FUNCTION = @as(u32, 3);
pub const DCB_EVENT = @as(u32, 5);
pub const DRVM_INIT = @as(u32, 100);
pub const DRVM_EXIT = @as(u32, 101);
pub const DRVM_DISABLE = @as(u32, 102);
pub const DRVM_ENABLE = @as(u32, 103);
pub const DRVM_INIT_EX = @as(u32, 104);
pub const DRVM_USER = @as(u32, 16384);
pub const DRVM_MAPPER_RECONFIGURE = @as(u32, 8193);
pub const DRVM_MAPPER_PREFERRED_GET = @as(u32, 8213);
pub const DRVM_MAPPER_CONSOLEVOICECOM_GET = @as(u32, 8215);
pub const DRV_QUERYDEVNODE = @as(u32, 2050);
pub const DRV_QUERYMAPPABLE = @as(u32, 2053);
pub const DRV_QUERYMODULE = @as(u32, 2057);
pub const DRV_PNPINSTALL = @as(u32, 2059);
pub const DRV_QUERYDEVICEINTERFACE = @as(u32, 2060);
pub const DRV_QUERYDEVICEINTERFACESIZE = @as(u32, 2061);
pub const DRV_QUERYSTRINGID = @as(u32, 2062);
pub const DRV_QUERYSTRINGIDSIZE = @as(u32, 2063);
pub const DRV_QUERYIDFROMSTRINGID = @as(u32, 2064);
pub const DRV_QUERYFUNCTIONINSTANCEID = @as(u32, 2065);
pub const DRV_QUERYFUNCTIONINSTANCEIDSIZE = @as(u32, 2066);
pub const DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY = @as(u32, 1);
pub const DRVM_IOCTL = @as(u32, 256);
pub const DRVM_ADD_THRU = @as(u32, 257);
pub const DRVM_REMOVE_THRU = @as(u32, 258);
pub const DRVM_IOCTL_LAST = @as(u32, 261);
pub const DRVM_IOCTL_CMD_USER = @as(i32, 0);
pub const DRVM_IOCTL_CMD_SYSTEM = @as(i32, -2147483648);
pub const VADMAD_Device_ID = @as(u32, 1092);
pub const WODM_GETNUMDEVS = @as(u32, 3);
pub const WODM_GETDEVCAPS = @as(u32, 4);
pub const WODM_OPEN = @as(u32, 5);
pub const WODM_CLOSE = @as(u32, 6);
pub const WODM_PREPARE = @as(u32, 7);
pub const WODM_UNPREPARE = @as(u32, 8);
pub const WODM_WRITE = @as(u32, 9);
pub const WODM_PAUSE = @as(u32, 10);
pub const WODM_RESTART = @as(u32, 11);
pub const WODM_RESET = @as(u32, 12);
pub const WODM_GETPOS = @as(u32, 13);
pub const WODM_GETPITCH = @as(u32, 14);
pub const WODM_SETPITCH = @as(u32, 15);
pub const WODM_GETVOLUME = @as(u32, 16);
pub const WODM_SETVOLUME = @as(u32, 17);
pub const WODM_GETPLAYBACKRATE = @as(u32, 18);
pub const WODM_SETPLAYBACKRATE = @as(u32, 19);
pub const WODM_BREAKLOOP = @as(u32, 20);
pub const WODM_PREFERRED = @as(u32, 21);
pub const WODM_BUSY = @as(u32, 21);
pub const WIDM_GETNUMDEVS = @as(u32, 50);
pub const WIDM_GETDEVCAPS = @as(u32, 51);
pub const WIDM_OPEN = @as(u32, 52);
pub const WIDM_CLOSE = @as(u32, 53);
pub const WIDM_PREPARE = @as(u32, 54);
pub const WIDM_UNPREPARE = @as(u32, 55);
pub const WIDM_ADDBUFFER = @as(u32, 56);
pub const WIDM_START = @as(u32, 57);
pub const WIDM_STOP = @as(u32, 58);
pub const WIDM_RESET = @as(u32, 59);
pub const WIDM_GETPOS = @as(u32, 60);
pub const WIDM_PREFERRED = @as(u32, 61);
pub const MIDI_IO_PACKED = @as(i32, 0);
pub const MIDI_IO_COOKED = @as(i32, 2);
pub const MODM_GETNUMDEVS = @as(u32, 1);
pub const MODM_GETDEVCAPS = @as(u32, 2);
pub const MODM_OPEN = @as(u32, 3);
pub const MODM_CLOSE = @as(u32, 4);
pub const MODM_PREPARE = @as(u32, 5);
pub const MODM_UNPREPARE = @as(u32, 6);
pub const MODM_DATA = @as(u32, 7);
pub const MODM_LONGDATA = @as(u32, 8);
pub const MODM_RESET = @as(u32, 9);
pub const MODM_GETVOLUME = @as(u32, 10);
pub const MODM_SETVOLUME = @as(u32, 11);
pub const MODM_CACHEPATCHES = @as(u32, 12);
pub const MODM_CACHEDRUMPATCHES = @as(u32, 13);
pub const MODM_STRMDATA = @as(u32, 14);
pub const MODM_GETPOS = @as(u32, 17);
pub const MODM_PAUSE = @as(u32, 18);
pub const MODM_RESTART = @as(u32, 19);
pub const MODM_STOP = @as(u32, 20);
pub const MODM_PROPERTIES = @as(u32, 21);
pub const MODM_PREFERRED = @as(u32, 22);
pub const MODM_RECONFIGURE = @as(u32, 18280);
pub const MIDM_GETNUMDEVS = @as(u32, 53);
pub const MIDM_GETDEVCAPS = @as(u32, 54);
pub const MIDM_OPEN = @as(u32, 55);
pub const MIDM_CLOSE = @as(u32, 56);
pub const MIDM_PREPARE = @as(u32, 57);
pub const MIDM_UNPREPARE = @as(u32, 58);
pub const MIDM_ADDBUFFER = @as(u32, 59);
pub const MIDM_START = @as(u32, 60);
pub const MIDM_STOP = @as(u32, 61);
pub const MIDM_RESET = @as(u32, 62);
pub const AUXDM_GETNUMDEVS = @as(u32, 3);
pub const AUXDM_GETDEVCAPS = @as(u32, 4);
pub const AUXDM_GETVOLUME = @as(u32, 5);
pub const AUXDM_SETVOLUME = @as(u32, 6);
pub const MXDM_BASE = @as(u32, 1);
pub const MXDM_GETNUMDEVS = @as(u32, 1);
pub const MXDM_GETDEVCAPS = @as(u32, 2);
pub const MXDM_OPEN = @as(u32, 3);
pub const MXDM_CLOSE = @as(u32, 4);
pub const MXDM_GETLINEINFO = @as(u32, 5);
pub const MXDM_GETLINECONTROLS = @as(u32, 6);
pub const MXDM_GETCONTROLDETAILS = @as(u32, 7);
pub const MXDM_SETCONTROLDETAILS = @as(u32, 8);
pub const TDD_KILLTIMEREVENT = @as(u32, 2048);
pub const TDD_SETTIMEREVENT = @as(u32, 2052);
pub const TDD_GETSYSTEMTIME = @as(u32, 2056);
pub const TDD_GETDEVCAPS = @as(u32, 2060);
pub const TDD_BEGINMINPERIOD = @as(u32, 2064);
pub const TDD_ENDMINPERIOD = @as(u32, 2068);
pub const JDD_GETNUMDEVS = @as(u32, 2049);
pub const JDD_GETDEVCAPS = @as(u32, 2050);
pub const JDD_GETPOS = @as(u32, 2305);
pub const JDD_SETCALIBRATION = @as(u32, 2306);
pub const JDD_CONFIGCHANGED = @as(u32, 2307);
pub const JDD_GETPOSEX = @as(u32, 2308);
pub const MCI_OPEN_DRIVER = @as(u32, 2049);
pub const MCI_CLOSE_DRIVER = @as(u32, 2050);
pub const MCI_FALSE = @as(u32, 531);
pub const MCI_TRUE = @as(u32, 532);
pub const MCI_FORMAT_MILLISECONDS_S = @as(u32, 533);
pub const MCI_FORMAT_HMS_S = @as(u32, 534);
pub const MCI_FORMAT_MSF_S = @as(u32, 535);
pub const MCI_FORMAT_FRAMES_S = @as(u32, 536);
pub const MCI_FORMAT_SMPTE_24_S = @as(u32, 537);
pub const MCI_FORMAT_SMPTE_25_S = @as(u32, 538);
pub const MCI_FORMAT_SMPTE_30_S = @as(u32, 539);
pub const MCI_FORMAT_SMPTE_30DROP_S = @as(u32, 540);
pub const MCI_FORMAT_BYTES_S = @as(u32, 541);
pub const MCI_FORMAT_SAMPLES_S = @as(u32, 542);
pub const MCI_FORMAT_TMSF_S = @as(u32, 543);
pub const MCI_VD_FORMAT_TRACK_S = @as(u32, 1029);
pub const WAVE_FORMAT_PCM_S = @as(u32, 1152);
pub const WAVE_MAPPER_S = @as(u32, 1153);
pub const MCI_SEQ_MAPPER_S = @as(u32, 1221);
pub const MCI_SEQ_FILE_S = @as(u32, 1222);
pub const MCI_SEQ_MIDI_S = @as(u32, 1223);
pub const MCI_SEQ_SMPTE_S = @as(u32, 1224);
pub const MCI_SEQ_FORMAT_SONGPTR_S = @as(u32, 1225);
pub const MCI_SEQ_NONE_S = @as(u32, 1226);
pub const MIDIMAPPER_S = @as(u32, 1227);
pub const MCI_MAX_DEVICE_TYPE_LENGTH = @as(u32, 80);
pub const MCI_RESOURCE_RETURNED = @as(u32, 65536);
pub const MCI_COLONIZED3_RETURN = @as(u32, 131072);
pub const MCI_COLONIZED4_RETURN = @as(u32, 262144);
pub const MCI_INTEGER_RETURNED = @as(u32, 524288);
pub const MCI_RESOURCE_DRIVER = @as(u32, 1048576);
pub const MCI_COMMAND_HEAD = @as(u32, 0);
pub const MCI_STRING = @as(u32, 1);
pub const MCI_INTEGER = @as(u32, 2);
pub const MCI_END_COMMAND = @as(u32, 3);
pub const MCI_RETURN = @as(u32, 4);
pub const MCI_FLAG = @as(u32, 5);
pub const MCI_END_COMMAND_LIST = @as(u32, 6);
pub const MCI_RECT = @as(u32, 7);
pub const MCI_CONSTANT = @as(u32, 8);
pub const MCI_END_CONSTANT = @as(u32, 9);
pub const MCI_HWND = @as(u32, 10);
pub const MCI_HPAL = @as(u32, 11);
pub const MCI_HDC = @as(u32, 12);
pub const MCI_INTEGER64 = @as(u32, 13);
pub const TASKERR_NOTASKSUPPORT = @as(u32, 1);
pub const TASKERR_OUTOFMEMORY = @as(u32, 2);
pub const DRV_EXITSESSION = @as(u32, 11);
pub const DRV_POWER = @as(u32, 15);
pub const DRVCNF_CANCEL = @as(u32, 0);
pub const DRVCNF_OK = @as(u32, 1);
pub const DRVCNF_RESTART = @as(u32, 2);
pub const DRV_MCI_LAST = @as(u32, 6143);
pub const MMIOERR_BASE = @as(u32, 256);
pub const MMIOERR_FILENOTFOUND = @as(u32, 257);
pub const MMIOERR_OUTOFMEMORY = @as(u32, 258);
pub const MMIOERR_CANNOTOPEN = @as(u32, 259);
pub const MMIOERR_CANNOTCLOSE = @as(u32, 260);
pub const MMIOERR_CANNOTREAD = @as(u32, 261);
pub const MMIOERR_CANNOTWRITE = @as(u32, 262);
pub const MMIOERR_CANNOTSEEK = @as(u32, 263);
pub const MMIOERR_CANNOTEXPAND = @as(u32, 264);
pub const MMIOERR_CHUNKNOTFOUND = @as(u32, 265);
pub const MMIOERR_UNBUFFERED = @as(u32, 266);
pub const MMIOERR_PATHNOTFOUND = @as(u32, 267);
pub const MMIOERR_ACCESSDENIED = @as(u32, 268);
pub const MMIOERR_SHARINGVIOLATION = @as(u32, 269);
pub const MMIOERR_NETWORKERROR = @as(u32, 270);
pub const MMIOERR_TOOMANYOPENFILES = @as(u32, 271);
pub const MMIOERR_INVALIDFILE = @as(u32, 272);
pub const MMIO_RWMODE = @as(u32, 3);
pub const MMIO_SHAREMODE = @as(u32, 112);
pub const MMIO_CREATE = @as(u32, 4096);
pub const MMIO_PARSE = @as(u32, 256);
pub const MMIO_DELETE = @as(u32, 512);
pub const MMIO_EXIST = @as(u32, 16384);
pub const MMIO_ALLOCBUF = @as(u32, 65536);
pub const MMIO_GETTEMP = @as(u32, 131072);
pub const MMIO_DIRTY = @as(u32, 268435456);
pub const MMIO_READ = @as(u32, 0);
pub const MMIO_WRITE = @as(u32, 1);
pub const MMIO_READWRITE = @as(u32, 2);
pub const MMIO_COMPAT = @as(u32, 0);
pub const MMIO_EXCLUSIVE = @as(u32, 16);
pub const MMIO_DENYWRITE = @as(u32, 32);
pub const MMIO_DENYREAD = @as(u32, 48);
pub const MMIO_DENYNONE = @as(u32, 64);
pub const MMIO_FHOPEN = @as(u32, 16);
pub const MMIO_EMPTYBUF = @as(u32, 16);
pub const MMIO_TOUPPER = @as(u32, 16);
pub const MMIO_INSTALLPROC = @as(u32, 65536);
pub const MMIO_GLOBALPROC = @as(u32, 268435456);
pub const MMIO_REMOVEPROC = @as(u32, 131072);
pub const MMIO_UNICODEPROC = @as(u32, 16777216);
pub const MMIO_FINDPROC = @as(u32, 262144);
pub const MMIO_FINDCHUNK = @as(u32, 16);
pub const MMIO_FINDRIFF = @as(u32, 32);
pub const MMIO_FINDLIST = @as(u32, 64);
pub const MMIO_CREATERIFF = @as(u32, 32);
pub const MMIO_CREATELIST = @as(u32, 64);
pub const MMIOM_SEEK = @as(u32, 2);
pub const MMIOM_OPEN = @as(u32, 3);
pub const MMIOM_CLOSE = @as(u32, 4);
pub const MMIOM_WRITEFLUSH = @as(u32, 5);
pub const MMIOM_RENAME = @as(u32, 6);
pub const MMIOM_USER = @as(u32, 32768);
pub const SEEK_SET = @as(u32, 0);
pub const SEEK_CUR = @as(u32, 1);
pub const SEEK_END = @as(u32, 2);
pub const MMIO_DEFAULTBUFFER = @as(u32, 8192);
pub const TIMERR_NOERROR = @as(u32, 0);
pub const TIMERR_NOCANDO = @as(u32, 97);
pub const TIMERR_STRUCT = @as(u32, 129);
//--------------------------------------------------------------------------------
// Section: Types (251)
//--------------------------------------------------------------------------------
pub const MIDI_WAVE_OPEN_TYPE = enum(u32) {
CALLBACK_TYPEMASK = 458752,
CALLBACK_NULL = 0,
CALLBACK_WINDOW = 65536,
CALLBACK_TASK = 131072,
CALLBACK_FUNCTION = 196608,
// CALLBACK_THREAD = 131072, this enum value conflicts with CALLBACK_TASK
CALLBACK_EVENT = 327680,
WAVE_FORMAT_QUERY = 1,
WAVE_ALLOWSYNC = 2,
WAVE_MAPPED = 4,
WAVE_FORMAT_DIRECT = 8,
WAVE_FORMAT_DIRECT_QUERY = 9,
WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE = 16,
MIDI_IO_STATUS = 32,
_,
pub fn initFlags(o: struct {
CALLBACK_TYPEMASK: u1 = 0,
CALLBACK_NULL: u1 = 0,
CALLBACK_WINDOW: u1 = 0,
CALLBACK_TASK: u1 = 0,
CALLBACK_FUNCTION: u1 = 0,
CALLBACK_EVENT: u1 = 0,
WAVE_FORMAT_QUERY: u1 = 0,
WAVE_ALLOWSYNC: u1 = 0,
WAVE_MAPPED: u1 = 0,
WAVE_FORMAT_DIRECT: u1 = 0,
WAVE_FORMAT_DIRECT_QUERY: u1 = 0,
WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE: u1 = 0,
MIDI_IO_STATUS: u1 = 0,
}) MIDI_WAVE_OPEN_TYPE {
return @intToEnum(MIDI_WAVE_OPEN_TYPE,
(if (o.CALLBACK_TYPEMASK == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_TYPEMASK) else 0)
| (if (o.CALLBACK_NULL == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_NULL) else 0)
| (if (o.CALLBACK_WINDOW == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_WINDOW) else 0)
| (if (o.CALLBACK_TASK == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_TASK) else 0)
| (if (o.CALLBACK_FUNCTION == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_FUNCTION) else 0)
| (if (o.CALLBACK_EVENT == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_EVENT) else 0)
| (if (o.WAVE_FORMAT_QUERY == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_QUERY) else 0)
| (if (o.WAVE_ALLOWSYNC == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_ALLOWSYNC) else 0)
| (if (o.WAVE_MAPPED == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_MAPPED) else 0)
| (if (o.WAVE_FORMAT_DIRECT == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_DIRECT) else 0)
| (if (o.WAVE_FORMAT_DIRECT_QUERY == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_DIRECT_QUERY) else 0)
| (if (o.WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE) else 0)
| (if (o.MIDI_IO_STATUS == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.MIDI_IO_STATUS) else 0)
);
}
};
pub const CALLBACK_TYPEMASK = MIDI_WAVE_OPEN_TYPE.CALLBACK_TYPEMASK;
pub const CALLBACK_NULL = MIDI_WAVE_OPEN_TYPE.CALLBACK_NULL;
pub const CALLBACK_WINDOW = MIDI_WAVE_OPEN_TYPE.CALLBACK_WINDOW;
pub const CALLBACK_TASK = MIDI_WAVE_OPEN_TYPE.CALLBACK_TASK;
pub const CALLBACK_FUNCTION = MIDI_WAVE_OPEN_TYPE.CALLBACK_FUNCTION;
pub const CALLBACK_THREAD = MIDI_WAVE_OPEN_TYPE.CALLBACK_TASK;
pub const CALLBACK_EVENT = MIDI_WAVE_OPEN_TYPE.CALLBACK_EVENT;
pub const WAVE_FORMAT_QUERY = MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_QUERY;
pub const WAVE_ALLOWSYNC = MIDI_WAVE_OPEN_TYPE.WAVE_ALLOWSYNC;
pub const WAVE_MAPPED = MIDI_WAVE_OPEN_TYPE.WAVE_MAPPED;
pub const WAVE_FORMAT_DIRECT = MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_DIRECT;
pub const WAVE_FORMAT_DIRECT_QUERY = MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_DIRECT_QUERY;
pub const WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE = MIDI_WAVE_OPEN_TYPE.WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE;
pub const MIDI_IO_STATUS = MIDI_WAVE_OPEN_TYPE.MIDI_IO_STATUS;
pub const MIXERLINE_COMPONENTTYPE = enum(u32) {
DST_DIGITAL = 1,
DST_HEADPHONES = 5,
DST_LINE = 2,
DST_MONITOR = 3,
DST_SPEAKERS = 4,
DST_TELEPHONE = 6,
DST_UNDEFINED = 0,
DST_VOICEIN = 8,
DST_WAVEIN = 7,
SRC_ANALOG = 4106,
SRC_AUXILIARY = 4105,
SRC_COMPACTDISC = 4101,
SRC_DIGITAL = 4097,
SRC_LINE = 4098,
SRC_MICROPHONE = 4099,
SRC_PCSPEAKER = 4103,
SRC_SYNTHESIZER = 4100,
SRC_TELEPHONE = 4102,
SRC_UNDEFINED = 4096,
SRC_WAVEOUT = 4104,
};
pub const MIXERLINE_COMPONENTTYPE_DST_DIGITAL = MIXERLINE_COMPONENTTYPE.DST_DIGITAL;
pub const MIXERLINE_COMPONENTTYPE_DST_HEADPHONES = MIXERLINE_COMPONENTTYPE.DST_HEADPHONES;
pub const MIXERLINE_COMPONENTTYPE_DST_LINE = MIXERLINE_COMPONENTTYPE.DST_LINE;
pub const MIXERLINE_COMPONENTTYPE_DST_MONITOR = MIXERLINE_COMPONENTTYPE.DST_MONITOR;
pub const MIXERLINE_COMPONENTTYPE_DST_SPEAKERS = MIXERLINE_COMPONENTTYPE.DST_SPEAKERS;
pub const MIXERLINE_COMPONENTTYPE_DST_TELEPHONE = MIXERLINE_COMPONENTTYPE.DST_TELEPHONE;
pub const MIXERLINE_COMPONENTTYPE_DST_UNDEFINED = MIXERLINE_COMPONENTTYPE.DST_UNDEFINED;
pub const MIXERLINE_COMPONENTTYPE_DST_VOICEIN = MIXERLINE_COMPONENTTYPE.DST_VOICEIN;
pub const MIXERLINE_COMPONENTTYPE_DST_WAVEIN = MIXERLINE_COMPONENTTYPE.DST_WAVEIN;
pub const MIXERLINE_COMPONENTTYPE_SRC_ANALOG = MIXERLINE_COMPONENTTYPE.SRC_ANALOG;
pub const MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY = MIXERLINE_COMPONENTTYPE.SRC_AUXILIARY;
pub const MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC = MIXERLINE_COMPONENTTYPE.SRC_COMPACTDISC;
pub const MIXERLINE_COMPONENTTYPE_SRC_DIGITAL = MIXERLINE_COMPONENTTYPE.SRC_DIGITAL;
pub const MIXERLINE_COMPONENTTYPE_SRC_LINE = MIXERLINE_COMPONENTTYPE.SRC_LINE;
pub const MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE = MIXERLINE_COMPONENTTYPE.SRC_MICROPHONE;
pub const MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER = MIXERLINE_COMPONENTTYPE.SRC_PCSPEAKER;
pub const MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER = MIXERLINE_COMPONENTTYPE.SRC_SYNTHESIZER;
pub const MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE = MIXERLINE_COMPONENTTYPE.SRC_TELEPHONE;
pub const MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED = MIXERLINE_COMPONENTTYPE.SRC_UNDEFINED;
pub const MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT = MIXERLINE_COMPONENTTYPE.SRC_WAVEOUT;
pub const LPWAVECALLBACK = fn(
hdrvr: ?HDRVR,
uMsg: u32,
dwUser: usize,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const LPMIDICALLBACK = fn(
hdrvr: ?HDRVR,
uMsg: u32,
dwUser: usize,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const HMIDI = *opaque{};
pub const HMIDIIN = *opaque{};
pub const HMIDIOUT = *opaque{};
pub const HMIDISTRM = *opaque{};
pub const HMIXER = *opaque{};
pub const HMIXEROBJ = *opaque{};
pub const HWAVE = *opaque{};
pub const HWAVEOUT = *opaque{};
pub const HWAVEIN = *opaque{};
pub const HMMIO = *opaque{};
pub const HDRVR = *opaque{};
pub const HACMDRIVERID = *opaque{};
pub const HACMDRIVER = *opaque{};
pub const HACMSTREAM = *opaque{};
pub const HACMOBJ = *opaque{};
pub const HIC = *opaque{};
pub const HVIDEO = *opaque{};
pub const WAVEFORMAT = packed struct {
wFormatTag: u16,
nChannels: u16,
nSamplesPerSec: u32,
nAvgBytesPerSec: u32,
nBlockAlign: u16,
};
pub const PCMWAVEFORMAT = packed struct {
wf: WAVEFORMAT,
wBitsPerSample: u16,
};
pub const WAVEFORMATEX = packed struct {
wFormatTag: u16,
nChannels: u16,
nSamplesPerSec: u32,
nAvgBytesPerSec: u32,
nBlockAlign: u16,
wBitsPerSample: u16,
cbSize: u16,
};
const CLSID_KSDATAFORMAT_SUBTYPE_PCM_Value = @import("../zig.zig").Guid.initString("00000001-0000-0010-8000-00aa00389b71");
pub const CLSID_KSDATAFORMAT_SUBTYPE_PCM = &CLSID_KSDATAFORMAT_SUBTYPE_PCM_Value;
const CLSID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT_Value = @import("../zig.zig").Guid.initString("00000003-0000-0010-8000-00aa00389b71");
pub const CLSID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = &CLSID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT_Value;
const CLSID_KSDATAFORMAT_SUBTYPE_WAVEFORMATEX_Value = @import("../zig.zig").Guid.initString("00000000-0000-0010-8000-00aa00389b71");
pub const CLSID_KSDATAFORMAT_SUBTYPE_WAVEFORMATEX = &CLSID_KSDATAFORMAT_SUBTYPE_WAVEFORMATEX_Value;
pub const WAVEFORMATEXTENSIBLE = packed struct {
Format: WAVEFORMATEX,
Samples: packed union {
wValidBitsPerSample: u16,
wSamplesPerBlock: u16,
wReserved: u16,
},
dwChannelMask: u32,
SubFormat: Guid,
};
pub const ADPCMCOEFSET = packed struct {
iCoef1: i16,
iCoef2: i16,
};
pub const ADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
wNumCoef: u16,
aCoef: [1]ADPCMCOEFSET,
};
pub const DRMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wReserved: u16,
ulContentId: u32,
wfxSecure: WAVEFORMATEX,
};
pub const DVIADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const IMAADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const MEDIASPACEADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wRevision: u16,
};
pub const SIERRAADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wRevision: u16,
};
pub const G723_ADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
cbExtraSize: u16,
nAuxBlockSize: u16,
};
pub const DIGISTDWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const DIGIFIXWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const DIALOGICOKIADPCMWAVEFORMAT = extern struct {
ewf: WAVEFORMATEX,
};
pub const YAMAHA_ADPCMWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const SONARCWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wCompType: u16,
};
pub const TRUESPEECHWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wRevision: u16,
nSamplesPerBlock: u16,
abReserved: [28]u8,
};
pub const ECHOSC1WAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const AUDIOFILE_AF36WAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const APTXWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const AUDIOFILE_AF10WAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const DOLBYAC2WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
nAuxBitsCode: u16,
};
pub const GSM610WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const ADPCMEWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const CONTRESVQLPCWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const DIGIREALWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const DIGIADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const CONTRESCR10WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const NMS_VBXADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
};
pub const G721_ADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
nAuxBlockSize: u16,
};
pub const MSAUDIO1WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wSamplesPerBlock: u16,
wEncodeOptions: u16,
};
pub const WMAUDIO2WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
dwSamplesPerBlock: u32,
wEncodeOptions: u16,
dwSuperBlockAlign: u32,
};
pub const WMAUDIO3WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wValidBitsPerSample: u16,
dwChannelMask: u32,
dwReserved1: u32,
dwReserved2: u32,
wEncodeOptions: u16,
wReserved3: u16,
};
pub const CREATIVEADPCMWAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wRevision: u16,
};
pub const CREATIVEFASTSPEECH8WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wRevision: u16,
};
pub const CREATIVEFASTSPEECH10WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wRevision: u16,
};
pub const FMTOWNS_SND_WAVEFORMAT = packed struct {
wfx: WAVEFORMATEX,
wRevision: u16,
};
pub const OLIGSMWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const OLIADPCMWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const OLICELPWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const OLISBCWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const OLIOPRWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const CSIMAADPCMWAVEFORMAT = extern struct {
wfx: WAVEFORMATEX,
};
pub const WAVEFILTER = packed struct {
cbStruct: u32,
dwFilterTag: u32,
fdwFilter: u32,
dwReserved: [5]u32,
};
pub const VOLUMEWAVEFILTER = packed struct {
wfltr: WAVEFILTER,
dwVolume: u32,
};
pub const ECHOWAVEFILTER = packed struct {
wfltr: WAVEFILTER,
dwVolume: u32,
dwDelay: u32,
};
pub const s_RIFFWAVE_inst = extern struct {
bUnshiftedNote: u8,
chFineTune: CHAR,
chGain: CHAR,
bLowNote: u8,
bHighNote: u8,
bLowVelocity: u8,
bHighVelocity: u8,
};
pub const EXBMINFOHEADER = packed struct {
bmi: BITMAPINFOHEADER,
biExtDataOffset: u32,
};
pub const JPEGINFOHEADER = packed struct {
JPEGSize: u32,
JPEGProcess: u32,
JPEGColorSpaceID: u32,
JPEGBitsPerSample: u32,
JPEGHSubSampling: u32,
JPEGVSubSampling: u32,
};
pub const MMTIME = packed struct {
wType: u32,
u: packed union {
ms: u32,
sample: u32,
cb: u32,
ticks: u32,
smpte: extern struct {
hour: u8,
min: u8,
sec: u8,
frame: u8,
fps: u8,
dummy: u8,
pad: [2]u8,
},
midi: packed struct {
songptrpos: u32,
},
},
};
pub const LPDRVCALLBACK = fn(
hdrvr: ?HDRVR,
uMsg: u32,
dwUser: usize,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const DRVCONFIGINFOEX = packed struct {
dwDCISize: u32,
lpszDCISectionName: ?[*:0]const u16,
lpszDCIAliasName: ?[*:0]const u16,
dnDevNode: u32,
};
pub const DRVCONFIGINFO = packed struct {
dwDCISize: u32,
lpszDCISectionName: ?[*:0]const u16,
lpszDCIAliasName: ?[*:0]const u16,
};
pub const DRIVERPROC = fn(
param0: usize,
param1: ?HDRVR,
param2: u32,
param3: LPARAM,
param4: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const DRIVERMSGPROC = fn(
param0: u32,
param1: u32,
param2: usize,
param3: usize,
param4: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const LPMMIOPROC = fn(
lpmmioinfo: ?PSTR,
uMsg: u32,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const MMIOINFO = packed struct {
dwFlags: u32,
fccIOProc: u32,
pIOProc: ?LPMMIOPROC,
wErrorRet: u32,
htask: ?HTASK,
cchBuffer: i32,
pchBuffer: ?*i8,
pchNext: ?*i8,
pchEndRead: ?*i8,
pchEndWrite: ?*i8,
lBufOffset: i32,
lDiskOffset: i32,
adwInfo: [3]u32,
dwReserved1: u32,
dwReserved2: u32,
hmmio: ?HMMIO,
};
pub const MMCKINFO = packed struct {
ckid: u32,
cksize: u32,
fccType: u32,
dwDataOffset: u32,
dwFlags: u32,
};
pub const WAVEHDR = packed struct {
lpData: ?PSTR,
dwBufferLength: u32,
dwBytesRecorded: u32,
dwUser: usize,
dwFlags: u32,
dwLoops: u32,
lpNext: ?*WAVEHDR,
reserved: usize,
};
pub const WAVEOUTCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
dwSupport: u32,
};
pub const WAVEOUTCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
dwSupport: u32,
};
pub const WAVEOUTCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const WAVEOUTCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const WAVEINCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
};
pub const WAVEINCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
};
pub const WAVEINCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const WAVEINCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIOUTCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
wTechnology: u16,
wVoices: u16,
wNotes: u16,
wChannelMask: u16,
dwSupport: u32,
};
pub const MIDIOUTCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
wTechnology: u16,
wVoices: u16,
wNotes: u16,
wChannelMask: u16,
dwSupport: u32,
};
pub const MIDIOUTCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
wTechnology: u16,
wVoices: u16,
wNotes: u16,
wChannelMask: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIOUTCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
wTechnology: u16,
wVoices: u16,
wNotes: u16,
wChannelMask: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIINCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwSupport: u32,
};
pub const MIDIINCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwSupport: u32,
};
pub const MIDIINCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIINCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIHDR = packed struct {
lpData: ?PSTR,
dwBufferLength: u32,
dwBytesRecorded: u32,
dwUser: usize,
dwFlags: u32,
lpNext: ?*MIDIHDR,
reserved: usize,
dwOffset: u32,
dwReserved: [8]usize,
};
pub const MIDIEVENT = packed struct {
dwDeltaTime: u32,
dwStreamID: u32,
dwEvent: u32,
dwParms: [1]u32,
};
pub const MIDISTRMBUFFVER = packed struct {
dwVersion: u32,
dwMid: u32,
dwOEMVersion: u32,
};
pub const MIDIPROPTIMEDIV = packed struct {
cbStruct: u32,
dwTimeDiv: u32,
};
pub const MIDIPROPTEMPO = packed struct {
cbStruct: u32,
dwTempo: u32,
};
pub const AUXCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
wTechnology: u16,
wReserved1: u16,
dwSupport: u32,
};
pub const AUXCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
wTechnology: u16,
wReserved1: u16,
dwSupport: u32,
};
pub const AUXCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
wTechnology: u16,
wReserved1: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const AUXCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
wTechnology: u16,
wReserved1: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIXERCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
fdwSupport: u32,
cDestinations: u32,
};
pub const MIXERCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
fdwSupport: u32,
cDestinations: u32,
};
pub const MIXERCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
fdwSupport: u32,
cDestinations: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIXERCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
fdwSupport: u32,
cDestinations: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIXERLINEA = packed struct {
cbStruct: u32,
dwDestination: u32,
dwSource: u32,
dwLineID: u32,
fdwLine: u32,
dwUser: usize,
dwComponentType: MIXERLINE_COMPONENTTYPE,
cChannels: u32,
cConnections: u32,
cControls: u32,
szShortName: [16]CHAR,
szName: [64]CHAR,
Target: packed struct {
dwType: u32,
dwDeviceID: u32,
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
},
};
pub const MIXERLINEW = packed struct {
cbStruct: u32,
dwDestination: u32,
dwSource: u32,
dwLineID: u32,
fdwLine: u32,
dwUser: usize,
dwComponentType: MIXERLINE_COMPONENTTYPE,
cChannels: u32,
cConnections: u32,
cControls: u32,
szShortName: [16]u16,
szName: [64]u16,
Target: packed struct {
dwType: u32,
dwDeviceID: u32,
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
},
};
pub const MIXERCONTROLA = packed struct {
cbStruct: u32,
dwControlID: u32,
dwControlType: u32,
fdwControl: u32,
cMultipleItems: u32,
szShortName: [16]CHAR,
szName: [64]CHAR,
Bounds: packed union {
Anonymous1: packed struct {
lMinimum: i32,
lMaximum: i32,
},
Anonymous2: packed struct {
dwMinimum: u32,
dwMaximum: u32,
},
dwReserved: [6]u32,
},
Metrics: packed union {
cSteps: u32,
cbCustomData: u32,
dwReserved: [6]u32,
},
};
pub const MIXERCONTROLW = packed struct {
cbStruct: u32,
dwControlID: u32,
dwControlType: u32,
fdwControl: u32,
cMultipleItems: u32,
szShortName: [16]u16,
szName: [64]u16,
Bounds: packed union {
Anonymous1: packed struct {
lMinimum: i32,
lMaximum: i32,
},
Anonymous2: packed struct {
dwMinimum: u32,
dwMaximum: u32,
},
dwReserved: [6]u32,
},
Metrics: packed union {
cSteps: u32,
cbCustomData: u32,
dwReserved: [6]u32,
},
};
pub const MIXERLINECONTROLSA = packed struct {
cbStruct: u32,
dwLineID: u32,
Anonymous: packed union {
dwControlID: u32,
dwControlType: u32,
},
cControls: u32,
cbmxctrl: u32,
pamxctrl: ?*MIXERCONTROLA,
};
pub const MIXERLINECONTROLSW = packed struct {
cbStruct: u32,
dwLineID: u32,
Anonymous: packed union {
dwControlID: u32,
dwControlType: u32,
},
cControls: u32,
cbmxctrl: u32,
pamxctrl: ?*MIXERCONTROLW,
};
pub const MIXERCONTROLDETAILS = packed struct {
cbStruct: u32,
dwControlID: u32,
cChannels: u32,
Anonymous: packed union {
hwndOwner: ?HWND,
cMultipleItems: u32,
},
cbDetails: u32,
paDetails: ?*c_void,
};
pub const MIXERCONTROLDETAILS_LISTTEXTA = packed struct {
dwParam1: u32,
dwParam2: u32,
szName: [64]CHAR,
};
pub const MIXERCONTROLDETAILS_LISTTEXTW = packed struct {
dwParam1: u32,
dwParam2: u32,
szName: [64]u16,
};
pub const MIXERCONTROLDETAILS_BOOLEAN = packed struct {
fValue: i32,
};
pub const MIXERCONTROLDETAILS_SIGNED = packed struct {
lValue: i32,
};
pub const MIXERCONTROLDETAILS_UNSIGNED = packed struct {
dwValue: u32,
};
pub const TIMECAPS = packed struct {
wPeriodMin: u32,
wPeriodMax: u32,
};
pub const JOYCAPSA = packed struct {
wMid: u16,
wPid: u16,
szPname: [32]CHAR,
wXmin: u32,
wXmax: u32,
wYmin: u32,
wYmax: u32,
wZmin: u32,
wZmax: u32,
wNumButtons: u32,
wPeriodMin: u32,
wPeriodMax: u32,
wRmin: u32,
wRmax: u32,
wUmin: u32,
wUmax: u32,
wVmin: u32,
wVmax: u32,
wCaps: u32,
wMaxAxes: u32,
wNumAxes: u32,
wMaxButtons: u32,
szRegKey: [32]CHAR,
szOEMVxD: [260]CHAR,
};
pub const JOYCAPSW = packed struct {
wMid: u16,
wPid: u16,
szPname: [32]u16,
wXmin: u32,
wXmax: u32,
wYmin: u32,
wYmax: u32,
wZmin: u32,
wZmax: u32,
wNumButtons: u32,
wPeriodMin: u32,
wPeriodMax: u32,
wRmin: u32,
wRmax: u32,
wUmin: u32,
wUmax: u32,
wVmin: u32,
wVmax: u32,
wCaps: u32,
wMaxAxes: u32,
wNumAxes: u32,
wMaxButtons: u32,
szRegKey: [32]u16,
szOEMVxD: [260]u16,
};
pub const JOYCAPS2A = packed struct {
wMid: u16,
wPid: u16,
szPname: [32]CHAR,
wXmin: u32,
wXmax: u32,
wYmin: u32,
wYmax: u32,
wZmin: u32,
wZmax: u32,
wNumButtons: u32,
wPeriodMin: u32,
wPeriodMax: u32,
wRmin: u32,
wRmax: u32,
wUmin: u32,
wUmax: u32,
wVmin: u32,
wVmax: u32,
wCaps: u32,
wMaxAxes: u32,
wNumAxes: u32,
wMaxButtons: u32,
szRegKey: [32]CHAR,
szOEMVxD: [260]CHAR,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const JOYCAPS2W = packed struct {
wMid: u16,
wPid: u16,
szPname: [32]u16,
wXmin: u32,
wXmax: u32,
wYmin: u32,
wYmax: u32,
wZmin: u32,
wZmax: u32,
wNumButtons: u32,
wPeriodMin: u32,
wPeriodMax: u32,
wRmin: u32,
wRmax: u32,
wUmin: u32,
wUmax: u32,
wVmin: u32,
wVmax: u32,
wCaps: u32,
wMaxAxes: u32,
wNumAxes: u32,
wMaxButtons: u32,
szRegKey: [32]u16,
szOEMVxD: [260]u16,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const JOYINFO = packed struct {
wXpos: u32,
wYpos: u32,
wZpos: u32,
wButtons: u32,
};
pub const JOYINFOEX = packed struct {
dwSize: u32,
dwFlags: u32,
dwXpos: u32,
dwYpos: u32,
dwZpos: u32,
dwRpos: u32,
dwUpos: u32,
dwVpos: u32,
dwButtons: u32,
dwButtonNumber: u32,
dwPOV: u32,
dwReserved1: u32,
dwReserved2: u32,
};
pub const MCI_DGV_RECT_PARMS = packed struct {
dwCallback: usize,
rc: RECT,
};
pub const MCI_DGV_CAPTURE_PARMSA = packed struct {
dwCallback: usize,
lpstrFileName: ?PSTR,
rc: RECT,
};
pub const MCI_DGV_CAPTURE_PARMSW = packed struct {
dwCallback: usize,
lpstrFileName: ?PWSTR,
rc: RECT,
};
pub const MCI_DGV_COPY_PARMS = packed struct {
dwCallback: usize,
dwFrom: u32,
dwTo: u32,
rc: RECT,
dwAudioStream: u32,
dwVideoStream: u32,
};
pub const MCI_DGV_CUE_PARMS = packed struct {
dwCallback: usize,
dwTo: u32,
};
pub const MCI_DGV_CUT_PARMS = packed struct {
dwCallback: usize,
dwFrom: u32,
dwTo: u32,
rc: RECT,
dwAudioStream: u32,
dwVideoStream: u32,
};
pub const MCI_DGV_DELETE_PARMS = packed struct {
dwCallback: usize,
dwFrom: u32,
dwTo: u32,
rc: RECT,
dwAudioStream: u32,
dwVideoStream: u32,
};
pub const MCI_DGV_INFO_PARMSA = packed struct {
dwCallback: usize,
lpstrReturn: ?PSTR,
dwRetSize: u32,
dwItem: u32,
};
pub const MCI_DGV_INFO_PARMSW = packed struct {
dwCallback: usize,
lpstrReturn: ?PWSTR,
dwRetSize: u32,
dwItem: u32,
};
pub const MCI_DGV_LIST_PARMSA = packed struct {
dwCallback: usize,
lpstrReturn: ?PSTR,
dwLength: u32,
dwNumber: u32,
dwItem: u32,
lpstrAlgorithm: ?PSTR,
};
pub const MCI_DGV_LIST_PARMSW = packed struct {
dwCallback: usize,
lpstrReturn: ?PWSTR,
dwLength: u32,
dwNumber: u32,
dwItem: u32,
lpstrAlgorithm: ?PWSTR,
};
pub const MCI_DGV_MONITOR_PARMS = packed struct {
dwCallback: usize,
dwSource: u32,
dwMethod: u32,
};
pub const MCI_DGV_OPEN_PARMSA = packed struct {
dwCallback: usize,
wDeviceID: u32,
lpstrDeviceType: ?PSTR,
lpstrElementName: ?PSTR,
lpstrAlias: ?PSTR,
dwStyle: u32,
hWndParent: ?HWND,
};
pub const MCI_DGV_OPEN_PARMSW = packed struct {
dwCallback: usize,
wDeviceID: u32,
lpstrDeviceType: ?PWSTR,
lpstrElementName: ?PWSTR,
lpstrAlias: ?PWSTR,
dwStyle: u32,
hWndParent: ?HWND,
};
pub const MCI_DGV_PASTE_PARMS = packed struct {
dwCallback: usize,
dwTo: u32,
rc: RECT,
dwAudioStream: u32,
dwVideoStream: u32,
};
pub const MCI_DGV_QUALITY_PARMSA = packed struct {
dwCallback: usize,
dwItem: u32,
lpstrName: ?PSTR,
lpstrAlgorithm: u32,
dwHandle: u32,
};
pub const MCI_DGV_QUALITY_PARMSW = packed struct {
dwCallback: usize,
dwItem: u32,
lpstrName: ?PWSTR,
lpstrAlgorithm: u32,
dwHandle: u32,
};
pub const MCI_DGV_RECORD_PARMS = packed struct {
dwCallback: usize,
dwFrom: u32,
dwTo: u32,
rc: RECT,
dwAudioStream: u32,
dwVideoStream: u32,
};
pub const MCI_DGV_RESERVE_PARMSA = packed struct {
dwCallback: usize,
lpstrPath: ?PSTR,
dwSize: u32,
};
pub const MCI_DGV_RESERVE_PARMSW = packed struct {
dwCallback: usize,
lpstrPath: ?PWSTR,
dwSize: u32,
};
pub const MCI_DGV_RESTORE_PARMSA = packed struct {
dwCallback: usize,
lpstrFileName: ?PSTR,
rc: RECT,
};
pub const MCI_DGV_RESTORE_PARMSW = packed struct {
dwCallback: usize,
lpstrFileName: ?PWSTR,
rc: RECT,
};
pub const MCI_DGV_SAVE_PARMSA = packed struct {
dwCallback: usize,
lpstrFileName: ?PSTR,
rc: RECT,
};
pub const MCI_DGV_SAVE_PARMSW = packed struct {
dwCallback: usize,
lpstrFileName: ?PWSTR,
rc: RECT,
};
pub const MCI_DGV_SET_PARMS = packed struct {
dwCallback: usize,
dwTimeFormat: u32,
dwAudio: u32,
dwFileFormat: u32,
dwSpeed: u32,
};
pub const MCI_DGV_SETAUDIO_PARMSA = packed struct {
dwCallback: usize,
dwItem: u32,
dwValue: u32,
dwOver: u32,
lpstrAlgorithm: ?PSTR,
lpstrQuality: ?PSTR,
};
pub const MCI_DGV_SETAUDIO_PARMSW = packed struct {
dwCallback: usize,
dwItem: u32,
dwValue: u32,
dwOver: u32,
lpstrAlgorithm: ?PWSTR,
lpstrQuality: ?PWSTR,
};
pub const MCI_DGV_SIGNAL_PARMS = packed struct {
dwCallback: usize,
dwPosition: u32,
dwPeriod: u32,
dwUserParm: u32,
};
pub const MCI_DGV_SETVIDEO_PARMSA = packed struct {
dwCallback: usize,
dwItem: u32,
dwValue: u32,
dwOver: u32,
lpstrAlgorithm: ?PSTR,
lpstrQuality: ?PSTR,
dwSourceNumber: u32,
};
pub const MCI_DGV_SETVIDEO_PARMSW = packed struct {
dwCallback: usize,
dwItem: u32,
dwValue: u32,
dwOver: u32,
lpstrAlgorithm: ?PWSTR,
lpstrQuality: ?PWSTR,
dwSourceNumber: u32,
};
pub const MCI_DGV_STATUS_PARMSA = packed struct {
dwCallback: usize,
dwReturn: usize,
dwItem: u32,
dwTrack: u32,
lpstrDrive: ?PSTR,
dwReference: u32,
};
pub const MCI_DGV_STATUS_PARMSW = packed struct {
dwCallback: usize,
dwReturn: usize,
dwItem: u32,
dwTrack: u32,
lpstrDrive: ?PWSTR,
dwReference: u32,
};
pub const MCI_DGV_STEP_PARMS = packed struct {
dwCallback: usize,
dwFrames: u32,
};
pub const MCI_DGV_UPDATE_PARMS = packed struct {
dwCallback: usize,
rc: RECT,
hDC: ?HDC,
};
pub const MCI_DGV_WINDOW_PARMSA = packed struct {
dwCallback: usize,
hWnd: ?HWND,
nCmdShow: u32,
lpstrText: ?PSTR,
};
pub const MCI_DGV_WINDOW_PARMSW = packed struct {
dwCallback: usize,
hWnd: ?HWND,
nCmdShow: u32,
lpstrText: ?PWSTR,
};
pub const ACMDRIVERENUMCB = fn(
hadid: ?HACMDRIVERID,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const LPACMDRIVERPROC = fn(
param0: usize,
param1: ?HACMDRIVERID,
param2: u32,
param3: LPARAM,
param4: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const ACMDRIVERDETAILSA = packed struct {
cbStruct: u32,
fccType: u32,
fccComp: u32,
wMid: u16,
wPid: u16,
vdwACM: u32,
vdwDriver: u32,
fdwSupport: u32,
cFormatTags: u32,
cFilterTags: u32,
hicon: ?HICON,
szShortName: [32]CHAR,
szLongName: [128]CHAR,
szCopyright: [80]CHAR,
szLicensing: [128]CHAR,
szFeatures: [512]CHAR,
};
pub const ACMDRIVERDETAILSW = packed struct {
cbStruct: u32,
fccType: u32,
fccComp: u32,
wMid: u16,
wPid: u16,
vdwACM: u32,
vdwDriver: u32,
fdwSupport: u32,
cFormatTags: u32,
cFilterTags: u32,
hicon: ?HICON,
szShortName: [32]u16,
szLongName: [128]u16,
szCopyright: [80]u16,
szLicensing: [128]u16,
szFeatures: [512]u16,
};
pub const ACMFORMATTAGDETAILSA = packed struct {
cbStruct: u32,
dwFormatTagIndex: u32,
dwFormatTag: u32,
cbFormatSize: u32,
fdwSupport: u32,
cStandardFormats: u32,
szFormatTag: [48]CHAR,
};
pub const ACMFORMATTAGDETAILSW = packed struct {
cbStruct: u32,
dwFormatTagIndex: u32,
dwFormatTag: u32,
cbFormatSize: u32,
fdwSupport: u32,
cStandardFormats: u32,
szFormatTag: [48]u16,
};
pub const ACMFORMATTAGENUMCBA = fn(
hadid: ?HACMDRIVERID,
paftd: ?*ACMFORMATTAGDETAILSA,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFORMATTAGENUMCBW = fn(
hadid: ?HACMDRIVERID,
paftd: ?*ACMFORMATTAGDETAILSW,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFORMATDETAILSA = packed struct {
cbStruct: u32,
dwFormatIndex: u32,
dwFormatTag: u32,
fdwSupport: u32,
pwfx: ?*WAVEFORMATEX,
cbwfx: u32,
szFormat: [128]CHAR,
};
pub const tACMFORMATDETAILSW = packed struct {
cbStruct: u32,
dwFormatIndex: u32,
dwFormatTag: u32,
fdwSupport: u32,
pwfx: ?*WAVEFORMATEX,
cbwfx: u32,
szFormat: [128]u16,
};
pub const ACMFORMATENUMCBA = fn(
hadid: ?HACMDRIVERID,
pafd: ?*ACMFORMATDETAILSA,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFORMATENUMCBW = fn(
hadid: ?HACMDRIVERID,
pafd: ?*tACMFORMATDETAILSW,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFORMATCHOOSEHOOKPROCA = fn(
hwnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ACMFORMATCHOOSEHOOKPROCW = fn(
hwnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ACMFORMATCHOOSEA = packed struct {
cbStruct: u32,
fdwStyle: u32,
hwndOwner: ?HWND,
pwfx: ?*WAVEFORMATEX,
cbwfx: u32,
pszTitle: ?[*:0]const u8,
szFormatTag: [48]CHAR,
szFormat: [128]CHAR,
pszName: ?PSTR,
cchName: u32,
fdwEnum: u32,
pwfxEnum: ?*WAVEFORMATEX,
hInstance: ?HINSTANCE,
pszTemplateName: ?[*:0]const u8,
lCustData: LPARAM,
pfnHook: ?ACMFORMATCHOOSEHOOKPROCA,
};
pub const ACMFORMATCHOOSEW = packed struct {
cbStruct: u32,
fdwStyle: u32,
hwndOwner: ?HWND,
pwfx: ?*WAVEFORMATEX,
cbwfx: u32,
pszTitle: ?[*:0]const u16,
szFormatTag: [48]u16,
szFormat: [128]u16,
pszName: ?PWSTR,
cchName: u32,
fdwEnum: u32,
pwfxEnum: ?*WAVEFORMATEX,
hInstance: ?HINSTANCE,
pszTemplateName: ?[*:0]const u16,
lCustData: LPARAM,
pfnHook: ?ACMFORMATCHOOSEHOOKPROCW,
};
pub const ACMFILTERTAGDETAILSA = packed struct {
cbStruct: u32,
dwFilterTagIndex: u32,
dwFilterTag: u32,
cbFilterSize: u32,
fdwSupport: u32,
cStandardFilters: u32,
szFilterTag: [48]CHAR,
};
pub const ACMFILTERTAGDETAILSW = packed struct {
cbStruct: u32,
dwFilterTagIndex: u32,
dwFilterTag: u32,
cbFilterSize: u32,
fdwSupport: u32,
cStandardFilters: u32,
szFilterTag: [48]u16,
};
pub const ACMFILTERTAGENUMCBA = fn(
hadid: ?HACMDRIVERID,
paftd: ?*ACMFILTERTAGDETAILSA,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFILTERTAGENUMCBW = fn(
hadid: ?HACMDRIVERID,
paftd: ?*ACMFILTERTAGDETAILSW,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFILTERDETAILSA = packed struct {
cbStruct: u32,
dwFilterIndex: u32,
dwFilterTag: u32,
fdwSupport: u32,
pwfltr: ?*WAVEFILTER,
cbwfltr: u32,
szFilter: [128]CHAR,
};
pub const ACMFILTERDETAILSW = packed struct {
cbStruct: u32,
dwFilterIndex: u32,
dwFilterTag: u32,
fdwSupport: u32,
pwfltr: ?*WAVEFILTER,
cbwfltr: u32,
szFilter: [128]u16,
};
pub const ACMFILTERENUMCBA = fn(
hadid: ?HACMDRIVERID,
pafd: ?*ACMFILTERDETAILSA,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFILTERENUMCBW = fn(
hadid: ?HACMDRIVERID,
pafd: ?*ACMFILTERDETAILSW,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFILTERCHOOSEHOOKPROCA = fn(
hwnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ACMFILTERCHOOSEHOOKPROCW = fn(
hwnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ACMFILTERCHOOSEA = packed struct {
cbStruct: u32,
fdwStyle: u32,
hwndOwner: ?HWND,
pwfltr: ?*WAVEFILTER,
cbwfltr: u32,
pszTitle: ?[*:0]const u8,
szFilterTag: [48]CHAR,
szFilter: [128]CHAR,
pszName: ?PSTR,
cchName: u32,
fdwEnum: u32,
pwfltrEnum: ?*WAVEFILTER,
hInstance: ?HINSTANCE,
pszTemplateName: ?[*:0]const u8,
lCustData: LPARAM,
pfnHook: ?ACMFILTERCHOOSEHOOKPROCA,
};
pub const ACMFILTERCHOOSEW = packed struct {
cbStruct: u32,
fdwStyle: u32,
hwndOwner: ?HWND,
pwfltr: ?*WAVEFILTER,
cbwfltr: u32,
pszTitle: ?[*:0]const u16,
szFilterTag: [48]u16,
szFilter: [128]u16,
pszName: ?PWSTR,
cchName: u32,
fdwEnum: u32,
pwfltrEnum: ?*WAVEFILTER,
hInstance: ?HINSTANCE,
pszTemplateName: ?[*:0]const u16,
lCustData: LPARAM,
pfnHook: ?ACMFILTERCHOOSEHOOKPROCW,
};
pub const ICOPEN = extern struct {
dwSize: u32,
fccType: u32,
fccHandler: u32,
dwVersion: u32,
dwFlags: u32,
dwError: LRESULT,
pV1Reserved: ?*c_void,
pV2Reserved: ?*c_void,
dnDevNode: u32,
};
pub const ICINFO = extern struct {
dwSize: u32,
fccType: u32,
fccHandler: u32,
dwFlags: u32,
dwVersion: u32,
dwVersionICM: u32,
szName: [16]u16,
szDescription: [128]u16,
szDriver: [128]u16,
};
pub const ICCOMPRESS = extern struct {
dwFlags: u32,
lpbiOutput: ?*BITMAPINFOHEADER,
lpOutput: ?*c_void,
lpbiInput: ?*BITMAPINFOHEADER,
lpInput: ?*c_void,
lpckid: ?*u32,
lpdwFlags: ?*u32,
lFrameNum: i32,
dwFrameSize: u32,
dwQuality: u32,
lpbiPrev: ?*BITMAPINFOHEADER,
lpPrev: ?*c_void,
};
pub const ICCOMPRESSFRAMES = extern struct {
dwFlags: u32,
lpbiOutput: ?*BITMAPINFOHEADER,
lOutput: LPARAM,
lpbiInput: ?*BITMAPINFOHEADER,
lInput: LPARAM,
lStartFrame: i32,
lFrameCount: i32,
lQuality: i32,
lDataRate: i32,
lKeyRate: i32,
dwRate: u32,
dwScale: u32,
dwOverheadPerFrame: u32,
dwReserved2: u32,
GetData: isize,
PutData: isize,
};
pub const ICSETSTATUSPROC = extern struct {
dwFlags: u32,
lParam: LPARAM,
Status: isize,
};
pub const ICDECOMPRESS = extern struct {
dwFlags: u32,
lpbiInput: ?*BITMAPINFOHEADER,
lpInput: ?*c_void,
lpbiOutput: ?*BITMAPINFOHEADER,
lpOutput: ?*c_void,
ckid: u32,
};
pub const ICDECOMPRESSEX = extern struct {
dwFlags: u32,
lpbiSrc: ?*BITMAPINFOHEADER,
lpSrc: ?*c_void,
lpbiDst: ?*BITMAPINFOHEADER,
lpDst: ?*c_void,
xDst: i32,
yDst: i32,
dxDst: i32,
dyDst: i32,
xSrc: i32,
ySrc: i32,
dxSrc: i32,
dySrc: i32,
};
pub const ICDRAWBEGIN = extern struct {
dwFlags: u32,
hpal: ?HPALETTE,
hwnd: ?HWND,
hdc: ?HDC,
xDst: i32,
yDst: i32,
dxDst: i32,
dyDst: i32,
lpbi: ?*BITMAPINFOHEADER,
xSrc: i32,
ySrc: i32,
dxSrc: i32,
dySrc: i32,
dwRate: u32,
dwScale: u32,
};
pub const ICDRAW = extern struct {
dwFlags: u32,
lpFormat: ?*c_void,
lpData: ?*c_void,
cbData: u32,
lTime: i32,
};
pub const ICDRAWSUGGEST = extern struct {
lpbiIn: ?*BITMAPINFOHEADER,
lpbiSuggest: ?*BITMAPINFOHEADER,
dxSrc: i32,
dySrc: i32,
dxDst: i32,
dyDst: i32,
hicDecompressor: ?HIC,
};
pub const ICPALETTE = extern struct {
dwFlags: u32,
iStart: i32,
iLen: i32,
lppe: ?*PALETTEENTRY,
};
pub const COMPVARS = extern struct {
cbSize: i32,
dwFlags: u32,
hic: ?HIC,
fccType: u32,
fccHandler: u32,
lpbiIn: ?*BITMAPINFO,
lpbiOut: ?*BITMAPINFO,
lpBitsOut: ?*c_void,
lpBitsPrev: ?*c_void,
lFrame: i32,
lKey: i32,
lDataRate: i32,
lQ: i32,
lKeyCount: i32,
lpState: ?*c_void,
cbState: i32,
};
pub const DRAWDIBTIME = extern struct {
timeCount: i32,
timeDraw: i32,
timeDecompress: i32,
timeDither: i32,
timeStretch: i32,
timeBlt: i32,
timeSetDIBits: i32,
};
pub const AVISTREAMINFOW = extern struct {
fccType: u32,
fccHandler: u32,
dwFlags: u32,
dwCaps: u32,
wPriority: u16,
wLanguage: u16,
dwScale: u32,
dwRate: u32,
dwStart: u32,
dwLength: u32,
dwInitialFrames: u32,
dwSuggestedBufferSize: u32,
dwQuality: u32,
dwSampleSize: u32,
rcFrame: RECT,
dwEditCount: u32,
dwFormatChangeCount: u32,
szName: [64]u16,
};
pub const AVISTREAMINFOA = extern struct {
fccType: u32,
fccHandler: u32,
dwFlags: u32,
dwCaps: u32,
wPriority: u16,
wLanguage: u16,
dwScale: u32,
dwRate: u32,
dwStart: u32,
dwLength: u32,
dwInitialFrames: u32,
dwSuggestedBufferSize: u32,
dwQuality: u32,
dwSampleSize: u32,
rcFrame: RECT,
dwEditCount: u32,
dwFormatChangeCount: u32,
szName: [64]CHAR,
};
pub const AVIFILEINFOW = extern struct {
dwMaxBytesPerSec: u32,
dwFlags: u32,
dwCaps: u32,
dwStreams: u32,
dwSuggestedBufferSize: u32,
dwWidth: u32,
dwHeight: u32,
dwScale: u32,
dwRate: u32,
dwLength: u32,
dwEditCount: u32,
szFileType: [64]u16,
};
pub const AVIFILEINFOA = extern struct {
dwMaxBytesPerSec: u32,
dwFlags: u32,
dwCaps: u32,
dwStreams: u32,
dwSuggestedBufferSize: u32,
dwWidth: u32,
dwHeight: u32,
dwScale: u32,
dwRate: u32,
dwLength: u32,
dwEditCount: u32,
szFileType: [64]CHAR,
};
pub const AVISAVECALLBACK = fn(
param0: i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const AVICOMPRESSOPTIONS = extern struct {
fccType: u32,
fccHandler: u32,
dwKeyFrameEvery: u32,
dwQuality: u32,
dwBytesPerSecond: u32,
dwFlags: u32,
lpFormat: ?*c_void,
cbFormat: u32,
lpParms: ?*c_void,
cbParms: u32,
dwInterleaveEvery: u32,
};
// TODO: this type is limited to platform 'windows5.0'
const IID_IAVIStream_Value = @import("../zig.zig").Guid.initString("00020021-0000-0000-c000-000000000046");
pub const IID_IAVIStream = &IID_IAVIStream_Value;
pub const IAVIStream = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Create: fn(
self: *const IAVIStream,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Info: fn(
self: *const IAVIStream,
// TODO: what to do with BytesParamIndex 1?
psi: ?*AVISTREAMINFOW,
lSize: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindSample: fn(
self: *const IAVIStream,
lPos: i32,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) i32,
ReadFormat: fn(
self: *const IAVIStream,
lPos: i32,
// TODO: what to do with BytesParamIndex 2?
lpFormat: ?*c_void,
lpcbFormat: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetFormat: fn(
self: *const IAVIStream,
lPos: i32,
// TODO: what to do with BytesParamIndex 2?
lpFormat: ?*c_void,
cbFormat: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Read: fn(
self: *const IAVIStream,
lStart: i32,
lSamples: i32,
// TODO: what to do with BytesParamIndex 3?
lpBuffer: ?*c_void,
cbBuffer: i32,
plBytes: ?*i32,
plSamples: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Write: fn(
self: *const IAVIStream,
lStart: i32,
lSamples: i32,
// TODO: what to do with BytesParamIndex 3?
lpBuffer: ?*c_void,
cbBuffer: i32,
dwFlags: u32,
plSampWritten: ?*i32,
plBytesWritten: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Delete: fn(
self: *const IAVIStream,
lStart: i32,
lSamples: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReadData: fn(
self: *const IAVIStream,
fcc: u32,
// TODO: what to do with BytesParamIndex 2?
lp: ?*c_void,
lpcb: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteData: fn(
self: *const IAVIStream,
fcc: u32,
// TODO: what to do with BytesParamIndex 2?
lp: ?*c_void,
cb: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetInfo: fn(
self: *const IAVIStream,
// TODO: what to do with BytesParamIndex 1?
lpInfo: ?*AVISTREAMINFOW,
cbInfo: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_Create(self: *const T, lParam1: LPARAM, lParam2: LPARAM) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).Create(@ptrCast(*const IAVIStream, self), lParam1, lParam2);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_Info(self: *const T, psi: ?*AVISTREAMINFOW, lSize: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).Info(@ptrCast(*const IAVIStream, self), psi, lSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_FindSample(self: *const T, lPos: i32, lFlags: i32) callconv(.Inline) i32 {
return @ptrCast(*const IAVIStream.VTable, self.vtable).FindSample(@ptrCast(*const IAVIStream, self), lPos, lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_ReadFormat(self: *const T, lPos: i32, lpFormat: ?*c_void, lpcbFormat: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).ReadFormat(@ptrCast(*const IAVIStream, self), lPos, lpFormat, lpcbFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_SetFormat(self: *const T, lPos: i32, lpFormat: ?*c_void, cbFormat: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).SetFormat(@ptrCast(*const IAVIStream, self), lPos, lpFormat, cbFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_Read(self: *const T, lStart: i32, lSamples: i32, lpBuffer: ?*c_void, cbBuffer: i32, plBytes: ?*i32, plSamples: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).Read(@ptrCast(*const IAVIStream, self), lStart, lSamples, lpBuffer, cbBuffer, plBytes, plSamples);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_Write(self: *const T, lStart: i32, lSamples: i32, lpBuffer: ?*c_void, cbBuffer: i32, dwFlags: u32, plSampWritten: ?*i32, plBytesWritten: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).Write(@ptrCast(*const IAVIStream, self), lStart, lSamples, lpBuffer, cbBuffer, dwFlags, plSampWritten, plBytesWritten);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_Delete(self: *const T, lStart: i32, lSamples: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).Delete(@ptrCast(*const IAVIStream, self), lStart, lSamples);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_ReadData(self: *const T, fcc: u32, lp: ?*c_void, lpcb: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).ReadData(@ptrCast(*const IAVIStream, self), fcc, lp, lpcb);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_WriteData(self: *const T, fcc: u32, lp: ?*c_void, cb: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).WriteData(@ptrCast(*const IAVIStream, self), fcc, lp, cb);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStream_SetInfo(self: *const T, lpInfo: ?*AVISTREAMINFOW, cbInfo: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStream.VTable, self.vtable).SetInfo(@ptrCast(*const IAVIStream, self), lpInfo, cbInfo);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows5.0'
const IID_IAVIStreaming_Value = @import("../zig.zig").Guid.initString("00020022-0000-0000-c000-000000000046");
pub const IID_IAVIStreaming = &IID_IAVIStreaming_Value;
pub const IAVIStreaming = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Begin: fn(
self: *const IAVIStreaming,
lStart: i32,
lEnd: i32,
lRate: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
End: fn(
self: *const IAVIStreaming,
) 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 IAVIStreaming_Begin(self: *const T, lStart: i32, lEnd: i32, lRate: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStreaming.VTable, self.vtable).Begin(@ptrCast(*const IAVIStreaming, self), lStart, lEnd, lRate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIStreaming_End(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIStreaming.VTable, self.vtable).End(@ptrCast(*const IAVIStreaming, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows5.0'
const IID_IAVIEditStream_Value = @import("../zig.zig").Guid.initString("00020024-0000-0000-c000-000000000046");
pub const IID_IAVIEditStream = &IID_IAVIEditStream_Value;
pub const IAVIEditStream = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Cut: fn(
self: *const IAVIEditStream,
plStart: ?*i32,
plLength: ?*i32,
ppResult: ?*?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Copy: fn(
self: *const IAVIEditStream,
plStart: ?*i32,
plLength: ?*i32,
ppResult: ?*?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Paste: fn(
self: *const IAVIEditStream,
plPos: ?*i32,
plLength: ?*i32,
pstream: ?*IAVIStream,
lStart: i32,
lEnd: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone: fn(
self: *const IAVIEditStream,
ppResult: ?*?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetInfo: fn(
self: *const IAVIEditStream,
// TODO: what to do with BytesParamIndex 1?
lpInfo: ?*AVISTREAMINFOW,
cbInfo: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIEditStream_Cut(self: *const T, plStart: ?*i32, plLength: ?*i32, ppResult: ?*?*IAVIStream) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIEditStream.VTable, self.vtable).Cut(@ptrCast(*const IAVIEditStream, self), plStart, plLength, ppResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIEditStream_Copy(self: *const T, plStart: ?*i32, plLength: ?*i32, ppResult: ?*?*IAVIStream) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIEditStream.VTable, self.vtable).Copy(@ptrCast(*const IAVIEditStream, self), plStart, plLength, ppResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIEditStream_Paste(self: *const T, plPos: ?*i32, plLength: ?*i32, pstream: ?*IAVIStream, lStart: i32, lEnd: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIEditStream.VTable, self.vtable).Paste(@ptrCast(*const IAVIEditStream, self), plPos, plLength, pstream, lStart, lEnd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIEditStream_Clone(self: *const T, ppResult: ?*?*IAVIStream) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIEditStream.VTable, self.vtable).Clone(@ptrCast(*const IAVIEditStream, self), ppResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIEditStream_SetInfo(self: *const T, lpInfo: ?*AVISTREAMINFOW, cbInfo: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIEditStream.VTable, self.vtable).SetInfo(@ptrCast(*const IAVIEditStream, self), lpInfo, cbInfo);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IAVIPersistFile_Value = @import("../zig.zig").Guid.initString("00020025-0000-0000-c000-000000000046");
pub const IID_IAVIPersistFile = &IID_IAVIPersistFile_Value;
pub const IAVIPersistFile = extern struct {
pub const VTable = extern struct {
base: IPersistFile.VTable,
Reserved1: fn(
self: *const IAVIPersistFile,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IPersistFile.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIPersistFile_Reserved1(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIPersistFile.VTable, self.vtable).Reserved1(@ptrCast(*const IAVIPersistFile, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows5.0'
const IID_IAVIFile_Value = @import("../zig.zig").Guid.initString("00020020-0000-0000-c000-000000000046");
pub const IID_IAVIFile = &IID_IAVIFile_Value;
pub const IAVIFile = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Info: fn(
self: *const IAVIFile,
// TODO: what to do with BytesParamIndex 1?
pfi: ?*AVIFILEINFOW,
lSize: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStream: fn(
self: *const IAVIFile,
ppStream: ?*?*IAVIStream,
fccType: u32,
lParam: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStream: fn(
self: *const IAVIFile,
ppStream: ?*?*IAVIStream,
psi: ?*AVISTREAMINFOW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteData: fn(
self: *const IAVIFile,
ckid: u32,
// TODO: what to do with BytesParamIndex 2?
lpData: ?*c_void,
cbData: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReadData: fn(
self: *const IAVIFile,
ckid: u32,
// TODO: what to do with BytesParamIndex 2?
lpData: ?*c_void,
lpcbData: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndRecord: fn(
self: *const IAVIFile,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteStream: fn(
self: *const IAVIFile,
fccType: u32,
lParam: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIFile_Info(self: *const T, pfi: ?*AVIFILEINFOW, lSize: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIFile.VTable, self.vtable).Info(@ptrCast(*const IAVIFile, self), pfi, lSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIFile_GetStream(self: *const T, ppStream: ?*?*IAVIStream, fccType: u32, lParam: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIFile.VTable, self.vtable).GetStream(@ptrCast(*const IAVIFile, self), ppStream, fccType, lParam);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIFile_CreateStream(self: *const T, ppStream: ?*?*IAVIStream, psi: ?*AVISTREAMINFOW) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIFile.VTable, self.vtable).CreateStream(@ptrCast(*const IAVIFile, self), ppStream, psi);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIFile_WriteData(self: *const T, ckid: u32, lpData: ?*c_void, cbData: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIFile.VTable, self.vtable).WriteData(@ptrCast(*const IAVIFile, self), ckid, lpData, cbData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIFile_ReadData(self: *const T, ckid: u32, lpData: ?*c_void, lpcbData: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIFile.VTable, self.vtable).ReadData(@ptrCast(*const IAVIFile, self), ckid, lpData, lpcbData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIFile_EndRecord(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIFile.VTable, self.vtable).EndRecord(@ptrCast(*const IAVIFile, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAVIFile_DeleteStream(self: *const T, fccType: u32, lParam: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAVIFile.VTable, self.vtable).DeleteStream(@ptrCast(*const IAVIFile, self), fccType, lParam);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows5.0'
const IID_IGetFrame_Value = @import("../zig.zig").Guid.initString("00020023-0000-0000-c000-000000000046");
pub const IID_IGetFrame = &IID_IGetFrame_Value;
pub const IGetFrame = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetFrame: fn(
self: *const IGetFrame,
lPos: i32,
) callconv(@import("std").os.windows.WINAPI) ?*c_void,
Begin: fn(
self: *const IGetFrame,
lStart: i32,
lEnd: i32,
lRate: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
End: fn(
self: *const IGetFrame,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetFormat: fn(
self: *const IGetFrame,
lpbi: ?*BITMAPINFOHEADER,
lpBits: ?*c_void,
x: i32,
y: i32,
dx: i32,
dy: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IGetFrame_GetFrame(self: *const T, lPos: i32) callconv(.Inline) ?*c_void {
return @ptrCast(*const IGetFrame.VTable, self.vtable).GetFrame(@ptrCast(*const IGetFrame, self), lPos);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IGetFrame_Begin(self: *const T, lStart: i32, lEnd: i32, lRate: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IGetFrame.VTable, self.vtable).Begin(@ptrCast(*const IGetFrame, self), lStart, lEnd, lRate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IGetFrame_End(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IGetFrame.VTable, self.vtable).End(@ptrCast(*const IGetFrame, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IGetFrame_SetFormat(self: *const T, lpbi: ?*BITMAPINFOHEADER, lpBits: ?*c_void, x: i32, y: i32, dx: i32, dy: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IGetFrame.VTable, self.vtable).SetFormat(@ptrCast(*const IGetFrame, self), lpbi, lpBits, x, y, dx, dy);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const VIDEOHDR = extern struct {
lpData: ?*u8,
dwBufferLength: u32,
dwBytesUsed: u32,
dwTimeCaptured: u32,
dwUser: usize,
dwFlags: u32,
dwReserved: [4]usize,
};
pub const CHANNEL_CAPS = extern struct {
dwFlags: u32,
dwSrcRectXMod: u32,
dwSrcRectYMod: u32,
dwSrcRectWidthMod: u32,
dwSrcRectHeightMod: u32,
dwDstRectXMod: u32,
dwDstRectYMod: u32,
dwDstRectWidthMod: u32,
dwDstRectHeightMod: u32,
};
pub const CAPDRIVERCAPS = extern struct {
wDeviceIndex: u32,
fHasOverlay: BOOL,
fHasDlgVideoSource: BOOL,
fHasDlgVideoFormat: BOOL,
fHasDlgVideoDisplay: BOOL,
fCaptureInitialized: BOOL,
fDriverSuppliesPalettes: BOOL,
hVideoIn: ?HANDLE,
hVideoOut: ?HANDLE,
hVideoExtIn: ?HANDLE,
hVideoExtOut: ?HANDLE,
};
pub const CAPSTATUS = extern struct {
uiImageWidth: u32,
uiImageHeight: u32,
fLiveWindow: BOOL,
fOverlayWindow: BOOL,
fScale: BOOL,
ptScroll: POINT,
fUsingDefaultPalette: BOOL,
fAudioHardware: BOOL,
fCapFileExists: BOOL,
dwCurrentVideoFrame: u32,
dwCurrentVideoFramesDropped: u32,
dwCurrentWaveSamples: u32,
dwCurrentTimeElapsedMS: u32,
hPalCurrent: ?HPALETTE,
fCapturingNow: BOOL,
dwReturn: u32,
wNumVideoAllocated: u32,
wNumAudioAllocated: u32,
};
pub const CAPTUREPARMS = extern struct {
dwRequestMicroSecPerFrame: u32,
fMakeUserHitOKToCapture: BOOL,
wPercentDropForError: u32,
fYield: BOOL,
dwIndexSize: u32,
wChunkGranularity: u32,
fUsingDOSMemory: BOOL,
wNumVideoRequested: u32,
fCaptureAudio: BOOL,
wNumAudioRequested: u32,
vKeyAbort: u32,
fAbortLeftMouse: BOOL,
fAbortRightMouse: BOOL,
fLimitEnabled: BOOL,
wTimeLimit: u32,
fMCIControl: BOOL,
fStepMCIDevice: BOOL,
dwMCIStartTime: u32,
dwMCIStopTime: u32,
fStepCaptureAt2x: BOOL,
wStepCaptureAverageFrames: u32,
dwAudioBufferSize: u32,
fDisableWriteCache: BOOL,
AVStreamMaster: u32,
};
pub const CAPINFOCHUNK = extern struct {
fccInfoID: u32,
lpData: ?*c_void,
cbData: i32,
};
pub const CAPYIELDCALLBACK = fn(
hWnd: ?HWND,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const CAPSTATUSCALLBACKW = fn(
hWnd: ?HWND,
nID: i32,
lpsz: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const CAPERRORCALLBACKW = fn(
hWnd: ?HWND,
nID: i32,
lpsz: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const CAPSTATUSCALLBACKA = fn(
hWnd: ?HWND,
nID: i32,
lpsz: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const CAPERRORCALLBACKA = fn(
hWnd: ?HWND,
nID: i32,
lpsz: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const CAPVIDEOCALLBACK = fn(
hWnd: ?HWND,
lpVHdr: ?*VIDEOHDR,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const CAPWAVECALLBACK = fn(
hWnd: ?HWND,
lpWHdr: ?*WAVEHDR,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const CAPCONTROLCALLBACK = fn(
hWnd: ?HWND,
nState: i32,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const DRVM_IOCTL_DATA = packed struct {
dwSize: u32,
dwCmd: u32,
};
pub const WAVEOPENDESC = packed struct {
hWave: ?HWAVE,
lpFormat: ?*WAVEFORMAT,
dwCallback: usize,
dwInstance: usize,
uMappedDeviceID: u32,
dnDevNode: usize,
};
pub const MIDIOPENSTRMID = packed struct {
dwStreamID: u32,
uDeviceID: u32,
};
pub const MIXEROPENDESC = packed struct {
hmx: ?HMIXER,
pReserved0: ?*c_void,
dwCallback: usize,
dwInstance: usize,
dnDevNode: usize,
};
pub const TIMEREVENT = packed struct {
wDelay: u16,
wResolution: u16,
lpFunction: ?LPTIMECALLBACK,
dwUser: u32,
wFlags: u16,
wReserved1: u16,
};
pub const JOYPOS = packed struct {
dwX: u32,
dwY: u32,
dwZ: u32,
dwR: u32,
dwU: u32,
dwV: u32,
};
pub const JOYRANGE = extern struct {
jpMin: JOYPOS,
jpMax: JOYPOS,
jpCenter: JOYPOS,
};
pub const JOYREGUSERVALUES = packed struct {
dwTimeOut: u32,
jrvRanges: JOYRANGE,
jpDeadZone: JOYPOS,
};
pub const JOYREGHWSETTINGS = packed struct {
dwFlags: u32,
dwNumButtons: u32,
};
pub const JOYREGHWCONFIG = packed struct {
hws: JOYREGHWSETTINGS,
dwUsageSettings: u32,
hwv: JOYREGHWVALUES,
dwType: u32,
dwReserved: u32,
};
pub const JOYCALIBRATE = packed struct {
wXbase: u16,
wXdelta: u16,
wYbase: u16,
wYdelta: u16,
wZbase: u16,
wZdelta: u16,
};
pub const LPJOYDEVMSGPROC = fn(
param0: u32,
param1: u32,
param2: i32,
param3: i32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const MCI_OPEN_DRIVER_PARMS = packed struct {
wDeviceID: u32,
lpstrParams: ?[*:0]const u16,
wCustomCommandTable: u32,
wType: u32,
};
pub const LPTASKCALLBACK = fn(
dwInst: usize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const ACMSTREAMHEADER = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => packed struct {
cbStruct: u32,
fdwStatus: u32,
dwUser: usize,
pbSrc: ?*u8,
cbSrcLength: u32,
cbSrcLengthUsed: u32,
dwSrcUser: usize,
pbDst: ?*u8,
cbDstLength: u32,
cbDstLengthUsed: u32,
dwDstUser: usize,
dwReservedDriver: [15]u32,
},
.X86 => packed struct {
cbStruct: u32,
fdwStatus: u32,
dwUser: usize,
pbSrc: ?*u8,
cbSrcLength: u32,
cbSrcLengthUsed: u32,
dwSrcUser: usize,
pbDst: ?*u8,
cbDstLength: u32,
cbDstLengthUsed: u32,
dwDstUser: usize,
dwReservedDriver: [10]u32,
},
};
//--------------------------------------------------------------------------------
// Section: Functions (304)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn CloseDriver(
hDriver: ?HDRVR,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn OpenDriver(
szDriverName: ?[*:0]const u16,
szSectionName: ?[*:0]const u16,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) ?HDRVR;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn SendDriverMessage(
hDriver: ?HDRVR,
message: u32,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn DrvGetModuleHandle(
hDriver: ?HDRVR,
) callconv(@import("std").os.windows.WINAPI) ?HINSTANCE;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn GetDriverModuleHandle(
hDriver: ?HDRVR,
) callconv(@import("std").os.windows.WINAPI) ?HINSTANCE;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn DefDriverProc(
dwDriverIdentifier: usize,
hdrvr: ?HDRVR,
uMsg: u32,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn DriverCallback(
dwCallback: usize,
dwFlags: u32,
hDevice: ?HDRVR,
dwMsg: u32,
dwUser: usize,
dwParam1: usize,
dwParam2: usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "api-ms-win-mm-misc-l1-1-1" fn sndOpenSound(
EventName: ?[*:0]const u16,
AppName: ?[*:0]const u16,
Flags: i32,
FileHandle: ?*?HANDLE,
) callconv(@import("std").os.windows.WINAPI) i32;
pub extern "WINMM" fn mmDrvInstall(
hDriver: ?HDRVR,
wszDrvEntry: ?[*:0]const u16,
drvMessage: ?DRIVERMSGPROC,
wFlags: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioStringToFOURCCA(
sz: ?[*:0]const u8,
uFlags: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioStringToFOURCCW(
sz: ?[*:0]const u16,
uFlags: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioInstallIOProcA(
fccIOProc: u32,
pIOProc: ?LPMMIOPROC,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) ?LPMMIOPROC;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioInstallIOProcW(
fccIOProc: u32,
pIOProc: ?LPMMIOPROC,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) ?LPMMIOPROC;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioOpenA(
pszFileName: ?*[128]u8,
pmmioinfo: ?*MMIOINFO,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) ?HMMIO;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioOpenW(
pszFileName: ?*[128]u16,
pmmioinfo: ?*MMIOINFO,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) ?HMMIO;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioRenameA(
pszFileName: ?[*:0]const u8,
pszNewFileName: ?[*:0]const u8,
pmmioinfo: ?*MMIOINFO,
fdwRename: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioRenameW(
pszFileName: ?[*:0]const u16,
pszNewFileName: ?[*:0]const u16,
pmmioinfo: ?*MMIOINFO,
fdwRename: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioClose(
hmmio: ?HMMIO,
fuClose: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioRead(
hmmio: ?HMMIO,
// TODO: what to do with BytesParamIndex 2?
pch: ?*i8,
cch: i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioWrite(
hmmio: ?HMMIO,
// TODO: what to do with BytesParamIndex 2?
pch: ?[*:0]const u8,
cch: i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioSeek(
hmmio: ?HMMIO,
lOffset: i32,
iOrigin: i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioGetInfo(
hmmio: ?HMMIO,
pmmioinfo: ?*MMIOINFO,
fuInfo: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioSetInfo(
hmmio: ?HMMIO,
pmmioinfo: ?*MMIOINFO,
fuInfo: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioSetBuffer(
hmmio: ?HMMIO,
pchBuffer: ?[*:0]u8,
cchBuffer: i32,
fuBuffer: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioFlush(
hmmio: ?HMMIO,
fuFlush: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioAdvance(
hmmio: ?HMMIO,
pmmioinfo: ?*MMIOINFO,
fuAdvance: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioSendMessage(
hmmio: ?HMMIO,
uMsg: u32,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioDescend(
hmmio: ?HMMIO,
pmmcki: ?*MMCKINFO,
pmmckiParent: ?*const MMCKINFO,
fuDescend: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioAscend(
hmmio: ?HMMIO,
pmmcki: ?*MMCKINFO,
fuAscend: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mmioCreateChunk(
hmmio: ?HMMIO,
pmmcki: ?*MMCKINFO,
fuCreate: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn sndPlaySoundA(
pszSound: ?[*:0]const u8,
fuSound: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINMM" fn sndPlaySoundW(
pszSound: ?[*:0]const u16,
fuSound: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINMM" fn PlaySoundA(
pszSound: ?[*:0]const u8,
hmod: ?HINSTANCE,
fdwSound: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINMM" fn PlaySoundW(
pszSound: ?[*:0]const u16,
hmod: ?HINSTANCE,
fdwSound: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveOutGetDevCapsA(
uDeviceID: usize,
pwoc: ?*WAVEOUTCAPSA,
cbwoc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveOutGetDevCapsW(
uDeviceID: usize,
pwoc: ?*WAVEOUTCAPSW,
cbwoc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetVolume(
hwo: ?HWAVEOUT,
pdwVolume: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutSetVolume(
hwo: ?HWAVEOUT,
dwVolume: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveOutGetErrorTextA(
mmrError: u32,
pszText: [*:0]u8,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveOutGetErrorTextW(
mmrError: u32,
pszText: [*:0]u16,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutOpen(
phwo: ?*?HWAVEOUT,
uDeviceID: u32,
pwfx: ?*WAVEFORMATEX,
dwCallback: usize,
dwInstance: usize,
fdwOpen: MIDI_WAVE_OPEN_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutClose(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutPrepareHeader(
hwo: ?HWAVEOUT,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutUnprepareHeader(
hwo: ?HWAVEOUT,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutWrite(
hwo: ?HWAVEOUT,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutPause(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutRestart(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutReset(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutBreakLoop(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetPosition(
hwo: ?HWAVEOUT,
// TODO: what to do with BytesParamIndex 2?
pmmt: ?*MMTIME,
cbmmt: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetPitch(
hwo: ?HWAVEOUT,
pdwPitch: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutSetPitch(
hwo: ?HWAVEOUT,
dwPitch: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetPlaybackRate(
hwo: ?HWAVEOUT,
pdwRate: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutSetPlaybackRate(
hwo: ?HWAVEOUT,
dwRate: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetID(
hwo: ?HWAVEOUT,
puDeviceID: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutMessage(
hwo: ?HWAVEOUT,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveInGetDevCapsA(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pwic: ?*WAVEINCAPSA,
cbwic: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveInGetDevCapsW(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pwic: ?*WAVEINCAPSW,
cbwic: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveInGetErrorTextA(
mmrError: u32,
pszText: [*:0]u8,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveInGetErrorTextW(
mmrError: u32,
pszText: [*:0]u16,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInOpen(
phwi: ?*?HWAVEIN,
uDeviceID: u32,
pwfx: ?*WAVEFORMATEX,
dwCallback: usize,
dwInstance: usize,
fdwOpen: MIDI_WAVE_OPEN_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInClose(
hwi: ?HWAVEIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInPrepareHeader(
hwi: ?HWAVEIN,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInUnprepareHeader(
hwi: ?HWAVEIN,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInAddBuffer(
hwi: ?HWAVEIN,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInStart(
hwi: ?HWAVEIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInStop(
hwi: ?HWAVEIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInReset(
hwi: ?HWAVEIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInGetPosition(
hwi: ?HWAVEIN,
// TODO: what to do with BytesParamIndex 2?
pmmt: ?*MMTIME,
cbmmt: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInGetID(
hwi: ?HWAVEIN,
puDeviceID: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInMessage(
hwi: ?HWAVEIN,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamOpen(
phms: ?*?HMIDISTRM,
puDeviceID: [*]u32,
cMidi: u32,
dwCallback: usize,
dwInstance: usize,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamClose(
hms: ?HMIDISTRM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamProperty(
hms: ?HMIDISTRM,
lppropdata: ?*u8,
dwProperty: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamPosition(
hms: ?HMIDISTRM,
// TODO: what to do with BytesParamIndex 2?
lpmmt: ?*MMTIME,
cbmmt: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamOut(
hms: ?HMIDISTRM,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamPause(
hms: ?HMIDISTRM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamRestart(
hms: ?HMIDISTRM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamStop(
hms: ?HMIDISTRM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiConnect(
hmi: ?HMIDI,
hmo: ?HMIDIOUT,
pReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiDisconnect(
hmi: ?HMIDI,
hmo: ?HMIDIOUT,
pReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetDevCapsA(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pmoc: ?*MIDIOUTCAPSA,
cbmoc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetDevCapsW(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pmoc: ?*MIDIOUTCAPSW,
cbmoc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetVolume(
hmo: ?HMIDIOUT,
pdwVolume: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutSetVolume(
hmo: ?HMIDIOUT,
dwVolume: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetErrorTextA(
mmrError: u32,
pszText: [*:0]u8,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetErrorTextW(
mmrError: u32,
pszText: [*:0]u16,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutOpen(
phmo: ?*?HMIDIOUT,
uDeviceID: u32,
dwCallback: usize,
dwInstance: usize,
fdwOpen: MIDI_WAVE_OPEN_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutClose(
hmo: ?HMIDIOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutPrepareHeader(
hmo: ?HMIDIOUT,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutUnprepareHeader(
hmo: ?HMIDIOUT,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutShortMsg(
hmo: ?HMIDIOUT,
dwMsg: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutLongMsg(
hmo: ?HMIDIOUT,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutReset(
hmo: ?HMIDIOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutCachePatches(
hmo: ?HMIDIOUT,
uBank: u32,
pwpa: *[128]u16,
fuCache: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutCacheDrumPatches(
hmo: ?HMIDIOUT,
uPatch: u32,
pwkya: *[128]u16,
fuCache: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetID(
hmo: ?HMIDIOUT,
puDeviceID: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutMessage(
hmo: ?HMIDIOUT,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetDevCapsA(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pmic: ?*MIDIINCAPSA,
cbmic: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetDevCapsW(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pmic: ?*MIDIINCAPSW,
cbmic: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetErrorTextA(
mmrError: u32,
pszText: [*:0]u8,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetErrorTextW(
mmrError: u32,
pszText: [*:0]u16,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInOpen(
phmi: ?*?HMIDIIN,
uDeviceID: u32,
dwCallback: usize,
dwInstance: usize,
fdwOpen: MIDI_WAVE_OPEN_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInClose(
hmi: ?HMIDIIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInPrepareHeader(
hmi: ?HMIDIIN,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInUnprepareHeader(
hmi: ?HMIDIIN,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInAddBuffer(
hmi: ?HMIDIIN,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInStart(
hmi: ?HMIDIIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInStop(
hmi: ?HMIDIIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInReset(
hmi: ?HMIDIIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetID(
hmi: ?HMIDIIN,
puDeviceID: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInMessage(
hmi: ?HMIDIIN,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxGetDevCapsA(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pac: ?*AUXCAPSA,
cbac: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxGetDevCapsW(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pac: ?*AUXCAPSW,
cbac: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxSetVolume(
uDeviceID: u32,
dwVolume: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxGetVolume(
uDeviceID: u32,
pdwVolume: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxOutMessage(
uDeviceID: u32,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetDevCapsA(
uMxId: usize,
// TODO: what to do with BytesParamIndex 2?
pmxcaps: ?*MIXERCAPSA,
cbmxcaps: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetDevCapsW(
uMxId: usize,
// TODO: what to do with BytesParamIndex 2?
pmxcaps: ?*MIXERCAPSW,
cbmxcaps: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerOpen(
phmx: ?*isize,
uMxId: u32,
dwCallback: usize,
dwInstance: usize,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerClose(
hmx: ?HMIXER,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerMessage(
hmx: ?HMIXER,
uMsg: u32,
dwParam1: usize,
dwParam2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetLineInfoA(
hmxobj: ?HMIXEROBJ,
pmxl: ?*MIXERLINEA,
fdwInfo: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetLineInfoW(
hmxobj: ?HMIXEROBJ,
pmxl: ?*MIXERLINEW,
fdwInfo: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetID(
hmxobj: ?HMIXEROBJ,
puMxId: ?*u32,
fdwId: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetLineControlsA(
hmxobj: ?HMIXEROBJ,
pmxlc: ?*MIXERLINECONTROLSA,
fdwControls: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetLineControlsW(
hmxobj: ?HMIXEROBJ,
pmxlc: ?*MIXERLINECONTROLSW,
fdwControls: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetControlDetailsA(
hmxobj: ?HMIXEROBJ,
pmxcd: ?*MIXERCONTROLDETAILS,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetControlDetailsW(
hmxobj: ?HMIXEROBJ,
pmxcd: ?*MIXERCONTROLDETAILS,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerSetControlDetails(
hmxobj: ?HMIXEROBJ,
pmxcd: ?*MIXERCONTROLDETAILS,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn timeGetSystemTime(
// TODO: what to do with BytesParamIndex 1?
pmmt: ?*MMTIME,
cbmmt: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn timeGetTime(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn timeGetDevCaps(
// TODO: what to do with BytesParamIndex 1?
ptc: ?*TIMECAPS,
cbtc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn timeBeginPeriod(
uPeriod: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn timeEndPeriod(
uPeriod: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn joyGetPosEx(
uJoyID: u32,
pji: ?*JOYINFOEX,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn joyGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn joyGetDevCapsA(
uJoyID: usize,
// TODO: what to do with BytesParamIndex 2?
pjc: ?*JOYCAPSA,
cbjc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn joyGetDevCapsW(
uJoyID: usize,
// TODO: what to do with BytesParamIndex 2?
pjc: ?*JOYCAPSW,
cbjc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn joyGetPos(
uJoyID: u32,
pji: ?*JOYINFO,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn joyGetThreshold(
uJoyID: u32,
puThreshold: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn joyReleaseCapture(
uJoyID: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn joySetCapture(
hwnd: ?HWND,
uJoyID: u32,
uPeriod: u32,
fChanged: BOOL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn joySetThreshold(
uJoyID: u32,
uThreshold: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmGetVersion(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmMetrics(
hao: ?HACMOBJ,
uMetric: u32,
pMetric: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverEnum(
fnCallback: ?ACMDRIVERENUMCB,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverID(
hao: ?HACMOBJ,
phadid: ?*isize,
fdwDriverID: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverAddA(
phadid: ?*isize,
hinstModule: ?HINSTANCE,
lParam: LPARAM,
dwPriority: u32,
fdwAdd: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverAddW(
phadid: ?*isize,
hinstModule: ?HINSTANCE,
lParam: LPARAM,
dwPriority: u32,
fdwAdd: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverRemove(
hadid: ?HACMDRIVERID,
fdwRemove: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverOpen(
phad: ?*isize,
hadid: ?HACMDRIVERID,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverClose(
had: ?HACMDRIVER,
fdwClose: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverMessage(
had: ?HACMDRIVER,
uMsg: u32,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverPriority(
hadid: ?HACMDRIVERID,
dwPriority: u32,
fdwPriority: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverDetailsA(
hadid: ?HACMDRIVERID,
padd: ?*ACMDRIVERDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverDetailsW(
hadid: ?HACMDRIVERID,
padd: ?*ACMDRIVERDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatTagDetailsA(
had: ?HACMDRIVER,
paftd: ?*ACMFORMATTAGDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatTagDetailsW(
had: ?HACMDRIVER,
paftd: ?*ACMFORMATTAGDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatTagEnumA(
had: ?HACMDRIVER,
paftd: ?*ACMFORMATTAGDETAILSA,
fnCallback: ?ACMFORMATTAGENUMCBA,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatTagEnumW(
had: ?HACMDRIVER,
paftd: ?*ACMFORMATTAGDETAILSW,
fnCallback: ?ACMFORMATTAGENUMCBW,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatDetailsA(
had: ?HACMDRIVER,
pafd: ?*ACMFORMATDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatDetailsW(
had: ?HACMDRIVER,
pafd: ?*tACMFORMATDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatEnumA(
had: ?HACMDRIVER,
pafd: ?*ACMFORMATDETAILSA,
fnCallback: ?ACMFORMATENUMCBA,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatEnumW(
had: ?HACMDRIVER,
pafd: ?*tACMFORMATDETAILSW,
fnCallback: ?ACMFORMATENUMCBW,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatSuggest(
had: ?HACMDRIVER,
pwfxSrc: ?*WAVEFORMATEX,
pwfxDst: ?*WAVEFORMATEX,
cbwfxDst: u32,
fdwSuggest: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatChooseA(
pafmtc: ?*ACMFORMATCHOOSEA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatChooseW(
pafmtc: ?*ACMFORMATCHOOSEW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterTagDetailsA(
had: ?HACMDRIVER,
paftd: ?*ACMFILTERTAGDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterTagDetailsW(
had: ?HACMDRIVER,
paftd: ?*ACMFILTERTAGDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterTagEnumA(
had: ?HACMDRIVER,
paftd: ?*ACMFILTERTAGDETAILSA,
fnCallback: ?ACMFILTERTAGENUMCBA,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterTagEnumW(
had: ?HACMDRIVER,
paftd: ?*ACMFILTERTAGDETAILSW,
fnCallback: ?ACMFILTERTAGENUMCBW,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterDetailsA(
had: ?HACMDRIVER,
pafd: ?*ACMFILTERDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterDetailsW(
had: ?HACMDRIVER,
pafd: ?*ACMFILTERDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterEnumA(
had: ?HACMDRIVER,
pafd: ?*ACMFILTERDETAILSA,
fnCallback: ?ACMFILTERENUMCBA,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterEnumW(
had: ?HACMDRIVER,
pafd: ?*ACMFILTERDETAILSW,
fnCallback: ?ACMFILTERENUMCBW,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterChooseA(
pafltrc: ?*ACMFILTERCHOOSEA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterChooseW(
pafltrc: ?*ACMFILTERCHOOSEW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamOpen(
phas: ?*isize,
had: ?HACMDRIVER,
pwfxSrc: ?*WAVEFORMATEX,
pwfxDst: ?*WAVEFORMATEX,
pwfltr: ?*WAVEFILTER,
dwCallback: usize,
dwInstance: usize,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamClose(
has: ?HACMSTREAM,
fdwClose: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamSize(
has: ?HACMSTREAM,
cbInput: u32,
pdwOutputBytes: ?*u32,
fdwSize: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamReset(
has: ?HACMSTREAM,
fdwReset: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamMessage(
has: ?HACMSTREAM,
uMsg: u32,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamConvert(
has: ?HACMSTREAM,
pash: ?*ACMSTREAMHEADER,
fdwConvert: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamPrepareHeader(
has: ?HACMSTREAM,
pash: ?*ACMSTREAMHEADER,
fdwPrepare: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamUnprepareHeader(
has: ?HACMSTREAM,
pash: ?*ACMSTREAMHEADER,
fdwUnprepare: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "MSVFW32" fn VideoForWindowsVersion(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICInfo(
fccType: u32,
fccHandler: u32,
lpicinfo: ?*ICINFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICInstall(
fccType: u32,
fccHandler: u32,
lParam: LPARAM,
szDesc: ?PSTR,
wFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICRemove(
fccType: u32,
fccHandler: u32,
wFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICGetInfo(
hic: ?HIC,
// TODO: what to do with BytesParamIndex 2?
picinfo: ?*ICINFO,
cb: u32,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICOpen(
fccType: u32,
fccHandler: u32,
wMode: u32,
) callconv(@import("std").os.windows.WINAPI) ?HIC;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICOpenFunction(
fccType: u32,
fccHandler: u32,
wMode: u32,
lpfnHandler: ?FARPROC,
) callconv(@import("std").os.windows.WINAPI) ?HIC;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICClose(
hic: ?HIC,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICSendMessage(
hic: ?HIC,
msg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICCompress(
hic: ?HIC,
dwFlags: u32,
lpbiOutput: ?*BITMAPINFOHEADER,
lpData: ?*c_void,
lpbiInput: ?*BITMAPINFOHEADER,
lpBits: ?*c_void,
lpckid: ?*u32,
lpdwFlags: ?*u32,
lFrameNum: i32,
dwFrameSize: u32,
dwQuality: u32,
lpbiPrev: ?*BITMAPINFOHEADER,
lpPrev: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICDecompress(
hic: ?HIC,
dwFlags: u32,
lpbiFormat: ?*BITMAPINFOHEADER,
lpData: ?*c_void,
lpbi: ?*BITMAPINFOHEADER,
lpBits: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICDrawBegin(
hic: ?HIC,
dwFlags: u32,
hpal: ?HPALETTE,
hwnd: ?HWND,
hdc: ?HDC,
xDst: i32,
yDst: i32,
dxDst: i32,
dyDst: i32,
lpbi: ?*BITMAPINFOHEADER,
xSrc: i32,
ySrc: i32,
dxSrc: i32,
dySrc: i32,
dwRate: u32,
dwScale: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICDraw(
hic: ?HIC,
dwFlags: u32,
lpFormat: ?*c_void,
// TODO: what to do with BytesParamIndex 4?
lpData: ?*c_void,
cbData: u32,
lTime: i32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICLocate(
fccType: u32,
fccHandler: u32,
lpbiIn: ?*BITMAPINFOHEADER,
lpbiOut: ?*BITMAPINFOHEADER,
wFlags: u16,
) callconv(@import("std").os.windows.WINAPI) ?HIC;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICGetDisplayFormat(
hic: ?HIC,
lpbiIn: ?*BITMAPINFOHEADER,
lpbiOut: ?*BITMAPINFOHEADER,
BitDepth: i32,
dx: i32,
dy: i32,
) callconv(@import("std").os.windows.WINAPI) ?HIC;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICImageCompress(
hic: ?HIC,
uiFlags: u32,
lpbiIn: ?*BITMAPINFO,
lpBits: ?*c_void,
lpbiOut: ?*BITMAPINFO,
lQuality: i32,
plSize: ?*i32,
) callconv(@import("std").os.windows.WINAPI) ?HANDLE;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICImageDecompress(
hic: ?HIC,
uiFlags: u32,
lpbiIn: ?*BITMAPINFO,
lpBits: ?*c_void,
lpbiOut: ?*BITMAPINFO,
) callconv(@import("std").os.windows.WINAPI) ?HANDLE;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICCompressorChoose(
hwnd: ?HWND,
uiFlags: u32,
pvIn: ?*c_void,
lpData: ?*c_void,
pc: ?*COMPVARS,
lpszTitle: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICSeqCompressFrameStart(
pc: ?*COMPVARS,
lpbiIn: ?*BITMAPINFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICSeqCompressFrameEnd(
pc: ?*COMPVARS,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICSeqCompressFrame(
pc: ?*COMPVARS,
uiFlags: u32,
lpBits: ?*c_void,
pfKey: ?*BOOL,
plSize: ?*i32,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn ICCompressorFree(
pc: ?*COMPVARS,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibOpen(
) callconv(@import("std").os.windows.WINAPI) isize;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibClose(
hdd: isize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibGetBuffer(
hdd: isize,
lpbi: ?*BITMAPINFOHEADER,
dwSize: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibGetPalette(
hdd: isize,
) callconv(@import("std").os.windows.WINAPI) ?HPALETTE;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibSetPalette(
hdd: isize,
hpal: ?HPALETTE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibChangePalette(
hdd: isize,
iStart: i32,
iLen: i32,
lppe: [*]PALETTEENTRY,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibRealize(
hdd: isize,
hdc: ?HDC,
fBackground: BOOL,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibStart(
hdd: isize,
rate: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibStop(
hdd: isize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibBegin(
hdd: isize,
hdc: ?HDC,
dxDst: i32,
dyDst: i32,
lpbi: ?*BITMAPINFOHEADER,
dxSrc: i32,
dySrc: i32,
wFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibDraw(
hdd: isize,
hdc: ?HDC,
xDst: i32,
yDst: i32,
dxDst: i32,
dyDst: i32,
lpbi: ?*BITMAPINFOHEADER,
lpBits: ?*c_void,
xSrc: i32,
ySrc: i32,
dxSrc: i32,
dySrc: i32,
wFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibEnd(
hdd: isize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibTime(
hdd: isize,
lpddtime: ?*DRAWDIBTIME,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn DrawDibProfileDisplay(
lpbi: ?*BITMAPINFOHEADER,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileInit(
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileExit(
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileAddRef(
pfile: ?*IAVIFile,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileRelease(
pfile: ?*IAVIFile,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileOpenA(
ppfile: ?*?*IAVIFile,
szFile: ?[*:0]const u8,
uMode: u32,
lpHandler: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileOpenW(
ppfile: ?*?*IAVIFile,
szFile: ?[*:0]const u16,
uMode: u32,
lpHandler: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileInfoW(
pfile: ?*IAVIFile,
// TODO: what to do with BytesParamIndex 2?
pfi: ?*AVIFILEINFOW,
lSize: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileInfoA(
pfile: ?*IAVIFile,
// TODO: what to do with BytesParamIndex 2?
pfi: ?*AVIFILEINFOA,
lSize: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileGetStream(
pfile: ?*IAVIFile,
ppavi: ?*?*IAVIStream,
fccType: u32,
lParam: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileCreateStreamW(
pfile: ?*IAVIFile,
ppavi: ?*?*IAVIStream,
psi: ?*AVISTREAMINFOW,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileCreateStreamA(
pfile: ?*IAVIFile,
ppavi: ?*?*IAVIStream,
psi: ?*AVISTREAMINFOA,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileWriteData(
pfile: ?*IAVIFile,
ckid: u32,
// TODO: what to do with BytesParamIndex 3?
lpData: ?*c_void,
cbData: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileReadData(
pfile: ?*IAVIFile,
ckid: u32,
// TODO: what to do with BytesParamIndex 3?
lpData: ?*c_void,
lpcbData: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIFileEndRecord(
pfile: ?*IAVIFile,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamAddRef(
pavi: ?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamRelease(
pavi: ?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamInfoW(
pavi: ?*IAVIStream,
// TODO: what to do with BytesParamIndex 2?
psi: ?*AVISTREAMINFOW,
lSize: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamInfoA(
pavi: ?*IAVIStream,
// TODO: what to do with BytesParamIndex 2?
psi: ?*AVISTREAMINFOA,
lSize: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamFindSample(
pavi: ?*IAVIStream,
lPos: i32,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamReadFormat(
pavi: ?*IAVIStream,
lPos: i32,
// TODO: what to do with BytesParamIndex 3?
lpFormat: ?*c_void,
lpcbFormat: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamSetFormat(
pavi: ?*IAVIStream,
lPos: i32,
// TODO: what to do with BytesParamIndex 3?
lpFormat: ?*c_void,
cbFormat: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamReadData(
pavi: ?*IAVIStream,
fcc: u32,
// TODO: what to do with BytesParamIndex 3?
lp: ?*c_void,
lpcb: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamWriteData(
pavi: ?*IAVIStream,
fcc: u32,
// TODO: what to do with BytesParamIndex 3?
lp: ?*c_void,
cb: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamRead(
pavi: ?*IAVIStream,
lStart: i32,
lSamples: i32,
// TODO: what to do with BytesParamIndex 4?
lpBuffer: ?*c_void,
cbBuffer: i32,
plBytes: ?*i32,
plSamples: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamWrite(
pavi: ?*IAVIStream,
lStart: i32,
lSamples: i32,
// TODO: what to do with BytesParamIndex 4?
lpBuffer: ?*c_void,
cbBuffer: i32,
dwFlags: u32,
plSampWritten: ?*i32,
plBytesWritten: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamStart(
pavi: ?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamLength(
pavi: ?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamTimeToSample(
pavi: ?*IAVIStream,
lTime: i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamSampleToTime(
pavi: ?*IAVIStream,
lSample: i32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamBeginStreaming(
pavi: ?*IAVIStream,
lStart: i32,
lEnd: i32,
lRate: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamEndStreaming(
pavi: ?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamGetFrameOpen(
pavi: ?*IAVIStream,
lpbiWanted: ?*BITMAPINFOHEADER,
) callconv(@import("std").os.windows.WINAPI) ?*IGetFrame;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamGetFrame(
pg: ?*IGetFrame,
lPos: i32,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamGetFrameClose(
pg: ?*IGetFrame,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamOpenFromFileA(
ppavi: ?*?*IAVIStream,
szFile: ?[*:0]const u8,
fccType: u32,
lParam: i32,
mode: u32,
pclsidHandler: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamOpenFromFileW(
ppavi: ?*?*IAVIStream,
szFile: ?[*:0]const u16,
fccType: u32,
lParam: i32,
mode: u32,
pclsidHandler: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIStreamCreate(
ppavi: ?*?*IAVIStream,
lParam1: i32,
lParam2: i32,
pclsidHandler: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIMakeCompressedStream(
ppsCompressed: ?*?*IAVIStream,
ppsSource: ?*IAVIStream,
lpOptions: ?*AVICOMPRESSOPTIONS,
pclsidHandler: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVISaveA(
szFile: ?[*:0]const u8,
pclsidHandler: ?*Guid,
lpfnCallback: ?AVISAVECALLBACK,
nStreams: i32,
pfile: ?*IAVIStream,
lpOptions: ?*AVICOMPRESSOPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVISaveVA(
szFile: ?[*:0]const u8,
pclsidHandler: ?*Guid,
lpfnCallback: ?AVISAVECALLBACK,
nStreams: i32,
ppavi: [*]?*IAVIStream,
plpOptions: [*]?*AVICOMPRESSOPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVISaveW(
szFile: ?[*:0]const u16,
pclsidHandler: ?*Guid,
lpfnCallback: ?AVISAVECALLBACK,
nStreams: i32,
pfile: ?*IAVIStream,
lpOptions: ?*AVICOMPRESSOPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVISaveVW(
szFile: ?[*:0]const u16,
pclsidHandler: ?*Guid,
lpfnCallback: ?AVISAVECALLBACK,
nStreams: i32,
ppavi: [*]?*IAVIStream,
plpOptions: [*]?*AVICOMPRESSOPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVISaveOptions(
hwnd: ?HWND,
uiFlags: u32,
nStreams: i32,
ppavi: [*]?*IAVIStream,
plpOptions: [*]?*AVICOMPRESSOPTIONS,
) callconv(@import("std").os.windows.WINAPI) isize;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVISaveOptionsFree(
nStreams: i32,
plpOptions: [*]?*AVICOMPRESSOPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIBuildFilterW(
lpszFilter: [*:0]u16,
cbFilter: i32,
fSaving: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIBuildFilterA(
lpszFilter: [*:0]u8,
cbFilter: i32,
fSaving: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIMakeFileFromStreams(
ppfile: ?*?*IAVIFile,
nStreams: i32,
papStreams: [*]?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIMakeStreamFromClipboard(
cfFormat: u32,
hGlobal: ?HANDLE,
ppstream: ?*?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIPutFileOnClipboard(
pf: ?*IAVIFile,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIGetFromClipboard(
lppf: ?*?*IAVIFile,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn AVIClearClipboard(
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn CreateEditableStream(
ppsEditable: ?*?*IAVIStream,
psSource: ?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn EditStreamCut(
pavi: ?*IAVIStream,
plStart: ?*i32,
plLength: ?*i32,
ppResult: ?*?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn EditStreamCopy(
pavi: ?*IAVIStream,
plStart: ?*i32,
plLength: ?*i32,
ppResult: ?*?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn EditStreamPaste(
pavi: ?*IAVIStream,
plPos: ?*i32,
plLength: ?*i32,
pstream: ?*IAVIStream,
lStart: i32,
lEnd: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn EditStreamClone(
pavi: ?*IAVIStream,
ppResult: ?*?*IAVIStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn EditStreamSetNameA(
pavi: ?*IAVIStream,
lpszName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn EditStreamSetNameW(
pavi: ?*IAVIStream,
lpszName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn EditStreamSetInfoW(
pavi: ?*IAVIStream,
// TODO: what to do with BytesParamIndex 2?
lpInfo: ?*AVISTREAMINFOW,
cbInfo: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVIFIL32" fn EditStreamSetInfoA(
pavi: ?*IAVIStream,
// TODO: what to do with BytesParamIndex 2?
lpInfo: ?*AVISTREAMINFOA,
cbInfo: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn MCIWndCreateA(
hwndParent: ?HWND,
hInstance: ?HINSTANCE,
dwStyle: u32,
szFile: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn MCIWndCreateW(
hwndParent: ?HWND,
hInstance: ?HINSTANCE,
dwStyle: u32,
szFile: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn MCIWndRegisterClass(
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVICAP32" fn capCreateCaptureWindowA(
lpszWindowName: ?[*:0]const u8,
dwStyle: u32,
x: i32,
y: i32,
nWidth: i32,
nHeight: i32,
hwndParent: ?HWND,
nID: i32,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVICAP32" fn capGetDriverDescriptionA(
wDriverIndex: u32,
lpszName: [*:0]u8,
cbName: i32,
lpszVer: [*:0]u8,
cbVer: i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVICAP32" fn capCreateCaptureWindowW(
lpszWindowName: ?[*:0]const u16,
dwStyle: u32,
x: i32,
y: i32,
nWidth: i32,
nHeight: i32,
hwndParent: ?HWND,
nID: i32,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
// TODO: this type is limited to platform 'windows5.0'
pub extern "AVICAP32" fn capGetDriverDescriptionW(
wDriverIndex: u32,
lpszName: [*:0]u16,
cbName: i32,
lpszVer: [*:0]u16,
cbVer: i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn GetOpenFileNamePreviewA(
lpofn: ?*OPENFILENAMEA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn GetSaveFileNamePreviewA(
lpofn: ?*OPENFILENAMEA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn GetOpenFileNamePreviewW(
lpofn: ?*OPENFILENAMEW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSVFW32" fn GetSaveFileNamePreviewW(
lpofn: ?*OPENFILENAMEW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINMM" fn mmTaskCreate(
lpfn: ?LPTASKCALLBACK,
lph: ?*?HANDLE,
dwInst: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn mmTaskBlock(
h: u32,
) callconv(@import("std").os.windows.WINAPI) void;
pub extern "WINMM" fn mmTaskSignal(
h: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINMM" fn mmTaskYield(
) callconv(@import("std").os.windows.WINAPI) void;
pub extern "WINMM" fn mmGetCurrentTask(
) callconv(@import("std").os.windows.WINAPI) u32;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (93)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
pub const WAVEOUTCAPS = thismodule.WAVEOUTCAPSA;
pub const WAVEOUTCAPS2 = thismodule.WAVEOUTCAPS2A;
pub const WAVEINCAPS = thismodule.WAVEINCAPSA;
pub const WAVEINCAPS2 = thismodule.WAVEINCAPS2A;
pub const MIDIOUTCAPS = thismodule.MIDIOUTCAPSA;
pub const MIDIOUTCAPS2 = thismodule.MIDIOUTCAPS2A;
pub const MIDIINCAPS = thismodule.MIDIINCAPSA;
pub const MIDIINCAPS2 = thismodule.MIDIINCAPS2A;
pub const AUXCAPS = thismodule.AUXCAPSA;
pub const AUXCAPS2 = thismodule.AUXCAPS2A;
pub const MIXERCAPS = thismodule.MIXERCAPSA;
pub const MIXERCAPS2 = thismodule.MIXERCAPS2A;
pub const MIXERLINE = thismodule.MIXERLINEA;
pub const MIXERCONTROL = thismodule.MIXERCONTROLA;
pub const MIXERLINECONTROLS = thismodule.MIXERLINECONTROLSA;
pub const MIXERCONTROLDETAILS_LISTTEXT = thismodule.MIXERCONTROLDETAILS_LISTTEXTA;
pub const JOYCAPS = thismodule.JOYCAPSA;
pub const JOYCAPS2 = thismodule.JOYCAPS2A;
pub const MCI_DGV_CAPTURE_PARMS = thismodule.MCI_DGV_CAPTURE_PARMSA;
pub const MCI_DGV_INFO_PARMS = thismodule.MCI_DGV_INFO_PARMSA;
pub const MCI_DGV_LIST_PARMS = thismodule.MCI_DGV_LIST_PARMSA;
pub const MCI_DGV_OPEN_PARMS = thismodule.MCI_DGV_OPEN_PARMSA;
pub const MCI_DGV_QUALITY_PARMS = thismodule.MCI_DGV_QUALITY_PARMSA;
pub const MCI_DGV_RESERVE_PARMS = thismodule.MCI_DGV_RESERVE_PARMSA;
pub const MCI_DGV_RESTORE_PARMS = thismodule.MCI_DGV_RESTORE_PARMSA;
pub const MCI_DGV_SAVE_PARMS = thismodule.MCI_DGV_SAVE_PARMSA;
pub const MCI_DGV_SETAUDIO_PARMS = thismodule.MCI_DGV_SETAUDIO_PARMSA;
pub const MCI_DGV_SETVIDEO_PARMS = thismodule.MCI_DGV_SETVIDEO_PARMSA;
pub const MCI_DGV_STATUS_PARMS = thismodule.MCI_DGV_STATUS_PARMSA;
pub const MCI_DGV_WINDOW_PARMS = thismodule.MCI_DGV_WINDOW_PARMSA;
pub const ACMDRIVERDETAILS = thismodule.ACMDRIVERDETAILSA;
pub const ACMFORMATTAGDETAILS = thismodule.ACMFORMATTAGDETAILSA;
pub const ACMFORMATTAGENUMCB = thismodule.ACMFORMATTAGENUMCBA;
pub const ACMFORMATENUMCB = thismodule.ACMFORMATENUMCBA;
pub const ACMFORMATCHOOSEHOOKPROC = thismodule.ACMFORMATCHOOSEHOOKPROCA;
pub const ACMFORMATCHOOSE = thismodule.ACMFORMATCHOOSEA;
pub const ACMFILTERTAGDETAILS = thismodule.ACMFILTERTAGDETAILSA;
pub const ACMFILTERTAGENUMCB = thismodule.ACMFILTERTAGENUMCBA;
pub const ACMFILTERDETAILS = thismodule.ACMFILTERDETAILSA;
pub const ACMFILTERENUMCB = thismodule.ACMFILTERENUMCBA;
pub const ACMFILTERCHOOSEHOOKPROC = thismodule.ACMFILTERCHOOSEHOOKPROCA;
pub const ACMFILTERCHOOSE = thismodule.ACMFILTERCHOOSEA;
pub const AVISTREAMINFO = thismodule.AVISTREAMINFOA;
pub const AVIFILEINFO = thismodule.AVIFILEINFOA;
pub const CAPSTATUSCALLBACK = thismodule.CAPSTATUSCALLBACKA;
pub const CAPERRORCALLBACK = thismodule.CAPERRORCALLBACKA;
pub const mmioStringToFOURCC = thismodule.mmioStringToFOURCCA;
pub const mmioInstallIOProc = thismodule.mmioInstallIOProcA;
pub const mmioOpen = thismodule.mmioOpenA;
pub const mmioRename = thismodule.mmioRenameA;
pub const sndPlaySound = thismodule.sndPlaySoundA;
pub const PlaySound = thismodule.PlaySoundA;
pub const waveOutGetDevCaps = thismodule.waveOutGetDevCapsA;
pub const waveOutGetErrorText = thismodule.waveOutGetErrorTextA;
pub const waveInGetDevCaps = thismodule.waveInGetDevCapsA;
pub const waveInGetErrorText = thismodule.waveInGetErrorTextA;
pub const midiOutGetDevCaps = thismodule.midiOutGetDevCapsA;
pub const midiOutGetErrorText = thismodule.midiOutGetErrorTextA;
pub const midiInGetDevCaps = thismodule.midiInGetDevCapsA;
pub const midiInGetErrorText = thismodule.midiInGetErrorTextA;
pub const auxGetDevCaps = thismodule.auxGetDevCapsA;
pub const mixerGetDevCaps = thismodule.mixerGetDevCapsA;
pub const mixerGetLineInfo = thismodule.mixerGetLineInfoA;
pub const mixerGetLineControls = thismodule.mixerGetLineControlsA;
pub const mixerGetControlDetails = thismodule.mixerGetControlDetailsA;
pub const joyGetDevCaps = thismodule.joyGetDevCapsA;
pub const acmDriverAdd = thismodule.acmDriverAddA;
pub const acmDriverDetails = thismodule.acmDriverDetailsA;
pub const acmFormatTagDetails = thismodule.acmFormatTagDetailsA;
pub const acmFormatTagEnum = thismodule.acmFormatTagEnumA;
pub const acmFormatDetails = thismodule.acmFormatDetailsA;
pub const acmFormatEnum = thismodule.acmFormatEnumA;
pub const acmFormatChoose = thismodule.acmFormatChooseA;
pub const acmFilterTagDetails = thismodule.acmFilterTagDetailsA;
pub const acmFilterTagEnum = thismodule.acmFilterTagEnumA;
pub const acmFilterDetails = thismodule.acmFilterDetailsA;
pub const acmFilterEnum = thismodule.acmFilterEnumA;
pub const acmFilterChoose = thismodule.acmFilterChooseA;
pub const AVIFileOpen = thismodule.AVIFileOpenA;
pub const AVIFileInfo = thismodule.AVIFileInfoA;
pub const AVIFileCreateStream = thismodule.AVIFileCreateStreamA;
pub const AVIStreamInfo = thismodule.AVIStreamInfoA;
pub const AVIStreamOpenFromFile = thismodule.AVIStreamOpenFromFileA;
pub const AVISave = thismodule.AVISaveA;
pub const AVISaveV = thismodule.AVISaveVA;
pub const AVIBuildFilter = thismodule.AVIBuildFilterA;
pub const EditStreamSetName = thismodule.EditStreamSetNameA;
pub const EditStreamSetInfo = thismodule.EditStreamSetInfoA;
pub const MCIWndCreate = thismodule.MCIWndCreateA;
pub const capCreateCaptureWindow = thismodule.capCreateCaptureWindowA;
pub const capGetDriverDescription = thismodule.capGetDriverDescriptionA;
pub const GetOpenFileNamePreview = thismodule.GetOpenFileNamePreviewA;
pub const GetSaveFileNamePreview = thismodule.GetSaveFileNamePreviewA;
},
.wide => struct {
pub const WAVEOUTCAPS = thismodule.WAVEOUTCAPSW;
pub const WAVEOUTCAPS2 = thismodule.WAVEOUTCAPS2W;
pub const WAVEINCAPS = thismodule.WAVEINCAPSW;
pub const WAVEINCAPS2 = thismodule.WAVEINCAPS2W;
pub const MIDIOUTCAPS = thismodule.MIDIOUTCAPSW;
pub const MIDIOUTCAPS2 = thismodule.MIDIOUTCAPS2W;
pub const MIDIINCAPS = thismodule.MIDIINCAPSW;
pub const MIDIINCAPS2 = thismodule.MIDIINCAPS2W;
pub const AUXCAPS = thismodule.AUXCAPSW;
pub const AUXCAPS2 = thismodule.AUXCAPS2W;
pub const MIXERCAPS = thismodule.MIXERCAPSW;
pub const MIXERCAPS2 = thismodule.MIXERCAPS2W;
pub const MIXERLINE = thismodule.MIXERLINEW;
pub const MIXERCONTROL = thismodule.MIXERCONTROLW;
pub const MIXERLINECONTROLS = thismodule.MIXERLINECONTROLSW;
pub const MIXERCONTROLDETAILS_LISTTEXT = thismodule.MIXERCONTROLDETAILS_LISTTEXTW;
pub const JOYCAPS = thismodule.JOYCAPSW;
pub const JOYCAPS2 = thismodule.JOYCAPS2W;
pub const MCI_DGV_CAPTURE_PARMS = thismodule.MCI_DGV_CAPTURE_PARMSW;
pub const MCI_DGV_INFO_PARMS = thismodule.MCI_DGV_INFO_PARMSW;
pub const MCI_DGV_LIST_PARMS = thismodule.MCI_DGV_LIST_PARMSW;
pub const MCI_DGV_OPEN_PARMS = thismodule.MCI_DGV_OPEN_PARMSW;
pub const MCI_DGV_QUALITY_PARMS = thismodule.MCI_DGV_QUALITY_PARMSW;
pub const MCI_DGV_RESERVE_PARMS = thismodule.MCI_DGV_RESERVE_PARMSW;
pub const MCI_DGV_RESTORE_PARMS = thismodule.MCI_DGV_RESTORE_PARMSW;
pub const MCI_DGV_SAVE_PARMS = thismodule.MCI_DGV_SAVE_PARMSW;
pub const MCI_DGV_SETAUDIO_PARMS = thismodule.MCI_DGV_SETAUDIO_PARMSW;
pub const MCI_DGV_SETVIDEO_PARMS = thismodule.MCI_DGV_SETVIDEO_PARMSW;
pub const MCI_DGV_STATUS_PARMS = thismodule.MCI_DGV_STATUS_PARMSW;
pub const MCI_DGV_WINDOW_PARMS = thismodule.MCI_DGV_WINDOW_PARMSW;
pub const ACMDRIVERDETAILS = thismodule.ACMDRIVERDETAILSW;
pub const ACMFORMATTAGDETAILS = thismodule.ACMFORMATTAGDETAILSW;
pub const ACMFORMATTAGENUMCB = thismodule.ACMFORMATTAGENUMCBW;
pub const ACMFORMATENUMCB = thismodule.ACMFORMATENUMCBW;
pub const ACMFORMATCHOOSEHOOKPROC = thismodule.ACMFORMATCHOOSEHOOKPROCW;
pub const ACMFORMATCHOOSE = thismodule.ACMFORMATCHOOSEW;
pub const ACMFILTERTAGDETAILS = thismodule.ACMFILTERTAGDETAILSW;
pub const ACMFILTERTAGENUMCB = thismodule.ACMFILTERTAGENUMCBW;
pub const ACMFILTERDETAILS = thismodule.ACMFILTERDETAILSW;
pub const ACMFILTERENUMCB = thismodule.ACMFILTERENUMCBW;
pub const ACMFILTERCHOOSEHOOKPROC = thismodule.ACMFILTERCHOOSEHOOKPROCW;
pub const ACMFILTERCHOOSE = thismodule.ACMFILTERCHOOSEW;
pub const AVISTREAMINFO = thismodule.AVISTREAMINFOW;
pub const AVIFILEINFO = thismodule.AVIFILEINFOW;
pub const CAPSTATUSCALLBACK = thismodule.CAPSTATUSCALLBACKW;
pub const CAPERRORCALLBACK = thismodule.CAPERRORCALLBACKW;
pub const mmioStringToFOURCC = thismodule.mmioStringToFOURCCW;
pub const mmioInstallIOProc = thismodule.mmioInstallIOProcW;
pub const mmioOpen = thismodule.mmioOpenW;
pub const mmioRename = thismodule.mmioRenameW;
pub const sndPlaySound = thismodule.sndPlaySoundW;
pub const PlaySound = thismodule.PlaySoundW;
pub const waveOutGetDevCaps = thismodule.waveOutGetDevCapsW;
pub const waveOutGetErrorText = thismodule.waveOutGetErrorTextW;
pub const waveInGetDevCaps = thismodule.waveInGetDevCapsW;
pub const waveInGetErrorText = thismodule.waveInGetErrorTextW;
pub const midiOutGetDevCaps = thismodule.midiOutGetDevCapsW;
pub const midiOutGetErrorText = thismodule.midiOutGetErrorTextW;
pub const midiInGetDevCaps = thismodule.midiInGetDevCapsW;
pub const midiInGetErrorText = thismodule.midiInGetErrorTextW;
pub const auxGetDevCaps = thismodule.auxGetDevCapsW;
pub const mixerGetDevCaps = thismodule.mixerGetDevCapsW;
pub const mixerGetLineInfo = thismodule.mixerGetLineInfoW;
pub const mixerGetLineControls = thismodule.mixerGetLineControlsW;
pub const mixerGetControlDetails = thismodule.mixerGetControlDetailsW;
pub const joyGetDevCaps = thismodule.joyGetDevCapsW;
pub const acmDriverAdd = thismodule.acmDriverAddW;
pub const acmDriverDetails = thismodule.acmDriverDetailsW;
pub const acmFormatTagDetails = thismodule.acmFormatTagDetailsW;
pub const acmFormatTagEnum = thismodule.acmFormatTagEnumW;
pub const acmFormatDetails = thismodule.acmFormatDetailsW;
pub const acmFormatEnum = thismodule.acmFormatEnumW;
pub const acmFormatChoose = thismodule.acmFormatChooseW;
pub const acmFilterTagDetails = thismodule.acmFilterTagDetailsW;
pub const acmFilterTagEnum = thismodule.acmFilterTagEnumW;
pub const acmFilterDetails = thismodule.acmFilterDetailsW;
pub const acmFilterEnum = thismodule.acmFilterEnumW;
pub const acmFilterChoose = thismodule.acmFilterChooseW;
pub const AVIFileOpen = thismodule.AVIFileOpenW;
pub const AVIFileInfo = thismodule.AVIFileInfoW;
pub const AVIFileCreateStream = thismodule.AVIFileCreateStreamW;
pub const AVIStreamInfo = thismodule.AVIStreamInfoW;
pub const AVIStreamOpenFromFile = thismodule.AVIStreamOpenFromFileW;
pub const AVISave = thismodule.AVISaveW;
pub const AVISaveV = thismodule.AVISaveVW;
pub const AVIBuildFilter = thismodule.AVIBuildFilterW;
pub const EditStreamSetName = thismodule.EditStreamSetNameW;
pub const EditStreamSetInfo = thismodule.EditStreamSetInfoW;
pub const MCIWndCreate = thismodule.MCIWndCreateW;
pub const capCreateCaptureWindow = thismodule.capCreateCaptureWindowW;
pub const capGetDriverDescription = thismodule.capGetDriverDescriptionW;
pub const GetOpenFileNamePreview = thismodule.GetOpenFileNamePreviewW;
pub const GetSaveFileNamePreview = thismodule.GetSaveFileNamePreviewW;
},
.unspecified => if (@import("builtin").is_test) struct {
pub const WAVEOUTCAPS = *opaque{};
pub const WAVEOUTCAPS2 = *opaque{};
pub const WAVEINCAPS = *opaque{};
pub const WAVEINCAPS2 = *opaque{};
pub const MIDIOUTCAPS = *opaque{};
pub const MIDIOUTCAPS2 = *opaque{};
pub const MIDIINCAPS = *opaque{};
pub const MIDIINCAPS2 = *opaque{};
pub const AUXCAPS = *opaque{};
pub const AUXCAPS2 = *opaque{};
pub const MIXERCAPS = *opaque{};
pub const MIXERCAPS2 = *opaque{};
pub const MIXERLINE = *opaque{};
pub const MIXERCONTROL = *opaque{};
pub const MIXERLINECONTROLS = *opaque{};
pub const MIXERCONTROLDETAILS_LISTTEXT = *opaque{};
pub const JOYCAPS = *opaque{};
pub const JOYCAPS2 = *opaque{};
pub const MCI_DGV_CAPTURE_PARMS = *opaque{};
pub const MCI_DGV_INFO_PARMS = *opaque{};
pub const MCI_DGV_LIST_PARMS = *opaque{};
pub const MCI_DGV_OPEN_PARMS = *opaque{};
pub const MCI_DGV_QUALITY_PARMS = *opaque{};
pub const MCI_DGV_RESERVE_PARMS = *opaque{};
pub const MCI_DGV_RESTORE_PARMS = *opaque{};
pub const MCI_DGV_SAVE_PARMS = *opaque{};
pub const MCI_DGV_SETAUDIO_PARMS = *opaque{};
pub const MCI_DGV_SETVIDEO_PARMS = *opaque{};
pub const MCI_DGV_STATUS_PARMS = *opaque{};
pub const MCI_DGV_WINDOW_PARMS = *opaque{};
pub const ACMDRIVERDETAILS = *opaque{};
pub const ACMFORMATTAGDETAILS = *opaque{};
pub const ACMFORMATTAGENUMCB = *opaque{};
pub const ACMFORMATENUMCB = *opaque{};
pub const ACMFORMATCHOOSEHOOKPROC = *opaque{};
pub const ACMFORMATCHOOSE = *opaque{};
pub const ACMFILTERTAGDETAILS = *opaque{};
pub const ACMFILTERTAGENUMCB = *opaque{};
pub const ACMFILTERDETAILS = *opaque{};
pub const ACMFILTERENUMCB = *opaque{};
pub const ACMFILTERCHOOSEHOOKPROC = *opaque{};
pub const ACMFILTERCHOOSE = *opaque{};
pub const AVISTREAMINFO = *opaque{};
pub const AVIFILEINFO = *opaque{};
pub const CAPSTATUSCALLBACK = *opaque{};
pub const CAPERRORCALLBACK = *opaque{};
pub const mmioStringToFOURCC = *opaque{};
pub const mmioInstallIOProc = *opaque{};
pub const mmioOpen = *opaque{};
pub const mmioRename = *opaque{};
pub const sndPlaySound = *opaque{};
pub const PlaySound = *opaque{};
pub const waveOutGetDevCaps = *opaque{};
pub const waveOutGetErrorText = *opaque{};
pub const waveInGetDevCaps = *opaque{};
pub const waveInGetErrorText = *opaque{};
pub const midiOutGetDevCaps = *opaque{};
pub const midiOutGetErrorText = *opaque{};
pub const midiInGetDevCaps = *opaque{};
pub const midiInGetErrorText = *opaque{};
pub const auxGetDevCaps = *opaque{};
pub const mixerGetDevCaps = *opaque{};
pub const mixerGetLineInfo = *opaque{};
pub const mixerGetLineControls = *opaque{};
pub const mixerGetControlDetails = *opaque{};
pub const joyGetDevCaps = *opaque{};
pub const acmDriverAdd = *opaque{};
pub const acmDriverDetails = *opaque{};
pub const acmFormatTagDetails = *opaque{};
pub const acmFormatTagEnum = *opaque{};
pub const acmFormatDetails = *opaque{};
pub const acmFormatEnum = *opaque{};
pub const acmFormatChoose = *opaque{};
pub const acmFilterTagDetails = *opaque{};
pub const acmFilterTagEnum = *opaque{};
pub const acmFilterDetails = *opaque{};
pub const acmFilterEnum = *opaque{};
pub const acmFilterChoose = *opaque{};
pub const AVIFileOpen = *opaque{};
pub const AVIFileInfo = *opaque{};
pub const AVIFileCreateStream = *opaque{};
pub const AVIStreamInfo = *opaque{};
pub const AVIStreamOpenFromFile = *opaque{};
pub const AVISave = *opaque{};
pub const AVISaveV = *opaque{};
pub const AVIBuildFilter = *opaque{};
pub const EditStreamSetName = *opaque{};
pub const EditStreamSetInfo = *opaque{};
pub const MCIWndCreate = *opaque{};
pub const capCreateCaptureWindow = *opaque{};
pub const capGetDriverDescription = *opaque{};
pub const GetOpenFileNamePreview = *opaque{};
pub const GetSaveFileNamePreview = *opaque{};
} else struct {
pub const WAVEOUTCAPS = @compileError("'WAVEOUTCAPS' requires that UNICODE be set to true or false in the root module");
pub const WAVEOUTCAPS2 = @compileError("'WAVEOUTCAPS2' requires that UNICODE be set to true or false in the root module");
pub const WAVEINCAPS = @compileError("'WAVEINCAPS' requires that UNICODE be set to true or false in the root module");
pub const WAVEINCAPS2 = @compileError("'WAVEINCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MIDIOUTCAPS = @compileError("'MIDIOUTCAPS' requires that UNICODE be set to true or false in the root module");
pub const MIDIOUTCAPS2 = @compileError("'MIDIOUTCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MIDIINCAPS = @compileError("'MIDIINCAPS' requires that UNICODE be set to true or false in the root module");
pub const MIDIINCAPS2 = @compileError("'MIDIINCAPS2' requires that UNICODE be set to true or false in the root module");
pub const AUXCAPS = @compileError("'AUXCAPS' requires that UNICODE be set to true or false in the root module");
pub const AUXCAPS2 = @compileError("'AUXCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MIXERCAPS = @compileError("'MIXERCAPS' requires that UNICODE be set to true or false in the root module");
pub const MIXERCAPS2 = @compileError("'MIXERCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MIXERLINE = @compileError("'MIXERLINE' requires that UNICODE be set to true or false in the root module");
pub const MIXERCONTROL = @compileError("'MIXERCONTROL' requires that UNICODE be set to true or false in the root module");
pub const MIXERLINECONTROLS = @compileError("'MIXERLINECONTROLS' requires that UNICODE be set to true or false in the root module");
pub const MIXERCONTROLDETAILS_LISTTEXT = @compileError("'MIXERCONTROLDETAILS_LISTTEXT' requires that UNICODE be set to true or false in the root module");
pub const JOYCAPS = @compileError("'JOYCAPS' requires that UNICODE be set to true or false in the root module");
pub const JOYCAPS2 = @compileError("'JOYCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_CAPTURE_PARMS = @compileError("'MCI_DGV_CAPTURE_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_INFO_PARMS = @compileError("'MCI_DGV_INFO_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_LIST_PARMS = @compileError("'MCI_DGV_LIST_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_OPEN_PARMS = @compileError("'MCI_DGV_OPEN_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_QUALITY_PARMS = @compileError("'MCI_DGV_QUALITY_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_RESERVE_PARMS = @compileError("'MCI_DGV_RESERVE_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_RESTORE_PARMS = @compileError("'MCI_DGV_RESTORE_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_SAVE_PARMS = @compileError("'MCI_DGV_SAVE_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_SETAUDIO_PARMS = @compileError("'MCI_DGV_SETAUDIO_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_SETVIDEO_PARMS = @compileError("'MCI_DGV_SETVIDEO_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_STATUS_PARMS = @compileError("'MCI_DGV_STATUS_PARMS' requires that UNICODE be set to true or false in the root module");
pub const MCI_DGV_WINDOW_PARMS = @compileError("'MCI_DGV_WINDOW_PARMS' requires that UNICODE be set to true or false in the root module");
pub const ACMDRIVERDETAILS = @compileError("'ACMDRIVERDETAILS' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATTAGDETAILS = @compileError("'ACMFORMATTAGDETAILS' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATTAGENUMCB = @compileError("'ACMFORMATTAGENUMCB' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATENUMCB = @compileError("'ACMFORMATENUMCB' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATCHOOSEHOOKPROC = @compileError("'ACMFORMATCHOOSEHOOKPROC' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATCHOOSE = @compileError("'ACMFORMATCHOOSE' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERTAGDETAILS = @compileError("'ACMFILTERTAGDETAILS' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERTAGENUMCB = @compileError("'ACMFILTERTAGENUMCB' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERDETAILS = @compileError("'ACMFILTERDETAILS' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERENUMCB = @compileError("'ACMFILTERENUMCB' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERCHOOSEHOOKPROC = @compileError("'ACMFILTERCHOOSEHOOKPROC' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERCHOOSE = @compileError("'ACMFILTERCHOOSE' requires that UNICODE be set to true or false in the root module");
pub const AVISTREAMINFO = @compileError("'AVISTREAMINFO' requires that UNICODE be set to true or false in the root module");
pub const AVIFILEINFO = @compileError("'AVIFILEINFO' requires that UNICODE be set to true or false in the root module");
pub const CAPSTATUSCALLBACK = @compileError("'CAPSTATUSCALLBACK' requires that UNICODE be set to true or false in the root module");
pub const CAPERRORCALLBACK = @compileError("'CAPERRORCALLBACK' requires that UNICODE be set to true or false in the root module");
pub const mmioStringToFOURCC = @compileError("'mmioStringToFOURCC' requires that UNICODE be set to true or false in the root module");
pub const mmioInstallIOProc = @compileError("'mmioInstallIOProc' requires that UNICODE be set to true or false in the root module");
pub const mmioOpen = @compileError("'mmioOpen' requires that UNICODE be set to true or false in the root module");
pub const mmioRename = @compileError("'mmioRename' requires that UNICODE be set to true or false in the root module");
pub const sndPlaySound = @compileError("'sndPlaySound' requires that UNICODE be set to true or false in the root module");
pub const PlaySound = @compileError("'PlaySound' requires that UNICODE be set to true or false in the root module");
pub const waveOutGetDevCaps = @compileError("'waveOutGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const waveOutGetErrorText = @compileError("'waveOutGetErrorText' requires that UNICODE be set to true or false in the root module");
pub const waveInGetDevCaps = @compileError("'waveInGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const waveInGetErrorText = @compileError("'waveInGetErrorText' requires that UNICODE be set to true or false in the root module");
pub const midiOutGetDevCaps = @compileError("'midiOutGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const midiOutGetErrorText = @compileError("'midiOutGetErrorText' requires that UNICODE be set to true or false in the root module");
pub const midiInGetDevCaps = @compileError("'midiInGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const midiInGetErrorText = @compileError("'midiInGetErrorText' requires that UNICODE be set to true or false in the root module");
pub const auxGetDevCaps = @compileError("'auxGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const mixerGetDevCaps = @compileError("'mixerGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const mixerGetLineInfo = @compileError("'mixerGetLineInfo' requires that UNICODE be set to true or false in the root module");
pub const mixerGetLineControls = @compileError("'mixerGetLineControls' requires that UNICODE be set to true or false in the root module");
pub const mixerGetControlDetails = @compileError("'mixerGetControlDetails' requires that UNICODE be set to true or false in the root module");
pub const joyGetDevCaps = @compileError("'joyGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const acmDriverAdd = @compileError("'acmDriverAdd' requires that UNICODE be set to true or false in the root module");
pub const acmDriverDetails = @compileError("'acmDriverDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFormatTagDetails = @compileError("'acmFormatTagDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFormatTagEnum = @compileError("'acmFormatTagEnum' requires that UNICODE be set to true or false in the root module");
pub const acmFormatDetails = @compileError("'acmFormatDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFormatEnum = @compileError("'acmFormatEnum' requires that UNICODE be set to true or false in the root module");
pub const acmFormatChoose = @compileError("'acmFormatChoose' requires that UNICODE be set to true or false in the root module");
pub const acmFilterTagDetails = @compileError("'acmFilterTagDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFilterTagEnum = @compileError("'acmFilterTagEnum' requires that UNICODE be set to true or false in the root module");
pub const acmFilterDetails = @compileError("'acmFilterDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFilterEnum = @compileError("'acmFilterEnum' requires that UNICODE be set to true or false in the root module");
pub const acmFilterChoose = @compileError("'acmFilterChoose' requires that UNICODE be set to true or false in the root module");
pub const AVIFileOpen = @compileError("'AVIFileOpen' requires that UNICODE be set to true or false in the root module");
pub const AVIFileInfo = @compileError("'AVIFileInfo' requires that UNICODE be set to true or false in the root module");
pub const AVIFileCreateStream = @compileError("'AVIFileCreateStream' requires that UNICODE be set to true or false in the root module");
pub const AVIStreamInfo = @compileError("'AVIStreamInfo' requires that UNICODE be set to true or false in the root module");
pub const AVIStreamOpenFromFile = @compileError("'AVIStreamOpenFromFile' requires that UNICODE be set to true or false in the root module");
pub const AVISave = @compileError("'AVISave' requires that UNICODE be set to true or false in the root module");
pub const AVISaveV = @compileError("'AVISaveV' requires that UNICODE be set to true or false in the root module");
pub const AVIBuildFilter = @compileError("'AVIBuildFilter' requires that UNICODE be set to true or false in the root module");
pub const EditStreamSetName = @compileError("'EditStreamSetName' requires that UNICODE be set to true or false in the root module");
pub const EditStreamSetInfo = @compileError("'EditStreamSetInfo' requires that UNICODE be set to true or false in the root module");
pub const MCIWndCreate = @compileError("'MCIWndCreate' requires that UNICODE be set to true or false in the root module");
pub const capCreateCaptureWindow = @compileError("'capCreateCaptureWindow' requires that UNICODE be set to true or false in the root module");
pub const capGetDriverDescription = @compileError("'capGetDriverDescription' requires that UNICODE be set to true or false in the root module");
pub const GetOpenFileNamePreview = @compileError("'GetOpenFileNamePreview' requires that UNICODE be set to true or false in the root module");
pub const GetSaveFileNamePreview = @compileError("'GetSaveFileNamePreview' requires that UNICODE be set to true or false in the root module");
},
};
//--------------------------------------------------------------------------------
// Section: Imports (28)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BITMAPINFO = @import("../graphics/gdi.zig").BITMAPINFO;
const BITMAPINFOHEADER = @import("../graphics/gdi.zig").BITMAPINFOHEADER;
const BOOL = @import("../foundation.zig").BOOL;
const CHAR = @import("../system/system_services.zig").CHAR;
const FARPROC = @import("../foundation.zig").FARPROC;
const HANDLE = @import("../foundation.zig").HANDLE;
const HDC = @import("../graphics/gdi.zig").HDC;
const HICON = @import("../ui/windows_and_messaging.zig").HICON;
const HINSTANCE = @import("../foundation.zig").HINSTANCE;
const HPALETTE = @import("../graphics/gdi.zig").HPALETTE;
const HRESULT = @import("../foundation.zig").HRESULT;
const HTASK = @import("../media/audio/core_audio.zig").HTASK;
const HWND = @import("../foundation.zig").HWND;
const IPersistFile = @import("../system/com.zig").IPersistFile;
const IUnknown = @import("../system/com.zig").IUnknown;
const JOYREGHWVALUES = @import("../devices/human_interface_device.zig").JOYREGHWVALUES;
const LPARAM = @import("../foundation.zig").LPARAM;
const LPTIMECALLBACK = @import("../system/system_services.zig").LPTIMECALLBACK;
const LRESULT = @import("../foundation.zig").LRESULT;
const OPENFILENAMEA = @import("../ui/windows_and_messaging.zig").OPENFILENAMEA;
const OPENFILENAMEW = @import("../ui/windows_and_messaging.zig").OPENFILENAMEW;
const PALETTEENTRY = @import("../graphics/gdi.zig").PALETTEENTRY;
const POINT = @import("../foundation.zig").POINT;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;
const RECT = @import("../foundation.zig").RECT;
const WPARAM = @import("../foundation.zig").WPARAM;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "LPWAVECALLBACK")) { _ = LPWAVECALLBACK; }
if (@hasDecl(@This(), "LPMIDICALLBACK")) { _ = LPMIDICALLBACK; }
if (@hasDecl(@This(), "LPDRVCALLBACK")) { _ = LPDRVCALLBACK; }
if (@hasDecl(@This(), "DRIVERPROC")) { _ = DRIVERPROC; }
if (@hasDecl(@This(), "DRIVERMSGPROC")) { _ = DRIVERMSGPROC; }
if (@hasDecl(@This(), "LPMMIOPROC")) { _ = LPMMIOPROC; }
if (@hasDecl(@This(), "ACMDRIVERENUMCB")) { _ = ACMDRIVERENUMCB; }
if (@hasDecl(@This(), "LPACMDRIVERPROC")) { _ = LPACMDRIVERPROC; }
if (@hasDecl(@This(), "ACMFORMATTAGENUMCBA")) { _ = ACMFORMATTAGENUMCBA; }
if (@hasDecl(@This(), "ACMFORMATTAGENUMCBW")) { _ = ACMFORMATTAGENUMCBW; }
if (@hasDecl(@This(), "ACMFORMATENUMCBA")) { _ = ACMFORMATENUMCBA; }
if (@hasDecl(@This(), "ACMFORMATENUMCBW")) { _ = ACMFORMATENUMCBW; }
if (@hasDecl(@This(), "ACMFORMATCHOOSEHOOKPROCA")) { _ = ACMFORMATCHOOSEHOOKPROCA; }
if (@hasDecl(@This(), "ACMFORMATCHOOSEHOOKPROCW")) { _ = ACMFORMATCHOOSEHOOKPROCW; }
if (@hasDecl(@This(), "ACMFILTERTAGENUMCBA")) { _ = ACMFILTERTAGENUMCBA; }
if (@hasDecl(@This(), "ACMFILTERTAGENUMCBW")) { _ = ACMFILTERTAGENUMCBW; }
if (@hasDecl(@This(), "ACMFILTERENUMCBA")) { _ = ACMFILTERENUMCBA; }
if (@hasDecl(@This(), "ACMFILTERENUMCBW")) { _ = ACMFILTERENUMCBW; }
if (@hasDecl(@This(), "ACMFILTERCHOOSEHOOKPROCA")) { _ = ACMFILTERCHOOSEHOOKPROCA; }
if (@hasDecl(@This(), "ACMFILTERCHOOSEHOOKPROCW")) { _ = ACMFILTERCHOOSEHOOKPROCW; }
if (@hasDecl(@This(), "AVISAVECALLBACK")) { _ = AVISAVECALLBACK; }
if (@hasDecl(@This(), "CAPYIELDCALLBACK")) { _ = CAPYIELDCALLBACK; }
if (@hasDecl(@This(), "CAPSTATUSCALLBACKW")) { _ = CAPSTATUSCALLBACKW; }
if (@hasDecl(@This(), "CAPERRORCALLBACKW")) { _ = CAPERRORCALLBACKW; }
if (@hasDecl(@This(), "CAPSTATUSCALLBACKA")) { _ = CAPSTATUSCALLBACKA; }
if (@hasDecl(@This(), "CAPERRORCALLBACKA")) { _ = CAPERRORCALLBACKA; }
if (@hasDecl(@This(), "CAPVIDEOCALLBACK")) { _ = CAPVIDEOCALLBACK; }
if (@hasDecl(@This(), "CAPWAVECALLBACK")) { _ = CAPWAVECALLBACK; }
if (@hasDecl(@This(), "CAPCONTROLCALLBACK")) { _ = CAPCONTROLCALLBACK; }
if (@hasDecl(@This(), "LPJOYDEVMSGPROC")) { _ = LPJOYDEVMSGPROC; }
if (@hasDecl(@This(), "LPTASKCALLBACK")) { _ = LPTASKCALLBACK; }
@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;
}
}
} | deps/zigwin32/win32/media/multimedia.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 = .info;
fn draw() !void {
const r = m.Rectangle{ .position = m.Vec2f{ .x = 100.0, .y = 200.0 }, .size = m.Vec2f{ .x = 50.0, .y = 50.0 } };
const col = alka.Colour{ .r = 1, .g = 1, .b = 1, .a = 1 };
//try alka.drawRectangleAdv(r, m.Vec2f{ .x = 25, .y = 25 }, m.deg2radf(45), col);
try alka.drawRectangleLinesAdv(r, m.Vec2f{ .x = 25, .y = 25 }, m.deg2radf(45), col);
const r2 = m.Rectangle{ .position = m.Vec2f{ .x = 200.0, .y = 200.0 }, .size = m.Vec2f{ .x = 30.0, .y = 30.0 } };
const col2 = alka.Colour.rgba(30, 80, 200, 255);
//try alka.drawRectangle(r2, col2);
try alka.drawRectangleLines(r2, col2);
// position, radius, colour
// segment count is 16 by default
//try alka.drawCircleLines(m.Vec2f{ .x = 350, .y = 260 }, 24, col);
//try alka.drawCircle(m.Vec2f{ .x = 450, .y = 260 }, 24, col);
// position, radius, segment count, startangle, endangle, colour
try alka.drawCircleLinesAdv(m.Vec2f{ .x = 350, .y = 260 }, 24, 8, 0, 360, col);
try alka.drawCircleLinesAdv(m.Vec2f{ .x = 350, .y = 360 }, 24, 32, 0, 360, col);
try alka.drawCircleAdv(m.Vec2f{ .x = 450, .y = 260 }, 24, 32, 0, 360, col);
try alka.drawCircleAdv(m.Vec2f{ .x = 450, .y = 360 }, 24, 8, 0, 360, col);
// start, end, thickness, colour
try alka.drawLine(m.Vec2f{ .x = 300, .y = 300 }, m.Vec2f{ .x = 400, .y = 350 }, 1, col);
var i: f32 = 0;
while (i < 10) : (i += 2) {
try alka.drawPixel(m.Vec2f{ .x = 300 + i, .y = 400 }, col);
}
}
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const callbacks = alka.Callbacks{
.update = null,
.fixed = null,
.draw = draw,
.resize = null,
.close = null,
};
try alka.init(&gpa.allocator, callbacks, 1024, 768, "Shape Drawing", 0, false);
try alka.open();
try alka.update();
try alka.close();
try alka.deinit();
const leaked = gpa.deinit();
if (leaked) return error.Leak;
} | examples/shape_drawing.zig |
const std = @import("std");
const glfw = @import("libs/mach-glfw/build.zig");
const gpu_dawn = @import("libs/mach-gpu-dawn/build.zig");
pub const BuildOptions = struct {
use_imgui: bool = true,
use_stb_image: bool = true,
glfw: glfw.Options = .{},
dawn: gpu_dawn.Options = .{},
};
pub const BuildOptionsStep = struct {
options: BuildOptions,
step: *std.build.OptionsStep,
pub fn init(b: *std.build.Builder, options: BuildOptions) BuildOptionsStep {
const bos = .{
.options = options,
.step = b.addOptions(),
};
return bos;
}
pub fn getPkg(bos: BuildOptionsStep) std.build.Pkg {
return bos.step.getPackage("zgpu_options");
}
fn addTo(bos: BuildOptionsStep, target_step: *std.build.LibExeObjStep) void {
target_step.addOptions("zgpu_options", bos.step);
}
};
pub fn link(exe: *std.build.LibExeObjStep, bos: BuildOptionsStep) void {
bos.addTo(exe);
// When user links with `zgpu` we automatically inject dependencies to `gpu` and `glfw`.
exe.addPackage(glfw.pkg);
exe.addPackage(gpu_pkg);
glfw.link(exe.builder, exe, bos.options.glfw);
gpu_dawn.link(exe.builder, exe, bos.options.dawn);
if (bos.options.use_imgui) {
exe.addIncludeDir(thisDir() ++ "/libs");
exe.addCSourceFile(thisDir() ++ "/libs/imgui/imgui.cpp", &.{""});
exe.addCSourceFile(thisDir() ++ "/libs/imgui/imgui_widgets.cpp", &.{""});
exe.addCSourceFile(thisDir() ++ "/libs/imgui/imgui_tables.cpp", &.{""});
exe.addCSourceFile(thisDir() ++ "/libs/imgui/imgui_draw.cpp", &.{""});
exe.addCSourceFile(thisDir() ++ "/libs/imgui/imgui_demo.cpp", &.{""});
exe.addCSourceFile(thisDir() ++ "/libs/imgui/cimgui.cpp", &.{""});
exe.addCSourceFile(thisDir() ++ "/libs/imgui/imgui_impl_glfw.cpp", &.{""});
exe.addCSourceFile(thisDir() ++ "/libs/imgui/imgui_impl_wgpu.cpp", &.{""});
}
if (bos.options.use_stb_image) {
exe.addCSourceFile(thisDir() ++ "/libs/stb/stb_image.c", &.{"-std=c99"});
}
}
const gpu_pkg = std.build.Pkg{
.name = "gpu",
.source = .{ .path = thisDir() ++ "/libs/mach-gpu/main.zig" },
};
pub fn getPkg(dependencies: []const std.build.Pkg) std.build.Pkg {
const static = struct {
var deps: [8]std.build.Pkg = undefined;
};
std.debug.assert(dependencies.len < static.deps.len - 1);
// Copy `dependencies` to a static memory.
for (dependencies) |dep, i| {
static.deps[i] = dep;
}
// When user links with `zgpu` we automatically inject dependencies to `gpu` and `glfw`.
static.deps[dependencies.len] = gpu_pkg;
static.deps[dependencies.len + 1] = glfw.pkg;
return .{
.name = "zgpu",
.source = .{ .path = thisDir() ++ "/src/zgpu.zig" },
.dependencies = static.deps[0 .. dependencies.len + 2],
};
}
fn thisDir() []const u8 {
comptime {
return std.fs.path.dirname(@src().file) orelse ".";
}
} | libs/zgpu/build.zig |
const std = @import("std");
const backend = @import("backend.zig");
const dataStructures = @import("data.zig");
const Size = dataStructures.Size;
const StringDataWrapper = dataStructures.StringDataWrapper;
pub const TextArea_Impl = struct {
pub usingnamespace @import("internal.zig").All(TextArea_Impl);
peer: ?backend.TextArea = null,
handlers: TextArea_Impl.Handlers = undefined,
dataWrappers: TextArea_Impl.DataWrappers = .{},
_text: []const u8,
pub fn init(text: []const u8) TextArea_Impl {
return TextArea_Impl.init_events(TextArea_Impl{ ._text = text });
}
pub fn show(self: *TextArea_Impl) !void {
if (self.peer == null) {
var peer = try backend.TextArea.create();
peer.setText(self._text);
self.peer = peer;
}
}
pub fn getPreferredSize(self: *TextArea_Impl, available: Size) Size {
_ = self;
_ = available;
// TODO getting hint from native peer
return Size{ .width = 100.0, .height = 100.0 };
}
pub fn setText(self: *TextArea_Impl, text: []const u8) void {
if (self.peer) |*peer| {
peer.setText(text);
} else {
self._text = text;
}
}
pub fn getText(self: *TextArea_Impl) []const u8 {
if (self.peer) |*peer| {
return peer.getText();
} else {
return self._text;
}
}
};
pub const TextField_Impl = struct {
pub usingnamespace @import("internal.zig").All(TextField_Impl);
//pub usingnamespace @import("internal.zig").Property(TextField_Impl, "text");
peer: ?backend.TextField = null,
handlers: TextField_Impl.Handlers = undefined,
dataWrappers: TextField_Impl.DataWrappers = .{},
text: StringDataWrapper,
pub fn init(text: []const u8) TextField_Impl {
return TextField_Impl.init_events(TextField_Impl{ .text = StringDataWrapper.of(text) });
}
/// Internal function used at initialization.
/// It is used to move some pointers so things do not break.
pub fn _pointerMoved(self: *TextField_Impl) void {
self.text.updateBinders();
}
/// When the text is changed in the StringDataWrapper
fn wrapperTextChanged(newValue: []const u8, userdata: usize) void {
const peer = @intToPtr(*?backend.TextField, userdata);
peer.*.?.setText(newValue);
}
fn textChanged(userdata: usize) void {
const self = @intToPtr(*TextField_Impl, userdata);
const text = self.peer.?.getText();
self.text.setNoListen(text);
}
pub fn show(self: *TextField_Impl) !void {
if (self.peer == null) {
var peer = try backend.TextField.create();
peer.setText(self.text.get());
self.peer = peer;
try self.show_events();
try peer.setCallback(.TextChanged, textChanged);
_ = try self.text.addChangeListener(.{ .function = wrapperTextChanged, .userdata = @ptrToInt(&self.peer) });
}
}
pub fn getPreferredSize(self: *TextField_Impl, available: Size) Size {
_ = self;
_ = available;
return Size{ .width = 100.0, .height = 40.0 };
}
pub fn setText(self: *TextField_Impl, text: []const u8) void {
self.text.set(text);
}
pub fn getText(self: *TextField_Impl) []const u8 {
return self.text.get();
}
/// Bind the 'text' property to argument.
pub fn bindText(self: *TextField_Impl, other: *StringDataWrapper) TextField_Impl {
self.text.bind(other);
self.text.set(other.get());
return self.*;
}
};
pub fn TextArea(config: struct { text: []const u8 = "" }) TextArea_Impl {
return TextArea_Impl.init(config.text);
}
pub fn TextField(config: struct { text: []const u8 = "" }) TextField_Impl {
return TextField_Impl.init(config.text);
} | src/text.zig |
const builtin = @import("builtin");
const is_test = builtin.is_test;
comptime {
const linkage = if (is_test) builtin.GlobalLinkage.Internal else builtin.GlobalLinkage.Weak;
const strong_linkage = if (is_test) builtin.GlobalLinkage.Internal else builtin.GlobalLinkage.Strong;
@export("__letf2", @import("comparetf2.zig").__letf2, linkage);
@export("__getf2", @import("comparetf2.zig").__getf2, linkage);
if (!is_test) {
// only create these aliases when not testing
@export("__cmptf2", @import("comparetf2.zig").__letf2, linkage);
@export("__eqtf2", @import("comparetf2.zig").__letf2, linkage);
@export("__lttf2", @import("comparetf2.zig").__letf2, linkage);
@export("__netf2", @import("comparetf2.zig").__letf2, linkage);
@export("__gttf2", @import("comparetf2.zig").__getf2, linkage);
@export("__gnu_h2f_ieee", @import("extendXfYf2.zig").__extendhfsf2, linkage);
@export("__gnu_f2h_ieee", @import("truncXfYf2.zig").__truncsfhf2, linkage);
}
@export("__unordtf2", @import("comparetf2.zig").__unordtf2, linkage);
@export("__floattitf", @import("floattitf.zig").__floattitf, linkage);
@export("__floattidf", @import("floattidf.zig").__floattidf, linkage);
@export("__floattisf", @import("floattisf.zig").__floattisf, linkage);
@export("__floatunditf", @import("floatunditf.zig").__floatunditf, linkage);
@export("__floatunsitf", @import("floatunsitf.zig").__floatunsitf, linkage);
@export("__floatuntitf", @import("floatuntitf.zig").__floatuntitf, linkage);
@export("__floatuntidf", @import("floatuntidf.zig").__floatuntidf, linkage);
@export("__floatuntisf", @import("floatuntisf.zig").__floatuntisf, linkage);
@export("__extenddftf2", @import("extendXfYf2.zig").__extenddftf2, linkage);
@export("__extendsftf2", @import("extendXfYf2.zig").__extendsftf2, linkage);
@export("__extendhfsf2", @import("extendXfYf2.zig").__extendhfsf2, linkage);
@export("__truncsfhf2", @import("truncXfYf2.zig").__truncsfhf2, linkage);
@export("__trunctfdf2", @import("truncXfYf2.zig").__trunctfdf2, linkage);
@export("__trunctfsf2", @import("truncXfYf2.zig").__trunctfsf2, linkage);
@export("__fixunssfsi", @import("fixunssfsi.zig").__fixunssfsi, linkage);
@export("__fixunssfdi", @import("fixunssfdi.zig").__fixunssfdi, linkage);
@export("__fixunssfti", @import("fixunssfti.zig").__fixunssfti, linkage);
@export("__fixunsdfsi", @import("fixunsdfsi.zig").__fixunsdfsi, linkage);
@export("__fixunsdfdi", @import("fixunsdfdi.zig").__fixunsdfdi, linkage);
@export("__fixunsdfti", @import("fixunsdfti.zig").__fixunsdfti, linkage);
@export("__fixunstfsi", @import("fixunstfsi.zig").__fixunstfsi, linkage);
@export("__fixunstfdi", @import("fixunstfdi.zig").__fixunstfdi, linkage);
@export("__fixunstfti", @import("fixunstfti.zig").__fixunstfti, linkage);
@export("__fixdfdi", @import("fixdfdi.zig").__fixdfdi, linkage);
@export("__fixdfsi", @import("fixdfsi.zig").__fixdfsi, linkage);
@export("__fixdfti", @import("fixdfti.zig").__fixdfti, linkage);
@export("__fixsfdi", @import("fixsfdi.zig").__fixsfdi, linkage);
@export("__fixsfsi", @import("fixsfsi.zig").__fixsfsi, linkage);
@export("__fixsfti", @import("fixsfti.zig").__fixsfti, linkage);
@export("__fixtfdi", @import("fixtfdi.zig").__fixtfdi, linkage);
@export("__fixtfsi", @import("fixtfsi.zig").__fixtfsi, linkage);
@export("__fixtfti", @import("fixtfti.zig").__fixtfti, linkage);
@export("__udivmoddi4", @import("udivmoddi4.zig").__udivmoddi4, linkage);
@export("__udivsi3", __udivsi3, linkage);
@export("__udivdi3", __udivdi3, linkage);
@export("__umoddi3", __umoddi3, linkage);
@export("__udivmodsi4", __udivmodsi4, linkage);
if (is_arm_arch and !is_arm_64) {
@export("__aeabi_uldivmod", __aeabi_uldivmod, linkage);
@export("__aeabi_uidivmod", __aeabi_uidivmod, linkage);
@export("__aeabi_uidiv", __udivsi3, linkage);
}
if (builtin.os == builtin.Os.windows) {
switch (builtin.arch) {
builtin.Arch.i386 => {
if (!builtin.link_libc) {
@export("_chkstk", _chkstk, strong_linkage);
@export("__chkstk_ms", __chkstk_ms, linkage);
}
@export("_aulldiv", @import("aulldiv.zig")._aulldiv, strong_linkage);
@export("_aullrem", @import("aullrem.zig")._aullrem, strong_linkage);
},
builtin.Arch.x86_64 => {
if (!builtin.link_libc) {
@export("__chkstk", __chkstk, strong_linkage);
@export("___chkstk_ms", ___chkstk_ms, linkage);
}
@export("__divti3", @import("divti3.zig").__divti3_windows_x86_64, linkage);
@export("__multi3", @import("multi3.zig").__multi3_windows_x86_64, linkage);
@export("__muloti4", @import("muloti4.zig").__muloti4_windows_x86_64, linkage);
@export("__udivti3", @import("udivti3.zig").__udivti3_windows_x86_64, linkage);
@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4_windows_x86_64, linkage);
@export("__umodti3", @import("umodti3.zig").__umodti3_windows_x86_64, linkage);
},
else => {},
}
} else {
@export("__divti3", @import("divti3.zig").__divti3, linkage);
@export("__multi3", @import("multi3.zig").__multi3, linkage);
@export("__muloti4", @import("muloti4.zig").__muloti4, linkage);
@export("__udivti3", @import("udivti3.zig").__udivti3, linkage);
@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4, linkage);
@export("__umodti3", @import("umodti3.zig").__umodti3, linkage);
}
}
const std = @import("std");
const assert = std.debug.assert;
const __udivmoddi4 = @import("udivmoddi4.zig").__udivmoddi4;
// Avoid dragging in the runtime safety mechanisms into this .o file,
// unless we're trying to test this file.
pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
@setCold(true);
if (is_test) {
std.debug.panic("{}", msg);
} else {
unreachable;
}
}
pub fn setXmm0(comptime T: type, value: T) void {
comptime assert(builtin.arch == builtin.Arch.x86_64);
const aligned_value: T align(16) = value;
asm volatile (
\\movaps (%[ptr]), %%xmm0
:
: [ptr] "r" (&aligned_value)
: "xmm0"
);
}
extern fn __udivdi3(a: u64, b: u64) u64 {
@setRuntimeSafety(is_test);
return __udivmoddi4(a, b, null);
}
extern fn __umoddi3(a: u64, b: u64) u64 {
@setRuntimeSafety(is_test);
var r: u64 = undefined;
_ = __udivmoddi4(a, b, &r);
return r;
}
const AeabiUlDivModResult = extern struct {
quot: u64,
rem: u64,
};
extern fn __aeabi_uldivmod(numerator: u64, denominator: u64) AeabiUlDivModResult {
@setRuntimeSafety(is_test);
var result: AeabiUlDivModResult = undefined;
result.quot = __udivmoddi4(numerator, denominator, &result.rem);
return result;
}
const is_arm_64 = switch (builtin.arch) {
builtin.Arch.aarch64v8_3a,
builtin.Arch.aarch64v8_2a,
builtin.Arch.aarch64v8_1a,
builtin.Arch.aarch64v8,
builtin.Arch.aarch64v8r,
builtin.Arch.aarch64v8m_baseline,
builtin.Arch.aarch64v8m_mainline,
builtin.Arch.aarch64_bev8_3a,
builtin.Arch.aarch64_bev8_2a,
builtin.Arch.aarch64_bev8_1a,
builtin.Arch.aarch64_bev8,
builtin.Arch.aarch64_bev8r,
builtin.Arch.aarch64_bev8m_baseline,
builtin.Arch.aarch64_bev8m_mainline,
=> true,
else => false,
};
const is_arm_arch = switch (builtin.arch) {
builtin.Arch.armv8_3a,
builtin.Arch.armv8_2a,
builtin.Arch.armv8_1a,
builtin.Arch.armv8,
builtin.Arch.armv8r,
builtin.Arch.armv8m_baseline,
builtin.Arch.armv8m_mainline,
builtin.Arch.armv7,
builtin.Arch.armv7em,
builtin.Arch.armv7m,
builtin.Arch.armv7s,
builtin.Arch.armv7k,
builtin.Arch.armv7ve,
builtin.Arch.armv6,
builtin.Arch.armv6m,
builtin.Arch.armv6k,
builtin.Arch.armv6t2,
builtin.Arch.armv5,
builtin.Arch.armv5te,
builtin.Arch.armv4t,
builtin.Arch.armebv8_3a,
builtin.Arch.armebv8_2a,
builtin.Arch.armebv8_1a,
builtin.Arch.armebv8,
builtin.Arch.armebv8r,
builtin.Arch.armebv8m_baseline,
builtin.Arch.armebv8m_mainline,
builtin.Arch.armebv7,
builtin.Arch.armebv7em,
builtin.Arch.armebv7m,
builtin.Arch.armebv7s,
builtin.Arch.armebv7k,
builtin.Arch.armebv7ve,
builtin.Arch.armebv6,
builtin.Arch.armebv6m,
builtin.Arch.armebv6k,
builtin.Arch.armebv6t2,
builtin.Arch.armebv5,
builtin.Arch.armebv5te,
builtin.Arch.armebv4t,
builtin.Arch.aarch64v8_3a,
builtin.Arch.aarch64v8_2a,
builtin.Arch.aarch64v8_1a,
builtin.Arch.aarch64v8,
builtin.Arch.aarch64v8r,
builtin.Arch.aarch64v8m_baseline,
builtin.Arch.aarch64v8m_mainline,
builtin.Arch.aarch64_bev8_3a,
builtin.Arch.aarch64_bev8_2a,
builtin.Arch.aarch64_bev8_1a,
builtin.Arch.aarch64_bev8,
builtin.Arch.aarch64_bev8r,
builtin.Arch.aarch64_bev8m_baseline,
builtin.Arch.aarch64_bev8m_mainline,
builtin.Arch.thumb,
builtin.Arch.thumbeb,
=> true,
else => false,
};
nakedcc fn __aeabi_uidivmod() void {
@setRuntimeSafety(false);
asm volatile (
\\ push { lr }
\\ sub sp, sp, #4
\\ mov r2, sp
\\ bl __udivmodsi4
\\ ldr r1, [sp]
\\ add sp, sp, #4
\\ pop { pc }
:
:
: "r2", "r1"
);
}
// _chkstk (_alloca) routine - probe stack between %esp and (%esp-%eax) in 4k increments,
// then decrement %esp by %eax. Preserves all registers except %esp and flags.
// This routine is windows specific
// http://msdn.microsoft.com/en-us/library/ms648426.aspx
nakedcc fn _chkstk() align(4) void {
@setRuntimeSafety(false);
asm volatile (
\\ push %%ecx
\\ push %%eax
\\ cmp $0x1000,%%eax
\\ lea 12(%%esp),%%ecx
\\ jb 1f
\\ 2:
\\ sub $0x1000,%%ecx
\\ test %%ecx,(%%ecx)
\\ sub $0x1000,%%eax
\\ cmp $0x1000,%%eax
\\ ja 2b
\\ 1:
\\ sub %%eax,%%ecx
\\ test %%ecx,(%%ecx)
\\ pop %%eax
\\ pop %%ecx
\\ ret
);
}
nakedcc fn __chkstk() align(4) void {
@setRuntimeSafety(false);
asm volatile (
\\ push %%rcx
\\ push %%rax
\\ cmp $0x1000,%%rax
\\ lea 24(%%rsp),%%rcx
\\ jb 1f
\\2:
\\ sub $0x1000,%%rcx
\\ test %%rcx,(%%rcx)
\\ sub $0x1000,%%rax
\\ cmp $0x1000,%%rax
\\ ja 2b
\\1:
\\ sub %%rax,%%rcx
\\ test %%rcx,(%%rcx)
\\ pop %%rax
\\ pop %%rcx
\\ ret
);
}
// _chkstk routine
// This routine is windows specific
// http://msdn.microsoft.com/en-us/library/ms648426.aspx
nakedcc fn __chkstk_ms() align(4) void {
@setRuntimeSafety(false);
asm volatile (
\\ push %%ecx
\\ push %%eax
\\ cmp $0x1000,%%eax
\\ lea 12(%%esp),%%ecx
\\ jb 1f
\\ 2:
\\ sub $0x1000,%%ecx
\\ test %%ecx,(%%ecx)
\\ sub $0x1000,%%eax
\\ cmp $0x1000,%%eax
\\ ja 2b
\\ 1:
\\ sub %%eax,%%ecx
\\ test %%ecx,(%%ecx)
\\ pop %%eax
\\ pop %%ecx
\\ ret
);
}
nakedcc fn ___chkstk_ms() align(4) void {
@setRuntimeSafety(false);
asm volatile (
\\ push %%rcx
\\ push %%rax
\\ cmp $0x1000,%%rax
\\ lea 24(%%rsp),%%rcx
\\ jb 1f
\\2:
\\ sub $0x1000,%%rcx
\\ test %%rcx,(%%rcx)
\\ sub $0x1000,%%rax
\\ cmp $0x1000,%%rax
\\ ja 2b
\\1:
\\ sub %%rax,%%rcx
\\ test %%rcx,(%%rcx)
\\ pop %%rax
\\ pop %%rcx
\\ ret
);
}
extern fn __udivmodsi4(a: u32, b: u32, rem: *u32) u32 {
@setRuntimeSafety(is_test);
const d = __udivsi3(a, b);
rem.* = @bitCast(u32, @bitCast(i32, a) -% (@bitCast(i32, d) * @bitCast(i32, b)));
return d;
}
extern fn __udivsi3(n: u32, d: u32) u32 {
@setRuntimeSafety(is_test);
const n_uword_bits: c_uint = u32.bit_count;
// special cases
if (d == 0) return 0; // ?!
if (n == 0) return 0;
var sr = @bitCast(c_uint, c_int(@clz(d)) - c_int(@clz(n)));
// 0 <= sr <= n_uword_bits - 1 or sr large
if (sr > n_uword_bits - 1) {
// d > r
return 0;
}
if (sr == n_uword_bits - 1) {
// d == 1
return n;
}
sr += 1;
// 1 <= sr <= n_uword_bits - 1
// Not a special case
var q: u32 = n << @intCast(u5, n_uword_bits - sr);
var r: u32 = n >> @intCast(u5, sr);
var carry: u32 = 0;
while (sr > 0) : (sr -= 1) {
// r:q = ((r:q) << 1) | carry
r = (r << 1) | (q >> @intCast(u5, n_uword_bits - 1));
q = (q << 1) | carry;
// carry = 0;
// if (r.all >= d.all)
// {
// r.all -= d.all;
// carry = 1;
// }
const s = @intCast(i32, d -% r -% 1) >> @intCast(u5, n_uword_bits - 1);
carry = @intCast(u32, s & 1);
r -= d & @bitCast(u32, s);
}
q = (q << 1) | carry;
return q;
}
test "test_umoddi3" {
test_one_umoddi3(0, 1, 0);
test_one_umoddi3(2, 1, 0);
test_one_umoddi3(0x8000000000000000, 1, 0x0);
test_one_umoddi3(0x8000000000000000, 2, 0x0);
test_one_umoddi3(0xFFFFFFFFFFFFFFFF, 2, 0x1);
}
fn test_one_umoddi3(a: u64, b: u64, expected_r: u64) void {
const r = __umoddi3(a, b);
assert(r == expected_r);
}
test "test_udivsi3" {
const cases = [][3]u32{
[]u32{
0x00000000,
0x00000001,
0x00000000,
},
[]u32{
0x00000000,
0x00000002,
0x00000000,
},
[]u32{
0x00000000,
0x00000003,
0x00000000,
},
[]u32{
0x00000000,
0x00000010,
0x00000000,
},
[]u32{
0x00000000,
0x078644FA,
0x00000000,
},
[]u32{
0x00000000,
0x0747AE14,
0x00000000,
},
[]u32{
0x00000000,
0x7FFFFFFF,
0x00000000,
},
[]u32{
0x00000000,
0x80000000,
0x00000000,
},
[]u32{
0x00000000,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x00000000,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x00000000,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0x00000001,
0x00000001,
0x00000001,
},
[]u32{
0x00000001,
0x00000002,
0x00000000,
},
[]u32{
0x00000001,
0x00000003,
0x00000000,
},
[]u32{
0x00000001,
0x00000010,
0x00000000,
},
[]u32{
0x00000001,
0x078644FA,
0x00000000,
},
[]u32{
0x00000001,
0x0747AE14,
0x00000000,
},
[]u32{
0x00000001,
0x7FFFFFFF,
0x00000000,
},
[]u32{
0x00000001,
0x80000000,
0x00000000,
},
[]u32{
0x00000001,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x00000001,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x00000001,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0x00000002,
0x00000001,
0x00000002,
},
[]u32{
0x00000002,
0x00000002,
0x00000001,
},
[]u32{
0x00000002,
0x00000003,
0x00000000,
},
[]u32{
0x00000002,
0x00000010,
0x00000000,
},
[]u32{
0x00000002,
0x078644FA,
0x00000000,
},
[]u32{
0x00000002,
0x0747AE14,
0x00000000,
},
[]u32{
0x00000002,
0x7FFFFFFF,
0x00000000,
},
[]u32{
0x00000002,
0x80000000,
0x00000000,
},
[]u32{
0x00000002,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x00000002,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x00000002,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0x00000003,
0x00000001,
0x00000003,
},
[]u32{
0x00000003,
0x00000002,
0x00000001,
},
[]u32{
0x00000003,
0x00000003,
0x00000001,
},
[]u32{
0x00000003,
0x00000010,
0x00000000,
},
[]u32{
0x00000003,
0x078644FA,
0x00000000,
},
[]u32{
0x00000003,
0x0747AE14,
0x00000000,
},
[]u32{
0x00000003,
0x7FFFFFFF,
0x00000000,
},
[]u32{
0x00000003,
0x80000000,
0x00000000,
},
[]u32{
0x00000003,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x00000003,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x00000003,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0x00000010,
0x00000001,
0x00000010,
},
[]u32{
0x00000010,
0x00000002,
0x00000008,
},
[]u32{
0x00000010,
0x00000003,
0x00000005,
},
[]u32{
0x00000010,
0x00000010,
0x00000001,
},
[]u32{
0x00000010,
0x078644FA,
0x00000000,
},
[]u32{
0x00000010,
0x0747AE14,
0x00000000,
},
[]u32{
0x00000010,
0x7FFFFFFF,
0x00000000,
},
[]u32{
0x00000010,
0x80000000,
0x00000000,
},
[]u32{
0x00000010,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x00000010,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x00000010,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0x078644FA,
0x00000001,
0x078644FA,
},
[]u32{
0x078644FA,
0x00000002,
0x03C3227D,
},
[]u32{
0x078644FA,
0x00000003,
0x028216FE,
},
[]u32{
0x078644FA,
0x00000010,
0x0078644F,
},
[]u32{
0x078644FA,
0x078644FA,
0x00000001,
},
[]u32{
0x078644FA,
0x0747AE14,
0x00000001,
},
[]u32{
0x078644FA,
0x7FFFFFFF,
0x00000000,
},
[]u32{
0x078644FA,
0x80000000,
0x00000000,
},
[]u32{
0x078644FA,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x078644FA,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x078644FA,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0x0747AE14,
0x00000001,
0x0747AE14,
},
[]u32{
0x0747AE14,
0x00000002,
0x03A3D70A,
},
[]u32{
0x0747AE14,
0x00000003,
0x026D3A06,
},
[]u32{
0x0747AE14,
0x00000010,
0x00747AE1,
},
[]u32{
0x0747AE14,
0x078644FA,
0x00000000,
},
[]u32{
0x0747AE14,
0x0747AE14,
0x00000001,
},
[]u32{
0x0747AE14,
0x7FFFFFFF,
0x00000000,
},
[]u32{
0x0747AE14,
0x80000000,
0x00000000,
},
[]u32{
0x0747AE14,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x0747AE14,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x0747AE14,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0x7FFFFFFF,
0x00000001,
0x7FFFFFFF,
},
[]u32{
0x7FFFFFFF,
0x00000002,
0x3FFFFFFF,
},
[]u32{
0x7FFFFFFF,
0x00000003,
0x2AAAAAAA,
},
[]u32{
0x7FFFFFFF,
0x00000010,
0x07FFFFFF,
},
[]u32{
0x7FFFFFFF,
0x078644FA,
0x00000011,
},
[]u32{
0x7FFFFFFF,
0x0747AE14,
0x00000011,
},
[]u32{
0x7FFFFFFF,
0x7FFFFFFF,
0x00000001,
},
[]u32{
0x7FFFFFFF,
0x80000000,
0x00000000,
},
[]u32{
0x7FFFFFFF,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x7FFFFFFF,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x7FFFFFFF,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0x80000000,
0x00000001,
0x80000000,
},
[]u32{
0x80000000,
0x00000002,
0x40000000,
},
[]u32{
0x80000000,
0x00000003,
0x2AAAAAAA,
},
[]u32{
0x80000000,
0x00000010,
0x08000000,
},
[]u32{
0x80000000,
0x078644FA,
0x00000011,
},
[]u32{
0x80000000,
0x0747AE14,
0x00000011,
},
[]u32{
0x80000000,
0x7FFFFFFF,
0x00000001,
},
[]u32{
0x80000000,
0x80000000,
0x00000001,
},
[]u32{
0x80000000,
0xFFFFFFFD,
0x00000000,
},
[]u32{
0x80000000,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0x80000000,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0xFFFFFFFD,
0x00000001,
0xFFFFFFFD,
},
[]u32{
0xFFFFFFFD,
0x00000002,
0x7FFFFFFE,
},
[]u32{
0xFFFFFFFD,
0x00000003,
0x55555554,
},
[]u32{
0xFFFFFFFD,
0x00000010,
0x0FFFFFFF,
},
[]u32{
0xFFFFFFFD,
0x078644FA,
0x00000022,
},
[]u32{
0xFFFFFFFD,
0x0747AE14,
0x00000023,
},
[]u32{
0xFFFFFFFD,
0x7FFFFFFF,
0x00000001,
},
[]u32{
0xFFFFFFFD,
0x80000000,
0x00000001,
},
[]u32{
0xFFFFFFFD,
0xFFFFFFFD,
0x00000001,
},
[]u32{
0xFFFFFFFD,
0xFFFFFFFE,
0x00000000,
},
[]u32{
0xFFFFFFFD,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0xFFFFFFFE,
0x00000001,
0xFFFFFFFE,
},
[]u32{
0xFFFFFFFE,
0x00000002,
0x7FFFFFFF,
},
[]u32{
0xFFFFFFFE,
0x00000003,
0x55555554,
},
[]u32{
0xFFFFFFFE,
0x00000010,
0x0FFFFFFF,
},
[]u32{
0xFFFFFFFE,
0x078644FA,
0x00000022,
},
[]u32{
0xFFFFFFFE,
0x0747AE14,
0x00000023,
},
[]u32{
0xFFFFFFFE,
0x7FFFFFFF,
0x00000002,
},
[]u32{
0xFFFFFFFE,
0x80000000,
0x00000001,
},
[]u32{
0xFFFFFFFE,
0xFFFFFFFD,
0x00000001,
},
[]u32{
0xFFFFFFFE,
0xFFFFFFFE,
0x00000001,
},
[]u32{
0xFFFFFFFE,
0xFFFFFFFF,
0x00000000,
},
[]u32{
0xFFFFFFFF,
0x00000001,
0xFFFFFFFF,
},
[]u32{
0xFFFFFFFF,
0x00000002,
0x7FFFFFFF,
},
[]u32{
0xFFFFFFFF,
0x00000003,
0x55555555,
},
[]u32{
0xFFFFFFFF,
0x00000010,
0x0FFFFFFF,
},
[]u32{
0xFFFFFFFF,
0x078644FA,
0x00000022,
},
[]u32{
0xFFFFFFFF,
0x0747AE14,
0x00000023,
},
[]u32{
0xFFFFFFFF,
0x7FFFFFFF,
0x00000002,
},
[]u32{
0xFFFFFFFF,
0x80000000,
0x00000001,
},
[]u32{
0xFFFFFFFF,
0xFFFFFFFD,
0x00000001,
},
[]u32{
0xFFFFFFFF,
0xFFFFFFFE,
0x00000001,
},
[]u32{
0xFFFFFFFF,
0xFFFFFFFF,
0x00000001,
},
};
for (cases) |case| {
test_one_udivsi3(case[0], case[1], case[2]);
}
}
fn test_one_udivsi3(a: u32, b: u32, expected_q: u32) void {
const q: u32 = __udivsi3(a, b);
assert(q == expected_q);
} | std/special/compiler_rt/index.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
pub const Problem = struct {
allocator: Allocator,
input: [:0]const u8 = undefined,
tokenizer: ?std.mem.TokenIterator(u8) = null,
splitter: ?std.mem.SplitIterator(u8) = null,
pub fn init(year: u16, day: u16, allocator: Allocator) !Problem {
var problem = Problem { .allocator = allocator };
var buf: [32]u8 = undefined;
const filename = try std.fmt.bufPrint(&buf, "input/{}/day{:0>2}.txt", .{year, day});
const file = try std.fs.cwd().openFile(filename, .{});
defer file.close();
problem.input = try file.readToEndAllocOptions(allocator, 262144, null, @alignOf(u8), 0);
return problem;
}
pub fn deinit(self: *Problem) void {
self.allocator.free(self.input);
}
pub fn line(self: *Problem) ?[]const u8 {
if (self.tokenizer == null) {
self.tokenizer = std.mem.tokenize(u8, self.input, "\n");
}
return self.tokenizer.?.next();
}
pub fn group(self: *Problem) ?[]const u8 {
if (self.splitter == null) {
self.splitter = std.mem.split(u8, self.input, "\n\n");
}
return self.splitter.?.next();
}
pub fn solution(self: *Problem, s1: anytype, s2: anytype) Solution {
const fmt1 = comptime if (std.meta.trait.isZigString(@TypeOf(s1))) "{s}" else "{}";
const fmt2 = comptime if (std.meta.trait.isZigString(@TypeOf(s2))) "{s}" else "{}";
return .{
.s1 = std.fmt.allocPrint(self.allocator, fmt1, .{s1}) catch unreachable,
.s2 = std.fmt.allocPrint(self.allocator, fmt2, .{s2}) catch unreachable,
};
}
};
pub const Solution = struct {
s1: []const u8,
s2: []const u8,
pub fn deinit(self: *Solution, allocator: Allocator) void {
allocator.free(self.s1);
allocator.free(self.s2);
}
};
usingnamespace @import("lib/conway.zig");
usingnamespace @import("lib/coord.zig");
usingnamespace @import("lib/matrix.zig");
usingnamespace @import("lib/multimap.zig");
usingnamespace @import("lib/permutator.zig");
usingnamespace @import("lib/regex.zig");
usingnamespace @import("lib/table.zig"); | src/main/zig/aoc.zig |
const std = @import("std");
const mem = std.mem;
pub const list = @import("clang_options_data.zig").data;
pub const CliArg = struct {
name: []const u8,
syntax: Syntax,
/// TODO we're going to want to change this when we start shipping self-hosted because this causes
/// all the functions in stage2.zig to get exported.
zig_equivalent: @import("stage2.zig").ClangArgIterator.ZigEquivalent,
/// Prefixed by "-"
pd1: bool = false,
/// Prefixed by "--"
pd2: bool = false,
/// Prefixed by "/"
psl: bool = false,
pub const Syntax = union(enum) {
/// A flag with no values.
flag,
/// An option which prefixes its (single) value.
joined,
/// An option which is followed by its value.
separate,
/// An option which is either joined to its (non-empty) value, or followed by its value.
joined_or_separate,
/// An option which is both joined to its (first) value, and followed by its (second) value.
joined_and_separate,
/// An option followed by its values, which are separated by commas.
comma_joined,
/// An option which consumes an optional joined argument and any other remaining arguments.
remaining_args_joined,
/// An option which is which takes multiple (separate) arguments.
multi_arg: u8,
};
pub fn matchEql(self: CliArg, arg: []const u8) u2 {
if (self.pd1 and arg.len >= self.name.len + 1 and
mem.startsWith(u8, arg, "-") and mem.eql(u8, arg[1..], self.name))
{
return 1;
}
if (self.pd2 and arg.len >= self.name.len + 2 and
mem.startsWith(u8, arg, "--") and mem.eql(u8, arg[2..], self.name))
{
return 2;
}
if (self.psl and arg.len >= self.name.len + 1 and
mem.startsWith(u8, arg, "/") and mem.eql(u8, arg[1..], self.name))
{
return 1;
}
return 0;
}
pub fn matchStartsWith(self: CliArg, arg: []const u8) usize {
if (self.pd1 and arg.len >= self.name.len + 1 and
mem.startsWith(u8, arg, "-") and mem.startsWith(u8, arg[1..], self.name))
{
return self.name.len + 1;
}
if (self.pd2 and arg.len >= self.name.len + 2 and
mem.startsWith(u8, arg, "--") and mem.startsWith(u8, arg[2..], self.name))
{
return self.name.len + 2;
}
if (self.psl and arg.len >= self.name.len + 1 and
mem.startsWith(u8, arg, "/") and mem.startsWith(u8, arg[1..], self.name))
{
return self.name.len + 1;
}
return 0;
}
};
/// Shortcut function for initializing a `CliArg`
pub fn flagpd1(name: []const u8) CliArg {
return .{
.name = name,
.syntax = .flag,
.zig_equivalent = .other,
.pd1 = true,
};
}
/// Shortcut function for initializing a `CliArg`
pub fn joinpd1(name: []const u8) CliArg {
return .{
.name = name,
.syntax = .joined,
.zig_equivalent = .other,
.pd1 = true,
};
}
/// Shortcut function for initializing a `CliArg`
pub fn jspd1(name: []const u8) CliArg {
return .{
.name = name,
.syntax = .joined_or_separate,
.zig_equivalent = .other,
.pd1 = true,
};
}
/// Shortcut function for initializing a `CliArg`
pub fn sepd1(name: []const u8) CliArg {
return .{
.name = name,
.syntax = .separate,
.zig_equivalent = .other,
.pd1 = true,
};
} | src-self-hosted/clang_options.zig |
const std = @import("../../std.zig");
const maxInt = std.math.maxInt;
const linux = std.os.linux;
const SYS = linux.SYS;
const socklen_t = linux.socklen_t;
const iovec = std.os.iovec;
const iovec_const = std.os.iovec_const;
const uid_t = linux.uid_t;
const gid_t = linux.gid_t;
const pid_t = linux.pid_t;
const stack_t = linux.stack_t;
const sigset_t = linux.sigset_t;
const sockaddr = linux.sockaddr;
const timespec = linux.timespec;
pub fn syscall0(number: SYS) usize {
return asm volatile (
\\ sc
\\ bns+ 1f
\\ neg 3, 3
\\ 1:
: [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
);
}
pub fn syscall1(number: SYS, arg1: usize) usize {
return asm volatile (
\\ sc
\\ bns+ 1f
\\ neg 3, 3
\\ 1:
: [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
);
}
pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
return asm volatile (
\\ sc
\\ bns+ 1f
\\ neg 3, 3
\\ 1:
: [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
);
}
pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
return asm volatile (
\\ sc
\\ bns+ 1f
\\ neg 3, 3
\\ 1:
: [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
);
}
pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
return asm volatile (
\\ sc
\\ bns+ 1f
\\ neg 3, 3
\\ 1:
: [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
);
}
pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
return asm volatile (
\\ sc
\\ bns+ 1f
\\ neg 3, 3
\\ 1:
: [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4),
[arg5] "{r7}" (arg5),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
);
}
pub fn syscall6(
number: SYS,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
arg5: usize,
arg6: usize,
) usize {
return asm volatile (
\\ sc
\\ bns+ 1f
\\ neg 3, 3
\\ 1:
: [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4),
[arg5] "{r7}" (arg5),
[arg6] "{r8}" (arg6),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
);
}
/// This matches the libc clone function.
pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags: usize, arg: usize, ptid: *i32, tls: usize, ctid: *i32) usize;
pub const restore = restore_rt;
pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("sc"
:
: [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
);
}
pub const O = struct {
pub const CREAT = 0o100;
pub const EXCL = 0o200;
pub const NOCTTY = 0o400;
pub const TRUNC = 0o1000;
pub const APPEND = 0o2000;
pub const NONBLOCK = 0o4000;
pub const DSYNC = 0o10000;
pub const SYNC = 0o4010000;
pub const RSYNC = 0o4010000;
pub const DIRECTORY = 0o40000;
pub const NOFOLLOW = 0o100000;
pub const CLOEXEC = 0o2000000;
pub const ASYNC = 0o20000;
pub const DIRECT = 0o400000;
pub const LARGEFILE = 0o200000;
pub const NOATIME = 0o1000000;
pub const PATH = 0o10000000;
pub const TMPFILE = 0o20200000;
pub const NDELAY = NONBLOCK;
};
pub const F = struct {
pub const DUPFD = 0;
pub const GETFD = 1;
pub const SETFD = 2;
pub const GETFL = 3;
pub const SETFL = 4;
pub const SETOWN = 8;
pub const GETOWN = 9;
pub const SETSIG = 10;
pub const GETSIG = 11;
pub const GETLK = 5;
pub const SETLK = 6;
pub const SETLKW = 7;
pub const RDLCK = 0;
pub const WRLCK = 1;
pub const UNLCK = 2;
pub const SETOWN_EX = 15;
pub const GETOWN_EX = 16;
pub const GETOWNER_UIDS = 17;
};
pub const LOCK = struct {
pub const SH = 1;
pub const EX = 2;
pub const UN = 8;
pub const NB = 4;
};
pub const MAP = struct {
/// stack-like segment
pub const GROWSDOWN = 0x0100;
/// ETXTBSY
pub const DENYWRITE = 0x0800;
/// mark it as an executable
pub const EXECUTABLE = 0x1000;
/// pages are locked
pub const LOCKED = 0x0080;
/// don't check for reservations
pub const NORESERVE = 0x0040;
};
pub const VDSO = struct {
pub const CGT_SYM = "__kernel_clock_gettime";
pub const CGT_VER = "LINUX_2.6.15";
};
pub const Flock = extern struct {
type: i16,
whence: i16,
start: off_t,
len: off_t,
pid: pid_t,
__unused: [4]u8,
};
pub const msghdr = extern struct {
name: ?*sockaddr,
namelen: socklen_t,
iov: [*]iovec,
iovlen: usize,
control: ?*anyopaque,
controllen: usize,
flags: i32,
};
pub const msghdr_const = extern struct {
name: ?*const sockaddr,
namelen: socklen_t,
iov: [*]const iovec_const,
iovlen: usize,
control: ?*const anyopaque,
controllen: usize,
flags: i32,
};
pub const blksize_t = i64;
pub const nlink_t = u64;
pub const time_t = i64;
pub const mode_t = u32;
pub const off_t = i64;
pub const ino_t = u64;
pub const dev_t = u64;
pub const blkcnt_t = i64;
// The `stat` definition used by the Linux kernel.
pub const Stat = extern struct {
dev: dev_t,
ino: ino_t,
nlink: nlink_t,
mode: mode_t,
uid: uid_t,
gid: gid_t,
rdev: dev_t,
size: off_t,
blksize: blksize_t,
blocks: blkcnt_t,
atim: timespec,
mtim: timespec,
ctim: timespec,
__unused: [3]u64,
pub fn atime(self: @This()) timespec {
return self.atim;
}
pub fn mtime(self: @This()) timespec {
return self.mtim;
}
pub fn ctime(self: @This()) timespec {
return self.ctim;
}
};
pub const timeval = extern struct {
tv_sec: isize,
tv_usec: isize,
};
pub const timezone = extern struct {
tz_minuteswest: i32,
tz_dsttime: i32,
};
pub const greg_t = u64;
pub const gregset_t = [48]greg_t;
pub const fpregset_t = [33]f64;
/// The position of the vscr register depends on endianness.
/// On C, macros are used to change vscr_word's offset to
/// account for this. Here we'll just define vscr_word_le
/// and vscr_word_be. Code must take care to use the correct one.
pub const vrregset = extern struct {
vrregs: [32][4]u32 align(16),
vscr_word_le: u32,
_pad1: [2]u32,
vscr_word_be: u32,
vrsave: u32,
_pad2: [3]u32,
};
pub const vrregset_t = vrregset;
pub const mcontext_t = extern struct {
__unused: [4]u64,
signal: i32,
_pad0: i32,
handler: u64,
oldmask: u64,
regs: ?*anyopaque,
gp_regs: gregset_t,
fp_regs: fpregset_t,
v_regs: *vrregset_t,
vmx_reserve: [34 + 34 + 32 + 1]i64,
};
pub const ucontext_t = extern struct {
flags: u32,
link: ?*ucontext_t,
stack: stack_t,
sigmask: sigset_t,
mcontext: mcontext_t,
};
pub const Elf_Symndx = u32; | lib/std/os/linux/powerpc64.zig |
const util = @import("../sdf_util.zig");
pub const info: util.SdfInfo = .{
.name = "Triangle",
.data_size = @sizeOf(Data),
.function_definition = function_definition,
.enter_command_fn = util.surfaceEnterCommand(Data),
.exit_command_fn = util.surfaceExitCommand(Data, exitCommand),
.append_mat_check_fn = util.surfaceMatCheckCommand(Data),
.sphere_bound_fn = sphereBound,
};
pub const Data = struct {
point_a: util.math.vec3,
point_b: util.math.vec3,
point_c: util.math.vec3,
mat: usize,
};
const function_definition: []const u8 =
\\float sdTriangle(vec3 p, vec3 a, vec3 b, vec3 c){
\\ vec3 ba = b - a; vec3 pa = p - a;
\\ vec3 cb = c - b; vec3 pb = p - b;
\\ vec3 ac = a - c; vec3 pc = p - c;
\\ vec3 nor = cross(ba, ac);
\\
\\ return sqrt(
\\ (sign(dot(cross(ba,nor),pa)) +
\\ sign(dot(cross(cb,nor),pb)) +
\\ sign(dot(cross(ac,nor),pc))<2.)
\\ ?
\\ min(min(
\\ dot2(ba*clamp(dot(ba,pa)/dot2(ba),0.,1.)-pa),
\\ dot2(cb*clamp(dot(cb,pb)/dot2(cb),0.,1.)-pb)),
\\ dot2(ac*clamp(dot(ac,pc)/dot2(ac),0.,1.)-pc))
\\ :
\\ dot(nor,pa)*dot(nor,pa)/dot2(nor));
\\}
\\
;
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} = sdTriangle({s},vec3({d:.5},{d:.5},{d:.5}),vec3({d:.5},{d:.5},{d:.5}),vec3({d:.5},{d:.5},{d:.5}));";
return util.std.fmt.allocPrint(allocator, format, .{
enter_index,
cur_point_name,
data.point_a[0],
data.point_a[1],
data.point_a[2],
data.point_b[0],
data.point_b[1],
data.point_b[2],
data.point_c[0],
data.point_c[1],
data.point_c[2],
}) 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.from3Points(data.point_a, data.point_b, data.point_c);
} | src/sdf/surfaces/triangle.zig |
pub const OFN_SHAREFALLTHROUGH = @as(u32, 2);
pub const OFN_SHARENOWARN = @as(u32, 1);
pub const OFN_SHAREWARN = @as(u32, 0);
pub const CDM_FIRST = @as(u32, 1124);
pub const CDM_LAST = @as(u32, 1224);
pub const CDM_GETSPEC = @as(u32, 1124);
pub const CDM_GETFILEPATH = @as(u32, 1125);
pub const CDM_GETFOLDERPATH = @as(u32, 1126);
pub const CDM_GETFOLDERIDLIST = @as(u32, 1127);
pub const CDM_SETCONTROLTEXT = @as(u32, 1128);
pub const CDM_HIDECONTROL = @as(u32, 1129);
pub const CDM_SETDEFEXT = @as(u32, 1130);
pub const FR_RAW = @as(u32, 131072);
pub const FR_SHOWWRAPAROUND = @as(u32, 262144);
pub const FR_NOWRAPAROUND = @as(u32, 524288);
pub const FR_WRAPAROUND = @as(u32, 1048576);
pub const FRM_FIRST = @as(u32, 1124);
pub const FRM_LAST = @as(u32, 1224);
pub const FRM_SETOPERATIONRESULT = @as(u32, 1124);
pub const FRM_SETOPERATIONRESULTTEXT = @as(u32, 1125);
pub const PS_OPENTYPE_FONTTYPE = @as(u32, 65536);
pub const TT_OPENTYPE_FONTTYPE = @as(u32, 131072);
pub const TYPE1_FONTTYPE = @as(u32, 262144);
pub const SYMBOL_FONTTYPE = @as(u32, 524288);
pub const WM_CHOOSEFONT_GETLOGFONT = @as(u32, 1025);
pub const WM_CHOOSEFONT_SETLOGFONT = @as(u32, 1125);
pub const WM_CHOOSEFONT_SETFLAGS = @as(u32, 1126);
pub const CD_LBSELNOITEMS = @as(i32, -1);
pub const CD_LBSELCHANGE = @as(u32, 0);
pub const CD_LBSELSUB = @as(u32, 1);
pub const CD_LBSELADD = @as(u32, 2);
pub const START_PAGE_GENERAL = @as(u32, 4294967295);
pub const PD_RESULT_CANCEL = @as(u32, 0);
pub const PD_RESULT_PRINT = @as(u32, 1);
pub const PD_RESULT_APPLY = @as(u32, 2);
pub const DN_DEFAULTPRN = @as(u32, 1);
pub const WM_PSD_FULLPAGERECT = @as(u32, 1025);
pub const WM_PSD_MINMARGINRECT = @as(u32, 1026);
pub const WM_PSD_MARGINRECT = @as(u32, 1027);
pub const WM_PSD_GREEKTEXTRECT = @as(u32, 1028);
pub const WM_PSD_ENVSTAMPRECT = @as(u32, 1029);
pub const WM_PSD_YAFULLPAGERECT = @as(u32, 1030);
pub const DLG_COLOR = @as(u32, 10);
pub const COLOR_HUESCROLL = @as(u32, 700);
pub const COLOR_SATSCROLL = @as(u32, 701);
pub const COLOR_LUMSCROLL = @as(u32, 702);
pub const COLOR_HUE = @as(u32, 703);
pub const COLOR_SAT = @as(u32, 704);
pub const COLOR_LUM = @as(u32, 705);
pub const COLOR_RED = @as(u32, 706);
pub const COLOR_GREEN = @as(u32, 707);
pub const COLOR_BLUE = @as(u32, 708);
pub const COLOR_CURRENT = @as(u32, 709);
pub const COLOR_RAINBOW = @as(u32, 710);
pub const COLOR_SAVE = @as(u32, 711);
pub const COLOR_ADD = @as(u32, 712);
pub const COLOR_SOLID = @as(u32, 713);
pub const COLOR_TUNE = @as(u32, 714);
pub const COLOR_SCHEMES = @as(u32, 715);
pub const COLOR_ELEMENT = @as(u32, 716);
pub const COLOR_SAMPLES = @as(u32, 717);
pub const COLOR_PALETTE = @as(u32, 718);
pub const COLOR_MIX = @as(u32, 719);
pub const COLOR_BOX1 = @as(u32, 720);
pub const COLOR_CUSTOM1 = @as(u32, 721);
pub const COLOR_HUEACCEL = @as(u32, 723);
pub const COLOR_SATACCEL = @as(u32, 724);
pub const COLOR_LUMACCEL = @as(u32, 725);
pub const COLOR_REDACCEL = @as(u32, 726);
pub const COLOR_GREENACCEL = @as(u32, 727);
pub const COLOR_BLUEACCEL = @as(u32, 728);
pub const COLOR_SOLID_LEFT = @as(u32, 730);
pub const COLOR_SOLID_RIGHT = @as(u32, 731);
pub const NUM_BASIC_COLORS = @as(u32, 48);
pub const NUM_CUSTOM_COLORS = @as(u32, 16);
//--------------------------------------------------------------------------------
// Section: Types (62)
//--------------------------------------------------------------------------------
pub const COMMON_DLG_ERRORS = enum(u32) {
CDERR_DIALOGFAILURE = 65535,
CDERR_GENERALCODES = 0,
CDERR_STRUCTSIZE = 1,
CDERR_INITIALIZATION = 2,
CDERR_NOTEMPLATE = 3,
CDERR_NOHINSTANCE = 4,
CDERR_LOADSTRFAILURE = 5,
CDERR_FINDRESFAILURE = 6,
CDERR_LOADRESFAILURE = 7,
CDERR_LOCKRESFAILURE = 8,
CDERR_MEMALLOCFAILURE = 9,
CDERR_MEMLOCKFAILURE = 10,
CDERR_NOHOOK = 11,
CDERR_REGISTERMSGFAIL = 12,
PDERR_PRINTERCODES = 4096,
PDERR_SETUPFAILURE = 4097,
PDERR_PARSEFAILURE = 4098,
PDERR_RETDEFFAILURE = 4099,
PDERR_LOADDRVFAILURE = 4100,
PDERR_GETDEVMODEFAIL = 4101,
PDERR_INITFAILURE = 4102,
PDERR_NODEVICES = 4103,
PDERR_NODEFAULTPRN = 4104,
PDERR_DNDMMISMATCH = 4105,
PDERR_CREATEICFAILURE = 4106,
PDERR_PRINTERNOTFOUND = 4107,
PDERR_DEFAULTDIFFERENT = 4108,
CFERR_CHOOSEFONTCODES = 8192,
CFERR_NOFONTS = 8193,
CFERR_MAXLESSTHANMIN = 8194,
FNERR_FILENAMECODES = 12288,
FNERR_SUBCLASSFAILURE = 12289,
FNERR_INVALIDFILENAME = 12290,
FNERR_BUFFERTOOSMALL = 12291,
FRERR_FINDREPLACECODES = 16384,
FRERR_BUFFERLENGTHZERO = 16385,
CCERR_CHOOSECOLORCODES = 20480,
};
pub const CDERR_DIALOGFAILURE = COMMON_DLG_ERRORS.CDERR_DIALOGFAILURE;
pub const CDERR_GENERALCODES = COMMON_DLG_ERRORS.CDERR_GENERALCODES;
pub const CDERR_STRUCTSIZE = COMMON_DLG_ERRORS.CDERR_STRUCTSIZE;
pub const CDERR_INITIALIZATION = COMMON_DLG_ERRORS.CDERR_INITIALIZATION;
pub const CDERR_NOTEMPLATE = COMMON_DLG_ERRORS.CDERR_NOTEMPLATE;
pub const CDERR_NOHINSTANCE = COMMON_DLG_ERRORS.CDERR_NOHINSTANCE;
pub const CDERR_LOADSTRFAILURE = COMMON_DLG_ERRORS.CDERR_LOADSTRFAILURE;
pub const CDERR_FINDRESFAILURE = COMMON_DLG_ERRORS.CDERR_FINDRESFAILURE;
pub const CDERR_LOADRESFAILURE = COMMON_DLG_ERRORS.CDERR_LOADRESFAILURE;
pub const CDERR_LOCKRESFAILURE = COMMON_DLG_ERRORS.CDERR_LOCKRESFAILURE;
pub const CDERR_MEMALLOCFAILURE = COMMON_DLG_ERRORS.CDERR_MEMALLOCFAILURE;
pub const CDERR_MEMLOCKFAILURE = COMMON_DLG_ERRORS.CDERR_MEMLOCKFAILURE;
pub const CDERR_NOHOOK = COMMON_DLG_ERRORS.CDERR_NOHOOK;
pub const CDERR_REGISTERMSGFAIL = COMMON_DLG_ERRORS.CDERR_REGISTERMSGFAIL;
pub const PDERR_PRINTERCODES = COMMON_DLG_ERRORS.PDERR_PRINTERCODES;
pub const PDERR_SETUPFAILURE = COMMON_DLG_ERRORS.PDERR_SETUPFAILURE;
pub const PDERR_PARSEFAILURE = COMMON_DLG_ERRORS.PDERR_PARSEFAILURE;
pub const PDERR_RETDEFFAILURE = COMMON_DLG_ERRORS.PDERR_RETDEFFAILURE;
pub const PDERR_LOADDRVFAILURE = COMMON_DLG_ERRORS.PDERR_LOADDRVFAILURE;
pub const PDERR_GETDEVMODEFAIL = COMMON_DLG_ERRORS.PDERR_GETDEVMODEFAIL;
pub const PDERR_INITFAILURE = COMMON_DLG_ERRORS.PDERR_INITFAILURE;
pub const PDERR_NODEVICES = COMMON_DLG_ERRORS.PDERR_NODEVICES;
pub const PDERR_NODEFAULTPRN = COMMON_DLG_ERRORS.PDERR_NODEFAULTPRN;
pub const PDERR_DNDMMISMATCH = COMMON_DLG_ERRORS.PDERR_DNDMMISMATCH;
pub const PDERR_CREATEICFAILURE = COMMON_DLG_ERRORS.PDERR_CREATEICFAILURE;
pub const PDERR_PRINTERNOTFOUND = COMMON_DLG_ERRORS.PDERR_PRINTERNOTFOUND;
pub const PDERR_DEFAULTDIFFERENT = COMMON_DLG_ERRORS.PDERR_DEFAULTDIFFERENT;
pub const CFERR_CHOOSEFONTCODES = COMMON_DLG_ERRORS.CFERR_CHOOSEFONTCODES;
pub const CFERR_NOFONTS = COMMON_DLG_ERRORS.CFERR_NOFONTS;
pub const CFERR_MAXLESSTHANMIN = COMMON_DLG_ERRORS.CFERR_MAXLESSTHANMIN;
pub const FNERR_FILENAMECODES = COMMON_DLG_ERRORS.FNERR_FILENAMECODES;
pub const FNERR_SUBCLASSFAILURE = COMMON_DLG_ERRORS.FNERR_SUBCLASSFAILURE;
pub const FNERR_INVALIDFILENAME = COMMON_DLG_ERRORS.FNERR_INVALIDFILENAME;
pub const FNERR_BUFFERTOOSMALL = COMMON_DLG_ERRORS.FNERR_BUFFERTOOSMALL;
pub const FRERR_FINDREPLACECODES = COMMON_DLG_ERRORS.FRERR_FINDREPLACECODES;
pub const FRERR_BUFFERLENGTHZERO = COMMON_DLG_ERRORS.FRERR_BUFFERLENGTHZERO;
pub const CCERR_CHOOSECOLORCODES = COMMON_DLG_ERRORS.CCERR_CHOOSECOLORCODES;
pub const OPEN_FILENAME_FLAGS = enum(u32) {
READONLY = 1,
OVERWRITEPROMPT = 2,
HIDEREADONLY = 4,
NOCHANGEDIR = 8,
SHOWHELP = 16,
ENABLEHOOK = 32,
ENABLETEMPLATE = 64,
ENABLETEMPLATEHANDLE = 128,
NOVALIDATE = 256,
ALLOWMULTISELECT = 512,
EXTENSIONDIFFERENT = 1024,
PATHMUSTEXIST = 2048,
FILEMUSTEXIST = 4096,
CREATEPROMPT = 8192,
SHAREAWARE = 16384,
NOREADONLYRETURN = 32768,
NOTESTFILECREATE = 65536,
NONETWORKBUTTON = 131072,
NOLONGNAMES = 262144,
EXPLORER = 524288,
NODEREFERENCELINKS = 1048576,
LONGNAMES = 2097152,
ENABLEINCLUDENOTIFY = 4194304,
ENABLESIZING = 8388608,
DONTADDTORECENT = 33554432,
FORCESHOWHIDDEN = 268435456,
_,
pub fn initFlags(o: struct {
READONLY: u1 = 0,
OVERWRITEPROMPT: u1 = 0,
HIDEREADONLY: u1 = 0,
NOCHANGEDIR: u1 = 0,
SHOWHELP: u1 = 0,
ENABLEHOOK: u1 = 0,
ENABLETEMPLATE: u1 = 0,
ENABLETEMPLATEHANDLE: u1 = 0,
NOVALIDATE: u1 = 0,
ALLOWMULTISELECT: u1 = 0,
EXTENSIONDIFFERENT: u1 = 0,
PATHMUSTEXIST: u1 = 0,
FILEMUSTEXIST: u1 = 0,
CREATEPROMPT: u1 = 0,
SHAREAWARE: u1 = 0,
NOREADONLYRETURN: u1 = 0,
NOTESTFILECREATE: u1 = 0,
NONETWORKBUTTON: u1 = 0,
NOLONGNAMES: u1 = 0,
EXPLORER: u1 = 0,
NODEREFERENCELINKS: u1 = 0,
LONGNAMES: u1 = 0,
ENABLEINCLUDENOTIFY: u1 = 0,
ENABLESIZING: u1 = 0,
DONTADDTORECENT: u1 = 0,
FORCESHOWHIDDEN: u1 = 0,
}) OPEN_FILENAME_FLAGS {
return @intToEnum(OPEN_FILENAME_FLAGS,
(if (o.READONLY == 1) @enumToInt(OPEN_FILENAME_FLAGS.READONLY) else 0)
| (if (o.OVERWRITEPROMPT == 1) @enumToInt(OPEN_FILENAME_FLAGS.OVERWRITEPROMPT) else 0)
| (if (o.HIDEREADONLY == 1) @enumToInt(OPEN_FILENAME_FLAGS.HIDEREADONLY) else 0)
| (if (o.NOCHANGEDIR == 1) @enumToInt(OPEN_FILENAME_FLAGS.NOCHANGEDIR) else 0)
| (if (o.SHOWHELP == 1) @enumToInt(OPEN_FILENAME_FLAGS.SHOWHELP) else 0)
| (if (o.ENABLEHOOK == 1) @enumToInt(OPEN_FILENAME_FLAGS.ENABLEHOOK) else 0)
| (if (o.ENABLETEMPLATE == 1) @enumToInt(OPEN_FILENAME_FLAGS.ENABLETEMPLATE) else 0)
| (if (o.ENABLETEMPLATEHANDLE == 1) @enumToInt(OPEN_FILENAME_FLAGS.ENABLETEMPLATEHANDLE) else 0)
| (if (o.NOVALIDATE == 1) @enumToInt(OPEN_FILENAME_FLAGS.NOVALIDATE) else 0)
| (if (o.ALLOWMULTISELECT == 1) @enumToInt(OPEN_FILENAME_FLAGS.ALLOWMULTISELECT) else 0)
| (if (o.EXTENSIONDIFFERENT == 1) @enumToInt(OPEN_FILENAME_FLAGS.EXTENSIONDIFFERENT) else 0)
| (if (o.PATHMUSTEXIST == 1) @enumToInt(OPEN_FILENAME_FLAGS.PATHMUSTEXIST) else 0)
| (if (o.FILEMUSTEXIST == 1) @enumToInt(OPEN_FILENAME_FLAGS.FILEMUSTEXIST) else 0)
| (if (o.CREATEPROMPT == 1) @enumToInt(OPEN_FILENAME_FLAGS.CREATEPROMPT) else 0)
| (if (o.SHAREAWARE == 1) @enumToInt(OPEN_FILENAME_FLAGS.SHAREAWARE) else 0)
| (if (o.NOREADONLYRETURN == 1) @enumToInt(OPEN_FILENAME_FLAGS.NOREADONLYRETURN) else 0)
| (if (o.NOTESTFILECREATE == 1) @enumToInt(OPEN_FILENAME_FLAGS.NOTESTFILECREATE) else 0)
| (if (o.NONETWORKBUTTON == 1) @enumToInt(OPEN_FILENAME_FLAGS.NONETWORKBUTTON) else 0)
| (if (o.NOLONGNAMES == 1) @enumToInt(OPEN_FILENAME_FLAGS.NOLONGNAMES) else 0)
| (if (o.EXPLORER == 1) @enumToInt(OPEN_FILENAME_FLAGS.EXPLORER) else 0)
| (if (o.NODEREFERENCELINKS == 1) @enumToInt(OPEN_FILENAME_FLAGS.NODEREFERENCELINKS) else 0)
| (if (o.LONGNAMES == 1) @enumToInt(OPEN_FILENAME_FLAGS.LONGNAMES) else 0)
| (if (o.ENABLEINCLUDENOTIFY == 1) @enumToInt(OPEN_FILENAME_FLAGS.ENABLEINCLUDENOTIFY) else 0)
| (if (o.ENABLESIZING == 1) @enumToInt(OPEN_FILENAME_FLAGS.ENABLESIZING) else 0)
| (if (o.DONTADDTORECENT == 1) @enumToInt(OPEN_FILENAME_FLAGS.DONTADDTORECENT) else 0)
| (if (o.FORCESHOWHIDDEN == 1) @enumToInt(OPEN_FILENAME_FLAGS.FORCESHOWHIDDEN) else 0)
);
}
};
pub const OFN_READONLY = OPEN_FILENAME_FLAGS.READONLY;
pub const OFN_OVERWRITEPROMPT = OPEN_FILENAME_FLAGS.OVERWRITEPROMPT;
pub const OFN_HIDEREADONLY = OPEN_FILENAME_FLAGS.HIDEREADONLY;
pub const OFN_NOCHANGEDIR = OPEN_FILENAME_FLAGS.NOCHANGEDIR;
pub const OFN_SHOWHELP = OPEN_FILENAME_FLAGS.SHOWHELP;
pub const OFN_ENABLEHOOK = OPEN_FILENAME_FLAGS.ENABLEHOOK;
pub const OFN_ENABLETEMPLATE = OPEN_FILENAME_FLAGS.ENABLETEMPLATE;
pub const OFN_ENABLETEMPLATEHANDLE = OPEN_FILENAME_FLAGS.ENABLETEMPLATEHANDLE;
pub const OFN_NOVALIDATE = OPEN_FILENAME_FLAGS.NOVALIDATE;
pub const OFN_ALLOWMULTISELECT = OPEN_FILENAME_FLAGS.ALLOWMULTISELECT;
pub const OFN_EXTENSIONDIFFERENT = OPEN_FILENAME_FLAGS.EXTENSIONDIFFERENT;
pub const OFN_PATHMUSTEXIST = OPEN_FILENAME_FLAGS.PATHMUSTEXIST;
pub const OFN_FILEMUSTEXIST = OPEN_FILENAME_FLAGS.FILEMUSTEXIST;
pub const OFN_CREATEPROMPT = OPEN_FILENAME_FLAGS.CREATEPROMPT;
pub const OFN_SHAREAWARE = OPEN_FILENAME_FLAGS.SHAREAWARE;
pub const OFN_NOREADONLYRETURN = OPEN_FILENAME_FLAGS.NOREADONLYRETURN;
pub const OFN_NOTESTFILECREATE = OPEN_FILENAME_FLAGS.NOTESTFILECREATE;
pub const OFN_NONETWORKBUTTON = OPEN_FILENAME_FLAGS.NONETWORKBUTTON;
pub const OFN_NOLONGNAMES = OPEN_FILENAME_FLAGS.NOLONGNAMES;
pub const OFN_EXPLORER = OPEN_FILENAME_FLAGS.EXPLORER;
pub const OFN_NODEREFERENCELINKS = OPEN_FILENAME_FLAGS.NODEREFERENCELINKS;
pub const OFN_LONGNAMES = OPEN_FILENAME_FLAGS.LONGNAMES;
pub const OFN_ENABLEINCLUDENOTIFY = OPEN_FILENAME_FLAGS.ENABLEINCLUDENOTIFY;
pub const OFN_ENABLESIZING = OPEN_FILENAME_FLAGS.ENABLESIZING;
pub const OFN_DONTADDTORECENT = OPEN_FILENAME_FLAGS.DONTADDTORECENT;
pub const OFN_FORCESHOWHIDDEN = OPEN_FILENAME_FLAGS.FORCESHOWHIDDEN;
pub const OPEN_FILENAME_FLAGS_EX = enum(u32) {
NE = 0,
PLACESBAR = 1,
_,
pub fn initFlags(o: struct {
NE: u1 = 0,
PLACESBAR: u1 = 0,
}) OPEN_FILENAME_FLAGS_EX {
return @intToEnum(OPEN_FILENAME_FLAGS_EX,
(if (o.NE == 1) @enumToInt(OPEN_FILENAME_FLAGS_EX.NE) else 0)
| (if (o.PLACESBAR == 1) @enumToInt(OPEN_FILENAME_FLAGS_EX.PLACESBAR) else 0)
);
}
};
pub const OFN_EX_NONE = OPEN_FILENAME_FLAGS_EX.NE;
pub const OFN_EX_NOPLACESBAR = OPEN_FILENAME_FLAGS_EX.PLACESBAR;
pub const PAGESETUPDLG_FLAGS = enum(u32) {
DEFAULTMINMARGINS = 0,
DISABLEMARGINS = 16,
DISABLEORIENTATION = 256,
DISABLEPAGEPAINTING = 524288,
DISABLEPAPER = 512,
DISABLEPRINTER = 32,
ENABLEPAGEPAINTHOOK = 262144,
ENABLEPAGESETUPHOOK = 8192,
ENABLEPAGESETUPTEMPLATE = 32768,
ENABLEPAGESETUPTEMPLATEHANDLE = 131072,
INHUNDREDTHSOFMILLIMETERS = 8,
INTHOUSANDTHSOFINCHES = 4,
// INWININIINTLMEASURE = 0, this enum value conflicts with DEFAULTMINMARGINS
MARGINS = 2,
MINMARGINS = 1,
NONETWORKBUTTON = 2097152,
NOWARNING = 128,
RETURNDEFAULT = 1024,
SHOWHELP = 2048,
_,
pub fn initFlags(o: struct {
DEFAULTMINMARGINS: u1 = 0,
DISABLEMARGINS: u1 = 0,
DISABLEORIENTATION: u1 = 0,
DISABLEPAGEPAINTING: u1 = 0,
DISABLEPAPER: u1 = 0,
DISABLEPRINTER: u1 = 0,
ENABLEPAGEPAINTHOOK: u1 = 0,
ENABLEPAGESETUPHOOK: u1 = 0,
ENABLEPAGESETUPTEMPLATE: u1 = 0,
ENABLEPAGESETUPTEMPLATEHANDLE: u1 = 0,
INHUNDREDTHSOFMILLIMETERS: u1 = 0,
INTHOUSANDTHSOFINCHES: u1 = 0,
MARGINS: u1 = 0,
MINMARGINS: u1 = 0,
NONETWORKBUTTON: u1 = 0,
NOWARNING: u1 = 0,
RETURNDEFAULT: u1 = 0,
SHOWHELP: u1 = 0,
}) PAGESETUPDLG_FLAGS {
return @intToEnum(PAGESETUPDLG_FLAGS,
(if (o.DEFAULTMINMARGINS == 1) @enumToInt(PAGESETUPDLG_FLAGS.DEFAULTMINMARGINS) else 0)
| (if (o.DISABLEMARGINS == 1) @enumToInt(PAGESETUPDLG_FLAGS.DISABLEMARGINS) else 0)
| (if (o.DISABLEORIENTATION == 1) @enumToInt(PAGESETUPDLG_FLAGS.DISABLEORIENTATION) else 0)
| (if (o.DISABLEPAGEPAINTING == 1) @enumToInt(PAGESETUPDLG_FLAGS.DISABLEPAGEPAINTING) else 0)
| (if (o.DISABLEPAPER == 1) @enumToInt(PAGESETUPDLG_FLAGS.DISABLEPAPER) else 0)
| (if (o.DISABLEPRINTER == 1) @enumToInt(PAGESETUPDLG_FLAGS.DISABLEPRINTER) else 0)
| (if (o.ENABLEPAGEPAINTHOOK == 1) @enumToInt(PAGESETUPDLG_FLAGS.ENABLEPAGEPAINTHOOK) else 0)
| (if (o.ENABLEPAGESETUPHOOK == 1) @enumToInt(PAGESETUPDLG_FLAGS.ENABLEPAGESETUPHOOK) else 0)
| (if (o.ENABLEPAGESETUPTEMPLATE == 1) @enumToInt(PAGESETUPDLG_FLAGS.ENABLEPAGESETUPTEMPLATE) else 0)
| (if (o.ENABLEPAGESETUPTEMPLATEHANDLE == 1) @enumToInt(PAGESETUPDLG_FLAGS.ENABLEPAGESETUPTEMPLATEHANDLE) else 0)
| (if (o.INHUNDREDTHSOFMILLIMETERS == 1) @enumToInt(PAGESETUPDLG_FLAGS.INHUNDREDTHSOFMILLIMETERS) else 0)
| (if (o.INTHOUSANDTHSOFINCHES == 1) @enumToInt(PAGESETUPDLG_FLAGS.INTHOUSANDTHSOFINCHES) else 0)
| (if (o.MARGINS == 1) @enumToInt(PAGESETUPDLG_FLAGS.MARGINS) else 0)
| (if (o.MINMARGINS == 1) @enumToInt(PAGESETUPDLG_FLAGS.MINMARGINS) else 0)
| (if (o.NONETWORKBUTTON == 1) @enumToInt(PAGESETUPDLG_FLAGS.NONETWORKBUTTON) else 0)
| (if (o.NOWARNING == 1) @enumToInt(PAGESETUPDLG_FLAGS.NOWARNING) else 0)
| (if (o.RETURNDEFAULT == 1) @enumToInt(PAGESETUPDLG_FLAGS.RETURNDEFAULT) else 0)
| (if (o.SHOWHELP == 1) @enumToInt(PAGESETUPDLG_FLAGS.SHOWHELP) else 0)
);
}
};
pub const PSD_DEFAULTMINMARGINS = PAGESETUPDLG_FLAGS.DEFAULTMINMARGINS;
pub const PSD_DISABLEMARGINS = PAGESETUPDLG_FLAGS.DISABLEMARGINS;
pub const PSD_DISABLEORIENTATION = PAGESETUPDLG_FLAGS.DISABLEORIENTATION;
pub const PSD_DISABLEPAGEPAINTING = PAGESETUPDLG_FLAGS.DISABLEPAGEPAINTING;
pub const PSD_DISABLEPAPER = PAGESETUPDLG_FLAGS.DISABLEPAPER;
pub const PSD_DISABLEPRINTER = PAGESETUPDLG_FLAGS.DISABLEPRINTER;
pub const PSD_ENABLEPAGEPAINTHOOK = PAGESETUPDLG_FLAGS.ENABLEPAGEPAINTHOOK;
pub const PSD_ENABLEPAGESETUPHOOK = PAGESETUPDLG_FLAGS.ENABLEPAGESETUPHOOK;
pub const PSD_ENABLEPAGESETUPTEMPLATE = PAGESETUPDLG_FLAGS.ENABLEPAGESETUPTEMPLATE;
pub const PSD_ENABLEPAGESETUPTEMPLATEHANDLE = PAGESETUPDLG_FLAGS.ENABLEPAGESETUPTEMPLATEHANDLE;
pub const PSD_INHUNDREDTHSOFMILLIMETERS = PAGESETUPDLG_FLAGS.INHUNDREDTHSOFMILLIMETERS;
pub const PSD_INTHOUSANDTHSOFINCHES = PAGESETUPDLG_FLAGS.INTHOUSANDTHSOFINCHES;
pub const PSD_INWININIINTLMEASURE = PAGESETUPDLG_FLAGS.DEFAULTMINMARGINS;
pub const PSD_MARGINS = PAGESETUPDLG_FLAGS.MARGINS;
pub const PSD_MINMARGINS = PAGESETUPDLG_FLAGS.MINMARGINS;
pub const PSD_NONETWORKBUTTON = PAGESETUPDLG_FLAGS.NONETWORKBUTTON;
pub const PSD_NOWARNING = PAGESETUPDLG_FLAGS.NOWARNING;
pub const PSD_RETURNDEFAULT = PAGESETUPDLG_FLAGS.RETURNDEFAULT;
pub const PSD_SHOWHELP = PAGESETUPDLG_FLAGS.SHOWHELP;
pub const CHOOSEFONT_FLAGS = enum(u32) {
APPLY = 512,
ANSIONLY = 1024,
BOTH = 3,
EFFECTS = 256,
ENABLEHOOK = 8,
ENABLETEMPLATE = 16,
ENABLETEMPLATEHANDLE = 32,
FIXEDPITCHONLY = 16384,
FORCEFONTEXIST = 65536,
INACTIVEFONTS = 33554432,
INITTOLOGFONTSTRUCT = 64,
LIMITSIZE = 8192,
NOOEMFONTS = 2048,
NOFACESEL = 524288,
NOSCRIPTSEL = 8388608,
NOSIMULATIONS = 4096,
NOSIZESEL = 2097152,
NOSTYLESEL = 1048576,
// NOVECTORFONTS = 2048, this enum value conflicts with NOOEMFONTS
NOVERTFONTS = 16777216,
PRINTERFONTS = 2,
SCALABLEONLY = 131072,
SCREENFONTS = 1,
// SCRIPTSONLY = 1024, this enum value conflicts with ANSIONLY
SELECTSCRIPT = 4194304,
SHOWHELP = 4,
TTONLY = 262144,
USESTYLE = 128,
WYSIWYG = 32768,
_,
pub fn initFlags(o: struct {
APPLY: u1 = 0,
ANSIONLY: u1 = 0,
BOTH: u1 = 0,
EFFECTS: u1 = 0,
ENABLEHOOK: u1 = 0,
ENABLETEMPLATE: u1 = 0,
ENABLETEMPLATEHANDLE: u1 = 0,
FIXEDPITCHONLY: u1 = 0,
FORCEFONTEXIST: u1 = 0,
INACTIVEFONTS: u1 = 0,
INITTOLOGFONTSTRUCT: u1 = 0,
LIMITSIZE: u1 = 0,
NOOEMFONTS: u1 = 0,
NOFACESEL: u1 = 0,
NOSCRIPTSEL: u1 = 0,
NOSIMULATIONS: u1 = 0,
NOSIZESEL: u1 = 0,
NOSTYLESEL: u1 = 0,
NOVERTFONTS: u1 = 0,
PRINTERFONTS: u1 = 0,
SCALABLEONLY: u1 = 0,
SCREENFONTS: u1 = 0,
SELECTSCRIPT: u1 = 0,
SHOWHELP: u1 = 0,
TTONLY: u1 = 0,
USESTYLE: u1 = 0,
WYSIWYG: u1 = 0,
}) CHOOSEFONT_FLAGS {
return @intToEnum(CHOOSEFONT_FLAGS,
(if (o.APPLY == 1) @enumToInt(CHOOSEFONT_FLAGS.APPLY) else 0)
| (if (o.ANSIONLY == 1) @enumToInt(CHOOSEFONT_FLAGS.ANSIONLY) else 0)
| (if (o.BOTH == 1) @enumToInt(CHOOSEFONT_FLAGS.BOTH) else 0)
| (if (o.EFFECTS == 1) @enumToInt(CHOOSEFONT_FLAGS.EFFECTS) else 0)
| (if (o.ENABLEHOOK == 1) @enumToInt(CHOOSEFONT_FLAGS.ENABLEHOOK) else 0)
| (if (o.ENABLETEMPLATE == 1) @enumToInt(CHOOSEFONT_FLAGS.ENABLETEMPLATE) else 0)
| (if (o.ENABLETEMPLATEHANDLE == 1) @enumToInt(CHOOSEFONT_FLAGS.ENABLETEMPLATEHANDLE) else 0)
| (if (o.FIXEDPITCHONLY == 1) @enumToInt(CHOOSEFONT_FLAGS.FIXEDPITCHONLY) else 0)
| (if (o.FORCEFONTEXIST == 1) @enumToInt(CHOOSEFONT_FLAGS.FORCEFONTEXIST) else 0)
| (if (o.INACTIVEFONTS == 1) @enumToInt(CHOOSEFONT_FLAGS.INACTIVEFONTS) else 0)
| (if (o.INITTOLOGFONTSTRUCT == 1) @enumToInt(CHOOSEFONT_FLAGS.INITTOLOGFONTSTRUCT) else 0)
| (if (o.LIMITSIZE == 1) @enumToInt(CHOOSEFONT_FLAGS.LIMITSIZE) else 0)
| (if (o.NOOEMFONTS == 1) @enumToInt(CHOOSEFONT_FLAGS.NOOEMFONTS) else 0)
| (if (o.NOFACESEL == 1) @enumToInt(CHOOSEFONT_FLAGS.NOFACESEL) else 0)
| (if (o.NOSCRIPTSEL == 1) @enumToInt(CHOOSEFONT_FLAGS.NOSCRIPTSEL) else 0)
| (if (o.NOSIMULATIONS == 1) @enumToInt(CHOOSEFONT_FLAGS.NOSIMULATIONS) else 0)
| (if (o.NOSIZESEL == 1) @enumToInt(CHOOSEFONT_FLAGS.NOSIZESEL) else 0)
| (if (o.NOSTYLESEL == 1) @enumToInt(CHOOSEFONT_FLAGS.NOSTYLESEL) else 0)
| (if (o.NOVERTFONTS == 1) @enumToInt(CHOOSEFONT_FLAGS.NOVERTFONTS) else 0)
| (if (o.PRINTERFONTS == 1) @enumToInt(CHOOSEFONT_FLAGS.PRINTERFONTS) else 0)
| (if (o.SCALABLEONLY == 1) @enumToInt(CHOOSEFONT_FLAGS.SCALABLEONLY) else 0)
| (if (o.SCREENFONTS == 1) @enumToInt(CHOOSEFONT_FLAGS.SCREENFONTS) else 0)
| (if (o.SELECTSCRIPT == 1) @enumToInt(CHOOSEFONT_FLAGS.SELECTSCRIPT) else 0)
| (if (o.SHOWHELP == 1) @enumToInt(CHOOSEFONT_FLAGS.SHOWHELP) else 0)
| (if (o.TTONLY == 1) @enumToInt(CHOOSEFONT_FLAGS.TTONLY) else 0)
| (if (o.USESTYLE == 1) @enumToInt(CHOOSEFONT_FLAGS.USESTYLE) else 0)
| (if (o.WYSIWYG == 1) @enumToInt(CHOOSEFONT_FLAGS.WYSIWYG) else 0)
);
}
};
pub const CF_APPLY = CHOOSEFONT_FLAGS.APPLY;
pub const CF_ANSIONLY = CHOOSEFONT_FLAGS.ANSIONLY;
pub const CF_BOTH = CHOOSEFONT_FLAGS.BOTH;
pub const CF_EFFECTS = CHOOSEFONT_FLAGS.EFFECTS;
pub const CF_ENABLEHOOK = CHOOSEFONT_FLAGS.ENABLEHOOK;
pub const CF_ENABLETEMPLATE = CHOOSEFONT_FLAGS.ENABLETEMPLATE;
pub const CF_ENABLETEMPLATEHANDLE = CHOOSEFONT_FLAGS.ENABLETEMPLATEHANDLE;
pub const CF_FIXEDPITCHONLY = CHOOSEFONT_FLAGS.FIXEDPITCHONLY;
pub const CF_FORCEFONTEXIST = CHOOSEFONT_FLAGS.FORCEFONTEXIST;
pub const CF_INACTIVEFONTS = CHOOSEFONT_FLAGS.INACTIVEFONTS;
pub const CF_INITTOLOGFONTSTRUCT = CHOOSEFONT_FLAGS.INITTOLOGFONTSTRUCT;
pub const CF_LIMITSIZE = CHOOSEFONT_FLAGS.LIMITSIZE;
pub const CF_NOOEMFONTS = CHOOSEFONT_FLAGS.NOOEMFONTS;
pub const CF_NOFACESEL = CHOOSEFONT_FLAGS.NOFACESEL;
pub const CF_NOSCRIPTSEL = CHOOSEFONT_FLAGS.NOSCRIPTSEL;
pub const CF_NOSIMULATIONS = CHOOSEFONT_FLAGS.NOSIMULATIONS;
pub const CF_NOSIZESEL = CHOOSEFONT_FLAGS.NOSIZESEL;
pub const CF_NOSTYLESEL = CHOOSEFONT_FLAGS.NOSTYLESEL;
pub const CF_NOVECTORFONTS = CHOOSEFONT_FLAGS.NOOEMFONTS;
pub const CF_NOVERTFONTS = CHOOSEFONT_FLAGS.NOVERTFONTS;
pub const CF_PRINTERFONTS = CHOOSEFONT_FLAGS.PRINTERFONTS;
pub const CF_SCALABLEONLY = CHOOSEFONT_FLAGS.SCALABLEONLY;
pub const CF_SCREENFONTS = CHOOSEFONT_FLAGS.SCREENFONTS;
pub const CF_SCRIPTSONLY = CHOOSEFONT_FLAGS.ANSIONLY;
pub const CF_SELECTSCRIPT = CHOOSEFONT_FLAGS.SELECTSCRIPT;
pub const CF_SHOWHELP = CHOOSEFONT_FLAGS.SHOWHELP;
pub const CF_TTONLY = CHOOSEFONT_FLAGS.TTONLY;
pub const CF_USESTYLE = CHOOSEFONT_FLAGS.USESTYLE;
pub const CF_WYSIWYG = CHOOSEFONT_FLAGS.WYSIWYG;
pub const FINDREPLACE_FLAGS = enum(u32) {
DIALOGTERM = 64,
DOWN = 1,
ENABLEHOOK = 256,
ENABLETEMPLATE = 512,
ENABLETEMPLATEHANDLE = 8192,
FINDNEXT = 8,
HIDEUPDOWN = 16384,
HIDEMATCHCASE = 32768,
HIDEWHOLEWORD = 65536,
MATCHCASE = 4,
NOMATCHCASE = 2048,
NOUPDOWN = 1024,
NOWHOLEWORD = 4096,
REPLACE = 16,
REPLACEALL = 32,
SHOWHELP = 128,
WHOLEWORD = 2,
_,
pub fn initFlags(o: struct {
DIALOGTERM: u1 = 0,
DOWN: u1 = 0,
ENABLEHOOK: u1 = 0,
ENABLETEMPLATE: u1 = 0,
ENABLETEMPLATEHANDLE: u1 = 0,
FINDNEXT: u1 = 0,
HIDEUPDOWN: u1 = 0,
HIDEMATCHCASE: u1 = 0,
HIDEWHOLEWORD: u1 = 0,
MATCHCASE: u1 = 0,
NOMATCHCASE: u1 = 0,
NOUPDOWN: u1 = 0,
NOWHOLEWORD: u1 = 0,
REPLACE: u1 = 0,
REPLACEALL: u1 = 0,
SHOWHELP: u1 = 0,
WHOLEWORD: u1 = 0,
}) FINDREPLACE_FLAGS {
return @intToEnum(FINDREPLACE_FLAGS,
(if (o.DIALOGTERM == 1) @enumToInt(FINDREPLACE_FLAGS.DIALOGTERM) else 0)
| (if (o.DOWN == 1) @enumToInt(FINDREPLACE_FLAGS.DOWN) else 0)
| (if (o.ENABLEHOOK == 1) @enumToInt(FINDREPLACE_FLAGS.ENABLEHOOK) else 0)
| (if (o.ENABLETEMPLATE == 1) @enumToInt(FINDREPLACE_FLAGS.ENABLETEMPLATE) else 0)
| (if (o.ENABLETEMPLATEHANDLE == 1) @enumToInt(FINDREPLACE_FLAGS.ENABLETEMPLATEHANDLE) else 0)
| (if (o.FINDNEXT == 1) @enumToInt(FINDREPLACE_FLAGS.FINDNEXT) else 0)
| (if (o.HIDEUPDOWN == 1) @enumToInt(FINDREPLACE_FLAGS.HIDEUPDOWN) else 0)
| (if (o.HIDEMATCHCASE == 1) @enumToInt(FINDREPLACE_FLAGS.HIDEMATCHCASE) else 0)
| (if (o.HIDEWHOLEWORD == 1) @enumToInt(FINDREPLACE_FLAGS.HIDEWHOLEWORD) else 0)
| (if (o.MATCHCASE == 1) @enumToInt(FINDREPLACE_FLAGS.MATCHCASE) else 0)
| (if (o.NOMATCHCASE == 1) @enumToInt(FINDREPLACE_FLAGS.NOMATCHCASE) else 0)
| (if (o.NOUPDOWN == 1) @enumToInt(FINDREPLACE_FLAGS.NOUPDOWN) else 0)
| (if (o.NOWHOLEWORD == 1) @enumToInt(FINDREPLACE_FLAGS.NOWHOLEWORD) else 0)
| (if (o.REPLACE == 1) @enumToInt(FINDREPLACE_FLAGS.REPLACE) else 0)
| (if (o.REPLACEALL == 1) @enumToInt(FINDREPLACE_FLAGS.REPLACEALL) else 0)
| (if (o.SHOWHELP == 1) @enumToInt(FINDREPLACE_FLAGS.SHOWHELP) else 0)
| (if (o.WHOLEWORD == 1) @enumToInt(FINDREPLACE_FLAGS.WHOLEWORD) else 0)
);
}
};
pub const FR_DIALOGTERM = FINDREPLACE_FLAGS.DIALOGTERM;
pub const FR_DOWN = FINDREPLACE_FLAGS.DOWN;
pub const FR_ENABLEHOOK = FINDREPLACE_FLAGS.ENABLEHOOK;
pub const FR_ENABLETEMPLATE = FINDREPLACE_FLAGS.ENABLETEMPLATE;
pub const FR_ENABLETEMPLATEHANDLE = FINDREPLACE_FLAGS.ENABLETEMPLATEHANDLE;
pub const FR_FINDNEXT = FINDREPLACE_FLAGS.FINDNEXT;
pub const FR_HIDEUPDOWN = FINDREPLACE_FLAGS.HIDEUPDOWN;
pub const FR_HIDEMATCHCASE = FINDREPLACE_FLAGS.HIDEMATCHCASE;
pub const FR_HIDEWHOLEWORD = FINDREPLACE_FLAGS.HIDEWHOLEWORD;
pub const FR_MATCHCASE = FINDREPLACE_FLAGS.MATCHCASE;
pub const FR_NOMATCHCASE = FINDREPLACE_FLAGS.NOMATCHCASE;
pub const FR_NOUPDOWN = FINDREPLACE_FLAGS.NOUPDOWN;
pub const FR_NOWHOLEWORD = FINDREPLACE_FLAGS.NOWHOLEWORD;
pub const FR_REPLACE = FINDREPLACE_FLAGS.REPLACE;
pub const FR_REPLACEALL = FINDREPLACE_FLAGS.REPLACEALL;
pub const FR_SHOWHELP = FINDREPLACE_FLAGS.SHOWHELP;
pub const FR_WHOLEWORD = FINDREPLACE_FLAGS.WHOLEWORD;
pub const PRINTDLGEX_FLAGS = enum(u32) {
ALLPAGES = 0,
COLLATE = 16,
CURRENTPAGE = 4194304,
DISABLEPRINTTOFILE = 524288,
ENABLEPRINTTEMPLATE = 16384,
ENABLEPRINTTEMPLATEHANDLE = 65536,
EXCLUSIONFLAGS = 16777216,
HIDEPRINTTOFILE = 1048576,
NOCURRENTPAGE = 8388608,
NOPAGENUMS = 8,
NOSELECTION = 4,
NOWARNING = 128,
PAGENUMS = 2,
PRINTTOFILE = 32,
RETURNDC = 256,
RETURNDEFAULT = 1024,
RETURNIC = 512,
SELECTION = 1,
USEDEVMODECOPIES = 262144,
// USEDEVMODECOPIESANDCOLLATE = 262144, this enum value conflicts with USEDEVMODECOPIES
USELARGETEMPLATE = 268435456,
ENABLEPRINTHOOK = 4096,
ENABLESETUPHOOK = 8192,
ENABLESETUPTEMPLATE = 32768,
ENABLESETUPTEMPLATEHANDLE = 131072,
NONETWORKBUTTON = 2097152,
PRINTSETUP = 64,
SHOWHELP = 2048,
_,
pub fn initFlags(o: struct {
ALLPAGES: u1 = 0,
COLLATE: u1 = 0,
CURRENTPAGE: u1 = 0,
DISABLEPRINTTOFILE: u1 = 0,
ENABLEPRINTTEMPLATE: u1 = 0,
ENABLEPRINTTEMPLATEHANDLE: u1 = 0,
EXCLUSIONFLAGS: u1 = 0,
HIDEPRINTTOFILE: u1 = 0,
NOCURRENTPAGE: u1 = 0,
NOPAGENUMS: u1 = 0,
NOSELECTION: u1 = 0,
NOWARNING: u1 = 0,
PAGENUMS: u1 = 0,
PRINTTOFILE: u1 = 0,
RETURNDC: u1 = 0,
RETURNDEFAULT: u1 = 0,
RETURNIC: u1 = 0,
SELECTION: u1 = 0,
USEDEVMODECOPIES: u1 = 0,
USELARGETEMPLATE: u1 = 0,
ENABLEPRINTHOOK: u1 = 0,
ENABLESETUPHOOK: u1 = 0,
ENABLESETUPTEMPLATE: u1 = 0,
ENABLESETUPTEMPLATEHANDLE: u1 = 0,
NONETWORKBUTTON: u1 = 0,
PRINTSETUP: u1 = 0,
SHOWHELP: u1 = 0,
}) PRINTDLGEX_FLAGS {
return @intToEnum(PRINTDLGEX_FLAGS,
(if (o.ALLPAGES == 1) @enumToInt(PRINTDLGEX_FLAGS.ALLPAGES) else 0)
| (if (o.COLLATE == 1) @enumToInt(PRINTDLGEX_FLAGS.COLLATE) else 0)
| (if (o.CURRENTPAGE == 1) @enumToInt(PRINTDLGEX_FLAGS.CURRENTPAGE) else 0)
| (if (o.DISABLEPRINTTOFILE == 1) @enumToInt(PRINTDLGEX_FLAGS.DISABLEPRINTTOFILE) else 0)
| (if (o.ENABLEPRINTTEMPLATE == 1) @enumToInt(PRINTDLGEX_FLAGS.ENABLEPRINTTEMPLATE) else 0)
| (if (o.ENABLEPRINTTEMPLATEHANDLE == 1) @enumToInt(PRINTDLGEX_FLAGS.ENABLEPRINTTEMPLATEHANDLE) else 0)
| (if (o.EXCLUSIONFLAGS == 1) @enumToInt(PRINTDLGEX_FLAGS.EXCLUSIONFLAGS) else 0)
| (if (o.HIDEPRINTTOFILE == 1) @enumToInt(PRINTDLGEX_FLAGS.HIDEPRINTTOFILE) else 0)
| (if (o.NOCURRENTPAGE == 1) @enumToInt(PRINTDLGEX_FLAGS.NOCURRENTPAGE) else 0)
| (if (o.NOPAGENUMS == 1) @enumToInt(PRINTDLGEX_FLAGS.NOPAGENUMS) else 0)
| (if (o.NOSELECTION == 1) @enumToInt(PRINTDLGEX_FLAGS.NOSELECTION) else 0)
| (if (o.NOWARNING == 1) @enumToInt(PRINTDLGEX_FLAGS.NOWARNING) else 0)
| (if (o.PAGENUMS == 1) @enumToInt(PRINTDLGEX_FLAGS.PAGENUMS) else 0)
| (if (o.PRINTTOFILE == 1) @enumToInt(PRINTDLGEX_FLAGS.PRINTTOFILE) else 0)
| (if (o.RETURNDC == 1) @enumToInt(PRINTDLGEX_FLAGS.RETURNDC) else 0)
| (if (o.RETURNDEFAULT == 1) @enumToInt(PRINTDLGEX_FLAGS.RETURNDEFAULT) else 0)
| (if (o.RETURNIC == 1) @enumToInt(PRINTDLGEX_FLAGS.RETURNIC) else 0)
| (if (o.SELECTION == 1) @enumToInt(PRINTDLGEX_FLAGS.SELECTION) else 0)
| (if (o.USEDEVMODECOPIES == 1) @enumToInt(PRINTDLGEX_FLAGS.USEDEVMODECOPIES) else 0)
| (if (o.USELARGETEMPLATE == 1) @enumToInt(PRINTDLGEX_FLAGS.USELARGETEMPLATE) else 0)
| (if (o.ENABLEPRINTHOOK == 1) @enumToInt(PRINTDLGEX_FLAGS.ENABLEPRINTHOOK) else 0)
| (if (o.ENABLESETUPHOOK == 1) @enumToInt(PRINTDLGEX_FLAGS.ENABLESETUPHOOK) else 0)
| (if (o.ENABLESETUPTEMPLATE == 1) @enumToInt(PRINTDLGEX_FLAGS.ENABLESETUPTEMPLATE) else 0)
| (if (o.ENABLESETUPTEMPLATEHANDLE == 1) @enumToInt(PRINTDLGEX_FLAGS.ENABLESETUPTEMPLATEHANDLE) else 0)
| (if (o.NONETWORKBUTTON == 1) @enumToInt(PRINTDLGEX_FLAGS.NONETWORKBUTTON) else 0)
| (if (o.PRINTSETUP == 1) @enumToInt(PRINTDLGEX_FLAGS.PRINTSETUP) else 0)
| (if (o.SHOWHELP == 1) @enumToInt(PRINTDLGEX_FLAGS.SHOWHELP) else 0)
);
}
};
pub const PD_ALLPAGES = PRINTDLGEX_FLAGS.ALLPAGES;
pub const PD_COLLATE = PRINTDLGEX_FLAGS.COLLATE;
pub const PD_CURRENTPAGE = PRINTDLGEX_FLAGS.CURRENTPAGE;
pub const PD_DISABLEPRINTTOFILE = PRINTDLGEX_FLAGS.DISABLEPRINTTOFILE;
pub const PD_ENABLEPRINTTEMPLATE = PRINTDLGEX_FLAGS.ENABLEPRINTTEMPLATE;
pub const PD_ENABLEPRINTTEMPLATEHANDLE = PRINTDLGEX_FLAGS.ENABLEPRINTTEMPLATEHANDLE;
pub const PD_EXCLUSIONFLAGS = PRINTDLGEX_FLAGS.EXCLUSIONFLAGS;
pub const PD_HIDEPRINTTOFILE = PRINTDLGEX_FLAGS.HIDEPRINTTOFILE;
pub const PD_NOCURRENTPAGE = PRINTDLGEX_FLAGS.NOCURRENTPAGE;
pub const PD_NOPAGENUMS = PRINTDLGEX_FLAGS.NOPAGENUMS;
pub const PD_NOSELECTION = PRINTDLGEX_FLAGS.NOSELECTION;
pub const PD_NOWARNING = PRINTDLGEX_FLAGS.NOWARNING;
pub const PD_PAGENUMS = PRINTDLGEX_FLAGS.PAGENUMS;
pub const PD_PRINTTOFILE = PRINTDLGEX_FLAGS.PRINTTOFILE;
pub const PD_RETURNDC = PRINTDLGEX_FLAGS.RETURNDC;
pub const PD_RETURNDEFAULT = PRINTDLGEX_FLAGS.RETURNDEFAULT;
pub const PD_RETURNIC = PRINTDLGEX_FLAGS.RETURNIC;
pub const PD_SELECTION = PRINTDLGEX_FLAGS.SELECTION;
pub const PD_USEDEVMODECOPIES = PRINTDLGEX_FLAGS.USEDEVMODECOPIES;
pub const PD_USEDEVMODECOPIESANDCOLLATE = PRINTDLGEX_FLAGS.USEDEVMODECOPIES;
pub const PD_USELARGETEMPLATE = PRINTDLGEX_FLAGS.USELARGETEMPLATE;
pub const PD_ENABLEPRINTHOOK = PRINTDLGEX_FLAGS.ENABLEPRINTHOOK;
pub const PD_ENABLESETUPHOOK = PRINTDLGEX_FLAGS.ENABLESETUPHOOK;
pub const PD_ENABLESETUPTEMPLATE = PRINTDLGEX_FLAGS.ENABLESETUPTEMPLATE;
pub const PD_ENABLESETUPTEMPLATEHANDLE = PRINTDLGEX_FLAGS.ENABLESETUPTEMPLATEHANDLE;
pub const PD_NONETWORKBUTTON = PRINTDLGEX_FLAGS.NONETWORKBUTTON;
pub const PD_PRINTSETUP = PRINTDLGEX_FLAGS.PRINTSETUP;
pub const PD_SHOWHELP = PRINTDLGEX_FLAGS.SHOWHELP;
pub const CHOOSEFONT_FONT_TYPE = enum(u16) {
BOLD_FONTTYPE = 256,
ITALIC_FONTTYPE = 512,
PRINTER_FONTTYPE = 16384,
REGULAR_FONTTYPE = 1024,
SCREEN_FONTTYPE = 8192,
SIMULATED_FONTTYPE = 32768,
_,
pub fn initFlags(o: struct {
BOLD_FONTTYPE: u1 = 0,
ITALIC_FONTTYPE: u1 = 0,
PRINTER_FONTTYPE: u1 = 0,
REGULAR_FONTTYPE: u1 = 0,
SCREEN_FONTTYPE: u1 = 0,
SIMULATED_FONTTYPE: u1 = 0,
}) CHOOSEFONT_FONT_TYPE {
return @intToEnum(CHOOSEFONT_FONT_TYPE,
(if (o.BOLD_FONTTYPE == 1) @enumToInt(CHOOSEFONT_FONT_TYPE.BOLD_FONTTYPE) else 0)
| (if (o.ITALIC_FONTTYPE == 1) @enumToInt(CHOOSEFONT_FONT_TYPE.ITALIC_FONTTYPE) else 0)
| (if (o.PRINTER_FONTTYPE == 1) @enumToInt(CHOOSEFONT_FONT_TYPE.PRINTER_FONTTYPE) else 0)
| (if (o.REGULAR_FONTTYPE == 1) @enumToInt(CHOOSEFONT_FONT_TYPE.REGULAR_FONTTYPE) else 0)
| (if (o.SCREEN_FONTTYPE == 1) @enumToInt(CHOOSEFONT_FONT_TYPE.SCREEN_FONTTYPE) else 0)
| (if (o.SIMULATED_FONTTYPE == 1) @enumToInt(CHOOSEFONT_FONT_TYPE.SIMULATED_FONTTYPE) else 0)
);
}
};
pub const BOLD_FONTTYPE = CHOOSEFONT_FONT_TYPE.BOLD_FONTTYPE;
pub const ITALIC_FONTTYPE = CHOOSEFONT_FONT_TYPE.ITALIC_FONTTYPE;
pub const PRINTER_FONTTYPE = CHOOSEFONT_FONT_TYPE.PRINTER_FONTTYPE;
pub const REGULAR_FONTTYPE = CHOOSEFONT_FONT_TYPE.REGULAR_FONTTYPE;
pub const SCREEN_FONTTYPE = CHOOSEFONT_FONT_TYPE.SCREEN_FONTTYPE;
pub const SIMULATED_FONTTYPE = CHOOSEFONT_FONT_TYPE.SIMULATED_FONTTYPE;
pub const LPOFNHOOKPROC = fn(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) usize;
pub const LPCCHOOKPROC = fn(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) usize;
pub const LPFRHOOKPROC = fn(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) usize;
pub const LPCFHOOKPROC = fn(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) usize;
pub const LPPRINTHOOKPROC = fn(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) usize;
pub const LPSETUPHOOKPROC = fn(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) usize;
// TODO: this type is limited to platform 'windows5.0'
const IID_IPrintDialogCallback_Value = Guid.initString("5852a2c3-6530-11d1-b6a3-0000f8757bf9");
pub const IID_IPrintDialogCallback = &IID_IPrintDialogCallback_Value;
pub const IPrintDialogCallback = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
InitDone: fn(
self: *const IPrintDialogCallback,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SelectionChange: fn(
self: *const IPrintDialogCallback,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
HandleMessage: fn(
self: *const IPrintDialogCallback,
hDlg: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
pResult: ?*LRESULT,
) 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 IPrintDialogCallback_InitDone(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IPrintDialogCallback.VTable, self.vtable).InitDone(@ptrCast(*const IPrintDialogCallback, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPrintDialogCallback_SelectionChange(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IPrintDialogCallback.VTable, self.vtable).SelectionChange(@ptrCast(*const IPrintDialogCallback, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPrintDialogCallback_HandleMessage(self: *const T, hDlg: ?HWND, uMsg: u32, wParam: WPARAM, lParam: LPARAM, pResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IPrintDialogCallback.VTable, self.vtable).HandleMessage(@ptrCast(*const IPrintDialogCallback, self), hDlg, uMsg, wParam, lParam, pResult);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows5.0'
const IID_IPrintDialogServices_Value = Guid.initString("509aaeda-5639-11d1-b6a1-0000f8757bf9");
pub const IID_IPrintDialogServices = &IID_IPrintDialogServices_Value;
pub const IPrintDialogServices = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetCurrentDevMode: fn(
self: *const IPrintDialogServices,
pDevMode: ?*DEVMODEA,
pcbSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCurrentPrinterName: fn(
self: *const IPrintDialogServices,
pPrinterName: ?[*:0]u16,
pcchSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCurrentPortName: fn(
self: *const IPrintDialogServices,
pPortName: ?[*:0]u16,
pcchSize: ?*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 IPrintDialogServices_GetCurrentDevMode(self: *const T, pDevMode: ?*DEVMODEA, pcbSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPrintDialogServices.VTable, self.vtable).GetCurrentDevMode(@ptrCast(*const IPrintDialogServices, self), pDevMode, pcbSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPrintDialogServices_GetCurrentPrinterName(self: *const T, pPrinterName: ?[*:0]u16, pcchSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPrintDialogServices.VTable, self.vtable).GetCurrentPrinterName(@ptrCast(*const IPrintDialogServices, self), pPrinterName, pcchSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPrintDialogServices_GetCurrentPortName(self: *const T, pPortName: ?[*:0]u16, pcchSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPrintDialogServices.VTable, self.vtable).GetCurrentPortName(@ptrCast(*const IPrintDialogServices, self), pPortName, pcchSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const LPPAGEPAINTHOOK = fn(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) usize;
pub const LPPAGESETUPHOOK = fn(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) usize;
pub const OPENFILENAME_NT4A = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
lpstrFilter: ?[*:0]const u8,
lpstrCustomFilter: ?PSTR,
nMaxCustFilter: u32,
nFilterIndex: u32,
lpstrFile: ?PSTR,
nMaxFile: u32,
lpstrFileTitle: ?PSTR,
nMaxFileTitle: u32,
lpstrInitialDir: ?[*:0]const u8,
lpstrTitle: ?[*:0]const u8,
Flags: u32,
nFileOffset: u16,
nFileExtension: u16,
lpstrDefExt: ?[*:0]const u8,
lCustData: LPARAM,
lpfnHook: ?LPOFNHOOKPROC,
lpTemplateName: ?[*:0]const u8,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
lpstrFilter: ?[*:0]const u8,
lpstrCustomFilter: ?PSTR,
nMaxCustFilter: u32,
nFilterIndex: u32,
lpstrFile: ?PSTR,
nMaxFile: u32,
lpstrFileTitle: ?PSTR,
nMaxFileTitle: u32,
lpstrInitialDir: ?[*:0]const u8,
lpstrTitle: ?[*:0]const u8,
Flags: u32,
nFileOffset: u16,
nFileExtension: u16,
lpstrDefExt: ?[*:0]const u8,
lCustData: LPARAM,
lpfnHook: ?LPOFNHOOKPROC,
lpTemplateName: ?[*:0]const u8,
},
};
pub const OPENFILENAME_NT4W = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
lpstrFilter: ?[*:0]const u16,
lpstrCustomFilter: ?PWSTR,
nMaxCustFilter: u32,
nFilterIndex: u32,
lpstrFile: ?PWSTR,
nMaxFile: u32,
lpstrFileTitle: ?PWSTR,
nMaxFileTitle: u32,
lpstrInitialDir: ?[*:0]const u16,
lpstrTitle: ?[*:0]const u16,
Flags: u32,
nFileOffset: u16,
nFileExtension: u16,
lpstrDefExt: ?[*:0]const u16,
lCustData: LPARAM,
lpfnHook: ?LPOFNHOOKPROC,
lpTemplateName: ?[*:0]const u16,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
lpstrFilter: ?[*:0]const u16,
lpstrCustomFilter: ?PWSTR,
nMaxCustFilter: u32,
nFilterIndex: u32,
lpstrFile: ?PWSTR,
nMaxFile: u32,
lpstrFileTitle: ?PWSTR,
nMaxFileTitle: u32,
lpstrInitialDir: ?[*:0]const u16,
lpstrTitle: ?[*:0]const u16,
Flags: u32,
nFileOffset: u16,
nFileExtension: u16,
lpstrDefExt: ?[*:0]const u16,
lCustData: LPARAM,
lpfnHook: ?LPOFNHOOKPROC,
lpTemplateName: ?[*:0]const u16,
},
};
pub const OPENFILENAMEA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
lpstrFilter: ?[*:0]const u8,
lpstrCustomFilter: ?PSTR,
nMaxCustFilter: u32,
nFilterIndex: u32,
lpstrFile: ?PSTR,
nMaxFile: u32,
lpstrFileTitle: ?PSTR,
nMaxFileTitle: u32,
lpstrInitialDir: ?[*:0]const u8,
lpstrTitle: ?[*:0]const u8,
Flags: OPEN_FILENAME_FLAGS,
nFileOffset: u16,
nFileExtension: u16,
lpstrDefExt: ?[*:0]const u8,
lCustData: LPARAM,
lpfnHook: ?LPOFNHOOKPROC,
lpTemplateName: ?[*:0]const u8,
pvReserved: ?*anyopaque,
dwReserved: u32,
FlagsEx: OPEN_FILENAME_FLAGS_EX,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
lpstrFilter: ?[*:0]const u8,
lpstrCustomFilter: ?PSTR,
nMaxCustFilter: u32,
nFilterIndex: u32,
lpstrFile: ?PSTR,
nMaxFile: u32,
lpstrFileTitle: ?PSTR,
nMaxFileTitle: u32,
lpstrInitialDir: ?[*:0]const u8,
lpstrTitle: ?[*:0]const u8,
Flags: OPEN_FILENAME_FLAGS,
nFileOffset: u16,
nFileExtension: u16,
lpstrDefExt: ?[*:0]const u8,
lCustData: LPARAM,
lpfnHook: ?LPOFNHOOKPROC,
lpTemplateName: ?[*:0]const u8,
pvReserved: ?*anyopaque,
dwReserved: u32,
FlagsEx: OPEN_FILENAME_FLAGS_EX,
},
};
pub const OPENFILENAMEW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
lpstrFilter: ?[*:0]const u16,
lpstrCustomFilter: ?PWSTR,
nMaxCustFilter: u32,
nFilterIndex: u32,
lpstrFile: ?PWSTR,
nMaxFile: u32,
lpstrFileTitle: ?PWSTR,
nMaxFileTitle: u32,
lpstrInitialDir: ?[*:0]const u16,
lpstrTitle: ?[*:0]const u16,
Flags: OPEN_FILENAME_FLAGS,
nFileOffset: u16,
nFileExtension: u16,
lpstrDefExt: ?[*:0]const u16,
lCustData: LPARAM,
lpfnHook: ?LPOFNHOOKPROC,
lpTemplateName: ?[*:0]const u16,
pvReserved: ?*anyopaque,
dwReserved: u32,
FlagsEx: OPEN_FILENAME_FLAGS_EX,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
lpstrFilter: ?[*:0]const u16,
lpstrCustomFilter: ?PWSTR,
nMaxCustFilter: u32,
nFilterIndex: u32,
lpstrFile: ?PWSTR,
nMaxFile: u32,
lpstrFileTitle: ?PWSTR,
nMaxFileTitle: u32,
lpstrInitialDir: ?[*:0]const u16,
lpstrTitle: ?[*:0]const u16,
Flags: OPEN_FILENAME_FLAGS,
nFileOffset: u16,
nFileExtension: u16,
lpstrDefExt: ?[*:0]const u16,
lCustData: LPARAM,
lpfnHook: ?LPOFNHOOKPROC,
lpTemplateName: ?[*:0]const u16,
pvReserved: ?*anyopaque,
dwReserved: u32,
FlagsEx: OPEN_FILENAME_FLAGS_EX,
},
};
pub const OFNOTIFYA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
hdr: NMHDR,
lpOFN: ?*OPENFILENAMEA,
pszFile: ?PSTR,
},
.X86 => packed struct {
hdr: NMHDR,
lpOFN: ?*OPENFILENAMEA,
pszFile: ?PSTR,
},
};
pub const OFNOTIFYW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
hdr: NMHDR,
lpOFN: ?*OPENFILENAMEW,
pszFile: ?PWSTR,
},
.X86 => packed struct {
hdr: NMHDR,
lpOFN: ?*OPENFILENAMEW,
pszFile: ?PWSTR,
},
};
pub const OFNOTIFYEXA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
hdr: NMHDR,
lpOFN: ?*OPENFILENAMEA,
psf: ?*anyopaque,
pidl: ?*anyopaque,
},
.X86 => packed struct {
hdr: NMHDR,
lpOFN: ?*OPENFILENAMEA,
psf: ?*anyopaque,
pidl: ?*anyopaque,
},
};
pub const OFNOTIFYEXW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
hdr: NMHDR,
lpOFN: ?*OPENFILENAMEW,
psf: ?*anyopaque,
pidl: ?*anyopaque,
},
.X86 => packed struct {
hdr: NMHDR,
lpOFN: ?*OPENFILENAMEW,
psf: ?*anyopaque,
pidl: ?*anyopaque,
},
};
pub const CHOOSECOLORA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HWND,
rgbResult: u32,
lpCustColors: ?*u32,
Flags: u32,
lCustData: LPARAM,
lpfnHook: ?LPCCHOOKPROC,
lpTemplateName: ?[*:0]const u8,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HWND,
rgbResult: u32,
lpCustColors: ?*u32,
Flags: u32,
lCustData: LPARAM,
lpfnHook: ?LPCCHOOKPROC,
lpTemplateName: ?[*:0]const u8,
},
};
pub const CHOOSECOLORW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HWND,
rgbResult: u32,
lpCustColors: ?*u32,
Flags: u32,
lCustData: LPARAM,
lpfnHook: ?LPCCHOOKPROC,
lpTemplateName: ?[*:0]const u16,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HWND,
rgbResult: u32,
lpCustColors: ?*u32,
Flags: u32,
lCustData: LPARAM,
lpfnHook: ?LPCCHOOKPROC,
lpTemplateName: ?[*:0]const u16,
},
};
pub const FINDREPLACEA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
Flags: FINDREPLACE_FLAGS,
lpstrFindWhat: ?PSTR,
lpstrReplaceWith: ?PSTR,
wFindWhatLen: u16,
wReplaceWithLen: u16,
lCustData: LPARAM,
lpfnHook: ?LPFRHOOKPROC,
lpTemplateName: ?[*:0]const u8,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
Flags: FINDREPLACE_FLAGS,
lpstrFindWhat: ?PSTR,
lpstrReplaceWith: ?PSTR,
wFindWhatLen: u16,
wReplaceWithLen: u16,
lCustData: LPARAM,
lpfnHook: ?LPFRHOOKPROC,
lpTemplateName: ?[*:0]const u8,
},
};
pub const FINDREPLACEW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
Flags: FINDREPLACE_FLAGS,
lpstrFindWhat: ?PWSTR,
lpstrReplaceWith: ?PWSTR,
wFindWhatLen: u16,
wReplaceWithLen: u16,
lCustData: LPARAM,
lpfnHook: ?LPFRHOOKPROC,
lpTemplateName: ?[*:0]const u16,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hInstance: ?HINSTANCE,
Flags: FINDREPLACE_FLAGS,
lpstrFindWhat: ?PWSTR,
lpstrReplaceWith: ?PWSTR,
wFindWhatLen: u16,
wReplaceWithLen: u16,
lCustData: LPARAM,
lpfnHook: ?LPFRHOOKPROC,
lpTemplateName: ?[*:0]const u16,
},
};
pub const CHOOSEFONTA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDC: ?HDC,
lpLogFont: ?*LOGFONTA,
iPointSize: i32,
Flags: CHOOSEFONT_FLAGS,
rgbColors: u32,
lCustData: LPARAM,
lpfnHook: ?LPCFHOOKPROC,
lpTemplateName: ?[*:0]const u8,
hInstance: ?HINSTANCE,
lpszStyle: ?PSTR,
nFontType: CHOOSEFONT_FONT_TYPE,
___MISSING_ALIGNMENT__: u16,
nSizeMin: i32,
nSizeMax: i32,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDC: ?HDC,
lpLogFont: ?*LOGFONTA,
iPointSize: i32,
Flags: CHOOSEFONT_FLAGS,
rgbColors: u32,
lCustData: LPARAM,
lpfnHook: ?LPCFHOOKPROC,
lpTemplateName: ?[*:0]const u8,
hInstance: ?HINSTANCE,
lpszStyle: ?PSTR,
nFontType: CHOOSEFONT_FONT_TYPE,
___MISSING_ALIGNMENT__: u16,
nSizeMin: i32,
nSizeMax: i32,
},
};
pub const CHOOSEFONTW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDC: ?HDC,
lpLogFont: ?*LOGFONTW,
iPointSize: i32,
Flags: CHOOSEFONT_FLAGS,
rgbColors: u32,
lCustData: LPARAM,
lpfnHook: ?LPCFHOOKPROC,
lpTemplateName: ?[*:0]const u16,
hInstance: ?HINSTANCE,
lpszStyle: ?PWSTR,
nFontType: CHOOSEFONT_FONT_TYPE,
___MISSING_ALIGNMENT__: u16,
nSizeMin: i32,
nSizeMax: i32,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDC: ?HDC,
lpLogFont: ?*LOGFONTW,
iPointSize: i32,
Flags: CHOOSEFONT_FLAGS,
rgbColors: u32,
lCustData: LPARAM,
lpfnHook: ?LPCFHOOKPROC,
lpTemplateName: ?[*:0]const u16,
hInstance: ?HINSTANCE,
lpszStyle: ?PWSTR,
nFontType: CHOOSEFONT_FONT_TYPE,
___MISSING_ALIGNMENT__: u16,
nSizeMin: i32,
nSizeMax: i32,
},
};
pub const PRINTDLGA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
hDC: ?HDC,
Flags: PRINTDLGEX_FLAGS,
nFromPage: u16,
nToPage: u16,
nMinPage: u16,
nMaxPage: u16,
nCopies: u16,
hInstance: ?HINSTANCE,
lCustData: LPARAM,
lpfnPrintHook: ?LPPRINTHOOKPROC,
lpfnSetupHook: ?LPSETUPHOOKPROC,
lpPrintTemplateName: ?[*:0]const u8,
lpSetupTemplateName: ?[*:0]const u8,
hPrintTemplate: isize,
hSetupTemplate: isize,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
hDC: ?HDC,
Flags: PRINTDLGEX_FLAGS,
nFromPage: u16,
nToPage: u16,
nMinPage: u16,
nMaxPage: u16,
nCopies: u16,
hInstance: ?HINSTANCE,
lCustData: LPARAM,
lpfnPrintHook: ?LPPRINTHOOKPROC,
lpfnSetupHook: ?LPSETUPHOOKPROC,
lpPrintTemplateName: ?[*:0]const u8,
lpSetupTemplateName: ?[*:0]const u8,
hPrintTemplate: isize,
hSetupTemplate: isize,
},
};
pub const PRINTDLGW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
hDC: ?HDC,
Flags: PRINTDLGEX_FLAGS,
nFromPage: u16,
nToPage: u16,
nMinPage: u16,
nMaxPage: u16,
nCopies: u16,
hInstance: ?HINSTANCE,
lCustData: LPARAM,
lpfnPrintHook: ?LPPRINTHOOKPROC,
lpfnSetupHook: ?LPSETUPHOOKPROC,
lpPrintTemplateName: ?[*:0]const u16,
lpSetupTemplateName: ?[*:0]const u16,
hPrintTemplate: isize,
hSetupTemplate: isize,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
hDC: ?HDC,
Flags: PRINTDLGEX_FLAGS,
nFromPage: u16,
nToPage: u16,
nMinPage: u16,
nMaxPage: u16,
nCopies: u16,
hInstance: ?HINSTANCE,
lCustData: LPARAM,
lpfnPrintHook: ?LPPRINTHOOKPROC,
lpfnSetupHook: ?LPSETUPHOOKPROC,
lpPrintTemplateName: ?[*:0]const u16,
lpSetupTemplateName: ?[*:0]const u16,
hPrintTemplate: isize,
hSetupTemplate: isize,
},
};
pub const PRINTPAGERANGE = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
nFromPage: u32,
nToPage: u32,
},
.X86 => packed struct {
nFromPage: u32,
nToPage: u32,
},
};
pub const PRINTDLGEXA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
hDC: ?HDC,
Flags: PRINTDLGEX_FLAGS,
Flags2: u32,
ExclusionFlags: u32,
nPageRanges: u32,
nMaxPageRanges: u32,
lpPageRanges: ?*PRINTPAGERANGE,
nMinPage: u32,
nMaxPage: u32,
nCopies: u32,
hInstance: ?HINSTANCE,
lpPrintTemplateName: ?[*:0]const u8,
lpCallback: ?*IUnknown,
nPropertyPages: u32,
lphPropertyPages: ?*?HPROPSHEETPAGE,
nStartPage: u32,
dwResultAction: u32,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
hDC: ?HDC,
Flags: PRINTDLGEX_FLAGS,
Flags2: u32,
ExclusionFlags: u32,
nPageRanges: u32,
nMaxPageRanges: u32,
lpPageRanges: ?*PRINTPAGERANGE,
nMinPage: u32,
nMaxPage: u32,
nCopies: u32,
hInstance: ?HINSTANCE,
lpPrintTemplateName: ?[*:0]const u8,
lpCallback: ?*IUnknown,
nPropertyPages: u32,
lphPropertyPages: ?*?HPROPSHEETPAGE,
nStartPage: u32,
dwResultAction: u32,
},
};
pub const PRINTDLGEXW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
hDC: ?HDC,
Flags: PRINTDLGEX_FLAGS,
Flags2: u32,
ExclusionFlags: u32,
nPageRanges: u32,
nMaxPageRanges: u32,
lpPageRanges: ?*PRINTPAGERANGE,
nMinPage: u32,
nMaxPage: u32,
nCopies: u32,
hInstance: ?HINSTANCE,
lpPrintTemplateName: ?[*:0]const u16,
lpCallback: ?*IUnknown,
nPropertyPages: u32,
lphPropertyPages: ?*?HPROPSHEETPAGE,
nStartPage: u32,
dwResultAction: u32,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
hDC: ?HDC,
Flags: PRINTDLGEX_FLAGS,
Flags2: u32,
ExclusionFlags: u32,
nPageRanges: u32,
nMaxPageRanges: u32,
lpPageRanges: ?*PRINTPAGERANGE,
nMinPage: u32,
nMaxPage: u32,
nCopies: u32,
hInstance: ?HINSTANCE,
lpPrintTemplateName: ?[*:0]const u16,
lpCallback: ?*IUnknown,
nPropertyPages: u32,
lphPropertyPages: ?*?HPROPSHEETPAGE,
nStartPage: u32,
dwResultAction: u32,
},
};
pub const DEVNAMES = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
wDriverOffset: u16,
wDeviceOffset: u16,
wOutputOffset: u16,
wDefault: u16,
},
.X86 => packed struct {
wDriverOffset: u16,
wDeviceOffset: u16,
wOutputOffset: u16,
wDefault: u16,
},
};
pub const PAGESETUPDLGA = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
Flags: PAGESETUPDLG_FLAGS,
ptPaperSize: POINT,
rtMinMargin: RECT,
rtMargin: RECT,
hInstance: ?HINSTANCE,
lCustData: LPARAM,
lpfnPageSetupHook: ?LPPAGESETUPHOOK,
lpfnPagePaintHook: ?LPPAGEPAINTHOOK,
lpPageSetupTemplateName: ?[*:0]const u8,
hPageSetupTemplate: isize,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
Flags: PAGESETUPDLG_FLAGS,
ptPaperSize: POINT,
rtMinMargin: RECT,
rtMargin: RECT,
hInstance: ?HINSTANCE,
lCustData: LPARAM,
lpfnPageSetupHook: ?LPPAGESETUPHOOK,
lpfnPagePaintHook: ?LPPAGEPAINTHOOK,
lpPageSetupTemplateName: ?[*:0]const u8,
hPageSetupTemplate: isize,
},
};
pub const PAGESETUPDLGW = switch(@import("../../zig.zig").arch) {
.X64, .Arm64 => extern struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
Flags: PAGESETUPDLG_FLAGS,
ptPaperSize: POINT,
rtMinMargin: RECT,
rtMargin: RECT,
hInstance: ?HINSTANCE,
lCustData: LPARAM,
lpfnPageSetupHook: ?LPPAGESETUPHOOK,
lpfnPagePaintHook: ?LPPAGEPAINTHOOK,
lpPageSetupTemplateName: ?[*:0]const u16,
hPageSetupTemplate: isize,
},
.X86 => packed struct {
lStructSize: u32,
hwndOwner: ?HWND,
hDevMode: isize,
hDevNames: isize,
Flags: PAGESETUPDLG_FLAGS,
ptPaperSize: POINT,
rtMinMargin: RECT,
rtMargin: RECT,
hInstance: ?HINSTANCE,
lCustData: LPARAM,
lpfnPageSetupHook: ?LPPAGESETUPHOOK,
lpfnPagePaintHook: ?LPPAGEPAINTHOOK,
lpPageSetupTemplateName: ?[*:0]const u16,
hPageSetupTemplate: isize,
},
};
//--------------------------------------------------------------------------------
// Section: Functions (21)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn GetOpenFileNameA(
param0: ?*OPENFILENAMEA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn GetOpenFileNameW(
param0: ?*OPENFILENAMEW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn GetSaveFileNameA(
param0: ?*OPENFILENAMEA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn GetSaveFileNameW(
param0: ?*OPENFILENAMEW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn GetFileTitleA(
param0: ?[*:0]const u8,
Buf: [*:0]u8,
cchSize: u16,
) callconv(@import("std").os.windows.WINAPI) i16;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn GetFileTitleW(
param0: ?[*:0]const u16,
Buf: [*:0]u16,
cchSize: u16,
) callconv(@import("std").os.windows.WINAPI) i16;
pub extern "COMDLG32" fn ChooseColorA(
param0: ?*CHOOSECOLORA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "COMDLG32" fn ChooseColorW(
param0: ?*CHOOSECOLORW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn FindTextA(
param0: ?*FINDREPLACEA,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn FindTextW(
param0: ?*FINDREPLACEW,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn ReplaceTextA(
param0: ?*FINDREPLACEA,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn ReplaceTextW(
param0: ?*FINDREPLACEW,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
pub extern "COMDLG32" fn ChooseFontA(
param0: ?*CHOOSEFONTA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "COMDLG32" fn ChooseFontW(
param0: ?*CHOOSEFONTW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "COMDLG32" fn PrintDlgA(
pPD: ?*PRINTDLGA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "COMDLG32" fn PrintDlgW(
pPD: ?*PRINTDLGW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "COMDLG32" fn PrintDlgExA(
pPD: ?*PRINTDLGEXA,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "COMDLG32" fn PrintDlgExW(
pPD: ?*PRINTDLGEXW,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "COMDLG32" fn CommDlgExtendedError(
) callconv(@import("std").os.windows.WINAPI) COMMON_DLG_ERRORS;
pub extern "COMDLG32" fn PageSetupDlgA(
param0: ?*PAGESETUPDLGA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "COMDLG32" fn PageSetupDlgW(
param0: ?*PAGESETUPDLGW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (20)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../../zig.zig").unicode_mode) {
.ansi => struct {
pub const OPENFILENAME_NT4 = thismodule.OPENFILENAME_NT4A;
pub const OPENFILENAME = thismodule.OPENFILENAMEA;
pub const OFNOTIFY = thismodule.OFNOTIFYA;
pub const OFNOTIFYEX = thismodule.OFNOTIFYEXA;
pub const CHOOSECOLOR = thismodule.CHOOSECOLORA;
pub const FINDREPLACE = thismodule.FINDREPLACEA;
pub const CHOOSEFONT = thismodule.CHOOSEFONTA;
pub const PRINTDLG = thismodule.PRINTDLGA;
pub const PRINTDLGEX = thismodule.PRINTDLGEXA;
pub const PAGESETUPDLG = thismodule.PAGESETUPDLGA;
pub const GetOpenFileName = thismodule.GetOpenFileNameA;
pub const GetSaveFileName = thismodule.GetSaveFileNameA;
pub const GetFileTitle = thismodule.GetFileTitleA;
pub const ChooseColor = thismodule.ChooseColorA;
pub const FindText = thismodule.FindTextA;
pub const ReplaceText = thismodule.ReplaceTextA;
pub const ChooseFont = thismodule.ChooseFontA;
pub const PrintDlg = thismodule.PrintDlgA;
pub const PrintDlgEx = thismodule.PrintDlgExA;
pub const PageSetupDlg = thismodule.PageSetupDlgA;
},
.wide => struct {
pub const OPENFILENAME_NT4 = thismodule.OPENFILENAME_NT4W;
pub const OPENFILENAME = thismodule.OPENFILENAMEW;
pub const OFNOTIFY = thismodule.OFNOTIFYW;
pub const OFNOTIFYEX = thismodule.OFNOTIFYEXW;
pub const CHOOSECOLOR = thismodule.CHOOSECOLORW;
pub const FINDREPLACE = thismodule.FINDREPLACEW;
pub const CHOOSEFONT = thismodule.CHOOSEFONTW;
pub const PRINTDLG = thismodule.PRINTDLGW;
pub const PRINTDLGEX = thismodule.PRINTDLGEXW;
pub const PAGESETUPDLG = thismodule.PAGESETUPDLGW;
pub const GetOpenFileName = thismodule.GetOpenFileNameW;
pub const GetSaveFileName = thismodule.GetSaveFileNameW;
pub const GetFileTitle = thismodule.GetFileTitleW;
pub const ChooseColor = thismodule.ChooseColorW;
pub const FindText = thismodule.FindTextW;
pub const ReplaceText = thismodule.ReplaceTextW;
pub const ChooseFont = thismodule.ChooseFontW;
pub const PrintDlg = thismodule.PrintDlgW;
pub const PrintDlgEx = thismodule.PrintDlgExW;
pub const PageSetupDlg = thismodule.PageSetupDlgW;
},
.unspecified => if (@import("builtin").is_test) struct {
pub const OPENFILENAME_NT4 = *opaque{};
pub const OPENFILENAME = *opaque{};
pub const OFNOTIFY = *opaque{};
pub const OFNOTIFYEX = *opaque{};
pub const CHOOSECOLOR = *opaque{};
pub const FINDREPLACE = *opaque{};
pub const CHOOSEFONT = *opaque{};
pub const PRINTDLG = *opaque{};
pub const PRINTDLGEX = *opaque{};
pub const PAGESETUPDLG = *opaque{};
pub const GetOpenFileName = *opaque{};
pub const GetSaveFileName = *opaque{};
pub const GetFileTitle = *opaque{};
pub const ChooseColor = *opaque{};
pub const FindText = *opaque{};
pub const ReplaceText = *opaque{};
pub const ChooseFont = *opaque{};
pub const PrintDlg = *opaque{};
pub const PrintDlgEx = *opaque{};
pub const PageSetupDlg = *opaque{};
} else struct {
pub const OPENFILENAME_NT4 = @compileError("'OPENFILENAME_NT4' requires that UNICODE be set to true or false in the root module");
pub const OPENFILENAME = @compileError("'OPENFILENAME' requires that UNICODE be set to true or false in the root module");
pub const OFNOTIFY = @compileError("'OFNOTIFY' requires that UNICODE be set to true or false in the root module");
pub const OFNOTIFYEX = @compileError("'OFNOTIFYEX' requires that UNICODE be set to true or false in the root module");
pub const CHOOSECOLOR = @compileError("'CHOOSECOLOR' requires that UNICODE be set to true or false in the root module");
pub const FINDREPLACE = @compileError("'FINDREPLACE' requires that UNICODE be set to true or false in the root module");
pub const CHOOSEFONT = @compileError("'CHOOSEFONT' requires that UNICODE be set to true or false in the root module");
pub const PRINTDLG = @compileError("'PRINTDLG' requires that UNICODE be set to true or false in the root module");
pub const PRINTDLGEX = @compileError("'PRINTDLGEX' requires that UNICODE be set to true or false in the root module");
pub const PAGESETUPDLG = @compileError("'PAGESETUPDLG' requires that UNICODE be set to true or false in the root module");
pub const GetOpenFileName = @compileError("'GetOpenFileName' requires that UNICODE be set to true or false in the root module");
pub const GetSaveFileName = @compileError("'GetSaveFileName' requires that UNICODE be set to true or false in the root module");
pub const GetFileTitle = @compileError("'GetFileTitle' requires that UNICODE be set to true or false in the root module");
pub const ChooseColor = @compileError("'ChooseColor' requires that UNICODE be set to true or false in the root module");
pub const FindText = @compileError("'FindText' requires that UNICODE be set to true or false in the root module");
pub const ReplaceText = @compileError("'ReplaceText' requires that UNICODE be set to true or false in the root module");
pub const ChooseFont = @compileError("'ChooseFont' requires that UNICODE be set to true or false in the root module");
pub const PrintDlg = @compileError("'PrintDlg' requires that UNICODE be set to true or false in the root module");
pub const PrintDlgEx = @compileError("'PrintDlgEx' requires that UNICODE be set to true or false in the root module");
pub const PageSetupDlg = @compileError("'PageSetupDlg' requires that UNICODE be set to true or false in the root module");
},
};
//--------------------------------------------------------------------------------
// Section: Imports (19)
//--------------------------------------------------------------------------------
const Guid = @import("../../zig.zig").Guid;
const BOOL = @import("../../foundation.zig").BOOL;
const DEVMODEA = @import("../../graphics/gdi.zig").DEVMODEA;
const HDC = @import("../../graphics/gdi.zig").HDC;
const HINSTANCE = @import("../../foundation.zig").HINSTANCE;
const HPROPSHEETPAGE = @import("../../ui/controls.zig").HPROPSHEETPAGE;
const HRESULT = @import("../../foundation.zig").HRESULT;
const HWND = @import("../../foundation.zig").HWND;
const IUnknown = @import("../../system/com.zig").IUnknown;
const LOGFONTA = @import("../../graphics/gdi.zig").LOGFONTA;
const LOGFONTW = @import("../../graphics/gdi.zig").LOGFONTW;
const LPARAM = @import("../../foundation.zig").LPARAM;
const LRESULT = @import("../../foundation.zig").LRESULT;
const NMHDR = @import("../../ui/controls.zig").NMHDR;
const POINT = @import("../../foundation.zig").POINT;
const PSTR = @import("../../foundation.zig").PSTR;
const PWSTR = @import("../../foundation.zig").PWSTR;
const RECT = @import("../../foundation.zig").RECT;
const WPARAM = @import("../../foundation.zig").WPARAM;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "LPOFNHOOKPROC")) { _ = LPOFNHOOKPROC; }
if (@hasDecl(@This(), "LPCCHOOKPROC")) { _ = LPCCHOOKPROC; }
if (@hasDecl(@This(), "LPFRHOOKPROC")) { _ = LPFRHOOKPROC; }
if (@hasDecl(@This(), "LPCFHOOKPROC")) { _ = LPCFHOOKPROC; }
if (@hasDecl(@This(), "LPPRINTHOOKPROC")) { _ = LPPRINTHOOKPROC; }
if (@hasDecl(@This(), "LPSETUPHOOKPROC")) { _ = LPSETUPHOOKPROC; }
if (@hasDecl(@This(), "LPPAGEPAINTHOOK")) { _ = LPPAGEPAINTHOOK; }
if (@hasDecl(@This(), "LPPAGESETUPHOOK")) { _ = LPPAGESETUPHOOK; }
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/ui/controls/dialogs.zig |
const std = @import("std");
const fs = std.fs;
const Answer = struct {
depth: u32,
length: u32,
};
fn get_answer_from_file(filename: []const u8, aimed: bool) !Answer {
var file = try fs.cwd().openFile(filename, .{ .read = true });
defer file.close();
var reader = std.io.bufferedReader(file.reader());
var in_stream = reader.reader();
var depth: u32 = 0;
var length: u32 = 0;
var aim: u32 = 0;
var buffer: [128]u8 = undefined;
while (try in_stream.readUntilDelimiterOrEof(&buffer, '\n')) |line| {
var it = std.mem.split(u8, line, " ");
var direction = it.next().?;
var amount = try std.fmt.parseInt(u32, it.next().?, 10);
if (std.mem.eql(u8, direction, "down")) {
if (aimed) {
aim += amount;
} else {
depth += amount;
}
} else if (std.mem.eql(u8, direction, "up")) {
if (amount > depth) {
std.debug.print("Oh noes! Depth is about to become negative!\n", .{});
break;
}
if (aimed) {
aim -= amount;
} else {
depth -= amount;
}
} else if (std.mem.eql(u8, direction, "forward")) {
length += amount;
if (aimed) {
depth += (aim * amount);
}
} else {
std.debug.print("Oh noes! Found unknown command '{s}'!\n", .{direction});
break;
}
}
return Answer{ .depth = depth, .length = length };
}
pub fn main() void {
var aimed = false;
var example_answer: u32 = undefined;
var puzzle_answer: u32 = undefined;
if (!aimed) { // part 1
example_answer = 150;
puzzle_answer = 1698735;
} else { // part 2
example_answer = 900;
puzzle_answer = 1594785890;
}
var example = get_answer_from_file("example.txt", aimed) catch {
std.debug.print("Couldn't read file.", .{});
return;
};
std.debug.print("Depth {d} Length {d}\n", .{ example.depth, example.length });
std.debug.print("Your example answer was {d} ({d}).\n", .{example.depth * example.length, example_answer});
var answer = get_answer_from_file("input.txt", aimed) catch {
std.debug.print("Couldn't read file.", .{});
return;
};
std.debug.print("Depth {d} Length {d}\n", .{ answer.depth, answer.length });
std.debug.print("Your puzzle answer was {d} ({d}).\n", .{answer.depth * answer.length, puzzle_answer});
} | day2/main.zig |
const std = @import("std");
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
// Public
// TODO: Parse a series of price entries!
// TODO: Refactoring / simplifying!
// TODO: Set up some unit tests for good and bad Price strings!
// TODO: Need a return type!
pub fn scanTokens(allocator: *Allocator, source: []const u8) !void {
var priceScanner = Scanner{
.source = source,
.tokens = ArrayList(Token).init(allocator),
};
try priceScanner.scanTokens();
}
// Private
const PriceSentinelCharacter = 'P';
const TokenType = enum {
PriceSentinel,
DateYear,
DateMonth,
DateDay,
Symbol,
Quantity,
LineBreak,
EndOfFile,
};
const Token = struct {
token_type: TokenType,
text: ?[]const u8,
line: usize,
fn printDebug(self: *const Token) void {
// TODO: can I use std.fmt.format to produce a string instead?
if (self.text == null) {
std.log.debug("Token: (Line {}) {}", .{self.line, self.token_type});
} else {
std.log.debug("Token: (Line {}) {} '{s}'", .{self.line, self.token_type, self.text});
}
}
};
const Scanner = struct {
source: []const u8,
tokens: ArrayList(Token),
current: u8 = undefined,
token_start: usize = 0,
index: usize = 0,
line: usize = 1,
fn scanTokens(self: *Scanner) !void {
// TODO: Need better error handling
std.log.debug("Parsing text (length {}): {s}", .{self.source.len, self.source});
while (self.index < self.source.len) {
// Start of new token
self.token_start = self.index;
// TODO: wrap this in a scanToken() ??
self.advance();
if (self.current == PriceSentinelCharacter) {
try self.price();
} else {
std.log.err("(Line {}) Expecting '{c}' but found: {}", .{self.line, PriceSentinelCharacter, self.current});
}
// Jump to the end to short-circuit parsing the rest!
self.index = self.source.len;
}
// TODO: Do I even need an EOF token?
try self.tokens.append(Token{
.token_type = TokenType.EndOfFile,
.text = null,
.line = self.line,
});
for (self.tokens.items) |token| {
token.printDebug();
}
}
fn advance(self: *Scanner) void {
if (self.index >= self.source.len)
{
self.current = 0;
self.index = self.source.len + 1;
} else {
self.current = self.source[self.index];
self.index += 1;
}
}
fn expect(self: *Scanner, character: u8) void {
if (self.current == character) {
self.advance();
} else {
std.log.err("(Line {}) Expecting '{c}' but found: {c}", .{self.line, character, self.current});
}
}
fn price(self: *Scanner) !void {
try self.tokens.append(Token{
.token_type = TokenType.PriceSentinel,
.text = self.source[self.token_start..self.index],
.line = self.line,
});
self.advance();
self.expect(' ');
try self.date();
self.expect(' ');
try self.symbol();
self.expect(' ');
try self.amount();
}
fn date(self: *Scanner) !void {
// yyyy-MM-dd
self.token_start = self.index - 1;
comptime var i = 0;
inline while (i < 4) : (i += 1) {
self.number();
}
try self.tokens.append(Token{
.token_type = TokenType.DateYear,
.text = self.source[self.token_start..self.index-1],
.line = self.line,
});
self.expect('-');
self.token_start = self.index - 1;
i = 0;
inline while (i < 2) : (i += 1) {
self.number();
}
try self.tokens.append(Token{
.token_type = TokenType.DateMonth,
.text = self.source[self.token_start..self.index-1],
.line = self.line,
});
self.expect('-');
self.token_start = self.index - 1;
i = 0;
inline while (i < 2) : (i += 1) {
self.number();
}
try self.tokens.append(Token{
.token_type = TokenType.DateDay,
.text = self.source[self.token_start..self.index-1],
.line = self.line,
});
}
fn number(self: *Scanner) void {
if (self.current >= '0' and self.current <= '9') {
self.advance();
} else {
std.log.err("(Line {}) Expecting number but found: {c}", .{self.line, self.current});
}
}
fn symbol(self: *Scanner) !void {
self.token_start = self.index - 1;
if (self.current == '\"') {
self.advance();
while (!oneOf(self.current, "\r\n\"")) {
self.advance();
}
self.expect('\"');
} else {
while (!oneOf(self.current, "-0123456789., @;\r\n\"")) {
self.advance();
}
}
try self.tokens.append(Token{
.token_type = TokenType.Symbol,
.text = self.source[self.token_start..self.index-1],
.line = self.line,
});
}
fn amount(self: *Scanner) !void {
if (self.current == '-' or self.current >= '0' and self.current <= '9') {
// quantity, then symbol
try self.quantity();
while (self.current == ' ' or self.current == '\t') {
self.advance();
}
try self.symbol();
} else {
// symbol, then quantity
try self.symbol();
while (self.current == ' ' or self.current == '\t') {
self.advance();
}
try self.quantity();
}
}
fn quantity(self: *Scanner) !void {
self.token_start = self.index - 1;
if (self.current == '-') self.advance();
while (oneOf(self.current, "0123456789,")) {
self.advance();
}
if (self.current == '.') {
self.advance();
while (oneOf(self.current, "0123456789")) {
self.advance();
}
}
try self.tokens.append(Token{
.token_type = TokenType.Symbol,
.text = self.source[self.token_start..self.index-1],
.line = self.line,
});
}
};
// TODO: Why can't I make this a comptime "inline for"?
// Gives me error: unable to evaluate constant expression
fn oneOf(input: u8, chars: []const u8) bool {
return for (chars) |char| {
if (input == char) break true;
} else false;
} | src/scanner.zig |
const std = @import("std");
const sdl_libraries = @import("sdl");
const sdl = sdl_libraries.sdl;
const sdl_img = sdl_libraries.sdl_img;
const Allocator = std.mem.Allocator;
const grey_boarder = sdl.Color{
.r = 66,
.g = 65,
.b = 65,
.a = 210,
};
const selected_color = sdl.Color{
.r = 233,
.g = 212,
.b = 18,
.a = 255,
};
pub fn main() !void {
try initAll();
defer deinitAll();
// the only thing that allocates (other than SDL in libc) is an ArrayList
// which won't get above 81 elements
var memory = [_]u8{undefined} ** (1024);
var fb_alloc = std.heap.FixedBufferAllocator.init(memory[0..]);
const alloc = &fb_alloc.allocator;
var world = try WorldData.init(alloc);
defer world.deinit();
var keyboardActions = makeKeyMap();
var e: sdl.Event = undefined;
while (true) {
if (sdl.waitEvent(&e) != 0) {
switch (e.@"type") {
sdl.QUIT => {
break;
},
sdl.KEYDOWN => {
const idx = @intCast(usize, @enumToInt(e.key.keysym.scancode));
keyboardActions[idx].call(&world);
},
else => {},
}
try world.render();
}
}
}
fn initAll() !void {
if (sdl.init(sdl.INIT_VIDEO) < 0) {
return error.SDL_INIT_ERROR;
}
if (sdl_img.init(sdl_img.INIT_PNG) & sdl_img.INIT_PNG == 0) {
return error.IMG_INIT_ERROR;
}
}
fn deinitAll() void {
_ = sdl_img.quit();
_ = sdl.quit();
}
fn load(renderer: *sdl.Renderer, file_name: []const u8) !*sdl.Texture {
const surface_opt = sdl_img.load(file_name.ptr);
if (surface_opt == null) {
sdl_img.handleError("Error loading asset as surface");
return error.SurfaceLoadError;
}
defer sdl.freeSurface(surface_opt.?);
const texture_opt = sdl.createTextureFromSurface(renderer, surface_opt.?);
if (texture_opt == null) {
sdl_img.handleError("Error converting surface to texture");
return error.TextureCreationError;
}
return texture_opt.?;
}
fn generateGrid() Grid {
var grid = Grid{ .grid = [_]Cell{undefined} ** 81 };
var i: usize = 0;
while (i < 9) : (i += 1) {
var j: usize = 0;
while (j < 9) : (j += 1) {
grid.grid[i * 9 + j] = .{
.draw_position = sdl.Rect{
.x = drawLocation(Point{ .x = @intCast(i32, j), .y = @intCast(i32, i) }).x,
.y = drawLocation(Point{ .x = @intCast(i32, j), .y = @intCast(i32, i) }).y,
.w = 42,
.h = 42,
},
.current_value = null,
.corners = undefined,
.center = undefined,
};
}
}
return grid;
}
fn SingleArgWrapper(comptime T: type) type {
return struct {
value: T,
func: fn (*WorldData, T) void,
pub fn call(self: @This(), world: *WorldData) void {
self.func(world, self.value);
}
};
}
const VoidWrapper = struct {
func: fn (*WorldData) void,
pub fn call(self: @This(), world: *WorldData) void {
self.func(world);
}
};
const FuncWrapper = union(enum) {
Number: SingleArgWrapper(u8),
Position: SingleArgWrapper(Point),
Void: VoidWrapper,
pub fn call(self: @This(), world: *WorldData) void {
// there's gotta be a way to do a generic "whatever the active one is do the thing"
return switch (self) {
.Number => |v| v.call(world),
.Position => |v| v.call(world),
.Void => |v| v.call(world),
};
}
};
fn makeKeyMap() [1000]FuncWrapper {
const noopFuncWrapper = FuncWrapper{ .Void = .{ .func = noop } };
var keyboardActions = [_]FuncWrapper{noopFuncWrapper} ** 1000;
keyboardActions[sdl.SCANCODE_UP] = .{ .Position = .{ .value = Point{ .x = 0, .y = -1 }, .func = WorldData.updateSingleSelection } };
keyboardActions[sdl.SCANCODE_DOWN] = .{ .Position = .{ .value = Point{ .x = 0, .y = 1 }, .func = WorldData.updateSingleSelection } };
keyboardActions[sdl.SCANCODE_LEFT] = .{ .Position = .{ .value = Point{ .x = -1, .y = 0 }, .func = WorldData.updateSingleSelection } };
keyboardActions[sdl.SCANCODE_RIGHT] = .{ .Position = .{ .value = Point{ .x = 1, .y = 0 }, .func = WorldData.updateSingleSelection } };
keyboardActions[sdl.SCANCODE_C] = .{ .Void = .{ .func = checkSolution } };
keyboardActions[sdl.SCANCODE_R] = .{ .Void = .{ .func = resetGrid } };
keyboardActions[sdl.SCANCODE_1] = .{ .Number = .{ .value = 1, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_2] = .{ .Number = .{ .value = 2, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_3] = .{ .Number = .{ .value = 3, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_4] = .{ .Number = .{ .value = 4, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_5] = .{ .Number = .{ .value = 5, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_6] = .{ .Number = .{ .value = 6, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_7] = .{ .Number = .{ .value = 7, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_8] = .{ .Number = .{ .value = 8, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_9] = .{ .Number = .{ .value = 9, .func = WorldData.updateNumber } };
keyboardActions[sdl.SCANCODE_BACKSPACE] = .{ .Void = .{ .func = WorldData.deleteSelection } };
keyboardActions[sdl.SCANCODE_Z] = .{ .Void = .{ .func = WorldData.big } };
keyboardActions[sdl.SCANCODE_X] = .{ .Void = .{ .func = WorldData.centers } };
return keyboardActions;
}
fn noop(w: *WorldData) void {}
// Vanity, does an offset that makes a grid I happen to like
fn drawLocation(point: Point) Point {
return Point{
.x = @intCast(i32, point.x * 43 + 4 * (@divTrunc(point.x, 3) + 1) - 1),
.y = @intCast(i32, point.y * 43 + 4 * (@divTrunc(point.y, 3) + 1) - 1),
};
}
/// Initialize Once in practice
const WorldData = struct {
window: *sdl.Window,
renderer: *sdl.Renderer,
grid: Grid,
selected_cells: std.ArrayList(Point),
enter_state: State,
allocator: *Allocator, // unused right now but might as well keep it around
numbers: *sdl.Texture,
incorrect: bool = false,
victory: bool = false,
const Self = @This();
const State = enum {
Big,
Center,
};
pub fn init(alloc: *Allocator) !Self {
const window = try sdl.createWindow(
"Sudoku",
sdl.WINDOWPOS_CENTERED,
sdl.WINDOWPOS_CENTERED,
1280,
720,
.{sdl.WINDOW_SHOWN},
);
const renderer = try sdl.createRenderer(window, -1, .{});
_ = sdl.renderSetLogicalSize(renderer, 640, 480);
const big_numbers_texture = try load(renderer, "assets/big_numbers.png");
var grid = generateGrid();
var selected = try std.ArrayList(Point).initCapacity(alloc, grid.grid.len);
try selected.append(Point{ .x = 0, .y = 0 });
return WorldData{
.window = window,
.renderer = renderer,
.grid = grid,
.selected_cells = selected,
.enter_state = State.Big,
.allocator = alloc,
.numbers = big_numbers_texture,
};
}
pub fn deinit(self: *Self) void {
self.selected_cells.deinit();
sdl.destroyTexture(self.numbers);
_ = sdl.destroyRenderer(self.renderer);
_ = sdl.destroyWindow(self.window);
}
// ugly af but it does what I want
pub fn render(self: *Self) !void {
try sdl.setRenderDrawColor(self.renderer, sdl.WHITE);
try sdl.renderClear(self.renderer);
try sdl.setRenderDrawColor(self.renderer, sdl.BLACK);
if (self.incorrect) {
try sdl.setRenderDrawColor(self.renderer, sdl.RED);
} else if (self.victory) {
try sdl.setRenderDrawColor(self.renderer, sdl.GREEN);
}
const mode_rect = sdl.Rect{
.x = 475,
.y = 50,
.w = 150,
.h = 100,
};
try sdl.renderFillRect(self.renderer, &mode_rect);
try sdl.setRenderDrawColor(self.renderer, grey_boarder);
for (self.grid.grid) |cell| {
try sdl.renderDrawRect(self.renderer, &cell.draw_position);
// Draw the big number if it's been placed
if (cell.current_value) |value| {
const cv_expand: i32 = value;
const number_src = sdl.Rect{ .x = (cv_expand - 1) * 42, .y = 0, .w = 42, .h = 42 };
//const number_src = sdl.Rect{ .x = 0, .y = 0, .w = 42, .h = 42 };
const number_draw_pos = sdl.Rect{
.x = cell.draw_position.x + 2,
.y = cell.draw_position.y + 2,
.w = 38,
.h = 38,
};
try sdl.renderCopy(
self.renderer,
self.numbers,
&number_src,
&number_draw_pos,
);
} else {
// draw any of the little numbers we've annotated
var printed_values: i32 = 0;
var start_y: i32 = 7;
const start_x: i32 = 3;
for (cell.center) |b, idx| {
if (b) {
const number_src = sdl.Rect{ .x = @intCast(i32, idx) * 42, .y = 0, .w = 42, .h = 42 };
const small_number_draw = sdl.Rect{
.x = cell.draw_position.x + start_x + 7 * printed_values,
.y = cell.draw_position.y + start_y,
.w = 7,
.h = 10,
};
try sdl.renderCopy(
self.renderer,
self.numbers,
&number_src,
&small_number_draw,
);
printed_values += 1;
if (printed_values == 5) {
start_y = 22;
printed_values = 0;
}
}
}
}
}
try sdl.setRenderDrawColor(self.renderer, selected_color);
for (self.selected_cells.items) |pos| {
const cell = self.grid.at(pos);
try sdl.renderDrawRect(self.renderer, &cell.draw_position);
}
sdl.renderPresent(self.renderer);
}
pub fn updateSingleSelection(world: *Self, transform: Point) void {
std.debug.assert(world.selected_cells.items.len > 0);
const old_point = world.selected_cells.items[0];
const new_selection: Point = .{
.x = wrap(old_point.x + transform.x, 0, 9),
.y = wrap(old_point.y + transform.y, 0, 9),
};
world.selected_cells.items[0] = new_selection;
world.selected_cells.resize(1) catch unreachable; // always resizing less than capacity
// note because it's sudoku we list it as row, column rather than x, y
std.debug.warn(
"Updating selection from r{}c{} to r{}c{}\n",
.{ old_point.y + 1, old_point.x + 1, new_selection.y + 1, new_selection.x + 1 },
);
}
pub fn updateNumber(self: *Self, value: u8) void {
if (self.enter_state == State.Big) {
for (self.selected_cells.items) |pos| {
var cell = self.grid.at(pos);
cell.current_value = value; // TODO: world stat e.g. corner/center
std.debug.warn("Updating selection r{}c{} to value {}\n", .{ pos.y + 1, pos.x + 1, value });
}
} else {
for (self.selected_cells.items) |pos| {
var cell = self.grid.at(pos);
if (cell.current_value == null) {
cell.center[value - 1] = true; // TODO: world stat e.g. corner/center
std.debug.warn("Adding center value {} to selection r{}c{}\n", .{ value, pos.y + 1, pos.x + 1 });
}
}
}
}
pub fn deleteSelection(self: *Self) void {
for (self.selected_cells.items) |pos| {
// If we have a current "Big" number just delete the big number
// otherwise clear the cell
var cell = self.grid.at(pos);
if (cell.current_value != null) {
cell.current_value = null;
} else {
for (cell.center) |*b| {
b.* = false;
}
}
}
}
pub fn centers(self: *Self) void {
self.enter_state = State.Center;
}
pub fn big(self: *Self) void {
self.enter_state = State.Big;
}
};
/// Inclusive of lower_bound but exclusive of upper_bound
fn wrap(value: i32, lower_bound: i32, upper_bound: i32) i32 {
std.debug.assert((value >= lower_bound and value < upper_bound) or (value == lower_bound - 1) or (value == upper_bound));
if (value < lower_bound) {
return upper_bound - 1;
} else if (value >= upper_bound) {
return lower_bound;
} else {
return value;
}
}
const Point = struct {
x: i32,
y: i32,
};
const Cell = struct {
current_value: ?u8,
corners: [9]bool,
center: [9]bool,
draw_position: sdl.Rect,
};
const Grid = struct {
grid: [81]Cell,
const Self = @This();
pub fn at(self: *Self, point: Point) *Cell {
std.debug.assert(point.x >= 0 and point.y >= 0);
return &self.grid[@intCast(usize, point.y * 9 + point.x)];
}
};
// real bad impl
fn checkSolution(world: *WorldData) void {
// check rows
var grid = &world.grid;
var row: usize = 0;
while (row < 9) : (row += 1) {
var col: usize = 0;
var row_buffer = [1]u8{0} ** 9;
while (col < 9) : (col += 1) {
if (grid.at(Point{ .x = @intCast(i32, col), .y = @intCast(i32, row) }).current_value) |value| {
std.debug.assert(value > 0);
row_buffer[value - 1] += 1;
}
}
for (row_buffer) |value| {
if (value != 1) {
std.debug.warn("Solution is incorrect\n", .{});
world.incorrect = true;
return;
}
}
}
// row is now columns
row = 0;
while (row < 9) : (row += 1) {
var col: usize = 0; // col is actually rows
var col_buffer = [1]u8{0} ** 9;
while (col < 9) : (col += 1) {
if (grid.at(Point{ .x = @intCast(i32, col), .y = @intCast(i32, row) }).current_value) |value| {
std.debug.assert(value > 0);
col_buffer[value - 1] += 1;
}
}
for (col_buffer) |value| {
if (value != 1) {
std.debug.warn("Solution is incorrect\n", .{});
world.incorrect = true;
return;
}
}
}
// solution is correct
std.debug.warn("THE SOLUTION IS CORRECT!\n", .{});
for (grid.grid) |cell| {
std.debug.warn("{}, ", .{cell.current_value.?});
}
world.victory = true;
world.incorrect = false;
}
fn resetGrid(world: *WorldData) void {
const grid = &world.grid;
std.debug.warn("Resetting Grid\n", .{});
for (grid.grid) |*cell| {
cell.current_value = null;
for (cell.center) |*b| {
b.* = false;
}
}
world.victory = false;
world.incorrect = false;
} | src/main.zig |
usingnamespace @import("root").preamble;
const log = lib.output.log.scoped(.{
.prefix = "VMWARE",
.filter = .info,
}).write;
const ps2 = @import("ps2.zig");
const ports = @import("ports.zig");
const eoi = @import("apic.zig").eoi;
fn do_op(self: *const Command, port: u16, comptime str: []const u8) CommandResult {
var rax: u64 = undefined;
var rbx: u64 = undefined;
var rcx: u64 = undefined;
var rdx: u64 = undefined;
var rsi: u64 = undefined;
var rdi: u64 = undefined;
// zig fmt: off
asm volatile (str
: [_] "={rax}" (rax)
, [_] "={rbx}" (rbx)
, [_] "={rcx}" (rcx)
, [_] "={rdx}" (rdx)
, [_] "={rsi}" (rsi)
, [_] "={rdi}" (rdi)
// https://github.com/ziglang/zig/issues/8107
: [_] "{rax}" (@as(u64, VMWARE_MAGIC))
, [_] "{rbx}" (@as(u64, self.size))
, [_] "{rcx}" (@as(u64, self.command))
, [_] "{rdx}" (@as(u64, port))
, [_] "{rsi}" (@as(u64, self.source))
, [_] "{rdi}" (@as(u64, self.destination))
);
// zig fmt: on
return .{
.rax = rax,
.rbx = rbx,
.rcx = rcx,
.rdx = rdx,
.rsi = rsi,
.rdi = rdi,
};
}
fn send(cmd: Command) CommandResult {
return do_op(&cmd, VMWARE_PORT,
\\inl %%dx, %%eax
\\
);
}
fn send_hb(cmd: Command) CommandResult {
return do_op(&cmd, VMWARE_PORTHB,
\\rep outsb
\\
);
}
fn get_hb(cmd: Command) CommandResult {
return do_op(&cmd, VMWARE_PORTHB,
\\rep insb
\\
);
}
const Command = struct {
command: u16 = undefined,
size: usize = undefined,
source: usize = undefined,
destination: usize = undefined,
};
const CommandResult = struct {
rax: u64,
rbx: u64,
rcx: u64,
rdx: u64,
rsi: u64,
rdi: u64,
};
const VMWARE_MAGIC: u32 = 0x564D5868;
const VMWARE_PORT: u16 = 0x5658;
const VMWARE_PORTHB: u16 = 0x5659;
const CMD_GETVERSION: u16 = 10;
const CMD_ABSPOINTER_DATA: u16 = 39;
const CMD_ABSPOINTER_STATUS: u16 = 40;
const CMD_ABSPOINTER_COMMAND: u16 = 41;
const ABSPOINTER_ENABLE: u32 = 0x45414552;
const ABSPOINTER_RELATIVE: u32 = 0xF5;
const ABSPOINTER_ABSOLUTE: u32 = 0x53424152;
fn detect() bool {
const reply = send(.{
.command = CMD_GETVERSION,
});
if (@truncate(u32, reply.rbx) != VMWARE_MAGIC) return false;
if (@truncate(u32, reply.rax) == 0xFFFFFFFF) return false;
return true;
}
var counter: usize = 0;
fn abscurorInterruptHandler(frame: *os.platform.InterruptFrame) void {
// Drop byte from ps2 buffer
counter += 1;
_ = ports.inb(0x60);
if (counter == 3) {
counter = 0;
const status = send(.{
.command = CMD_ABSPOINTER_STATUS,
.size = 0,
});
if (@truncate(u32, status.rax) == 0xFFFF0000) {
unreachable; // Mouse problem
}
const num_packets = @divTrunc(@truncate(u16, status.rax), 4);
var i: u16 = 0;
while (i < num_packets) : (i += 1) {
const mouse_pkt = send(.{
.command = CMD_ABSPOINTER_DATA,
.size = 4,
});
const buttons = @truncate(u16, mouse_pkt.rax);
const rmb = (buttons & 0x10) != 0;
const lmb = (buttons & 0x20) != 0;
const mmb = (buttons & 0x08) != 0;
const scaled_x = @truncate(u16, mouse_pkt.rbx);
const scaled_y = @truncate(u16, mouse_pkt.rcx);
const scroll = @bitCast(i2, @truncate(u2, mouse_pkt.rdx));
}
}
eoi();
}
pub fn init() void {
if (comptime (!config.kernel.x86_64.vmware.enable))
return;
if (!detect()) {
log(.info, "Not detected", .{});
return;
}
log(.info, "Detected", .{});
var cmd = Command{};
if (comptime config.kernel.x86_64.vmware.abscursor) {
if (comptime (!config.kernel.x86_64.ps2.mouse.enable))
@compileError("PS/2 mouse has to be enabled for vmware cursor support");
log(.info, "Enabling abscursor...", .{});
const state = os.platform.get_and_disable_interrupts();
defer os.platform.set_interrupts(state);
_ = send(.{
.command = CMD_ABSPOINTER_COMMAND,
.size = ABSPOINTER_ENABLE,
});
_ = send(.{
.command = CMD_ABSPOINTER_STATUS,
.size = 0,
});
_ = send(.{
.command = CMD_ABSPOINTER_DATA,
.size = 1,
});
_ = send(.{
.command = CMD_ABSPOINTER_COMMAND,
.size = ABSPOINTER_ABSOLUTE,
});
@import("interrupts.zig").add_handler(ps2.mouse_interrupt_vector, abscurorInterruptHandler, true, 0, 1);
}
} | subprojects/flork/src/platform/x86_64/vmware.zig |
const std = @import("std");
const kernel = @import("root");
const mm = kernel.mm;
const x86 = kernel.arch.x86;
const lib = kernel.lib;
const PhysicalAddress = mm.PhysicalAddress;
const VirtualAddress = mm.VirtualAddress;
const paging = @import("paging.zig");
const PML4 = paging.PML4;
const PDPT = paging.PDPT;
const PD = paging.PD;
const PT = paging.PT;
const PageKind = paging.PageKind;
pub const VirtAddrType = u64;
pub const PhysAddrType = u64;
const BIT = kernel.lib.BIT;
const bit_set = kernel.lib.bit_set;
pub var logger = @TypeOf(x86.logger).childOf(@typeName(@This())){};
const KERNEL_MEMORY_MAP = [_]mm.VirtualMemoryRange{
DIRECT_MAPPING,
DYNAMIC_MAPPING,
KERNEL_IMAGE,
};
const DIRECT_MAPPING = mm.VirtualMemoryRange.sized(
VirtualAddress.new(0xffff800000000000),
lib.GiB(64),
);
const DYNAMIC_MAPPING = mm.VirtualMemoryRange.sized(
VirtualAddress.new(0xffff900000000000),
lib.TiB(1),
);
const KERNEL_IMAGE = mm.VirtualMemoryRange.sized(
VirtualAddress.new(0xffffffff80000000),
lib.GiB(1),
);
pub extern var kernel_end: [*]u8;
pub fn get_kernel_end() mm.VirtualAddress {
return mm.VirtualAddress.new(@ptrToInt(&kernel_end));
}
var direct_mapping: mm.DirectMapping = undefined;
pub fn directMapping() *mm.DirectMapping {
return &direct_mapping;
}
var main_allocator: mm.FrameAllocator = undefined;
pub fn frameAllocator() *mm.FrameAllocator {
return &main_allocator;
}
var kernel_vm: mm.VirtualMemory = undefined;
pub fn detect_memory() ?mm.PhysicalMemoryRange {
return x86.multiboot.get_multiboot_memory();
}
pub const VirtualMemoryImpl = struct {
allocator: *mm.FrameAllocator,
pml4: PML4,
dynamic_next: VirtualAddress,
dynamic_end: VirtualAddress,
const Self = @This();
const MapOptions = struct {
writable: bool,
user: bool,
write_through: bool,
cache_disable: bool,
no_execute: bool,
};
const Error = error{
InvalidSize,
UnalignedAddress,
MappingExists,
MappingNotExists,
};
pub fn init(frame_allocator: *mm.FrameAllocator) !VirtualMemoryImpl {
const frame = try frame_allocator.alloc_zero_frame();
return VirtualMemoryImpl{
.allocator = frame_allocator,
.pml4 = PML4.init(frame, null),
.dynamic_next = DYNAMIC_MAPPING.base,
.dynamic_end = DYNAMIC_MAPPING.get_end(),
};
}
pub fn switch_to(self: Self) void {
x86.CR3.write(self.pml4.root.value);
}
pub fn walk(self: Self, comptime T: type, context: *T) void {
self.pml4.walk(T, context);
}
fn map_page_4kb(
self: Self,
where: VirtualAddress,
what: PhysicalAddress,
options: *const MapOptions,
) !void {
if (!where.isAligned(lib.KiB(4)) or !what.isAligned(lib.KiB(4))) {
return Error.UnalignedAddress;
}
const pml4_index = PML4.get_slot(where);
const pdpt_index = PDPT.get_slot(where);
const pd_index = PD.get_slot(where);
const pt_index = PT.get_slot(where);
const pdpt = try self.pml4.get_pdpt_alloc(self.allocator, pml4_index);
const pd = try pdpt.get_pd_alloc(self.allocator, pdpt_index);
const pt = try pd.get_pt_alloc(self.allocator, pd_index);
if (pt.get_entry_kind(pt_index) != PT.EntryKind.Missing) {
return Error.MappingExists;
}
var flags: u64 = 0;
if (options.writable) {
flags |= PT.WRITABLE.v();
}
if (options.user) {
flags |= PT.USER.v();
}
if (options.write_through) {
flags |= PT.WRITE_THROUGH.v();
}
if (options.cache_disable) {
flags |= PT.CACHE_DISABLE.v();
}
flags |= PD.PRESENT.v();
pt.set_entry(pt_index, what.value | flags);
}
fn unmap_page_4kb(self: Self, where: VirtualAddress) !PhysicalAddress {
if (!where.isAligned(lib.KiB(4))) {
return Error.UnalignedAddress;
}
const pml4_index = PML4.get_slot(where);
const pdpt_index = PDPT.get_slot(where);
const pd_index = PD.get_slot(where);
const pt_index = PT.get_slot(where);
const pdpt = self.pml4.get_pdpt(pml4_index) orelse return Error.MappingNotExists;
const pd = pdpt.get_pd(pdpt_index) orelse return Error.MappingNotExists;
const pt = pd.get_pt(pd_index) orelse return Error.MappingNotExists;
if (pt.get_page(pt_index)) |page| {
pt.set_entry(pt_index, 0);
return page;
}
return Error.MappingNotExists;
}
fn map_page_2mb(
self: Self,
where: VirtualAddress,
what: PhysicalAddress,
options: *const MapOptions,
) !void {
if (!where.isAligned(lib.MiB(2)) or !what.isAligned(lib.MiB(2))) {
return Error.UnalignedAddress;
}
const pml4_index = PML4.get_slot(where);
const pdpt_index = PDPT.get_slot(where);
const pd_index = PD.get_slot(where);
const pdpt = try self.pml4.get_pdpt_alloc(self.allocator, pml4_index);
const pd = try pdpt.get_pd_alloc(self.allocator, pdpt_index);
if (pd.get_entry_kind(pd_index) != PD.EntryKind.Missing) {
return Error.MappingExists;
}
var flags: u64 = 0;
if (options.writable) {
flags |= PD.WRITABLE.v();
}
if (options.user) {
flags |= PD.USER.v();
}
if (options.write_through) {
flags |= PD.WRITE_THROUGH.v();
}
if (options.cache_disable) {
flags |= PD.CACHE_DISABLE.v();
}
flags |= PD.PRESENT.v() | PD.PAGE_2M.v();
pd.set_entry(pd_index, what.value | flags);
}
fn unmap_page_2mb(self: *Self, where: VirtualAddress) !PhysicalAddress {
if (!where.isAligned(lib.MiB(2))) {
return Error.UnalignedAddress;
}
const pml4_index = PML4.get_slot(where);
const pdpt_index = PDPT.get_slot(where);
const pd_index = PD.get_slot(where);
const pdpt = self.pml4.get_pdpt(pml4_index) orelse return Error.MappingNotExists;
const pd = pdpt.get_pd(pdpt_index) orelse return Error.MappingNotExists;
if (pd.get_page_2m(pd_index)) |phys| {
pd.set_entry(pd_index, 0);
return phys;
}
return Error.MappingNotExists;
}
pub fn map_addr(
self: Self,
where: VirtualAddress,
what: PhysicalAddress,
length: usize,
options: *const MapOptions,
) !void {
switch (length) {
lib.KiB(4) => return self.map_page_4kb(where, what, options),
lib.MiB(2) => return self.map_page_2mb(where, what, options),
lib.GiB(1) => @panic("Unimplemented"),
else => return Error.InvalidSize,
}
}
pub fn map_range(
self: Self,
where: VirtualAddress,
what: PhysicalAddress,
size: usize,
options: *const MapOptions,
) !mm.VirtualMemoryRange {
// Align to smallest page
var left = std.mem.alignForward(size, PageKind.Page4K.size());
var done: usize = 0;
var unit: PageKind = undefined;
while (left != 0) : ({
left -= unit.size();
done += unit.size();
}) {
const where_addr = where.add(done);
const what_addr = what.add(done);
const use_2mb = init: {
if (!where_addr.isAligned(lib.MiB(2))) {
break :init false;
}
if (!what_addr.isAligned(lib.MiB(2))) {
break :init false;
}
if (left < lib.MiB(2)) {
break :init false;
}
break :init true;
};
if (use_2mb) {
unit = PageKind.Page2M;
} else {
unit = PageKind.Page4K;
}
logger.debug("Mapping {} to {} ({x})\n", .{ what_addr, where_addr, unit });
self.map_addr(where_addr, what_addr, unit.size(), options) catch |err| {
logger.log("{}\n", .{err});
@panic("Failed to setup direct mapping");
};
}
return mm.VirtualMemoryRange{ .base = where, .size = done };
}
pub fn map_memory(
self: Self,
where: VirtualAddress,
what: PhysicalAddress,
size: usize,
protection: kernel.mm.VirtualMemory.Protection,
) !mm.VirtualMemoryRange {
const options = MapOptions{
.writable = protection.write,
.user = protection.user,
.write_through = false,
.cache_disable = true,
.no_execute = !protection.execute,
};
return self.map_range(where, what, size, &options);
}
pub fn map_io(self: *Self, what: PhysicalAddress, size: usize) !mm.VirtualMemoryRange {
const options = MapOptions{
.writable = true,
.user = false,
.write_through = false,
.cache_disable = true,
.no_execute = false,
};
const range = try self.map_range(self.dynamic_next, what, size, &options);
self.dynamic_next = self.dynamic_next.add(range.size);
return range;
}
fn get_page_kind(self: *const Self, where: VirtualAddress) ?PageKind {
const pml4_index = PML4.get_slot(where);
const pdpt_index = PDPT.get_slot(where);
const pd_index = PD.get_slot(where);
const pt_index = PT.get_slot(where);
const pdpt = self.pml4.get_pdpt(pml4_index) orelse return null;
switch (pdpt.get_entry_kind(pdpt_index)) {
.Missing => return null,
.Page1G => return .Page1G,
.PD => {
const pd = pdpt.get_pd(pdpt_index) orelse return null;
switch (pd.get_entry_kind(pd_index)) {
.Missing => return null,
.Page2M => return .Page2M,
.PageTable => {
const pt = pd.get_pt(pd_index) orelse return null;
switch (pt.get_entry_kind(pt_index)) {
.Page4K => return .Page4K,
.Missing => return null,
}
},
}
},
}
return null;
}
pub fn unmap(self: *Self, range: mm.VirtualMemoryRange) !void {
logger.setLevel(.Debug);
defer logger.setLevel(.Info);
var left = range;
while (left.size > lib.KiB(4)) {
const kind = self.get_page_kind(left.base) orelse {
logger.err("Tried to unmap page at {}, but there's none\n", left.base);
return Error.MappingNotExists;
};
switch (kind) {
.Page4K => {
if (!left.base.isAligned(lib.KiB(4))) {
left.base.value = std.mem.alignBackward(left.base.value, lib.KiB(4));
}
_ = self.unmap_page_4kb(left.base) catch |err| {
logger.err("Failed to unmap 4KiB page at {}\n", left.base);
return err;
};
left.base = left.base.add(lib.KiB(4));
},
.Page2M => {
if (!left.base.isAligned(lib.MiB(2))) {
left.base.value = std.mem.alignBackward(left.base.value, lib.MiB(2));
}
_ = self.unmap_page_2mb(left.base) catch |err| {
logger.err("Failed to unmap 2MiB page at {}\n", left.base);
return err;
};
left.base = left.base.add(lib.MiB(2));
},
.Page1G => @panic("Unimplemented"),
}
}
paging.flushTlb();
}
};
pub var kernel_vm_impl: VirtualMemoryImpl = undefined;
fn setup_kernel_vm() !void {
// Initialize generic kernel VM
mm.kernel_vm = mm.VirtualMemory.init(&kernel_vm_impl);
// Initial 1GiB mapping
logger.debug("Identity mapping 1GiB from 0 phys\n", .{});
const initial_mapping_size = lib.GiB(1);
_ = try mm.kernel_vm.map_memory(
DIRECT_MAPPING.base,
PhysicalAddress.new(0x0),
initial_mapping_size,
mm.VirtualMemory.Protection.RWX,
);
// Map kernel image
logger.debug("Mapping kernel image\n", .{});
const kern_end = VirtualAddress.new(@ptrToInt(&kernel_end));
const kernel_size = VirtualAddress.span(KERNEL_IMAGE.base, kern_end);
_ = mm.kernel_vm.map_memory(
KERNEL_IMAGE.base,
PhysicalAddress.new(0),
std.mem.alignForward(kernel_size, lib.MiB(2)),
mm.VirtualMemory.Protection.RWX,
) catch |err| {
logger.log("{}\n", .{err});
@panic("Failed to remap kernel");
};
logger.debug("Switching to new virtual memory\n", .{});
mm.kernel_vm.switch_to();
logger.debug("Survived switching to kernel VM\n", .{});
// switch to new virtual memory
directMapping().virt_start = DIRECT_MAPPING.base;
directMapping().size = initial_mapping_size;
kernel.mm.dump_vm_mappings(&mm.kernel_vm);
logger.debug("Mapping rest of direct memory\n", .{});
_ = try mm.kernel_vm.map_memory(
DIRECT_MAPPING.base.add(initial_mapping_size),
PhysicalAddress.new(0 + initial_mapping_size),
lib.GiB(63),
mm.VirtualMemory.Protection.RWX,
);
directMapping().virt_start = DIRECT_MAPPING.base;
directMapping().size = lib.GiB(64);
logger.debug("VM setup done\n", .{});
}
pub fn init() void {
const mem = x86.mm.detect_memory();
if (mem == null) {
@panic("Unable to find any free memory!");
}
var free_memory = mem.?;
// Ensure we don't overwrite kernel
const kend = x86.mm.directMapping().to_phys(x86.mm.get_kernel_end());
// Move beginning to after kernel
const begin = kend.max(free_memory.base);
const adjusted_memory = mm.PhysicalMemoryRange.from_range(begin, free_memory.get_end());
logger.log("Detected {}MiB of free memory\n", .{adjusted_memory.size / 1024 / 1024});
// Initialize physical memory allocator
main_allocator = mm.FrameAllocator.new(adjusted_memory);
// Initialize x86 VM implementation
kernel_vm_impl = VirtualMemoryImpl.init(&main_allocator) catch {
@panic("Failed to initialize VM implementation");
};
setup_kernel_vm() catch {
@panic("Failed to initialize kernel VM implementation");
};
logger.log("Memory subsystem initialized\n", .{});
} | kernel/arch/x86/mm.zig |
const std = @import("std");
const opt = @import("opt.zig");
const comparator = @import("ls.zig").compare_words;
const warn = std.debug.warn;
const Allocator = std.mem.Allocator;
const stdout = &std.io.getStdOut().outStream();
/// memory belongs to caller
pub fn sort(allocator: *Allocator, file: std.fs.File, options: PrintOptions) !std.ArrayList([]u8) {
var lines = std.ArrayList([]u8).init(allocator);
while (true) {
var line: []u8 = get_line(allocator, file) catch |err| {
if (err == error.EndOfStream) break;
return err;
};
try lines.append(line);
}
std.sort.sort([]const u8, lines.items[0..], {}, comparator);
if (options == PrintOptions.Reverse) {
var i: u32 = 0;
while (i < lines.items.len / 2) : (i += 1) {
var temp = lines.items[i];
lines.items[i] = lines.items[lines.items.len - i - 1];
lines.items[lines.items.len - i - 1] = temp;
}
}
return lines;
}
/// Get a single line of file -- needs to be freed bor
pub fn get_line(allocator: *Allocator, file: std.fs.File) ![]u8 {
var char: u8 = undefined;
var stream = std.fs.File.inStream(file);
var i: u64 = 0;
char = try stream.readByte(); // err if no stream
var buffer: []u8 = try allocator.alloc(u8, 0);
while (char != -1) : (char = stream.readByte() catch {
return buffer;
}) {
if (char == '\n') break;
buffer = try allocator.realloc(buffer, i + 1);
buffer[i] = char;
i += 1;
}
return buffer;
}
const SortFlags = enum {
Help,
Version,
Reverse,
};
var flags = [_]opt.Flag(SortFlags){
.{
.name = SortFlags.Help,
.long = "help",
},
.{
.name = SortFlags.Version,
.long = "version",
},
.{
.name = SortFlags.Reverse,
.short = 'r',
},
};
const PrintOptions = enum {
Reverse,
Default,
};
pub fn main(args: [][]u8) anyerror!u8 {
var options: PrintOptions = PrintOptions.Default;
var it = opt.FlagIterator(SortFlags).init(flags[0..], args);
while (it.next_flag() catch {
return 1;
}) |flag| {
switch (flag.name) {
SortFlags.Help => {
warn("{} [-r] [FILE_NAME]\n", .{args[0]});
return 0;
},
SortFlags.Version => {
warn("TODO", .{});
return 0;
},
SortFlags.Reverse => {
options = PrintOptions.Reverse;
},
}
}
var input = it.next_arg();
var lines: std.ArrayList([]u8) = undefined;
if (input) |name| {
const file = std.fs.cwd().openFile(name[0..], std.fs.File.OpenFlags{ .read = true, .write = false }) catch |err| {
try stdout.print("Error: cannot open file {}\n", .{name});
return 1;
};
lines = try sort(std.heap.page_allocator, file, options);
file.close();
} else {
// stdin
lines = try sort(std.heap.page_allocator, std.io.getStdIn(), options);
}
for (lines.items) |line| {
warn("{}\n", .{line});
std.heap.page_allocator.free(line);
}
lines.deinit();
return 0;
}
test "basic sort test" {
const file = try std.fs.cwd().createFile("/tmp/testshuff", std.fs.File.CreateFlags{ .read = true });
_ = try file.write(
\\2
\\1
\\3
\\4
\\5
);
const expected = [5][1]u8{ [_]u8{'1'}, [_]u8{'2'}, [_]u8{'3'}, [_]u8{'4'}, [_]u8{'5'} };
// seek back to start
try file.seekTo(0);
var result = try sort(std.heap.page_allocator, file, PrintOptions.Default);
file.close();
var i: u8 = 0;
while (i < result.items.len) : (i += 1) {
std.debug.assert(std.mem.eql(u8, result.items[i], expected[i][0..]));
std.heap.page_allocator.free(result.items[i]);
}
result.deinit();
} | src/sort.zig |
const std = @import("std");
const build_options = @import("build_options");
const fb = @import("console/fb.zig");
const printf = fb.printf;
const arch = @import("arch.zig");
const hw = @import("hw.zig");
pub const Shell = struct {
pub fn run() void {
var sh = Shell{};
sh.exec();
}
fn exec(self: *Shell) void {
printf("> ", .{});
var last_buf: [256]u8 = undefined;
var last_len: u8 = 0;
var buf: [256]u8 = undefined;
var len: u8 = 0;
var uart_buf: [16]u8 = [_]u8{undefined} ** 16;
var state: enum { normal, escape, escape_lbr } = .normal;
while (true) {
fb.placechar('\xdb');
var recv = hw.uart.readBlock(&uart_buf) catch return;
fb.placechar(' ');
for (uart_buf[0..recv]) |c| {
switch (state) {
.normal => switch (c) {
8, 127 => {
if (len > 0) {
printf("\x08 \x08", .{});
len -= 1;
}
},
21 => {
while (len > 0) : (len -= 1) {
printf("\x08 \x08", .{});
}
},
23 => {
// ^W
},
27 => state = .escape,
'\t' => {
const maybe_rest = self.autocomplete(buf[0..len]) catch |err| switch (err) {
error.PromptNeedsRedraw => {
printf("> {s}", .{buf[0..len]});
continue;
},
};
if (maybe_rest) |rest| {
std.mem.copy(u8, buf[len..], rest);
printf("{s}", .{rest});
len += @truncate(u8, rest.len);
}
},
'\r' => {
printf("\n", .{});
std.mem.copy(u8, &last_buf, buf[0..len]);
last_len = len;
self.process(buf[0..len]);
printf("> ", .{});
len = 0;
},
'a'...'z', 'A'...'Z', '0'...'9', '=', '\\', '^', '+', ':', '%', '@', '&', '!', '(', '[', '{', '<', ' ', '#', '$', '"', '\'', ',', '.', '_', '~', '`', '-', '/', '*', '>', '}', ']', ')', '?' => {
buf[len] = c;
len += 1;
printf("{c}", .{c});
},
else => {
printf("?{}?", .{c});
},
},
.escape => switch (c) {
'[' => state = .escape_lbr,
else => state = .normal,
},
.escape_lbr => switch (c) {
'A', 'B' => {
var i: u8 = len;
while (i > 0) : (i -= 1) {
printf("\x08 \x08", .{});
}
std.mem.swap([256]u8, &last_buf, &buf);
std.mem.swap(u8, &last_len, &len);
printf("{s}", .{buf[0..len]});
state = .normal;
},
else => state = .normal,
},
}
}
}
}
const AUTOCOMPLETES: []const []const u8 = &.{
"echo ",
"help ",
"paging ",
"paging dump ",
"poweroff ",
"reset ",
};
const AutocompleteError = error{PromptNeedsRedraw};
fn autocomplete(self: *Shell, buf: []const u8) AutocompleteError!?[]const u8 {
var maybe_match: ?[]const u8 = null;
var ambiguous = false;
for (AUTOCOMPLETES) |candidate| {
if (std.mem.startsWith(u8, candidate, buf)) {
if (ambiguous) {
printf("{s}", .{candidate});
continue;
}
if (maybe_match) |match| {
// Multiple matches. If the existing match is a strict prefix, ignore this
// to allow prefix completion.
// Otherwise we can't continue due to multiple possible matches; start dumping
// all potential matches.
if (std.mem.startsWith(u8, candidate, match)) {
continue;
}
printf("\n{s}{s}", .{ match, candidate });
ambiguous = true;
continue;
}
maybe_match = candidate;
}
}
if (ambiguous) {
printf("\n", .{});
return error.PromptNeedsRedraw;
}
if (maybe_match) |match| {
return match[buf.len..];
}
return null;
}
fn process(self: *Shell, cmd: []const u8) void {
const trimmed = std.mem.trim(u8, cmd, " \t");
if (std.mem.eql(u8, trimmed, "reset")) {
arch.reset();
} else if (std.mem.eql(u8, trimmed, "poweroff")) {
arch.poweroff();
} else if (std.mem.eql(u8, trimmed, "echo")) {
printf("\n", .{});
} else if (std.mem.startsWith(u8, trimmed, "echo ")) {
printf("{s}\n", .{trimmed["echo ".len..]});
} else if (std.mem.eql(u8, trimmed, "help")) {
self.help();
} else if (std.mem.eql(u8, trimmed, "paging")) {
self.paging("");
} else if (std.mem.eql(u8, trimmed, "paging ")) {
self.paging(std.mem.trim(u8, trimmed["paging ".len..], " \t"));
} else if (trimmed.len == 0) {
// nop
} else {
printf("unknown command: {s}\n", .{trimmed});
}
}
fn help(self: *Shell) void {
printf(
\\daintree kernel shell ({s} on {s})
\\
\\echo Print a blank line.
\\echo STRING Print a given string.
\\help Show this help.
\\paging Paging commands.
\\poweroff Power the board off.
\\reset Reset the system.
\\
,
.{ build_options.version, build_options.board },
);
}
fn paging(self: *Shell, cmd: []const u8) void {
if (cmd.len == 0) {
printf(
\\Paging commands.
\\
\\paging Show this help.
\\paging dump Dump the page table trees.
\\
,
.{},
);
} else if (std.mem.eql(u8, cmd, "dump")) {
// TODO -- need to unify arm/riscv entry files first.
} else {
printf("unknown paging command: {s}\n", .{cmd});
}
}
}; | dainkrnl/src/shell.zig |
const std = @import("std");
usingnamespace @import("wren.zig");
const data = @import("data.zig");
/// Should be bound to config.bindForeignMethodFn
pub fn foreignMethodFn(
vm:?*VM,
module:CString,
className:CString,
isStatic:bool,
signature:CString
) callconv(.C) ForeignMethodFnC {
if(util.matches(module,"meta")) {
return metaBindForeignMethod(vm,className,isStatic,signature);
}
if(util.matches(module,"random")) {
return randomBindForeignMethod(vm,className,isStatic,signature);
}
return foreign.findMethod(
vm,
std.mem.span(module),
std.mem.span(className),
std.mem.span(signature),
isStatic
) catch unreachable;
}
/// Should be bound to config.bindForeignMethodFn
pub fn bindForeignClassFn (
vm:?*VM,
module:CString,
className:CString
) callconv(.C) ForeignClassMethods {
if(util.matches(module,"random")) {
return randomBindForeignClass(vm,module,className);
}
return foreign.findClass(vm,std.mem.span(module),std.mem.span(className)) catch {
return .{
.allocate = null,
.finalize = null
};
};
}
/// Should be bound to config.loadModuleFn
pub fn loadModuleFn(vm:?*VM,name:CString) callconv(.C) LoadModuleResult {
_=vm;
if(util.matches(name,"meta")) {
return .{.source = metaSource(), .onComplete = null, .userData = null};
}
if(util.matches(name,"random")) {
return .{.source = randomSource(), .onComplete = null, .userData = null};
}
var src = util.loadWrenSourceFile(data.allocator,std.mem.span(name)) catch unreachable;
return .{
.source = src,
.onComplete = loadModuleCompleteFn, // ?fn, called on done running to free mem
.userData = null, // ?*c_void
};
}
/// Should be bound to the callback of the loadModuleFn definition
pub fn loadModuleCompleteFn (vm:?*VM,module:CString,result:LoadModuleResult) callconv(.C) void {
_=vm;
_=module;
if(result.source != null) {
var slice_len = std.mem.sliceTo(result.source,0).len;
data.allocator.free(result.source[0..slice_len]);
}
}
/// Should be bound to config.writeFn
pub fn writeFn(vm:?*VM, text:CString) callconv(.C) void {
_=vm;
std.debug.print("{s}",.{text});
}
/// Should be bound to config.errorFn
pub fn errorFn(vm:?*VM, err_type:ErrorType, module:CString, line:c_int, msg:CString) callconv(.C) void {
_=vm;
var err_desc = switch(@intToEnum(ErrType,err_type)) {
.compile => "Compile Error",
.runtime => "Runtime Error",
.stack_trace => "Stack Trace",
};
std.debug.print("{s} @ ",.{err_desc});
if(module) |mod| {
std.debug.print("{s}:{}\n",.{mod,line});
} else std.debug.print("{s}:{}\n",.{"[null]",line});
if(msg) |mg| {
std.debug.print(">> {s}\n",.{mg});
} else std.debug.print(">> {s}\n",.{"[null]"});
} | src/bindings.zig |
usingnamespace @import("psptypes.zig");
pub const struct_SceKernelSysClock = extern struct {
low: SceUInt32,
hi: SceUInt32,
};
pub const SceKernelSysClock = struct_SceKernelSysClock;
pub const enum_PspThreadAttributes = extern enum(u32) {
PSP_THREAD_ATTR_VFPU = 16384,
PSP_THREAD_ATTR_USER = 2147483648,
PSP_THREAD_ATTR_USBWLAN = 2684354560,
PSP_THREAD_ATTR_VSH = 3221225472,
PSP_THREAD_ATTR_SCRATCH_SRAM = 32768,
PSP_THREAD_ATTR_NO_FILLSTACK = 1048576,
PSP_THREAD_ATTR_CLEAR_STACK = 2097152,
_,
};
pub const SceKernelThreadEntry = ?fn (SceSize, ?*c_void) callconv(.C) c_int;
pub const struct_SceKernelThreadOptParam = extern struct {
size: SceSize,
stackMpid: SceUID,
};
pub const SceKernelThreadOptParam = struct_SceKernelThreadOptParam;
pub const struct_SceKernelThreadInfo = extern struct {
size: SceSize,
name: [32]u8,
attr: SceUInt,
status: c_int,
entry: SceKernelThreadEntry,
stack: ?*c_void,
stackSize: c_int,
gpReg: ?*c_void,
initPriority: c_int,
currentPriority: c_int,
waitType: c_int,
waitId: SceUID,
wakeupCount: c_int,
exitStatus: c_int,
runClocks: SceKernelSysClock,
intrPreemptCount: SceUInt,
threadPreemptCount: SceUInt,
releaseCount: SceUInt,
};
pub const SceKernelThreadInfo = struct_SceKernelThreadInfo;
pub const struct_SceKernelThreadRunStatus = extern struct {
size: SceSize,
status: c_int,
currentPriority: c_int,
waitType: c_int,
waitId: c_int,
wakeupCount: c_int,
runClocks: SceKernelSysClock,
intrPreemptCount: SceUInt,
threadPreemptCount: SceUInt,
releaseCount: SceUInt,
};
pub const SceKernelThreadRunStatus = struct_SceKernelThreadRunStatus;
pub const enum_PspThreadStatus = extern enum(c_int) {
PSP_THREAD_RUNNING = 1,
PSP_THREAD_READY = 2,
PSP_THREAD_WAITING = 4,
PSP_THREAD_SUSPEND = 8,
PSP_THREAD_STOPPED = 16,
PSP_THREAD_KILLED = 32,
_,
};
pub extern fn sceKernelDeleteThread(thid: SceUID) c_int;
pub extern fn sceKernelStartThread(thid: SceUID, arglen: SceSize, argp: ?*c_void) c_int;
pub extern fn sceKernelExitThread(status: c_int) c_int;
pub extern fn sceKernelExitDeleteThread(status: c_int) c_int;
pub extern fn sceKernelTerminateThread(thid: SceUID) c_int;
pub extern fn sceKernelTerminateDeleteThread(thid: SceUID) c_int;
pub extern fn sceKernelSuspendDispatchThread() c_int;
pub extern fn sceKernelResumeDispatchThread(state: c_int) c_int;
pub extern fn sceKernelSleepThread() c_int;
pub extern fn sceKernelSleepThreadCB() c_int;
pub extern fn sceKernelWakeupThread(thid: SceUID) c_int;
pub extern fn sceKernelCancelWakeupThread(thid: SceUID) c_int;
pub extern fn sceKernelSuspendThread(thid: SceUID) c_int;
pub extern fn sceKernelResumeThread(thid: SceUID) c_int;
pub extern fn sceKernelWaitThreadEnd(thid: SceUID, timeout: [*c]SceUInt) c_int;
pub extern fn sceKernelWaitThreadEndCB(thid: SceUID, timeout: [*c]SceUInt) c_int;
pub extern fn sceKernelDelayThread(delay: u32) c_int;
pub extern fn sceKernelDelayThreadCB(delay: SceUInt) c_int;
pub extern fn sceKernelDelaySysClockThread(delay: [*c]SceKernelSysClock) c_int;
pub extern fn sceKernelDelaySysClockThreadCB(delay: [*c]SceKernelSysClock) c_int;
pub extern fn sceKernelChangeCurrentThreadAttr(unknown: c_int, attr: SceUInt) c_int;
pub extern fn sceKernelChangeThreadPriority(thid: SceUID, priority: c_int) c_int;
pub extern fn sceKernelRotateThreadReadyQueue(priority: c_int) c_int;
pub extern fn sceKernelReleaseWaitThread(thid: SceUID) c_int;
pub extern fn sceKernelGetThreadId() c_int;
pub extern fn sceKernelGetThreadCurrentPriority() c_int;
pub extern fn sceKernelGetThreadExitStatus(thid: SceUID) c_int;
pub extern fn sceKernelCheckThreadStack() c_int;
pub extern fn sceKernelGetThreadStackFreeSize(thid: SceUID) c_int;
pub extern fn sceKernelReferThreadStatus(thid: SceUID, info: [*c]SceKernelThreadInfo) c_int;
pub extern fn sceKernelReferThreadRunStatus(thid: SceUID, status: [*c]SceKernelThreadRunStatus) c_int;
pub const struct_SceKernelSemaOptParam = extern struct {
size: SceSize,
};
pub const SceKernelSemaOptParam = struct_SceKernelSemaOptParam;
pub const struct_SceKernelSemaInfo = extern struct {
size: SceSize,
name: [32]u8,
attr: SceUInt,
initCount: c_int,
currentCount: c_int,
maxCount: c_int,
numWaitThreads: c_int,
};
pub const SceKernelSemaInfo = struct_SceKernelSemaInfo;
pub extern fn sceKernelCreateSema(name: [*c]const u8, attr: SceUInt, initVal: c_int, maxVal: c_int, option: [*c]SceKernelSemaOptParam) SceUID;
pub extern fn sceKernelDeleteSema(semaid: SceUID) c_int;
pub extern fn sceKernelSignalSema(semaid: SceUID, signal: c_int) c_int;
pub extern fn sceKernelWaitSema(semaid: SceUID, signal: c_int, timeout: [*c]SceUInt) c_int;
pub extern fn sceKernelWaitSemaCB(semaid: SceUID, signal: c_int, timeout: [*c]SceUInt) c_int;
pub extern fn sceKernelPollSema(semaid: SceUID, signal: c_int) c_int;
pub extern fn sceKernelReferSemaStatus(semaid: SceUID, info: [*c]SceKernelSemaInfo) c_int;
pub const struct_SceKernelEventFlagInfo = extern struct {
size: SceSize,
name: [32]u8,
attr: SceUInt,
initPattern: SceUInt,
currentPattern: SceUInt,
numWaitThreads: c_int,
};
pub const SceKernelEventFlagInfo = struct_SceKernelEventFlagInfo;
pub const struct_SceKernelEventFlagOptParam = extern struct {
size: SceSize,
};
pub const SceKernelEventFlagOptParam = struct_SceKernelEventFlagOptParam;
pub const enum_PspEventFlagAttributes = extern enum(c_int) {
PSP_EVENT_WAITMULTIPLE = 512,
_,
};
pub const enum_PspEventFlagWaitTypes = extern enum(c_int) {
PSP_EVENT_WAITAND = 0,
PSP_EVENT_WAITOR = 1,
PSP_EVENT_WAITCLEAR = 32,
_,
};
pub extern fn sceKernelCreateEventFlag(name: [*c]const u8, attr: c_int, bits: c_int, opt: [*c]SceKernelEventFlagOptParam) SceUID;
pub extern fn sceKernelSetEventFlag(evid: SceUID, bits: u32) c_int;
pub extern fn sceKernelClearEventFlag(evid: SceUID, bits: u32) c_int;
pub extern fn sceKernelPollEventFlag(evid: c_int, bits: u32, wait: u32, outBits: [*c]u32) c_int;
pub extern fn sceKernelWaitEventFlag(evid: c_int, bits: u32, wait: u32, outBits: [*c]u32, timeout: [*c]SceUInt) c_int;
pub extern fn sceKernelWaitEventFlagCB(evid: c_int, bits: u32, wait: u32, outBits: [*c]u32, timeout: [*c]SceUInt) c_int;
pub extern fn sceKernelDeleteEventFlag(evid: c_int) c_int;
pub extern fn sceKernelReferEventFlagStatus(event: SceUID, status: [*c]SceKernelEventFlagInfo) c_int;
pub const struct_SceKernelMbxOptParam = extern struct {
size: SceSize,
};
pub const SceKernelMbxOptParam = struct_SceKernelMbxOptParam;
pub const struct_SceKernelMbxInfo = extern struct {
size: SceSize,
name: [32]u8,
attr: SceUInt,
numWaitThreads: c_int,
numMessages: c_int,
firstMessage: ?*c_void,
};
pub const SceKernelMbxInfo = struct_SceKernelMbxInfo;
pub const struct_SceKernelMsgPacket = extern struct {
next: [*c]struct_SceKernelMsgPacket,
msgPriority: SceUChar,
dummy: [3]SceUChar,
};
pub const SceKernelMsgPacket = struct_SceKernelMsgPacket;
pub extern fn sceKernelCreateMbx(name: [*c]const u8, attr: SceUInt, option: [*c]SceKernelMbxOptParam) SceUID;
pub extern fn sceKernelDeleteMbx(mbxid: SceUID) c_int;
pub extern fn sceKernelSendMbx(mbxid: SceUID, message: ?*c_void) c_int;
pub extern fn sceKernelReceiveMbx(mbxid: SceUID, pmessage: [*c]?*c_void, timeout: [*c]SceUInt) c_int;
pub extern fn sceKernelReceiveMbxCB(mbxid: SceUID, pmessage: [*c]?*c_void, timeout: [*c]SceUInt) c_int;
pub extern fn sceKernelPollMbx(mbxid: SceUID, pmessage: [*c]?*c_void) c_int;
pub extern fn sceKernelCancelReceiveMbx(mbxid: SceUID, pnum: [*c]c_int) c_int;
pub extern fn sceKernelReferMbxStatus(mbxid: SceUID, info: [*c]SceKernelMbxInfo) c_int;
pub const SceKernelAlarmHandler = ?fn (?*c_void) callconv(.C) SceUInt;
pub const struct_SceKernelAlarmInfo = extern struct {
size: SceSize,
schedule: SceKernelSysClock,
handler: SceKernelAlarmHandler,
common: ?*c_void,
};
pub const SceKernelAlarmInfo = struct_SceKernelAlarmInfo;
pub extern fn sceKernelSetAlarm(clock: SceUInt, handler: SceKernelAlarmHandler, common: ?*c_void) SceUID;
pub extern fn sceKernelSetSysClockAlarm(clock: [*c]SceKernelSysClock, handler: SceKernelAlarmHandler, common: ?*c_void) SceUID;
pub extern fn sceKernelCancelAlarm(alarmid: SceUID) c_int;
pub extern fn sceKernelReferAlarmStatus(alarmid: SceUID, info: [*c]SceKernelAlarmInfo) c_int;
pub const SceKernelCallbackFunction = ?fn (c_int, c_int, ?*c_void) callconv(.C) c_int;
pub const struct_SceKernelCallbackInfo = extern struct {
size: SceSize,
name: [32]u8,
threadId: SceUID,
callback: SceKernelCallbackFunction,
common: ?*c_void,
notifyCount: c_int,
notifyArg: c_int,
};
pub const SceKernelCallbackInfo = struct_SceKernelCallbackInfo;
pub extern fn sceKernelCreateCallback(name: [*c]const u8, func: SceKernelCallbackFunction, arg: ?*c_void) c_int;
pub extern fn sceKernelReferCallbackStatus(cb: SceUID, status: [*c]SceKernelCallbackInfo) c_int;
pub extern fn sceKernelDeleteCallback(cb: SceUID) c_int;
pub extern fn sceKernelNotifyCallback(cb: SceUID, arg2: c_int) c_int;
pub extern fn sceKernelCancelCallback(cb: SceUID) c_int;
pub extern fn sceKernelGetCallbackCount(cb: SceUID) c_int;
pub extern fn sceKernelCheckCallback() c_int;
pub const enum_SceKernelIdListType = extern enum(c_int) {
SCE_KERNEL_TMID_Thread = 1,
SCE_KERNEL_TMID_Semaphore = 2,
SCE_KERNEL_TMID_EventFlag = 3,
SCE_KERNEL_TMID_Mbox = 4,
SCE_KERNEL_TMID_Vpl = 5,
SCE_KERNEL_TMID_Fpl = 6,
SCE_KERNEL_TMID_Mpipe = 7,
SCE_KERNEL_TMID_Callback = 8,
SCE_KERNEL_TMID_ThreadEventHandler = 9,
SCE_KERNEL_TMID_Alarm = 10,
SCE_KERNEL_TMID_VTimer = 11,
SCE_KERNEL_TMID_SleepThread = 64,
SCE_KERNEL_TMID_DelayThread = 65,
SCE_KERNEL_TMID_SuspendThread = 66,
SCE_KERNEL_TMID_DormantThread = 67,
_,
};
pub extern fn sceKernelGetThreadmanIdList(typec: enum_SceKernelIdListType, readbuf: [*c]SceUID, readbufsize: c_int, idcount: [*c]c_int) c_int;
pub const struct_SceKernelSystemStatus = extern struct {
size: SceSize,
status: SceUInt,
idleClocks: SceKernelSysClock,
comesOutOfIdleCount: SceUInt,
threadSwitchCount: SceUInt,
vfpuSwitchCount: SceUInt,
};
pub const SceKernelSystemStatus = struct_SceKernelSystemStatus;
pub extern fn sceKernelReferSystemStatus(status: [*c]SceKernelSystemStatus) c_int;
pub extern fn sceKernelCreateMsgPipe(name: [*c]const u8, part: c_int, attr: c_int, unk1: ?*c_void, opt: ?*c_void) SceUID;
pub extern fn sceKernelDeleteMsgPipe(uid: SceUID) c_int;
pub extern fn sceKernelSendMsgPipe(uid: SceUID, message: ?*c_void, size: c_uint, unk1: c_int, unk2: ?*c_void, timeout: [*c]c_uint) c_int;
pub extern fn sceKernelSendMsgPipeCB(uid: SceUID, message: ?*c_void, size: c_uint, unk1: c_int, unk2: ?*c_void, timeout: [*c]c_uint) c_int;
pub extern fn sceKernelTrySendMsgPipe(uid: SceUID, message: ?*c_void, size: c_uint, unk1: c_int, unk2: ?*c_void) c_int;
pub extern fn sceKernelReceiveMsgPipe(uid: SceUID, message: ?*c_void, size: c_uint, unk1: c_int, unk2: ?*c_void, timeout: [*c]c_uint) c_int;
pub extern fn sceKernelReceiveMsgPipeCB(uid: SceUID, message: ?*c_void, size: c_uint, unk1: c_int, unk2: ?*c_void, timeout: [*c]c_uint) c_int;
pub extern fn sceKernelTryReceiveMsgPipe(uid: SceUID, message: ?*c_void, size: c_uint, unk1: c_int, unk2: ?*c_void) c_int;
pub extern fn sceKernelCancelMsgPipe(uid: SceUID, psend: [*c]c_int, precv: [*c]c_int) c_int;
pub const struct_SceKernelMppInfo = extern struct {
size: SceSize,
name: [32]u8,
attr: SceUInt,
bufSize: c_int,
freeSize: c_int,
numSendWaitThreads: c_int,
numReceiveWaitThreads: c_int,
};
pub const SceKernelMppInfo = struct_SceKernelMppInfo;
pub extern fn sceKernelReferMsgPipeStatus(uid: SceUID, info: [*c]SceKernelMppInfo) c_int;
pub const struct_SceKernelVplOptParam = extern struct {
size: SceSize,
};
pub extern fn sceKernelCreateVpl(name: [*c]const u8, part: c_int, attr: c_int, size: c_uint, opt: [*c]struct_SceKernelVplOptParam) SceUID;
pub extern fn sceKernelDeleteVpl(uid: SceUID) c_int;
pub extern fn sceKernelAllocateVpl(uid: SceUID, size: c_uint, data: [*c]?*c_void, timeout: [*c]c_uint) c_int;
pub extern fn sceKernelAllocateVplCB(uid: SceUID, size: c_uint, data: [*c]?*c_void, timeout: [*c]c_uint) c_int;
pub extern fn sceKernelTryAllocateVpl(uid: SceUID, size: c_uint, data: [*c]?*c_void) c_int;
pub extern fn sceKernelFreeVpl(uid: SceUID, data: ?*c_void) c_int;
pub extern fn sceKernelCancelVpl(uid: SceUID, pnum: [*c]c_int) c_int;
pub const struct_SceKernelVplInfo = extern struct {
size: SceSize,
name: [32]u8,
attr: SceUInt,
poolSize: c_int,
freeSize: c_int,
numWaitThreads: c_int,
};
pub const SceKernelVplInfo = struct_SceKernelVplInfo;
pub extern fn sceKernelReferVplStatus(uid: SceUID, info: [*c]SceKernelVplInfo) c_int;
pub const struct_SceKernelFplOptParam = extern struct {
size: SceSize,
};
pub extern fn sceKernelCreateFpl(name: [*c]const u8, part: c_int, attr: c_int, size: c_uint, blocks: c_uint, opt: [*c]struct_SceKernelFplOptParam) c_int;
pub extern fn sceKernelDeleteFpl(uid: SceUID) c_int;
pub extern fn sceKernelAllocateFpl(uid: SceUID, data: [*c]?*c_void, timeout: [*c]c_uint) c_int;
pub extern fn sceKernelAllocateFplCB(uid: SceUID, data: [*c]?*c_void, timeout: [*c]c_uint) c_int;
pub extern fn sceKernelTryAllocateFpl(uid: SceUID, data: [*c]?*c_void) c_int;
pub extern fn sceKernelFreeFpl(uid: SceUID, data: ?*c_void) c_int;
pub extern fn sceKernelCancelFpl(uid: SceUID, pnum: [*c]c_int) c_int;
pub const struct_SceKernelFplInfo = extern struct {
size: SceSize,
name: [32]u8,
attr: SceUInt,
blockSize: c_int,
numBlocks: c_int,
freeBlocks: c_int,
numWaitThreads: c_int,
};
pub const SceKernelFplInfo = struct_SceKernelFplInfo;
pub extern fn sceKernelReferFplStatus(uid: SceUID, info: [*c]SceKernelFplInfo) c_int;
pub extern fn _sceKernelReturnFromTimerHandler() void;
pub extern fn _sceKernelReturnFromCallback() void;
pub extern fn sceKernelUSec2SysClock(usec: c_uint, clock: [*c]SceKernelSysClock) c_int;
pub extern fn sceKernelUSec2SysClockWide(usec: c_uint) SceInt64;
pub extern fn sceKernelSysClock2USec(clock: [*c]SceKernelSysClock, low: [*c]c_uint, high: [*c]c_uint) c_int;
pub extern fn sceKernelSysClock2USecWide(clock: SceInt64, low: [*c]c_uint, high: [*c]c_uint) c_int;
pub extern fn sceKernelGetSystemTime(time: [*c]SceKernelSysClock) c_int;
pub extern fn sceKernelGetSystemTimeWide() SceInt64;
pub extern fn sceKernelGetSystemTimeLow() c_uint;
pub const struct_SceKernelVTimerOptParam = extern struct {
size: SceSize,
};
pub extern fn sceKernelCreateVTimer(name: [*c]const u8, opt: [*c]struct_SceKernelVTimerOptParam) SceUID;
pub extern fn sceKernelDeleteVTimer(uid: SceUID) c_int;
pub extern fn sceKernelGetVTimerBase(uid: SceUID, base: [*c]SceKernelSysClock) c_int;
pub extern fn sceKernelGetVTimerBaseWide(uid: SceUID) SceInt64;
pub extern fn sceKernelGetVTimerTime(uid: SceUID, time: [*c]SceKernelSysClock) c_int;
pub extern fn sceKernelGetVTimerTimeWide(uid: SceUID) SceInt64;
pub extern fn sceKernelSetVTimerTime(uid: SceUID, time: [*c]SceKernelSysClock) c_int;
pub extern fn sceKernelSetVTimerTimeWide(uid: SceUID, time: SceInt64) SceInt64;
pub extern fn sceKernelStartVTimer(uid: SceUID) c_int;
pub extern fn sceKernelStopVTimer(uid: SceUID) c_int;
pub const SceKernelVTimerHandler = ?fn (SceUID, [*c]SceKernelSysClock, [*c]SceKernelSysClock, ?*c_void) callconv(.C) SceUInt;
pub const SceKernelVTimerHandlerWide = ?fn (SceUID, SceInt64, SceInt64, ?*c_void) callconv(.C) SceUInt;
pub extern fn sceKernelSetVTimerHandler(uid: SceUID, time: [*c]SceKernelSysClock, handler: SceKernelVTimerHandler, common: ?*c_void) c_int;
pub extern fn sceKernelSetVTimerHandlerWide(uid: SceUID, time: SceInt64, handler: SceKernelVTimerHandlerWide, common: ?*c_void) c_int;
pub extern fn sceKernelCancelVTimerHandler(uid: SceUID) c_int;
pub const struct_SceKernelVTimerInfo = extern struct {
size: SceSize,
name: [32]u8,
active: c_int,
base: SceKernelSysClock,
current: SceKernelSysClock,
schedule: SceKernelSysClock,
handler: SceKernelVTimerHandler,
common: ?*c_void,
};
pub const SceKernelVTimerInfo = struct_SceKernelVTimerInfo;
pub extern fn sceKernelReferVTimerStatus(uid: SceUID, info: [*c]SceKernelVTimerInfo) c_int;
pub extern fn _sceKernelExitThread() void;
pub extern fn sceKernelGetThreadmanIdType(uid: SceUID) enum_SceKernelIdListType;
pub const SceKernelThreadEventHandler = ?fn (c_int, SceUID, ?*c_void) callconv(.C) c_int;
pub const struct_SceKernelThreadEventHandlerInfo = extern struct {
size: SceSize,
name: [32]u8,
threadId: SceUID,
mask: c_int,
handler: SceKernelThreadEventHandler,
common: ?*c_void,
};
pub const SceKernelThreadEventHandlerInfo = struct_SceKernelThreadEventHandlerInfo;
pub const enum_ThreadEventIds = extern enum(c_int) {
THREADEVENT_ALL = 4294967295,
THREADEVENT_KERN = 4294967288,
THREADEVENT_USER = 4294967280,
THREADEVENT_CURRENT = 0,
_,
};
pub const enum_ThreadEvents = extern enum(c_int) {
THREAD_CREATE = 1,
THREAD_START = 2,
THREAD_EXIT = 4,
THREAD_DELETE = 8,
_,
};
pub extern fn sceKernelRegisterThreadEventHandler(name: [*c]const u8, threadID: SceUID, mask: c_int, handler: SceKernelThreadEventHandler, common: ?*c_void) SceUID;
pub extern fn sceKernelReleaseThreadEventHandler(uid: SceUID) c_int;
pub extern fn sceKernelReferThreadEventHandlerStatus(uid: SceUID, info: [*c]struct_SceKernelThreadEventHandlerInfo) c_int;
pub extern fn sceKernelReferThreadProfiler() [*c]PspDebugProfilerRegs;
pub extern fn sceKernelReferGlobalProfiler() [*c]PspDebugProfilerRegs;
pub extern fn sceKernelCreateThread(name: [*c]const u8, entry: SceKernelThreadEntry, initPriority: c_int, stackSize: c_int, attr: SceUInt, option: [*c]SceKernelThreadOptParam) SceUID;
pub const PspModuleInfoAttr = enum_PspModuleInfoAttr;
pub const PspThreadAttributes = enum_PspThreadAttributes;
pub const PspThreadStatus = enum_PspThreadStatus;
pub const PspEventFlagAttributes = enum_PspEventFlagAttributes;
pub const PspEventFlagWaitTypes = enum_PspEventFlagWaitTypes;
pub const SceKernelIdListType = enum_SceKernelIdListType;
pub const SceKernelVplOptParam = struct_SceKernelVplOptParam;
pub const SceKernelFplOptParam = struct_SceKernelFplOptParam;
pub const SceKernelVTimerOptParam = struct_SceKernelVTimerOptParam;
pub const ThreadEventIds = enum_ThreadEventIds;
pub const ThreadEvents = enum_ThreadEvents; | src/psp/sdk/pspthreadman.zig |
const std = @import("std");
const stdx = @import("stdx");
const fatal = stdx.fatal;
const vk = @import("vk");
pub fn updateDescriptorSet(device: vk.VkDevice, desc_set: vk.VkDescriptorSet, image_infos: []vk.VkDescriptorImageInfo) void {
const write = vk.VkWriteDescriptorSet{
.sType = vk.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = desc_set,
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorType = vk.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = @intCast(u32, image_infos.len),
.pImageInfo = image_infos.ptr,
.pNext = null,
.pBufferInfo = null,
.pTexelBufferView = null,
};
vk.updateDescriptorSets(device, 1, &write, 0, null);
}
pub fn createDescriptorSets(alloc: std.mem.Allocator, device: vk.VkDevice, pool: vk.VkDescriptorPool, n: u32, layout: vk.VkDescriptorSetLayout) []vk.VkDescriptorSet {
const layouts = alloc.alloc(vk.VkDescriptorSetLayout, n) catch fatal();
defer alloc.free(layouts);
for (layouts) |_, i| {
layouts[i] = layout;
}
var sets = alloc.alloc(vk.VkDescriptorSet, n) catch fatal();
const alloc_info = vk.VkDescriptorSetAllocateInfo{
.sType = vk.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.descriptorPool = pool,
.descriptorSetCount = n,
.pSetLayouts = layouts.ptr,
.pNext = null,
};
const res = vk.allocateDescriptorSets(device, &alloc_info, sets.ptr);
vk.assertSuccess(res);
return sets;
}
pub fn createDescriptorSet(device: vk.VkDevice, pool: vk.VkDescriptorPool, layout: vk.VkDescriptorSetLayout) vk.VkDescriptorSet {
var ret: vk.VkDescriptorSet = undefined;
const alloc_info = vk.VkDescriptorSetAllocateInfo{
.sType = vk.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.descriptorPool = pool,
.descriptorSetCount = 1,
.pSetLayouts = &layout,
.pNext = null,
};
const res = vk.allocateDescriptorSets(device, &alloc_info, &ret);
vk.assertSuccess(res);
return ret;
} | graphics/src/backend/vk/descriptor.zig |
const std = @import("std");
const c = @import("c.zig");
const BitmapGlyph = @import("BitmapGlyph.zig");
const Stroker = @import("Stroker.zig");
const types = @import("types.zig");
const Error = @import("error.zig").Error;
const intToError = @import("error.zig").intToError;
const Glyph = @This();
pub const BBoxMode = enum(u2) {
// https://freetype.org/freetype2/docs/reference/ft2-glyph_management.html#ft_glyph_bbox_mode
// both `unscaled` and `subpixel` constants are set to 0
unscaled_or_subpixels = c.FT_GLYPH_BBOX_UNSCALED,
gridfit = c.FT_GLYPH_BBOX_GRIDFIT,
truncate = c.FT_GLYPH_BBOX_TRUNCATE,
pixels = c.FT_GLYPH_BBOX_PIXELS,
};
pub const GlyphMetrics = c.FT_Glyph_Metrics;
pub const GlyphFormat = enum(u32) {
none = c.FT_GLYPH_FORMAT_NONE,
composite = c.FT_GLYPH_FORMAT_COMPOSITE,
bitmap = c.FT_GLYPH_FORMAT_BITMAP,
outline = c.FT_GLYPH_FORMAT_OUTLINE,
plotter = c.FT_GLYPH_FORMAT_PLOTTER,
svg = c.FT_GLYPH_FORMAT_SVG,
};
handle: c.FT_Glyph,
pub fn init(handle: c.FT_Glyph) Glyph {
return Glyph{ .handle = handle };
}
pub fn deinit(self: Glyph) void {
c.FT_Done_Glyph(self.handle);
}
pub fn clone(self: Glyph) Error!Glyph {
var res = std.mem.zeroes(c.FT_Glyph);
try intToError(c.FT_Glyph_Copy(self.handle, &res));
return Glyph.init(res);
}
pub fn transform(self: Glyph, matrix: ?types.Matrix, delta: ?types.Vector) Error!void {
var m = matrix orelse std.mem.zeroes(types.Matrix);
var d = delta orelse std.mem.zeroes(types.Vector);
try intToError(c.FT_Glyph_Transform(self.handle, @ptrCast(*c.FT_Matrix, &m), @ptrCast(*c.FT_Vector, &d)));
}
pub fn getCBox(self: Glyph, bbox_mode: BBoxMode) types.BBox {
var res = std.mem.zeroes(types.BBox);
c.FT_Glyph_Get_CBox(self.handle, @enumToInt(bbox_mode), @ptrCast(*c.FT_BBox, &res));
return res;
}
pub fn toBitmap(self: Glyph, render_mode: types.RenderMode, origin: ?types.Vector) Error!BitmapGlyph {
var res = self.handle;
var o = origin orelse std.mem.zeroes(types.Vector);
try intToError(c.FT_Glyph_To_Bitmap(&res, @enumToInt(render_mode), @ptrCast(*c.FT_Vector, &o), 0));
return BitmapGlyph.init(@ptrCast(c.FT_BitmapGlyph, self.handle));
}
pub fn stroke(self: Glyph, stroker: Stroker) Error!Glyph {
var res = self.handle;
try intToError(c.FT_Glyph_Stroke(&res, stroker.handle, 0));
return Glyph.init(res);
}
pub fn strokeBorder(self: Glyph, stroker: Stroker, inside: bool) Error!Glyph {
var res = self.handle;
try intToError(c.FT_Glyph_StrokeBorder(&res, stroker.handle, if (inside) 1 else 0, 0));
return Glyph.init(res);
}
pub fn format(self: Glyph) GlyphFormat {
return @intToEnum(GlyphFormat, self.handle.*.format);
}
pub fn advanceX(self: Glyph) isize {
return self.handle.*.advance.x;
}
pub fn advanceY(self: Glyph) isize {
return self.handle.*.advance.y;
} | freetype/src/Glyph.zig |
allocator: Allocator,
tokens: []const TokenKind,
src: []const u8,
panicking: bool = false,
cursor: usize = 0,
errors: std.ArrayListUnmanaged(ParseError) = .{},
const std = @import("std");
const Allocator = std.mem.Allocator;
const Tokens = std.MultiArrayList(Token).Slice;
const super = @import("!mod.zig");
const Token = super.Token;
const TokenKind = super.TokenKind;
const Cst = super.Cst;
const NodeBuilder = Cst.NodeBuilder;
const Self = @This();
pub fn parse(allocator: Allocator, tokens: []const TokenKind, src: []const u8) ParseResult {
var parser = Self{
.allocator = allocator,
.tokens = tokens,
.src = src,
};
var root = parser.parseToplevel();
defer root.deinit(allocator);
return .{
// .cst = .{ .nodes = parser.nodes },
.cst = Cst.buildCst(allocator, root) catch unreachable,
.errors = parser.errors,
};
}
pub const ParseResult = struct {
cst: Cst,
errors: std.ArrayListUnmanaged(ParseError),
pub fn deinit(self: *@This(), allocator: Allocator) void {
self.cst.deinit(allocator);
self.errors.deinit(allocator);
}
};
pub const ParseError = union(enum) {
expected: Expected,
pub const Expected = struct {
what: What,
found: usize,
in: Context,
pub const What = union(enum) {
item: Item,
token: TokenKind,
one_of: []const What,
pub const Item = enum {
decl,
expr,
};
};
pub const Context = enum {
top_level,
decl_function,
stmt,
stmt_let,
expr_start,
expr_paren,
expr_block,
expr_call,
string,
path,
};
};
};
//
// Token ops
//
fn atEnd(self: Self) bool {
return self.at(.EOF);
}
fn advance(self: *Self) void {
if (self.atEnd())
return;
self.cursor += 1;
}
fn peek(self: Self) TokenKind {
return self.tokens[self.cursor];
}
fn at(self: Self, kind: TokenKind) bool {
return self.peek() == kind;
}
fn atOneOf(self: Self, set: []const TokenKind) bool {
for (set) |kind| {
if (self.at(kind))
return true;
}
return false;
}
fn match(self: *Self, kind: TokenKind, parent: *NodeBuilder) bool {
if (self.at(kind)) {
self.bump(parent);
return true;
}
return false;
}
//
// Error ops
//
fn report(self: *Self, parent: *NodeBuilder, err: ParseError) void {
if (!self.panicking) {
self.panicking = true;
self.errors.append(self.allocator, err) catch unreachable;
return;
}
if (self.atOneOf(&[_]TokenKind{
.brkt_brace_close,
.kw_fn,
.EOF,
})) {
self.bump(parent);
self.panicking = false;
} else {
var node = NodeBuilder{ .kind = .skipped };
self.bump(&node);
self.appendNodeTo(parent, node);
}
}
fn expect(
self: *Self,
kind: TokenKind,
in: ParseError.Expected.Context,
parent: *NodeBuilder,
) void {
if (!self.match(kind, parent)) {
self.report(parent, .{
.expected = .{
.what = .{ .token = kind },
.found = self.cursor - 1,
.in = in,
},
});
}
}
//
// Node ops
//
fn bump(self: *Self, parent: *NodeBuilder) void {
self.appendTokenTo(parent);
self.advance();
}
fn appendNodeTo(self: *Self, to: *NodeBuilder, node: NodeBuilder) void {
to.appendNode(self.allocator, node) catch unreachable;
}
fn appendTokenTo(self: *Self, to: *NodeBuilder) void {
to.appendToken(self.allocator) catch unreachable;
}
//
// Parse
//
fn parseToplevel(self: *Self) NodeBuilder {
var root = NodeBuilder{ .kind = .root };
while (!self.atEnd()) {
self.parseDecl(.top_level, &root);
}
if (self.tokens[self.cursor] == .EOF) {} else {}
while (self.tokens[self.cursor] != .EOF) {
self.appendTokenTo(&root);
self.cursor += 1;
}
self.appendTokenTo(&root);
return root;
}
fn parsePath(self: *Self) NodeBuilder {
std.debug.assert(self.atOneOf(&.{ .ident, .punct_dblColon }));
var path = NodeBuilder{ .kind = .path };
if (self.match(.punct_dblColon, &path)) {
self.expect(.ident, .path, &path);
}
_ = self.match(.ident, &path);
while (true) {
if (self.at(.punct_dblColon))
self.bump(&path)
else
break;
if (!self.match(.ident, &path))
break;
}
return path;
}
fn parseString(self: *Self) NodeBuilder {
std.debug.assert(self.at(.string_open));
var str = NodeBuilder{ .kind = .string };
self.bump(&str);
while (self.atOneOf(&.{
.string_literal,
.esc_quote_single,
.esc_quote_double,
.esc_ascii_newline,
.esc_ascii_carriageReturn,
.esc_ascii_tab,
.esc_ascii_backslash,
.esc_ascii_null,
.esc_ascii_escape,
// .esc_ascii_characterCode,
// .esc_unicode,
})) {
self.bump(&str);
}
self.expect(.string_close, .string, &str);
return str;
}
fn parseLiteralInt(self: *Self) NodeBuilder {
std.debug.assert(self.atOneOf(&.{ .int_dec, .int_hex, .int_bin, .int_oct }));
var lit = NodeBuilder{ .kind = .literal_int };
self.bump(&lit);
return lit;
}
fn parseLiteralFloat(self: *Self) NodeBuilder {
std.debug.assert(self.at(.float));
var lit = NodeBuilder{ .kind = .literal_float };
self.bump(&lit);
return lit;
}
//
// Parse Decl
//
fn parseDecl(self: *Self, in: ParseError.Expected.Context, parent: *NodeBuilder) void {
switch (self.peek()) {
.kw_fn => self.parseDeclFunction(parent),
.kw_use => self.parseDeclUse(parent),
else => {
self.report(parent, .{
.expected = .{
.what = .{ .item = .decl },
.found = self.cursor,
.in = in,
},
});
},
}
}
fn parseDeclFunction(self: *Self, parent: *NodeBuilder) void {
std.debug.assert(self.at(.kw_fn));
var func = NodeBuilder{ .kind = .decl_function };
defer self.appendNodeTo(parent, func);
self.bump(&func);
self.expect(.ident, .decl_function, &func);
if (!self.at(.punct_semiColon)) {
self.parseStmtExpr(&func);
} else {
self.bump(&func);
}
}
fn parseDeclUse(self: *Self, parent: *NodeBuilder) void {
std.debug.assert(self.at(.kw_use));
// var use = NodeBuilder{ .kind = .decl_use };
// defer self.appendNodeTo(parent, use);
// self.bump(&use);
_ = parent;
@panic("todo");
}
//
// Parse stmt
//
fn parseStmt(self: *Self, parent: *NodeBuilder) void {
switch (self.peek()) {
.kw_let => self.parseStmtLet(parent),
else => self.parseStmtExpr(parent),
}
}
fn parseStmtExpr(self: *Self, parent: *NodeBuilder) void {
self.parseExpr(parent);
if (self.tokens[self.cursor - 1] != .brkt_brace_close) {
self.expect(.punct_semiColon, .stmt, parent);
}
}
fn parseStmtLet(self: *Self, parent: *NodeBuilder) void {
std.debug.assert(self.at(.kw_let));
var let = NodeBuilder{ .kind = .stmt_let };
defer self.appendNodeTo(parent, let);
self.bump(&let); // kw
self.expect(.ident, .stmt_let, &let);
self.expect(.punct_eq, .stmt_let, &let);
self.parseExpr(&let);
self.expect(.punct_semiColon, .stmt_let, &let);
}
//
// Parse expr
//
fn parseExpr(self: *Self, parent: *NodeBuilder) void {
self.parseExprPrecedence(.none, parent);
}
const Precedence = enum(u8) {
none = 0,
// assignment,
// logical_or,
// logical_and,
sum,
product,
// prefix,
call,
pub fn get(kind: TokenKind) Precedence {
return switch (kind) {
// .Punct_Eq => .assignment,
// .Kw_or => .logical_or,
// .Kw_and => .logical_and,
.punct_plus, .punct_minus => .sum,
.punct_star, .punct_slash => .product,
// .Punct_Exclamation, .Kw_not => .prefix,
.brkt_paren_open => .call,
else => .none,
};
}
};
fn parseExprPrecedence(self: *Self, precedence: Precedence, parent: *NodeBuilder) void {
var lhs = if (self.parseExprStart()) |n| n else {
self.report(parent, .{
.expected = .{
.what = .{ .item = .expr },
.found = self.cursor,
.in = .expr_start,
},
});
return;
};
const initial_prec = @enumToInt(precedence);
var p = self.peek();
var infix_prec = @enumToInt(Precedence.get(self.peek()));
while (initial_prec < infix_prec) {
if (self.parseExprInfix(p, lhs, infix_prec)) |node|
lhs = node
else {
// @FIXME: Is this an error condition?
self.appendNodeTo(parent, lhs);
return;
}
p = self.peek();
infix_prec = @enumToInt(Precedence.get(p));
}
self.appendNodeTo(parent, lhs);
}
fn parseExprStart(self: *Self) ?NodeBuilder {
return switch (self.peek()) {
.ident, .punct_dblColon => self.parsePath(),
.string_open => self.parseString(),
.int_dec, .int_hex, .int_bin, .int_oct => self.parseLiteralInt(),
.float => self.parseLiteralFloat(),
.brkt_paren_open => blk: {
var expr = NodeBuilder{ .kind = undefined };
self.bump(&expr); // '('
// unit
if (self.match(.brkt_paren_close, &expr)) { // ')'
expr.kind = .expr_unit;
break :blk expr;
}
self.parseExpr(&expr);
// grouping
if (self.match(.brkt_paren_close, &expr)) { // ')'
expr.kind = .expr_grouping;
break :blk expr;
}
// tuple
expr.kind = .expr_tuple;
while (self.match(.punct_comma, &expr)) {
if (self.at(.brkt_paren_close))
break;
self.parseExpr(&expr);
}
self.expect(.brkt_paren_close, .expr_paren, &expr); // ')'
break :blk expr;
},
.brkt_brace_open => blk: {
var block = NodeBuilder{ .kind = .expr_block };
self.bump(&block); // '{'
while (!self.atOneOf(&.{ .brkt_brace_close, .EOF })) {
self.parseStmt(&block);
}
self.expect(.brkt_brace_close, .expr_block, &block); // '}'
break :blk block;
},
else => return null,
};
}
fn parseExprInfix(self: *Self, p: TokenKind, lhs: NodeBuilder, prec: u8) ?NodeBuilder {
return switch (p) {
.punct_plus,
.punct_minus,
.punct_star,
.punct_slash,
=> blk: {
var infix = NodeBuilder{ .kind = .expr_infix };
self.appendNodeTo(&infix, lhs); // lhs
self.bump(&infix); // operator
self.parseExprPrecedence(@intToEnum(Precedence, prec), &infix); // rhs
break :blk infix;
},
.brkt_paren_open => blk: {
var call = NodeBuilder{ .kind = .expr_call };
self.appendNodeTo(&call, lhs);
self.bump(&call); // '('
if (self.match(.brkt_paren_close, &call)) // ')'
break :blk call;
self.parseExpr(&call);
while (self.match(.punct_comma, &call)) {
if (self.at(.brkt_paren_close))
break;
self.parseExpr(&call);
}
self.expect(.brkt_paren_close, .expr_call, &call); // ')'
break :blk call;
},
else => return null,
};
} | fexc/src/parse/Parser.zig |
const std = @import("../index.zig");
const math = std.math;
const debug = std.debug;
const assert = debug.assert;
const mem = std.mem;
const builtin = @import("builtin");
const errol3 = @import("errol/index.zig").errol3;
const max_int_digits = 65;
/// Renders fmt string with args, calling output with slices of bytes.
/// If `output` returns an error, the error is returned from `format` and
/// `output` is not called again.
pub fn format(context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void,
comptime fmt: []const u8, args: ...) Errors!void
{
const State = enum {
Start,
OpenBrace,
CloseBrace,
Integer,
IntegerWidth,
Float,
FloatWidth,
Character,
Buf,
BufWidth,
};
comptime var start_index = 0;
comptime var state = State.Start;
comptime var next_arg = 0;
comptime var radix = 0;
comptime var uppercase = false;
comptime var width = 0;
comptime var width_start = 0;
inline for (fmt) |c, i| {
switch (state) {
State.Start => switch (c) {
'{' => {
if (start_index < i) {
try output(context, fmt[start_index..i]);
}
state = State.OpenBrace;
},
'}' => {
if (start_index < i) {
try output(context, fmt[start_index..i]);
}
state = State.CloseBrace;
},
else => {},
},
State.OpenBrace => switch (c) {
'{' => {
state = State.Start;
start_index = i;
},
'}' => {
try formatValue(args[next_arg], context, Errors, output);
next_arg += 1;
state = State.Start;
start_index = i + 1;
},
'd' => {
radix = 10;
uppercase = false;
width = 0;
state = State.Integer;
},
'x' => {
radix = 16;
uppercase = false;
width = 0;
state = State.Integer;
},
'X' => {
radix = 16;
uppercase = true;
width = 0;
state = State.Integer;
},
'c' => {
state = State.Character;
},
's' => {
state = State.Buf;
},
'.' => {
state = State.Float;
},
else => @compileError("Unknown format character: " ++ []u8{c}),
},
State.Buf => switch (c) {
'}' => {
return output(context, args[next_arg]);
},
'0' ... '9' => {
width_start = i;
state = State.BufWidth;
},
else => @compileError("Unexpected character in format string: " ++ []u8{c}),
},
State.CloseBrace => switch (c) {
'}' => {
state = State.Start;
start_index = i;
},
else => @compileError("Single '}' encountered in format string"),
},
State.Integer => switch (c) {
'}' => {
try formatInt(args[next_arg], radix, uppercase, width, context, Errors, output);
next_arg += 1;
state = State.Start;
start_index = i + 1;
},
'0' ... '9' => {
width_start = i;
state = State.IntegerWidth;
},
else => @compileError("Unexpected character in format string: " ++ []u8{c}),
},
State.IntegerWidth => switch (c) {
'}' => {
width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
try formatInt(args[next_arg], radix, uppercase, width, context, Errors, output);
next_arg += 1;
state = State.Start;
start_index = i + 1;
},
'0' ... '9' => {},
else => @compileError("Unexpected character in format string: " ++ []u8{c}),
},
State.Float => switch (c) {
'}' => {
try formatFloatDecimal(args[next_arg], 0, context, Errors, output);
next_arg += 1;
state = State.Start;
start_index = i + 1;
},
'0' ... '9' => {
width_start = i;
state = State.FloatWidth;
},
else => @compileError("Unexpected character in format string: " ++ []u8{c}),
},
State.FloatWidth => switch (c) {
'}' => {
width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
try formatFloatDecimal(args[next_arg], width, context, Errors, output);
next_arg += 1;
state = State.Start;
start_index = i + 1;
},
'0' ... '9' => {},
else => @compileError("Unexpected character in format string: " ++ []u8{c}),
},
State.BufWidth => switch (c) {
'}' => {
width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
try formatBuf(args[next_arg], width, context, Errors, output);
next_arg += 1;
state = State.Start;
start_index = i + 1;
},
'0' ... '9' => {},
else => @compileError("Unexpected character in format string: " ++ []u8{c}),
},
State.Character => switch (c) {
'}' => {
try formatAsciiChar(args[next_arg], context, Errors, output);
next_arg += 1;
state = State.Start;
start_index = i + 1;
},
else => @compileError("Unexpected character in format string: " ++ []u8{c}),
},
}
}
comptime {
if (args.len != next_arg) {
@compileError("Unused arguments");
}
if (state != State.Start) {
@compileError("Incomplete format string: " ++ fmt);
}
}
if (start_index < fmt.len) {
try output(context, fmt[start_index..]);
}
}
pub fn formatValue(value: var, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void {
const T = @typeOf(value);
switch (@typeId(T)) {
builtin.TypeId.Int => {
return formatInt(value, 10, false, 0, context, Errors, output);
},
builtin.TypeId.Float => {
return formatFloat(value, context, Errors, output);
},
builtin.TypeId.Void => {
return output(context, "void");
},
builtin.TypeId.Bool => {
return output(context, if (value) "true" else "false");
},
builtin.TypeId.Nullable => {
if (value) |payload| {
return formatValue(payload, context, Errors, output);
} else {
return output(context, "null");
}
},
builtin.TypeId.ErrorUnion => {
if (value) |payload| {
return formatValue(payload, context, Errors, output);
} else |err| {
return formatValue(err, context, Errors, output);
}
},
builtin.TypeId.ErrorSet => {
try output(context, "error.");
return output(context, @errorName(value));
},
builtin.TypeId.Pointer => {
if (@typeId(T.Child) == builtin.TypeId.Array and T.Child.Child == u8) {
return output(context, (*value)[0..]);
} else {
return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value));
}
},
else => if (@canImplicitCast([]const u8, value)) {
const casted_value = ([]const u8)(value);
return output(context, casted_value);
} else {
@compileError("Unable to format type '" ++ @typeName(T) ++ "'");
},
}
}
pub fn formatAsciiChar(c: u8, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void {
return output(context, (&c)[0..1]);
}
pub fn formatBuf(buf: []const u8, width: usize,
context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void
{
try output(context, buf);
var leftover_padding = if (width > buf.len) (width - buf.len) else return;
const pad_byte: u8 = ' ';
while (leftover_padding > 0) : (leftover_padding -= 1) {
try output(context, (&pad_byte)[0..1]);
}
}
pub fn formatFloat(value: var, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void {
var x = f64(value);
// Errol doesn't handle these special cases.
if (math.isNan(x)) {
return output(context, "NaN");
}
if (math.signbit(x)) {
try output(context, "-");
x = -x;
}
if (math.isPositiveInf(x)) {
return output(context, "Infinity");
}
if (x == 0.0) {
return output(context, "0.0");
}
var buffer: [32]u8 = undefined;
const float_decimal = errol3(x, buffer[0..]);
try output(context, float_decimal.digits[0..1]);
try output(context, ".");
if (float_decimal.digits.len > 1) {
const num_digits = if (@typeOf(value) == f32)
math.min(usize(9), float_decimal.digits.len)
else
float_decimal.digits.len;
try output(context, float_decimal.digits[1 .. num_digits]);
} else {
try output(context, "0");
}
if (float_decimal.exp != 1) {
try output(context, "e");
try formatInt(float_decimal.exp - 1, 10, false, 0, context, Errors, output);
}
}
pub fn formatFloatDecimal(value: var, precision: usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void {
var x = f64(value);
// Errol doesn't handle these special cases.
if (math.isNan(x)) {
return output(context, "NaN");
}
if (math.signbit(x)) {
try output(context, "-");
x = -x;
}
if (math.isPositiveInf(x)) {
return output(context, "Infinity");
}
if (x == 0.0) {
return output(context, "0.0");
}
var buffer: [32]u8 = undefined;
const float_decimal = errol3(x, buffer[0..]);
const num_left_digits = if (float_decimal.exp > 0) usize(float_decimal.exp) else 1;
try output(context, float_decimal.digits[0 .. num_left_digits]);
try output(context, ".");
if (float_decimal.digits.len > 1) {
const num_valid_digtis = if (@typeOf(value) == f32) math.min(usize(7), float_decimal.digits.len)
else
float_decimal.digits.len;
const num_right_digits = if (precision != 0)
math.min(precision, (num_valid_digtis-num_left_digits))
else
num_valid_digtis - num_left_digits;
try output(context, float_decimal.digits[num_left_digits .. (num_left_digits + num_right_digits)]);
} else {
try output(context, "0");
}
}
pub fn formatInt(value: var, base: u8, uppercase: bool, width: usize,
context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void
{
if (@typeOf(value).is_signed) {
return formatIntSigned(value, base, uppercase, width, context, Errors, output);
} else {
return formatIntUnsigned(value, base, uppercase, width, context, Errors, output);
}
}
fn formatIntSigned(value: var, base: u8, uppercase: bool, width: usize,
context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void
{
const uint = @IntType(false, @typeOf(value).bit_count);
if (value < 0) {
const minus_sign: u8 = '-';
try output(context, (&minus_sign)[0..1]);
const new_value = uint(-(value + 1)) + 1;
const new_width = if (width == 0) 0 else (width - 1);
return formatIntUnsigned(new_value, base, uppercase, new_width, context, Errors, output);
} else if (width == 0) {
return formatIntUnsigned(uint(value), base, uppercase, width, context, Errors, output);
} else {
const plus_sign: u8 = '+';
try output(context, (&plus_sign)[0..1]);
const new_value = uint(value);
const new_width = if (width == 0) 0 else (width - 1);
return formatIntUnsigned(new_value, base, uppercase, new_width, context, Errors, output);
}
}
fn formatIntUnsigned(value: var, base: u8, uppercase: bool, width: usize,
context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void
{
// max_int_digits accounts for the minus sign. when printing an unsigned
// number we don't need to do that.
var buf: [max_int_digits - 1]u8 = undefined;
var a = if (@sizeOf(@typeOf(value)) == 1) u8(value) else value;
var index: usize = buf.len;
while (true) {
const digit = a % base;
index -= 1;
buf[index] = digitToChar(u8(digit), uppercase);
a /= base;
if (a == 0)
break;
}
const digits_buf = buf[index..];
const padding = if (width > digits_buf.len) (width - digits_buf.len) else 0;
if (padding > index) {
const zero_byte: u8 = '0';
var leftover_padding = padding - index;
while (true) {
try output(context, (&zero_byte)[0..1]);
leftover_padding -= 1;
if (leftover_padding == 0)
break;
}
mem.set(u8, buf[0..index], '0');
return output(context, buf);
} else {
const padded_buf = buf[index - padding..];
mem.set(u8, padded_buf[0..padding], '0');
return output(context, padded_buf);
}
}
pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, width: usize) usize {
var context = FormatIntBuf {
.out_buf = out_buf,
.index = 0,
};
formatInt(value, base, uppercase, width, &context, error{}, formatIntCallback) catch unreachable;
return context.index;
}
const FormatIntBuf = struct {
out_buf: []u8,
index: usize,
};
fn formatIntCallback(context: &FormatIntBuf, bytes: []const u8) (error{}!void) {
mem.copy(u8, context.out_buf[context.index..], bytes);
context.index += bytes.len;
}
pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) !T {
if (!T.is_signed)
return parseUnsigned(T, buf, radix);
if (buf.len == 0)
return T(0);
if (buf[0] == '-') {
return math.negate(try parseUnsigned(T, buf[1..], radix));
} else if (buf[0] == '+') {
return parseUnsigned(T, buf[1..], radix);
} else {
return parseUnsigned(T, buf, radix);
}
}
test "fmt.parseInt" {
assert((parseInt(i32, "-10", 10) catch unreachable) == -10);
assert((parseInt(i32, "+10", 10) catch unreachable) == 10);
assert(if (parseInt(i32, " 10", 10)) |_| false else |err| err == error.InvalidCharacter);
assert(if (parseInt(i32, "10 ", 10)) |_| false else |err| err == error.InvalidCharacter);
assert(if (parseInt(u32, "-10", 10)) |_| false else |err| err == error.InvalidCharacter);
assert((parseInt(u8, "255", 10) catch unreachable) == 255);
assert(if (parseInt(u8, "256", 10)) |_| false else |err| err == error.Overflow);
}
const ParseUnsignedError = error {
/// The result cannot fit in the type specified
Overflow,
/// The input had a byte that was not a digit
InvalidCharacter,
};
pub fn parseUnsigned(comptime T: type, buf: []const u8, radix: u8) ParseUnsignedError!T {
var x: T = 0;
for (buf) |c| {
const digit = try charToDigit(c, radix);
x = try math.mul(T, x, radix);
x = try math.add(T, x, digit);
}
return x;
}
pub fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
const value = switch (c) {
'0' ... '9' => c - '0',
'A' ... 'Z' => c - 'A' + 10,
'a' ... 'z' => c - 'a' + 10,
else => return error.InvalidCharacter,
};
if (value >= radix)
return error.InvalidCharacter;
return value;
}
fn digitToChar(digit: u8, uppercase: bool) u8 {
return switch (digit) {
0 ... 9 => digit + '0',
10 ... 35 => digit + ((if (uppercase) u8('A') else u8('a')) - 10),
else => unreachable,
};
}
const BufPrintContext = struct {
remaining: []u8,
};
fn bufPrintWrite(context: &BufPrintContext, bytes: []const u8) !void {
if (context.remaining.len < bytes.len) return error.BufferTooSmall;
mem.copy(u8, context.remaining, bytes);
context.remaining = context.remaining[bytes.len..];
}
pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: ...) ![]u8 {
var context = BufPrintContext { .remaining = buf, };
try format(&context, error{BufferTooSmall}, bufPrintWrite, fmt, args);
return buf[0..buf.len - context.remaining.len];
}
pub fn allocPrint(allocator: &mem.Allocator, comptime fmt: []const u8, args: ...) ![]u8 {
var size: usize = 0;
format(&size, error{}, countSize, fmt, args) catch |err| switch (err) {};
const buf = try allocator.alloc(u8, size);
return bufPrint(buf, fmt, args);
}
fn countSize(size: &usize, bytes: []const u8) (error{}!void) {
*size += bytes.len;
}
test "buf print int" {
var buffer: [max_int_digits]u8 = undefined;
const buf = buffer[0..];
assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 2, false, 0), "-101111000110000101001110"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 10, false, 0), "-12345678"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, false, 0), "-bc614e"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, true, 0), "-BC614E"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(12345678), 10, true, 0), "12345678"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(666), 10, false, 6), "000666"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, 6), "001234"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, 1), "1234"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(42), 10, false, 3), "+42"));
assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-42), 10, false, 3), "-42"));
}
fn bufPrintIntToSlice(buf: []u8, value: var, base: u8, uppercase: bool, width: usize) []u8 {
return buf[0..formatIntBuf(buf, value, base, uppercase, width)];
}
test "parse u64 digit too big" {
_ = parseUnsigned(u64, "123a", 10) catch |err| {
if (err == error.InvalidCharacter) return;
unreachable;
};
unreachable;
}
test "parse unsigned comptime" {
comptime {
assert((try parseUnsigned(usize, "2", 10)) == 2);
}
}
test "fmt.format" {
{
var buf1: [32]u8 = undefined;
const value: ?i32 = 1234;
const result = try bufPrint(buf1[0..], "nullable: {}\n", value);
assert(mem.eql(u8, result, "nullable: 1234\n"));
}
{
var buf1: [32]u8 = undefined;
const value: ?i32 = null;
const result = try bufPrint(buf1[0..], "nullable: {}\n", value);
assert(mem.eql(u8, result, "nullable: null\n"));
}
{
var buf1: [32]u8 = undefined;
const value: error!i32 = 1234;
const result = try bufPrint(buf1[0..], "error union: {}\n", value);
assert(mem.eql(u8, result, "error union: 1234\n"));
}
{
var buf1: [32]u8 = undefined;
const value: error!i32 = error.InvalidChar;
const result = try bufPrint(buf1[0..], "error union: {}\n", value);
assert(mem.eql(u8, result, "error union: error.InvalidChar\n"));
}
{
var buf1: [32]u8 = undefined;
const value: u3 = 0b101;
const result = try bufPrint(buf1[0..], "u3: {}\n", value);
assert(mem.eql(u8, result, "u3: 5\n"));
}
{
// Dummy field because of https://github.com/zig-lang/zig/issues/557.
const Struct = struct {
unused: u8,
};
var buf1: [32]u8 = undefined;
const value = Struct {
.unused = 42,
};
const result = try bufPrint(buf1[0..], "pointer: {}\n", &value);
assert(mem.startsWith(u8, result, "pointer: Struct@"));
}
// TODO get these tests passing in release modes
// https://github.com/zig-lang/zig/issues/564
if (builtin.mode == builtin.Mode.Debug) {
{
var buf1: [32]u8 = undefined;
const value: f32 = 12.34;
const result = try bufPrint(buf1[0..], "f32: {}\n", value);
assert(mem.eql(u8, result, "f32: 1.23400001e1\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f64 = -12.34e10;
const result = try bufPrint(buf1[0..], "f64: {}\n", value);
assert(mem.eql(u8, result, "f64: -1.234e11\n"));
}
{
var buf1: [32]u8 = undefined;
const result = try bufPrint(buf1[0..], "f64: {}\n", math.nan_f64);
assert(mem.eql(u8, result, "f64: NaN\n"));
}
{
var buf1: [32]u8 = undefined;
const result = try bufPrint(buf1[0..], "f64: {}\n", math.inf_f64);
assert(mem.eql(u8, result, "f64: Infinity\n"));
}
{
var buf1: [32]u8 = undefined;
const result = try bufPrint(buf1[0..], "f64: {}\n", -math.inf_f64);
assert(mem.eql(u8, result, "f64: -Infinity\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f32 = 1.1234;
const result = try bufPrint(buf1[0..], "f32: {.1}\n", value);
assert(mem.eql(u8, result, "f32: 1.1\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f32 = 1234.567;
const result = try bufPrint(buf1[0..], "f32: {.2}\n", value);
assert(mem.eql(u8, result, "f32: 1234.56\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f32 = -11.1234;
const result = try bufPrint(buf1[0..], "f32: {.4}\n", value);
// -11.1234 is converted to f64 -11.12339... internally (errol3() function takes f64).
// -11.12339... is truncated to -11.1233
assert(mem.eql(u8, result, "f32: -11.1233\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f32 = 91.12345;
const result = try bufPrint(buf1[0..], "f32: {.}\n", value);
assert(mem.eql(u8, result, "f32: 91.12345\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f64 = 91.12345678901235;
const result = try bufPrint(buf1[0..], "f64: {.10}\n", value);
assert(mem.eql(u8, result, "f64: 91.1234567890\n"));
}
}
}
pub fn trim(buf: []const u8) []const u8 {
var start: usize = 0;
while (start < buf.len and isWhiteSpace(buf[start])) : (start += 1) { }
var end: usize = buf.len;
while (true) {
if (end > start) {
const new_end = end - 1;
if (isWhiteSpace(buf[new_end])) {
end = new_end;
continue;
}
}
break;
}
return buf[start..end];
}
test "fmt.trim" {
assert(mem.eql(u8, "abc", trim("\n abc \t")));
assert(mem.eql(u8, "", trim(" ")));
assert(mem.eql(u8, "", trim("")));
assert(mem.eql(u8, "abc", trim(" abc")));
assert(mem.eql(u8, "abc", trim("abc ")));
}
pub fn isWhiteSpace(byte: u8) bool {
return switch (byte) {
' ', '\t', '\n', '\r' => true,
else => false,
};
} | std/fmt/index.zig |
const regs = @import("registers.zig");
const gpio = @import("gpio.zig");
pub fn main() void {
systemInit();
// Enable GPIOD port
regs.RCC.AHB1ENR.modify(.{ .GPIODEN = 1 });
// Set PD12/13/14/15 mode to general purpose output
gpio.port.d.set_mode(12, .{ .output = .{} });
gpio.port.d.set_mode(13, .{ .output = .{} });
gpio.port.d.set_mode(14, .{ .output = .{} });
gpio.port.d.set_mode(15, .{ .output = .{} });
// Set PC13 mode to general purpose input
gpio.port.c.set_mode(13, .{ .input = .{ .mode = .pull_up } });
// Set pin 12 and 14
regs.GPIOD.BSRR.modify(.{ .BS12 = 1, .BS14 = 1 });
while (true) {
// Read the LED state
var leds_state = regs.GPIOD.ODR.read();
var a = gpio.port.d.read_output(14);
// Set the LED output to the negation of the currrent output
regs.GPIOD.ODR.modify(.{
.ODR12 = ~leds_state.ODR12,
.ODR13 = ~leds_state.ODR13,
.ODR14 = ~a,
.ODR15 = ~leds_state.ODR15,
});
// Sleep for some time
var i: u32 = 0;
while (i < 600000) {
asm volatile ("nop");
i += 1;
}
}
}
fn systemInit() void {
// This init does these things:
// - Enables the FPU coprocessor
// - Sets the external oscillator to achieve a clock frequency of 168MHz
// - Sets the correct PLL prescalers for that clock frequency
// - Enables the flash data and instruction cache and sets the correct latency for 168MHz
// Enable FPU coprocessor
// WARN: currently not supported in qemu, comment if testing it there
// regs.FPU_CPACR.CPACR.modify(.{ .CP = 0b11 });
// Enable HSI
regs.RCC.CR.modify(.{ .HSION = 1 });
// Wait for HSI ready
while (regs.RCC.CR.read().HSIRDY != 1) {}
// Select HSI as clock source
regs.RCC.CFGR.modify(.{ .SW0 = 0, .SW1 = 0 });
// Enable external high-speed oscillator (HSE)
regs.RCC.CR.modify(.{ .HSEON = 1 });
// Wait for HSE ready
while (regs.RCC.CR.read().HSERDY != 1) {}
// Set prescalers for 168 MHz: HPRE = 0, PPRE1 = DIV_2, PPRE2 = DIV_4
regs.RCC.CFGR.modify(.{ .HPRE = 0, .PPRE1 = 0b101, .PPRE2 = 0b100 });
// Disable PLL before changing its configuration
regs.RCC.CR.modify(.{ .PLLON = 0 });
// Set PLL prescalers and HSE clock source
// TODO: change the svd to expose prescalers as packed numbers instead of single bits
regs.RCC.PLLCFGR.modify(.{
.PLLSRC = 1,
// PLLM = 8 = 0b001000
.PLLM0 = 0,
.PLLM1 = 0,
.PLLM2 = 0,
.PLLM3 = 1,
.PLLM4 = 0,
.PLLM5 = 0,
// PLLN = 336 = 0b101010000
.PLLN0 = 0,
.PLLN1 = 0,
.PLLN2 = 0,
.PLLN3 = 0,
.PLLN4 = 1,
.PLLN5 = 0,
.PLLN6 = 1,
.PLLN7 = 0,
.PLLN8 = 1,
// PLLP = 2 = 0b10
.PLLP0 = 0,
.PLLP1 = 1,
// PLLQ = 7 = 0b111
.PLLQ0 = 1,
.PLLQ1 = 1,
.PLLQ2 = 1,
});
// Enable PLL
regs.RCC.CR.modify(.{ .PLLON = 1 });
// Wait for PLL ready
while (regs.RCC.CR.read().PLLRDY != 1) {}
// Enable flash data and instruction cache and set flash latency to 5 wait states
regs.FLASH.ACR.modify(.{ .DCEN = 1, .ICEN = 1, .LATENCY = 5 });
// Select PLL as clock source
regs.RCC.CFGR.modify(.{ .SW1 = 1, .SW0 = 0 });
// Wait for PLL selected as clock source
var cfgr = regs.RCC.CFGR.read();
while (cfgr.SWS1 != 1 and cfgr.SWS0 != 0) : (cfgr = regs.RCC.CFGR.read()) {}
// Disable HSI
regs.RCC.CR.modify(.{ .HSION = 0 });
} | src/main.zig |
const std = @import("std");
const Builder = @import("std").build.Builder;
fn addWebviewDeps(exe: *std.build.LibExeObjStep, webviewObjStep: *std.build.Step) void {
exe.step.dependOn(webviewObjStep);
exe.addIncludeDir("src/webview");
exe.addLibPath("/usr/lib");
exe.addObjectFile("src/webview/webview.o");
exe.linkSystemLibrary("c++");
exe.linkSystemLibrary("gtk+-3.0");
exe.linkSystemLibrary("webkit2gtk-4.0");
}
pub fn build(b: *Builder) void {
{
// b.verbose_cc = true;
const mode = b.standardReleaseOptions();
const mdView = b.addExecutable("mdv", "src/main.zig");
mdView.setBuildMode(mode);
mdView.addPackagePath("zig-log", "lib/log.zig/src/index.zig");
mdView.addPackagePath("mylog", "src/log/log.zig");
mdView.addPackagePath("zig-time", "lib/zig-time/src/time.zig");
mdView.c_std = Builder.CStd.C11;
const webviewObjStep = WebviewLibraryStep.create(b);
addWebviewDeps(mdView, &webviewObjStep.step);
mdView.install();
const run_cmd = mdView.run();
run_cmd.step.dependOn(b.getInstallStep());
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
}
{
const mdTest = b.addTest("test.zig");
mdTest.addPackagePath("zig-time", "lib/zig-time/src/time.zig");
mdTest.addPackagePath("zig-log", "lib/log.zig/src/index.zig");
b.step("test", "Run all tests").dependOn(&mdTest.step);
}
}
const WebviewLibraryStep = struct {
builder: *std.build.Builder,
step: std.build.Step,
fn create(builder: *std.build.Builder) *WebviewLibraryStep {
const self = builder.allocator.create(WebviewLibraryStep) catch unreachable;
self.* = init(builder);
return self;
}
fn init(builder: *std.build.Builder) WebviewLibraryStep {
return WebviewLibraryStep{
.builder = builder,
.step = std.build.Step.init(std.build.Step.Id.LibExeObj, "Webview Library Compile", builder.allocator, make),
};
}
fn make(step: *std.build.Step) !void {
const self = @fieldParentPtr(WebviewLibraryStep, "step", step);
const libs = std.mem.trim(u8, try self.builder.exec(
&[_][]const u8{ "pkg-config", "--cflags", "--libs", "gtk+-3.0", "webkit2gtk-4.0" },
), &std.ascii.spaces);
var cmd = std.ArrayList([]const u8).init(self.builder.allocator);
defer cmd.deinit();
try cmd.append("zig");
try cmd.append("c++");
// try cmd.append("--version");
// try cmd.append("-print-search-dirs");
try cmd.append("-v");
try cmd.append("-c");
try cmd.append("src/webview/webview.cc");
try cmd.append("-DWEBVIEW_GTK");
try cmd.append("-std=c++11");
var line_it = std.mem.tokenize(libs, " ");
while (line_it.next()) |item| {
try cmd.append(item);
}
try cmd.append("-o");
try cmd.append("src/webview/webview.o");
_ = std.mem.trim(u8, try self.builder.exec(cmd.items), &std.ascii.spaces);
}
}; | build.zig |
const std = @import("std");
pub const Action = enum {
Allow,
Deny,
};
pub const Flow = enum {
In,
Out,
Any,
};
pub const Protocol = enum {
TCP,
UDP,
Any,
};
pub const Port = union(enum) {
All: void,
Numeric: u16,
Range: struct { from: u16, to: u16 },
};
// TODO CIDR?
pub const Target = union(enum) {
Address: std.net.Address,
Any: void,
Local: void,
};
pub const Rule = struct {
interface: ?[]const u8,
action: Action,
flow: Flow,
protocol: Protocol,
port: Port,
from: Target,
to: Target,
fn printTarget(writer: anytype, comptime fmt: []const u8, target: Target) !void {
switch (target) {
.Any => {},
.Local => {
// TODO iface goes here
try writer.print(fmt, .{"inet4(wm0)"});
},
.Address => |addr| {
try writer.print(fmt, .{addr});
},
}
}
/// Print this rule as an NPF rule.
/// Caller owns the memory.
pub fn emitNpf(self: @This(), allocator: *std.mem.Allocator) ![]const u8 {
var list = std.ArrayList(u8).init(allocator);
defer list.deinit();
var writer = list.writer();
_ = switch (self.action) {
.Allow => try writer.write("pass"),
.Deny => try writer.write("block"),
};
if (self.protocol == .TCP) {
try writer.print(" stateful", .{});
}
switch (self.flow) {
.In => {
try writer.print(" in", .{});
},
.Out => {
try writer.print(" out", .{});
},
.Any => {},
}
if (self.interface) |interface| {
try writer.print(" on {}", .{self.interface});
}
_ = switch (self.protocol) {
.TCP => try writer.write(" proto tcp"),
.UDP => try writer.write(" proto udp"),
.Any => 0,
};
if (self.protocol == .TCP) {
try writer.print(" flags S/SA", .{});
}
try @This().printTarget(writer, " from {}", self.from);
try @This().printTarget(writer, " to {}", self.to);
switch (self.port) {
.All => try writer.print(" all", .{}),
.Numeric => |port_num| {
try writer.print(" port {}", .{port_num});
},
.Range => |range| {
try writer.print(" port {}-{}", .{ range.from, range.to });
},
}
return list.toOwnedSlice();
}
};
test "ensure rules print out to good npf rules" {
const iface = "wm0";
const lo_iface = "lo0";
const rules = [_]Rule{
.{
.interface = null,
.action = .Deny,
.flow = .Any,
.protocol = .Any,
.port = Port{ .All = {} },
.from = Target{ .Any = {} },
.to = Target{ .Any = {} },
},
.{
.interface = iface,
.action = .Allow,
.flow = .In,
.protocol = .TCP,
.port = Port{ .Numeric = 80 },
.from = Target{ .Any = {} },
.to = Target{ .Any = {} },
},
.{
.interface = iface,
.action = .Allow,
.flow = .In,
.protocol = .UDP,
.port = Port{ .Range = .{ .from = 60001, .to = 60999 } },
.from = Target{ .Any = {} },
.to = Target{ .Any = {} },
},
.{
.interface = iface,
.action = .Allow,
.flow = .Out,
.protocol = .UDP,
.port = Port{ .All = .{} },
.from = Target{ .Any = {} },
.to = Target{ .Any = {} },
},
.{
.interface = lo_iface,
.action = .Allow,
.flow = .Any,
.protocol = .Any,
.port = Port{ .All = .{} },
.from = Target{ .Any = {} },
.to = Target{ .Any = {} },
},
// .{
// .interface = iface,
// .action = .Allow,
// .flow = .Out,
// .protocol = .TCP,
// .port = Port{ .All = .{} },
// .from = Target{ .Any = {} },
// .to = Target{ .Any = {} },
// },
};
const npf_rules = [_][]const u8{
"block all",
"pass stateful in on " ++ iface ++ " proto tcp flags S/SA port 80",
"pass in on " ++ iface ++ " proto udp port 60001-60999",
"pass out on " ++ iface ++ " proto udp all",
"pass on " ++ lo_iface ++ " all",
//"pass stateful out on " ++ iface ++ " proto tcp all",
};
for (rules) |rule, idx| {
const npf_rule = try rule.emitNpf(std.testing.allocator);
defer std.testing.allocator.free(npf_rule);
const wanted_npf_rule = npf_rules[idx];
std.testing.expectEqualStrings(wanted_npf_rule, npf_rule);
}
} | src/rules.zig |
const fmt = @import("std").fmt;
const uefiConsole = @import("../uefi/console.zig");
const serial = @import("../debug/serial.zig");
const PSF_FONT_MAGIC: u32 = 0x864ab572;
const Font = packed struct {
magic: u32,
version: u32, // Zero
headerSize: u32, // Offset of bitmaps in file, 32
flags: u32, // 0 if no unicode table
numGlyphs: u32, // Number of glyphs
bytesPerGlyph: u32, // Size of each glyph
height: u32, // Height in pixels
width: u32, // Width in pixels
fn data(self: *const Font) [*]const u8 {
return @ptrCast([*]const u8, self) + self.headerSize;
}
};
const rawFontBuffer = @embedFile("Lat2-Terminus16.psfu");
pub const defaultFont = @ptrCast([*]const u8, rawFontBuffer);
pub fn asFont(buffer: [*]const u8) *const Font {
return @ptrCast(*const Font, buffer);
}
fn hexdump(buffer: []const u8, length: u32) [512]u8 {
var i: u64 = 0;
var j: u32 = 0;
var outBuffer: [512]u8 = undefined;
while (j < length and i < 512) : (j += 1) {
_ = fmt.bufPrint(outBuffer[i..], "{}", .{0xFF & buffer[j]}) catch unreachable;
i += fmt.count("{}", .{0xFF & buffer[i]});
}
return outBuffer;
}
pub fn debugGlyph(font: *const Font, glyph_index: u32) void {
if (glyph_index < 0 or glyph_index >= font.numGlyphs) {
return serial.writeText("out of range glyph\r\n");
}
const start = glyph_index * font.bytesPerGlyph;
const glyph = font.data()[start .. start + 16];
serial.printf("{} out of {}, offset {}, glyp at {*}\n", .{ glyph_index, font.numGlyphs, font.headerSize, font.data() + start });
for (glyph) |l| {
serial.printf("{b:0>8}\n", .{l});
}
}
pub fn renderChar(font: *const Font, dest: [*]u32, char: u8, cx: i32, cy: i32, fg: u32, bg: u32, scanLine: u32) void {
const bytesPerLine: u32 = (font.width + 7) / 8;
var glyph = font.data() + (if (char > 0 and char < font.numGlyphs) char else 0) * font.bytesPerGlyph;
var linePtr = dest + @bitCast(u32, (cy * @bitCast(i32, scanLine)) + cx);
var y: u32 = 0;
while (y < font.height) : (y += 1) {
var mask: u32 = @as(u32, 1) << @truncate(u5, (font.width - 1));
var lineByte: u32 = 0;
while (lineByte < bytesPerLine) : (lineByte += 1) {
const castedGlyph = @as(u32, glyph[0]) << @truncate(u5, (bytesPerLine - lineByte - 1));
var byteRowPtr = linePtr + lineByte * 8;
var x: u32 = 0;
while (x < font.width) : (x += 1) {
var target = byteRowPtr + x;
target.* = (if (castedGlyph & mask > 0) fg else bg);
mask >>= 1;
}
glyph += 1;
}
linePtr += scanLine;
}
} | src/kernel/fonts/psf2.zig |
const std = @import("std");
const time = std.time;
const math = @import("./math.zig");
const vec3 = math.vec3;
const Ray = struct {
normalized_direction: vec3,
position: vec3,
};
const Sphere = struct {
position: vec3,
radius: f32,
};
const Plane = struct {
normalized_direction: vec3,
distance: f32,
};
const SphereIntersection = struct {
distance1: f32 = -std.math.inf(f32),
distance2: f32 = -std.math.inf(f32),
};
fn intersect_sphere(ray: Ray, sphere: Sphere) SphereIntersection {
var ray_sphere_vector = math.sub_vec3(sphere.position, ray.position);
var ray_sphere_distance = math.dot_vec3(ray_sphere_vector, ray.normalized_direction);
if (ray_sphere_distance < 0) return .{};
var leg_squared = math.sq_vec3(ray_sphere_vector) - ray_sphere_distance * ray_sphere_distance;
var sphere_radius_squared = sphere.radius * sphere.radius;
if (leg_squared > sphere_radius_squared) return .{};
var chord_half = math.f_sqrt(sphere_radius_squared - leg_squared);
return .{
.distance1 = ray_sphere_distance - chord_half,
.distance2 = ray_sphere_distance + chord_half,
};
}
const PlaneIntersection = struct {
distance: f32 = -std.math.inf(f32),
};
fn intersect_plane(ray: Ray, plane: Plane) PlaneInterSection {
var denom = math.mul_vec3(ray.normalized_direction, plane.normalized_direction);
if (denom == 0) return .{};
return .{(plane.distance - math.mul_vec3(ray.position, plane.normalized_direction)) / denom};
}
pub const RGBA = struct {
R: u8,
G: u8,
B: u8,
A: u8 = 255,
};
pub fn raytrace(buffer: *[]RGBA, width: u32) !void {
const height = @divExact(buffer.len, width);
var sphere = Sphere{ .position = .{ 50, 0, 0 }, .radius = 20 };
const max_int: f32 = 255.0;
const x_fov = 90 * math.deg_to_rad;
const y_fov = x_fov * @intToFloat(f32, height) / @intToFloat(f32, width);
var y: usize = 0;
while (y < height) : (y += 1) {
var x: usize = 0;
while (x < width) : (x += 1) {
var a = (@intToFloat(f32, x) / @intToFloat(f32, width - 1) - 0.5) * x_fov;
var b = (@intToFloat(f32, y) / @intToFloat(f32, height - 1) - 0.5) * y_fov;
var ray = Ray{
.position = .{ 0, 0, 0 },
.normalized_direction = .{
math.cos(a) * math.cos(b),
math.sin(a),
math.cos(a) * math.sin(b),
},
}; // @TODO: implement camera transform
var intersection = intersect_sphere(ray, sphere);
var ray_sphere1 = math.mul_vec3(ray.normalized_direction, intersection.distance1);
var sphere_sphere1_vector = math.sub_vec3(ray_sphere1, sphere.position);
var cos = if (intersection.distance1 > 0) -math.cos_vec3(ray_sphere1, sphere_sphere1_vector) else 0;
buffer.*[y * width + x] = .{
.R = @floatToInt(u8, std.math.min(cos * max_int, max_int)),
.G = @floatToInt(u8, std.math.min(cos * max_int, max_int)),
.B = @floatToInt(u8, std.math.min(cos * max_int, max_int)),
};
}
}
} | src/raytrace.zig |
const std = @import("std");
const print = std.debug.print;
const testing = std.testing;
const ArrayList = std.ArrayList;
const AutoArrayHashMap = std.AutoArrayHashMap;
const mem = std.mem;
const alloc = std.testing.allocator;
pub const GraphError = error{ NodeAlreadyExists, EdgeAlreadyExists, NodesDoNotExist, EdgesDoNotExist };
pub fn Graph(comptime index_type: type, dir: bool) type {
return struct {
const Self = @This();
directed: bool = dir,
graph: AutoArrayHashMap(index_type, AutoArrayHashMap(index_type, index_type)),
edge_list: AutoArrayHashMap(index_type, [2]index_type),
allocator: *mem.Allocator,
pub fn init(alloc_in: *mem.Allocator) Self {
return Self{ .graph = AutoArrayHashMap(index_type, AutoArrayHashMap(index_type, index_type)).init(alloc_in), .edge_list = AutoArrayHashMap(index_type, [2]index_type).init(alloc_in), .allocator = alloc_in };
}
pub fn deinit(self: *Self) !void {
var itr = self.graph.iterator();
while (itr.next()) |entry| {
entry.value_ptr.deinit();
}
self.graph.deinit();
self.edge_list.deinit();
}
//Adding a node to the graph via index of node
pub fn addNode(self: *Self, id: index_type) !void {
if (!self.graph.contains(id)) {
try self.graph.put(id, AutoArrayHashMap(index_type, index_type).init(self.allocator));
} else {
return GraphError.NodeAlreadyExists;
}
}
//Adding an edge to a graph between nodes n1_id, and n2_id (note that order matters for a directed graph)
pub fn addEdge(self: *Self, id: index_type, n1_id: index_type, n2_id: index_type) !void {
if (self.edge_list.contains(id)) {
return GraphError.EdgeAlreadyExists;
}
if (!self.graph.contains(n1_id) or !self.graph.contains(n2_id)) {
return GraphError.NodesDoNotExist;
}
var node1_map = self.graph.get(n1_id);
try node1_map.?.put(id, n2_id);
try self.graph.put(n1_id, node1_map.?);
if (!self.directed) {
var node2_map = self.graph.get(n2_id);
try node2_map.?.put(id, n1_id);
try self.graph.put(n2_id, node2_map.?);
}
try self.edge_list.put(id, [2]index_type{ n1_id, n2_id });
}
//Remove just the node from the graph hashmap, the edges pointing to it will still be there,
//graph is thust invalid
pub fn removeNodeWithoutEdges(self: *Self, id: index_type) !void {
_ = try self.graph.swapRemove(id);
}
//Removes node with all edges going to/fro it
pub fn removeNodeWithEdges(self: *Self, id: index_type) !ArrayList(index_type) {
if (!self.graph.contains(id)) {
return GraphError.NodesDoNotExist;
}
if (self.directed) {
return self.removeNodeWithEdgesDirected(id);
} else {
return self.removeNodeWithEdgesUndirected(id);
}
}
//Removes node with all edges for an undirected graph (is faster than removeNodeWithEdgesDirected)
//Use removeNode, do not call this directly
fn removeNodeWithEdgesUndirected(self: *Self, id: index_type) !ArrayList(index_type) {
var n1_remove = self.graph.get(id);
var iterator_n1 = n1_remove.?.iterator();
var edges_removed = ArrayList(index_type).init(self.allocator);
while (iterator_n1.next()) |entry| {
var edge = entry.key_ptr.*;
try edges_removed.append(edge);
}
for (edges_removed.items) |index| {
try self.removeEdgeByID(index);
}
n1_remove.?.deinit();
//swap remove chosen because its faster than orderedRemove
_ = self.graph.swapRemove(id);
return edges_removed;
}
//Removes node with all edges for a directed graph
//Use removeNode, do not call this directly
fn removeNodeWithEdgesDirected(self: *Self, id: index_type) !ArrayList(index_type) {
var iterator = self.graph.iterator();
var edges_removed = ArrayList(index_type).init(self.allocator);
//removal of all edges going to the given node
while (iterator.next()) |entry| {
var node = entry.key_ptr.*;
var removal = try self.removeEdgesBetween(node, id);
try edges_removed.appendSlice(removal.items);
removal.deinit();
}
//removal of all edges going from the given node
var node_list = self.graph.get(id);
var node_iterator = node_list.?.iterator();
while (node_iterator.next()) |entry| {
var edge = entry.key_ptr.*;
try self.removeEdgeByID(edge);
try edges_removed.append(edge);
}
node_list.?.deinit();
_ = self.graph.swapRemove(id);
return edges_removed;
}
//Remove the edges between n1 and n2 (order matters for a directed graph)
pub fn removeEdgesBetween(self: *Self, n1_id: index_type, n2_id: index_type) !ArrayList(index_type) {
if (!self.graph.contains(n1_id) or !self.graph.contains(n2_id)) {
return GraphError.NodesDoNotExist;
}
var edges_removed = ArrayList(index_type).init(self.allocator);
var iterator_n1 = self.graph.get(n1_id).?.iterator();
while (iterator_n1.next()) |entry| {
var node = entry.value_ptr.*;
var edge = entry.key_ptr.*;
if (node == n2_id) {
try edges_removed.append(edge);
}
}
for (edges_removed.items) |index| {
try self.removeEdgeByID(index);
}
return edges_removed;
}
//Remove the edge with the given ID
pub fn removeEdgeByID(self: *Self, id: index_type) !void {
if (!self.edge_list.contains(id)) {
return GraphError.EdgesDoNotExist;
}
var node_data = self.edge_list.get(id);
var node1_list = self.graph.get(node_data.?[0]);
_ = node1_list.?.swapRemove(id);
try self.graph.put(node_data.?[0], node1_list.?);
if (!self.directed) {
var node2_list = self.graph.get(node_data.?[1]);
_ = node2_list.?.swapRemove(id);
try self.graph.put(node_data.?[1], node2_list.?);
}
_ = self.edge_list.swapRemove(id);
}
//Print the graph
pub fn print(self: *Self) !void {
var iterator = self.graph.iterator();
while (iterator.next()) |entry| {
std.debug.print("Node: {}\n", .{entry.key_ptr.*});
var node_itr = entry.value_ptr.iterator();
while (node_itr.next()) |value| {
std.debug.print("\t->Edge To: {}", .{value.value_ptr.*});
std.debug.print(" With ID: {}", .{value.key_ptr.*});
}
}
}
//Get the neighbors of a given node (returns the hashmap in graph hashmap)
pub fn GetNeighbors(self: *Self, id: index_type) !AutoArrayHashMap(index_type, index_type) {
if (!self.graph.contains(id)) {
return GraphError.NodesDoNotExist;
}
return self.graph.get(id).?;
}
//Returns 1 as default edge weight
pub fn getEdgeWeight(self: *Self, id: index_type) !u32 {
if (!self.edge_list.contains(id)) {
return GraphError.EdgesDoNotExist;
}
return 1;
}
};
}
test "nominal-addNode" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try testing.expect(graph.graph.count() == 1);
try testing.expect(graph.graph.contains(2));
try graph.deinit();
}
test "offnominal-addNode" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try testing.expect(if (graph.addNode(2)) |_| unreachable else |err| err == GraphError.NodeAlreadyExists);
try graph.deinit();
}
test "nominal-addEdgeDirected" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
try testing.expect(graph.edge_list.count() == 2);
var edge_list = graph.graph.get(2).?;
try testing.expect(edge_list.count() == 1);
edge_list = graph.graph.get(3).?;
try testing.expect(edge_list.count() == 1);
try testing.expect(graph.edge_list.count() == 2);
try graph.deinit();
}
test "offnominal-addEdge" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try testing.expect(if (graph.addEdge(1, 2, 3)) |_| unreachable else |err| err == GraphError.EdgeAlreadyExists);
try graph.deinit();
}
test "nominal-addEdgeUndirected" {
var graph = Graph(u32, false).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
try testing.expect(graph.edge_list.count() == 2);
var edge_list = graph.graph.get(2).?;
try testing.expect(edge_list.count() == 2);
edge_list = graph.graph.get(3).?;
try testing.expect(edge_list.count() == 2);
try graph.deinit();
}
test "nominal-removeNodeWithEdgesDirected" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
var edge_list = try graph.removeNodeWithEdges(2);
edge_list.deinit();
try testing.expect(graph.edge_list.count() == 0);
try testing.expect(graph.graph.count() == 1);
try testing.expect(graph.graph.get(3).?.count() == 0);
try testing.expect(graph.edge_list.count() == 0);
try graph.deinit();
}
test "nominal-removeNodeWithEdgesUndirected" {
var graph = Graph(u32, false).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
var edges = try graph.removeNodeWithEdges(2);
try testing.expect(edges.items.len == 2);
try testing.expect(graph.edge_list.count() == 0);
try testing.expect(graph.graph.count() == 1);
try testing.expect(graph.graph.get(3).?.count() == 0);
try testing.expect(graph.edge_list.count() == 0);
try graph.deinit();
edges.deinit();
}
test "offnominal-removeNodeWithEdges" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try testing.expect(if (graph.removeNodeWithEdges(5)) |_| unreachable else |err| err == GraphError.NodesDoNotExist);
try graph.deinit();
}
test "nominal-removeEdgeByIDDirected" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
try graph.removeEdgeByID(2);
try testing.expect(graph.edge_list.count() == 1);
var edge_list = graph.graph.get(2).?;
try testing.expect(edge_list.count() == 1);
edge_list = graph.graph.get(3).?;
try testing.expect(edge_list.count() == 0);
try testing.expect(graph.edge_list.count() == 1);
try graph.deinit();
}
test "nominal-removeEdgeByIDUndirected" {
var graph = Graph(u32, false).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
try graph.removeEdgeByID(2);
try graph.removeEdgeByID(1);
try testing.expect(graph.edge_list.count() == 0);
var edge_list = graph.graph.get(2).?;
try testing.expect(edge_list.count() == 0);
edge_list = graph.graph.get(3).?;
try testing.expect(edge_list.count() == 0);
try testing.expect(graph.edge_list.count() == 0);
try graph.deinit();
}
test "offnominal-removeEdgeByID" {
var graph = Graph(u32, false).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
try testing.expect(if (graph.removeEdgeByID(5)) |_| unreachable else |err| err == GraphError.EdgesDoNotExist);
try graph.deinit();
}
test "nominal-removeEdgesBetween" {
var graph = Graph(u32, false).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
var edges = try graph.removeEdgesBetween(2, 3);
edges.deinit();
var edge_list = graph.graph.get(2).?;
edge_list = graph.graph.get(3).?;
try testing.expect(graph.edge_list.count() == 0);
try graph.deinit();
}
test "offnominal-removeEdgesBetween" {
var graph = Graph(u32, false).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 3, 2);
try testing.expect(if (graph.removeEdgesBetween(5, 4)) |_| unreachable else |err| err == GraphError.NodesDoNotExist);
try graph.deinit();
}
test "nominal-GetNeighbors" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addNode(4);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 2, 4);
var neighbors = try graph.GetNeighbors(2);
try testing.expect(neighbors.get(1).? == 3);
try testing.expect(neighbors.get(2).? == 4);
try graph.deinit();
}
test "offnominal-GetNeighbors" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addNode(4);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 2, 4);
try testing.expect(if (graph.GetNeighbors(6)) |_| unreachable else |err| err == GraphError.NodesDoNotExist);
try graph.deinit();
}
test "nominal-getEdgeWeight" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addNode(4);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 2, 4);
var weight = try graph.getEdgeWeight(2);
try testing.expect(weight == 1);
try graph.deinit();
}
test "offnominal-getEdgeWeight" {
var graph = Graph(u32, true).init(alloc);
try graph.addNode(2);
try graph.addNode(3);
try graph.addNode(4);
try graph.addEdge(1, 2, 3);
try graph.addEdge(2, 2, 4);
try testing.expect(if (graph.getEdgeWeight(4)) |_| unreachable else |err| err == GraphError.EdgesDoNotExist);
try graph.deinit();
} | src/graph.zig |
const std = @import("std");
const fmt = std.fmt;
const mem = std.mem;
const unicode = std.unicode;
/// Improved Utf8View which also keeps track of the length in codepoints
pub const Utf8View = struct {
bytes: []const u8,
len: usize,
pub fn init(str: []const u8) !Utf8View {
return Utf8View{
.bytes = str,
.len = try utf8Len(str),
};
}
pub fn slice(view: Utf8View, start: usize, end: usize) Utf8View {
var len: usize = 0;
var i: usize = 0;
var it = view.iterator();
while (i < start) : (i += 1)
len += @boolToInt(it.nextCodepointSlice() != null);
const start_i = it.i;
while (i < end) : (i += 1)
len += @boolToInt(it.nextCodepointSlice() != null);
return .{
.bytes = view.bytes[start_i..it.i],
.len = len,
};
}
pub fn iterator(view: Utf8View) unicode.Utf8Iterator {
return unicode.Utf8View.initUnchecked(view.bytes).iterator();
}
pub fn format(
self: @This(),
comptime fmt_str: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
try fmt.formatType(
self.bytes,
fmt_str,
options,
writer,
fmt.default_max_depth,
);
}
};
/// Given a string of words, this function will split the string into lines where
/// a maximum of `max_line_len` characters can occure on each line.
pub fn splitIntoLines(allocator: mem.Allocator, max_line_len: usize, string: Utf8View) !Utf8View {
var res = std.ArrayList(u8).init(allocator);
errdefer res.deinit();
var curr_line_len: usize = 0;
var it = mem.tokenize(u8, string.bytes, " \n");
while (it.next()) |word_bytes| {
const word = Utf8View.init(word_bytes) catch unreachable;
const next_line_len = word.len + curr_line_len + (1 * @boolToInt(curr_line_len != 0));
if (next_line_len > max_line_len) {
try res.appendSlice("\n");
try res.appendSlice(word_bytes);
curr_line_len = word.len;
} else {
if (curr_line_len != 0)
try res.appendSlice(" ");
try res.appendSlice(word_bytes);
curr_line_len = next_line_len;
}
}
return Utf8View.init(res.toOwnedSlice()) catch unreachable;
}
fn utf8Len(s: []const u8) !usize {
var res: usize = 0;
var i: usize = 0;
while (i < s.len) : (res += 1) {
const cp_len = try unicode.utf8ByteSequenceLength(s[i]);
if (i + cp_len > s.len) {
return error.InvalidUtf8;
}
if (unicode.utf8Decode(s[i .. i + cp_len])) |_| {} else |_| {
return error.InvalidUtf8;
}
i += cp_len;
}
return res;
} | src/common/unicode.zig |
const std = @import("std");
const common = @import("../common/data.zig");
const options = @import("../common/options.zig");
const protocol = @import("../common/protocol.zig");
const rng = @import("../common/rng.zig");
const data = @import("data.zig");
const assert = std.debug.assert;
const expectEqual = std.testing.expectEqual;
const Choice = common.Choice;
const showdown = options.showdown;
const PSRNG = rng.PSRNG;
const DVs = data.DVs;
const Move = data.Move;
const MoveSlot = data.MoveSlot;
const Species = data.Species;
const Stats = data.Stats;
const Status = data.Status;
const ArgType = protocol.ArgType;
const Log = protocol.Log(std.io.FixedBufferStream([]u8).Writer);
pub const Battle = struct {
pub fn init(
seed: u64,
p1: []const Pokemon,
p2: []const Pokemon,
) data.Battle(data.PRNG) {
return .{
.rng = prng(&PSRNG.init(seed), true),
.sides = .{ Side.init(p1), Side.init(p2) },
};
}
pub fn fixed(
comptime rolls: anytype,
p1: []const Pokemon,
p2: []const Pokemon,
) data.Battle(rng.FixedRNG(1, rolls.len)) {
return .{
.rng = .{ .rolls = rolls },
.sides = .{ Side.init(p1), Side.init(p2) },
};
}
pub fn random(rand: *PSRNG, initial: bool) data.Battle(data.PRNG) {
var p1: u4 = 0;
var p2: u4 = 0;
var battle: data.Battle(data.PRNG) = .{
.rng = prng(rand, initial),
.turn = if (initial) 0 else rand.range(u16, 1, 1000 + 1),
.last_damage = if (initial) 0 else rand.range(u16, 1, 704 + 1),
.sides = .{ Side.random(rand, &p1, initial), Side.random(rand, &p2, initial) },
};
battle.last_selected_indexes.p1 = p1;
battle.last_selected_indexes.p2 = p2;
return battle;
}
};
fn prng(rand: *PSRNG, initial: bool) data.PRNG {
// GLITCH: initial bytes in seed can only range from 0-252, not 0-255
const max: u9 = if (initial) 253 else 256;
return .{
.src = .{
.seed = if (showdown)
rand.newSeed()
else .{
rand.range(u8, 0, max), rand.range(u8, 0, max),
rand.range(u8, 0, max), rand.range(u8, 0, max),
rand.range(u8, 0, max), rand.range(u8, 0, max),
rand.range(u8, 0, max), rand.range(u8, 0, max),
rand.range(u8, 0, max), rand.range(u8, 0, max),
},
},
};
}
pub const Side = struct {
pub fn init(ps: []const Pokemon) data.Side {
assert(ps.len > 0 and ps.len <= 6);
var side = data.Side{};
var i: u4 = 0;
while (i < ps.len) : (i += 1) {
side.pokemon[i] = Pokemon.init(ps[i]);
side.order[i] = i + 1;
}
return side;
}
pub fn random(rand: *PSRNG, index: *u4, initial: bool) data.Side {
const n = if (rand.chance(u8, 1, 100)) rand.range(u4, 1, 5 + 1) else 6;
var side = data.Side{};
var i: u4 = 0;
while (i < n) : (i += 1) {
side.pokemon[i] = Pokemon.random(rand, initial);
side.order[i] = i + 1;
var pokemon = &side.pokemon[i];
if (initial) continue;
var j: u4 = 0;
while (j < 4) : (j += 1) {
if (rand.chance(u8, 1, 5 + (@as(u8, i) * 2))) {
side.last_selected_move = pokemon.moves[j].id;
index.* = j;
}
if (rand.chance(u8, 1, 5 + (@as(u8, i) * 2))) {
side.last_used_move = pokemon.moves[j].id;
}
}
if (i == 0) {
var active = &side.active;
active.stats = pokemon.stats;
inline for (std.meta.fields(@TypeOf(active.boosts))) |field| {
if (field.field_type != u4) continue;
if (rand.chance(u8, 1, 10)) {
@field(active.boosts, field.name) =
@truncate(i4, @as(i5, rand.range(u4, 0, 12 + 1)) - 6);
}
}
active.species = pokemon.species;
for (pokemon.moves) |m, k| {
active.moves[k] = m;
}
active.types = pokemon.types;
var volatiles = &active.volatiles;
inline for (std.meta.fields(@TypeOf(active.volatiles))) |field| {
if (field.field_type != bool) continue;
if (comptime std.mem.eql(u8, field.name, "Transform")) continue;
if (rand.chance(u8, 1, 18)) {
@field(volatiles, field.name) = true;
if (std.mem.eql(u8, field.name, "Bide")) {
volatiles.state = rand.range(u16, 1, active.stats.hp);
} else if (std.mem.eql(u8, field.name, "Trapping")) {
volatiles.attacks = rand.range(u3, 0, 4 + 1);
} else if (std.mem.eql(u8, field.name, "Thrashing")) {
volatiles.attacks = rand.range(u3, 0, 4 + 1);
volatiles.state =
if (rand.chance(u8, 1, 10)) rand.range(u8, 1, 255 + 1) else 0;
} else if (std.mem.eql(u8, field.name, "Rage")) {
volatiles.state =
if (rand.chance(u8, 1, 10)) rand.range(u8, 1, 255 + 1) else 0;
} else if (std.mem.eql(u8, field.name, "Confusion")) {
volatiles.confusion = rand.range(u3, 1, 5 + 1);
} else if (std.mem.eql(u8, field.name, "Toxic")) {
pokemon.status = Status.init(Status.PSN);
volatiles.toxic = rand.range(u4, 1, 15 + 1);
} else if (std.mem.eql(u8, field.name, "Substitute")) {
volatiles.substitute =
rand.range(u8, 1, @truncate(u8, active.stats.hp / 4) + 1);
}
}
}
if (rand.chance(u8, 1, 20)) {
const m = rand.range(u4, 0, 4);
if (active.moves[m].id != .None) {
volatiles.disabled = .{
.move = m,
.duration = rand.range(u4, 1, 5 + 1),
};
}
}
}
}
return side;
}
};
pub const EXP = 0xFFFF;
pub const Pokemon = struct {
species: Species,
moves: []const Move,
hp: ?u16 = null,
status: u8 = 0,
level: u8 = 100,
stats: Stats(u16) = .{ .hp = EXP, .atk = EXP, .def = EXP, .spe = EXP, .spc = EXP },
pub fn init(p: Pokemon) data.Pokemon {
var pokemon = data.Pokemon{};
pokemon.species = p.species;
const species = Species.get(p.species);
inline for (std.meta.fields(@TypeOf(pokemon.stats))) |field| {
@field(pokemon.stats, field.name) = Stats(u16).calc(
field.name,
@field(species.stats, field.name),
0xF,
@field(p.stats, field.name),
p.level,
);
}
assert(p.moves.len > 0 and p.moves.len <= 4);
for (p.moves) |m, j| {
pokemon.moves[j].id = m;
// NB: PP can be at most 61 legally (though can overflow to 63)
pokemon.moves[j].pp = @truncate(u8, @minimum(Move.pp(m) / 5 * 8, 61));
}
if (p.hp) |hp| {
pokemon.hp = hp;
} else {
pokemon.hp = pokemon.stats.hp;
}
pokemon.status = p.status;
pokemon.types = species.types;
pokemon.level = p.level;
return pokemon;
}
pub fn random(rand: *PSRNG, initial: bool) data.Pokemon {
const s = @intToEnum(Species, rand.range(u8, 1, 151 + 1));
const species = Species.get(s);
const lvl = if (rand.chance(u8, 1, 20)) rand.range(u8, 1, 99 + 1) else 100;
var stats: Stats(u16) = .{};
const dvs = DVs.random(rand);
inline for (std.meta.fields(@TypeOf(stats))) |field| {
@field(stats, field.name) = Stats(u16).calc(
field.name,
@field(species.stats, field.name),
if (field.field_type != u4) dvs.hp() else @field(dvs, field.name),
if (rand.chance(u8, 1, 20)) rand.range(u8, 0, 255 + 1) else 255,
lvl,
);
}
var ms = [_]MoveSlot{.{}} ** 4;
var i: u4 = 0;
const n = if (rand.chance(u8, 1, 100)) rand.range(u4, 1, 3 + 1) else 4;
while (i < n) : (i += 1) {
var m: Move = .None;
sample: while (true) {
m = @intToEnum(Move, rand.range(u8, 1, 165 + 1));
var j: u4 = 0;
while (j < i) : (j += 1) {
if (ms[j].id == m) continue :sample;
if (showdown and blocked(m)) continue :sample;
}
break;
}
const pp_ups =
if (!initial and rand.chance(u8, 1, 10)) rand.range(u2, 0, 2 + 1) else 3;
// NB: PP can be at most 61 legally (though can overflow to 63)
const max_pp = @truncate(u8, @minimum(Move.pp(m) / 5 * (5 + @as(u8, pp_ups)), 61));
ms[i] = .{
.id = m,
.pp = if (initial) max_pp else rand.range(u8, 0, max_pp + 1),
};
}
return .{
.species = s,
.types = species.types,
.level = lvl,
.stats = stats,
.hp = if (initial) stats.hp else rand.range(u16, 0, stats.hp + 1),
// TODO: SLF
.status = if (!initial and rand.chance(u8, 1, 6 + 1))
0 | (@as(u8, 1) << rand.range(u3, 1, 6 + 1))
else
0,
.moves = ms,
};
}
};
// cat src/test/blocklist.json | jq '."1".moves'
fn blocked(m: Move) bool {
if (Move.get(m).effect == .Trapping) return true;
return switch (m) {
.Bind, .Counter, .Mimic, .Haze, .Bide, .Metronome, .MirrorMove, .Transform => true,
else => false,
};
}
pub fn move(slot: u4) Choice {
return .{ .type = .Move, .data = slot };
}
pub fn swtch(slot: u4) Choice {
return .{ .type = .Switch, .data = slot };
} | src/lib/gen1/helpers.zig |
const std = @import("std");
const reg = @import("registry.zig");
const util = @import("util.zig");
const cparse = @import("c-parse.zig");
const mem = std.mem;
const Allocator = mem.Allocator;
const preamble =
\\
\\// This file is generated from the Khronos Vulkan XML API Registry
\\
\\const std = @import("std");
\\const builtin = @import("builtin");
\\const root = @import("root");
\\pub const vulkan_call_conv: builtin.CallingConvention = if (builtin.os.tag == .windows)
\\ .Stdcall
\\ else if (builtin.abi == .android and (builtin.cpu.arch.isARM() or builtin.cpu.arch.isThumb()) and builtin.Target.arm.featureSetHas(builtin.cpu.features, .has_v7) and builtin.cpu.arch.ptrBitWidth() == 32)
\\ // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
\\ // calling convention, i.e. float parameters are passed in registers. This
\\ // is true even if the rest of the application passes floats on the stack,
\\ // as it does by default when compiling for the armeabi-v7a NDK ABI.
\\ .AAPCSVFP
\\ else
\\ .C;
\\pub fn FlagsMixin(comptime FlagsType: type) type {
\\ return struct {
\\ pub const IntType = Flags;
\\ pub fn toInt(self: FlagsType) IntType {
\\ return @bitCast(IntType, self);
\\ }
\\ pub fn fromInt(flags: IntType) FlagsType {
\\ return @bitCast(FlagsType, flags);
\\ }
\\ pub fn merge(lhs: FlagsType, rhs: FlagsType) FlagsType {
\\ return fromInt(toInt(lhs) | toInt(rhs));
\\ }
\\ pub fn intersect(lhs: FlagsType, rhs: FlagsType) FlagsType {
\\ return fromInt(toInt(lhs) & toInt(rhs));
\\ }
\\ pub fn complement(self: FlagsType) FlagsType {
\\ return fromInt(~toInt(lhs));
\\ }
\\ pub fn subtract(lhs: FlagsType, rhs: FlagsType) FlagsType {
\\ return fromInt(toInt(lhs) & toInt(rhs.complement()));
\\ }
\\ pub fn contains(lhs: FlagsType, rhs: FlagsType) bool {
\\ return toInt(intersect(lhs, rhs)) == toInt(rhs);
\\ }
\\ };
\\}
\\pub fn makeVersion(major: u10, minor: u10, patch: u12) u32 {
\\ return (@as(u32, major) << 22) | (@as(u32, minor) << 12) | patch;
\\}
\\pub fn versionMajor(version: u32) u10 {
\\ return @truncate(u10, version >> 22);
\\}
\\pub fn versionMinor(version: u32) u10 {
\\ return @truncate(u10, version >> 12);
\\}
\\pub fn versionPatch(version: u32) u12 {
\\ return @truncate(u12, version);
\\}
\\
;
const builtin_types = std.ComptimeStringMap([]const u8, .{
.{"void", @typeName(void)},
.{"char", @typeName(u8)},
.{"float", @typeName(f32)},
.{"double", @typeName(f64)},
.{"uint8_t", @typeName(u8)},
.{"uint16_t", @typeName(u16)},
.{"uint32_t", @typeName(u32)},
.{"uint64_t", @typeName(u64)},
.{"int32_t", @typeName(i32)},
.{"int64_t", @typeName(i64)},
.{"size_t", @typeName(usize)},
.{"int", @typeName(c_int)},
});
const foreign_types = std.ComptimeStringMap([]const u8, .{
.{"Display", "@Type(.Opaque)"},
.{"VisualID", @typeName(c_uint)},
.{"Window", @typeName(c_ulong)},
.{"RROutput", @typeName(c_ulong)},
.{"wl_display", "@Type(.Opaque)"},
.{"wl_surface", "@Type(.Opaque)"},
.{"HINSTANCE", "std.os.HINSTANCE"},
.{"HWND", "*@Type(.Opaque)"},
.{"HMONITOR", "*@Type(.Opaque)"},
.{"HANDLE", "std.os.HANDLE"},
.{"SECURITY_ATTRIBUTES", "std.os.SECURITY_ATTRIBUTES"},
.{"DWORD", "std.os.DWORD"},
.{"LPCWSTR", "std.os.LPCWSTR"},
.{"xcb_connection_t", "@Type(.Opaque)"},
.{"xcb_visualid_t", @typeName(u32)},
.{"xcb_window_t", @typeName(u32)},
.{"zx_handle_t", @typeName(u32)},
});
fn eqlIgnoreCase(lhs: []const u8, rhs: []const u8) bool {
if (lhs.len != rhs.len) {
return false;
}
for (lhs) |c, i| {
if (std.ascii.toLower(c) != std.ascii.toLower(rhs[i])) {
return false;
}
}
return true;
}
fn Renderer(comptime WriterType: type) type {
return struct {
const Self = @This();
const WriteError = WriterType.Error;
const RenderTypeInfoError = WriteError || error {
OutOfMemory,
};
const BitflagName = struct {
/// Name without FlagBits, so VkSurfaceTransformFlagBitsKHR
/// becomes VkSurfaceTransform
base_name: []const u8,
/// Optional tag of the flag
tag: ?[]const u8,
};
const ParamType = enum {
in_pointer,
out_pointer,
bitflags,
mut_buffer_len,
buffer_len,
other,
};
const ReturnValue = struct {
name: []const u8,
return_value_type: reg.TypeInfo,
origin: enum {
parameter,
inner_return_value,
},
};
const CommandDispatchType = enum {
base,
instance,
device,
};
writer: WriterType,
allocator: *Allocator,
registry: *const reg.Registry,
id_renderer: util.IdRenderer,
fn init(writer: WriterType, allocator: *Allocator, registry: *const reg.Registry) Self {
return .{
.writer = writer,
.allocator = allocator,
.registry = registry,
.id_renderer = util.IdRenderer.init(allocator, registry.tags),
};
}
fn deinit(self: Self) void {
self.id_renderer.deinit();
}
fn writeIdentifier(self: Self, id: []const u8) !void {
try self.id_renderer.render(self.writer, id);
}
fn writeIdentifierWithCase(self: *Self, case: util.CaseStyle, id: []const u8) !void {
try self.id_renderer.renderWithCase(self.writer, case, id);
}
fn writeIdentifierFmt(self: *Self, comptime fmt: []const u8, args: anytype) !void {
try self.id_renderer.renderFmt(self.writer, fmt, args);
}
fn extractEnumFieldName(self: Self, enum_name: []const u8, field_name: []const u8) ![]const u8 {
const adjusted_enum_name = util.stripAuthorTag(enum_name, self.registry.tags);
var enum_it = util.SegmentIterator.init(adjusted_enum_name);
var field_it = util.SegmentIterator.init(field_name);
while (true) {
const rest = field_it.rest();
const enum_segment = enum_it.next() orelse return rest;
const field_segment = field_it.next() orelse return error.FieldNameEqualsEnumName;
if (!eqlIgnoreCase(enum_segment, field_segment)) {
return rest;
}
}
}
fn extractBitflagName(self: Self, name: []const u8) ?BitflagName {
const tag = util.getAuthorTag(name, self.registry.tags);
const base_name = if (tag) |tag_name| name[0 .. name.len - tag_name.len] else name;
if (!mem.endsWith(u8, base_name, "FlagBits")) {
return null;
}
return BitflagName{
.base_name = base_name[0 .. base_name.len - "FlagBits".len],
.tag = tag,
};
}
fn isFlags(self: Self, name: []const u8) bool {
const tag = util.getAuthorTag(name, self.registry.tags);
const base_name = if (tag) |tag_name| name[0 .. name.len - tag_name.len] else name;
return mem.endsWith(u8, base_name, "Flags");
}
fn classifyParam(self: Self, param: reg.Command.Param) !ParamType {
switch (param.param_type) {
.pointer => |ptr| {
if (param.is_buffer_len) {
if (ptr.is_const or ptr.is_optional) {
return error.InvalidRegistry;
}
return .mut_buffer_len;
}
if (ptr.child.* == .name) {
const child_name = ptr.child.name;
if (mem.eql(u8, child_name, "void")) {
return .other;
} else if (builtin_types.get(child_name) == null and util.trimVkNamespace(child_name).ptr == child_name.ptr) {
return .other; // External type
}
}
if (ptr.size == .one and !ptr.is_optional) {
if (ptr.is_const) {
return .in_pointer;
} else {
return .out_pointer;
}
}
},
.name => |name| {
if (self.extractBitflagName(param.param_type.name) != null or self.isFlags(param.param_type.name)) {
return .bitflags;
}
},
else => {},
}
if (param.is_buffer_len) {
return .buffer_len;
}
return .other;
}
fn classifyCommandDispatch(self: Self, name: []const u8, command: reg.Command) CommandDispatchType {
const device_handles = std.ComptimeStringMap(void, .{
.{"VkDevice", {}},
.{"VkCommandBuffer", {}},
.{"VkQueue", {}},
});
const override_functions = std.ComptimeStringMap(CommandDispatchType, .{
.{"vkGetInstanceProcAddr", .base},
.{"vkCreateInstance", .base},
.{"vkEnumerateInstanceLayerProperties", .base},
.{"vkEnumerateInstanceExtensionProperties", .base},
.{"vkEnumerateInstanceVersion", .base},
.{"vkGetDeviceProcAddr", .instance},
});
if (override_functions.get(name)) |dispatch_type| {
return dispatch_type;
}
switch (command.params[0].param_type) {
.name => |first_param_type_name| {
if (device_handles.get(first_param_type_name)) |_| {
return .device;
}
},
else => {},
}
return .instance;
}
fn render(self: *Self) !void {
try self.renderCopyright();
try self.writer.writeAll(preamble);
for (self.registry.api_constants) |api_constant| {
try self.renderApiConstant(api_constant);
}
for (self.registry.decls) |decl| {
try self.renderDecl(decl);
}
try self.renderCommandPtrs();
try self.renderExtensionInfo();
try self.renderWrappers();
}
fn renderCopyright(self: *Self) !void {
var it = mem.split(self.registry.copyright, "\n");
while (it.next()) |line| {
try self.writer.print("// {}\n", .{line});
}
}
fn renderApiConstant(self: *Self, api_constant: reg.ApiConstant) !void {
try self.writer.writeAll("pub const ");
try self.renderName(api_constant.name);
try self.writer.writeAll(" = ");
switch (api_constant.value) {
.expr => |expr| try self.renderApiConstantExpr(expr),
.version => |version| {
try self.writer.writeAll("makeVersion(");
for (version) |part, i| {
if (i != 0) {
try self.writer.writeAll(", ");
}
try self.renderApiConstantExpr(part);
}
try self.writer.writeAll(")");
},
}
try self.writer.writeAll(";\n");
}
fn renderApiConstantExpr(self: *Self, expr: []const u8) !void {
const adjusted_expr = if (expr.len > 2 and expr[0] == '(' and expr[expr.len - 1] == ')')
expr[1 .. expr.len - 1]
else
expr;
var tokenizer = cparse.CTokenizer{.source = adjusted_expr};
var peeked: ?cparse.Token = null;
while (true) {
const tok = peeked orelse (try tokenizer.next()) orelse break;
peeked = null;
switch (tok.kind) {
.lparen, .rparen, .tilde, .minus => {
try self.writer.writeAll(tok.text);
continue;
},
.id => {
try self.renderName(tok.text);
continue;
},
.int => {},
else => return error.InvalidApiConstant,
}
const suffix = (try tokenizer.next()) orelse {
try self.writer.writeAll(tok.text);
break;
};
switch (suffix.kind) {
.id => {
if (mem.eql(u8, suffix.text, "ULL")) {
try self.writer.print("@as(u64, {})", .{tok.text});
} else if (mem.eql(u8, suffix.text, "U")) {
try self.writer.print("@as(u32, {})", .{tok.text});
} else {
return error.InvalidApiConstant;
}
},
.dot => {
const decimal = (try tokenizer.next()) orelse return error.InvalidConstantExpr;
try self.writer.print("@as(f32, {}.{})", .{tok.text, decimal.text});
const f = (try tokenizer.next()) orelse return error.InvalidConstantExpr;
if (f.kind != .id or !mem.eql(u8, f.text, "f")) {
return error.InvalidApiConstant;
}
},
else => {
try self.writer.writeAll(tok.text);
peeked = suffix;
},
}
}
}
fn renderTypeInfo(self: *Self, type_info: reg.TypeInfo) RenderTypeInfoError!void {
switch (type_info) {
.name => |name| try self.renderName(name),
.command_ptr => |command_ptr| try self.renderCommandPtr(command_ptr, true),
.pointer => |pointer| try self.renderPointer(pointer),
.array => |array| try self.renderArray(array),
}
}
fn renderName(self: *Self, name: []const u8) !void {
if (builtin_types.get(name)) |zig_name| {
try self.writer.writeAll(zig_name);
return;
} else if (self.extractBitflagName(name)) |bitflag_name| {
try self.writeIdentifierFmt("{}Flags{}", .{
util.trimVkNamespace(bitflag_name.base_name),
@as([]const u8, if (bitflag_name.tag) |tag| tag else "")
});
return;
} else if (mem.startsWith(u8, name, "vk")) {
// Function type, always render with the exact same text for linking purposes.
try self.writeIdentifier(name);
return;
} else if (mem.startsWith(u8, name, "Vk")) {
// Type, strip namespace and write, as they are alreay in title case.
try self.writeIdentifier(name[2..]);
return;
} else if (mem.startsWith(u8, name, "PFN_vk")) {
// Function pointer type, strip off the PFN_vk part and replace it with Pfn. Note that
// this function is only called to render the typedeffed function pointers like vkVoidFunction
try self.writeIdentifierFmt("Pfn{}", .{name[6..]});
return;
} else if (mem.startsWith(u8, name, "VK_")) {
// Constants
try self.writeIdentifier(name[3..]);
return;
}
try self.writeIdentifier(name);
}
fn renderCommandPtr(self: *Self, command_ptr: reg.Command, optional: bool) !void {
if (optional) {
try self.writer.writeByte('?');
}
try self.writer.writeAll("fn(");
for (command_ptr.params) |param| {
try self.writeIdentifierWithCase(.snake, param.name);
try self.writer.writeAll(": ");
blk: {
if (param.param_type == .name) {
if (self.extractBitflagName(param.param_type.name)) |bitflag_name| {
try self.writeIdentifierFmt("{}Flags{}", .{
util.trimVkNamespace(bitflag_name.base_name),
@as([]const u8, if (bitflag_name.tag) |tag| tag else "")
});
try self.writer.writeAll(".IntType");
break :blk;
} else if (self.isFlags(param.param_type.name)) {
try self.renderTypeInfo(param.param_type);
try self.writer.writeAll(".IntType");
break :blk;
}
}
try self.renderTypeInfo(param.param_type);
}
try self.writer.writeAll(", ");
}
try self.writer.writeAll(") callconv(vulkan_call_conv)");
try self.renderTypeInfo(command_ptr.return_type.*);
}
fn renderPointer(self: *Self, pointer: reg.Pointer) !void {
const child_is_void = pointer.child.* == .name and mem.eql(u8, pointer.child.name, "void");
if (pointer.is_optional) {
try self.writer.writeByte('?');
}
const size = if (child_is_void) .one else pointer.size;
switch (size) {
.one => try self.writer.writeByte('*'),
.many, .other_field => try self.writer.writeAll("[*]"),
.zero_terminated => try self.writer.writeAll("[*:0]"),
}
if (pointer.is_const) {
try self.writer.writeAll("const ");
}
if (child_is_void) {
try self.writer.writeAll("c_void");
} else {
try self.renderTypeInfo(pointer.child.*);
}
}
fn renderArray(self: *Self, array: reg.Array) !void {
try self.writer.writeByte('[');
switch (array.size) {
.int => |size| try self.writer.print("{}", .{size}),
.alias => |alias| try self.renderName(alias),
}
try self.writer.writeByte(']');
try self.renderTypeInfo(array.child.*);
}
fn renderDecl(self: *Self, decl: reg.Declaration) !void {
switch (decl.decl_type) {
.container => |container| try self.renderContainer(decl.name, container),
.enumeration => |enumeration| try self.renderEnumeration(decl.name, enumeration),
.bitmask => |bitmask| try self.renderBitmask(decl.name, bitmask),
.handle => |handle| try self.renderHandle(decl.name, handle),
.command => {},
.alias => |alias| try self.renderAlias(decl.name, alias),
.foreign => |foreign| try self.renderForeign(decl.name, foreign),
.typedef => |type_info| try self.renderTypedef(decl.name, type_info),
.opaque => try self.renderOpaque(decl.name),
}
}
fn renderContainer(self: *Self, name: []const u8, container: reg.Container) !void {
try self.writer.writeAll("pub const ");
try self.renderName(name);
try self.writer.writeAll(" = ");
for (container.fields) |field| {
if (field.bits != null) {
try self.writer.writeAll("packed ");
break;
}
} else {
try self.writer.writeAll("extern ");
}
if (container.is_union) {
try self.writer.writeAll("union {");
} else {
try self.writer.writeAll("struct {");
}
for (container.fields) |field| {
try self.writeIdentifierWithCase(.snake, field.name);
try self.writer.writeAll(": ");
if (field.bits) |bits| {
try self.writer.print(" u{},", .{bits});
if (field.field_type != .name or builtin_types.get(field.field_type.name) == null) {
try self.writer.writeAll("// ");
try self.renderTypeInfo(field.field_type);
try self.writer.writeByte('\n');
}
} else {
try self.renderTypeInfo(field.field_type);
try self.renderContainerDefaultField(name, field);
try self.writer.writeAll(", ");
}
}
try self.writer.writeAll("};\n");
}
fn renderContainerDefaultField(self: *Self, name: []const u8, field: reg.Container.Field) !void {
if (mem.eql(u8, field.name, "pNext")) {
try self.writer.writeAll(" = null");
} else if (mem.eql(u8, field.name, "sType")) {
try self.writer.writeAll(" = .");
try self.writeIdentifierWithCase(.snake, util.trimVkNamespace(name));
}
}
fn renderEnumFieldName(self: *Self, name: []const u8, field_name: []const u8) !void {
try self.writeIdentifierWithCase(.snake, try self.extractEnumFieldName(name, field_name));
}
fn renderEnumeration(self: *Self, name: []const u8, enumeration: reg.Enum) !void {
if (enumeration.is_bitmask) {
try self.renderBitmaskBits(name, enumeration);
return;
}
try self.writer.writeAll("pub const ");
try self.renderName(name);
try self.writer.writeAll(" = extern enum {");
for (enumeration.fields) |field| {
if (field.value == .alias) {
continue;
}
try self.renderEnumFieldName(name, field.name);
switch (field.value) {
.int => |int| try self.writer.print(" = {}, ", .{int}),
.bitpos => |pos| try self.writer.print(" = 1 << {}, ", .{pos}),
.bit_vector => |value| try self.writer.print(" = 0x{X}, ", .{value}),
.alias => unreachable,
}
}
for (enumeration.fields) |field| {
if (field.value != .alias or field.value.alias.is_compat_alias) {
continue;
}
try self.writer.writeAll("pub const ");
try self.renderEnumFieldName(name, field.name);
try self.writer.writeAll(" = .");
try self.renderEnumFieldName(name, field.value.alias.name);
try self.writer.writeAll(";");
}
try self.writer.writeAll("};\n");
}
fn renderBitmaskBits(self: *Self, name: []const u8, bits: reg.Enum) !void {
try self.writer.writeAll("pub const ");
try self.renderName(name);
try self.writer.writeAll(" = packed struct {");
if (bits.fields.len == 0) {
try self.writer.writeAll("_reserved_bits: Flags = 0,");
} else {
var flags_by_bitpos = [_]?[]const u8{null} ** 32;
for (bits.fields) |field| {
if (field.value == .bitpos) {
flags_by_bitpos[field.value.bitpos] = field.name;
}
}
for (flags_by_bitpos) |opt_flag_name, bitpos| {
if (opt_flag_name) |flag_name| {
try self.renderEnumFieldName(name, flag_name);
} else {
try self.writer.print("_reserved_bit_{}", .{bitpos});
}
try self.writer.writeAll(": bool ");
if (bitpos == 0) { // Force alignment to integer boundaries
try self.writer.writeAll("align(@alignOf(Flags)) ");
}
try self.writer.writeAll("= false, ");
}
}
try self.writer.writeAll("pub usingnamespace FlagsMixin(");
try self.renderName(name);
try self.writer.writeAll(");\n};\n");
}
fn renderBitmask(self: *Self, name: []const u8, bitmask: reg.Bitmask) !void {
if (bitmask.bits_enum == null) {
// The bits structure is generated by renderBitmaskBits, but that wont
// output flags with no associated bits type.
try self.writer.writeAll("pub const ");
try self.renderName(name);
try self.writer.writeAll(
\\ = packed struct {
\\_reserved_bits: Flags = 0,
\\pub usingnamespace FlagsMixin(
);
try self.renderName(name);
try self.writer.writeAll(
\\);
\\};
\\
);
}
}
fn renderHandle(self: *Self, name: []const u8, handle: reg.Handle) !void {
const backing_type: []const u8 = if (handle.is_dispatchable) "usize" else "u64";
try self.writer.writeAll("pub const ");
try self.renderName(name);
try self.writer.print(" = extern enum({}) {{null_handle = 0, _}};\n", .{backing_type});
}
fn renderAlias(self: *Self, name: []const u8, alias: reg.Alias) !void {
if (alias.target == .other_command) {
return;
} else if (self.extractBitflagName(name) != null) {
// Don't make aliases of the bitflag names, as those are replaced by just the flags type
return;
}
try self.writer.writeAll("pub const ");
try self.renderName(name);
try self.writer.writeAll(" = ");
try self.renderName(alias.name);
try self.writer.writeAll(";\n");
}
fn renderOpaque(self: *Self, name: []const u8) !void {
try self.writer.writeAll("pub const ");
try self.renderName(name);
try self.writer.writeAll(" = @Type(.Opaque);\n");
}
fn renderForeign(self: *Self, name: []const u8, foreign: reg.Foreign) !void {
if (mem.eql(u8, foreign.depends, "vk_platform")) {
return; // Skip built-in types, they are handled differently
}
try self.writer.writeAll("pub const ");
try self.writeIdentifier(name);
try self.writer.print(" = if (@hasDecl(root, \"{}\")) root.", .{name});
try self.writeIdentifier(name);
try self.writer.writeAll(" else ");
if (foreign_types.get(name)) |default| {
try self.writer.writeAll(default);
try self.writer.writeAll(";\n");
} else {
try self.writer.print("@compileError(\"Missing type definition of '{}'\");\n", .{name});
}
}
fn renderTypedef(self: *Self, name: []const u8, type_info: reg.TypeInfo) !void {
try self.writer.writeAll("pub const ");
try self.renderName(name);
try self.writer.writeAll(" = ");
try self.renderTypeInfo(type_info);
try self.writer.writeAll(";\n");
}
fn renderCommandPtrName(self: *Self, name: []const u8) !void {
try self.writeIdentifierFmt("Pfn{}", .{util.trimVkNamespace(name)});
}
fn renderCommandPtrs(self: *Self) !void {
for (self.registry.decls) |decl| {
if (decl.decl_type != .command) {
continue;
}
try self.writer.writeAll("pub const ");
try self.renderCommandPtrName(decl.name);
try self.writer.writeAll(" = ");
try self.renderCommandPtr(decl.decl_type.command, false);
try self.writer.writeAll(";\n");
}
}
fn renderExtensionInfo(self: *Self) !void {
try self.writer.writeAll(
\\pub const extension_info = struct {
\\ const Info = struct {
\\ name: [:0]const u8,
\\ version: u32,
\\ };
);
for (self.registry.extensions) |ext| {
try self.writer.writeAll("pub const ");
try self.writeIdentifierWithCase(.snake, util.trimVkNamespace(ext.name));
try self.writer.writeAll("= Info {\n");
try self.writer.print(".name = \"{}\", .version = {},", .{ext.name, ext.version});
try self.writer.writeAll("};\n");
}
try self.writer.writeAll("};\n");
}
fn renderWrappers(self: *Self) !void {
try self.renderWrappersOfDispatchType("BaseWrapper", .base);
try self.renderWrappersOfDispatchType("InstanceWrapper", .instance);
try self.renderWrappersOfDispatchType("DeviceWrapper", .device);
}
fn renderWrappersOfDispatchType(self: *Self, name: []const u8, dispatch_type: CommandDispatchType) !void {
try self.writer.print(
\\pub fn {}(comptime Self: type) type {{
\\ return struct {{
\\
, .{name}
);
try self.renderWrapperLoader(dispatch_type);
for (self.registry.decls) |decl| {
if (decl.decl_type == .command) {
const command = decl.decl_type.command;
if (self.classifyCommandDispatch(decl.name, command) == dispatch_type) {
try self.renderWrapper(decl.name, decl.decl_type.command);
}
}
}
try self.writer.writeAll("};}\n");
}
fn renderWrapperLoader(self: *Self, dispatch_type: CommandDispatchType) !void {
const params = switch (dispatch_type) {
.base => "loader: PfnGetInstanceProcAddr",
.instance => "instance: Instance, loader: PfnGetInstanceProcAddr",
.device => "device: Device, loader: PfnGetDeviceProcAddr",
};
const loader_first_param = switch (dispatch_type) {
.base => ".null_handle, ",
.instance => "instance, ",
.device => "device, ",
};
@setEvalBranchQuota(2000);
try self.writer.print(
\\pub fn load({}) !Self {{
\\ var self: Self = undefined;
\\ inline for (std.meta.fields(Self)) |field| {{
\\ const name = @ptrCast([*:0]const u8, field.name ++ "\x00");
\\ const cmd_ptr = loader({}name) orelse return error.InvalidCommand;
\\ @field(self, field.name) = @ptrCast(field.field_type, cmd_ptr);
\\ }}
\\ return self;
\\}}
\\
, .{params, loader_first_param}
);
}
fn derefName(name: []const u8) []const u8 {
var it = util.SegmentIterator.init(name);
return if (mem.eql(u8, it.next().?, "p"))
name[1..]
else
name;
}
fn renderWrapperPrototype(self: *Self, name: []const u8, command: reg.Command, returns: []const ReturnValue) !void {
try self.writer.writeAll("pub fn ");
try self.writeIdentifierWithCase(.camel, util.trimVkNamespace(name));
try self.writer.writeAll("(self: Self, ");
for (command.params) |param| {
switch (try self.classifyParam(param)) {
.in_pointer => {
// Remove one pointer level
try self.writeIdentifierWithCase(.snake, derefName(param.name));
try self.writer.writeAll(": ");
try self.renderTypeInfo(param.param_type.pointer.child.*);
},
.out_pointer => continue, // Return value
.bitflags, // Special stuff handled in renderWrapperCall
.buffer_len,
.mut_buffer_len,
.other => {
try self.writeIdentifierWithCase(.snake, param.name);
try self.writer.writeAll(": ");
try self.renderTypeInfo(param.param_type);
},
}
try self.writer.writeAll(", ");
}
try self.writer.writeAll(") ");
if (command.return_type.* == .name and mem.eql(u8, command.return_type.name, "VkResult")) {
try self.renderErrorSet(command.error_codes);
try self.writer.writeByte('!');
}
if (returns.len == 1) {
try self.renderTypeInfo(returns[0].return_value_type);
} else if (returns.len > 1) {
try self.renderReturnStructName(name);
} else {
try self.writer.writeAll("void");
}
}
fn renderWrapperCall(self: *Self, name: []const u8, command: reg.Command, returns: []const ReturnValue) !void {
try self.writer.writeAll("self.");
try self.writeIdentifier(name);
try self.writer.writeAll("(");
for (command.params) |param| {
switch (try self.classifyParam(param)) {
.in_pointer => {
try self.writer.writeByte('&');
try self.writeIdentifierWithCase(.snake, derefName(param.name));
},
.out_pointer => {
try self.writer.writeByte('&');
if (returns.len > 1) {
try self.writer.writeAll("return_values.");
}
try self.writeIdentifierWithCase(.snake, derefName(param.name));
},
.bitflags => {
try self.writeIdentifierWithCase(.snake, param.name);
try self.writer.writeAll(".toInt()");
},
.buffer_len, .mut_buffer_len, .other => {
try self.writeIdentifierWithCase(.snake, param.name);
},
}
try self.writer.writeAll(", ");
}
try self.writer.writeAll(")");
}
fn extractReturns(self: *Self, command: reg.Command) ![]const ReturnValue {
var returns = std.ArrayList(ReturnValue).init(self.allocator);
if (command.return_type.* == .name) {
const return_name = command.return_type.name;
if (!mem.eql(u8, return_name, "void") and !mem.eql(u8, return_name, "VkResult")) {
try returns.append(.{
.name = "return_value",
.return_value_type = command.return_type.*,
.origin = .inner_return_value,
});
}
}
if (command.success_codes.len > 1) {
if (command.return_type.* != .name or !mem.eql(u8, command.return_type.name, "VkResult")) {
return error.InvalidRegistry;
}
try returns.append(.{
.name = "result",
.return_value_type = command.return_type.*,
.origin = .inner_return_value,
});
} else if (command.success_codes.len == 1 and !mem.eql(u8, command.success_codes[0], "VK_SUCCESS")) {
return error.InvalidRegistry;
}
for (command.params) |param| {
if ((try self.classifyParam(param)) == .out_pointer) {
try returns.append(.{
.name = derefName(param.name),
.return_value_type = param.param_type.pointer.child.*,
.origin = .parameter,
});
}
}
return returns.toOwnedSlice();
}
fn renderReturnStructName(self: *Self, command_name: []const u8) !void {
try self.writeIdentifierFmt("{}Result", .{util.trimVkNamespace(command_name)});
}
fn renderReturnStruct(self: *Self, command_name: []const u8, returns: []const ReturnValue) !void {
try self.writer.writeAll("pub const ");
try self.renderReturnStructName(command_name);
try self.writer.writeAll(" = struct {\n");
for (returns) |ret| {
try self.writeIdentifierWithCase(.snake, ret.name);
try self.writer.writeAll(": ");
try self.renderTypeInfo(ret.return_value_type);
try self.writer.writeAll(", ");
}
try self.writer.writeAll("};\n");
}
fn renderWrapper(self: *Self, name: []const u8, command: reg.Command) !void {
const returns_vk_result = command.return_type.* == .name
and mem.eql(u8, command.return_type.name, "VkResult");
const returns_void = command.return_type.* == .name
and mem.eql(u8, command.return_type.name, "void");
const returns = try self.extractReturns(command);
if (returns.len > 1) {
try self.renderReturnStruct(name, returns);
}
try self.renderWrapperPrototype(name, command, returns);
if (returns.len == 1 and returns[0].origin == .inner_return_value) {
try self.writer.writeAll("{\n\n");
if (returns_vk_result) {
try self.writer.writeAll("const result = ");
try self.renderWrapperCall(name, command, returns);
try self.writer.writeAll(";\n");
try self.renderErrorSwitch("result", command);
try self.writer.writeAll("return result;\n");
} else {
try self.writer.writeAll("return ");
try self.renderWrapperCall(name, command, returns);
try self.writer.writeAll(";\n");
}
try self.writer.writeAll("\n}\n");
return;
}
try self.writer.writeAll("{\n");
if (returns.len == 1) {
try self.writer.writeAll("var ");
try self.writeIdentifierWithCase(.snake, returns[0].name);
try self.writer.writeAll(": ");
try self.renderTypeInfo(returns[0].return_value_type);
try self.writer.writeAll(" = undefined;\n");
} else if (returns.len > 1) {
try self.writer.writeAll("var return_values: ");
try self.renderReturnStructName(name);
try self.writer.writeAll(" = undefined;\n");
}
if (returns_vk_result) {
try self.writer.writeAll("const result = ");
try self.renderWrapperCall(name, command, returns);
try self.writer.writeAll(";\n");
try self.renderErrorSwitch("result", command);
if (command.success_codes.len > 1) {
try self.writer.writeAll("return_values.result = result;\n");
}
} else {
if (!returns_void) {
try self.writer.writeAll("return_values.return_value = ");
}
try self.renderWrapperCall(name, command, returns);
try self.writer.writeAll(";\n");
}
if (returns.len == 1) {
try self.writer.writeAll("return ");
try self.writeIdentifierWithCase(.snake, returns[0].name);
try self.writer.writeAll(";\n");
} else if (returns.len > 1) {
try self.writer.writeAll("return return_values;\n");
}
try self.writer.writeAll("}\n");
}
fn renderErrorSwitch(self: *Self, result_var: []const u8, command: reg.Command) !void {
try self.writer.writeAll("switch (");
try self.writeIdentifier(result_var);
try self.writer.writeAll(") {\n");
for (command.success_codes) |success| {
try self.writer.writeByte('.');
try self.renderEnumFieldName("VkResult", success);
try self.writer.writeAll(" => {},");
}
for (command.error_codes) |err| {
try self.writer.writeByte('.');
try self.renderEnumFieldName("VkResult", err);
try self.writer.writeAll(" => return error.");
try self.renderResultAsErrorName(err);
try self.writer.writeAll(", ");
}
try self.writer.writeAll("else => return error.Unknown,}\n");
}
fn renderErrorSet(self: *Self, errors: []const []const u8) !void {
try self.writer.writeAll("error{");
for (errors) |name| {
try self.renderResultAsErrorName(name);
try self.writer.writeAll(", ");
}
try self.writer.writeAll("Unknown, }");
}
fn renderResultAsErrorName(self: *Self, name: []const u8) !void {
const error_prefix = "VK_ERROR_";
if (mem.startsWith(u8, name, error_prefix)) {
try self.writeIdentifierWithCase(.title, name[error_prefix.len ..]);
} else {
// Apparently some commands (VkAcquireProfilingLockInfoKHR) return
// success codes as error...
try self.writeIdentifierWithCase(.title, util.trimVkNamespace(name));
}
}
};
}
pub fn render(writer: anytype, allocator: *Allocator, registry: *const reg.Registry) !void {
var renderer = Renderer(@TypeOf(writer)).init(writer, allocator, registry);
defer renderer.deinit();
try renderer.render();
} | generator/vulkan/render.zig |
pub const Keys = enum(c_int) {
unknown = 0,
a = 4,
b = 5,
c = 6,
d = 7,
e = 8,
f = 9,
g = 10,
h = 11,
i = 12,
j = 13,
k = 14,
l = 15,
m = 16,
n = 17,
o = 18,
p = 19,
q = 20,
r = 21,
s = 22,
t = 23,
u = 24,
v = 25,
w = 26,
x = 27,
y = 28,
z = 29,
num_1 = 30,
num_2 = 31,
num_3 = 32,
num_4 = 33,
num_5 = 34,
num_6 = 35,
num_7 = 36,
num_8 = 37,
num_9 = 38,
num_0 = 39,
key_return = 40,
escape = 41,
backspace = 42,
tab = 43,
space = 44,
minus = 45,
equals = 46,
leftbracket = 47,
rightbracket = 48,
backslash = 49,
nonushash = 50,
semicolon = 51,
apostrophe = 52,
grave = 53,
comma = 54,
period = 55,
slash = 56,
capslock = 57,
f1 = 58,
f2 = 59,
f3 = 60,
f4 = 61,
f5 = 62,
f6 = 63,
f7 = 64,
f8 = 65,
f9 = 66,
f10 = 67,
f11 = 68,
f12 = 69,
printscreen = 70,
scrolllock = 71,
pause = 72,
insert = 73,
home = 74,
pageup = 75,
delete = 76,
end = 77,
pagedown = 78,
right = 79,
left = 80,
down = 81,
up = 82,
numlockclear = 83,
kp_divide = 84,
kp_multiply = 85,
kp_minus = 86,
kp_plus = 87,
kp_enter = 88,
kp_1 = 89,
kp_2 = 90,
kp_3 = 91,
kp_4 = 92,
kp_5 = 93,
kp_6 = 94,
kp_7 = 95,
kp_8 = 96,
kp_9 = 97,
kp_0 = 98,
kp_period = 99,
nonusbackslash = 100,
application = 101,
power = 102,
kp_equals = 103,
f13 = 104,
f14 = 105,
f15 = 106,
f16 = 107,
f17 = 108,
f18 = 109,
f19 = 110,
f20 = 111,
f21 = 112,
f22 = 113,
f23 = 114,
f24 = 115,
execute = 116,
help = 117,
menu = 118,
select = 119,
stop = 120,
again = 121,
undo = 122,
cut = 123,
copy = 124,
paste = 125,
find = 126,
mute = 127,
volumeup = 128,
volumedown = 129,
kp_comma = 133,
kp_equalsas400 = 134,
international1 = 135,
international2 = 136,
international3 = 137,
international4 = 138,
international5 = 139,
international6 = 140,
international7 = 141,
international8 = 142,
international9 = 143,
lang1 = 144,
lang2 = 145,
lang3 = 146,
lang4 = 147,
lang5 = 148,
lang6 = 149,
lang7 = 150,
lang8 = 151,
lang9 = 152,
alterase = 153,
sysreq = 154,
cancel = 155,
clear = 156,
prior = 157,
return2 = 158,
separator = 159,
out = 160,
oper = 161,
clearagain = 162,
crsel = 163,
exsel = 164,
kp_00 = 176,
kp_000 = 177,
thousandsseparator = 178,
decimalseparator = 179,
currencyunit = 180,
currencysubunit = 181,
kp_leftparen = 182,
kp_rightparen = 183,
kp_leftbrace = 184,
kp_rightbrace = 185,
kp_tab = 186,
kp_backspace = 187,
kp_a = 188,
kp_b = 189,
kp_c = 190,
kp_d = 191,
kp_e = 192,
kp_f = 193,
kp_xor = 194,
kp_power = 195,
kp_percent = 196,
kp_less = 197,
kp_greater = 198,
kp_ampersand = 199,
kp_dblampersand = 200,
kp_verticalbar = 201,
kp_dblverticalbar = 202,
kp_colon = 203,
kp_hash = 204,
kp_space = 205,
kp_at = 206,
kp_exclam = 207,
kp_memstore = 208,
kp_memrecall = 209,
kp_memclear = 210,
kp_memadd = 211,
kp_memsubtract = 212,
kp_memmultiply = 213,
kp_memdivide = 214,
kp_plusminus = 215,
kp_clear = 216,
kp_clearentry = 217,
kp_binary = 218,
kp_octal = 219,
kp_decimal = 220,
kp_hexadecimal = 221,
lctrl = 224,
lshift = 225,
lalt = 226,
lgui = 227,
rctrl = 228,
rshift = 229,
ralt = 230,
rgui = 231,
mode = 257,
audionext = 258,
audioprev = 259,
audiostop = 260,
audioplay = 261,
audiomute = 262,
mediaselect = 263,
www = 264,
mail = 265,
calculator = 266,
computer = 267,
ac_search = 268,
ac_home = 269,
ac_back = 270,
ac_forward = 271,
ac_stop = 272,
ac_refresh = 273,
ac_bookmarks = 274,
brightnessdown = 275,
brightnessup = 276,
displayswitch = 277,
kbdillumtoggle = 278,
kbdillumdown = 279,
kbdillumup = 280,
eject = 281,
sleep = 282,
app1 = 283,
app2 = 284,
audiorewind = 285,
audiofastforward = 286,
num_keys = 287,
}; | gamekit/input_types.zig |
const std = @import("std");
const stdx = @import("stdx");
const ds = stdx.ds;
const platform = @import("platform");
const cgltf = @import("cgltf");
const stbi = @import("stbi");
const math = stdx.math;
const Vec2 = math.Vec2;
const vec2 = math.Vec2.init;
const Mat4 = math.Mat4;
const geom = math.geom;
const gl = @import("gl");
const vk = @import("vk");
const builtin = @import("builtin");
const lyon = @import("lyon");
const tess2 = @import("tess2");
const pt = lyon.initPt;
const t = stdx.testing;
const trace = stdx.debug.tracy.trace;
const build_options = @import("build_options");
const Backend = build_options.GraphicsBackend;
const graphics = @import("../../graphics.zig");
const QuadBez = graphics.curve.QuadBez;
const SubQuadBez = graphics.curve.SubQuadBez;
const CubicBez = graphics.curve.CubicBez;
const Color = graphics.Color;
const BlendMode = graphics.BlendMode;
const Transform = graphics.transform.Transform;
const VMetrics = graphics.font.VMetrics;
const TextMetrics = graphics.TextMetrics;
const Font = graphics.font.Font;
pub const font_cache = @import("font_cache.zig");
pub const FontCache = font_cache.FontCache;
const ImageId = graphics.ImageId;
const TextAlign = graphics.TextAlign;
const TextBaseline = graphics.TextBaseline;
const FontId = graphics.FontId;
const FontGroupId = graphics.FontGroupId;
const log = stdx.log.scoped(.graphics_gl);
const mesh = @import("mesh.zig");
const VertexData = mesh.VertexData;
pub const TexShaderVertex = mesh.TexShaderVertex;
const Batcher = @import("batcher.zig").Batcher;
const text_renderer = @import("text_renderer.zig");
pub const TextGlyphIterator = text_renderer.TextGlyphIterator;
const RenderTextIterator = text_renderer.RenderTextIterator;
const svg = graphics.svg;
const stroke = @import("stroke.zig");
const tessellator = @import("../../tessellator.zig");
const Tessellator = tessellator.Tessellator;
pub const RenderFont = @import("render_font.zig").RenderFont;
pub const Glyph = @import("glyph.zig").Glyph;
const gvk = graphics.vk;
const VkContext = gvk.VkContext;
const image = @import("image.zig");
pub const ImageStore = image.ImageStore;
pub const Image = image.Image;
pub const ImageTex = image.ImageTex;
const vera_ttf = @embedFile("../../../../assets/vera.ttf");
const IsWasm = builtin.target.isWasm();
/// Having 2 frames "in flight" to draw on allows the cpu and gpu to work in parallel. More than 2 is not recommended right now.
/// This doesn't have to match the number of swap chain images/framebuffers. This indicates the max number of frames that can be active at any moment.
/// Once this limit is reached, the cpu will block until the gpu is done with the oldest frame.
/// Currently used explicitly by the Vulkan implementation.
pub const MaxActiveFrames = 2;
/// Should be agnostic to viewport dimensions so it can be reused to draw on different viewports.
pub const Graphics = struct {
alloc: std.mem.Allocator,
white_tex: image.ImageTex,
inner: switch (Backend) {
.OpenGL => struct {
pipelines: graphics.gl.Pipelines,
},
.Vulkan => struct {
ctx: VkContext,
pipelines: gvk.Pipelines,
tex_desc_pool: vk.VkDescriptorPool,
tex_desc_set_layout: vk.VkDescriptorSetLayout,
cur_cmd_buf: vk.VkCommandBuffer,
},
else => @compileError("unsupported"),
},
batcher: Batcher,
font_cache: FontCache,
cur_proj_transform: Transform,
view_transform: Transform,
cur_buf_width: u32,
cur_buf_height: u32,
default_font_id: FontId,
default_font_gid: FontGroupId,
cur_font_gid: FontGroupId,
cur_font_size: f32,
cur_text_align: TextAlign,
cur_text_baseline: TextBaseline,
cur_fill_color: Color,
cur_stroke_color: Color,
cur_line_width: f32,
cur_line_width_half: f32,
clear_color: Color,
// Depth pixel ratio:
// This is used to fetch a higher res font bitmap for high dpi displays.
// eg. 18px user font size would normally use a 32px backed font bitmap but with dpr=2,
// it would use a 64px bitmap font instead.
cur_dpr: u8,
image_store: image.ImageStore,
// Draw state stack.
state_stack: std.ArrayList(DrawState),
cur_clip_rect: geom.Rect,
cur_scissors: bool,
cur_blend_mode: BlendMode,
vec2_helper_buf: std.ArrayList(Vec2),
vec2_slice_helper_buf: std.ArrayList([]const Vec2),
qbez_helper_buf: std.ArrayList(SubQuadBez),
tessellator: Tessellator,
/// Temporary buffer used to rasterize a glyph by a backend (eg. stbtt).
raster_glyph_buffer: std.ArrayList(u8),
const Self = @This();
pub fn initGL(self: *Self, alloc: std.mem.Allocator, dpr: u8) void {
self.initDefault(alloc, dpr);
self.initCommon(alloc);
const max_total_textures = gl.getMaxTotalTextures();
const max_fragment_textures = gl.getMaxFragmentTextures();
log.debug("max frag textures: {}, max total textures: {}", .{ max_fragment_textures, max_total_textures });
// Builtin shaders use the same vert buffer.
var vert_buf_id: gl.GLuint = undefined;
gl.genBuffers(1, &vert_buf_id);
// Initialize pipelines.
self.inner.pipelines.tex = graphics.gl.TexShader.init(vert_buf_id);
self.inner.pipelines.gradient = graphics.gl.GradientShader.init(vert_buf_id);
self.batcher = Batcher.initGL(alloc, vert_buf_id, self.inner.pipelines, &self.image_store);
// 2D graphics for now. Turn off 3d options.
gl.disable(gl.GL_DEPTH_TEST);
gl.disable(gl.GL_CULL_FACE);
// Enable blending by default.
gl.enable(gl.GL_BLEND);
}
pub fn initVK(self: *Self, alloc: std.mem.Allocator, dpr: u8, vk_ctx: VkContext) void {
self.initDefault(alloc, dpr);
self.inner.ctx = vk_ctx;
self.inner.tex_desc_set_layout = gvk.createTexDescriptorSetLayout(vk_ctx.device);
self.inner.tex_desc_pool = gvk.createTexDescriptorPool(vk_ctx.device);
self.initCommon(alloc);
var vert_buf: vk.VkBuffer = undefined;
var vert_buf_mem: vk.VkDeviceMemory = undefined;
gvk.buffer.createVertexBuffer(vk_ctx.physical, vk_ctx.device, 40 * 20000, &vert_buf, &vert_buf_mem);
var index_buf: vk.VkBuffer = undefined;
var index_buf_mem: vk.VkDeviceMemory = undefined;
gvk.buffer.createIndexBuffer(vk_ctx.physical, vk_ctx.device, 2 * 20000 * 3, &index_buf, &index_buf_mem);
self.inner.pipelines.tex_pipeline = gvk.createTexPipeline(vk_ctx.device, vk_ctx.pass, vk_ctx.framebuffer_size, self.inner.tex_desc_set_layout, true, false);
self.inner.pipelines.tex_pipeline_2d = gvk.createTexPipeline(vk_ctx.device, vk_ctx.pass, vk_ctx.framebuffer_size, self.inner.tex_desc_set_layout, false, false);
self.inner.pipelines.wireframe_pipeline = gvk.createTexPipeline(vk_ctx.device, vk_ctx.pass, vk_ctx.framebuffer_size, self.inner.tex_desc_set_layout, true, true);
self.inner.pipelines.gradient_pipeline_2d = gvk.createGradientPipeline(vk_ctx.device, vk_ctx.pass, vk_ctx.framebuffer_size);
self.inner.pipelines.plane_pipeline = gvk.createPlanePipeline(vk_ctx.device, vk_ctx.pass, vk_ctx.framebuffer_size);
self.batcher = Batcher.initVK(alloc, vert_buf, vert_buf_mem, index_buf, index_buf_mem, vk_ctx, self.inner.pipelines, &self.image_store);
}
fn initDefault(self: *Self, alloc: std.mem.Allocator, dpr: u8) void {
self.* = .{
.alloc = alloc,
.white_tex = undefined,
.inner = undefined,
.batcher = undefined,
.font_cache = undefined,
.default_font_id = undefined,
.default_font_gid = undefined,
.cur_buf_width = 0,
.cur_buf_height = 0,
.cur_font_gid = undefined,
.cur_font_size = undefined,
.cur_fill_color = Color.Black,
.cur_stroke_color = Color.Black,
.cur_blend_mode = ._undefined,
.cur_line_width = undefined,
.cur_line_width_half = undefined,
.cur_proj_transform = undefined,
.view_transform = undefined,
.image_store = image.ImageStore.init(alloc, self),
.state_stack = std.ArrayList(DrawState).init(alloc),
.cur_clip_rect = undefined,
.cur_scissors = undefined,
.cur_text_align = .Left,
.cur_text_baseline = .Top,
.cur_dpr = dpr,
.vec2_helper_buf = std.ArrayList(Vec2).init(alloc),
.vec2_slice_helper_buf = std.ArrayList([]const Vec2).init(alloc),
.qbez_helper_buf = std.ArrayList(SubQuadBez).init(alloc),
.tessellator = undefined,
.raster_glyph_buffer = std.ArrayList(u8).init(alloc),
.clear_color = undefined,
};
}
fn initCommon(self: *Self, alloc: std.mem.Allocator) void {
self.tessellator.init(alloc);
// Generate basic solid color texture.
var buf: [16]u32 = undefined;
std.mem.set(u32, &buf, 0xFFFFFFFF);
self.white_tex = self.image_store.createImageFromBitmap(4, 4, std.mem.sliceAsBytes(buf[0..]), false);
self.font_cache.init(alloc, self);
// TODO: Embed a default bitmap font.
// TODO: Embed a default ttf monospace font.
self.default_font_id = self.addFontTTF(vera_ttf);
self.default_font_gid = self.font_cache.getOrLoadFontGroup(&.{self.default_font_id});
self.setFont(self.default_font_id);
// Set default font size.
self.setFontSize(20);
// View transform can be changed by user transforms.
self.view_transform = Transform.initIdentity();
self.setLineWidth(1);
if (build_options.has_lyon) {
lyon.init();
}
// Clear color. Default to white.
self.setClearColor(Color.White);
// gl.clearColor(0.1, 0.2, 0.3, 1.0);
// gl.clearColor(0, 0, 0, 1.0);
}
pub fn deinit(self: *Self) void {
switch (Backend) {
.OpenGL => {
self.inner.pipelines.deinit();
},
.Vulkan => {
const device = self.inner.ctx.device;
self.inner.pipelines.deinit(device);
vk.destroyDescriptorSetLayout(device, self.inner.tex_desc_set_layout, null);
vk.destroyDescriptorPool(device, self.inner.tex_desc_pool, null);
},
else => {},
}
self.batcher.deinit();
self.font_cache.deinit();
self.state_stack.deinit();
if (build_options.has_lyon) {
lyon.deinit();
}
self.image_store.deinit();
self.vec2_helper_buf.deinit();
self.vec2_slice_helper_buf.deinit();
self.qbez_helper_buf.deinit();
self.tessellator.deinit();
self.raster_glyph_buffer.deinit();
}
pub fn addFontOTB(self: *Self, data: []const graphics.BitmapFontData) FontId {
return self.font_cache.addFontOTB(data);
}
pub fn addFontTTF(self: *Self, data: []const u8) FontId {
return self.font_cache.addFontTTF(data);
}
pub fn addFallbackFont(self: *Self, font_id: FontId) void {
self.font_cache.addSystemFont(font_id) catch unreachable;
}
pub fn clipRect(self: *Self, x: f32, y: f32, width: f32, height: f32) void {
// log.debug("clipRect {} {} {} {}", .{x, y, width, height});
switch (Backend) {
.OpenGL => {
self.cur_clip_rect = .{
.x = x,
// clip-y starts at bottom.
.y = @intToFloat(f32, self.cur_buf_height) - (y + height),
.width = width,
.height = height,
};
},
.Vulkan => {
self.cur_clip_rect = .{
.x = x,
.y = y,
.width = width,
.height = height,
};
},
else => {},
}
self.cur_scissors = true;
// Execute current draw calls before we alter state.
self.endCmd();
self.clipRectCmd(self.cur_clip_rect);
}
fn clipRectCmd(self: Self, rect: geom.Rect) void {
switch (Backend) {
.OpenGL => {
gl.scissor(@floatToInt(c_int, rect.x), @floatToInt(c_int, rect.y), @floatToInt(c_int, rect.width), @floatToInt(c_int, rect.height));
gl.enable(gl.GL_SCISSOR_TEST);
},
.Vulkan => {
const vk_rect = vk.VkRect2D{
.offset = .{
.x = @floatToInt(i32, rect.x),
.y = @floatToInt(i32, rect.y),
},
.extent = .{
.width = @floatToInt(u32, rect.width),
.height = @floatToInt(u32, rect.height),
},
};
vk.cmdSetScissor(self.inner.cur_cmd_buf, 0, 1, &vk_rect);
},
else => {},
}
}
pub fn resetTransform(self: *Self) void {
self.view_transform.reset();
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.beginMvp(mvp);
}
pub fn pushState(self: *Self) void {
self.state_stack.append(.{
.clip_rect = self.cur_clip_rect,
.use_scissors = self.cur_scissors,
.blend_mode = self.cur_blend_mode,
.view_transform = self.view_transform,
}) catch unreachable;
}
pub fn popState(self: *Self) void {
// log.debug("popState", .{});
// Execute current draw calls before altering state.
self.endCmd();
const state = self.state_stack.pop();
if (state.use_scissors) {
const r = state.clip_rect;
self.clipRect(r.x, r.y, r.width, r.height);
} else {
self.cur_scissors = false;
switch (Backend) {
.OpenGL => {
gl.disable(gl.GL_SCISSOR_TEST);
},
.Vulkan => {
const r = state.clip_rect;
self.clipRect(r.x, r.y, r.width, r.height);
},
else => {},
}
}
if (state.blend_mode != self.cur_blend_mode) {
self.setBlendMode(state.blend_mode);
}
if (!std.meta.eql(self.view_transform.mat, state.view_transform.mat)) {
self.view_transform = state.view_transform;
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.mvp = mvp;
}
}
pub fn getViewTransform(self: Self) Transform {
return self.view_transform;
}
pub fn getLineWidth(self: Self) f32 {
return self.cur_line_width;
}
pub fn setLineWidth(self: *Self, width: f32) void {
self.cur_line_width = width;
self.cur_line_width_half = width * 0.5;
}
pub fn setFont(self: *Self, font_id: FontId) void {
// Lookup font group single font.
const font_gid = self.font_cache.getOrLoadFontGroup(&.{font_id});
self.setFontGroup(font_gid);
}
pub fn setFontGroup(self: *Self, font_gid: FontGroupId) void {
if (font_gid != self.cur_font_gid) {
self.cur_font_gid = font_gid;
}
}
pub inline fn clear(self: Self) void {
_ = self;
gl.clear(gl.GL_COLOR_BUFFER_BIT);
}
pub fn setClearColor(self: *Self, color: Color) void {
self.clear_color = color;
if (Backend == .OpenGL) {
const f = color.toFloatArray();
gl.clearColor(f[0], f[1], f[2], f[3]);
}
}
pub fn getFillColor(self: Self) Color {
return self.cur_fill_color;
}
pub fn setFillColor(self: *Self, color: Color) void {
self.batcher.beginTex(self.white_tex);
self.cur_fill_color = color;
}
pub fn setFillGradient(self: *Self, start_x: f32, start_y: f32, start_color: Color, end_x: f32, end_y: f32, end_color: Color) void {
// Convert to screen coords on cpu.
const start_screen_pos = self.view_transform.interpolatePt(vec2(start_x, start_y));
const end_screen_pos = self.view_transform.interpolatePt(vec2(end_x, end_y));
self.batcher.beginGradient(start_screen_pos, start_color, end_screen_pos, end_color);
}
pub fn getStrokeColor(self: Self) Color {
return self.cur_stroke_color;
}
pub fn setStrokeColor(self: *Self, color: Color) void {
self.cur_stroke_color = color;
}
pub fn getFontSize(self: Self) f32 {
return self.cur_font_size;
}
pub fn getOrLoadFontGroupByFamily(self: *Self, family: graphics.FontFamily) FontGroupId {
switch (family) {
.Name => {
return self.font_cache.getOrLoadFontGroupByNameSeq(&.{family.Name}).?;
},
.FontGroup => return family.FontGroup,
.Font => return self.font_cache.getOrLoadFontGroup(&.{ family.Font }),
.Default => return self.default_font_gid,
}
}
pub fn setFontSize(self: *Self, size: f32) void {
if (self.cur_font_size != size) {
self.cur_font_size = size;
}
}
pub fn setTextAlign(self: *Self, align_: TextAlign) void {
self.cur_text_align = align_;
}
pub fn setTextBaseline(self: *Self, baseline: TextBaseline) void {
self.cur_text_baseline = baseline;
}
pub fn measureText(self: *Self, str: []const u8, res: *TextMetrics) void {
text_renderer.measureText(self, self.cur_font_gid, self.cur_font_size, self.cur_dpr, str, res, true);
}
pub fn measureFontText(self: *Self, group_id: FontGroupId, size: f32, str: []const u8, res: *TextMetrics) void {
text_renderer.measureText(self, group_id, size, self.cur_dpr, str, res, true);
}
pub inline fn textGlyphIter(self: *Self, font_gid: FontGroupId, size: f32, str: []const u8) graphics.TextGlyphIterator {
return text_renderer.textGlyphIter(self, font_gid, size, self.cur_dpr, str);
}
pub fn fillText(self: *Self, x: f32, y: f32, str: []const u8) void {
// log.info("draw text '{s}'", .{str});
var vert: TexShaderVertex = undefined;
var vdata: VertexData(4, 6) = undefined;
var start_x = x;
var start_y = y;
if (self.cur_text_align != .Left) {
var metrics: TextMetrics = undefined;
self.measureText(str, &metrics);
switch (self.cur_text_align) {
.Left => {},
.Right => start_x = x-metrics.width,
.Center => start_x = x-metrics.width/2,
}
}
if (self.cur_text_baseline != .Top) {
const vmetrics = self.font_cache.getPrimaryFontVMetrics(self.cur_font_gid, self.cur_font_size);
switch (self.cur_text_baseline) {
.Top => {},
.Middle => start_y = y - vmetrics.height / 2,
.Alphabetic => start_y = y - vmetrics.ascender,
.Bottom => start_y = y - vmetrics.height,
}
}
var iter = text_renderer.RenderTextIterator.init(self, self.cur_font_gid, self.cur_font_size, self.cur_dpr, start_x, start_y, str);
while (iter.nextCodepointQuad(true)) {
self.setCurrentTexture(iter.quad.image);
if (iter.quad.is_color_bitmap) {
vert.setColor(Color.White);
} else {
vert.setColor(self.cur_fill_color);
}
// top left
vert.setXY(iter.quad.x0, iter.quad.y0);
vert.setUV(iter.quad.u0, iter.quad.v0);
vdata.verts[0] = vert;
// top right
vert.setXY(iter.quad.x1, iter.quad.y0);
vert.setUV(iter.quad.u1, iter.quad.v0);
vdata.verts[1] = vert;
// bottom right
vert.setXY(iter.quad.x1, iter.quad.y1);
vert.setUV(iter.quad.u1, iter.quad.v1);
vdata.verts[2] = vert;
// bottom left
vert.setXY(iter.quad.x0, iter.quad.y1);
vert.setUV(iter.quad.u0, iter.quad.v1);
vdata.verts[3] = vert;
// indexes
vdata.setRect(0, 0, 1, 2, 3);
self.pushVertexData(4, 6, &vdata);
}
}
pub inline fn setCurrentTexture(self: *Self, image_tex: image.ImageTex) void {
self.batcher.beginTexture(image_tex);
}
fn ensureUnusedBatchCapacity(self: *Self, vert_inc: usize, index_inc: usize) void {
if (!self.batcher.ensureUnusedBuffer(vert_inc, index_inc)) {
self.endCmd();
}
}
fn pushLyonVertexData(self: *Self, data: *lyon.VertexData, color: Color) void {
self.ensureUnusedBatchCapacity(data.vertex_len, data.index_len);
self.batcher.pushLyonVertexData(data, color);
}
fn pushVertexData(self: *Self, comptime num_verts: usize, comptime num_indices: usize, data: *VertexData(num_verts, num_indices)) void {
self.ensureUnusedBatchCapacity(num_verts, num_indices);
self.batcher.pushVertexData(num_verts, num_indices, data);
}
pub fn drawRectVec(self: *Self, pos: Vec2, width: f32, height: f32) void {
self.drawRect(pos.x, pos.y, width, height);
}
pub fn drawRect(self: *Self, x: f32, y: f32, width: f32, height: f32) void {
self.batcher.beginTex(self.white_tex);
// Top border.
self.fillRectColor(x - self.cur_line_width_half, y - self.cur_line_width_half, width + self.cur_line_width, self.cur_line_width, self.cur_stroke_color);
// Right border.
self.fillRectColor(x + width - self.cur_line_width_half, y + self.cur_line_width_half, self.cur_line_width, height - self.cur_line_width, self.cur_stroke_color);
// Bottom border.
self.fillRectColor(x - self.cur_line_width_half, y + height - self.cur_line_width_half, width + self.cur_line_width, self.cur_line_width, self.cur_stroke_color);
// Left border.
self.fillRectColor(x - self.cur_line_width_half, y + self.cur_line_width_half, self.cur_line_width, height - self.cur_line_width, self.cur_stroke_color);
}
// Uses path rendering.
pub fn strokeRectLyon(self: *Self, x: f32, y: f32, width: f32, height: f32) void {
self.batcher.beginTex(self.white_tex);
// log.debug("strokeRect {d:.2} {d:.2} {d:.2} {d:.2}", .{pos.x, pos.y, width, height});
const b = lyon.initBuilder();
lyon.addRectangle(b, &.{ .x = x, .y = y, .width = width, .height = height });
var data = lyon.buildStroke(b, self.cur_line_width);
self.setCurrentTexture(self.white_tex);
self.pushLyonVertexData(&data, self.cur_stroke_color);
}
pub fn fillRoundRect(self: *Self, x: f32, y: f32, width: f32, height: f32, radius: f32) void {
// Top left corner.
self.fillCircleSectorN(x + radius, y + radius, radius, math.pi, math.pi_half, 90);
// Left side.
self.fillRect(x, y + radius, radius, height - radius * 2);
// Bottom left corner.
self.fillCircleSectorN(x + radius, y + height - radius, radius, math.pi_half, math.pi_half, 90);
// Middle.
self.fillRect(x + radius, y, width - radius * 2, height);
// Top right corner.
self.fillCircleSectorN(x + width - radius, y + radius, radius, -math.pi_half, math.pi_half, 90);
// Right side.
self.fillRect(x + width - radius, y + radius, radius, height - radius * 2);
// Bottom right corner.
self.fillCircleSectorN(x + width - radius, y + height - radius, radius, 0, math.pi_half, 90);
}
pub fn drawRoundRect(self: *Self, x: f32, y: f32, width: f32, height: f32, radius: f32) void {
self.batcher.beginTex(self.white_tex);
// Top left corner.
self.drawCircleArcN(x + radius, y + radius, radius, math.pi, math.pi_half, 90);
// Left side.
self.fillRectColor(x - self.cur_line_width_half, y + radius, self.cur_line_width, height - radius * 2, self.cur_stroke_color);
// Bottom left corner.
self.drawCircleArcN(x + radius, y + height - radius, radius, math.pi_half, math.pi_half, 90);
// Top.
self.fillRectColor(x + radius, y - self.cur_line_width_half, width - radius * 2, self.cur_line_width, self.cur_stroke_color);
// Bottom.
self.fillRectColor(x + radius, y + height - self.cur_line_width_half, width - radius * 2, self.cur_line_width, self.cur_stroke_color);
// Top right corner.
self.drawCircleArcN(x + width - radius, y + radius, radius, -math.pi_half, math.pi_half, 90);
// Right side.
self.fillRectColor(x + width - self.cur_line_width_half, y + radius, self.cur_line_width, height - radius * 2, self.cur_stroke_color);
// Bottom right corner.
self.drawCircleArcN(x + width - radius, y + height - radius, radius, 0, math.pi_half, 90);
}
pub fn drawPlane(self: *Self) void {
self.batcher.endCmd();
self.batcher.cur_shader_type = .Plane;
self.batcher.mesh.addIndex(0);
self.batcher.mesh.addIndex(1);
self.batcher.mesh.addIndex(2);
self.batcher.mesh.addIndex(3);
self.batcher.mesh.addIndex(4);
self.batcher.mesh.addIndex(5);
self.batcher.endCmdForce();
}
pub fn fillRect(self: *Self, x: f32, y: f32, width: f32, height: f32) void {
self.fillRectColor(x, y, width, height, self.cur_fill_color);
}
// Sometimes we want to override the color (eg. rendering part of a stroke.)
fn fillRectColor(self: *Self, x: f32, y: f32, width: f32, height: f32, color: Color) void {
self.setCurrentTexture(self.white_tex);
self.ensureUnusedBatchCapacity(4, 6);
var vert: TexShaderVertex = undefined;
vert.setColor(color);
const start_idx = self.batcher.mesh.getNextIndexId();
// top left
vert.setXY(x, y);
vert.setUV(0, 0);
self.batcher.mesh.addVertex(&vert);
// top right
vert.setXY(x + width, y);
vert.setUV(1, 0);
self.batcher.mesh.addVertex(&vert);
// bottom right
vert.setXY(x + width, y + height);
vert.setUV(1, 1);
self.batcher.mesh.addVertex(&vert);
// bottom left
vert.setXY(x, y + height);
vert.setUV(0, 1);
self.batcher.mesh.addVertex(&vert);
// add rect
self.batcher.mesh.addQuad(start_idx, start_idx + 1, start_idx + 2, start_idx + 3);
}
pub fn drawCircleArc(self: *Self, x: f32, y: f32, radius: f32, start_rad: f32, sweep_rad: f32) void {
self.batcher.beginTex(self.white_tex);
if (builtin.mode == .Debug) {
stdx.debug.assertInRange(start_rad, -math.pi_2, math.pi_2);
stdx.debug.assertInRange(sweep_rad, -math.pi_2, math.pi_2);
}
// Approx 1 arc sector per degree.
var n = @floatToInt(u32, @ceil(@fabs(sweep_rad) / math.pi_2 * 360));
self.drawCircleArcN(x, y, radius, start_rad, sweep_rad, n);
}
// n is the number of sections in the arc we will draw.
pub fn drawCircleArcN(self: *Self, x: f32, y: f32, radius: f32, start_rad: f32, sweep_rad: f32, n: u32) void {
self.batcher.beginTex(self.white_tex);
self.ensureUnusedBatchCapacity(2 + n * 2, n * 3 * 2);
const inner_rad = radius - self.cur_line_width_half;
const outer_rad = radius + self.cur_line_width_half;
var vert: TexShaderVertex = undefined;
vert.setColor(self.cur_stroke_color);
vert.setUV(0, 0); // Currently we don't do uv mapping for strokes.
// Add first two vertices.
var cos = @cos(start_rad);
var sin = @sin(start_rad);
vert.setXY(x + cos * inner_rad, y + sin * inner_rad);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x + cos * outer_rad, y + sin * outer_rad);
self.batcher.mesh.addVertex(&vert);
const rad_per_n = sweep_rad / @intToFloat(f32, n);
var cur_vert_idx = self.batcher.mesh.getNextIndexId();
var i: u32 = 1;
while (i <= n) : (i += 1) {
const rad = start_rad + rad_per_n * @intToFloat(f32, i);
// Add inner/outer vertex.
cos = @cos(rad);
sin = @sin(rad);
vert.setXY(x + cos * inner_rad, y + sin * inner_rad);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x + cos * outer_rad, y + sin * outer_rad);
self.batcher.mesh.addVertex(&vert);
// Add arc sector.
self.batcher.mesh.addQuad(cur_vert_idx - 1, cur_vert_idx + 1, cur_vert_idx, cur_vert_idx - 2);
cur_vert_idx += 2;
}
}
pub fn fillCircleSectorN(self: *Self, x: f32, y: f32, radius: f32, start_rad: f32, sweep_rad: f32, num_tri: u32) void {
self.setCurrentTexture(self.white_tex);
self.ensureUnusedBatchCapacity(num_tri + 2, num_tri * 3);
var vert: TexShaderVertex = undefined;
vert.setColor(self.cur_fill_color);
// Add center.
const center = self.batcher.mesh.getNextIndexId();
vert.setUV(0.5, 0.5);
vert.setXY(x, y);
self.batcher.mesh.addVertex(&vert);
// Add first circle vertex.
var cos = @cos(start_rad);
var sin = @sin(start_rad);
vert.setUV(0.5 + cos, 0.5 + sin);
vert.setXY(x + cos * radius, y + sin * radius);
self.batcher.mesh.addVertex(&vert);
const rad_per_tri = sweep_rad / @intToFloat(f32, num_tri);
var last_vert_idx = center + 1;
var i: u32 = 1;
while (i <= num_tri) : (i += 1) {
const rad = start_rad + rad_per_tri * @intToFloat(f32, i);
// Add next circle vertex.
cos = @cos(rad);
sin = @sin(rad);
vert.setUV(0.5 + cos, 0.5 + sin);
vert.setXY(x + cos * radius, y + sin * radius);
self.batcher.mesh.addVertex(&vert);
// Add triangle.
const next_idx = last_vert_idx + 1;
self.batcher.mesh.addTriangle(center, last_vert_idx, next_idx);
last_vert_idx = next_idx;
}
}
pub fn fillCircleSector(self: *Self, x: f32, y: f32, radius: f32, start_rad: f32, sweep_rad: f32) void {
if (builtin.mode == .Debug) {
stdx.debug.assertInRange(start_rad, -math.pi_2, math.pi_2);
stdx.debug.assertInRange(sweep_rad, -math.pi_2, math.pi_2);
}
// Approx 1 triangle per degree.
var num_tri = @floatToInt(u32, @ceil(@fabs(sweep_rad) / math.pi_2 * 360));
self.fillCircleSectorN(x, y, radius, start_rad, sweep_rad, num_tri);
}
// Same implementation as fillEllipse when h_radius = v_radius.
pub fn fillCircle(self: *Self, x: f32, y: f32, radius: f32) void {
self.fillCircleSectorN(x, y, radius, 0, math.pi_2, 360);
}
// Same implementation as drawEllipse when h_radius = v_radius. Might be slightly faster since we use fewer vars.
pub fn drawCircle(self: *Self, x: f32, y: f32, radius: f32) void {
self.drawCircleArcN(x, y, radius, 0, math.pi_2, 360);
}
pub fn fillEllipseSectorN(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32, start_rad: f32, sweep_rad: f32, n: u32) void {
self.setCurrentTexture(self.white_tex);
self.ensureUnusedBatchCapacity(n + 2, n * 3);
var vert: TexShaderVertex = undefined;
vert.setColor(self.cur_fill_color);
// Add center.
const center = self.batcher.mesh.getNextIndexId();
vert.setUV(0.5, 0.5);
vert.setXY(x, y);
self.batcher.mesh.addVertex(&vert);
// Add first circle vertex.
var cos = @cos(start_rad);
var sin = @sin(start_rad);
vert.setUV(0.5 + cos, 0.5 + sin);
vert.setXY(x + cos * h_radius, y + sin * v_radius);
self.batcher.mesh.addVertex(&vert);
const rad_per_tri = sweep_rad / @intToFloat(f32, n);
var last_vert_idx = center + 1;
var i: u32 = 1;
while (i <= n) : (i += 1) {
const rad = start_rad + rad_per_tri * @intToFloat(f32, i);
// Add next circle vertex.
cos = @cos(rad);
sin = @sin(rad);
vert.setUV(0.5 + cos, 0.5 + sin);
vert.setXY(x + cos * h_radius, y + sin * v_radius);
self.batcher.mesh.addVertex(&vert);
// Add triangle.
const next_idx = last_vert_idx + 1;
self.batcher.mesh.addTriangle(center, last_vert_idx, next_idx);
last_vert_idx = next_idx;
}
}
pub fn fillEllipseSector(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32, start_rad: f32, sweep_rad: f32) void {
if (builtin.mode == .Debug) {
stdx.debug.assertInRange(start_rad, -math.pi_2, math.pi_2);
stdx.debug.assertInRange(sweep_rad, -math.pi_2, math.pi_2);
}
// Approx 1 arc section per degree.
var n = @floatToInt(u32, @ceil(@fabs(sweep_rad) / math.pi_2 * 360));
self.fillEllipseSectorN(x, y, h_radius, v_radius, start_rad, sweep_rad, n);
}
pub fn fillEllipse(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32) void {
self.fillEllipseSectorN(x, y, h_radius, v_radius, 0, math.pi_2, 360);
}
pub fn drawEllipseArc(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32, start_rad: f32, sweep_rad: f32) void {
if (builtin.mode == .Debug) {
stdx.debug.assertInRange(start_rad, -math.pi_2, math.pi_2);
stdx.debug.assertInRange(sweep_rad, -math.pi_2, math.pi_2);
}
// Approx 1 arc sector per degree.
var n = @floatToInt(u32, @ceil(@fabs(sweep_rad) / math.pi_2 * 360));
self.drawEllipseArcN(x, y, h_radius, v_radius, start_rad, sweep_rad, n);
}
// n is the number of sections in the arc we will draw.
pub fn drawEllipseArcN(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32, start_rad: f32, sweep_rad: f32, n: u32) void {
self.batcher.beginTex(self.white_tex);
self.ensureUnusedBatchCapacity(2 + n * 2, n * 3 * 2);
const inner_h_rad = h_radius - self.cur_line_width_half;
const inner_v_rad = v_radius - self.cur_line_width_half;
const outer_h_rad = h_radius + self.cur_line_width_half;
const outer_v_rad = v_radius + self.cur_line_width_half;
var vert: TexShaderVertex = undefined;
vert.setColor(self.cur_stroke_color);
vert.setUV(0, 0); // Currently we don't do uv mapping for strokes.
// Add first two vertices.
var cos = @cos(start_rad);
var sin = @sin(start_rad);
vert.setXY(x + cos * inner_h_rad, y + sin * inner_v_rad);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x + cos * outer_h_rad, y + sin * outer_v_rad);
self.batcher.mesh.addVertex(&vert);
const rad_per_n = sweep_rad / @intToFloat(f32, n);
var cur_vert_idx = self.batcher.mesh.getNextIndexId();
var i: u32 = 1;
while (i <= n) : (i += 1) {
const rad = start_rad + rad_per_n * @intToFloat(f32, i);
// Add inner/outer vertex.
cos = @cos(rad);
sin = @sin(rad);
vert.setXY(x + cos * inner_h_rad, y + sin * inner_v_rad);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x + cos * outer_h_rad, y + sin * outer_v_rad);
self.batcher.mesh.addVertex(&vert);
// Add arc sector.
self.batcher.mesh.addQuad(cur_vert_idx + 1, cur_vert_idx - 1, cur_vert_idx - 2, cur_vert_idx);
cur_vert_idx += 2;
}
}
pub fn drawEllipse(self: *Self, x: f32, y: f32, h_radius: f32, v_radius: f32) void {
self.drawEllipseArcN(x, y, h_radius, v_radius, 0, math.pi_2, 360);
}
pub fn drawPoint(self: *Self, x: f32, y: f32) void {
self.batcher.beginTex(self.white_tex);
self.fillRectColor(x - self.cur_line_width_half, y - self.cur_line_width_half, self.cur_line_width, self.cur_line_width, self.cur_stroke_color);
}
pub fn drawLine(self: *Self, x1: f32, y1: f32, x2: f32, y2: f32) void {
self.batcher.beginTex(self.white_tex);
if (x1 == x2) {
self.fillRectColor(x1 - self.cur_line_width_half, y1, self.cur_line_width, y2 - y1, self.cur_stroke_color);
} else {
const normal = vec2(y2 - y1, x2 - x1).toLength(self.cur_line_width_half);
self.fillQuad(
x1 - normal.x, y1 + normal.y,
x1 + normal.x, y1 - normal.y,
x2 + normal.x, y2 - normal.y,
x2 - normal.x, y2 + normal.y,
self.cur_stroke_color,
);
}
}
pub fn drawQuadraticBezierCurve(self: *Self, x0: f32, y0: f32, cx: f32, cy: f32, x1: f32, y1: f32) void {
self.batcher.beginTex(self.white_tex);
const q_bez = QuadBez{
.x0 = x0,
.y0 = y0,
.cx = cx,
.cy = cy,
.x1 = x1,
.y1 = y1,
};
self.vec2_helper_buf.clearRetainingCapacity();
stroke.strokeQuadBez(&self.batcher.mesh, &self.vec2_helper_buf, q_bez, self.cur_line_width_half, self.cur_stroke_color);
}
pub fn drawQuadraticBezierCurveLyon(self: *Self, x0: f32, y0: f32, cx: f32, cy: f32, x1: f32, y1: f32) void {
self.batcher.beginTex(self.white_tex);
const b = lyon.initBuilder();
lyon.begin(b, &pt(x0, y0));
lyon.quadraticBezierTo(b, &pt(cx, cy), &pt(x1, y1));
lyon.end(b, false);
var data = lyon.buildStroke(b, self.cur_line_width);
self.setCurrentTexture(self.white_tex);
self.pushLyonVertexData(&data, self.cur_stroke_color);
}
pub fn drawCubicBezierCurve(self: *Self, x0: f32, y0: f32, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x1: f32, y1: f32) void {
self.batcher.beginTex(self.white_tex);
const c_bez = CubicBez{
.x0 = x0,
.y0 = y0,
.cx0 = cx0,
.cy0 = cy0,
.cx1 = cx1,
.cy1 = cy1,
.x1 = x1,
.y1 = y1,
};
self.qbez_helper_buf.clearRetainingCapacity();
self.vec2_helper_buf.clearRetainingCapacity();
stroke.strokeCubicBez(&self.batcher.mesh, &self.vec2_helper_buf, &self.qbez_helper_buf, c_bez, self.cur_line_width_half, self.cur_stroke_color);
}
pub fn drawCubicBezierCurveLyon(self: *Self, x0: f32, y0: f32, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x1: f32, y1: f32) void {
self.batcher.beginTex(self.white_tex);
const b = lyon.initBuilder();
lyon.begin(b, &pt(x0, y0));
lyon.cubicBezierTo(b, &pt(cx0, cy0), &pt(cx1, cy1), &pt(x1, y1));
lyon.end(b, false);
var data = lyon.buildStroke(b, self.cur_line_width);
self.setCurrentTexture(self.white_tex);
self.pushLyonVertexData(&data, self.cur_stroke_color);
}
// Points are given in ccw order. Currently doesn't map uvs.
pub fn fillQuad(self: *Self, x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32, x4: f32, y4: f32, color: Color) void {
self.setCurrentTexture(self.white_tex);
self.ensureUnusedBatchCapacity(4, 6);
var vert: TexShaderVertex = undefined;
vert.setColor(color);
vert.setUV(0, 0); // Don't map uvs for now.
const start_idx = self.batcher.mesh.getNextIndexId();
vert.setXY(x1, y1);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x2, y2);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x3, y3);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x4, y4);
self.batcher.mesh.addVertex(&vert);
self.batcher.mesh.addQuad(start_idx, start_idx + 1, start_idx + 2, start_idx + 3);
}
pub fn fillSvgPath(self: *Self, x: f32, y: f32, path: *const svg.SvgPath) void {
const t_ = trace(@src());
defer t_.end();
self.drawSvgPath(x, y, path, true);
}
pub fn fillSvgPathLyon(self: *Self, x: f32, y: f32, path: *const svg.SvgPath) void {
const t_ = trace(@src());
defer t_.end();
self.drawSvgPathLyon(x, y, path, true);
}
pub fn fillSvgPathTess2(self: *Self, x: f32, y: f32, path: *const svg.SvgPath) void {
const t_ = trace(@src());
defer t_.end();
_ = x;
_ = y;
// Accumulate polygons.
self.vec2_helper_buf.clearRetainingCapacity();
self.vec2_slice_helper_buf.clearRetainingCapacity();
self.qbez_helper_buf.clearRetainingCapacity();
var last_cmd_was_curveto = false;
var last_control_pt = vec2(0, 0);
var cur_data_idx: u32 = 0;
var cur_pt = vec2(0, 0);
var cur_poly_start: u32 = 0;
for (path.cmds) |cmd| {
var cmd_is_curveto = false;
switch (cmd) {
.MoveTo => {
if (self.vec2_helper_buf.items.len > cur_poly_start + 1) {
self.vec2_slice_helper_buf.append(self.vec2_helper_buf.items[cur_poly_start..]) catch unreachable;
} else if (self.vec2_helper_buf.items.len == cur_poly_start + 1) {
// Only one unused point. Remove it.
_ = self.vec2_helper_buf.pop();
}
const data = path.getData(.MoveTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.MoveTo)) / 4;
cur_pt = .{
.x = data.x,
.y = data.y,
};
cur_poly_start = @intCast(u32, self.vec2_helper_buf.items.len);
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.MoveToRel => {
if (self.vec2_helper_buf.items.len > cur_poly_start + 1) {
self.vec2_slice_helper_buf.append(self.vec2_helper_buf.items[cur_poly_start..]) catch unreachable;
} else if (self.vec2_helper_buf.items.len == cur_poly_start + 1) {
// Only one unused point. Remove it.
_ = self.vec2_helper_buf.pop();
}
const data = path.getData(.MoveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.MoveToRel)) / 4;
cur_pt = .{
.x = cur_pt.x + data.x,
.y = cur_pt.y + data.y,
};
cur_poly_start = @intCast(u32, self.vec2_helper_buf.items.len);
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.CurveToRel => {
const data = path.getData(.CurveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.CurveToRel)) / 4;
last_control_pt = .{
.x = cur_pt.x + data.cb_x,
.y = cur_pt.y + data.cb_y,
};
const prev_pt = cur_pt;
cur_pt = .{
.x = cur_pt.x + data.x,
.y = cur_pt.y + data.y,
};
const c_bez = CubicBez{
.x0 = prev_pt.x,
.y0 = prev_pt.y,
.cx0 = prev_pt.x + data.ca_x,
.cy0 = prev_pt.y + data.ca_y,
.cx1 = last_control_pt.x,
.cy1 = last_control_pt.y,
.x1 = cur_pt.x,
.y1 = cur_pt.y,
};
c_bez.flatten(0.5, &self.vec2_helper_buf, &self.qbez_helper_buf);
cmd_is_curveto = true;
},
.LineTo => {
const data = path.getData(.LineTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.LineTo)) / 4;
cur_pt = .{
.x = data.x,
.y = data.y,
};
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.LineToRel => {
const data = path.getData(.LineToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.LineToRel)) / 4;
cur_pt = .{
.x = cur_pt.x + data.x,
.y = cur_pt.y + data.y,
};
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.SmoothCurveToRel => {
const data = path.getData(.SmoothCurveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.SmoothCurveToRel)) / 4;
var cx0: f32 = undefined;
var cy0: f32 = undefined;
if (last_cmd_was_curveto) {
// Reflection of last control point over current pos.
cx0 = cur_pt.x + (cur_pt.x - last_control_pt.x);
cy0 = cur_pt.y + (cur_pt.y - last_control_pt.y);
} else {
cx0 = cur_pt.x;
cy0 = cur_pt.y;
}
last_control_pt = .{
.x = cur_pt.x + data.c2_x,
.y = cur_pt.y + data.c2_y,
};
const prev_pt = cur_pt;
cur_pt = .{
.x = cur_pt.x + data.x,
.y = cur_pt.y + data.y,
};
const c_bez = CubicBez{
.x0 = prev_pt.x,
.y0 = prev_pt.y,
.cx0 = cx0,
.cy0 = cy0,
.cx1 = last_control_pt.x,
.cy1 = last_control_pt.y,
.x1 = cur_pt.x,
.y1 = cur_pt.y,
};
c_bez.flatten(0.5, &self.vec2_helper_buf, &self.qbez_helper_buf);
cmd_is_curveto = true;
},
.VertLineToRel => {
const data = path.getData(.VertLineToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.VertLineToRel)) / 4;
cur_pt.y += data.y;
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.ClosePath => {
// if (fill) {
// // For fills, this is a no-op.
// } else {
// // For strokes, this would form a seamless connection to the first point.
// }
},
else => {
stdx.panicFmt("unsupported: {}", .{cmd});
},
}
last_cmd_was_curveto = cmd_is_curveto;
}
if (self.vec2_helper_buf.items.len > cur_poly_start + 1) {
// Push the current polygon.
self.vec2_slice_helper_buf.append(self.vec2_helper_buf.items[cur_poly_start..]) catch unreachable;
}
if (self.vec2_slice_helper_buf.items.len == 0) {
return;
}
for (self.vec2_slice_helper_buf.items) |polygon| {
var tess = getTess2Handle();
tess2.tessAddContour(tess, 2, &polygon[0], 8, @intCast(c_int, polygon.len));
const res = tess2.tessTesselate(tess, tess2.TESS_WINDING_ODD, tess2.TESS_POLYGONS, 3, 2, null);
if (res == 0) {
unreachable;
}
var gpu_vert: TexShaderVertex = undefined;
gpu_vert.setColor(self.cur_fill_color);
const vert_offset_id = self.batcher.mesh.getNextIndexId();
var nverts = tess2.tessGetVertexCount(tess);
var verts = tess2.tessGetVertices(tess);
const nelems = tess2.tessGetElementCount(tess);
// log.debug("poly: {}, {}, {}", .{polygon.len, nverts, nelems});
self.setCurrentTexture(self.white_tex);
self.ensureUnusedBatchCapacity(@intCast(u32, nverts), @intCast(usize, nelems * 3));
var i: u32 = 0;
while (i < nverts) : (i += 1) {
gpu_vert.setXY(verts[i*2], verts[i*2+1]);
// log.debug("{},{}", .{gpu_vert.pos_x, gpu_vert.pos_y});
gpu_vert.setUV(0, 0);
_ = self.batcher.mesh.addVertex(&gpu_vert);
}
const elems = tess2.tessGetElements(tess);
i = 0;
while (i < nelems) : (i += 1) {
self.batcher.mesh.addIndex(@intCast(u16, vert_offset_id + elems[i*3+2]));
self.batcher.mesh.addIndex(@intCast(u16, vert_offset_id + elems[i*3+1]));
self.batcher.mesh.addIndex(@intCast(u16, vert_offset_id + elems[i*3]));
// log.debug("idx {}", .{elems[i]});
}
}
}
pub fn strokeSvgPath(self: *Self, x: f32, y: f32, path: *const svg.SvgPath) void {
self.drawSvgPath(x, y, path, false);
}
fn drawSvgPath(self: *Self, x: f32, y: f32, path: *const svg.SvgPath, fill: bool) void {
// log.debug("drawSvgPath {} {}", .{path.cmds.len, fill});
_ = x;
_ = y;
// Accumulate polygons.
self.vec2_helper_buf.clearRetainingCapacity();
self.vec2_slice_helper_buf.clearRetainingCapacity();
self.qbez_helper_buf.clearRetainingCapacity();
var last_cmd_was_curveto = false;
var last_control_pt = vec2(0, 0);
var cur_data_idx: u32 = 0;
var cur_pt = vec2(0, 0);
var cur_poly_start: u32 = 0;
for (path.cmds) |cmd| {
var cmd_is_curveto = false;
switch (cmd) {
.MoveTo => {
if (self.vec2_helper_buf.items.len > cur_poly_start + 1) {
self.vec2_slice_helper_buf.append(self.vec2_helper_buf.items[cur_poly_start..]) catch unreachable;
} else if (self.vec2_helper_buf.items.len == cur_poly_start + 1) {
// Only one unused point. Remove it.
_ = self.vec2_helper_buf.pop();
}
const data = path.getData(.MoveTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.MoveTo)) / 4;
cur_pt = .{
.x = data.x,
.y = data.y,
};
cur_poly_start = @intCast(u32, self.vec2_helper_buf.items.len);
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.MoveToRel => {
if (self.vec2_helper_buf.items.len > cur_poly_start + 1) {
self.vec2_slice_helper_buf.append(self.vec2_helper_buf.items[cur_poly_start..]) catch unreachable;
} else if (self.vec2_helper_buf.items.len == cur_poly_start + 1) {
// Only one unused point. Remove it.
_ = self.vec2_helper_buf.pop();
}
const data = path.getData(.MoveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.MoveToRel)) / 4;
cur_pt = .{
.x = cur_pt.x + data.x,
.y = cur_pt.y + data.y,
};
cur_poly_start = @intCast(u32, self.vec2_helper_buf.items.len);
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.CurveToRel => {
const data = path.getData(.CurveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.CurveToRel)) / 4;
last_control_pt = .{
.x = cur_pt.x + data.cb_x,
.y = cur_pt.y + data.cb_y,
};
const prev_pt = cur_pt;
cur_pt = .{
.x = cur_pt.x + data.x,
.y = cur_pt.y + data.y,
};
const c_bez = CubicBez{
.x0 = prev_pt.x,
.y0 = prev_pt.y,
.cx0 = prev_pt.x + data.ca_x,
.cy0 = prev_pt.y + data.ca_y,
.cx1 = last_control_pt.x,
.cy1 = last_control_pt.y,
.x1 = cur_pt.x,
.y1 = cur_pt.y,
};
c_bez.flatten(0.5, &self.vec2_helper_buf, &self.qbez_helper_buf);
cmd_is_curveto = true;
},
.LineTo => {
const data = path.getData(.LineTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.LineTo)) / 4;
cur_pt = .{
.x = data.x,
.y = data.y,
};
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.LineToRel => {
const data = path.getData(.LineToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.LineToRel)) / 4;
cur_pt = .{
.x = cur_pt.x + data.x,
.y = cur_pt.y + data.y,
};
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.SmoothCurveToRel => {
const data = path.getData(.SmoothCurveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.SmoothCurveToRel)) / 4;
var cx0: f32 = undefined;
var cy0: f32 = undefined;
if (last_cmd_was_curveto) {
// Reflection of last control point over current pos.
cx0 = cur_pt.x + (cur_pt.x - last_control_pt.x);
cy0 = cur_pt.y + (cur_pt.y - last_control_pt.y);
} else {
cx0 = cur_pt.x;
cy0 = cur_pt.y;
}
last_control_pt = .{
.x = cur_pt.x + data.c2_x,
.y = cur_pt.y + data.c2_y,
};
const prev_pt = cur_pt;
cur_pt = .{
.x = cur_pt.x + data.x,
.y = cur_pt.y + data.y,
};
const c_bez = CubicBez{
.x0 = prev_pt.x,
.y0 = prev_pt.y,
.cx0 = cx0,
.cy0 = cy0,
.cx1 = last_control_pt.x,
.cy1 = last_control_pt.y,
.x1 = cur_pt.x,
.y1 = cur_pt.y,
};
c_bez.flatten(0.5, &self.vec2_helper_buf, &self.qbez_helper_buf);
cmd_is_curveto = true;
},
.VertLineToRel => {
const data = path.getData(.VertLineToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.VertLineToRel)) / 4;
cur_pt.y += data.y;
self.vec2_helper_buf.append(cur_pt) catch unreachable;
},
.ClosePath => {
if (fill) {
// For fills, this is a no-op.
} else {
// For strokes, this would form a seamless connection to the first point.
}
},
else => {
stdx.panicFmt("unsupported: {}", .{cmd});
},
}
// .VertLineTo => {
// const data = path.getData(.VertLineTo, cur_data_idx);
// cur_data_idx += @sizeOf(svg.PathCommandData(.VertLineTo)) / 4;
// cur_pos.y = data.y;
// lyon.lineTo(b, &cur_pos);
// },
// .CurveTo => {
// const data = path.getData(.CurveTo, cur_data_idx);
// cur_data_idx += @sizeOf(svg.PathCommandData(.CurveTo)) / 4;
// cur_pos.x = data.x;
// cur_pos.y = data.y;
// last_control_pos.x = data.cb_x;
// last_control_pos.y = data.cb_y;
// cmd_is_curveto = true;
// lyon.cubicBezierTo(b, &pt(data.ca_x, data.ca_y), &last_control_pos, &cur_pos);
// },
// .SmoothCurveTo => {
// const data = path.getData(.SmoothCurveTo, cur_data_idx);
// cur_data_idx += @sizeOf(svg.PathCommandData(.SmoothCurveTo)) / 4;
// // Reflection of last control point over current pos.
// var c1_x: f32 = undefined;
// var c1_y: f32 = undefined;
// if (last_cmd_was_curveto) {
// c1_x = cur_pos.x + (cur_pos.x - last_control_pos.x);
// c1_y = cur_pos.y + (cur_pos.y - last_control_pos.y);
// } else {
// c1_x = cur_pos.x;
// c1_y = cur_pos.y;
// }
// cur_pos.x = data.x;
// cur_pos.y = data.y;
// last_control_pos.x = data.c2_x;
// last_control_pos.y = data.c2_y;
// cmd_is_curveto = true;
// lyon.cubicBezierTo(b, &pt(c1_x, c1_y), &last_control_pos, &cur_pos);
// },
// }
last_cmd_was_curveto = cmd_is_curveto;
}
if (self.vec2_helper_buf.items.len > cur_poly_start + 1) {
// Push the current polygon.
self.vec2_slice_helper_buf.append(self.vec2_helper_buf.items[cur_poly_start..]) catch unreachable;
}
if (self.vec2_slice_helper_buf.items.len == 0) {
return;
}
if (fill) {
// dumpPolygons(self.alloc, self.vec2_slice_helper_buf.items);
self.tessellator.clearBuffers();
self.tessellator.triangulatePolygons(self.vec2_slice_helper_buf.items);
self.setCurrentTexture(self.white_tex);
const out_verts = self.tessellator.out_verts.items;
const out_idxes = self.tessellator.out_idxes.items;
self.ensureUnusedBatchCapacity(out_verts.len, out_idxes.len);
self.batcher.pushVertIdxBatch(out_verts, out_idxes, self.cur_fill_color);
} else {
unreachable;
// var data = lyon.buildStroke(b, self.cur_line_width);
// self.setCurrentTexture(self.white_tex);
// self.pushLyonVertexData(&data, self.cur_stroke_color);
}
}
fn drawSvgPathLyon(self: *Self, x: f32, y: f32, path: *const svg.SvgPath, fill: bool) void {
// log.debug("drawSvgPath {}", .{path.cmds.len});
_ = x;
_ = y;
const b = lyon.initBuilder();
var cur_pos = pt(0, 0);
var cur_data_idx: u32 = 0;
var last_control_pos = pt(0, 0);
var cur_path_ended = true;
var last_cmd_was_curveto = false;
for (path.cmds) |it| {
var cmd_is_curveto = false;
switch (it) {
.MoveTo => {
if (!cur_path_ended) {
// End previous subpath.
lyon.end(b, false);
}
// log.debug("lyon begin", .{});
const data = path.getData(.MoveTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.MoveTo)) / 4;
cur_pos.x = data.x;
cur_pos.y = data.y;
lyon.begin(b, &cur_pos);
cur_path_ended = false;
},
.MoveToRel => {
if (!cur_path_ended) {
// End previous subpath.
lyon.end(b, false);
}
const data = path.getData(.MoveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.MoveToRel)) / 4;
cur_pos.x += data.x;
cur_pos.y += data.y;
lyon.begin(b, &cur_pos);
cur_path_ended = false;
},
.VertLineTo => {
const data = path.getData(.VertLineTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.VertLineTo)) / 4;
cur_pos.y = data.y;
lyon.lineTo(b, &cur_pos);
},
.VertLineToRel => {
const data = path.getData(.VertLineToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.VertLineToRel)) / 4;
cur_pos.y += data.y;
lyon.lineTo(b, &cur_pos);
},
.LineTo => {
const data = path.getData(.LineTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.LineTo)) / 4;
cur_pos.x = data.x;
cur_pos.y = data.y;
lyon.lineTo(b, &cur_pos);
},
.LineToRel => {
const data = path.getData(.LineToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.LineToRel)) / 4;
cur_pos.x += data.x;
cur_pos.y += data.y;
lyon.lineTo(b, &cur_pos);
},
.CurveTo => {
const data = path.getData(.CurveTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.CurveTo)) / 4;
cur_pos.x = data.x;
cur_pos.y = data.y;
last_control_pos.x = data.cb_x;
last_control_pos.y = data.cb_y;
cmd_is_curveto = true;
lyon.cubicBezierTo(b, &pt(data.ca_x, data.ca_y), &last_control_pos, &cur_pos);
},
.CurveToRel => {
const data = path.getData(.CurveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.CurveToRel)) / 4;
const prev_x = cur_pos.x;
const prev_y = cur_pos.y;
cur_pos.x += data.x;
cur_pos.y += data.y;
last_control_pos.x = prev_x + data.cb_x;
last_control_pos.y = prev_y + data.cb_y;
cmd_is_curveto = true;
lyon.cubicBezierTo(b, &pt(prev_x + data.ca_x, prev_y + data.ca_y), &last_control_pos, &cur_pos);
},
.SmoothCurveTo => {
const data = path.getData(.SmoothCurveTo, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.SmoothCurveTo)) / 4;
// Reflection of last control point over current pos.
var c1_x: f32 = undefined;
var c1_y: f32 = undefined;
if (last_cmd_was_curveto) {
c1_x = cur_pos.x + (cur_pos.x - last_control_pos.x);
c1_y = cur_pos.y + (cur_pos.y - last_control_pos.y);
} else {
c1_x = cur_pos.x;
c1_y = cur_pos.y;
}
cur_pos.x = data.x;
cur_pos.y = data.y;
last_control_pos.x = data.c2_x;
last_control_pos.y = data.c2_y;
cmd_is_curveto = true;
lyon.cubicBezierTo(b, &pt(c1_x, c1_y), &last_control_pos, &cur_pos);
},
.SmoothCurveToRel => {
const data = path.getData(.SmoothCurveToRel, cur_data_idx);
cur_data_idx += @sizeOf(svg.PathCommandData(.SmoothCurveToRel)) / 4;
const prev_x = cur_pos.x;
const prev_y = cur_pos.y;
var c1_x: f32 = undefined;
var c1_y: f32 = undefined;
if (last_cmd_was_curveto) {
// Reflection of last control point over current pos.
c1_x = cur_pos.x + (cur_pos.x - last_control_pos.x);
c1_y = cur_pos.y + (cur_pos.y - last_control_pos.y);
} else {
c1_x = cur_pos.x;
c1_y = cur_pos.y;
}
cur_pos.x += data.x;
cur_pos.y += data.y;
last_control_pos.x = prev_x + data.c2_x;
last_control_pos.y = prev_y + data.c2_y;
cmd_is_curveto = true;
lyon.cubicBezierTo(b, &pt(c1_x, c1_y), &last_control_pos, &cur_pos);
},
.ClosePath => {
lyon.close(b);
cur_path_ended = true;
},
}
last_cmd_was_curveto = cmd_is_curveto;
}
if (fill) {
var data = lyon.buildFill(b);
self.setCurrentTexture(self.white_tex);
self.pushLyonVertexData(&data, self.cur_fill_color);
} else {
var data = lyon.buildStroke(b, self.cur_line_width);
self.setCurrentTexture(self.white_tex);
self.pushLyonVertexData(&data, self.cur_stroke_color);
}
}
/// Points of front face is in ccw order.
pub fn fillTriangle3D(self: *Self, x1: f32, y1: f32, z1: f32, x2: f32, y2: f32, z2: f32, x3: f32, y3: f32, z3: f32) void {
self.batcher.beginTex3D(self.white_tex);
self.ensureUnusedBatchCapacity(3, 3);
var vert: TexShaderVertex = undefined;
vert.setColor(self.cur_fill_color);
vert.setUV(0, 0); // Don't map uvs for now.
const start_idx = self.batcher.mesh.getNextIndexId();
vert.setXYZ(x1, y1, z1);
self.batcher.mesh.addVertex(&vert);
vert.setXYZ(x2, y2, z2);
self.batcher.mesh.addVertex(&vert);
vert.setXYZ(x3, y3, z3);
self.batcher.mesh.addVertex(&vert);
self.batcher.mesh.addTriangle(start_idx, start_idx + 1, start_idx + 2);
}
pub fn fillTriangle(self: *Self, x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32) void {
self.setCurrentTexture(self.white_tex);
self.ensureUnusedBatchCapacity(3, 3);
var vert: TexShaderVertex = undefined;
vert.setColor(self.cur_fill_color);
vert.setUV(0, 0); // Don't map uvs for now.
const start_idx = self.batcher.mesh.getNextIndexId();
vert.setXY(x1, y1);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x2, y2);
self.batcher.mesh.addVertex(&vert);
vert.setXY(x3, y3);
self.batcher.mesh.addVertex(&vert);
self.batcher.mesh.addTriangle(start_idx, start_idx + 1, start_idx + 2);
}
/// Assumes pts are in ccw order.
pub fn fillConvexPolygon(self: *Self, pts: []const Vec2) void {
self.setCurrentTexture(self.white_tex);
self.ensureUnusedBatchCapacity(pts.len, (pts.len - 2) * 3);
var vert: TexShaderVertex = undefined;
vert.setColor(self.cur_fill_color);
vert.setUV(0, 0); // Don't map uvs for now.
const start_idx = self.batcher.mesh.getNextIndexId();
// Add first two vertices.
vert.setXY(pts[0].x, pts[0].y);
self.batcher.mesh.addVertex(&vert);
vert.setXY(pts[1].x, pts[1].y);
self.batcher.mesh.addVertex(&vert);
var i: u16 = 2;
while (i < pts.len) : (i += 1) {
vert.setXY(pts[i].x, pts[i].y);
self.batcher.mesh.addVertex(&vert);
self.batcher.mesh.addTriangle(start_idx, start_idx + i - 1, start_idx + i);
}
}
pub fn fillPolygon(self: *Self, pts: []const Vec2) void {
self.tessellator.clearBuffers();
self.tessellator.triangulatePolygon(pts);
self.setCurrentTexture(self.white_tex);
const out_verts = self.tessellator.out_verts.items;
const out_idxes = self.tessellator.out_idxes.items;
self.ensureUnusedBatchCapacity(out_verts.len, out_idxes.len);
self.batcher.pushVertIdxBatch(out_verts, out_idxes, self.cur_fill_color);
}
pub fn fillPolygonLyon(self: *Self, pts: []const Vec2) void {
const b = lyon.initBuilder();
lyon.addPolygon(b, pts, true);
var data = lyon.buildFill(b);
self.setCurrentTexture(self.white_tex);
self.pushLyonVertexData(&data, self.cur_fill_color);
}
pub fn fillPolygonTess2(self: *Self, pts: []const Vec2) void {
var tess = getTess2Handle();
tess2.tessAddContour(tess, 2, &pts[0], 0, @intCast(c_int, pts.len));
const res = tess2.tessTesselate(tess, tess2.TESS_WINDING_ODD, tess2.TESS_POLYGONS, 3, 2, null);
if (res == 0) {
unreachable;
}
var gpu_vert: TexShaderVertex = undefined;
gpu_vert.setColor(self.cur_fill_color);
const vert_offset_id = self.batcher.mesh.getNextIndexId();
var nverts = tess2.tessGetVertexCount(tess);
var verts = tess2.tessGetVertices(tess);
const nelems = tess2.tessGetElementCount(tess);
self.ensureUnusedBatchCapacity(@intCast(u32, nverts), @intCast(usize, nelems * 3));
var i: u32 = 0;
while (i < nverts) : (i += 1) {
gpu_vert.setXY(verts[i*2], verts[i*2+1]);
gpu_vert.setUV(0, 0);
_ = self.batcher.mesh.addVertex(&gpu_vert);
}
const elems = tess2.tessGetElements(tess);
i = 0;
while (i < nelems) : (i += 1) {
self.batcher.mesh.addIndex(@intCast(u16, vert_offset_id + elems[i*3+2]));
self.batcher.mesh.addIndex(@intCast(u16, vert_offset_id + elems[i*3+1]));
self.batcher.mesh.addIndex(@intCast(u16, vert_offset_id + elems[i*3]));
}
}
pub fn drawMesh3D(self: *Self, xform: Transform, verts: []const TexShaderVertex, indexes: []const u16) void {
self.batcher.beginTex3D(self.white_tex);
const cur_mvp = self.batcher.mvp;
// Create temp mvp.
const vp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
const mvp = xform.getAppliedTransform(vp);
self.batcher.beginMvp(mvp);
self.batcher.pushMeshData(verts, indexes);
self.batcher.beginMvp(cur_mvp);
}
pub fn fillMesh3D(self: *Self, xform: Transform, verts: []const TexShaderVertex, indexes: []const u16) void {
self.batcher.beginTex3D(self.white_tex);
const cur_mvp = self.batcher.mvp;
// Create temp mvp.
const vp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
const mvp = xform.getAppliedTransform(vp);
self.batcher.beginMvp(mvp);
if (!self.batcher.ensureUnusedBuffer(verts.len, indexes.len)) {
self.batcher.endCmd();
}
const vert_start = self.batcher.mesh.getNextIndexId();
for (verts) |vert| {
var new_vert = vert;
new_vert.setColor(self.cur_fill_color);
self.batcher.mesh.addVertex(&new_vert);
}
self.batcher.mesh.addDeltaIndices(vert_start, indexes);
self.batcher.beginMvp(cur_mvp);
}
pub fn strokeMesh3D(self: *Self, xform: Transform, verts: []const TexShaderVertex, indexes: []const u16) void {
self.batcher.beginWireframe();
const cur_mvp = self.batcher.mvp;
// Create temp mvp.
const vp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
const mvp = xform.getAppliedTransform(vp);
self.batcher.beginMvp(mvp);
// TODO: stroke color should pushed as a constant.
if (!self.batcher.ensureUnusedBuffer(verts.len, indexes.len)) {
self.batcher.endCmd();
}
const vert_start = self.batcher.mesh.getNextIndexId();
for (verts) |vert| {
var new_vert = vert;
new_vert.setColor(self.cur_stroke_color);
self.batcher.mesh.addVertex(&new_vert);
}
self.batcher.mesh.addDeltaIndices(vert_start, indexes);
self.batcher.beginMvp(cur_mvp);
}
pub fn drawPolygon(self: *Self, pts: []const Vec2) void {
_ = self;
_ = pts;
self.batcher.beginTex(self.white_tex);
// TODO: Implement this.
}
pub fn drawPolygonLyon(self: *Self, pts: []const Vec2) void {
self.batcher.beginTex(self.white_tex);
const b = lyon.initBuilder();
lyon.addPolygon(b, pts, true);
var data = lyon.buildStroke(b, self.cur_line_width);
self.pushLyonVertexData(&data, self.cur_stroke_color);
}
pub fn drawSubImage(self: *Self, src_x: f32, src_y: f32, src_width: f32, src_height: f32, x: f32, y: f32, width: f32, height: f32, image_id: ImageId) void {
const img = self.image_store.images.get(image_id);
self.batcher.beginTex(image.ImageDesc{ .image_id = image_id, .tex_id = img.tex_id });
self.ensureUnusedBatchCapacity(4, 6);
var vert: TexShaderVertex = undefined;
vert.setColor(Color.White);
const start_idx = self.batcher.mesh.getNextIndexId();
const u_start = src_x / width;
const u_end = (src_x + src_width) / width;
const v_start = src_y / height;
const v_end = (src_y + src_height) / height;
// top left
vert.setXY(x, y);
vert.setUV(u_start, v_start);
self.batcher.mesh.addVertex(&vert);
// top right
vert.setXY(x + width, y);
vert.setUV(u_end, v_start);
self.batcher.mesh.addVertex(&vert);
// bottom right
vert.setXY(x + width, y + height);
vert.setUV(u_end, v_end);
self.batcher.mesh.addVertex(&vert);
// bottom left
vert.setXY(x, y + height);
vert.setUV(u_start, v_end);
self.batcher.mesh.addVertex(&vert);
// add rect
self.batcher.mesh.addQuad(start_idx, start_idx + 1, start_idx + 2, start_idx + 3);
}
pub fn drawImageSized(self: *Self, x: f32, y: f32, width: f32, height: f32, image_id: ImageId) void {
const img = self.image_store.images.getNoCheck(image_id);
self.batcher.beginTex(image.ImageTex{ .image_id = image_id, .tex_id = img.tex_id });
self.ensureUnusedBatchCapacity(4, 6);
var vert: TexShaderVertex = undefined;
vert.setColor(Color.White);
const start_idx = self.batcher.mesh.getNextIndexId();
// top left
vert.setXY(x, y);
vert.setUV(0, 0);
self.batcher.mesh.addVertex(&vert);
// top right
vert.setXY(x + width, y);
vert.setUV(1, 0);
self.batcher.mesh.addVertex(&vert);
// bottom right
vert.setXY(x + width, y + height);
vert.setUV(1, 1);
self.batcher.mesh.addVertex(&vert);
// bottom left
vert.setXY(x, y + height);
vert.setUV(0, 1);
self.batcher.mesh.addVertex(&vert);
// add rect
self.batcher.mesh.addQuad(start_idx, start_idx + 1, start_idx + 2, start_idx + 3);
}
pub fn drawImage(self: *Self, x: f32, y: f32, image_id: ImageId) void {
const img = self.image_store.images.getNoCheck(image_id);
self.batcher.beginTex(image.ImageTex{ .image_id = image_id, .tex_id = img.tex_id });
self.ensureUnusedBatchCapacity(4, 6);
var vert: TexShaderVertex = undefined;
vert.setColor(Color.White);
const start_idx = self.batcher.mesh.getNextIndexId();
// top left
vert.setXY(x, y);
vert.setUV(0, 0);
self.batcher.mesh.addVertex(&vert);
// top right
vert.setXY(x + @intToFloat(f32, img.width), y);
vert.setUV(1, 0);
self.batcher.mesh.addVertex(&vert);
// bottom right
vert.setXY(x + @intToFloat(f32, img.width), y + @intToFloat(f32, img.height));
vert.setUV(1, 1);
self.batcher.mesh.addVertex(&vert);
// bottom left
vert.setXY(x, y + @intToFloat(f32, img.height));
vert.setUV(0, 1);
self.batcher.mesh.addVertex(&vert);
// add rect
self.batcher.mesh.addQuad(start_idx, start_idx + 1, start_idx + 2, start_idx + 3);
}
/// Binds an image to the write buffer.
pub fn bindImageBuffer(self: *Self, image_id: ImageId) void {
var img = self.image_store.images.getPtrNoCheck(image_id);
if (img.fbo_id == null) {
img.fbo_id = self.createTextureFramebuffer(img.tex_id);
}
gl.bindFramebuffer(gl.GL_FRAMEBUFFER, img.fbo_id.?);
gl.viewport(0, 0, @intCast(c_int, img.width), @intCast(c_int, img.height));
self.cur_proj_transform = graphics.initTextureProjection(@intToFloat(f32, img.width), @intToFloat(f32, img.height));
self.view_transform = Transform.initIdentity();
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.beginMvp(mvp);
}
fn createTextureFramebuffer(self: Self, tex_id: gl.GLuint) gl.GLuint {
_ = self;
var fbo_id: gl.GLuint = 0;
gl.genFramebuffers(1, &fbo_id);
gl.bindFramebuffer(gl.GL_FRAMEBUFFER, fbo_id);
gl.bindTexture(gl.GL_TEXTURE_2D, tex_id);
gl.framebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, tex_id, 0);
const status = gl.checkFramebufferStatus(gl.GL_FRAMEBUFFER);
if (status != gl.GL_FRAMEBUFFER_COMPLETE) {
log.debug("unexpected status: {}", .{status});
unreachable;
}
return fbo_id;
}
pub fn beginFrameVK(self: *Self, buf_width: u32, buf_height: u32, image_idx: u32, frame_idx: u32) void {
self.cur_buf_width = buf_width;
self.cur_buf_height = buf_height;
self.inner.cur_cmd_buf = self.inner.ctx.cmd_bufs[image_idx];
self.batcher.resetStateVK(self.white_tex, image_idx, frame_idx, self.clear_color);
self.cur_clip_rect = .{
.x = 0,
.y = 0,
.width = @intToFloat(f32, buf_width),
.height = @intToFloat(f32, buf_height),
};
self.cur_scissors = false;
self.clipRectCmd(self.cur_clip_rect);
}
/// Begin frame sets up the context before any other draw call.
/// This should be agnostic to the view port dimensions so this context can be reused by different windows.
pub fn beginFrame(self: *Self, buf_width: u32, buf_height: u32, custom_fbo: gl.GLuint) void {
// log.debug("beginFrame", .{});
self.cur_buf_width = buf_width;
self.cur_buf_height = buf_height;
// TODO: Viewport only needs to be set on window resize or multiple windows are active.
gl.viewport(0, 0, @intCast(c_int, buf_width), @intCast(c_int, buf_height));
self.batcher.resetState(self.white_tex);
// Scissor affects glClear so reset it first.
self.cur_clip_rect = .{
.x = 0,
.y = 0,
.width = @intToFloat(f32, buf_width),
.height = @intToFloat(f32, buf_height),
};
self.cur_scissors = false;
gl.disable(gl.GL_SCISSOR_TEST);
if (custom_fbo == 0) {
// This clears the main framebuffer that is swapped to window.
gl.bindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, 0);
gl.clear(gl.GL_COLOR_BUFFER_BIT);
} else {
// Set the frame buffer we are drawing to.
gl.bindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, custom_fbo);
// Clears the custom frame buffer.
gl.clear(gl.GL_COLOR_BUFFER_BIT);
}
// Straight alpha by default.
self.setBlendMode(.StraightAlpha);
}
pub fn endFrameVK(self: *Self) void {
self.endCmd();
self.batcher.endFrameVK();
self.image_store.processRemovals();
}
pub fn endFrame(self: *Self, buf_width: u32, buf_height: u32, custom_fbo: gl.GLuint) void {
// log.debug("endFrame", .{});
self.endCmd();
if (custom_fbo != 0) {
// If we were drawing to custom framebuffer such as msaa buffer, then blit the custom buffer into the default ogl buffer.
gl.bindFramebuffer(gl.GL_READ_FRAMEBUFFER, custom_fbo);
gl.bindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, 0);
// blit's filter is only used when the sizes between src and dst buffers are different.
gl.blitFramebuffer(0, 0, @intCast(c_int, buf_width), @intCast(c_int, buf_height), 0, 0, @intCast(c_int, buf_width), @intCast(c_int, buf_height), gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST);
}
}
pub fn setCamera(self: *Self, cam: graphics.Camera) void {
self.endCmd();
self.cur_proj_transform = cam.proj_transform;
self.view_transform = cam.view_transform;
self.batcher.mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
}
pub fn translate(self: *Self, x: f32, y: f32) void {
self.view_transform.translate(x, y);
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.beginMvp(mvp);
}
pub fn translate3D(self: *Self, x: f32, y: f32, z: f32) void {
self.view_transform.translate3D(x, y, z);
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.beginMvp(mvp);
}
pub fn scale(self: *Self, x: f32, y: f32) void {
self.view_transform.scale(x, y);
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.beginMvp(mvp);
}
pub fn rotateZ(self: *Self, rad: f32) void {
self.view_transform.rotateZ(rad);
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.beginMvp(mvp);
}
pub fn rotateX(self: *Self, rad: f32) void {
self.view_transform.rotateX(rad);
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.beginMvp(mvp);
}
pub fn rotateY(self: *Self, rad: f32) void {
self.view_transform.rotateY(rad);
const mvp = self.view_transform.getAppliedTransform(self.cur_proj_transform);
self.batcher.beginMvp(mvp);
}
// GL Only.
pub fn setBlendModeCustom(self: *Self, src: gl.GLenum, dst: gl.GLenum, eq: gl.GLenum) void {
_ = self;
gl.blendFunc(src, dst);
gl.blendEquation(eq);
}
// TODO: Implement this in Vulkan.
pub fn setBlendMode(self: *Self, mode: BlendMode) void {
if (self.cur_blend_mode != mode) {
self.endCmd();
switch (mode) {
.StraightAlpha => gl.blendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA),
.Add, .Glow => {
gl.blendFunc(gl.GL_ONE, gl.GL_ONE);
gl.blendEquation(gl.GL_FUNC_ADD);
},
.Subtract => {
gl.blendFunc(gl.GL_ONE, gl.GL_ONE);
gl.blendEquation(gl.GL_FUNC_SUBTRACT);
},
.Multiplied => {
gl.blendFunc(gl.GL_DST_COLOR, gl.GL_ONE_MINUS_SRC_ALPHA);
gl.blendEquation(gl.GL_FUNC_ADD);
},
.Opaque => {
gl.blendFunc(gl.GL_ONE, gl.GL_ZERO);
gl.blendEquation(gl.GL_FUNC_ADD);
},
.Additive => {
gl.blendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE);
gl.blendEquation(gl.GL_FUNC_ADD);
},
.PremultipliedAlpha => {
gl.blendFunc(gl.GL_ONE, gl.GL_ONE_MINUS_SRC_ALPHA);
gl.blendEquation(gl.GL_FUNC_ADD);
},
else => @panic("unsupported"),
}
self.cur_blend_mode = mode;
}
}
pub fn endCmd(self: *Self) void {
self.batcher.endCmd();
}
pub fn updateTextureData(self: *const Self, img: image.Image, buf: []const u8) void {
switch (Backend) {
.OpenGL => {
gl.activeTexture(gl.GL_TEXTURE0 + 0);
const gl_tex_id = self.image_store.getTexture(img.tex_id).inner.tex_id;
gl.bindTexture(gl.GL_TEXTURE_2D, gl_tex_id);
gl.texSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, @intCast(c_int, img.width), @intCast(c_int, img.height), gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, buf.ptr);
gl.bindTexture(gl.GL_TEXTURE_2D, 0);
},
.Vulkan => {
const ctx = self.inner.ctx;
var staging_buf: vk.VkBuffer = undefined;
var staging_buf_mem: vk.VkDeviceMemory = undefined;
const size = @intCast(u32, buf.len);
gvk.buffer.createBuffer(ctx.physical, ctx.device, size, vk.VK_BUFFER_USAGE_TRANSFER_SRC_BIT, vk.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | vk.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &staging_buf, &staging_buf_mem);
// Copy to gpu.
var gpu_data: ?*anyopaque = null;
var res = vk.mapMemory(ctx.device, staging_buf_mem, 0, size, 0, &gpu_data);
vk.assertSuccess(res);
std.mem.copy(u8, @ptrCast([*]u8, gpu_data)[0..size], buf);
vk.unmapMemory(ctx.device, staging_buf_mem);
// Transition to transfer dst layout.
ctx.transitionImageLayout(img.inner.image, vk.VK_FORMAT_R8G8B8A8_SRGB, vk.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, vk.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
ctx.copyBufferToImage(staging_buf, img.inner.image, img.width, img.height);
// Transition to shader access layout.
ctx.transitionImageLayout(img.inner.image, vk.VK_FORMAT_R8G8B8A8_SRGB, vk.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, vk.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
// Cleanup.
vk.destroyBuffer(ctx.device, staging_buf, null);
vk.freeMemory(ctx.device, staging_buf_mem, null);
},
else => {},
}
}
};
const DrawState = struct {
clip_rect: geom.Rect,
use_scissors: bool,
blend_mode: BlendMode,
view_transform: Transform,
};
fn dumpPolygons(alloc: std.mem.Allocator, polys: []const []const Vec2) void {
var buf = std.ArrayList(u8).init(alloc);
defer buf.deinit();
const writer = buf.writer();
for (polys) |poly, i| {
std.fmt.format(writer, "polygon {} ", .{i}) catch unreachable;
for (poly) |pt_| {
std.fmt.format(writer, "{d:.2}, {d:.2},", .{pt_.x, pt_.y}) catch unreachable;
}
std.fmt.format(writer, "\n", .{}) catch unreachable;
}
log.debug("{s}", .{buf.items});
}
var tess_: ?*tess2.TESStesselator = null;
fn getTess2Handle() *tess2.TESStesselator {
if (tess_ == null) {
tess_ = tess2.tessNewTess(null);
}
return tess_.?;
} | graphics/src/backend/gpu/graphics.zig |
const std = @import("std");
const build_options = @import("build_options");
const Backend = build_options.GraphicsBackend;
const stdx = @import("stdx");
const Vec2 = stdx.math.Vec2;
const Vec3 = stdx.math.Vec3;
const Vec4 = stdx.math.Vec4;
const t = stdx.testing;
const platform = @import("platform");
const graphics = @import("graphics.zig");
const Transform = graphics.transform.Transform;
const log = stdx.log.scoped(.camera);
const eqApproxVec2 = stdx.math.eqApproxVec2;
const eqApproxVec3 = stdx.math.eqApproxVec3;
const eqApproxVec4 = stdx.math.eqApproxVec4;
// Vulkan clip-space: [-1,1][-1,1][0,1]
// OpenGL clip-space: [-1,1][-1,1][-1,1]
pub const Camera = struct {
proj_transform: Transform,
view_transform: Transform,
world_pos: Vec3,
/// Used to do movement along axis.
up_nvec: Vec3,
right_nvec: Vec3,
forward_nvec: Vec3,
// TODO: Implement with geometric algebra.
/// It's easier to deal with changing rotations by keeping the axis rotation values.
rotate_x: f32,
rotate_y: f32,
/// Logical width and height.
pub fn init2D(self: *Camera, width: u32, height: u32) void {
self.proj_transform = initDisplayProjection(@intToFloat(f32, width), @intToFloat(f32, height));
self.view_transform = Transform.initIdentity();
}
pub fn initPerspective3D(self: *Camera, vert_fov_deg: f32, aspect_ratio: f32, near: f32, far: f32) void {
self.proj_transform = initPerspectiveProjection(vert_fov_deg, aspect_ratio, near, far);
self.world_pos = stdx.math.Vec3.init(0, 0, 0);
self.setRotation(0, -std.math.pi);
}
pub fn moveForward(self: *Camera, delta: f32) void {
self.world_pos.x += self.forward_nvec.x * delta;
self.world_pos.y += self.forward_nvec.y * delta;
self.world_pos.z += self.forward_nvec.z * delta;
self.computeViewTransform();
}
pub fn moveUp(self: *Camera, delta: f32) void {
self.world_pos.x += self.up_nvec.x * delta;
self.world_pos.y += self.up_nvec.y * delta;
self.world_pos.z += self.up_nvec.z * delta;
self.computeViewTransform();
}
pub fn moveRight(self: *Camera, delta: f32) void {
self.world_pos.x += self.right_nvec.x * delta;
self.world_pos.y += self.right_nvec.y * delta;
self.world_pos.z += self.right_nvec.z * delta;
self.computeViewTransform();
}
pub fn setPos(self: *Camera, x: f32, y: f32, z: f32) void {
self.world_pos.x = x;
self.world_pos.y = y;
self.world_pos.z = z;
self.computeViewTransform();
}
pub fn setRotation(self: *Camera, rotate_x: f32, rotate_y: f32) void {
self.rotate_x = rotate_x;
self.rotate_y = rotate_y;
self.computeViewTransform();
}
// TODO: Convert to rotate_x, rotate_y.
// pub fn setForward(self: *Camera, forward: Vec3) void {
// self.forward_nvec = forward.normalize();
// self.right_nvec = self.forward_nvec.cross(Vec3.init(0, 1, 0)).normalize();
// if (std.math.isNan(self.right_nvec.x)) {
// self.right_nvec = self.forward_nvec.cross(Vec3.init(0, 0, 1)).normalize();
// }
// self.up_nvec = self.right_nvec.cross(self.forward_nvec).normalize();
// self.computeViewTransform();
// }
fn computeViewTransform(self: *Camera) void {
self.view_transform = Transform.initIdentity();
self.view_transform.translate3D(-self.world_pos.x, -self.world_pos.y, -self.world_pos.z);
var rotate_xform = Transform.initIdentity();
rotate_xform.rotateY(self.rotate_y + std.math.pi);
rotate_xform.rotateX(self.rotate_x);
// Set forward, up, right vecs from rotation matrix.
// Use opposite forward vector since eye defaults to looking behind.
self.forward_nvec = Vec3.init(-rotate_xform.mat[8], -rotate_xform.mat[9], -rotate_xform.mat[10]);
self.right_nvec = Vec3.init(rotate_xform.mat[0], rotate_xform.mat[1], rotate_xform.mat[2]);
self.up_nvec = Vec3.init(rotate_xform.mat[4], rotate_xform.mat[5], rotate_xform.mat[6]);
self.view_transform.applyTransform(rotate_xform);
}
};
pub fn initDisplayProjection(width: f32, height: f32) Transform {
return initDisplayProjection2(width, height, Backend);
}
/// Expose for testing.
inline fn initDisplayProjection2(width: f32, height: f32, comptime backend: @TypeOf(Backend)) Transform {
var res = Transform.initIdentity();
// first reduce to [0,1] values
res.scale(1.0 / width, 1.0 / height);
// to [0,2] values
res.scale(2.0, 2.0);
// to clip space [-1,1]
res.translate(-1.0, -1.0);
if (backend == .OpenGL) {
// flip y since clip space is based on cartesian
res.scale(1.0, -1.0);
}
return res;
}
test "initDisplayProjection" {
var transform = initDisplayProjection2(800, 600, .OpenGL);
try t.eq(transform.interpolatePt(Vec2.init(0, 0)), Vec2.init(-1, 1));
try t.eq(transform.interpolatePt(Vec2.init(800, 0)), Vec2.init(1, 1));
try t.eq(transform.interpolatePt(Vec2.init(800, 600)), Vec2.init(1, -1));
try t.eq(transform.interpolatePt(Vec2.init(0, 600)), Vec2.init(-1, -1));
}
/// For drawing to textures. Similar to display projection but y isn't flipped.
pub fn initTextureProjection(width: f32, height: f32) Transform {
var res = Transform.initIdentity();
// first reduce to [0,1] values
res.scale(1.0 / width, 1.0 / height);
// to [0,2] values
res.scale(2.0, 2.0);
// to clip space [-1,1]
res.translate(-1.0, -1.0);
return res;
}
/// https://vincent-p.github.io/posts/vulkan_perspective_matrix/
pub fn initPerspectiveProjection(vert_fov_deg: f32, aspect_ratio: f32, near: f32, far: f32) Transform {
const fov_rad = vert_fov_deg * 2 * std.math.pi / 360;
const focal_length = 1 / std.math.tan(fov_rad / 2);
const x = focal_length / aspect_ratio;
const y = -focal_length;
const a = near / (far - near);
const b = far * a;
return Transform.initRowMajor(.{
x, 0, 0, 0,
0, y, 0, 0,
0, 0, a, b,
0, 0, -1, 0,
});
}
test "Perspective camera." {
const pif = @as(f32, std.math.pi);
var cam: Camera = undefined;
cam.initPerspective3D(60, 2, 0.1, 100);
try eqApproxVec3(cam.forward_nvec, Vec3.init(0, 0, -1));
try eqApproxVec3(cam.right_nvec, Vec3.init(1, 0, 0));
try eqApproxVec3(cam.up_nvec, Vec3.init(0, 1, 0));
try eqApproxVec4(cam.view_transform.interpolate4(0, 0, -10, 1), Vec4.init(0, 0, -10, 1));
// Look tilted downward.
cam.setRotation(-pif * 0.25, -pif);
try eqApproxVec3(cam.forward_nvec, Vec3.init(0, -1, -1).normalize());
try eqApproxVec3(cam.right_nvec, Vec3.init(1, 0, 0));
try eqApproxVec3(cam.up_nvec, Vec3.init(0, 1, -1).normalize());
try eqApproxVec4(cam.view_transform.interpolate4(0, 0, -10, 1), Vec4.init(0, std.math.sqrt(50.0), -std.math.sqrt(50.0), 1));
// Look tilted upward.
cam.setRotation(pif * 0.25, -pif);
try eqApproxVec3(cam.forward_nvec, Vec3.init(0, 1, -1).normalize());
try eqApproxVec3(cam.right_nvec, Vec3.init(1, 0, 0));
try eqApproxVec3(cam.up_nvec, Vec3.init(0, 1, 1).normalize());
try eqApproxVec4(cam.view_transform.interpolate4(0, 0, -10, 1), Vec4.init(0, -std.math.sqrt(50.0), -std.math.sqrt(50.0), 1));
// Look tilted to the left.
cam.setRotation(0, -pif * 0.75);
try eqApproxVec3(cam.forward_nvec, Vec3.init(-1, 0, -1).normalize());
try eqApproxVec3(cam.right_nvec, Vec3.init(1, 0, -1).normalize());
try eqApproxVec3(cam.up_nvec, Vec3.init(0, 1, 0));
try eqApproxVec4(cam.view_transform.interpolate4(0, 0, -10, 1), Vec4.init(std.math.sqrt(50.0), 0, -std.math.sqrt(50.0), 1));
// Look tilted to the right.
cam.setRotation(0, pif * 0.75);
try eqApproxVec3(cam.forward_nvec, Vec3.init(1, 0, -1).normalize());
try eqApproxVec3(cam.right_nvec, Vec3.init(1, 0, 1).normalize());
try eqApproxVec3(cam.up_nvec, Vec3.init(0, 1, 0));
try eqApproxVec4(cam.view_transform.interpolate4(0, 0, -10, 1), Vec4.init(-std.math.sqrt(50.0), 0, -std.math.sqrt(50.0), 1));
// Look downwards.
cam.setRotation(pif, 0);
try eqApproxVec3(cam.forward_nvec, Vec3.init(0, 0, -1));
try eqApproxVec3(cam.right_nvec, Vec3.init(-1, 0, 0));
try eqApproxVec3(cam.up_nvec, Vec3.init(0, -1, 0));
}
/// near and far are towards -z.
pub fn initFrustumProjection(near: f32, far: f32, left: f32, right: f32, top: f32, bottom: f32) Transform {
const width = right - left;
const height = top - bottom;
return Transform.initRowMajor(.{
2 * near / width, 0, (right + left) / width, 0,
0, -2 * near / height, -(top + bottom) / height, 0,
0, 0, near / (far - near), far * near / (far - near),
0, 0, -1, 0,
});
}
/// Binds to the event dispatcher and allows camera movement with mouse and keyboard events.
pub const CameraModule = struct {
cam: *Camera,
move_forward: bool,
move_backward: bool,
move_left: bool,
move_right: bool,
dragging: bool,
drag_start_rotate_x: f32,
drag_start_rotate_y: f32,
drag_start_x: f32,
drag_start_y: f32,
const Self = @This();
pub fn init(self_: *Self, cam: *Camera, dispatcher: *platform.EventDispatcher) void {
const S = struct {
fn onKeyDown(ptr: ?*anyopaque, ke: platform.KeyDownEvent) void {
const self = stdx.mem.ptrCastAlign(*Self, ptr);
switch (ke.code) {
.W => self.move_forward = true,
.S => self.move_backward = true,
.A => self.move_left = true,
.D => self.move_right = true,
else => {},
}
}
fn onKeyUp(ptr: ?*anyopaque, ke: platform.KeyUpEvent) void {
const self = stdx.mem.ptrCastAlign(*Self, ptr);
switch (ke.code) {
.W => self.move_forward = false,
.S => self.move_backward = false,
.A => self.move_left = false,
.D => self.move_right = false,
else => {},
}
}
fn onMouseDown(ptr: ?*anyopaque, me: platform.MouseDownEvent) platform.EventResult {
const self = stdx.mem.ptrCastAlign(*Self, ptr);
if (me.button == .Left) {
self.dragging = true;
self.drag_start_x = @intToFloat(f32, me.x);
self.drag_start_y = @intToFloat(f32, me.y);
self.drag_start_rotate_x = self.cam.rotate_x;
self.drag_start_rotate_y = self.cam.rotate_y;
}
return .Continue;
}
fn onMouseUp(ptr: ?*anyopaque, me: platform.MouseUpEvent) void {
const self = stdx.mem.ptrCastAlign(*Self, ptr);
if (me.button == .Left) {
self.dragging = false;
}
}
fn onMouseMove(ptr: ?*anyopaque, me: platform.MouseMoveEvent) void {
const self = stdx.mem.ptrCastAlign(*Self, ptr);
if (self.dragging) {
const delta_x = @intToFloat(f32, me.x) - self.drag_start_x;
const delta_y = -(@intToFloat(f32, me.y) - self.drag_start_y);
const delta_pitch = delta_y * 0.01;
const delta_yaw = delta_x * 0.01;
self.cam.setRotation(self.drag_start_rotate_x + delta_pitch, self.drag_start_rotate_y - delta_yaw);
}
}
};
dispatcher.addOnKeyDown(self_, S.onKeyDown);
dispatcher.addOnKeyUp(self_, S.onKeyUp);
dispatcher.addOnMouseDown(self_, S.onMouseDown);
dispatcher.addOnMouseUp(self_, S.onMouseUp);
dispatcher.addOnMouseMove(self_, S.onMouseMove);
self_.* = .{
.cam = cam,
.move_forward = false,
.move_backward = false,
.move_left = false,
.move_right = false,
.dragging = false,
.drag_start_rotate_x = undefined,
.drag_start_rotate_y = undefined,
.drag_start_x = undefined,
.drag_start_y = undefined,
};
}
pub fn update(self: *Self, delta_ms: f32) void {
if (self.move_backward) {
self.cam.moveForward(-0.05 * delta_ms);
}
if (self.move_forward) {
self.cam.moveForward(0.05 * delta_ms);
}
if (self.move_left) {
self.cam.moveRight(-0.05 * delta_ms);
}
if (self.move_right) {
self.cam.moveRight(0.05 * delta_ms);
}
}
}; | graphics/src/camera.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const Options = @import("Options.zig");
const term = @import("term.zig");
const util = @import("util.zig");
const debug = @import("debug.zig");
const CodeLens = @import("CodeLens.zig");
const parse = @import("parse/!mod.zig");
pub fn main() anyerror!void {
var gpa = std.heap.GeneralPurposeAllocator(.{
// // uncomment to print more useful information when debugging allocation related bugs,
// // such as double-frees and segfaults.
// // Be warned: will use *a lot* more memory and be *much* slower.
// .never_unmap = true,
// .retain_metadata = true,
// .stack_trace_frames = 16,
}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
term.init();
defer term.deinit();
const opts = try Options.get(allocator);
defer opts.deinit(allocator);
var path = opts.files[0];
var src = try util.readFile(path, allocator);
defer allocator.free(src);
var lex_res = parse.Lexer.lex(allocator, src);
defer lex_res.deinit(allocator);
const spans = lex_res.spans;
if (opts.verbose.tokens) {
try debug.printTokens(allocator, lex_res.tokens, spans, src);
term.println("", .{});
}
const token_kinds = lex_res.tokens.items(.kind);
var parse_res = parse.Parser.parse(allocator, token_kinds, src);
defer parse_res.deinit(allocator);
if (parse_res.errors.items.len != 0) {
term.eprintln("", .{});
for (parse_res.errors.items) |err| {
const loc: parse.LocationSpan = switch (err) {
.expected => |data| blk: {
const found = token_kinds[data.found];
term.eprintln("error: Expected '{?}' in '{?}', but found '{?}'", .{ data.what, data.in, found });
const loc = parse.Location.get(src, spans[data.found].start);
break :blk .{ .start = loc, .end = loc };
},
};
const lens = CodeLens{ .allocator = allocator, .source = src, .filename = path };
try lens.printLens(loc);
term.eprintln("", .{});
}
}
if (opts.verbose.cst) {
try debug.printCst(allocator, parse_res.cst, token_kinds, spans, src);
}
} | fexc/src/main.zig |
const c = @cImport({
@cInclude("X11/Xlib.h");
@cDefine("XUTIL_DEFINE_FUNCTIONS", ""); // replace macros with functions
@cInclude("X11/Xutil.h");
// @cInclude("X11/Xatom.h");
});
const std = @import("std");
const draw = @import("pixel_draw.zig");
var main_allocator: *std.mem.Allocator = undefined;
// ===== Input =====
pub var mouse_pos_x: i32 = 0;
pub var mouse_pos_y: i32 = 0;
pub var is_mouse_on_window: bool = false;
pub var mouse_buttons_down = [_]bool{false} ** 8;
pub var mouse_buttons_up = [_]bool{false} ** 8;
pub var mouse_buttons_pressed = [_]bool{false} ** 8;
const keymap = [_]u32{
c.XK_q,
c.XK_w,
c.XK_e,
c.XK_r,
c.XK_a,
c.XK_s,
c.XK_d,
c.XK_1,
c.XK_2,
c.XK_3,
c.XK_4,
c.XK_5,
c.XK_6,
c.XK_7,
c.XK_8,
c.XK_9,
c.XK_0,
c.XK_Up,
c.XK_Down,
c.XK_Left,
c.XK_Right,
};
pub var keys_down = [_]bool{false} ** keymap.len;
pub var keys_up = [_]bool{false} ** keymap.len;
pub var keys_pressed = [_]bool{false} ** keymap.len;
pub var char_input_buffer: [4096]u8 = undefined;
pub var char_input_len: usize = 0;
// =================
pub fn plataformInit(
al: *std.mem.Allocator,
w_width: u32,
w_height: u32,
start_fn: fn () void,
update_fn: fn (f32) void,
) !void {
main_allocator = al;
draw.gb.width = w_width;
draw.gb.height = w_height;
const display = blk: {
if (c.XOpenDisplay(0)) |d| {
break :blk d;
} else {
return error.NoDisplayAvailable;
}
};
const root_window = c.XDefaultRootWindow(display);
const default_screen = c.XDefaultScreen(display);
const screen_bit_depth = 24;
var visual_info: c.XVisualInfo = undefined;
if (c.XMatchVisualInfo(display, default_screen, screen_bit_depth, c.TrueColor, &visual_info) == 0) {
return error.NoMatchingVisualInfo;
}
var window_attr: c.XSetWindowAttributes = undefined;
window_attr.bit_gravity = c.StaticGravity;
window_attr.background_pixel = 0;
window_attr.colormap = c.XCreateColormap(display, root_window, visual_info.visual, c.AllocNone);
window_attr.event_mask = c.StructureNotifyMask | c.KeyPressMask |
c.KeyReleaseMask | c.ButtonPressMask | c.ButtonReleaseMask;
const atrribute_mask: u64 = c.CWBitGravity | c.CWBackPixel | c.CWColormap | c.CWEventMask;
const window = c.XCreateWindow(display, root_window, 0, 0, draw.gb.width, draw.gb.height, 0, visual_info.depth, c.InputOutput, visual_info.visual, atrribute_mask, &window_attr);
if (window == 0) return error.UnableToCreateWindow;
if (c.XStoreName(display, window, "Hello") == 0) return error.ErrorInRenamingWindow;
// Init X input
if (false) {
const x_input_method = c.XOpenIM(display, null, 0, 0);
if (x_input_method == null) {
return error.InputMethodCouldNotBeOpened;
}
var styles: ?*c.XIMStyles = null;
if (c.XGetIMValues(x_input_method, c.XNQueryInputStyle, &styles) == 0 or styles == null) {
return error.InputStylesCouldNotBeRetrived;
}
var best_match_style: c.XIMStyle = 0;
var i: usize = 0;
while (i < styles.?.count_styles) : (i += 1) {
const this_style = styles.?.supported_styles[i];
if (this_style == (c.XIMPreeditNothing | c.XIMStatusNothing)) {
best_match_style = this_style;
break;
}
}
_ = c.XFree(styles);
}
if (c.XMapWindow(display, window) == 0) return error.ErrorMappingTheWindow;
if (c.XFlush(display) == 0) return error.ErrorFlushinTheDisplay;
var wm_delete_window = c.XInternAtom(display, "WM_DELETE_WINDOW", c.False);
if (c.XSetWMProtocols(display, window, &wm_delete_window, 1) == 0)
return error.CouldNotRegisterWmDeleteWindowProperty;
// Setup window buffer
const pixel_bits = 32;
const pixel_bytes = pixel_bits / 8;
try draw.gb.allocate(main_allocator, draw.gb.width, draw.gb.height);
var x_window_buffer = c.XCreateImage(display, visual_info.visual, @intCast(c_uint, visual_info.depth), c.ZPixmap, 0, draw.gb.screen.ptr, draw.gb.width, draw.gb.height, pixel_bits, 0);
var default_graphics_context = c.XDefaultGC(display, default_screen);
start_fn();
// var anim_offset: u32 = 0;
var delta: f32 = 0.0;
var initTime: i128 = 0;
// main looping
var size_has_changed = false;
var should_close = false;
while (!should_close) {
initTime = std.time.nanoTimestamp() - initTime;
delta = @floatCast(f32, @intToFloat(f64, initTime) / 1000000000);
initTime = std.time.nanoTimestamp();
// std.debug.print("{d:0.4} {d:0.4}\n", .{ 1.0 / delta, delta });
for (draw.gb.depth) |*it| it.* = std.math.inf_f32;
var event: c.XEvent = undefined;
// Reset inputs
for (mouse_buttons_down) |*it| it.* = false;
for (mouse_buttons_up) |*it| it.* = false;
for (keys_down) |*it| it.* = false;
for (keys_up) |*it| it.* = false;
{ // query pointer
var root_x: i32 = 0;
var root_y: i32 = 0;
var win_x: i32 = 0;
var win_y: i32 = 0;
var button_mask: u32 = 0;
var root_return: c.Window = undefined;
var win_return: c.Window = undefined;
_ = c.XQueryPointer(display, window, &root_return, &win_return, &root_x, &root_y, &win_x, &win_y, &button_mask);
// if (win_return == window) {
mouse_pos_x = @intCast(i32, win_x);
mouse_pos_y = @intCast(i32, win_y);
// }
}
// Event loop
while (c.XPending(display) > 0) {
_ = c.XNextEvent(display, &event);
switch (event.@"type") {
c.DestroyNotify => {
const e = @ptrCast(*c.XDestroyWindowEvent, &event);
if (e.window == window) should_close = true;
},
c.ClientMessage => {
const e = @ptrCast(*c.XClientMessageEvent, &event);
if (e.data.l[0] == wm_delete_window) {
// This is to avoid a anoing error message when closing the application
_ = c.XDestroyWindow(display, window);
should_close = true;
}
},
c.ConfigureNotify => {
const e = @ptrCast(*c.XConfigureEvent, &event);
const nwidth = @intCast(u32, e.width);
const nheight = @intCast(u32, e.height);
size_has_changed = true;
draw.gb.width = nwidth;
draw.gb.height = nheight;
},
c.KeyPress => {
const e = @ptrCast(*c.XKeyPressedEvent, &event);
const key = c.XKeycodeToKeysym(display, @intCast(u8, e.keycode), 0);
var char_buffer: [128]u8 = undefined;
var status: c.XComposeStatus = undefined;
char_buffer[0] = 0;
const char_buffer_len = @intCast(usize, c.XLookupString(e, char_buffer[0..], char_buffer.len, null, &status));
for (char_buffer[0..char_buffer_len]) |cr| {
if (char_input_len >= char_input_buffer.len) break;
char_input_buffer[char_input_len] = cr;
char_input_len += 1;
}
for (keys_down) |*it, i| {
if (keymap[i] == key) {
it.* = true;
keys_pressed[i] = true;
}
}
},
c.KeyRelease => {
const e = @ptrCast(*c.XKeyPressedEvent, &event);
const key = c.XKeycodeToKeysym(display, @intCast(u8, e.keycode), 0);
for (keys_up) |*it, i| {
if (keymap[i] == key) {
it.* = true;
keys_pressed[i] = false;
}
}
},
c.ButtonPress => {
const e = @ptrCast(*c.XButtonPressedEvent, &event);
if (e.button <= 7) {
mouse_buttons_down[@intCast(usize, e.button)] = true;
mouse_buttons_pressed[@intCast(usize, e.button)] = true;
}
},
c.ButtonRelease => {
const e = @ptrCast(*c.XButtonPressedEvent, &event);
if (e.button <= 7) {
mouse_buttons_up[@intCast(usize, e.button)] = true;
mouse_buttons_pressed[@intCast(usize, e.button)] = false;
}
},
else => {},
}
}
// Handle resizes
if (size_has_changed) {
size_has_changed = false;
// Free memory
try draw.gb.resize(main_allocator, draw.gb.width, draw.gb.height);
x_window_buffer = c.XCreateImage(
display,
visual_info.visual,
@intCast(c_uint, visual_info.depth),
c.ZPixmap,
0,
draw.gb.screen.ptr,
draw.gb.width,
draw.gb.height,
pixel_bits,
0,
);
}
update_fn(delta);
_ = c.XPutImage(display, window, default_graphics_context, x_window_buffer, 0, 0, 0, 0, draw.gb.width, draw.gb.height);
}
draw.gb.free(main_allocator);
} | src/xlib_plataform.zig |
//--------------------------------------------------------------------------------
// Section: Types (1)
//--------------------------------------------------------------------------------
pub const LicenseProtectionStatus = enum(i32) {
Success = 0,
LicenseKeyNotFound = 1,
LicenseKeyUnprotected = 2,
LicenseKeyCorrupted = 3,
LicenseKeyAlreadyExists = 4,
};
pub const Success = LicenseProtectionStatus.Success;
pub const LicenseKeyNotFound = LicenseProtectionStatus.LicenseKeyNotFound;
pub const LicenseKeyUnprotected = LicenseProtectionStatus.LicenseKeyUnprotected;
pub const LicenseKeyCorrupted = LicenseProtectionStatus.LicenseKeyCorrupted;
pub const LicenseKeyAlreadyExists = LicenseProtectionStatus.LicenseKeyAlreadyExists;
//--------------------------------------------------------------------------------
// Section: Functions (2)
//--------------------------------------------------------------------------------
pub extern "licenseprotection" fn RegisterLicenseKeyWithExpiration(
licenseKey: ?[*:0]const u16,
validityInDays: u32,
status: ?*LicenseProtectionStatus,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "licenseprotection" fn ValidateLicenseKeyProtection(
licenseKey: ?[*:0]const u16,
notValidBefore: ?*FILETIME,
notValidAfter: ?*FILETIME,
status: ?*LicenseProtectionStatus,
) 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 (3)
//--------------------------------------------------------------------------------
const FILETIME = @import("../foundation.zig").FILETIME;
const HRESULT = @import("../foundation.zig").HRESULT;
const PWSTR = @import("../foundation.zig").PWSTR;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/security/license_protection.zig |
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Computer = struct {
const Op = enum(u8) {
ADD = 0,
MUL = 1,
MIN = 2,
MAX = 3,
LIT = 4,
CGT = 5,
CLT = 6,
CEQ = 7,
};
bits: std.ArrayList(u1),
pos: usize,
sum_versions: usize,
result: usize,
pub fn init() Computer {
var self = Computer{
.bits = std.ArrayList(u1).init(allocator),
.pos = 0,
.sum_versions = 0,
.result = 0,
};
return self;
}
pub fn deinit(self: *Computer) void {
self.bits.deinit();
}
fn hex2int(c: u8) u8 {
if (c >= 'A' and c <= 'F') return c - 'A' + 10;
if (c >= 'a' and c <= 'f') return c - 'a' + 10;
if (c >= '0' and c <= '9') return c - '0';
unreachable;
}
pub fn process_line(self: *Computer, data: []const u8) !void {
for (data) |c| {
const n = hex2int(c);
try self.bits.append(if ((n & 8) > 0) 1 else 0);
try self.bits.append(if ((n & 4) > 0) 1 else 0);
try self.bits.append(if ((n & 2) > 0) 1 else 0);
try self.bits.append(if ((n & 1) > 0) 1 else 0);
}
self.result = self.decode_packet();
}
pub fn get_sum_of_versions(self: *Computer) !usize {
return self.sum_versions;
}
pub fn get_result(self: *Computer) !usize {
return self.result;
}
fn decode_packet(self: *Computer) usize {
const version = self.decode_bits(3);
const type_id = @intToEnum(Op, self.decode_bits(3));
// std.debug.warn("VERSION {}, TYPE_ID {}\n", .{ version, type_id });
self.sum_versions += version;
return self.decode_operator(type_id);
}
fn decode_operator(self: *Computer, op: Op) usize {
if (op == Op.LIT) {
return self.run_operator(0, op, 0);
}
const length_type_id = self.decode_bits(1);
if (length_type_id == 0) {
return self.decode_operator_bits(op, self.decode_bits(15));
} else {
return self.decode_operator_packets(op, self.decode_bits(11));
}
}
fn decode_operator_bits(self: *Computer, op: Op, length_in_bits: usize) usize {
var result: usize = std.math.maxInt(usize);
const target = self.pos + length_in_bits;
while (self.pos < target) {
result = self.run_operator(result, op, self.decode_packet());
}
return result;
}
fn decode_operator_packets(self: *Computer, op: Op, number_of_packets: usize) usize {
var result: usize = std.math.maxInt(usize);
var p: usize = 0;
while (p < number_of_packets) : (p += 1) {
result = self.run_operator(result, op, self.decode_packet());
}
return result;
}
fn run_operator(self: *Computer, before: usize, op: Op, value: usize) usize {
if (before == std.math.maxInt(usize)) {
return value;
}
return switch (op) {
Op.ADD => before + value,
Op.MUL => before * value,
Op.MIN => if (before < value) before else value,
Op.MAX => if (before > value) before else value,
Op.LIT => self.decode_literal(),
Op.CGT => if (before > value) @as(usize, 1) else @as(usize, 0),
Op.CLT => if (before < value) @as(usize, 1) else @as(usize, 0),
Op.CEQ => if (before == value) @as(usize, 1) else @as(usize, 0),
};
}
fn decode_literal(self: *Computer) usize {
var value: usize = 0;
while (true) {
const more = self.decode_bits(1);
const nibble = self.decode_bits(4);
value *= 16;
value += nibble;
// std.debug.warn("NIBBLE pos {} more {} value {} TOTAL {}\n", .{ self.pos, more, nibble, value });
if (more == 0) break;
}
return value;
}
fn decode_bits(self: *Computer, count: usize) usize {
var value: usize = 0;
var p: usize = 0;
while (p < count) : (p += 1) {
value *= 2;
value += self.bits.items[self.pos + p];
}
// std.debug.warn("BITS at {} len {} = {}\n", .{ self.pos, count, value });
self.pos += count;
return value;
}
};
test "sample part a small" {
const data: []const u8 =
\\D2FE28
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const sum = try computer.get_sum_of_versions();
try testing.expect(sum == 6);
}
test "sample part a bits" {
const data: []const u8 =
\\38006F45291200
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const sum = try computer.get_sum_of_versions();
try testing.expect(sum == 9);
}
test "sample part a packets" {
const data: []const u8 =
\\EE00D40C823060
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const sum = try computer.get_sum_of_versions();
try testing.expect(sum == 14);
}
test "sample part a 1" {
const data: []const u8 =
\\8A004A801A8002F478
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const sum = try computer.get_sum_of_versions();
try testing.expect(sum == 16);
}
test "sample part a 2" {
const data: []const u8 =
\\620080001611562C8802118E34
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const sum = try computer.get_sum_of_versions();
try testing.expect(sum == 12);
}
test "sample part a 3" {
const data: []const u8 =
\\C0015000016115A2E0802F182340
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const sum = try computer.get_sum_of_versions();
try testing.expect(sum == 23);
}
test "sample part a 4" {
const data: []const u8 =
\\A0016C880162017C3686B18A3D4780
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const sum = try computer.get_sum_of_versions();
try testing.expect(sum == 31);
}
test "sample part b 1" {
const data: []const u8 =
\\C200B40A82
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const result = try computer.get_result();
try testing.expect(result == 3);
}
test "sample part b 2" {
const data: []const u8 =
\\04005AC33890
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const result = try computer.get_result();
try testing.expect(result == 54);
}
test "sample part b 3" {
const data: []const u8 =
\\880086C3E88112
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const result = try computer.get_result();
try testing.expect(result == 7);
}
test "sample part b 4" {
const data: []const u8 =
\\CE00C43D881120
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const result = try computer.get_result();
try testing.expect(result == 9);
}
test "sample part b 5" {
const data: []const u8 =
\\D8005AC2A8F0
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const result = try computer.get_result();
try testing.expect(result == 1);
}
test "sample part b 6" {
const data: []const u8 =
\\F600BC2D8F
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const result = try computer.get_result();
try testing.expect(result == 0);
}
test "sample part b 7" {
const data: []const u8 =
\\9C005AC2F8F0
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const result = try computer.get_result();
try testing.expect(result == 0);
}
test "sample part b 8" {
const data: []const u8 =
\\9C0141080250320F1802104A08
;
var computer = Computer.init();
defer computer.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
try computer.process_line(line);
}
const result = try computer.get_result();
try testing.expect(result == 1);
} | 2021/p16/computer.zig |
const memory = @import("memory.zig");
const Allocator = memory.Allocator;
const MemoryError = memory.MemoryError;
const AllocError = memory.AllocError;
const FreeError = memory.FreeError;
const util = @import("utils");
const print = @import("print.zig");
const BlockStatus = enum(u2) {
Invalid = 0,
Split,
Free,
Used,
};
const Error = error {
WrongBlockStatus,
InternalError,
RequestedSizeTooSmall,
RequestedSizeTooLarge,
} || util.Error;
const FreeBlock = struct {
const ConstPtr = *allowzero const FreeBlock;
const Ptr = *allowzero FreeBlock;
prev: ?Ptr,
next: ?Ptr,
};
const min_size: usize = @sizeOf(FreeBlock);
pub fn BuddyAllocator(max_size_arg: usize) type {
return struct {
const Self = @This();
pub const max_size: usize = max_size_arg;
const max_level_block_count = max_size / min_size;
const level_count: usize = util.int_log2(usize, max_level_block_count) + 1;
const unique_block_count: usize = level_block_count(level_count);
const FreeBlocks = struct {
lists: [level_count]?FreeBlock.Ptr = undefined,
pub fn init(self: *FreeBlocks, start: usize) void {
for (self.lists) |*ptr| {
ptr.* = null;
}
self.push(0, @intToPtr(FreeBlock.Ptr, start)) catch unreachable;
}
pub fn get(self: *FreeBlocks, level: usize) Error!?FreeBlock.Ptr {
if (level >= level_count) {
return Error.OutOfBounds;
}
return self.lists[level];
}
pub fn push(self: *FreeBlocks, level: usize,
block: FreeBlock.Ptr) Error!void {
if (level >= level_count) {
return Error.OutOfBounds;
}
const current_maybe = self.lists[level];
if (current_maybe) |current| {
current.prev = block;
}
block.next = current_maybe;
block.prev = null;
self.lists[level] = block;
}
// TODO: Unused, is it even needed?
pub fn pop(self: *FreeBlocks, level: usize) Error!?FreeBlock.Ptr {
if (level >= level_count) {
return Error.OutOfBounds;
}
const current_maybe = self.lists[level];
if (current_maybe) |current| {
self.lists[level] = current.next;
if (current.next) |next| {
next.prev = null;
}
}
return current_maybe;
}
pub fn remove_block(self: *FreeBlocks, level: usize,
block: FreeBlock.ConstPtr) void {
if (block.prev) |prev| {
prev.next = block.next;
} else {
self.lists[level] = block.next;
}
if (block.next) |next| {
next.prev = block.prev;
}
}
};
allocator: Allocator = undefined,
start: usize = undefined,
free_blocks: FreeBlocks = undefined,
block_statuses: util.PackedArray(
BlockStatus, unique_block_count) = undefined,
pub fn init(self: *Self, area: []u8) Error!void {
self.allocator = Allocator{
.alloc_impl = alloc,
.free_impl = free,
};
if (area.len < max_size) {
return Error.NotEnoughDestination;
}
self.start = @ptrToInt(area.ptr);
self.free_blocks.init(self.start);
self.block_statuses.reset();
self.block_statuses.set(0, .Free) catch unreachable;
}
fn level_block_count(level: usize) usize {
return (@as(usize, 1) << @truncate(util.UsizeLog2Type, level)) - 1;
}
fn level_to_block_size(level: usize) usize {
return max_size >> @truncate(util.UsizeLog2Type, level);
}
fn size_to_level(size: usize) usize {
const target_size = util.max(usize, min_size, util.pow2_round_up(usize, size));
return level_count - util.int_log2(usize, target_size / min_size) - 1;
}
fn unique_id(level: usize, index: usize) usize {
return level_block_count(level) + index;
}
fn get_index(self: *const Self, level: usize,
address: FreeBlock.ConstPtr) usize {
return (@ptrToInt(address) - self.start) / level_to_block_size(level);
}
fn get_pointer(self: *const Self, level: usize,
index: usize) FreeBlock.Ptr {
return @intToPtr(FreeBlock.Ptr,
self.start + index * level_to_block_size(level));
}
fn get_buddy_index(index: usize) usize {
return if ((index % 2) == 1) (index - 1) else (index + 1);
}
fn assert_unique_id(self: *Self, level: usize, index: usize,
expected_status: BlockStatus) Error!usize {
const id = unique_id(level, index);
const status = try self.block_statuses.get(id);
if (status != expected_status) {
return Error.WrongBlockStatus;
}
return id;
}
fn split(self: *Self, level: usize, index: usize) Error!void {
const this_unique_id = try self.assert_unique_id(
level, index, .Free);
const this_ptr = self.get_pointer(level, index);
const new_level: usize = level + 1;
const new_index = index << 1;
const buddy_index = new_index + 1;
const buddy_ptr = self.get_pointer(new_level, buddy_index);
// Update Free Blocks
self.free_blocks.remove_block(level, this_ptr);
try self.free_blocks.push(new_level, buddy_ptr);
try self.free_blocks.push(new_level, this_ptr);
// Update Statuses
try self.block_statuses.set(this_unique_id, BlockStatus.Split);
try self.block_statuses.set(
unique_id(new_level, new_index), BlockStatus.Free);
try self.block_statuses.set(
unique_id(new_level, buddy_index), BlockStatus.Free);
}
pub fn alloc(allocator: *Allocator, size: usize, align_to: usize) AllocError![]u8 {
_ = align_to;
const self = @fieldParentPtr(Self, "allocator", allocator);
// TODO: Do we have to do something with align_to?
if (size > max_size) {
return AllocError.OutOfMemory;
}
const target_level = size_to_level(size);
// Figure out how many (if any) levels we need to split a block in
// to get a free block in our target level.
var address_maybe: ?FreeBlock.Ptr = null;
var level = target_level;
while (true) {
address_maybe = self.free_blocks.get(level) catch unreachable;
if (address_maybe != null) {
break;
}
if (level == 0) {
return AllocError.OutOfMemory;
}
level -= 1;
}
// If we need to split blocks, do that
var split_level = level;
while (split_level != target_level) {
self.split(split_level,
self.get_index(split_level, address_maybe.?))
catch unreachable;
split_level += 1;
address_maybe = self.free_blocks.get(split_level) catch unreachable;
if (address_maybe == null) {
unreachable;
}
}
// Reserve it
const address = address_maybe.?;
self.free_blocks.remove_block(target_level, address);
const index = self.get_index(target_level, address);
const id = unique_id(target_level, index);
self.block_statuses.set(id, .Used) catch unreachable;
return @ptrCast([*]u8, address)[0..size];
}
fn merge(self: *Self, level: usize, index: usize) Error!void {
if (level == 0) {
return Error.OutOfBounds;
}
const buddy_index = get_buddy_index(index);
const new_level = level - 1;
const new_index = index >> 1;
// Assert existing blocks are free and new/parent block is split
const this_unique_id = try self.assert_unique_id(level, index, .Free);
const buddy_unique_id = try self.assert_unique_id(level, buddy_index, .Free);
const new_unique_id = try self.assert_unique_id(new_level, new_index, .Split);
// Remove pointers to the old blocks
const this_ptr = self.get_pointer(level, index);
const buddy_ptr = self.get_pointer(level, buddy_index);
self.free_blocks.remove_block(level, this_ptr);
self.free_blocks.remove_block(level, buddy_ptr);
// Push New Block into List
try self.free_blocks.push(new_level, self.get_pointer(new_level, new_index));
// Set New Statuses
try self.block_statuses.set(this_unique_id, .Invalid);
try self.block_statuses.set(buddy_unique_id, .Invalid);
try self.block_statuses.set(new_unique_id, .Free);
}
fn free(allocator: *Allocator, value: []const u8, aligned_to: usize) FreeError!void {
_ = aligned_to;
const self = @fieldParentPtr(Self, "allocator", allocator);
// TODO: Check aligned_to makes sense?
if (value.len > max_size) return FreeError.InvalidFree;
const address = @ptrToInt(value.ptr);
const block = @intToPtr(FreeBlock.Ptr, address);
if (value.len > 0) {
const level = size_to_level(value.len);
const index = self.get_index(level, block);
const id = unique_id(level, index);
const status = self.block_statuses.get(id) catch unreachable;
if (status != .Used) {
print.format(
"Error: BuddyAllocator.free will return InvalidFree for {:a} " ++
"size {} because its block at level {} index {} has status {}\n",
.{address, value.len, level, index, status});
}
}
// else if it's zero-sized then it probably came from something like C
// free where we don't get the size.
// Find the level
var level = level_count - 1;
var id_maybe: ?usize = null;
var index: usize = undefined;
while (id_maybe == null) {
index = self.get_index(level, block);
if (self.assert_unique_id(level, index, .Used)) |i| {
id_maybe = i;
} else |e| switch (e) {
Error.WrongBlockStatus => {
if (level == 0) {
break;
}
level -= 1;
},
else => unreachable,
}
}
if (id_maybe == null) {
return FreeError.InvalidFree;
}
const id = id_maybe.?;
// Insert Block into List and Mark as Free
self.free_blocks.push(level, block) catch unreachable;
self.block_statuses.set(id, .Free) catch unreachable;
// Merge Until Buddy isn't Free or Level Is 0
while (level > 0) {
const buddy_index = get_buddy_index(index);
const buddy_unique_id = unique_id(level, buddy_index);
const buddy_status = self.block_statuses.get(buddy_unique_id)
catch unreachable;
if (buddy_status == .Free) {
self.merge(level, index) catch unreachable;
index >>= 1;
} else {
break;
}
level -= 1;
}
}
};
}
const List = @import("list.zig").List;
const AllocList = List([]u8);
fn test_helper(
a: *Allocator, al: *AllocList, size: usize, fill: u8) MemoryError!void {
const s = try a.alloc_array(u8, size);
for (s) |*e| e.* = fill;
try al.push_front(s);
}
test "BuddyAllocator" {
const std = @import("std");
const ptr_size = util.int_bit_size(usize);
const free_pointer_size: usize = switch (ptr_size) {
32 => @as(usize, 8),
64 => @as(usize, 16),
else => unreachable,
};
try std.testing.expectEqual(free_pointer_size, @sizeOf(?FreeBlock.Ptr));
try std.testing.expectEqual(free_pointer_size * 2, min_size);
const size: usize = 128;
const ABuddyAllocator = BuddyAllocator(size);
const expected_level_count: usize = switch (ptr_size) {
32 => @as(usize, 4),
64 => @as(usize, 3),
else => unreachable,
};
try std.testing.expectEqual(
expected_level_count, ABuddyAllocator.level_count);
var b = ABuddyAllocator{};
var m: [size]u8 = undefined;
try b.init(m[0..]);
const a = &b.allocator;
var al_alloc = memory.UnitTestAllocator{};
al_alloc.init();
defer al_alloc.done();
var al = AllocList{.alloc = &al_alloc.allocator};
try test_helper(a, &al, @as(usize, 32), @as(u8, 0x01));
try test_helper(a, &al, @as(usize, 32), @as(u8, 0x04));
try test_helper(a, &al, @as(usize, 64), @as(u8, 0xff));
try std.testing.expectEqualSlices(u8,
"\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01" ++
"\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01" ++
"\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04" ++
"\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04" ++
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" ++
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" ++
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" ++
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
m[0..]);
try a.free_array((try al.pop_front()).?);
const byte: u8 = 0xaa;
try test_helper(a, &al, @as(usize, 1), byte);
try std.testing.expectEqual(byte, m[32 * 2]);
try a.free_array((try al.pop_front()).?);
try test_helper(a, &al, @as(usize, 32), @as(u8, 0x88));
try test_helper(a, &al, @as(usize, 32), @as(u8, 0x77));
try std.testing.expectEqualSlices(u8,
"\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01" ++
"\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01" ++
"\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04" ++
"\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04" ++
"\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88" ++
"\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88" ++
"\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77" ++
"\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77\x77",
m[0..]);
while (try al.pop_front()) |slice| {
try a.free_array(slice);
}
} | kernel/buddy_allocator.zig |
const std = @import("std");
const Url = @import("url.zig").Url;
const net = std.net;
const Allocator = std.mem.Allocator;
/// Sends a GET request to the given url.
/// Returns a `Response` that contains the statuscode, headers and body.
pub fn get(gpa: *Allocator, url: []const u8) !Response {
const endpoint = try Url.init(url);
// build our request header
var buf: [4096]u8 = undefined;
const get_string = try std.fmt.bufPrint(&buf, "GET {s} HTTP/1.1\r\nHOST: {s}\r\nConnection: close\r\n\r\n", .{
endpoint.path,
endpoint.host,
});
const socket = try net.tcpConnectToHost(gpa, endpoint.host, endpoint.port);
defer socket.close();
_ = try socket.write(get_string);
var parser = HttpParser.init(gpa);
return parser.parse(socket.reader());
}
pub const ParseError = error{NoStatusCode};
/// Http header with a `name` and `value`
pub const Header = struct {
name: []const u8,
value: []const u8,
};
/// Http Response that contains the statuscode, headers and body of a Http request.
/// deinit must be called to free its memory
pub const Response = struct {
status_code: []const u8,
headers: []Header,
body: []const u8,
gpa: *Allocator,
fn deinit(self: @This()) void {
self.gpa.free(self.status_code);
self.gpa.free(self.headers);
self.gpa.free(self.body);
}
};
/// HttpParser can parse Http responses into a `Response` object.
/// It takes in an `io.InStream` and parses each line seperately.
/// Note that deinit has to be called on the response provided by `parse` to free the memory.
/// Currently the implementation is fairly basic and it parses most values as 'strings' such as the status code.
pub const HttpParser = struct {
const Self = @This();
state: State,
gpa: *Allocator,
/// State of the `HttpParser`
const State = enum {
status_code,
header,
body,
};
fn init(gpa: *Allocator) Self {
return Self{ .gpa = gpa, .state = .status_code };
}
/// parse accepts an `io.Reader`, it will read all data it contains
/// and tries to parse it into a `Response`. Can return `ParseError` if data is corrupt
fn parse(self: *Self, reader: anytype) !Response {
var response: Response = undefined;
response.gpa = self.gpa;
// per line we accept 4Kb, this should be enough
var buffer: [4096]u8 = undefined;
var headers = std.ArrayList(Header).init(self.gpa);
errdefer headers.deinit(); // only deinit on errors as it is done automatically by toOwnedSlice()
var body = std.ArrayList([]const u8).init(self.gpa);
errdefer body.deinit();
// read stream until end of file, parse each line
while (try reader.readUntilDelimiterOrEof(&buffer, '\n')) |bytes| {
switch (self.state) {
.status_code => {
response.status_code = parseStatusCode(self.gpa, bytes) catch |err| return err;
self.state = .header;
},
.header => {
// read until all headers are parsed, if null is returned, assume data has started
// and set the current state to .Data
if (try parseHeader(self.gpa, bytes)) |header| {
try headers.append(header);
} else {
self.state = .body;
}
},
.body => {
const data = try parseData(self.gpa, bytes);
try body.append(data);
},
}
}
response.headers = headers.toOwnedSlice();
response.body = try std.mem.join(self.gpa, "\n", body.toOwnedSlice());
return response;
}
/// Attempts to retrieve the statuscode from given bytes, returns an error if no statuscode is found
fn parseStatusCode(gpa: *Allocator, bytes: []u8) ![]const u8 {
var parts = std.mem.split(bytes, " ");
// skip first part
if (parts.next() == null) return ParseError.NoStatusCode;
// copy code part into buffer
if (parts.next()) |code| {
const buf = try gpa.alloc(u8, code.len);
std.mem.copy(u8, buf, code);
return buf;
} else {
return error.NoStatusCode;
}
}
/// Attempts to parse a line into a header, returns `null` if no header is found
fn parseHeader(allocator: *Allocator, bytes: []u8) !?Header {
if (bytes.len == 0 or bytes[0] == 13) return null;
var header: Header = undefined;
// each header is defined by "name: value"
var parts = std.mem.split(bytes, ": ");
if (parts.next()) |name| {
var buf = try allocator.alloc(u8, name.len);
std.mem.copy(u8, buf, name);
header.name = buf;
} else {
// no name found, free memory and return null so we can parse data
// allocator.free(header);
return null;
}
if (parts.next()) |val| {
var buf = try allocator.alloc(u8, val.len);
std.mem.copy(u8, buf, val);
header.value = buf;
}
return header;
}
/// Simply copies the data in an allocated buffer so we can keep a reference to it
fn parseData(allocator: *Allocator, bytes: []u8) ![]const u8 {
var buf = try allocator.alloc(u8, bytes.len);
std.mem.copy(u8, buf, bytes);
return buf;
}
}; | src/net/http.zig |
const std = @import("std");
const redis = @import("okredis");
const version = @import("version");
const zzz = @import("zzz");
const tar = @import("tar");
usingnamespace @import("common.zig");
const GET = redis.commands.strings.GET;
const SET = redis.commands.strings.SET;
const FV = redis.commands.hashes.utils.FV;
const SADD = redis.commands.sets.SADD;
const SISMEMBER = redis.commands.sets.SISMEMBER;
const OrErr = redis.types.OrErr;
const FixBuf = redis.types.FixBuf;
const HSET = redis.commands.hashes.HSET;
const optional_fields = [_][]const u8{
"description",
"homepage_url",
"source_url",
"license",
};
pub fn serializeDepsToJson(
arena: *std.heap.ArenaAllocator,
root: *zzz.ZNode,
tag: []const u8,
) !std.ArrayList([]const u8) {
var ret = std.ArrayList([]const u8).init(&arena.allocator);
if (zFindChild(root, tag)) |deps_node| {
var it = ZChildIterator.init(deps_node);
const stdout = std.io.getStdOut().writer();
while (it.next()) |child_node| {
const src_node = zFindChild(child_node, "src") orelse return error.NoSrcTag;
const type_node = src_node.*.child orelse return error.NoSrcType;
const type_str = try zGetString(type_node);
var fifo = std.fifo.LinearFifo(u8, .{ .Dynamic = {} }).init(&arena.allocator);
var json = std.json.writeStream(fifo.writer(), 4);
json.whitespace = .{
.indent = .{ .Space = 0 },
.separator = false,
};
try json.beginObject();
try json.objectField(type_str);
if (std.mem.eql(u8, "pkg", type_str)) {
try json.beginObject();
try json.objectField("repository");
try json.emitString((try zFindString(type_node, "repository")) orelse return error.NoRepository);
try json.objectField("user");
try json.emitString((try zFindString(type_node, "user")) orelse return error.NoUser);
try json.objectField("name");
try json.emitString((try zFindString(type_node, "name")) orelse return error.NoName);
try json.objectField("version");
try json.emitString((try zFindString(type_node, "version")) orelse return error.NoVersion);
try json.endObject();
} else if (std.mem.eql(u8, "github", type_str)) {
try json.beginObject();
try json.objectField("repo");
try json.emitString((try zFindString(type_node, "repo")) orelse return error.NoRepo);
try json.objectField("user");
try json.emitString((try zFindString(type_node, "user")) orelse return error.NoUser);
try json.objectField("ref");
try json.emitString((try zFindString(type_node, "ref")) orelse return error.NoRef);
try json.endObject();
} else if (std.mem.eql(u8, "url", type_str)) {
try json.emitString(try zGetString(type_node.*.child orelse return error.NoUrl));
} else return error.InvalidTag;
try json.endObject();
// have to do replacement because the stream writer doesn't minify correctly
try ret.append(try std.mem.replaceOwned(u8, &arena.allocator, fifo.readableSlice(0), "\n", ""));
}
}
return ret;
}
pub fn main() !void {
var args = std.process.args();
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = &arena.allocator;
_ = args.nextPosix();
const username = args.nextPosix() orelse return error.NoUsername;
const path = args.nextPosix() orelse return error.NoPath;
var client: redis.Client = undefined;
try client.init(try std.net.connectUnixSocket("/var/run/redis/redis.sock"));
defer client.close();
const file = try std.fs.cwd().openFile(path, .{});
defer file.close();
var gzip = try std.compress.gzip.gzipStream(allocator, file.reader());
defer gzip.deinit();
var extractor = tar.fileExtractor("manifest.zzz", gzip.reader());
const text = try extractor.reader().readAllAlloc(allocator, std.math.maxInt(usize));
var tree = zzz.ZTree(1, 1000){};
var root = try tree.appendText(text);
const deps = try serializeDepsToJson(&arena, root, "deps");
const build_deps = try serializeDepsToJson(&arena, root, "build_deps");
var tags = std.ArrayList([]const u8).init(allocator);
if (zFindChild(root, "tags")) |tags_node| {
var it = ZChildIterator.init(tags_node);
while (it.next()) |tag_node| try tags.append(try zGetString(tag_node));
}
// required fields
const name = (try zFindString(root, "name")) orelse return error.NoName;
const semver_str = (try zFindString(root, "version")) orelse return error.NoVersion;
const semver = try version.Semver.parse(semver_str);
// check if it exists
const versions_key = try std.fmt.allocPrint(allocator, "user:{s}:pkg:{s}", .{
username, name,
});
if ((try client.send(usize, SISMEMBER.init(versions_key, semver_str))) > 0) {
std.log.err("'{s}/{s}' {} is already published", .{ username, name, semver });
return error.AlreadyPublished;
}
// is it the latest?
const latest_key = try std.fmt.allocPrint(allocator, "{s}:latest", .{versions_key});
const latest_str: ?FixBuf(5) = switch (try client.send(OrErr(FixBuf(5)), GET.init(latest_key))) {
.Ok => |val| val,
.Nil => null,
.Err => return error.Redis,
};
const publishing_latest = if (latest_str) |str| switch (semver.cmp(try version.Semver.parse(str.toSlice()))) {
.lt => false,
.gt => true,
.eq => {
std.log.err("'{s}/{s}' {} is already published", .{ username, name, semver });
return error.AlreadyPublished;
},
} else true;
var fields = std.ArrayList(FV).init(allocator);
inline for (optional_fields) |field| {
if (try zFindString(root, field)) |value| try fields.append(.{ .field = field, .value = value });
}
try fields.append(.{ .field = "downloads", .value = "0" });
const current_key = try std.fmt.allocPrint(allocator, "{s}:{}", .{
versions_key, semver,
});
const keys = .{
.pkg = current_key,
.versions = versions_key,
.tags = try std.fmt.allocPrint(allocator, "{s}:tags", .{current_key}),
.deps = try std.fmt.allocPrint(allocator, "{s}:deps", .{current_key}),
.build_deps = try std.fmt.allocPrint(allocator, "{s}:build_deps", .{
current_key,
}),
};
// TODO: do proper cleanup on error
const reply = try client.trans(struct {
pkg: OrErr(void),
versions: OrErr(void),
}, .{
HSET.init(keys.pkg, fields.items),
SADD.init(keys.versions, &[_][]const u8{semver_str}),
});
errdefer {
inline for (std.meta.fields(@TypeOf(reply))) |field| {
if (@field(reply, field.name) == .Ok) {
std.log.debug("removing {s}", .{field.name});
client.send(void, .{ "DEL", @field(keys, field.name) }) catch {};
}
}
}
inline for (std.meta.fields(@TypeOf(reply))) |field| {
if (@field(reply, field.name) != .Ok) {
std.log.err("issue with {s}", .{field.name});
return error.Redis;
}
}
if (tags.items.len > 0)
try client.send(void, SADD.init(keys.tags, tags.items));
errdefer client.send(void, .{ "DEL", keys.tags }) catch {};
if (deps.items.len > 0)
try client.send(void, SADD.init(keys.deps, deps.items));
errdefer client.send(void, .{ "DEL", keys.deps }) catch {};
if (build_deps.items.len > 0)
try client.send(void, SADD.init(keys.build_deps, build_deps.items));
errdefer client.send(void, .{ "DEL", keys.build_deps }) catch {};
var old_version: ?FixBuf(5) = if (publishing_latest) blk: {
const ret: ?FixBuf(5) = switch (try client.send(OrErr(FixBuf(5)), GET.init(latest_key))) {
.Ok => |val| val,
.Nil => null,
.Err => return error.OldLatest,
};
try client.send(void, SET.init(latest_key, semver_str, .NoExpire, .NoConditions));
break :blk ret;
} else null;
errdefer if (publishing_latest) {
if (old_version) |ver|
client.send(void, SET.init(latest_key, ver.toSlice(), .NoExpire, .NoConditions)) catch {}
else
client.send(void, .{ "DEL", latest_key }) catch {};
};
const package_id = try std.fmt.allocPrint(allocator, "{s}/{s}", .{ username, name });
for (tags.items) |tag| {
const tag_key = try std.fmt.allocPrint(allocator, "tag:{s}", .{tag});
try client.send(void, SADD.init(tag_key, &[_][]const u8{package_id}));
}
// TODO: rollback
try client.send(void, SADD.init("pkgs", &[_][]const u8{package_id}));
const user_pkgs_key = try std.fmt.allocPrint(allocator, "user:{s}:pkgs", .{username});
try client.send(void, SADD.init(user_pkgs_key, &[_][]const u8{name}));
// move file
const user_path = try std.fs.path.join(allocator, &[_][]const u8{ "/var/www/archive", username });
var user_dir = try std.fs.openDirAbsolute(user_path, .{});
defer user_dir.close();
var dst_dir = try user_dir.makeOpenPath(try std.fs.path.join(allocator, &[_][]const u8{ user_path, name }), .{});
defer dst_dir.close();
try std.fs.cwd().copyFile(path, dst_dir, semver_str, .{});
std.log.info("published {s} {}", .{ package_id, semver });
} | src/publish.zig |
const builtin = @import("builtin");
const std = @import("std");
const assert = std.debug.assert;
const os = @import("windows/windows.zig");
const dxgi = @import("windows/dxgi.zig");
const dcommon = @import("windows/dcommon.zig");
const d3d12 = @import("windows/d3d12.zig");
const d3d11 = @import("windows/d3d11.zig");
const d2d1 = @import("windows/d2d1.zig");
const dwrite = @import("windows/dwrite.zig");
const wincodec = @import("windows/wincodec.zig");
const vhr = os.vhr;
const releaseCom = os.releaseCom;
const num_frames = 3;
const num_swapbuffers = 3;
const num_rtv_descriptors = 128;
const num_dsv_descriptors = 128;
const num_cbv_srv_uav_cpu_descriptors = 16 * 1024;
const num_cbv_srv_uav_gpu_descriptors = 4 * 1024;
const max_num_resources = 256;
const max_num_pipelines = 128;
const upload_heaps_capacity = 8 * 1024 * 1024;
pub const DxContext = struct {
wic_factory: *wincodec.IImagingFactory,
device: *d3d12.IDevice,
cmdlist: *d3d12.IGraphicsCommandList,
cmdqueue: *d3d12.ICommandQueue,
cmdallocs: [num_frames]*d3d12.ICommandAllocator,
swapchain: *dxgi.ISwapChain3,
swapbuffers: [num_swapbuffers]ResourceHandle,
rtv_heap: DescriptorHeap,
dsv_heap: DescriptorHeap,
cbv_srv_uav_cpu_heap: DescriptorHeap,
cbv_srv_uav_gpu_heaps: [num_frames]DescriptorHeap,
upload_memory_heaps: [num_frames]GpuMemoryHeap,
frame_fence: *d3d12.IFence,
frame_fence_event: os.HANDLE,
frame_fence_counter: u64 = 0,
frame_index: u32 = 0,
back_buffer_index: u32 = 0,
resource_pool: ResourcePool,
pipeline: struct {
pool: PipelinePool,
map: std.AutoHashMap(u32, PipelineHandle),
current: PipelineHandle,
},
num_resource_barriers: u32 = 0,
buffered_resource_barriers: []d3d12.RESOURCE_BARRIER,
viewport_width: u32,
viewport_height: u32,
window: os.HWND,
d2d: struct {
factory: *d2d1.IFactory7,
device: *d2d1.IDevice6,
context: *d2d1.IDeviceContext6,
device11on12: *d3d11.I11On12Device,
device11: *d3d11.IDevice,
context11: *d3d11.IDeviceContext,
wrapped_swapbuffers: [num_swapbuffers]*d3d11.IResource,
targets: [num_swapbuffers]*d2d1.IBitmap1,
dwrite_factory: *dwrite.IFactory,
},
allocator: *std.mem.Allocator,
pub fn init(allocator: *std.mem.Allocator, window: os.HWND) DxContext {
dxgi.init();
d3d11.init();
d3d12.init();
d2d1.init();
dwrite.init();
os.vhr(os.CoInitialize(null));
var wic_factory: *wincodec.IImagingFactory = undefined;
os.vhr(os.CoCreateInstance(
&wincodec.CLSID_ImagingFactory,
null,
os.CLSCTX_INPROC_SERVER,
&wincodec.IID_IImagingFactory,
@ptrCast(**c_void, &wic_factory),
));
var rect: os.RECT = undefined;
_ = os.GetClientRect(window, &rect);
const viewport_width = @intCast(u32, rect.right - rect.left);
const viewport_height = @intCast(u32, rect.bottom - rect.top);
var factory: *dxgi.IFactory4 = undefined;
vhr(dxgi.CreateFactory2(
if (comptime builtin.mode == .Debug) dxgi.CREATE_FACTORY_DEBUG else 0,
&dxgi.IID_IFactory4,
@ptrCast(**c_void, &factory),
));
if (comptime builtin.mode == .Debug) {
var debug: *d3d12.IDebug1 = undefined;
if (d3d12.GetDebugInterface(&d3d12.IID_IDebug1, @ptrCast(**c_void, &debug)) == 0) {
debug.EnableDebugLayer();
debug.SetEnableGPUBasedValidation(os.TRUE);
releaseCom(&debug);
}
}
var device: *d3d12.IDevice = undefined;
vhr(d3d12.CreateDevice(
null,
dcommon.FEATURE_LEVEL._11_1,
&d3d12.IID_IDevice,
@ptrCast(**c_void, &device),
));
if (comptime builtin.mode == .Debug) {
// Hide some D3D12 Debug Layer warnings.
var info_queue: *d3d12.IInfoQueue = undefined;
if (device.QueryInterface(&d3d12.IID_IInfoQueue, @ptrCast(**c_void, &info_queue)) == 0) {
defer releaseCom(&info_queue);
var hide = [_]d3d12.MESSAGE_ID{
.CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE,
};
vhr(info_queue.AddStorageFilterEntries(&d3d12.INFO_QUEUE_FILTER{
.AllowList = .{
.NumCategories = 0,
.pCategoryList = null,
.NumSeverities = 0,
.pSeverityList = null,
.NumIDs = 0,
.pIDList = null,
},
.DenyList = .{
.NumCategories = 0,
.pCategoryList = null,
.NumSeverities = 0,
.pSeverityList = null,
.NumIDs = hide.len,
.pIDList = &hide,
},
}));
}
}
var cmdqueue: *d3d12.ICommandQueue = undefined;
vhr(device.CreateCommandQueue(
&d3d12.COMMAND_QUEUE_DESC{
.Type = .DIRECT,
.Priority = @enumToInt(d3d12.COMMAND_QUEUE_PRIORITY.NORMAL),
.Flags = .NONE,
.NodeMask = 0,
},
&d3d12.IID_ICommandQueue,
@ptrCast(**c_void, &cmdqueue),
));
var temp_swapchain: *os.IUnknown = undefined;
vhr(factory.CreateSwapChain(
@ptrCast(*os.IUnknown, cmdqueue),
&dxgi.SWAP_CHAIN_DESC{
.BufferDesc = dxgi.MODE_DESC{
.Width = viewport_width,
.Height = viewport_height,
.RefreshRate = dxgi.RATIONAL{
.Numerator = 0,
.Denominator = 0,
},
.Format = .R8G8B8A8_UNORM,
.ScanlineOrdering = .UNSPECIFIED,
.Scaling = .UNSPECIFIED,
},
.SampleDesc = dxgi.SAMPLE_DESC{
.Count = 1,
.Quality = 0,
},
.BufferUsage = dxgi.USAGE_RENDER_TARGET_OUTPUT,
.BufferCount = num_swapbuffers,
.OutputWindow = window,
.Windowed = os.TRUE,
.SwapEffect = .FLIP_DISCARD,
.Flags = 0,
},
&temp_swapchain,
));
var swapchain: *dxgi.ISwapChain3 = undefined;
vhr(temp_swapchain.QueryInterface(&dxgi.IID_ISwapChain3, @ptrCast(**c_void, &swapchain)));
releaseCom(&temp_swapchain);
releaseCom(&factory);
var device11: *d3d11.IDevice = undefined;
var device_context11: *d3d11.IDeviceContext = undefined;
vhr(d3d11.Create11On12Device(
@ptrCast(*os.IUnknown, device),
if (comptime builtin.mode == .Debug)
.{ .DEBUG = true, .BGRA_SUPPORT = true }
else
.{ .BGRA_SUPPORT = true },
null,
0,
&[_]*os.IUnknown{@ptrCast(*os.IUnknown, cmdqueue)},
1,
0,
&device11,
&device_context11,
null,
));
var device11on12: *d3d11.I11On12Device = undefined;
vhr(device11.QueryInterface(&d3d11.IID_I11On12Device, @ptrCast(**c_void, &device11on12)));
var dxgi_device: *dxgi.IDevice = undefined;
vhr(device11on12.QueryInterface(&dxgi.IID_IDevice, @ptrCast(**c_void, &dxgi_device)));
defer releaseCom(&dxgi_device);
var d2d_factory: *d2d1.IFactory7 = undefined;
vhr(d2d1.CreateFactory(
.SINGLE_THREADED,
&d2d1.IID_IFactory7,
if (comptime builtin.mode == .Debug)
&d2d1.FACTORY_OPTIONS{ .debugLevel = .INFORMATION }
else
&d2d1.FACTORY_OPTIONS{ .debugLevel = .NONE },
@ptrCast(**c_void, &d2d_factory),
));
var d2d_device: *d2d1.IDevice6 = undefined;
vhr(d2d_factory.CreateDevice6(dxgi_device, &d2d_device));
var d2d_device_context: *d2d1.IDeviceContext6 = undefined;
vhr(d2d_device.CreateDeviceContext6(.{}, &d2d_device_context));
var dwrite_factory: *dwrite.IFactory = undefined;
vhr(dwrite.CreateFactory(.SHARED, &dwrite.IID_IFactory, @ptrCast(**c_void, &dwrite_factory)));
var frame_fence: *d3d12.IFence = undefined;
vhr(device.CreateFence(0, .NONE, &d3d12.IID_IFence, @ptrCast(**c_void, &frame_fence)));
const frame_fence_event = os.CreateEventEx(
null,
"frame_fence_event",
0,
os.EVENT_ALL_ACCESS,
) catch unreachable;
var cmdallocs: [num_frames]*d3d12.ICommandAllocator = undefined;
for (cmdallocs) |*cmdalloc| {
vhr(device.CreateCommandAllocator(
.DIRECT,
&d3d12.IID_ICommandAllocator,
@ptrCast(**c_void, &cmdalloc.*),
));
}
var rtv_heap = DescriptorHeap.init(device, num_rtv_descriptors, .RTV, .NONE);
var dsv_heap = DescriptorHeap.init(device, num_dsv_descriptors, .DSV, .NONE);
var cbv_srv_uav_cpu_heap = DescriptorHeap.init(
device,
num_cbv_srv_uav_cpu_descriptors,
.CBV_SRV_UAV,
.NONE,
);
var cbv_srv_uav_gpu_heaps: [num_frames]DescriptorHeap = undefined;
for (cbv_srv_uav_gpu_heaps) |*heap| {
heap.* = DescriptorHeap.init(
device,
num_cbv_srv_uav_gpu_descriptors,
.CBV_SRV_UAV,
.SHADER_VISIBLE,
);
}
var upload_memory_heaps: [num_frames]GpuMemoryHeap = undefined;
for (upload_memory_heaps) |*heap| {
heap.* = GpuMemoryHeap.init(device, upload_heaps_capacity, .UPLOAD);
}
var resource_pool = ResourcePool.init();
var pipeline_pool = PipelinePool.init();
// First 'num_swapbuffers' slots in 'rtv_heap' contain swapbuffer descriptors.
var swapbuffers: [num_swapbuffers]ResourceHandle = undefined;
var wrapped_swapbuffers: [num_swapbuffers]*d3d11.IResource = undefined;
var d2d_targets: [num_swapbuffers]*d2d1.IBitmap1 = undefined;
{
var handle = rtv_heap.allocateDescriptors(num_swapbuffers).cpu_handle;
for (swapbuffers) |*swapbuffer, buffer_idx| {
var buffer: *d3d12.IResource = undefined;
vhr(swapchain.GetBuffer(
@intCast(u32, buffer_idx),
&d3d12.IID_IResource,
@ptrCast(**c_void, &buffer),
));
swapbuffer.* = resource_pool.addResource(buffer, .{}, .R8G8B8A8_UNORM);
device.CreateRenderTargetView(buffer, null, handle);
handle.ptr += rtv_heap.descriptor_size;
vhr(device11on12.CreateWrappedResource(
@ptrCast(*os.IUnknown, buffer),
&d3d11.RESOURCE_FLAGS_11ON12{},
.{ .RENDER_TARGET = true },
.{}, // We want out state to be .PRESENT
&d3d11.IID_IResource,
@ptrCast(**c_void, &wrapped_swapbuffers[buffer_idx]),
));
var surface: *dxgi.ISurface = undefined;
vhr(wrapped_swapbuffers[buffer_idx].QueryInterface(
&dxgi.IID_ISurface,
@ptrCast(**c_void, &surface),
));
defer releaseCom(&surface);
vhr(d2d_device_context.CreateBitmapFromDxgiSurface(
surface,
&d2d1.BITMAP_PROPERTIES1{
.pixelFormat = .{ .format = .R8G8B8A8_UNORM, .alphaMode = .PREMULTIPLIED },
.dpiX = 96.0,
.dpiY = 96.0,
.bitmapOptions = .{ .TARGET = true, .CANNOT_DRAW = true },
},
&d2d_targets[buffer_idx],
));
}
}
var cmdlist: *d3d12.IGraphicsCommandList = undefined;
vhr(device.CreateCommandList(
0,
.DIRECT,
cmdallocs[0],
null,
&d3d12.IID_IGraphicsCommandList,
@ptrCast(**c_void, &cmdlist),
));
vhr(cmdlist.Close());
return DxContext{
.wic_factory = wic_factory,
.device = device,
.cmdlist = cmdlist,
.cmdqueue = cmdqueue,
.cmdallocs = cmdallocs,
.swapchain = swapchain,
.swapbuffers = swapbuffers,
.rtv_heap = rtv_heap,
.dsv_heap = dsv_heap,
.cbv_srv_uav_cpu_heap = cbv_srv_uav_cpu_heap,
.cbv_srv_uav_gpu_heaps = cbv_srv_uav_gpu_heaps,
.upload_memory_heaps = upload_memory_heaps,
.frame_fence = frame_fence,
.frame_fence_event = frame_fence_event,
.resource_pool = resource_pool,
.pipeline = .{
.pool = pipeline_pool,
.map = std.AutoHashMap(u32, PipelineHandle).init(allocator),
.current = PipelineHandle{ .index = 0, .generation = 0 },
},
.buffered_resource_barriers = allocator.alloc(
d3d12.RESOURCE_BARRIER,
32,
) catch unreachable,
.viewport_width = viewport_width,
.viewport_height = viewport_height,
.window = window,
.d2d = .{
.factory = d2d_factory,
.device = d2d_device,
.context = d2d_device_context,
.device11on12 = device11on12,
.device11 = device11,
.context11 = device_context11,
.wrapped_swapbuffers = wrapped_swapbuffers,
.targets = d2d_targets,
.dwrite_factory = dwrite_factory,
},
.allocator = allocator,
};
}
pub fn deinit(dx: *DxContext) void {
waitForGpu(dx);
dx.allocator.free(dx.buffered_resource_barriers);
for (dx.d2d.wrapped_swapbuffers) |*buffer| {
releaseCom(&buffer.*);
}
for (dx.d2d.targets) |*target| {
releaseCom(&target.*);
}
releaseCom(&dx.wic_factory);
releaseCom(&dx.d2d.dwrite_factory);
releaseCom(&dx.d2d.context);
releaseCom(&dx.d2d.device);
releaseCom(&dx.d2d.factory);
releaseCom(&dx.d2d.device11on12);
releaseCom(&dx.d2d.context11);
releaseCom(&dx.d2d.device11);
dx.resource_pool.deinit();
dx.pipeline.pool.deinit();
assert(dx.pipeline.map.count() == 0);
dx.pipeline.map.deinit();
releaseCom(&dx.rtv_heap.heap);
releaseCom(&dx.dsv_heap.heap);
releaseCom(&dx.cbv_srv_uav_cpu_heap.heap);
for (dx.cbv_srv_uav_gpu_heaps) |*heap| {
releaseCom(&heap.*.heap);
}
for (dx.upload_memory_heaps) |*heap| {
releaseCom(&heap.*.heap);
}
for (dx.cmdallocs) |*cmdalloc| {
releaseCom(&cmdalloc.*);
}
os.CloseHandle(dx.frame_fence_event);
releaseCom(&dx.cmdqueue);
releaseCom(&dx.cmdlist);
releaseCom(&dx.frame_fence);
releaseCom(&dx.swapchain);
releaseCom(&dx.device);
dx.* = undefined;
}
pub fn beginFrame(dx: *DxContext) void {
const cmdalloc = dx.cmdallocs[dx.frame_index];
vhr(cmdalloc.Reset());
vhr(dx.cmdlist.Reset(cmdalloc, null));
dx.cmdlist.SetDescriptorHeaps(
1,
&[_]*d3d12.IDescriptorHeap{dx.cbv_srv_uav_gpu_heaps[dx.frame_index].heap},
);
dx.cmdlist.RSSetViewports(1, &[_]d3d12.VIEWPORT{.{
.TopLeftX = 0.0,
.TopLeftY = 0.0,
.Width = @intToFloat(f32, dx.viewport_width),
.Height = @intToFloat(f32, dx.viewport_height),
.MinDepth = 0.0,
.MaxDepth = 1.0,
}});
dx.cmdlist.RSSetScissorRects(1, &[_]d3d12.RECT{.{
.left = 0,
.top = 0,
.right = @intCast(c_long, dx.viewport_width),
.bottom = @intCast(c_long, dx.viewport_height),
}});
dx.pipeline.current = .{ .index = 0, .generation = 0 };
}
pub fn endFrame(dx: *DxContext) void {
dx.frame_fence_counter += 1;
vhr(dx.swapchain.Present(0, 0));
vhr(dx.cmdqueue.Signal(dx.frame_fence, dx.frame_fence_counter));
const gpu_frame_counter = dx.frame_fence.GetCompletedValue();
if ((dx.frame_fence_counter - gpu_frame_counter) >= num_frames) {
vhr(dx.frame_fence.SetEventOnCompletion(gpu_frame_counter + 1, dx.frame_fence_event));
os.WaitForSingleObject(dx.frame_fence_event, os.INFINITE) catch unreachable;
}
dx.frame_index = (dx.frame_index + 1) % num_frames;
dx.back_buffer_index = dx.swapchain.GetCurrentBackBufferIndex();
dx.cbv_srv_uav_gpu_heaps[dx.frame_index].size = 0;
dx.upload_memory_heaps[dx.frame_index].size = 0;
}
pub fn waitForGpu(dx: *DxContext) void {
dx.frame_fence_counter += 1;
vhr(dx.cmdqueue.Signal(dx.frame_fence, dx.frame_fence_counter));
vhr(dx.frame_fence.SetEventOnCompletion(dx.frame_fence_counter, dx.frame_fence_event));
os.WaitForSingleObject(dx.frame_fence_event, os.INFINITE) catch unreachable;
dx.cbv_srv_uav_gpu_heaps[dx.frame_index].size = 0;
dx.upload_memory_heaps[dx.frame_index].size = 0;
}
pub fn beginDraw2d(dx: DxContext) void {
dx.d2d.device11on12.AcquireWrappedResources(
&[_]*d3d11.IResource{dx.d2d.wrapped_swapbuffers[dx.back_buffer_index]},
1,
);
dx.d2d.context.SetTarget(@ptrCast(*d2d1.IImage, dx.d2d.targets[dx.back_buffer_index]));
dx.d2d.context.BeginDraw();
}
pub fn endDraw2d(dx: DxContext) void {
vhr(dx.d2d.context.EndDraw(null, null));
dx.d2d.device11on12.ReleaseWrappedResources(
&[_]*d3d11.IResource{dx.d2d.wrapped_swapbuffers[dx.back_buffer_index]},
1,
);
dx.d2d.context11.Flush();
// Above calls will set back buffer state to PRESENT. We need to reflect this change
// in 'resource_pool' by manually setting state.
dx.resource_pool.getResource(dx.swapbuffers[dx.back_buffer_index]).*.state = .{};
}
pub fn allocateCpuDescriptors(
dx: *DxContext,
heap_type: d3d12.DESCRIPTOR_HEAP_TYPE,
num_descriptors: u32,
) d3d12.CPU_DESCRIPTOR_HANDLE {
return switch (heap_type) {
.CBV_SRV_UAV => dx.cbv_srv_uav_cpu_heap.allocateDescriptors(num_descriptors).cpu_handle,
.SAMPLER => unreachable,
.RTV => dx.rtv_heap.allocateDescriptors(num_descriptors).cpu_handle,
.DSV => dx.dsv_heap.allocateDescriptors(num_descriptors).cpu_handle,
};
}
pub fn allocateGpuDescriptors(dx: *DxContext, num_descriptors: u32) Descriptor {
return dx.cbv_srv_uav_gpu_heaps[dx.frame_index].allocateDescriptors(num_descriptors);
}
pub fn getResource(dx: DxContext, handle: ResourceHandle) *d3d12.IResource {
return dx.resource_pool.getResource(handle).*.raw.?;
}
pub fn getBackBuffer(dx: DxContext) struct {
resource_handle: ResourceHandle,
cpu_handle: d3d12.CPU_DESCRIPTOR_HANDLE,
} {
return .{
.resource_handle = dx.swapbuffers[dx.back_buffer_index],
.cpu_handle = d3d12.CPU_DESCRIPTOR_HANDLE{
.ptr = dx.rtv_heap.cpu_start.ptr + dx.back_buffer_index * dx.rtv_heap.descriptor_size,
},
};
}
pub fn addTransitionBarrier(
dx: *DxContext,
handle: ResourceHandle,
state_after: d3d12.RESOURCE_STATES,
) void {
var resource = dx.resource_pool.getResource(handle);
if (@bitCast(u32, state_after) != @bitCast(u32, resource.state)) {
if (dx.num_resource_barriers >= dx.buffered_resource_barriers.len) {
flushResourceBarriers(dx);
}
dx.buffered_resource_barriers[dx.num_resource_barriers] = d3d12.RESOURCE_BARRIER{
.Type = .TRANSITION,
.Flags = .NONE,
.u = .{
.Transition = d3d12.RESOURCE_TRANSITION_BARRIER{
.pResource = resource.raw.?,
.Subresource = d3d12.RESOURCE_BARRIER_ALL_SUBRESOURCES,
.StateBefore = resource.state,
.StateAfter = state_after,
},
},
};
dx.num_resource_barriers += 1;
resource.state = state_after;
}
}
pub fn flushResourceBarriers(dx: *DxContext) void {
if (dx.num_resource_barriers > 0) {
dx.cmdlist.ResourceBarrier(dx.num_resource_barriers, dx.buffered_resource_barriers.ptr);
dx.num_resource_barriers = 0;
}
}
pub fn setPipelineState(dx: *DxContext, pipeline_handle: PipelineHandle) void {
// TODO: Do we need to unset pipeline state (null, null)?
const pipeline = dx.pipeline.pool.getPipeline(pipeline_handle);
if (pipeline_handle.index == dx.pipeline.current.index and
pipeline_handle.generation == dx.pipeline.current.generation)
{
return;
}
dx.cmdlist.SetPipelineState(pipeline.pso.?);
switch (pipeline.ptype.?) {
.Graphics => dx.cmdlist.SetGraphicsRootSignature(pipeline.root_signature.?),
.Compute => dx.cmdlist.SetComputeRootSignature(pipeline.root_signature.?),
}
dx.pipeline.current = pipeline_handle;
}
pub fn createCommittedResource(
dx: *DxContext,
heap_type: d3d12.HEAP_TYPE,
heap_flags: d3d12.HEAP_FLAGS,
desc: *const d3d12.RESOURCE_DESC,
initial_state: d3d12.RESOURCE_STATES,
clear_value: ?*const d3d12.CLEAR_VALUE,
) ResourceHandle {
var raw: *d3d12.IResource = undefined;
vhr(dx.device.CreateCommittedResource(
&d3d12.HEAP_PROPERTIES{ .Type = heap_type },
heap_flags,
desc,
initial_state,
clear_value,
&d3d12.IID_IResource,
@ptrCast(**c_void, &raw),
));
return dx.resource_pool.addResource(raw, initial_state, desc.Format);
}
pub fn createTextureFromFile(
dx: *DxContext,
filename: []const u8,
num_mip_levels: u32,
texture: *ResourceHandle,
texture_srv: *d3d12.CPU_DESCRIPTOR_HANDLE,
) void {
// TODO: Hardcoded max path length.
var path: [256:0]u16 = undefined;
{
assert(filename.len < 64);
var buf: [256]u8 = undefined;
const string = std.fmt.bufPrint(
buf[0..],
"{}/{}",
.{ std.fs.selfExeDirPath(buf[0..]), filename },
) catch unreachable;
const len = std.unicode.utf8ToUtf16Le(path[0..], string) catch unreachable;
path[len] = 0;
}
var bitmap_decoder: *wincodec.IBitmapDecoder = undefined;
os.vhr(dx.wic_factory.CreateDecoderFromFilename(
&path,
null,
os.GENERIC_READ,
.MetadataCacheOnDemand,
&bitmap_decoder,
));
defer os.releaseCom(&bitmap_decoder);
var bitmap_frame: *wincodec.IBitmapFrameDecode = undefined;
os.vhr(bitmap_decoder.GetFrame(0, &bitmap_frame));
defer os.releaseCom(&bitmap_frame);
var pixel_format: os.GUID = undefined;
os.vhr(bitmap_frame.GetPixelFormat(&pixel_format));
const eql = std.mem.eql;
const asBytes = std.mem.asBytes;
const num_components: u32 = blk: {
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat24bppRGB)))
break :blk 4;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat32bppRGB)))
break :blk 4;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat32bppRGBA)))
break :blk 4;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat32bppPRGBA)))
break :blk 4;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat24bppBGR)))
break :blk 4;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat32bppBGR)))
break :blk 4;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat32bppBGRA)))
break :blk 4;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat32bppPBGRA)))
break :blk 4;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat8bppGray)))
break :blk 1;
if (eql(u8, asBytes(&pixel_format), asBytes(&wincodec.GUID_PixelFormat8bppAlpha)))
break :blk 1;
break :blk 0;
};
assert(num_components != 0);
const wic_format = if (num_components == 1)
&wincodec.GUID_PixelFormat8bppGray
else
&wincodec.GUID_PixelFormat32bppRGBA;
const dxgi_format = if (num_components == 1) dxgi.FORMAT.R8_UNORM else dxgi.FORMAT.R8G8B8A8_UNORM;
var image: *wincodec.IFormatConverter = undefined;
os.vhr(dx.wic_factory.CreateFormatConverter(&image));
defer os.releaseCom(&image);
os.vhr(image.Initialize(
@ptrCast(*wincodec.IBitmapSource, bitmap_frame),
wic_format,
.None,
null,
0.0,
.Custom,
));
var image_width: u32 = undefined;
var image_height: u32 = undefined;
os.vhr(image.GetSize(&image_width, &image_height));
// TODO: Remove this limitation.
assert(num_mip_levels == 1);
texture.* = dx.createCommittedResource(
.DEFAULT,
.{},
&blk: {
var desc = d3d12.RESOURCE_DESC.tex2d(dxgi_format, image_width, image_height);
desc.MipLevels = @intCast(u16, num_mip_levels);
break :blk desc;
},
.{ .COPY_DEST = true },
null,
);
texture_srv.* = dx.allocateCpuDescriptors(.CBV_SRV_UAV, 1);
dx.device.CreateShaderResourceView(dx.getResource(texture.*), null, texture_srv.*);
const desc = dx.getResource(texture.*).GetDesc();
var layout: d3d12.PLACED_SUBRESOURCE_FOOTPRINT = undefined;
var required_size: u64 = undefined;
dx.device.GetCopyableFootprints(&desc, 0, 1, 0, &layout, null, null, &required_size);
const upload = dx.allocateUploadBufferRegion(u8, @intCast(u32, required_size));
layout.Offset = upload.buffer_offset;
os.vhr(image.CopyPixels(
null,
layout.Footprint.RowPitch,
layout.Footprint.RowPitch * layout.Footprint.Height,
upload.cpu_slice.ptr,
));
const dst = d3d12.TEXTURE_COPY_LOCATION{
.pResource = dx.getResource(texture.*),
.Type = .SUBRESOURCE_INDEX,
.u = .{ .SubresourceIndex = 0 },
};
const src = d3d12.TEXTURE_COPY_LOCATION{
.pResource = upload.buffer,
.Type = .PLACED_FOOTPRINT,
.u = .{ .PlacedFootprint = layout },
};
dx.cmdlist.CopyTextureRegion(&dst, 0, 0, 0, &src, null);
}
pub fn addResourceRef(dx: DxContext, handle: ResourceHandle) u32 {
const resource = dx.resource_pool.getResource(handle);
return resource.raw.?.AddRef();
}
pub fn releaseResource(dx: DxContext, handle: ResourceHandle) u32 {
var resource = dx.resource_pool.getResource(handle);
const refcount = resource.raw.?.Release();
if (refcount == 0) {
resource.* = Resource{ .raw = null, .state = .{}, .format = .UNKNOWN };
}
return refcount;
}
pub fn createGraphicsPipeline(
dx: *DxContext,
pso_desc: d3d12.GRAPHICS_PIPELINE_STATE_DESC,
) PipelineHandle {
const hash = compute_hash: {
var hasher = std.hash.Adler32.init();
hasher.update(
@ptrCast([*]const u8, pso_desc.VS.pShaderBytecode.?)[0..pso_desc.VS.BytecodeLength],
);
hasher.update(
@ptrCast([*]const u8, pso_desc.PS.pShaderBytecode.?)[0..pso_desc.PS.BytecodeLength],
);
hasher.update(std.mem.asBytes(&pso_desc.BlendState));
hasher.update(std.mem.asBytes(&pso_desc.SampleMask));
hasher.update(std.mem.asBytes(&pso_desc.RasterizerState));
hasher.update(std.mem.asBytes(&pso_desc.DepthStencilState));
hasher.update(std.mem.asBytes(&pso_desc.IBStripCutValue));
hasher.update(std.mem.asBytes(&pso_desc.PrimitiveTopologyType));
hasher.update(std.mem.asBytes(&pso_desc.NumRenderTargets));
hasher.update(std.mem.asBytes(&pso_desc.RTVFormats));
hasher.update(std.mem.asBytes(&pso_desc.DSVFormat));
hasher.update(std.mem.asBytes(&pso_desc.SampleDesc));
// We don't support fixed vertex fetch.
assert(pso_desc.InputLayout.pInputElementDescs == null);
assert(pso_desc.InputLayout.NumElements == 0);
break :compute_hash hasher.final();
};
if (dx.pipeline.map.contains(hash)) {
std.log.info("[graphics] Graphics pipeline hit detected.", .{});
const handle = dx.pipeline.map.getEntry(hash).?.value;
_ = dx.addPipelineRef(handle);
return handle;
}
var root_signature: *d3d12.IRootSignature = undefined;
vhr(dx.device.CreateRootSignature(
0,
pso_desc.VS.pShaderBytecode.?,
pso_desc.VS.BytecodeLength,
&d3d12.IID_IRootSignature,
@ptrCast(**c_void, &root_signature),
));
var pso: *d3d12.IPipelineState = undefined;
vhr(dx.device.CreateGraphicsPipelineState(
&pso_desc,
&d3d12.IID_IPipelineState,
@ptrCast(**c_void, &pso),
));
const handle = dx.pipeline.pool.addPipeline(pso, root_signature, .Graphics);
dx.pipeline.map.put(hash, handle) catch unreachable;
return handle;
}
pub fn createComputePipeline(
dx: *DxContext,
pso_desc: d3d12.COMPUTE_PIPELINE_STATE_DESC,
) PipelineHandle {
const hash = compute_hash: {
var hasher = std.hash.Adler32.init();
hasher.update(
@ptrCast([*]const u8, pso_desc.CS.pShaderBytecode.?)[0..pso_desc.CS.BytecodeLength],
);
break :compute_hash hasher.final();
};
if (dx.pipeline.map.contains(hash)) {
std.log.info("[graphics] Compute pipeline hit detected.", .{});
const handle = dx.pipeline.map.getEntry(hash).?.value;
_ = addPipelineRef(handle);
return handle;
}
var root_signature: *d3d12.IRootSignature = undefined;
vhr(dx.device.CreateRootSignature(
0,
pso_desc.CS.pShaderBytecode.?,
pso_desc.CS.BytecodeLength,
&d3d12.IID_IRootSignature,
@ptrCast(**c_void, &root_signature),
));
var pso: *d3d12.IPipelineState = undefined;
vhr(dx.device.CreateComputePipelineState(
&pso_desc,
&d3d12.IID_IPipelineState,
@ptrCast(**c_void, &pso),
));
const handle = dx.pipeline.pool.addPipeline(pso, root_signature, .Compute);
dx.pipeline.map.put(hash, handle) catch unreachable;
return handle;
}
pub fn addPipelineRef(dx: DxContext, handle: PipelineHandle) u32 {
const pipeline = dx.pipeline.pool.getPipeline(handle);
const refcount = pipeline.pso.?.AddRef();
if (pipeline.root_signature.?.AddRef() != refcount) {
assert(false);
}
return refcount;
}
pub fn releasePipeline(dx: *DxContext, handle: PipelineHandle) u32 {
var pipeline = dx.pipeline.pool.getPipeline(handle);
const refcount = pipeline.pso.?.Release();
if (pipeline.root_signature.?.Release() != refcount) {
assert(false);
}
if (refcount == 0) {
const hash_to_delete = blk: {
var it = dx.pipeline.map.iterator();
while (it.next()) |kv| {
if (kv.value.index == handle.index and
kv.value.generation == handle.generation)
{
break :blk kv.key;
}
}
unreachable;
};
_ = dx.pipeline.map.remove(hash_to_delete);
pipeline.* = Pipeline{ .pso = null, .root_signature = null, .ptype = null };
}
return refcount;
}
fn allocateUploadMemory(
dx: *DxContext,
size: u32,
) struct { cpu_slice: []u8, gpu_addr: d3d12.GPU_VIRTUAL_ADDRESS } {
var memory = dx.upload_memory_heaps[dx.frame_index].allocate(size);
if (memory.cpu_slice == null and memory.gpu_addr == null) {
std.log.info("[graphics] Upload memory exhausted - waiting for a GPU...", .{});
dx.closeAndExecuteCommandList();
dx.waitForGpu();
dx.beginFrame();
memory = dx.upload_memory_heaps[dx.frame_index].allocate(size);
}
return .{ .cpu_slice = memory.cpu_slice.?, .gpu_addr = memory.gpu_addr.? };
}
pub fn allocateUploadBufferRegion(
dx: *DxContext,
comptime T: type,
num_elements: u32,
) struct { cpu_slice: []T, buffer: *d3d12.IResource, buffer_offset: u64 } {
const size = num_elements * @sizeOf(T);
const memory = dx.allocateUploadMemory(size);
const aligned_size = (size + 511) & 0xffff_fe00;
return .{
.cpu_slice = std.mem.bytesAsSlice(T, @alignCast(@alignOf(T), memory.cpu_slice)),
.buffer = dx.upload_memory_heaps[dx.frame_index].heap,
.buffer_offset = dx.upload_memory_heaps[dx.frame_index].size - aligned_size,
};
}
pub fn closeAndExecuteCommandList(dx: *DxContext) void {
vhr(dx.cmdlist.Close());
dx.cmdqueue.ExecuteCommandLists(
1,
&[_]*d3d12.ICommandList{@ptrCast(*d3d12.ICommandList, dx.cmdlist)},
);
}
pub fn copyDescriptorsToGpuHeap(
dx: *DxContext,
num: u32,
src_base_handle: d3d12.CPU_DESCRIPTOR_HANDLE,
) d3d12.GPU_DESCRIPTOR_HANDLE {
const base = dx.allocateGpuDescriptors(num);
dx.device.CopyDescriptorsSimple(num, base.cpu_handle, src_base_handle, .CBV_SRV_UAV);
return base.gpu_handle;
}
};
const DescriptorHeap = struct {
heap: *d3d12.IDescriptorHeap,
cpu_start: d3d12.CPU_DESCRIPTOR_HANDLE,
gpu_start: d3d12.GPU_DESCRIPTOR_HANDLE,
size: u32,
capacity: u32,
descriptor_size: u32,
fn init(
device: *d3d12.IDevice,
capacity: u32,
heap_type: d3d12.DESCRIPTOR_HEAP_TYPE,
flags: d3d12.DESCRIPTOR_HEAP_FLAGS,
) DescriptorHeap {
assert(capacity > 0);
var heap: *d3d12.IDescriptorHeap = undefined;
vhr(device.CreateDescriptorHeap(
&d3d12.DESCRIPTOR_HEAP_DESC{
.Type = heap_type,
.NumDescriptors = capacity,
.Flags = flags,
.NodeMask = 0,
},
&d3d12.IID_IDescriptorHeap,
@ptrCast(**c_void, &heap),
));
return DescriptorHeap{
.heap = heap,
.cpu_start = heap.GetCPUDescriptorHandleForHeapStart(),
.gpu_start = blk: {
if (flags == .SHADER_VISIBLE)
break :blk heap.GetGPUDescriptorHandleForHeapStart();
break :blk d3d12.GPU_DESCRIPTOR_HANDLE{ .ptr = 0 };
},
.size = 0,
.capacity = capacity,
.descriptor_size = device.GetDescriptorHandleIncrementSize(heap_type),
};
}
fn allocateDescriptors(self: *DescriptorHeap, num_descriptors: u32) Descriptor {
assert((self.size + num_descriptors) < self.capacity);
const cpu_handle = d3d12.CPU_DESCRIPTOR_HANDLE{
.ptr = self.cpu_start.ptr + self.size * self.descriptor_size,
};
const gpu_handle = d3d12.GPU_DESCRIPTOR_HANDLE{
.ptr = blk: {
if (self.gpu_start.ptr != 0)
break :blk self.gpu_start.ptr + self.size * self.descriptor_size;
break :blk 0;
},
};
self.size += num_descriptors;
return Descriptor{ .cpu_handle = cpu_handle, .gpu_handle = gpu_handle };
}
};
const Descriptor = struct {
cpu_handle: d3d12.CPU_DESCRIPTOR_HANDLE,
gpu_handle: d3d12.GPU_DESCRIPTOR_HANDLE,
};
pub const PipelineHandle = struct {
index: u16,
generation: u16,
};
const PipelineType = enum {
Graphics,
Compute,
};
const Pipeline = struct {
pso: ?*d3d12.IPipelineState,
root_signature: ?*d3d12.IRootSignature,
ptype: ?PipelineType,
};
const PipelinePool = struct {
pipelines: []Pipeline,
generations: []u16,
fn init() PipelinePool {
return PipelinePool{
.pipelines = blk: {
var pipelines = std.heap.page_allocator.alloc(
Pipeline,
max_num_pipelines + 1,
) catch unreachable;
for (pipelines) |*pipeline| {
pipeline.* = Pipeline{ .pso = null, .root_signature = null, .ptype = null };
}
break :blk pipelines;
},
.generations = blk: {
var generations = std.heap.page_allocator.alloc(
u16,
max_num_pipelines + 1,
) catch unreachable;
for (generations) |*generation| {
generation.* = 0;
}
break :blk generations;
},
};
}
fn deinit(self: *PipelinePool) void {
for (self.pipelines) |pipeline| {
// Verify that all pipelines has been released by a user.
assert(pipeline.pso == null);
assert(pipeline.root_signature == null);
}
std.heap.page_allocator.free(self.pipelines);
std.heap.page_allocator.free(self.generations);
self.* = undefined;
}
fn addPipeline(
self: *PipelinePool,
pso: *d3d12.IPipelineState,
root_signature: *d3d12.IRootSignature,
ptype: PipelineType,
) PipelineHandle {
var slot_idx: u32 = 1;
while (slot_idx <= max_num_pipelines) : (slot_idx += 1) {
if (self.pipelines[slot_idx].pso == null)
break;
}
assert(slot_idx <= max_num_pipelines);
self.pipelines[slot_idx] = Pipeline{
.pso = pso,
.root_signature = root_signature,
.ptype = ptype,
};
return PipelineHandle{
.index = @intCast(u16, slot_idx),
.generation = blk: {
self.generations[slot_idx] += 1;
break :blk self.generations[slot_idx];
},
};
}
fn getPipeline(self: PipelinePool, handle: PipelineHandle) *Pipeline {
assert(handle.index > 0 and handle.index <= max_num_pipelines);
assert(handle.generation > 0);
assert(handle.generation == self.generations[handle.index]);
return &self.pipelines[handle.index];
}
};
pub const ResourceHandle = struct {
index: u16,
generation: u16,
};
const Resource = struct {
raw: ?*d3d12.IResource,
state: d3d12.RESOURCE_STATES,
format: dxgi.FORMAT,
};
const ResourcePool = struct {
resources: []Resource,
generations: []u16,
fn init() ResourcePool {
return ResourcePool{
.resources = blk: {
var resources = std.heap.page_allocator.alloc(
Resource,
max_num_resources + 1,
) catch unreachable;
for (resources) |*res| {
res.* = Resource{ .raw = null, .state = .{}, .format = .UNKNOWN };
}
break :blk resources;
},
.generations = blk: {
var generations = std.heap.page_allocator.alloc(
u16,
max_num_resources + 1,
) catch unreachable;
for (generations) |*gen| {
gen.* = 0;
}
break :blk generations;
},
};
}
fn deinit(self: *ResourcePool) void {
for (self.resources) |resource, i| {
if (i > 0 and i <= num_swapbuffers) {
// Release internally created swapbuffers.
_ = resource.raw.?.Release();
} else if (i > num_swapbuffers) {
// Verify that all resources has been released by a user.
assert(resource.raw == null);
}
}
std.heap.page_allocator.free(self.resources);
std.heap.page_allocator.free(self.generations);
self.* = undefined;
}
fn addResource(
self: *ResourcePool,
raw: *d3d12.IResource,
state: d3d12.RESOURCE_STATES,
format: dxgi.FORMAT,
) ResourceHandle {
var slot_idx: u32 = 1;
while (slot_idx <= max_num_resources) : (slot_idx += 1) {
if (self.resources[slot_idx].raw == null)
break;
}
assert(slot_idx <= max_num_resources);
self.resources[slot_idx] = Resource{ .raw = raw, .state = state, .format = format };
return ResourceHandle{
.index = @intCast(u16, slot_idx),
.generation = blk: {
self.generations[slot_idx] += 1;
break :blk self.generations[slot_idx];
},
};
}
fn getResource(self: ResourcePool, handle: ResourceHandle) *Resource {
assert(handle.index > 0 and handle.index <= max_num_resources);
assert(handle.generation > 0);
assert(handle.generation == self.generations[handle.index]);
return &self.resources[handle.index];
}
};
const GpuMemoryHeap = struct {
heap: *d3d12.IResource,
cpu_slice: []u8,
gpu_start: d3d12.GPU_VIRTUAL_ADDRESS,
size: u32,
capacity: u32,
fn init(device: *d3d12.IDevice, capacity: u32, heap_type: d3d12.HEAP_TYPE) GpuMemoryHeap {
var heap: *d3d12.IResource = undefined;
vhr(device.CreateCommittedResource(
&d3d12.HEAP_PROPERTIES{ .Type = heap_type },
.{},
&d3d12.RESOURCE_DESC.buffer(capacity),
d3d12.RESOURCE_STATES.genericRead(),
null,
&d3d12.IID_IResource,
@ptrCast(**c_void, &heap),
));
var cpu_start: [*]u8 = undefined;
vhr(heap.Map(0, &d3d12.RANGE{ .Begin = 0, .End = 0 }, @ptrCast(**c_void, &cpu_start)));
return GpuMemoryHeap{
.heap = heap,
.cpu_slice = cpu_start[0..capacity],
.gpu_start = heap.GetGPUVirtualAddress(),
.size = 0,
.capacity = capacity,
};
}
fn deinit(self: *GpuMemoryHeap) void {
releaseCom(&self.heap);
self.* = undefined;
}
fn allocate(
self: *GpuMemoryHeap,
size: u32,
) struct { cpu_slice: ?[]u8, gpu_addr: ?d3d12.GPU_VIRTUAL_ADDRESS } {
assert(size > 0);
const aligned_size = (size + 511) & 0xffff_fe00;
if ((self.size + aligned_size) >= self.capacity) {
return .{ .cpu_slice = null, .gpu_addr = null };
}
const cpu_slice = (self.cpu_slice.ptr + self.size)[0..size];
const gpu_addr = self.gpu_start + self.size;
self.size += aligned_size;
return .{ .cpu_slice = cpu_slice, .gpu_addr = gpu_addr };
}
}; | src/graphics.zig |
const std = @import("std");
const Pkg = std.build.Pkg;
const Builder = std.build.Builder;
pub const pkgs = struct {
pub const zap = Pkg{
.name = "zap",
.path = "zap/src/zap.zig",
};
pub const clap = Pkg{
.name = "clap",
.path = "clap/clap.zig",
};
pub const hyperia = Pkg{
.name = "hyperia",
.path = "hyperia.zig",
.dependencies = &[_]Pkg{
zap,
},
};
};
pub fn register(step: *std.build.LibExeObjStep) void {
step.linkLibC();
step.addPackage(pkgs.zap);
step.addPackage(pkgs.clap);
step.addPackage(pkgs.hyperia);
@import("picohttp/picohttp.zig").addTo(step, "picohttp");
@import("blake3/blake3.zig").addTo(step, "blake3");
}
pub fn build(b: *Builder) void {
const target = b.standardTargetOptions(.{});
const mode = b.standardReleaseOptions();
const test_step = b.step("test", "Run library tests.");
const test_filter = b.option([]const u8, "test-filter", "Test filter");
const sanitize_thread = b.option(bool, "sanitize-thread", "Enable ThreadSanitizer") orelse false;
const file = b.addTest("hyperia.zig");
file.sanitize_thread = sanitize_thread;
file.setTarget(target);
file.setBuildMode(mode);
register(file);
if (test_filter != null) {
file.setFilter(test_filter.?);
}
test_step.dependOn(&file.step);
inline for (.{
"example_tcp_client",
"example_tcp_server",
"example_http_client",
"example_http_server",
}) |example_name| {
const example_step = b.step(example_name, "Example " ++ example_name ++ ".zig");
const exe = b.addExecutable(example_name, example_name ++ ".zig");
exe.sanitize_thread = sanitize_thread;
exe.setTarget(target);
exe.setBuildMode(mode);
register(exe);
exe.install();
const exe_run = exe.run();
if (b.args) |args| exe_run.addArgs(args);
example_step.dependOn(&exe_run.step);
}
} | build.zig |
const std = @import("std");
const fmt = std.fmt;
const utils = @import("main.zig").utils;
/// 256 colors
pub const Color = enum(u8) {
black = 0,
red,
green,
yellow,
blue,
magenta,
cyan,
white,
default,
};
pub const print = struct {
/// Returns a string to change text foreground using 256 colors
pub inline fn fg(comptime color: Color) []const u8 {
return utils.comptimeCsi("38;5;{d}m", .{@enumToInt(color)});
}
/// Returns a string to change text background using 256 colors
pub inline fn bg(comptime color: Color) []const u8 {
return utils.comptimeCsi("48;5;{d}m", .{@enumToInt(color)});
}
/// Returns a string to change text foreground using rgb colors
/// Uses a buffer.
pub inline fn fgRGB(r: u8, g: u8, b: u8) []const u8 {
var buf: [22]u8 = undefined;
return fmt.bufPrint(&buf, "\x1b[38;2;{d};{d};{d}m", .{ r, g, b }) catch unreachable;
}
/// Returns a string to change text background using rgb colors
/// Uses a buffer.
pub inline fn bgRGB(r: u8, g: u8, b: u8) []const u8 {
var buf: [22]u8 = undefined;
return fmt.bufPrint(&buf, "\x1b[48;2;{d};{d};{d}m", .{ r, g, b }) catch unreachable;
}
pub const reset = utils.comptimeCsi("0m", .{});
};
/// Writes the escape sequence code to change foreground to `color` (using 256 colors)
pub fn fg256(writer: anytype, color: Color) !void {
return std.fmt.format(writer, utils.csi ++ utils.fg_256 ++ "{d}m", .{@enumToInt(color)});
}
/// Writes the escape sequence code to change background to `color` (using 256 colors)
pub fn bg256(writer: anytype, color: Color) !void {
return std.fmt.format(writer, utils.csi ++ utils.bg_256 ++ "{d}m", .{@enumToInt(color)});
}
/// Writes the escape sequence code to change foreground to rgb color
pub fn fgRGB(writer: anytype, r: u8, g: u8, b: u8) !void {
return std.fmt.format(writer, utils.csi ++ utils.fg_rgb ++ "{d};{d};{d}m", .{ r, g, b });
}
/// Writes the escape sequence code to change background to rgb color
pub fn bgRGB(writer: anytype, r: u8, g: u8, b: u8) !void {
return std.fmt.format(writer, utils.csi ++ utils.bg_rgb ++ "{d};{d};{d}m", .{ r, g, b });
}
/// Writes the escape code to reset style and color
pub fn resetAll(writer: anytype) !void {
return std.fmt.format(writer, utils.csi ++ utils.reset_all, .{});
} | src/color.zig |
const std = @import("std");
const common = @import("common.zig");
const VertexBufferHandle = common.VertexBufferHandle;
pub fn withBackend(comptime backend: anytype) type {
return struct {
pub fn VertexBuffer(comptime vertex_type: type) type {
return struct {
pub const VertexType: type = vertex_type;
handle: VertexBufferHandle,
capacity: u32,
write_cursor: u32,
mapped: ?[]VertexType,
pub fn init(capacity: u32) !@This() {
const size = capacity * @sizeOf(VertexType);
const handle = try backend.createVertexBuffer(size);
return @This(){
.handle = handle,
.capacity = capacity,
.write_cursor = 0,
.mapped = null,
};
}
pub fn deinit(self: @This()) void {
if (self.mapped != null) self.unmap();
backend.destroyVertexBuffer(self.handle);
}
pub fn map(self: *@This()) !void {
std.debug.assert(self.mapped == null);
const size = self.capacity * @sizeOf(VertexType);
const bytes = try backend.mapBuffer(
self.handle,
0,
size,
@alignOf(VertexType),
);
self.mapped = std.mem.bytesAsSlice(VertexType, bytes);
}
pub fn unmap(self: *@This()) void {
std.debug.assert(self.mapped != null);
backend.unmapBuffer(self.handle);
self.mapped = null;
}
/// Writes vertices at the write cursor and moves the cursor forward
/// Returns the offset in the buffer of the first vertex that was written
pub fn append(self: *@This(), vertices: []const VertexType) u32 {
self.overwrite(self.write_cursor, vertices);
const position = self.write_cursor;
self.write_cursor += @intCast(u32, vertices.len);
return position;
}
pub fn overwrite(self: *@This(), offset: u32, vertices: []const VertexType) void {
std.debug.assert(self.mapped != null);
if (self.mapped) |buffer| {
const elems = vertices[0..];
std.mem.copy(
VertexType,
buffer[offset..(offset + elems.len)],
elems,
);
} else {
std.debug.panic("Unimplemented", .{});
}
}
pub fn clear(self: *@This(), write_zeros: bool) void {
if (write_zeros) {
std.debug.assert(self.mapped != null);
if (self.mapped) |buffer| {
for (buffer) |*v| v.* = std.mem.zeroes(VertexType);
} else {
std.debug.panic("Unimplemented", .{});
}
}
self.write_cursor = 0;
}
};
}
};
} | modules/graphics/src/buffers.zig |
const std = @import("index.zig");
const builtin = @import("builtin");
const assert = std.debug.assert;
const event = this;
const mem = std.mem;
const posix = std.os.posix;
pub const TcpServer = struct {
handleRequestFn: async<*mem.Allocator> fn (*TcpServer, *const std.net.Address, *const std.os.File) void,
loop: *Loop,
sockfd: i32,
accept_coro: ?promise,
listen_address: std.net.Address,
waiting_for_emfile_node: PromiseNode,
const PromiseNode = std.LinkedList(promise).Node;
pub fn init(loop: *Loop) !TcpServer {
const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM | posix.SOCK_CLOEXEC | posix.SOCK_NONBLOCK, posix.PROTO_tcp);
errdefer std.os.close(sockfd);
// TODO can't initialize handler coroutine here because we need well defined copy elision
return TcpServer{
.loop = loop,
.sockfd = sockfd,
.accept_coro = null,
.handleRequestFn = undefined,
.waiting_for_emfile_node = undefined,
.listen_address = undefined,
};
}
pub fn listen(self: *TcpServer, address: *const std.net.Address, handleRequestFn: async<*mem.Allocator> fn (*TcpServer, *const std.net.Address, *const std.os.File) void) !void {
self.handleRequestFn = handleRequestFn;
try std.os.posixBind(self.sockfd, &address.os_addr);
try std.os.posixListen(self.sockfd, posix.SOMAXCONN);
self.listen_address = std.net.Address.initPosix(try std.os.posixGetSockName(self.sockfd));
self.accept_coro = try async<self.loop.allocator> TcpServer.handler(self);
errdefer cancel self.accept_coro.?;
try self.loop.addFd(self.sockfd, self.accept_coro.?);
errdefer self.loop.removeFd(self.sockfd);
}
pub fn deinit(self: *TcpServer) void {
self.loop.removeFd(self.sockfd);
if (self.accept_coro) |accept_coro| cancel accept_coro;
std.os.close(self.sockfd);
}
pub async fn handler(self: *TcpServer) void {
while (true) {
var accepted_addr: std.net.Address = undefined;
if (std.os.posixAccept(self.sockfd, &accepted_addr.os_addr, posix.SOCK_NONBLOCK | posix.SOCK_CLOEXEC)) |accepted_fd| {
var socket = std.os.File.openHandle(accepted_fd);
_ = async<self.loop.allocator> self.handleRequestFn(self, accepted_addr, socket) catch |err| switch (err) {
error.OutOfMemory => {
socket.close();
continue;
},
};
} else |err| switch (err) {
error.WouldBlock => {
suspend; // we will get resumed by epoll_wait in the event loop
continue;
},
error.ProcessFdQuotaExceeded => {
errdefer std.os.emfile_promise_queue.remove(&self.waiting_for_emfile_node);
suspend |p| {
self.waiting_for_emfile_node = PromiseNode.init(p);
std.os.emfile_promise_queue.append(&self.waiting_for_emfile_node);
}
continue;
},
error.ConnectionAborted, error.FileDescriptorClosed => continue,
error.PageFault => unreachable,
error.InvalidSyscall => unreachable,
error.FileDescriptorNotASocket => unreachable,
error.OperationNotSupported => unreachable,
error.SystemFdQuotaExceeded, error.SystemResources, error.ProtocolFailure, error.BlockedByFirewall, error.Unexpected => {
@panic("TODO handle this error");
},
}
}
}
};
pub const Loop = struct {
allocator: *mem.Allocator,
epollfd: i32,
keep_running: bool,
fn init(allocator: *mem.Allocator) !Loop {
const epollfd = try std.os.linuxEpollCreate(std.os.linux.EPOLL_CLOEXEC);
return Loop{
.keep_running = true,
.allocator = allocator,
.epollfd = epollfd,
};
}
pub fn addFd(self: *Loop, fd: i32, prom: promise) !void {
var ev = std.os.linux.epoll_event{
.events = std.os.linux.EPOLLIN | std.os.linux.EPOLLOUT | std.os.linux.EPOLLET,
.data = std.os.linux.epoll_data{ .ptr = @ptrToInt(prom) },
};
try std.os.linuxEpollCtl(self.epollfd, std.os.linux.EPOLL_CTL_ADD, fd, &ev);
}
pub fn removeFd(self: *Loop, fd: i32) void {
std.os.linuxEpollCtl(self.epollfd, std.os.linux.EPOLL_CTL_DEL, fd, undefined) catch {};
}
async fn waitFd(self: *Loop, fd: i32) !void {
defer self.removeFd(fd);
suspend |p| {
try self.addFd(fd, p);
}
}
pub fn stop(self: *Loop) void {
// TODO make atomic
self.keep_running = false;
// TODO activate an fd in the epoll set
}
pub fn run(self: *Loop) void {
while (self.keep_running) {
var events: [16]std.os.linux.epoll_event = undefined;
const count = std.os.linuxEpollWait(self.epollfd, events[0..], -1);
for (events[0..count]) |ev| {
const p = @intToPtr(promise, ev.data.ptr);
resume p;
}
}
}
};
pub async fn connect(loop: *Loop, _address: *const std.net.Address) !std.os.File {
var address = _address.*; // TODO https://github.com/ziglang/zig/issues/733
const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM | posix.SOCK_CLOEXEC | posix.SOCK_NONBLOCK, posix.PROTO_tcp);
errdefer std.os.close(sockfd);
try std.os.posixConnectAsync(sockfd, &address.os_addr);
try await try async loop.waitFd(sockfd);
try std.os.posixGetSockOptConnectError(sockfd);
return std.os.File.openHandle(sockfd);
}
test "listen on a port, send bytes, receive bytes" {
if (builtin.os != builtin.Os.linux) {
// TODO build abstractions for other operating systems
return;
}
const MyServer = struct {
tcp_server: TcpServer,
const Self = this;
async<*mem.Allocator> fn handler(tcp_server: *TcpServer, _addr: *const std.net.Address, _socket: *const std.os.File) void {
const self = @fieldParentPtr(Self, "tcp_server", tcp_server);
var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733
defer socket.close();
const next_handler = async errorableHandler(self, _addr, socket) catch |err| switch (err) {
error.OutOfMemory => @panic("unable to handle connection: out of memory"),
};
(await next_handler) catch |err| {
std.debug.panic("unable to handle connection: {}\n", err);
};
suspend |p| {
cancel p;
}
}
async fn errorableHandler(self: *Self, _addr: *const std.net.Address, _socket: *const std.os.File) !void {
const addr = _addr.*; // TODO https://github.com/ziglang/zig/issues/733
var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733
var adapter = std.io.FileOutStream.init(&socket);
var stream = &adapter.stream;
try stream.print("hello from server\n");
}
};
const ip4addr = std.net.parseIp4("127.0.0.1") catch unreachable;
const addr = std.net.Address.initIp4(ip4addr, 0);
var loop = try Loop.init(std.debug.global_allocator);
var server = MyServer{ .tcp_server = try TcpServer.init(&loop) };
defer server.tcp_server.deinit();
try server.tcp_server.listen(addr, MyServer.handler);
const p = try async<std.debug.global_allocator> doAsyncTest(&loop, server.tcp_server.listen_address);
defer cancel p;
loop.run();
}
async fn doAsyncTest(loop: *Loop, address: *const std.net.Address) void {
errdefer @panic("test failure");
var socket_file = try await try async event.connect(loop, address);
defer socket_file.close();
var buf: [512]u8 = undefined;
const amt_read = try socket_file.read(buf[0..]);
const msg = buf[0..amt_read];
assert(mem.eql(u8, msg, "hello from server\n"));
loop.stop();
} | std/event.zig |
const std = @import("std");
const builtin = @import("builtin");
const testing = std.testing;
const expect = testing.expect;
const expectEqual = testing.expectEqual;
test "params" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(testParamsAdd(22, 11) == 33);
}
fn testParamsAdd(a: i32, b: i32) i32 {
return a + b;
}
test "local variables" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
testLocVars(2);
}
fn testLocVars(b: i32) void {
const a: i32 = 1;
if (a + b != 3) unreachable;
}
test "mutable local variables" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var zero: i32 = 0;
try expect(zero == 0);
var i = @as(i32, 0);
while (i != 3) {
i += 1;
}
try expect(i == 3);
}
test "separate block scopes" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
{
const no_conflict: i32 = 5;
try expect(no_conflict == 5);
}
const c = x: {
const no_conflict = @as(i32, 10);
break :x no_conflict;
};
try expect(c == 10);
}
fn @"weird function name"() i32 {
return 1234;
}
test "weird function name" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(@"weird function name"() == 1234);
}
test "assign inline fn to const variable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const a = inlineFn;
a();
}
inline fn inlineFn() void {}
fn outer(y: u32) *const fn (u32) u32 {
const Y = @TypeOf(y);
const st = struct {
fn get(z: u32) u32 {
return z + @sizeOf(Y);
}
};
return st.get;
}
test "return inner function which references comptime variable of outer function" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
var func = outer(10);
try expect(func(3) == 7);
}
test "discard the result of a function that returns a struct" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
fn entry() void {
_ = func();
}
fn func() Foo {
return undefined;
}
const Foo = struct {
a: u64,
b: u64,
};
};
S.entry();
comptime S.entry();
}
test "inline function call that calls optional function pointer, return pointer at callsite interacts correctly with callsite return type" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
field: u32,
fn doTheTest() !void {
bar2 = actualFn;
const result = try foo();
try expect(result.field == 1234);
}
const Foo = struct { field: u32 };
fn foo() !Foo {
var res: Foo = undefined;
res.field = bar();
return res;
}
inline fn bar() u32 {
return bar2.?();
}
var bar2: ?*const fn () u32 = null;
fn actualFn() u32 {
return 1234;
}
};
try S.doTheTest();
}
test "implicit cast function unreachable return" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
wantsFnWithVoid(fnWithUnreachable);
}
fn wantsFnWithVoid(f: fn () void) void {
_ = f;
}
fn fnWithUnreachable() noreturn {
unreachable;
}
test "extern struct with stdcallcc fn pointer" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = extern struct {
ptr: *const fn () callconv(if (builtin.target.cpu.arch == .i386) .Stdcall else .C) i32,
fn foo() callconv(if (builtin.target.cpu.arch == .i386) .Stdcall else .C) i32 {
return 1234;
}
};
var s: S = undefined;
s.ptr = S.foo;
try expect(s.ptr() == 1234);
}
const nComplexCallconv = 100;
fn fComplexCallconvRet(x: u32) callconv(blk: {
const s: struct { n: u32 } = .{ .n = nComplexCallconv };
break :blk switch (s.n) {
0 => .C,
1 => .Inline,
else => .Unspecified,
};
}) struct { x: u32 } {
return .{ .x = x * x };
}
test "function with complex callconv and return type expressions" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(fComplexCallconvRet(3).x == 9);
}
test "pass by non-copying value" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
}
const Point = struct {
x: i32,
y: i32,
};
fn addPointCoords(pt: Point) i32 {
return pt.x + pt.y;
}
test "pass by non-copying value through var arg" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
}
fn addPointCoordsVar(pt: anytype) !i32 {
comptime try expect(@TypeOf(pt) == Point);
return pt.x + pt.y;
}
test "pass by non-copying value as method" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var pt = Point2{ .x = 1, .y = 2 };
try expect(pt.addPointCoords() == 3);
}
const Point2 = struct {
x: i32,
y: i32,
fn addPointCoords(self: Point2) i32 {
return self.x + self.y;
}
};
test "pass by non-copying value as method, which is generic" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var pt = Point3{ .x = 1, .y = 2 };
try expect(pt.addPointCoords(i32) == 3);
}
const Point3 = struct {
x: i32,
y: i32,
fn addPointCoords(self: Point3, comptime T: type) i32 {
_ = T;
return self.x + self.y;
}
};
test "pass by non-copying value as method, at comptime" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
comptime {
var pt = Point2{ .x = 1, .y = 2 };
try expect(pt.addPointCoords() == 3);
}
}
test "implicit cast fn call result to optional in field result" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
fn entry() !void {
var x = Foo{
.field = optionalPtr(),
};
try expect(x.field.?.* == 999);
}
const glob: i32 = 999;
fn optionalPtr() *const i32 {
return &glob;
}
const Foo = struct {
field: ?*const i32,
};
};
try S.entry();
comptime try S.entry();
}
test "void parameters" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
try voidFun(1, void{}, 2, {});
}
fn voidFun(a: i32, b: void, c: i32, d: void) !void {
_ = d;
const v = b;
const vv: void = if (a == 1) v else {};
try expect(a + c == 3);
return vv;
}
test "call function with empty string" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
acceptsString("");
}
fn acceptsString(foo: []u8) void {
_ = foo;
}
test "function pointers" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
const fns = [_]@TypeOf(fn1){
fn1,
fn2,
fn3,
fn4,
};
for (fns) |f, i| {
try expect(f() == @intCast(u32, i) + 5);
}
}
fn fn1() u32 {
return 5;
}
fn fn2() u32 {
return 6;
}
fn fn3() u32 {
return 7;
}
fn fn4() u32 {
return 8;
}
test "number literal as an argument" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try numberLiteralArg(3);
comptime try numberLiteralArg(3);
}
fn numberLiteralArg(a: anytype) !void {
try expect(a == 3);
}
test "function call with anon list literal" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
try consumeVec(.{ 9, 8, 7 });
}
fn consumeVec(vec: [3]f32) !void {
try expect(vec[0] == 9);
try expect(vec[1] == 8);
try expect(vec[2] == 7);
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "ability to give comptime types and non comptime types to same parameter" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
var x: i32 = 1;
try expect(foo(x) == 10);
try expect(foo(i32) == 20);
}
fn foo(arg: anytype) i32 {
if (@typeInfo(@TypeOf(arg)) == .Type and arg == i32) return 20;
return 9 + arg;
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "function with inferred error set but returning no error" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
const S = struct {
fn foo() !void {}
};
const return_ty = @typeInfo(@TypeOf(S.foo)).Fn.return_type.?;
try expectEqual(0, @typeInfo(@typeInfo(return_ty).ErrorUnion.error_set).ErrorSet.?.len);
} | test/behavior/fn.zig |
const std = @import("std.zig");
const builtin = @import("builtin");
const Os = builtin.Os;
const c = std.c;
const math = std.math;
const debug = std.debug;
const assert = debug.assert;
const os = std.os;
const mem = std.mem;
const meta = std.meta;
const trait = meta.trait;
const Buffer = std.Buffer;
const fmt = std.fmt;
const File = std.os.File;
const testing = std.testing;
const is_posix = builtin.os != builtin.Os.windows;
const is_windows = builtin.os == builtin.Os.windows;
const GetStdIoErrs = os.WindowsGetStdHandleErrs;
pub fn getStdErr() GetStdIoErrs!File {
const handle = if (is_windows) try os.windowsGetStdHandle(os.windows.STD_ERROR_HANDLE) else if (is_posix) os.posix.STDERR_FILENO else unreachable;
return File.openHandle(handle);
}
pub fn getStdOut() GetStdIoErrs!File {
const handle = if (is_windows) try os.windowsGetStdHandle(os.windows.STD_OUTPUT_HANDLE) else if (is_posix) os.posix.STDOUT_FILENO else unreachable;
return File.openHandle(handle);
}
pub fn getStdIn() GetStdIoErrs!File {
const handle = if (is_windows) try os.windowsGetStdHandle(os.windows.STD_INPUT_HANDLE) else if (is_posix) os.posix.STDIN_FILENO else unreachable;
return File.openHandle(handle);
}
pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;
pub fn InStream(comptime ReadError: type) type {
return struct {
const Self = @This();
pub const Error = ReadError;
/// Return the number of bytes read. If the number read is smaller than buf.len, it
/// means the stream reached the end. Reaching the end of a stream is not an error
/// condition.
readFn: fn (self: *Self, buffer: []u8) Error!usize,
/// Replaces `buffer` contents by reading from the stream until it is finished.
/// If `buffer.len()` would exceed `max_size`, `error.StreamTooLong` is returned and
/// the contents read from the stream are lost.
pub fn readAllBuffer(self: *Self, buffer: *Buffer, max_size: usize) !void {
try buffer.resize(0);
var actual_buf_len: usize = 0;
while (true) {
const dest_slice = buffer.toSlice()[actual_buf_len..];
const bytes_read = try self.readFull(dest_slice);
actual_buf_len += bytes_read;
if (bytes_read != dest_slice.len) {
buffer.shrink(actual_buf_len);
return;
}
const new_buf_size = math.min(max_size, actual_buf_len + os.page_size);
if (new_buf_size == actual_buf_len) return error.StreamTooLong;
try buffer.resize(new_buf_size);
}
}
/// Allocates enough memory to hold all the contents of the stream. If the allocated
/// memory would be greater than `max_size`, returns `error.StreamTooLong`.
/// Caller owns returned memory.
/// If this function returns an error, the contents from the stream read so far are lost.
pub fn readAllAlloc(self: *Self, allocator: *mem.Allocator, max_size: usize) ![]u8 {
var buf = Buffer.initNull(allocator);
defer buf.deinit();
try self.readAllBuffer(&buf, max_size);
return buf.toOwnedSlice();
}
/// Replaces `buffer` contents by reading from the stream until `delimiter` is found.
/// Does not include the delimiter in the result.
/// If `buffer.len()` would exceed `max_size`, `error.StreamTooLong` is returned and the contents
/// read from the stream so far are lost.
pub fn readUntilDelimiterBuffer(self: *Self, buffer: *Buffer, delimiter: u8, max_size: usize) !void {
try buffer.resize(0);
while (true) {
var byte: u8 = try self.readByte();
if (byte == delimiter) {
return;
}
if (buffer.len() == max_size) {
return error.StreamTooLong;
}
try buffer.appendByte(byte);
}
}
/// Allocates enough memory to read until `delimiter`. If the allocated
/// memory would be greater than `max_size`, returns `error.StreamTooLong`.
/// Caller owns returned memory.
/// If this function returns an error, the contents from the stream read so far are lost.
pub fn readUntilDelimiterAlloc(self: *Self, allocator: *mem.Allocator, delimiter: u8, max_size: usize) ![]u8 {
var buf = Buffer.initNull(allocator);
defer buf.deinit();
try self.readUntilDelimiterBuffer(&buf, delimiter, max_size);
return buf.toOwnedSlice();
}
/// Returns the number of bytes read. It may be less than buffer.len.
/// If the number of bytes read is 0, it means end of stream.
/// End of stream is not an error condition.
pub fn read(self: *Self, buffer: []u8) Error!usize {
return self.readFn(self, buffer);
}
/// Returns the number of bytes read. If the number read is smaller than buf.len, it
/// means the stream reached the end. Reaching the end of a stream is not an error
/// condition.
pub fn readFull(self: *Self, buffer: []u8) Error!usize {
var index: usize = 0;
while (index != buffer.len) {
const amt = try self.read(buffer[index..]);
if (amt == 0) return index;
index += amt;
}
return index;
}
/// Same as `readFull` but end of stream returns `error.EndOfStream`.
pub fn readNoEof(self: *Self, buf: []u8) !void {
const amt_read = try self.read(buf);
if (amt_read < buf.len) return error.EndOfStream;
}
/// Reads 1 byte from the stream or returns `error.EndOfStream`.
pub fn readByte(self: *Self) !u8 {
var result: [1]u8 = undefined;
try self.readNoEof(result[0..]);
return result[0];
}
/// Same as `readByte` except the returned byte is signed.
pub fn readByteSigned(self: *Self) !i8 {
return @bitCast(i8, try self.readByte());
}
/// Reads a native-endian integer
pub fn readIntNative(self: *Self, comptime T: type) !T {
var bytes: [@sizeOf(T)]u8 = undefined;
try self.readNoEof(bytes[0..]);
return mem.readIntNative(T, &bytes);
}
/// Reads a foreign-endian integer
pub fn readIntForeign(self: *Self, comptime T: type) !T {
var bytes: [@sizeOf(T)]u8 = undefined;
try self.readNoEof(bytes[0..]);
return mem.readIntForeign(T, &bytes);
}
pub fn readIntLittle(self: *Self, comptime T: type) !T {
var bytes: [@sizeOf(T)]u8 = undefined;
try self.readNoEof(bytes[0..]);
return mem.readIntLittle(T, &bytes);
}
pub fn readIntBig(self: *Self, comptime T: type) !T {
var bytes: [@sizeOf(T)]u8 = undefined;
try self.readNoEof(bytes[0..]);
return mem.readIntBig(T, &bytes);
}
pub fn readInt(self: *Self, comptime T: type, endian: builtin.Endian) !T {
var bytes: [@sizeOf(T)]u8 = undefined;
try self.readNoEof(bytes[0..]);
return mem.readInt(T, &bytes, endian);
}
pub fn readVarInt(self: *Self, comptime ReturnType: type, endian: builtin.Endian, size: usize) !ReturnType {
assert(size <= @sizeOf(ReturnType));
var bytes_buf: [@sizeOf(ReturnType)]u8 = undefined;
const bytes = bytes_buf[0..size];
try self.readNoEof(bytes);
return mem.readVarInt(ReturnType, bytes, endian);
}
pub fn skipBytes(self: *Self, num_bytes: usize) !void {
var i: usize = 0;
while (i < num_bytes) : (i += 1) {
_ = try self.readByte();
}
}
pub fn readStruct(self: *Self, comptime T: type) !T {
// Only extern and packed structs have defined in-memory layout.
comptime assert(@typeInfo(T).Struct.layout != builtin.TypeInfo.ContainerLayout.Auto);
var res: [1]T = undefined;
try self.readNoEof(@sliceToBytes(res[0..]));
return res[0];
}
};
}
pub fn OutStream(comptime WriteError: type) type {
return struct {
const Self = @This();
pub const Error = WriteError;
writeFn: fn (self: *Self, bytes: []const u8) Error!void,
pub fn print(self: *Self, comptime format: []const u8, args: ...) Error!void {
return std.fmt.format(self, Error, self.writeFn, format, args);
}
pub fn write(self: *Self, bytes: []const u8) Error!void {
return self.writeFn(self, bytes);
}
pub fn writeByte(self: *Self, byte: u8) Error!void {
const slice = (*const [1]u8)(&byte)[0..];
return self.writeFn(self, slice);
}
pub fn writeByteNTimes(self: *Self, byte: u8, n: usize) Error!void {
const slice = (*const [1]u8)(&byte)[0..];
var i: usize = 0;
while (i < n) : (i += 1) {
try self.writeFn(self, slice);
}
}
/// Write a native-endian integer.
pub fn writeIntNative(self: *Self, comptime T: type, value: T) Error!void {
var bytes: [@sizeOf(T)]u8 = undefined;
mem.writeIntNative(T, &bytes, value);
return self.writeFn(self, bytes);
}
/// Write a foreign-endian integer.
pub fn writeIntForeign(self: *Self, comptime T: type, value: T) Error!void {
var bytes: [@sizeOf(T)]u8 = undefined;
mem.writeIntForeign(T, &bytes, value);
return self.writeFn(self, bytes);
}
pub fn writeIntLittle(self: *Self, comptime T: type, value: T) Error!void {
var bytes: [@sizeOf(T)]u8 = undefined;
mem.writeIntLittle(T, &bytes, value);
return self.writeFn(self, bytes);
}
pub fn writeIntBig(self: *Self, comptime T: type, value: T) Error!void {
var bytes: [@sizeOf(T)]u8 = undefined;
mem.writeIntBig(T, &bytes, value);
return self.writeFn(self, bytes);
}
pub fn writeInt(self: *Self, comptime T: type, value: T, endian: builtin.Endian) Error!void {
var bytes: [@sizeOf(T)]u8 = undefined;
mem.writeInt(T, &bytes, value, endian);
return self.writeFn(self, bytes);
}
};
}
pub fn writeFile(path: []const u8, data: []const u8) !void {
var file = try File.openWrite(path);
defer file.close();
try file.write(data);
}
/// On success, caller owns returned buffer.
pub fn readFileAlloc(allocator: *mem.Allocator, path: []const u8) ![]u8 {
return readFileAllocAligned(allocator, path, @alignOf(u8));
}
/// On success, caller owns returned buffer.
pub fn readFileAllocAligned(allocator: *mem.Allocator, path: []const u8, comptime A: u29) ![]align(A) u8 {
var file = try File.openRead(path);
defer file.close();
const size = try file.getEndPos();
const buf = try allocator.alignedAlloc(u8, A, size);
errdefer allocator.free(buf);
var adapter = file.inStream();
try adapter.stream.readNoEof(buf[0..size]);
return buf;
}
pub fn BufferedInStream(comptime Error: type) type {
return BufferedInStreamCustom(os.page_size, Error);
}
pub fn BufferedInStreamCustom(comptime buffer_size: usize, comptime Error: type) type {
return struct {
const Self = @This();
const Stream = InStream(Error);
pub stream: Stream,
unbuffered_in_stream: *Stream,
buffer: [buffer_size]u8,
start_index: usize,
end_index: usize,
pub fn init(unbuffered_in_stream: *Stream) Self {
return Self{
.unbuffered_in_stream = unbuffered_in_stream,
.buffer = undefined,
// Initialize these two fields to buffer_size so that
// in `readFn` we treat the state as being able to read
// more from the unbuffered stream. If we set them to 0
// and 0, the code would think we already hit EOF.
.start_index = buffer_size,
.end_index = buffer_size,
.stream = Stream{ .readFn = readFn },
};
}
fn readFn(in_stream: *Stream, dest: []u8) !usize {
const self = @fieldParentPtr(Self, "stream", in_stream);
var dest_index: usize = 0;
while (true) {
const dest_space = dest.len - dest_index;
if (dest_space == 0) {
return dest_index;
}
const amt_buffered = self.end_index - self.start_index;
if (amt_buffered == 0) {
assert(self.end_index <= buffer_size);
// Make sure the last read actually gave us some data
if (self.end_index == 0) {
// reading from the unbuffered stream returned nothing
// so we have nothing left to read.
return dest_index;
}
// we can read more data from the unbuffered stream
if (dest_space < buffer_size) {
self.start_index = 0;
self.end_index = try self.unbuffered_in_stream.read(self.buffer[0..]);
} else {
// asking for so much data that buffering is actually less efficient.
// forward the request directly to the unbuffered stream
const amt_read = try self.unbuffered_in_stream.read(dest[dest_index..]);
return dest_index + amt_read;
}
}
const copy_amount = math.min(dest_space, amt_buffered);
const copy_end_index = self.start_index + copy_amount;
mem.copy(u8, dest[dest_index..], self.buffer[self.start_index..copy_end_index]);
self.start_index = copy_end_index;
dest_index += copy_amount;
}
}
};
}
test "io.BufferedInStream" {
const OneByteReadInStream = struct {
const Error = error{NoError};
const Stream = InStream(Error);
stream: Stream,
str: []const u8,
curr: usize,
fn init(str: []const u8) @This() {
return @This(){
.stream = Stream{ .readFn = readFn },
.str = str,
.curr = 0,
};
}
fn readFn(in_stream: *Stream, dest: []u8) Error!usize {
const self = @fieldParentPtr(@This(), "stream", in_stream);
if (self.str.len <= self.curr or dest.len == 0)
return 0;
dest[0] = self.str[self.curr];
self.curr += 1;
return 1;
}
};
var buf: [100]u8 = undefined;
const allocator = &std.heap.FixedBufferAllocator.init(buf[0..]).allocator;
const str = "This is a test";
var one_byte_stream = OneByteReadInStream.init(str);
var buf_in_stream = BufferedInStream(OneByteReadInStream.Error).init(&one_byte_stream.stream);
const stream = &buf_in_stream.stream;
const res = try stream.readAllAlloc(allocator, str.len + 1);
testing.expectEqualSlices(u8, str, res);
}
/// Creates a stream which supports 'un-reading' data, so that it can be read again.
/// This makes look-ahead style parsing much easier.
pub fn PeekStream(comptime buffer_size: usize, comptime InStreamError: type) type {
return struct {
const Self = @This();
pub const Error = InStreamError;
pub const Stream = InStream(Error);
pub stream: Stream,
base: *Stream,
// Right now the look-ahead space is statically allocated, but a version with dynamic allocation
// is not too difficult to derive from this.
buffer: [buffer_size]u8,
index: usize,
at_end: bool,
pub fn init(base: *Stream) Self {
return Self{
.base = base,
.buffer = undefined,
.index = 0,
.at_end = false,
.stream = Stream{ .readFn = readFn },
};
}
pub fn putBackByte(self: *Self, byte: u8) void {
self.buffer[self.index] = byte;
self.index += 1;
}
pub fn putBack(self: *Self, bytes: []const u8) void {
var pos = bytes.len;
while (pos != 0) {
pos -= 1;
self.putBackByte(bytes[pos]);
}
}
fn readFn(in_stream: *Stream, dest: []u8) Error!usize {
const self = @fieldParentPtr(Self, "stream", in_stream);
// copy over anything putBack()'d
var pos: usize = 0;
while (pos < dest.len and self.index != 0) {
dest[pos] = self.buffer[self.index - 1];
self.index -= 1;
pos += 1;
}
if (pos == dest.len or self.at_end) {
return pos;
}
// ask the backing stream for more
const left = dest.len - pos;
const read = try self.base.read(dest[pos..]);
assert(read <= left);
self.at_end = (read < left);
return pos + read;
}
};
}
pub const SliceInStream = struct {
const Self = @This();
pub const Error = error{};
pub const Stream = InStream(Error);
pub stream: Stream,
pos: usize,
slice: []const u8,
pub fn init(slice: []const u8) Self {
return Self{
.slice = slice,
.pos = 0,
.stream = Stream{ .readFn = readFn },
};
}
fn readFn(in_stream: *Stream, dest: []u8) Error!usize {
const self = @fieldParentPtr(Self, "stream", in_stream);
const size = math.min(dest.len, self.slice.len - self.pos);
const end = self.pos + size;
mem.copy(u8, dest[0..size], self.slice[self.pos..end]);
self.pos = end;
return size;
}
};
/// Creates a stream which allows for reading bit fields from another stream
pub fn BitInStream(endian: builtin.Endian, comptime Error: type) type {
return struct {
const Self = @This();
in_stream: *Stream,
bit_buffer: u7,
bit_count: u3,
stream: Stream,
pub const Stream = InStream(Error);
const u8_bit_count = comptime meta.bitCount(u8);
const u7_bit_count = comptime meta.bitCount(u7);
const u4_bit_count = comptime meta.bitCount(u4);
pub fn init(in_stream: *Stream) Self {
return Self{
.in_stream = in_stream,
.bit_buffer = 0,
.bit_count = 0,
.stream = Stream{ .readFn = read },
};
}
/// Reads `bits` bits from the stream and returns a specified unsigned int type
/// containing them in the least significant end, returning an error if the
/// specified number of bits could not be read.
pub fn readBitsNoEof(self: *Self, comptime U: type, bits: usize) !U {
var n: usize = undefined;
const result = try self.readBits(U, bits, &n);
if (n < bits) return error.EndOfStream;
return result;
}
/// Reads `bits` bits from the stream and returns a specified unsigned int type
/// containing them in the least significant end. The number of bits successfully
/// read is placed in `out_bits`, as reaching the end of the stream is not an error.
pub fn readBits(self: *Self, comptime U: type, bits: usize, out_bits: *usize) Error!U {
comptime assert(trait.isUnsignedInt(U));
//by extending the buffer to a minimum of u8 we can cover a number of edge cases
// related to shifting and casting.
const u_bit_count = comptime meta.bitCount(U);
const buf_bit_count = bc: {
assert(u_bit_count >= bits);
break :bc if (u_bit_count <= u8_bit_count) u8_bit_count else u_bit_count;
};
const Buf = @IntType(false, buf_bit_count);
const BufShift = math.Log2Int(Buf);
out_bits.* = usize(0);
if (U == u0 or bits == 0) return 0;
var out_buffer = Buf(0);
if (self.bit_count > 0) {
const n = if (self.bit_count >= bits) @intCast(u3, bits) else self.bit_count;
const shift = u7_bit_count - n;
switch (endian) {
builtin.Endian.Big => {
out_buffer = Buf(self.bit_buffer >> shift);
self.bit_buffer <<= n;
},
builtin.Endian.Little => {
const value = (self.bit_buffer << shift) >> shift;
out_buffer = Buf(value);
self.bit_buffer >>= n;
},
}
self.bit_count -= n;
out_bits.* = n;
}
//at this point we know bit_buffer is empty
//copy bytes until we have enough bits, then leave the rest in bit_buffer
while (out_bits.* < bits) {
const n = bits - out_bits.*;
const next_byte = self.in_stream.readByte() catch |err| {
if (err == error.EndOfStream) {
return @intCast(U, out_buffer);
}
//@BUG: See #1810. Not sure if the bug is that I have to do this for some
// streams, or that I don't for streams with emtpy errorsets.
return @errSetCast(Error, err);
};
switch (endian) {
builtin.Endian.Big => {
if (n >= u8_bit_count) {
out_buffer <<= @intCast(u3, u8_bit_count - 1);
out_buffer <<= 1;
out_buffer |= Buf(next_byte);
out_bits.* += u8_bit_count;
continue;
}
const shift = @intCast(u3, u8_bit_count - n);
out_buffer <<= @intCast(BufShift, n);
out_buffer |= Buf(next_byte >> shift);
out_bits.* += n;
self.bit_buffer = @truncate(u7, next_byte << @intCast(u3, n - 1));
self.bit_count = shift;
},
builtin.Endian.Little => {
if (n >= u8_bit_count) {
out_buffer |= Buf(next_byte) << @intCast(BufShift, out_bits.*);
out_bits.* += u8_bit_count;
continue;
}
const shift = @intCast(u3, u8_bit_count - n);
const value = (next_byte << shift) >> shift;
out_buffer |= Buf(value) << @intCast(BufShift, out_bits.*);
out_bits.* += n;
self.bit_buffer = @truncate(u7, next_byte >> @intCast(u3, n));
self.bit_count = shift;
},
}
}
return @intCast(U, out_buffer);
}
pub fn alignToByte(self: *Self) void {
self.bit_buffer = 0;
self.bit_count = 0;
}
pub fn read(self_stream: *Stream, buffer: []u8) Error!usize {
var self = @fieldParentPtr(Self, "stream", self_stream);
var out_bits: usize = undefined;
var out_bits_total = usize(0);
//@NOTE: I'm not sure this is a good idea, maybe alignToByte should be forced
if (self.bit_count > 0) {
for (buffer) |*b, i| {
b.* = try self.readBits(u8, u8_bit_count, &out_bits);
out_bits_total += out_bits;
}
const incomplete_byte = @boolToInt(out_bits_total % u8_bit_count > 0);
return (out_bits_total / u8_bit_count) + incomplete_byte;
}
return self.in_stream.read(buffer);
}
};
}
/// This is a simple OutStream that writes to a slice, and returns an error
/// when it runs out of space.
pub const SliceOutStream = struct {
pub const Error = error{OutOfSpace};
pub const Stream = OutStream(Error);
pub stream: Stream,
pub pos: usize,
slice: []u8,
pub fn init(slice: []u8) SliceOutStream {
return SliceOutStream{
.slice = slice,
.pos = 0,
.stream = Stream{ .writeFn = writeFn },
};
}
pub fn getWritten(self: *const SliceOutStream) []const u8 {
return self.slice[0..self.pos];
}
pub fn reset(self: *SliceOutStream) void {
self.pos = 0;
}
fn writeFn(out_stream: *Stream, bytes: []const u8) Error!void {
const self = @fieldParentPtr(SliceOutStream, "stream", out_stream);
assert(self.pos <= self.slice.len);
const n = if (self.pos + bytes.len <= self.slice.len)
bytes.len
else
self.slice.len - self.pos;
std.mem.copy(u8, self.slice[self.pos .. self.pos + n], bytes[0..n]);
self.pos += n;
if (n < bytes.len) {
return Error.OutOfSpace;
}
}
};
test "io.SliceOutStream" {
var buf: [255]u8 = undefined;
var slice_stream = SliceOutStream.init(buf[0..]);
const stream = &slice_stream.stream;
try stream.print("{}{}!", "Hello", "World");
testing.expectEqualSlices(u8, "HelloWorld!", slice_stream.getWritten());
}
var null_out_stream_state = NullOutStream.init();
pub const null_out_stream = &null_out_stream_state.stream;
/// An OutStream that doesn't write to anything.
pub const NullOutStream = struct {
pub const Error = error{};
pub const Stream = OutStream(Error);
pub stream: Stream,
pub fn init() NullOutStream {
return NullOutStream{
.stream = Stream{ .writeFn = writeFn },
};
}
fn writeFn(out_stream: *Stream, bytes: []const u8) Error!void {}
};
test "io.NullOutStream" {
var null_stream = NullOutStream.init();
const stream = &null_stream.stream;
stream.write("yay" ** 10000) catch unreachable;
}
/// An OutStream that counts how many bytes has been written to it.
pub fn CountingOutStream(comptime OutStreamError: type) type {
return struct {
const Self = @This();
pub const Stream = OutStream(Error);
pub const Error = OutStreamError;
pub stream: Stream,
pub bytes_written: usize,
child_stream: *Stream,
pub fn init(child_stream: *Stream) Self {
return Self{
.stream = Stream{ .writeFn = writeFn },
.bytes_written = 0,
.child_stream = child_stream,
};
}
fn writeFn(out_stream: *Stream, bytes: []const u8) OutStreamError!void {
const self = @fieldParentPtr(Self, "stream", out_stream);
try self.child_stream.write(bytes);
self.bytes_written += bytes.len;
}
};
}
test "io.CountingOutStream" {
var null_stream = NullOutStream.init();
var counting_stream = CountingOutStream(NullOutStream.Error).init(&null_stream.stream);
const stream = &counting_stream.stream;
const bytes = "yay" ** 10000;
stream.write(bytes) catch unreachable;
testing.expect(counting_stream.bytes_written == bytes.len);
}
pub fn BufferedOutStream(comptime Error: type) type {
return BufferedOutStreamCustom(os.page_size, Error);
}
pub fn BufferedOutStreamCustom(comptime buffer_size: usize, comptime OutStreamError: type) type {
return struct {
const Self = @This();
pub const Stream = OutStream(Error);
pub const Error = OutStreamError;
pub stream: Stream,
unbuffered_out_stream: *Stream,
buffer: [buffer_size]u8,
index: usize,
pub fn init(unbuffered_out_stream: *Stream) Self {
return Self{
.unbuffered_out_stream = unbuffered_out_stream,
.buffer = undefined,
.index = 0,
.stream = Stream{ .writeFn = writeFn },
};
}
pub fn flush(self: *Self) !void {
try self.unbuffered_out_stream.write(self.buffer[0..self.index]);
self.index = 0;
}
fn writeFn(out_stream: *Stream, bytes: []const u8) !void {
const self = @fieldParentPtr(Self, "stream", out_stream);
if (bytes.len >= self.buffer.len) {
try self.flush();
return self.unbuffered_out_stream.write(bytes);
}
var src_index: usize = 0;
while (src_index < bytes.len) {
const dest_space_left = self.buffer.len - self.index;
const copy_amt = math.min(dest_space_left, bytes.len - src_index);
mem.copy(u8, self.buffer[self.index..], bytes[src_index .. src_index + copy_amt]);
self.index += copy_amt;
assert(self.index <= self.buffer.len);
if (self.index == self.buffer.len) {
try self.flush();
}
src_index += copy_amt;
}
}
};
}
/// Implementation of OutStream trait for Buffer
pub const BufferOutStream = struct {
buffer: *Buffer,
stream: Stream,
pub const Error = error{OutOfMemory};
pub const Stream = OutStream(Error);
pub fn init(buffer: *Buffer) BufferOutStream {
return BufferOutStream{
.buffer = buffer,
.stream = Stream{ .writeFn = writeFn },
};
}
fn writeFn(out_stream: *Stream, bytes: []const u8) !void {
const self = @fieldParentPtr(BufferOutStream, "stream", out_stream);
return self.buffer.append(bytes);
}
};
/// Creates a stream which allows for writing bit fields to another stream
pub fn BitOutStream(endian: builtin.Endian, comptime Error: type) type {
return struct {
const Self = @This();
out_stream: *Stream,
bit_buffer: u8,
bit_count: u4,
stream: Stream,
pub const Stream = OutStream(Error);
const u8_bit_count = comptime meta.bitCount(u8);
const u4_bit_count = comptime meta.bitCount(u4);
pub fn init(out_stream: *Stream) Self {
return Self{
.out_stream = out_stream,
.bit_buffer = 0,
.bit_count = 0,
.stream = Stream{ .writeFn = write },
};
}
/// Write the specified number of bits to the stream from the least significant bits of
/// the specified unsigned int value. Bits will only be written to the stream when there
/// are enough to fill a byte.
pub fn writeBits(self: *Self, value: var, bits: usize) Error!void {
if (bits == 0) return;
const U = @typeOf(value);
comptime assert(trait.isUnsignedInt(U));
//by extending the buffer to a minimum of u8 we can cover a number of edge cases
// related to shifting and casting.
const u_bit_count = comptime meta.bitCount(U);
const buf_bit_count = bc: {
assert(u_bit_count >= bits);
break :bc if (u_bit_count <= u8_bit_count) u8_bit_count else u_bit_count;
};
const Buf = @IntType(false, buf_bit_count);
const BufShift = math.Log2Int(Buf);
const buf_value = @intCast(Buf, value);
const high_byte_shift = @intCast(BufShift, buf_bit_count - u8_bit_count);
var in_buffer = switch (endian) {
builtin.Endian.Big => buf_value << @intCast(BufShift, buf_bit_count - bits),
builtin.Endian.Little => buf_value,
};
var in_bits = bits;
if (self.bit_count > 0) {
const bits_remaining = u8_bit_count - self.bit_count;
const n = @intCast(u3, if (bits_remaining > bits) bits else bits_remaining);
switch (endian) {
builtin.Endian.Big => {
const shift = @intCast(BufShift, high_byte_shift + self.bit_count);
const v = @intCast(u8, in_buffer >> shift);
self.bit_buffer |= v;
in_buffer <<= n;
},
builtin.Endian.Little => {
const v = @truncate(u8, in_buffer) << @intCast(u3, self.bit_count);
self.bit_buffer |= v;
in_buffer >>= n;
},
}
self.bit_count += n;
in_bits -= n;
//if we didn't fill the buffer, it's because bits < bits_remaining;
if (self.bit_count != u8_bit_count) return;
try self.out_stream.writeByte(self.bit_buffer);
self.bit_buffer = 0;
self.bit_count = 0;
}
//at this point we know bit_buffer is empty
//copy bytes until we can't fill one anymore, then leave the rest in bit_buffer
while (in_bits >= u8_bit_count) {
switch (endian) {
builtin.Endian.Big => {
const v = @intCast(u8, in_buffer >> high_byte_shift);
try self.out_stream.writeByte(v);
in_buffer <<= @intCast(u3, u8_bit_count - 1);
in_buffer <<= 1;
},
builtin.Endian.Little => {
const v = @truncate(u8, in_buffer);
try self.out_stream.writeByte(v);
in_buffer >>= @intCast(u3, u8_bit_count - 1);
in_buffer >>= 1;
},
}
in_bits -= u8_bit_count;
}
if (in_bits > 0) {
self.bit_count = @intCast(u4, in_bits);
self.bit_buffer = switch (endian) {
builtin.Endian.Big => @truncate(u8, in_buffer >> high_byte_shift),
builtin.Endian.Little => @truncate(u8, in_buffer),
};
}
}
/// Flush any remaining bits to the stream.
pub fn flushBits(self: *Self) Error!void {
if (self.bit_count == 0) return;
try self.out_stream.writeByte(self.bit_buffer);
self.bit_buffer = 0;
self.bit_count = 0;
}
pub fn write(self_stream: *Stream, buffer: []const u8) Error!void {
var self = @fieldParentPtr(Self, "stream", self_stream);
//@NOTE: I'm not sure this is a good idea, maybe flushBits should be forced
if (self.bit_count > 0) {
for (buffer) |b, i|
try self.writeBits(b, u8_bit_count);
return;
}
return self.out_stream.write(buffer);
}
};
}
pub const BufferedAtomicFile = struct {
atomic_file: os.AtomicFile,
file_stream: os.File.OutStream,
buffered_stream: BufferedOutStream(os.File.WriteError),
allocator: *mem.Allocator,
pub fn create(allocator: *mem.Allocator, dest_path: []const u8) !*BufferedAtomicFile {
// TODO with well defined copy elision we don't need this allocation
var self = try allocator.create(BufferedAtomicFile);
self.* = BufferedAtomicFile{
.atomic_file = undefined,
.file_stream = undefined,
.buffered_stream = undefined,
.allocator = allocator,
};
errdefer allocator.destroy(self);
self.atomic_file = try os.AtomicFile.init(dest_path, os.File.default_mode);
errdefer self.atomic_file.deinit();
self.file_stream = self.atomic_file.file.outStream();
self.buffered_stream = BufferedOutStream(os.File.WriteError).init(&self.file_stream.stream);
return self;
}
/// always call destroy, even after successful finish()
pub fn destroy(self: *BufferedAtomicFile) void {
self.atomic_file.deinit();
self.allocator.destroy(self);
}
pub fn finish(self: *BufferedAtomicFile) !void {
try self.buffered_stream.flush();
try self.atomic_file.finish();
}
pub fn stream(self: *BufferedAtomicFile) *OutStream(os.File.WriteError) {
return &self.buffered_stream.stream;
}
};
pub fn readLine(buf: *std.Buffer) ![]u8 {
var stdin = try getStdIn();
var stdin_stream = stdin.inStream();
return readLineFrom(&stdin_stream.stream, buf);
}
/// Reads all characters until the next newline into buf, and returns
/// a slice of the characters read (excluding the newline character(s)).
pub fn readLineFrom(stream: var, buf: *std.Buffer) ![]u8 {
const start = buf.len();
while (true) {
const byte = try stream.readByte();
switch (byte) {
'\r' => {
// trash the following \n
_ = try stream.readByte();
return buf.toSlice()[start..];
},
'\n' => return buf.toSlice()[start..],
else => try buf.appendByte(byte),
}
}
}
test "io.readLineFrom" {
var bytes: [128]u8 = undefined;
const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
var buf = try std.Buffer.initSize(allocator, 0);
var mem_stream = SliceInStream.init(
\\Line 1
\\Line 22
\\Line 333
);
const stream = &mem_stream.stream;
testing.expectEqualSlices(u8, "Line 1", try readLineFrom(stream, &buf));
testing.expectEqualSlices(u8, "Line 22", try readLineFrom(stream, &buf));
testing.expectError(error.EndOfStream, readLineFrom(stream, &buf));
testing.expectEqualSlices(u8, "Line 1Line 22Line 333", buf.toSlice());
}
pub fn readLineSlice(slice: []u8) ![]u8 {
var stdin = try getStdIn();
var stdin_stream = stdin.inStream();
return readLineSliceFrom(&stdin_stream.stream, slice);
}
/// Reads all characters until the next newline into slice, and returns
/// a slice of the characters read (excluding the newline character(s)).
pub fn readLineSliceFrom(stream: var, slice: []u8) ![]u8 {
// We cannot use Buffer.fromOwnedSlice, as it wants to append a null byte
// after taking ownership, which would always require an allocation.
var buf = std.Buffer{ .list = std.ArrayList(u8).fromOwnedSlice(debug.failing_allocator, slice) };
try buf.resize(0);
return try readLineFrom(stream, &buf);
}
test "io.readLineSliceFrom" {
var buf: [7]u8 = undefined;
var mem_stream = SliceInStream.init(
\\Line 1
\\Line 22
\\Line 333
);
const stream = &mem_stream.stream;
testing.expectEqualSlices(u8, "Line 1", try readLineSliceFrom(stream, buf[0..]));
testing.expectError(error.OutOfMemory, readLineSliceFrom(stream, buf[0..]));
}
pub const Packing = enum {
Byte, /// Pack data to byte alignment
Bit, /// Pack data to bit alignment
};
/// Creates a deserializer that deserializes types from any stream.
/// If `is_packed` is true, the data stream is treated as bit-packed,
/// otherwise data is expected to be packed to the smallest byte.
/// Types may implement a custom deserialization routine with a
/// function named `deserialize` in the form of:
/// pub fn deserialize(self: *Self, deserializer: var) !void
/// which will be called when the deserializer is used to deserialize
/// that type. It will pass a pointer to the type instance to deserialize
/// into and a pointer to the deserializer struct.
pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing, comptime Error: type) type {
return struct {
const Self = @This();
in_stream: if (packing == .Bit) BitInStream(endian, Stream.Error) else *Stream,
pub const Stream = InStream(Error);
pub fn init(in_stream: *Stream) Self {
return Self{ .in_stream = switch (packing) {
.Bit => BitInStream(endian, Stream.Error).init(in_stream),
.Byte => in_stream,
} };
}
pub fn alignToByte(self: *Self) void {
if (!is_packed) return;
self.in_stream.alignToByte();
}
//@BUG: inferred error issue. See: #1386
fn deserializeInt(self: *Self, comptime T: type) (Error || error{EndOfStream})!T {
comptime assert(trait.is(builtin.TypeId.Int)(T) or trait.is(builtin.TypeId.Float)(T));
const u8_bit_count = 8;
const t_bit_count = comptime meta.bitCount(T);
const U = @IntType(false, t_bit_count);
const Log2U = math.Log2Int(U);
const int_size = (U.bit_count + 7) / 8;
if (packing == .Bit) {
const result = try self.in_stream.readBitsNoEof(U, t_bit_count);
return @bitCast(T, result);
}
var buffer: [int_size]u8 = undefined;
const read_size = try self.in_stream.read(buffer[0..]);
if (read_size < int_size) return error.EndOfStream;
if (int_size == 1) {
if (t_bit_count == 8) return @bitCast(T, buffer[0]);
const PossiblySignedByte = @IntType(T.is_signed, 8);
return @truncate(T, @bitCast(PossiblySignedByte, buffer[0]));
}
var result = U(0);
for (buffer) |byte, i| {
switch (endian) {
builtin.Endian.Big => {
result = (result << u8_bit_count) | byte;
},
builtin.Endian.Little => {
result |= U(byte) << @intCast(Log2U, u8_bit_count * i);
},
}
}
return @bitCast(T, result);
}
//@TODO: Replace this with @unionInit or whatever when it is added
// see: #1315
fn setTag(ptr: var, tag: var) void {
const T = @typeOf(ptr);
comptime assert(trait.isPtrTo(builtin.TypeId.Union)(T));
const U = meta.Child(T);
const info = @typeInfo(U).Union;
if (info.tag_type) |TagType| {
comptime assert(TagType == @typeOf(tag));
var ptr_tag = ptr: {
if (@alignOf(TagType) >= @alignOf(U)) break :ptr @ptrCast(*TagType, ptr);
const offset = comptime max: {
var max_field_size: comptime_int = 0;
for (info.fields) |field_info| {
const field_size = @sizeOf(field_info.field_type);
max_field_size = math.max(max_field_size, field_size);
}
break :max math.max(max_field_size, @alignOf(U));
};
break :ptr @intToPtr(*TagType, @ptrToInt(ptr) + offset);
};
ptr_tag.* = tag;
}
}
/// Deserializes and returns data of the specified type from the stream
pub fn deserialize(self: *Self, comptime T: type) !T {
var value: T = undefined;
try self.deserializeInto(&value);
return value;
}
/// Deserializes data into the type pointed to by `ptr`
pub fn deserializeInto(self: *Self, ptr: var) !void {
const T = @typeOf(ptr);
comptime assert(trait.is(builtin.TypeId.Pointer)(T));
if (comptime trait.isSlice(T) or comptime trait.isPtrTo(builtin.TypeId.Array)(T)) {
for (ptr) |*v|
try self.deserializeInto(v);
return;
}
comptime assert(trait.isSingleItemPtr(T));
const C = comptime meta.Child(T);
const child_type_id = @typeId(C);
//custom deserializer: fn(self: *Self, deserializer: var) !void
if (comptime trait.hasFn("deserialize")(C)) return C.deserialize(ptr, self);
if (comptime trait.isPacked(C) and packing != .Bit) {
var packed_deserializer = Deserializer(endian, .Bit, Error).init(self.in_stream);
return packed_deserializer.deserializeInto(ptr);
}
switch (child_type_id) {
builtin.TypeId.Void => return,
builtin.TypeId.Bool => ptr.* = (try self.deserializeInt(u1)) > 0,
builtin.TypeId.Float, builtin.TypeId.Int => ptr.* = try self.deserializeInt(C),
builtin.TypeId.Struct => {
const info = @typeInfo(C).Struct;
inline for (info.fields) |*field_info| {
const name = field_info.name;
const FieldType = field_info.field_type;
if (FieldType == void or FieldType == u0) continue;
//it doesn't make any sense to read pointers
if (comptime trait.is(builtin.TypeId.Pointer)(FieldType)) {
@compileError("Will not " ++ "read field " ++ name ++ " of struct " ++
@typeName(C) ++ " because it " ++ "is of pointer-type " ++
@typeName(FieldType) ++ ".");
}
try self.deserializeInto(&@field(ptr, name));
}
},
builtin.TypeId.Union => {
const info = @typeInfo(C).Union;
if (info.tag_type) |TagType| {
//we avoid duplicate iteration over the enum tags
// by getting the int directly and casting it without
// safety. If it is bad, it will be caught anyway.
const TagInt = @TagType(TagType);
const tag = try self.deserializeInt(TagInt);
{
@setRuntimeSafety(false);
//See: #1315
setTag(ptr, @intToEnum(TagType, tag));
}
inline for (info.fields) |field_info| {
if (field_info.enum_field.?.value == tag) {
const name = field_info.name;
const FieldType = field_info.field_type;
@field(ptr, name) = FieldType(undefined);
try self.deserializeInto(&@field(ptr, name));
return;
}
}
//This is reachable if the enum data is bad
return error.InvalidEnumTag;
}
@compileError("Cannot meaningfully deserialize " ++ @typeName(C) ++
" because it is an untagged union. Use a custom deserialize().");
},
builtin.TypeId.Optional => {
const OC = comptime meta.Child(C);
const exists = (try self.deserializeInt(u1)) > 0;
if (!exists) {
ptr.* = null;
return;
}
ptr.* = OC(undefined); //make it non-null so the following .? is guaranteed safe
const val_ptr = &ptr.*.?;
try self.deserializeInto(val_ptr);
},
builtin.TypeId.Enum => {
var value = try self.deserializeInt(@TagType(C));
ptr.* = try meta.intToEnum(C, value);
},
else => {
@compileError("Cannot deserialize " ++ @tagName(child_type_id) ++ " types (unimplemented).");
},
}
}
};
}
/// Creates a serializer that serializes types to any stream.
/// If `is_packed` is true, the data will be bit-packed into the stream.
/// Note that the you must call `serializer.flush()` when you are done
/// writing bit-packed data in order ensure any unwritten bits are committed.
/// If `is_packed` is false, data is packed to the smallest byte. In the case
/// of packed structs, the struct will written bit-packed and with the specified
/// endianess, after which data will resume being written at the next byte boundary.
/// Types may implement a custom serialization routine with a
/// function named `serialize` in the form of:
/// pub fn serialize(self: Self, serializer: var) !void
/// which will be called when the serializer is used to serialize that type. It will
/// pass a const pointer to the type instance to be serialized and a pointer
/// to the serializer struct.
pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, comptime Error: type) type {
return struct {
const Self = @This();
out_stream: if (packing == .Bit) BitOutStream(endian, Stream.Error) else *Stream,
pub const Stream = OutStream(Error);
pub fn init(out_stream: *Stream) Self {
return Self{ .out_stream = switch (packing) {
.Bit => BitOutStream(endian, Stream.Error).init(out_stream),
.Byte => out_stream,
} };
}
/// Flushes any unwritten bits to the stream
pub fn flush(self: *Self) Error!void {
if (packing == .Bit) return self.out_stream.flushBits();
}
fn serializeInt(self: *Self, value: var) Error!void {
const T = @typeOf(value);
comptime assert(trait.is(builtin.TypeId.Int)(T) or trait.is(builtin.TypeId.Float)(T));
const t_bit_count = comptime meta.bitCount(T);
const u8_bit_count = comptime meta.bitCount(u8);
const U = @IntType(false, t_bit_count);
const Log2U = math.Log2Int(U);
const int_size = (U.bit_count + 7) / 8;
const u_value = @bitCast(U, value);
if (packing == .Bit) return self.out_stream.writeBits(u_value, t_bit_count);
var buffer: [int_size]u8 = undefined;
if (int_size == 1) buffer[0] = u_value;
for (buffer) |*byte, i| {
const idx = switch (endian) {
.Big => int_size - i - 1,
.Little => i,
};
const shift = @intCast(Log2U, idx * u8_bit_count);
const v = u_value >> shift;
byte.* = if (t_bit_count < u8_bit_count) v else @truncate(u8, v);
}
try self.out_stream.write(buffer);
}
/// Serializes the passed value into the stream
pub fn serialize(self: *Self, value: var) Error!void {
const T = comptime @typeOf(value);
if (comptime trait.isIndexable(T)) {
for (value) |v|
try self.serialize(v);
return;
}
//custom serializer: fn(self: Self, serializer: var) !void
if (comptime trait.hasFn("serialize")(T)) return T.serialize(value, self);
if (comptime trait.isPacked(T) and packing != .Bit) {
var packed_serializer = Serializer(endian, .Bit, Error).init(self.out_stream);
try packed_serializer.serialize(value);
try packed_serializer.flush();
return;
}
switch (@typeId(T)) {
builtin.TypeId.Void => return,
builtin.TypeId.Bool => try self.serializeInt(u1(@boolToInt(value))),
builtin.TypeId.Float, builtin.TypeId.Int => try self.serializeInt(value),
builtin.TypeId.Struct => {
const info = @typeInfo(T);
inline for (info.Struct.fields) |*field_info| {
const name = field_info.name;
const FieldType = field_info.field_type;
if (FieldType == void or FieldType == u0) continue;
//It doesn't make sense to write pointers
if (comptime trait.is(builtin.TypeId.Pointer)(FieldType)) {
@compileError("Will not " ++ "serialize field " ++ name ++
" of struct " ++ @typeName(T) ++ " because it " ++
"is of pointer-type " ++ @typeName(FieldType) ++ ".");
}
try self.serialize(@field(value, name));
}
},
builtin.TypeId.Union => {
const info = @typeInfo(T).Union;
if (info.tag_type) |TagType| {
const active_tag = meta.activeTag(value);
try self.serialize(active_tag);
//This inline loop is necessary because active_tag is a runtime
// value, but @field requires a comptime value. Our alternative
// is to check each field for a match
inline for (info.fields) |field_info| {
if (field_info.enum_field.?.value == @enumToInt(active_tag)) {
const name = field_info.name;
const FieldType = field_info.field_type;
try self.serialize(@field(value, name));
return;
}
}
unreachable;
}
@compileError("Cannot meaningfully serialize " ++ @typeName(T) ++
" because it is an untagged union. Use a custom serialize().");
},
builtin.TypeId.Optional => {
if (value == null) {
try self.serializeInt(u1(@boolToInt(false)));
return;
}
try self.serializeInt(u1(@boolToInt(true)));
const OC = comptime meta.Child(T);
const val_ptr = &value.?;
try self.serialize(val_ptr.*);
},
builtin.TypeId.Enum => {
try self.serializeInt(@enumToInt(value));
},
else => @compileError("Cannot serialize " ++ @tagName(@typeId(T)) ++ " types (unimplemented)."),
}
}
};
}
test "import io tests" {
comptime {
_ = @import("io_test.zig");
}
} | std/io.zig |
const std = @import("../std.zig");
const builtin = std.builtin;
const build = std.build;
const Step = build.Step;
const Builder = build.Builder;
const LibExeObjStep = build.LibExeObjStep;
const WriteFileStep = build.WriteFileStep;
const fs = std.fs;
const mem = std.mem;
const process = std.process;
const ArrayList = std.ArrayList;
const BufMap = std.BufMap;
const warn = std.debug.warn;
const max_stdout_size = 1 * 1024 * 1024; // 1 MiB
pub const RunStep = struct {
step: Step,
builder: *Builder,
/// See also addArg and addArgs to modifying this directly
argv: ArrayList(Arg),
/// Set this to modify the current working directory
cwd: ?[]const u8,
/// Override this field to modify the environment, or use setEnvironmentVariable
env_map: ?*BufMap,
stdout_action: StdIoAction = .inherit,
stderr_action: StdIoAction = .inherit,
stdin_behavior: std.ChildProcess.StdIo = .Inherit,
expected_exit_code: u8 = 0,
pub const StdIoAction = union(enum) {
inherit,
ignore,
expect_exact: []const u8,
expect_matches: []const []const u8,
};
pub const Arg = union(enum) {
Artifact: *LibExeObjStep,
WriteFile: struct {
step: *WriteFileStep,
file_name: []const u8,
},
Bytes: []u8,
};
pub fn create(builder: *Builder, name: []const u8) *RunStep {
const self = builder.allocator.create(RunStep) catch unreachable;
self.* = RunStep{
.builder = builder,
.step = Step.init(.Run, name, builder.allocator, make),
.argv = ArrayList(Arg).init(builder.allocator),
.cwd = null,
.env_map = null,
};
return self;
}
pub fn addArtifactArg(self: *RunStep, artifact: *LibExeObjStep) void {
self.argv.append(Arg{ .Artifact = artifact }) catch unreachable;
self.step.dependOn(&artifact.step);
}
pub fn addWriteFileArg(self: *RunStep, write_file: *WriteFileStep, file_name: []const u8) void {
self.argv.append(Arg{
.WriteFile = .{
.step = write_file,
.file_name = file_name,
},
}) catch unreachable;
self.step.dependOn(&write_file.step);
}
pub fn addArg(self: *RunStep, arg: []const u8) void {
self.argv.append(Arg{ .Bytes = self.builder.dupe(arg) }) catch unreachable;
}
pub fn addArgs(self: *RunStep, args: []const []const u8) void {
for (args) |arg| {
self.addArg(arg);
}
}
pub fn clearEnvironment(self: *RunStep) void {
const new_env_map = self.builder.allocator.create(BufMap) catch unreachable;
new_env_map.* = BufMap.init(self.builder.allocator);
self.env_map = new_env_map;
}
pub fn addPathDir(self: *RunStep, search_path: []const u8) void {
const env_map = self.getEnvMap();
var key: []const u8 = undefined;
var prev_path: ?[]const u8 = undefined;
if (builtin.os.tag == .windows) {
key = "Path";
prev_path = env_map.get(key);
if (prev_path == null) {
key = "PATH";
prev_path = env_map.get(key);
}
} else {
key = "PATH";
prev_path = env_map.get(key);
}
if (prev_path) |pp| {
const new_path = self.builder.fmt("{}" ++ [1]u8{fs.path.delimiter} ++ "{}", .{ pp, search_path });
env_map.set(key, new_path) catch unreachable;
} else {
env_map.set(key, search_path) catch unreachable;
}
}
pub fn getEnvMap(self: *RunStep) *BufMap {
return self.env_map orelse {
const env_map = self.builder.allocator.create(BufMap) catch unreachable;
env_map.* = process.getEnvMap(self.builder.allocator) catch unreachable;
self.env_map = env_map;
return env_map;
};
}
pub fn setEnvironmentVariable(self: *RunStep, key: []const u8, value: []const u8) void {
const env_map = self.getEnvMap();
env_map.set(key, value) catch unreachable;
}
pub fn expectStdErrEqual(self: *RunStep, bytes: []const u8) void {
self.stderr_action = .{ .expect_exact = bytes };
}
pub fn expectStdOutEqual(self: *RunStep, bytes: []const u8) void {
self.stdout_action = .{ .expect_exact = bytes };
}
fn stdIoActionToBehavior(action: StdIoAction) std.ChildProcess.StdIo {
return switch (action) {
.ignore => .Ignore,
.inherit => .Inherit,
.expect_exact, .expect_matches => .Pipe,
};
}
fn make(step: *Step) !void {
const self = @fieldParentPtr(RunStep, "step", step);
const cwd = if (self.cwd) |cwd| self.builder.pathFromRoot(cwd) else self.builder.build_root;
var argv_list = ArrayList([]const u8).init(self.builder.allocator);
for (self.argv.items) |arg| {
switch (arg) {
Arg.Bytes => |bytes| try argv_list.append(bytes),
Arg.WriteFile => |file| {
try argv_list.append(file.step.getOutputPath(file.file_name));
},
Arg.Artifact => |artifact| {
if (artifact.target.isWindows()) {
// On Windows we don't have rpaths so we have to add .dll search paths to PATH
self.addPathForDynLibs(artifact);
}
const executable_path = artifact.installed_path orelse artifact.getOutputPath();
try argv_list.append(executable_path);
},
}
}
const argv = argv_list.items;
const child = std.ChildProcess.init(argv, self.builder.allocator) catch unreachable;
defer child.deinit();
child.cwd = cwd;
child.env_map = self.env_map orelse self.builder.env_map;
child.stdin_behavior = self.stdin_behavior;
child.stdout_behavior = stdIoActionToBehavior(self.stdout_action);
child.stderr_behavior = stdIoActionToBehavior(self.stderr_action);
child.spawn() catch |err| {
warn("Unable to spawn {}: {}\n", .{ argv[0], @errorName(err) });
return err;
};
// TODO need to poll to read these streams to prevent a deadlock (or rely on evented I/O).
var stdout: ?[]const u8 = null;
defer if (stdout) |s| self.builder.allocator.free(s);
switch (self.stdout_action) {
.expect_exact, .expect_matches => {
stdout = child.stdout.?.inStream().readAllAlloc(self.builder.allocator, max_stdout_size) catch unreachable;
},
.inherit, .ignore => {},
}
var stderr: ?[]const u8 = null;
defer if (stderr) |s| self.builder.allocator.free(s);
switch (self.stderr_action) {
.expect_exact, .expect_matches => {
stderr = child.stderr.?.inStream().readAllAlloc(self.builder.allocator, max_stdout_size) catch unreachable;
},
.inherit, .ignore => {},
}
const term = child.wait() catch |err| {
warn("Unable to spawn {}: {}\n", .{ argv[0], @errorName(err) });
return err;
};
switch (term) {
.Exited => |code| {
if (code != self.expected_exit_code) {
warn("The following command exited with error code {} (expected {}):\n", .{
code,
self.expected_exit_code,
});
printCmd(cwd, argv);
return error.UncleanExit;
}
},
else => {
warn("The following command terminated unexpectedly:\n", .{});
printCmd(cwd, argv);
return error.UncleanExit;
},
}
switch (self.stderr_action) {
.inherit, .ignore => {},
.expect_exact => |expected_bytes| {
if (!mem.eql(u8, expected_bytes, stderr.?)) {
warn(
\\
\\========= Expected this stderr: =========
\\{}
\\========= But found: ====================
\\{}
\\
, .{ expected_bytes, stderr.? });
printCmd(cwd, argv);
return error.TestFailed;
}
},
.expect_matches => |matches| for (matches) |match| {
if (mem.indexOf(u8, stderr.?, match) == null) {
warn(
\\
\\========= Expected to find in stderr: =========
\\{}
\\========= But stderr does not contain it: =====
\\{}
\\
, .{ match, stderr.? });
printCmd(cwd, argv);
return error.TestFailed;
}
},
}
switch (self.stdout_action) {
.inherit, .ignore => {},
.expect_exact => |expected_bytes| {
if (!mem.eql(u8, expected_bytes, stdout.?)) {
warn(
\\
\\========= Expected this stdout: =========
\\{}
\\========= But found: ====================
\\{}
\\
, .{ expected_bytes, stdout.? });
printCmd(cwd, argv);
return error.TestFailed;
}
},
.expect_matches => |matches| for (matches) |match| {
if (mem.indexOf(u8, stdout.?, match) == null) {
warn(
\\
\\========= Expected to find in stdout: =========
\\{}
\\========= But stdout does not contain it: =====
\\{}
\\
, .{ match, stdout.? });
printCmd(cwd, argv);
return error.TestFailed;
}
},
}
}
fn printCmd(cwd: ?[]const u8, argv: []const []const u8) void {
if (cwd) |yes_cwd| warn("cd {} && ", .{yes_cwd});
for (argv) |arg| {
warn("{} ", .{arg});
}
warn("\n", .{});
}
fn addPathForDynLibs(self: *RunStep, artifact: *LibExeObjStep) void {
for (artifact.link_objects.items) |link_object| {
switch (link_object) {
.OtherStep => |other| {
if (other.target.isWindows() and other.isDynamicLibrary()) {
self.addPathDir(fs.path.dirname(other.getOutputPath()).?);
self.addPathForDynLibs(other);
}
},
else => {},
}
}
}
}; | lib/std/build/run.zig |
const std = @import("std");
const ArrayList = std.ArrayList;
const testing = std.testing;
/// Candidates are the strings read from stdin
/// if the filepath matching algorithm is used, then name will be
/// used to store the filename of the path in str.
pub const Candidate = struct {
str: []const u8,
name: ?[]const u8 = null,
rank: f64 = 0,
ranges: ?[]Range = null,
};
pub const Range = struct {
start: usize = 0,
end: usize = 0,
};
/// read the candidates from the buffer
pub fn collectCandidates(allocator: std.mem.Allocator, buf: []const u8, delimiter: u8, plain: bool) ![]Candidate {
var candidates = ArrayList(Candidate).init(allocator);
// find delimiters
var start: usize = 0;
for (buf) |char, index| {
if (char == delimiter) {
// add to arraylist only if slice is not all delimiters
if (index - start != 0) {
try candidates.append(.{ .str = buf[start..index] });
}
start = index + 1;
}
}
// catch the end if stdio didn't end in a delimiter
if (start < buf.len) {
try candidates.append(.{ .str = buf[start..] });
}
// extract filepaths
if (!plain) {
for (candidates.items) |*candidate| {
candidate.name = std.fs.path.basename(candidate.str);
}
}
return candidates.toOwnedSlice();
}
test "collectCandidates whitespace" {
var candidates = try collectCandidates(testing.allocator, "first second third fourth", ' ', false);
defer testing.allocator.free(candidates);
try testing.expectEqual(@as(usize, 4), candidates.len);
try testing.expectEqualStrings("first", candidates[0].str);
try testing.expectEqualStrings("second", candidates[1].str);
try testing.expectEqualStrings("third", candidates[2].str);
try testing.expectEqualStrings("fourth", candidates[3].str);
}
test "collectCandidates newline" {
var candidates = try collectCandidates(testing.allocator, "first\nsecond\nthird\nfourth", '\n', false);
defer testing.allocator.free(candidates);
try testing.expectEqual(@as(usize, 4), candidates.len);
try testing.expectEqualStrings("first", candidates[0].str);
try testing.expectEqualStrings("second", candidates[1].str);
try testing.expectEqualStrings("third", candidates[2].str);
try testing.expectEqualStrings("fourth", candidates[3].str);
}
test "collectCandidates excess whitespace" {
var candidates = try collectCandidates(testing.allocator, " first second third fourth ", ' ', false);
defer testing.allocator.free(candidates);
try testing.expectEqual(@as(usize, 4), candidates.len);
try testing.expectEqualStrings("first", candidates[0].str);
try testing.expectEqualStrings("second", candidates[1].str);
try testing.expectEqualStrings("third", candidates[2].str);
try testing.expectEqualStrings("fourth", candidates[3].str);
}
fn hasUpper(query: []const u8) bool {
for (query) |*c| {
if (std.ascii.isUpper(c.*)) return true;
}
return false;
}
/// rank each candidate against the query
///
/// returns a sorted slice of Candidates that match the query ready for display
/// in a tui or output to stdout
pub fn rankCandidates(
allocator: std.mem.Allocator,
candidates: []Candidate,
query: []const u8,
keep_order: bool,
) ![]Candidate {
var ranked = ArrayList(Candidate).init(allocator);
const smart_case = !hasUpper(query);
if (query.len == 0) {
for (candidates) |candidate| {
try ranked.append(candidate);
}
return ranked.toOwnedSlice();
}
var query_tokens = try splitQuery(allocator, query);
defer allocator.free(query_tokens);
for (candidates) |candidate| {
var c = candidate;
c.ranges = try allocator.alloc(Range, query_tokens.len);
if (rankCandidate(&c, query_tokens, smart_case)) {
try ranked.append(c);
}
}
if (!keep_order) {
std.sort.sort(Candidate, ranked.items, {}, sort);
}
return ranked.toOwnedSlice();
}
/// split the query on spaces and return a slice of query tokens
fn splitQuery(allocator: std.mem.Allocator, query: []const u8) ![][]const u8 {
var tokens = ArrayList([]const u8).init(allocator);
var it = std.mem.tokenize(u8, query, " ");
while (it.next()) |token| {
try tokens.append(token);
}
return tokens.toOwnedSlice();
}
const indexOfCaseSensitive = std.mem.indexOfScalarPos;
fn indexOf(comptime T: type, slice: []const T, start_index: usize, value: T) ?usize {
var i: usize = start_index;
while (i < slice.len) : (i += 1) {
if (std.ascii.toLower(slice[i]) == value) return i;
}
return null;
}
const IndexIterator = struct {
str: []const u8,
char: u8,
index: usize = 0,
smart_case: bool,
pub fn init(str: []const u8, char: u8, smart_case: bool) @This() {
return .{ .str = str, .char = char, .smart_case = smart_case };
}
pub fn next(self: *@This()) ?usize {
const index = if (self.smart_case) indexOf(u8, self.str, self.index, self.char) else indexOfCaseSensitive(u8, self.str, self.index, self.char);
if (index) |i| self.index = i + 1;
return index;
}
};
/// rank a candidate against the given query tokens
///
/// algorithm inspired by https://github.com/garybernhardt/selecta
fn rankCandidate(candidate: *Candidate, query_tokens: [][]const u8, smart_case: bool) bool {
candidate.rank = 0;
// the candidate must contain all of the characters (in order) in each token.
// each tokens rank is summed. if any token does not match the candidate is ignored
for (query_tokens) |token, i| {
if (rankToken(candidate.str, candidate.name, &candidate.ranges.?[i], token, smart_case)) |r| {
candidate.rank += r;
} else return false;
}
// all tokens matched and the best ranks for each tokens are summed
return true;
}
pub fn rankToken(
str: []const u8,
name: ?[]const u8,
range: *Range,
token: []const u8,
smart_case: bool,
) ?f64 {
// iterate over the indexes where the first char of the token matches
var best_rank: ?f64 = null;
var it = IndexIterator.init(name.?, token[0], smart_case);
const offs = str.len - name.?.len;
while (it.next()) |start_index| {
if (scanToEnd(name.?, token[1..], start_index, smart_case)) |match| {
if (best_rank == null or match.rank < best_rank.?) {
best_rank = match.rank;
range.* = .{ .start = match.start + offs, .end = match.end + offs };
}
} else break;
}
if (best_rank != null) {
// was a filename match, give priority
best_rank.? /= 2.0;
// how much of the token matched the filename?
if (token.len == name.?.len) {
best_rank.? /= 2.0;
} else {
const coverage = 1.0 - (@intToFloat(f64, token.len) / @intToFloat(f64, name.?.len));
best_rank.? *= coverage;
}
} else {
// retry on the full string
it = IndexIterator.init(str, token[0], smart_case);
while (it.next()) |start_index| {
if (scanToEnd(str, token[1..], start_index, smart_case)) |match| {
if (best_rank == null or match.rank < best_rank.?) {
best_rank = match.rank;
range.* = .{ .start = match.start, .end = match.end };
}
} else break;
}
}
return best_rank;
}
const Match = struct {
rank: f64,
start: usize,
end: usize,
};
inline fn isStartOfWord(byte: u8) bool {
return switch (byte) {
std.fs.path.sep, '_', '-', '.', ' ' => true,
else => false,
};
}
/// this is the core of the ranking algorithm. special precedence is given to
/// filenames. if a match is found on a filename the candidate is ranked higher
fn scanToEnd(str: []const u8, token: []const u8, start_index: usize, smart_case: bool) ?Match {
var match: Match = .{ .rank = 1, .start = start_index, .end = 0 };
var last_index = start_index;
var last_sequential = false;
// penalty for not starting on a word boundary
if (start_index > 0 and !isStartOfWord(str[start_index - 1])) {
match.rank += 2.0;
}
for (token) |c| {
const index = if (smart_case) indexOf(u8, str, last_index + 1, c) else indexOfCaseSensitive(u8, str, last_index + 1, c);
if (index == null) return null;
if (index.? == last_index + 1) {
// sequential matches only count the first character
if (!last_sequential) {
last_sequential = true;
match.rank += 1.0;
}
} else {
// penalty for not starting on a word boundary
if (!isStartOfWord(str[index.? - 1])) {
match.rank += 2.0;
}
// normal match
last_sequential = false;
match.rank += @intToFloat(f64, index.? - last_index);
}
last_index = index.?;
}
match.end = last_index;
return match;
}
fn sort(_: void, a: Candidate, b: Candidate) bool {
// first by rank
if (a.rank < b.rank) return true;
if (a.rank > b.rank) return false;
// then by length
if (a.str.len < b.str.len) return true;
if (a.str.len > b.str.len) return false;
// then alphabetically
for (a.str) |c, i| {
if (c < b.str[i]) return true;
if (c > b.str[i]) return false;
}
return false;
} | src/filter.zig |
const std = @import("std");
const fs = std.fs;
const io = std.io;
const info = std.log.info;
const print = std.debug.print;
const fmt = std.fmt;
const ArrayList = std.ArrayList;
const utils = @import("utils.zig");
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const State = enum {
active,
inactive,
};
const Coord = ArrayList(isize);
fn hashFn(a: Coord) u32 {
var hash: u32 = 1;
for (a.items) |val, i| {
hash += @intCast(u32, val) * ((@intCast(u32, i) * 0xff) + 1);
}
return hash;
}
fn eqlFn(a: Coord, b: Coord) bool {
return std.mem.eql(isize, a.items, b.items);
}
const CoordHashMap = std.ArrayHashMap(Coord, Cube, hashFn, eqlFn, true);
fn getCoordNeighbors(allo: *std.mem.Allocator, coord: Coord) !ArrayList(Coord) {
var res = ArrayList(Coord).init(allo);
// 3 because we want -1,0,1 of coord
const range = 3;
const offset = -1;
const dims = coord.items.len;
const elems = std.math.pow(usize, range, dims);
var i: usize = 0;
while (i < elems) : (i += 1) {
var new_coord = ArrayList(isize).init(allo);
for (coord.items) |pnt, j| {
const val: usize = @divTrunc(i, std.math.pow(usize, range, j)) % range;
const modded_val = pnt + @intCast(isize, val) + offset;
try new_coord.append(modded_val);
}
if (!std.mem.eql(isize, new_coord.items, coord.items)) {
try res.append(new_coord);
} else {
new_coord.deinit();
}
}
return res;
}
fn countActiveCubes(cubes: CoordHashMap) usize {
var res: usize = 0;
var cubes_iter = cubes.iterator();
while (cubes_iter.next()) |cube| {
if (cube.value.state == .active) {
res += 1;
}
}
return res;
}
const Cube = struct {
allo: *std.mem.Allocator,
coord: Coord,
state: State,
next_state: ?State = null,
near_coords: ArrayList(Coord),
pub fn init(allo: *std.mem.Allocator, coord: Coord, state: State) Cube {
return Cube{
.allo = allo,
.coord = coord,
.state = state,
.near_coords = getCoordNeighbors(allo, coord) catch unreachable,
};
}
pub fn deinit(self: *Cube) void {
self.coord.deinit();
for (self.near_coords.items) |item| {
item.deinit();
}
self.near_coords.deinit();
}
pub fn getNearCoords(self: *Cube) ArrayList(Coord) {
return self.near_coords;
}
pub fn calcNextState(self: *Cube, neighbors: *CoordHashMap) void {
const neighbor_coords = self.getNearCoords();
var actives: usize = 0;
for (neighbor_coords.items) |nc, i| {
// active block must have all neighboring blocks
const neighbor = neighbors.get(nc) orelse {
if (self.state == .inactive) {
continue;
} else {
unreachable;
}
};
if (neighbor.state == .active) {
actives += 1;
}
}
if (self.state == .active) {
if (actives == 2 or actives == 3) {
// remain active
} else {
self.next_state = .inactive;
}
} else {
if (actives == 3) {
self.next_state = .active;
}
}
}
pub fn commit(self: *Cube) void {
if (self.next_state) |ns| {
self.state = ns;
self.next_state = null;
}
}
};
fn doTask(allo: *std.mem.Allocator, cubes: *CoordHashMap) void {
var cycle: usize = 0;
while (cycle < 6) : (cycle += 1) {
// add all inactive neighoring cubes
print("cycle: {} cubes: {}\n", .{ cycle, countActiveCubes(cubes.*) });
var new_cubes = CoordHashMap.init(allo);
defer new_cubes.deinit();
var iter_cubes = cubes.iterator();
while (iter_cubes.next()) |cube| {
if (cube.value.state == .inactive) {
continue;
}
const near_coords = cube.value.getNearCoords();
for (near_coords.items) |near_coord| {
if (cubes.get(near_coord)) |existing_cube| {
continue;
}
// do not add already seen new
if (new_cubes.get(near_coord)) |existing| {
continue;
}
// make a copy of the coords
var cube_coord = ArrayList(isize).init(allo);
cube_coord.appendSlice(near_coord.items) catch unreachable;
// init all non-existant cubes as inactive
const new_cube = Cube.init(allo, cube_coord, .inactive);
new_cubes.put(new_cube.coord, new_cube) catch unreachable;
}
}
var new_cubes_iter = new_cubes.iterator();
while (new_cubes_iter.next()) |new_cube_kv| {
const new_coord = new_cube_kv.key;
const new_cube = new_cube_kv.value;
cubes.put(new_coord, new_cube) catch unreachable;
}
iter_cubes = cubes.iterator();
while (iter_cubes.next()) |cube_kv| {
cube_kv.value.calcNextState(cubes);
}
iter_cubes = cubes.iterator();
while (iter_cubes.next()) |cube| {
cube.value.commit();
}
}
}
pub fn main() !void {
const begin = @divTrunc(std.time.nanoTimestamp(), 1000);
// setup
//
defer _ = gpa.deinit();
var allo = &gpa.allocator;
var lines: std.mem.TokenIterator = try utils.readInputLines(allo, "./input1");
defer allo.free(lines.buffer);
var p1_cubes = CoordHashMap.init(allo);
var p2_cubes = CoordHashMap.init(allo);
// load initial cubes
var y: isize = 0;
while (lines.next()) |line| : (y += 1) {
for (line) |char, _x| {
const x = @intCast(isize, _x);
if (char == '.') {
continue;
}
// p1
var p1_coord_slic = [_]isize{ x, y, 0 };
var p1_coord = ArrayList(isize).init(allo);
p1_coord.appendSlice(p1_coord_slic[0..]) catch unreachable;
const p1_cube = Cube.init(allo, p1_coord, .active);
p1_cubes.put(p1_cube.coord, p1_cube) catch unreachable;
// p2
var p2_coord_slic = [_]isize{ x, y, 0, 0 };
var p2_coord = ArrayList(isize).init(allo);
p2_coord.appendSlice(p2_coord_slic[0..]) catch unreachable;
const p2_cube = Cube.init(allo, p2_coord, .active);
p2_cubes.put(p2_cube.coord, p2_cube) catch unreachable;
}
}
// task p1
print("doin task p1\n", .{});
doTask(allo, &p1_cubes);
print("p1: {}\n", .{countActiveCubes(p1_cubes)});
defer {
var p1_iter = p1_cubes.iterator();
while (p1_iter.next()) |kv| {
kv.value.deinit();
}
p1_cubes.deinit();
}
// task p2
print("doin task p2\n", .{});
doTask(allo, &p2_cubes);
print("p2: {}\n", .{countActiveCubes(p2_cubes)});
defer {
var p2_iter = p2_cubes.iterator();
while (p2_iter.next()) |kv| {
kv.value.deinit();
}
p2_cubes.deinit();
}
// end
const delta = @divTrunc(std.time.nanoTimestamp(), 1000) - begin;
print("all done in {} microseconds\n", .{delta});
} | day_17/src/main.zig |
const std = @import("std");
const ansi = @import("ansi_esc.zig");
const Self = @This();
pub const buff_size = 512;
pub const log_level: std.log.Level = switch (std.builtin.mode) {
.Debug => .debug,
.ReleaseSafe => .info,
.ReleaseFast => .info,
.ReleaseSmall => .info,
};
pub var log_ctx: Self = undefined; // TODO: init checks
out_mut: std.Thread.Mutex = .{},
out: std.io.BufferedWriter(buff_size, std.fs.File.Writer),
err: std.io.BufferedWriter(buff_size, std.fs.File.Writer),
pub fn init() void {
log_ctx = .{
.out = .{ .unbuffered_writer = std.io.getStdOut().writer() },
.err = .{ .unbuffered_writer = std.io.getStdErr().writer() },
};
configure_console();
}
pub fn deinit() !void {
try log_ctx.out.flush();
try log_ctx.err.flush();
}
pub fn getCtx() *Self {
return &log_ctx;
}
pub const scoped = std.log.scoped;
pub fn log(
comptime level: std.log.Level,
comptime scope: @TypeOf(.EnumLiteral),
comptime format: []const u8,
args: anytype,
) void {
if (@enumToInt(level) > @enumToInt(log_level)) return;
const use_err = @enumToInt(level) <= @enumToInt(std.log.Level.warn);
const flush = if (use_err) log_ctx.err.flush else log_ctx.out.flush;
var out = if (use_err) log_ctx.err.writer() else log_ctx.out.writer();
const outm = if (use_err) std.debug.getStderrMutex() else &log_ctx.out_mut;
if (scope == .raw) {
const lock = outm.acquire();
out.print(format, args) catch @panic("Can't write log!");
lock.release();
return;
}
const color = switch (level) {
.emerg => ansi.style.bold ++ ansi.style.underline ++ ansi.style.fg.col256(214) ++ ansi.style.bg.col256(52),
.alert => ansi.style.bold ++ ansi.style.underline ++ ansi.style.fg.red,
.crit => ansi.style.bold ++ ansi.style.fg.red,
.err => ansi.style.fg.red,
.warn => "" ++ ansi.style.fg.col256(214),
.notice => ansi.style.bold,
.info => "",
.debug => comptime ansi.style.fg.col256(245) ++ ansi.style.italic,
};
//const scope_prefix = "(" ++ @tagName(scope) ++ "):\t";
//const prefix = "[" ++ @tagName(level) ++ "] " ++ scope_prefix;
const prefix = "";
const lock = outm.acquire();
const postfix = if (format.len > 1 and format[format.len - 1] < ' ') "" else "\n";
out.print(color ++ prefix ++ format ++ ansi.style.reset ++ postfix, args) catch @panic("Can't write log!");
if (@enumToInt(level) <= @enumToInt(std.log.Level.notice)) flush() catch @panic("Can't flush log!");
lock.release();
}
fn configure_console() void {
if (std.builtin.os.tag == .windows) {
// configure windows console - use utf8 and ascii VT100 escape sequences
const win_con = struct {
const CP_UTF8: u32 = 65001;
const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004;
const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
const BOOL = std.os.windows.BOOL;
const HANDLE = std.os.windows.HANDLE;
const DWORD = std.os.windows.DWORD;
const GetStdHandle = std.os.windows.GetStdHandle;
const STD_OUTPUT_HANDLE = std.os.windows.STD_OUTPUT_HANDLE;
const STD_ERROR_HANDLE = std.os.windows.STD_ERROR_HANDLE;
const kernel32 = std.os.windows.kernel32;
//const STD_INPUT_HANDLE: (DWORD) = -10;
//const STD_OUTPUT_HANDLE: (DWORD) = -11;
//const STD_ERROR_HANDLE: (DWORD) = -12;
pub extern "kernel32" fn SetConsoleOutputCP(wCodePageID: std.os.windows.UINT) BOOL;
pub extern "kernel32" fn SetConsoleMode(hConsoleHandle: HANDLE, dwMode: DWORD) BOOL;
//pub const GetStdHandle = kernel32.GetStdHandle;
pub fn configure() void {
if (SetConsoleOutputCP(CP_UTF8) == 0) {
scoped(.console).err("Can't configure windows console to UTF8!", .{});
}
var stdout_handle: HANDLE = GetStdHandle(STD_OUTPUT_HANDLE) catch |err| {
scoped(.console).err("Windows: Can't get stdout handle! err: {}", .{err});
return;
};
// var stdin_handle: HANDLE = GetStdHandle(STD_INPUT_HANDLE) catch |err| {
// scoped(.console).err("Windows: Can't get stdin handle! err: {}", .{err});
// return;
// };
var stderr_handle: HANDLE = GetStdHandle(STD_ERROR_HANDLE) catch |err| {
scoped(.console).err("Windows: Can't get stderr handle! err: {}", .{err});
return;
};
// Get console mode
var stdout_mode: DWORD = 0;
//var stdin_mode: DWORD = 0;
var stderr_mode: DWORD = 0;
if (kernel32.GetConsoleMode(stdout_handle, &stdout_mode) == 0) {
scoped(.console).err("Windows can't get stdout console mode! {}", .{kernel32.GetLastError()});
}
// if (kernel32.GetConsoleMode(stdin_handle, &stdout_mode) == 0) {
// scoped(.console).err("Windows can't get stdin_mode console mode! {}", .{kernel32.GetLastError()});
// }
if (kernel32.GetConsoleMode(stderr_handle, &stderr_mode) == 0) {
scoped(.console).err("Windows can't get stderr console mode! {}", .{kernel32.GetLastError()});
}
// set ENABLE_VIRTUAL_TERMINAL_PROCESSING
if (SetConsoleMode(stdout_handle, stdout_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING) == 0) {
scoped(.console).err("Windows can't set stdout console mode! {}", .{kernel32.GetLastError()});
}
// if (SetConsoleMode(stdin_handle, stdin_mode | ENABLE_VIRTUAL_TERMINAL_INPUT) == 0) {
// scoped(.console).err("Windows can't set stdin_mode console mode! {}", .{kernel32.GetLastError()});
// }
if (SetConsoleMode(stderr_handle, stderr_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING) == 0) {
scoped(.console).err("Windows can't set stderr console mode! {}", .{kernel32.GetLastError()});
}
}
};
_ = win_con;
win_con.configure();
}
}
pub fn testOut() void {
scoped(.testOut).emerg("emerg", .{});
scoped(.testOut).alert("alert", .{});
scoped(.testOut).crit("crit", .{});
scoped(.testOut).err("err", .{});
scoped(.testOut).warn("warn", .{});
scoped(.testOut).notice("notice", .{});
scoped(.testOut).info("info", .{});
scoped(.testOut).debug("debug", .{});
} | src/log.zig |
const std = @import("std");
const input = @import("input.zig");
pub fn run(allocator: std.mem.Allocator, stdout: anytype) anyerror!void {
var input_ = try input.readFile("inputs/day4");
defer input_.deinit();
var input_parsed = try Input.init(allocator, &input_);
defer input_parsed.deinit();
{
const result = try part1(&input_parsed);
try stdout.print("4a: {}\n", .{ result });
std.debug.assert(result == 11774);
}
for (input_parsed.boards.items) |*board| {
board.resetMarked();
}
{
const result = try part2(&input_parsed);
try stdout.print("4b: {}\n", .{ result });
std.debug.assert(result == 4495);
}
}
const Input = struct {
nums: std.ArrayList(BoardSpot.Type),
boards: std.ArrayList(Board),
fn init(allocator: std.mem.Allocator, input_: anytype) !@This() {
var nums = std.ArrayList(BoardSpot.Type).init(allocator);
errdefer nums.deinit();
{
const line = (try input_.next()) orelse return error.InvalidInput;
var nums_iterator = std.mem.split(u8, line, ",");
while (nums_iterator.next()) |num| {
try nums.append(try std.fmt.parseInt(BoardSpot.Type, num, 10));
}
}
var boards = std.ArrayList(Board).init(allocator);
errdefer boards.deinit();
while (try Board.init(input_)) |board| {
try boards.append(board);
}
return Input {
.nums = nums,
.boards = boards,
};
}
fn deinit(self: @This()) void {
self.nums.deinit();
self.boards.deinit();
}
};
const Board = struct {
const rows = 5;
const cols = 5;
const Sum = std.math.IntFittingRange(0, BoardSpot.max * cols * rows);
const Score = std.math.IntFittingRange(0, BoardSpot.max * cols * rows * BoardSpot.max);
spots: [rows][cols]BoardSpot = [_][cols]BoardSpot { [_]BoardSpot { .{ .num = 0, .marked = false } } ** cols } ** rows,
unmarked_sum: Sum = 0,
fn init(input_: anytype) !?@This() {
var nums = std.BoundedArray(BoardSpot.Type, cols * rows).init(0) catch unreachable;
while (try input_.next()) |line| {
var nums_iterator = std.mem.tokenize(u8, line, " ");
while (nums_iterator.next()) |num_s| {
const num = try std.fmt.parseInt(BoardSpot.Type, num_s, 10);
try nums.append(num);
}
if (nums.len == cols * rows) {
var result = Board {};
for (nums.constSlice()) |num, i| {
result.spots[i / cols][i % cols].num = num;
result.unmarked_sum += num;
}
return result;
}
}
if (nums.len > 0) {
return error.InvalidInput;
}
return null;
}
fn resetMarked(self: *@This()) void {
for (self.spots) |*row| {
for (row) |*spot| {
if (spot.marked) {
spot.marked = false;
self.unmarked_sum += spot.num;
}
}
}
}
fn mark(self: *@This(), num: BoardSpot.Type) ?Score {
const marked_spot =
marked_spot: for (self.spots) |*row, row_num| {
for (row) |*spot, col_num| {
if (spot.num == num) {
spot.marked = true;
self.unmarked_sum -= num;
break :marked_spot .{ .row_num = row_num, .col_num = col_num };
}
}
}
else return null;
const row_num = marked_spot.row_num;
const col_num = marked_spot.col_num;
const has_won = has_won: {
var allRowMarked = true;
for (self.spots[row_num]) |*spot| {
if (!spot.marked) {
allRowMarked = false;
break;
}
}
if (allRowMarked) {
break :has_won true;
}
var allColMarked = true;
for (self.spots) |*row| {
if (!row[col_num].marked) {
allColMarked = false;
break;
}
}
if (allColMarked) {
break :has_won true;
}
break :has_won false;
};
return
if (has_won) @as(Score, self.unmarked_sum) * @as(Score, num)
else null;
}
};
const BoardSpot = struct {
const max = 99;
const Type = std.math.IntFittingRange(0, max);
num: Type,
marked: bool,
};
fn part1(input_: *Input) !Board.Score {
for (input_.nums.items) |num| {
for (input_.boards.items) |*board| {
return board.mark(num) orelse continue;
}
}
return error.NoBoardsWon;
}
fn part2(input_: *Input) !Board.Score {
for (input_.nums.items) |num| {
var board_i: usize = 0;
while (board_i < input_.boards.items.len) {
const board = &input_.boards.items[board_i];
if (board.mark(num)) |score| {
if (input_.boards.items.len == 1) {
return score;
}
_ = input_.boards.swapRemove(board_i);
}
else {
board_i += 1;
}
}
}
return error.NotAllBoardsWon;
}
test "day 4 example 1" {
const input_ =
\\7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1
\\
\\22 13 17 11 0
\\ 8 2 23 4 24
\\21 9 14 16 7
\\ 6 10 3 18 5
\\ 1 12 20 15 19
\\
\\ 3 15 0 2 22
\\ 9 18 13 17 5
\\19 8 7 25 23
\\20 11 10 24 4
\\14 21 16 12 6
\\
\\14 21 17 24 4
\\10 16 15 9 19
\\18 8 23 26 20
\\22 11 13 6 5
\\ 2 0 12 3 7
;
var input__ = input.readString(input_);
var input_parsed = try Input.init(std.testing.allocator, &input__);
defer input_parsed.deinit();
try std.testing.expectEqual(@as(Board.Score, 188 * 24), try part1(&input_parsed));
for (input_parsed.boards.items) |*board| {
board.resetMarked();
}
try std.testing.expectEqual(@as(Board.Score, 148 * 13), try part2(&input_parsed));
} | src/day4.zig |
pub const RTL_CORRELATION_VECTOR_STRING_LENGTH = @as(u32, 129);
pub const RTL_CORRELATION_VECTOR_V1_PREFIX_LENGTH = @as(u32, 16);
pub const RTL_CORRELATION_VECTOR_V1_LENGTH = @as(u32, 64);
pub const RTL_CORRELATION_VECTOR_V2_PREFIX_LENGTH = @as(u32, 22);
pub const RTL_CORRELATION_VECTOR_V2_LENGTH = @as(u32, 128);
//--------------------------------------------------------------------------------
// Section: Types (1)
//--------------------------------------------------------------------------------
pub const CORRELATION_VECTOR = extern struct {
Version: CHAR,
Vector: [129]CHAR,
};
//--------------------------------------------------------------------------------
// Section: Functions (4)
//--------------------------------------------------------------------------------
pub extern "ntdll" fn RtlInitializeCorrelationVector(
CorrelationVector: ?*CORRELATION_VECTOR,
Version: i32,
Guid: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "ntdll" fn RtlIncrementCorrelationVector(
CorrelationVector: ?*CORRELATION_VECTOR,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "ntdll" fn RtlExtendCorrelationVector(
CorrelationVector: ?*CORRELATION_VECTOR,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "ntdll" fn RtlValidateCorrelationVector(
Vector: ?*CORRELATION_VECTOR,
) callconv(@import("std").os.windows.WINAPI) u32;
//--------------------------------------------------------------------------------
// 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 (2)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const CHAR = @import("../foundation.zig").CHAR;
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/correlation_vector.zig |
const std = @import("std");
const debug = @import("debug.zig");
const utility = @import("utility.zig");
const enums = @import("enums.zig");
const structs = @import("structs.zig");
const ws = std.os.windows.ws2_32;
const bigInt = std.math.big.int.Managed;
const rand = std.crypto.random;
/// Will be returning proper TLS session interface in future
/// Inits a handshake on port 433, Windows only
pub fn initTLS(hostname: [*:0]const u8, alloc: *std.mem.Allocator) anyerror!usize {
const port = "443";
var hints: ws.addrinfo = .{
.flags = 0,
.family = ws.AF.UNSPEC,
.socktype = ws.SOCK.STREAM,
.protocol = ws.IPPROTO.TCP,
.addrlen = 0,
.canonname = null,
.addr = null,
.next = null,
};
var res: *ws.addrinfo = undefined;
_ = ws.getaddrinfo(hostname, port, &hints, &res);
var sock: ws.SOCKET = ws.socket(res.*.family, res.*.socktype, res.*.protocol);
defer _ = ws.closesocket(sock);
if (sock == ws.INVALID_SOCKET) {
std.log.err("socket creation failed", .{});
return error.socketCreationFailed;
} else {
std.log.debug("created socket", .{});
}
if (ws.connect(sock, @ptrCast(*const ws.sockaddr, res.*.addr), @intCast(i32, res.*.addrlen)) != 0) {
std.log.err("connection to {s} on port {s} failed!", .{ hostname, port });
return error.connectFailed;
} else {
std.log.debug("connected to {s} on port {s}", .{ hostname, port });
}
// allocate storage for keys
var server_random = try alloc.alloc(u8, 32);
defer alloc.free(server_random);
var client_random = try alloc.alloc(u8, 32);
defer alloc.free(client_random);
var server_public_key_x = try alloc.alloc(u8, 32);
defer alloc.free(server_public_key_x);
var server_public_key_y = try alloc.alloc(u8, 32);
defer alloc.free(server_public_key_y);
var client_private_key = try alloc.alloc(u8, 32);
defer alloc.free(client_private_key);
// start handshake
var client_hello = try createClientHello(alloc);
defer alloc.free(client_hello.data);
try debug.printRecord(client_hello, "sent to server");
try sendRecord(alloc, sock, client_hello);
std.mem.copy(u8, client_random, client_hello.data[6 .. 6 + 32]);
// recieve server answer records
while (true) {
var answer = try recieveRecord(sock, alloc);
defer alloc.free(answer.data);
try debug.printRecord(answer, "recieved from server");
if (answer.type != enums.ContentType.handshake) return error.non_handshake_packet_during_handshake;
var handshake_type = @intToEnum(enums.HandshakeType, answer.data[0]);
switch (handshake_type) {
.server_hello => {
std.mem.copy(u8, server_random, answer.data[6 .. 6 + 32]);
},
.certificate => {},
.server_key_exchange => {
std.mem.copy(u8, server_public_key_x, answer.data[9 .. 9 + 32]);
std.mem.copy(u8, server_public_key_y, answer.data[9 + 32 .. 9 + 64]);
},
.server_hello_done => {},
.finished => {},
.certificate_status => {},
else => return error.unexpected_message,
}
if (handshake_type == enums.HandshakeType.server_hello_done) break;
}
// Public key generation with secp256r1 curve
// curve parameters initialization
var p = try bigInt.init(alloc.*);
var a = try bigInt.init(alloc.*);
var b = try bigInt.init(alloc.*);
var gx = try bigInt.init(alloc.*);
var gy = try bigInt.init(alloc.*);
var n = try bigInt.init(alloc.*);
defer p.deinit();
defer a.deinit();
defer b.deinit();
defer gx.deinit();
defer gy.deinit();
defer n.deinit();
try a.setString(16, "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc");
try p.setString(16, "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff");
try b.setString(16, "5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b");
try gx.setString(16, "6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296");
try gy.setString(16, "4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5");
try n.setString(16, "ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
var x = try bigInt.init(alloc.*);
var y = try bigInt.init(alloc.*);
var y_pow_2 = try bigInt.init(alloc.*);
var x_pow_3 = try bigInt.init(alloc.*);
var ax = try bigInt.init(alloc.*);
var result = try bigInt.init(alloc.*);
var garbage = try bigInt.init(alloc.*);
defer garbage.deinit();
defer result.deinit();
defer x.deinit();
defer y.deinit();
defer y_pow_2.deinit();
defer x_pow_3.deinit();
defer ax.deinit();
// generate random 32byte (not 32bit) number
var randomdata: []u8 = try alloc.alloc(u8, 32);
for (randomdata) |*pointer| pointer.* = rand.int(u8);
var randomdata_string: []u8 = try utility.sliceToHexString(alloc, randomdata);
var random: bigInt = try bigInt.init(alloc.*);
defer random.deinit();
try random.setString(16, "DF975846F2E9BEFE12F787E60C4623BA28CED8BEE184B0B7EFBC477EBD5095BD");
alloc.free(randomdata_string);
std.mem.copy(u8, client_private_key, randomdata);
alloc.free(randomdata);
try bigInt.mul(&x, random.toConst(), gx.toConst());
try bigInt.divFloor(&garbage, &x, x.toConst(), p.toConst());
try bigInt.mul(&y, random.toConst(), gy.toConst());
try bigInt.divFloor(&garbage, &y, y.toConst(), p.toConst());
std.log.debug("random: {any}", .{random});
std.log.debug("x: {any}", .{x});
std.log.debug("y: {any}", .{y});
// a 115792089210356248762697446949407573530086143415290314195533631308867097853948
// p 115792089210356248762697446949407573530086143415290314195533631308867097853951
// gx 48439561293906451759052585252797914202762949526041747995844080717082404635286
// gy 36134250956749795798585127919587881956611106672985015071877198253568414405109
// rand 33436815818058981058483358951621600002596237373747952831627919882242365437947
// b 41058363725152142129326129780047268409114441015993725554835256314039467401291
//temp 2105500643802459836055704388002888456559614687578220162827952000662987686779641784803603123876009687215868686860631762198717048959341230802808117077778102179775361872614879439381530766076052247780506220908335727503498464448325387
// // y^2 = x^3 + ax + b
// // Point belong to curve if (X^3 + AX + B - Y**2) % P == 0
// // x^3 & ax
// try bigInt.pow(&x_pow_3, x.toConst(), 3);
// std.log.debug("run1 {}", .{x_pow_3});
// try bigInt.mul(&ax, a.toConst(), x.toConst());
// std.log.debug("run2 {}", .{ax});
// // x^3 + ax
// try bigInt.add(&result, x_pow_3.toConst(), ax.toConst());
// std.log.debug("run3 {}", .{result});
// // (x^3 + ax) + b
// try bigInt.add(&result, result.toConst(), b.toConst());
// // (x^3 + ax + b) - y^2
// try bigInt.pow(&y_pow_2, y.toConst(), 2);
// try bigInt.sub(&result, result.toConst(), y_pow_2.toConst());
// try bigInt.divFloor(&garbage, &result, y_pow_2.toConst(), p.toConst());
// std.log.debug("res: {any}", .{result});
// // (x^3 + ax + b) % p
// const temp_const_3 = temp_val_3.toConst();
// var ignore: bigInt = try bigInt.init(alloc);
// defer ignore.deinit();
// try bigInt.divFloor(&ignore, &res_val, temp_const_3, p);
// var test_record: structs.Record = .{
// .type = .handshake,
// .version = .TLS_1_2,
// .data = try utility.hexStringToSlice(alloc, "0E000000"),
// };
// defer alloc.free(test_record.data);
// try debug.printRecord(test_record, "sent unexpected message");
// try sendRecord(alloc, sock, test_record);
// var answer2 = try recieveRecord(sock, alloc);
// defer alloc.free(answer2.data);
// try debug.printRecord(answer2, "recieved this");
// debug.showMem(client_random, "Client Random");
// debug.showMem(server_random, "Server Random");
// debug.showMem(server_public_key_x, "Server Public Key X");
// debug.showMem(server_public_key_y, "Server Public Key Y");
// debug.showMem(client_private_key, "Client Private key");
// debug.showMem(client_public_key_x, "Client Public Key X");
// debug.showMem(client_public_key_y, "Client Public Key Y");
var G: Point = .{
.x = &gx,
.y = &gy,
};
G = try ECCPointDouble(alloc, G);
std.debug.print("G: {any}\n", .{G});
return 0;
}
const Point = struct {
x: *bigInt,
y: *bigInt,
};
/// Point doubling
/// lambda = (3X^2 + a)/(2y)
/// xr = lambda^2 - x1 - x2
/// yr = lambda(x1 - x2)-y1
pub fn ECCPointDouble(alloc: *std.mem.Allocator, P: Point) anyerror!Point {
var divident = try bigInt.init(alloc.*);
defer divident.deinit();
var divider = try bigInt.init(alloc.*);
defer divider.deinit();
var lambda = try bigInt.init(alloc.*);
defer lambda.deinit();
var temp = try bigInt.initSet(alloc.*, 3);
defer temp.deinit();
var result_x = try bigInt.init(alloc.*);
errdefer result_x.deinit();
var result_y = try bigInt.init(alloc.*);
errdefer result_y.deinit();
var result: Point = .{
.x = &result_x,
.y = &result_y,
};
try bigInt.pow(÷nt, P.x.toConst(), 2);
try bigInt.mul(÷nt, divident.toConst(), temp.toConst());
// FIXME add proper eliptic curve parameter
try temp.setString(16, "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc");
try bigInt.add(÷nt, divident.toConst(), temp.toConst());
try temp.set(2);
try bigInt.mul(÷r, P.y.toConst(), temp.toConst());
try bigInt.divFloor(&temp, &lambda, divident.toConst(), divider.toConst());
try bigInt.pow(result.x, lambda.toConst(), 2);
try bigInt.sub(result.x, result.x.toConst(), P.x.toConst());
try bigInt.sub(result.x, result.x.toConst(), P.x.toConst());
try temp.setString(16, "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc");
try bigInt.divFloor(&temp, result.x, result.x.toConst(), temp.toConst());
try bigInt.sub(result.y, P.x.toConst(), result.x.toConst());
std.log.debug("hmm?{any}", .{result.y.*}); // FIXME BUG IS HERE
result_y.setSign(true);
try bigInt.mul(result.y, result.y.toConst(), lambda.toConst());
try bigInt.sub(result.y, result.y.toConst(), P.y.toConst());
try temp.setString(16, "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc");
try bigInt.divFloor(&temp, result.y, result.y.toConst(), temp.toConst());
return result;
}
// TODO implement proper filling from function parameters
/// Creates basic client hello
pub fn createClientHello(alloc: *std.mem.Allocator) anyerror!structs.Record {
// Lengths
const essentials_len: usize = 38;
var session_id_len: usize = 1;
var ciphersuites_len: usize = 0;
var compressions_len: usize = 0;
var extensions_len: usize = 0;
var filled: usize = 0;
var result: structs.Record = .{
.type = .handshake,
.version = .TLS_1_0,
.data = try alloc.alloc(u8, essentials_len),
};
errdefer alloc.free(result.data);
// Handshake Header
// Header type
result.data[filled] = @enumToInt(enums.HandshakeType.client_hello);
filled += 1;
// allocate space for following bytes count
filled += 3;
// Client Version
std.mem.writeIntSliceBig(u16, result.data[filled .. filled + 2], @enumToInt(enums.Version.TLS_1_2));
filled += 2;
// Client Random
for (result.data[filled .. filled + 32]) |*pointer| pointer.* = rand.int(u8);
filled += 32;
result.data = try alloc.realloc(result.data, filled + session_id_len);
// Session ID
result.data[filled] = 0x00;
filled += 1;
// Cipher Suites
const cipher_suites = [_]enums.CipherSuite{
.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
// .TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
// .TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
};
ciphersuites_len = 2 + cipher_suites.len * 2;
result.data = try alloc.realloc(result.data, filled + ciphersuites_len);
std.mem.writeIntSliceBig(u16, result.data[filled .. filled + 2], cipher_suites.len * 2);
filled += 2;
for (cipher_suites) |suite| {
std.mem.writeIntSliceBig(u16, result.data[filled .. filled + 2], @enumToInt(suite));
filled += 2;
}
// Compression Methods
compressions_len += 2;
result.data = try alloc.realloc(result.data, filled + compressions_len);
result.data[filled] = 0x01;
filled += 1;
result.data[filled] = 0x00;
filled += 1;
// Extensions
// allocate space for extensions size
result.data = try alloc.realloc(result.data, filled + 2);
filled += 2;
var extension_server_name: []u8 = (try utility.hexStringToSlice(alloc, "0000000F000D00000A676f6f676c652e636f6d"));
result.data = try alloc.realloc(result.data, filled + extension_server_name.len);
std.mem.copy(u8, result.data[filled .. filled + extension_server_name.len], extension_server_name);
filled += extension_server_name.len;
alloc.free(extension_server_name);
extensions_len += extension_server_name.len;
var extension_status_request: []u8 = (try utility.hexStringToSlice(alloc, "000500050100000000"));
result.data = try alloc.realloc(result.data, filled + extension_status_request.len);
std.mem.copy(u8, result.data[filled .. filled + extension_status_request.len], extension_status_request);
filled += extension_status_request.len;
alloc.free(extension_status_request);
extensions_len += extension_status_request.len;
var extension_supported_groups: []u8 = (try utility.hexStringToSlice(alloc, "000a000400020017"));
result.data = try alloc.realloc(result.data, filled + extension_supported_groups.len);
std.mem.copy(u8, result.data[filled .. filled + extension_supported_groups.len], extension_supported_groups);
filled += extension_supported_groups.len;
alloc.free(extension_supported_groups);
extensions_len += extension_supported_groups.len;
var extension_supported_formats: []u8 = (try utility.hexStringToSlice(alloc, "000B00020100"));
result.data = try alloc.realloc(result.data, filled + extension_supported_formats.len);
std.mem.copy(u8, result.data[filled .. filled + extension_supported_formats.len], extension_supported_formats);
filled += extension_supported_formats.len;
alloc.free(extension_supported_formats);
extensions_len += extension_supported_formats.len;
// Set size for handshake header
result.data[1] = 0;
std.mem.writeIntSliceBig(u16, result.data[2..4], @intCast(u16, result.data.len - 4));
// Set size for extensions header
const offset = essentials_len + ciphersuites_len + compressions_len + session_id_len;
std.mem.writeIntSliceBig(u16, result.data[offset .. offset + 2], @intCast(u16, extensions_len));
return result;
}
/// Recieves TLS record from socket
/// Result.data must be freed manualy
pub fn recieveRecord(sock: ws.SOCKET, alloc: *std.mem.Allocator) anyerror!structs.Record {
const recv_bufsize = 1024;
var recv_buffer: []u8 = try alloc.alloc(u8, recv_bufsize);
defer alloc.free(recv_buffer);
var recv: i32 = ws.recv(sock, recv_buffer.ptr, @intCast(i32, recv_bufsize), ws.MSG.PEEK);
if (recv == -1) return error.RecvFailed;
if (recv == 0) return error.ConnectionClosed;
var packet_size = (@intCast(u16, recv_buffer[4]) | @intCast(u16, recv_buffer[3]) << 8);
var result: structs.Record = .{
.type = @intToEnum(enums.ContentType, recv_buffer[0]),
.version = @intToEnum(enums.Version, (@intCast(u16, recv_buffer[2]) | @intCast(u16, recv_buffer[1]) << 8)),
.data = try alloc.alloc(u8, packet_size),
};
errdefer alloc.free(result.data);
// flush 5 bytes of record header to recieve record data in loop
recv = ws.recv(sock, @ptrCast([*]u8, &result.data[0]), 5, 0);
if (recv == -1) return error.RecvFailed;
if (recv == 0) return error.ConnectionClosed;
var recieved: usize = 0;
while (true) {
// Set smaller buffer if need to recieve less than default buffersize
var to_recieve: usize = if (packet_size - recieved < recv_bufsize) (packet_size - recieved) else recv_bufsize;
recv = ws.recv(sock, @ptrCast([*]u8, &result.data[recieved]), @intCast(i32, to_recieve), 0);
if (recv == -1) return error.RecvFailed;
if (recv == 0) return error.ConnectionClosed;
recieved += @intCast(usize, recv);
if (recieved == packet_size) break;
}
return result;
}
/// Sends TLS record from socket
/// Result.data must be freed manualy
pub fn sendRecord(alloc: *std.mem.Allocator, sock: ws.SOCKET, record: structs.Record) anyerror!void {
var send_buffer = try alloc.alloc(u8, 5);
defer alloc.free(send_buffer);
send_buffer[0] = @enumToInt(record.type);
std.mem.writeIntSliceBig(u16, send_buffer[1..3], @enumToInt(record.version));
std.mem.writeIntSliceBig(u16, send_buffer[3..5], @intCast(u16, record.data.len));
var res: i32 = ws.send(sock, send_buffer.ptr, 5, 0);
if (res == -1) return error.SendFailed;
if (res == 0) return error.ConnectionClosed;
res = ws.send(sock, record.data.ptr, @intCast(i32, record.data.len), 0);
if (res == -1) return error.SendFailed;
if (res == 0) return error.ConnectionClosed;
} | src/tls.zig |
const std = @import("std");
const bytesToValue = std.mem.bytesToValue;
const toBytes = std.mem.toBytes;
const TagType = std.meta.TagType;
const odbc = @import("c.zig");
const util = @import("util.zig");
const Bitmask = util.Bitmask;
const unionInitEnum = util.unionInitEnum;
const sliceToValue = util.sliceToValue;
/// Return codes that might be returned from ODBC functions.
pub const SqlReturn = enum(odbc.SQLRETURN) {
Success = odbc.SQL_SUCCESS,
SuccessWithInfo = odbc.SQL_SUCCESS_WITH_INFO,
NeedsData = odbc.SQL_NEED_DATA,
StillExecuting = odbc.SQL_STILL_EXECUTING,
Error = odbc.SQL_ERROR,
InvalidHandle = odbc.SQL_INVALID_HANDLE,
NoData = odbc.SQL_NO_DATA,
ParamDataAvailable = odbc.SQL_PARAM_DATA_AVAILABLE
};
pub const HandleType = enum(odbc.SQLSMALLINT) {
Environment = odbc.SQL_HANDLE_ENV,
Connection = odbc.SQL_HANDLE_DBC,
Statement = odbc.SQL_HANDLE_STMT,
Descriptor = odbc.SQL_HANDLE_DESC
};
pub const Driver = struct {
description: []const u8,
attributes: []const u8,
pub fn deinit(self: *Driver, allocator: *std.mem.Allocator) void {
allocator.free(self.description);
allocator.free(self.attributes);
}
};
pub const DataSource = struct {
server_name: []const u8, description: []const u8
};
pub const DriverCompletion = enum(c_ushort) {
/// If the user does not provide enough information in the connection string to establish a connection,
/// return an error.
NoPrompt = odbc.SQL_DRIVER_NOPROMPT,
/// If the user does not provide enough information in the connection string to establish a connection,
/// display a window prompt that will allow them to fill out any other information.
Complete = odbc.SQL_DRIVER_COMPLETE,
/// Always prompt the user for connection information, using the values provided in the connection string
/// as default values.
Prompt = odbc.SQL_DRIVER_PROMPT,
/// If the user does not provide enough information in the connection string to establish a connection,
/// display a window prompt that will allow them to fill out only fields that are required in order to connection.
CompleteRequired = odbc.SQL_DRIVER_COMPLETE_REQUIRED
};
pub const Direction = enum(c_ushort) {
/// Fetch the next record in the list. If this is used for the first fetch call, then the first record
/// will be returned. If `FetchFirstUser` was used before this, then this will get the next user record.
/// The same is true for `FetchFirstSystem`.
FetchNext = odbc.SQL_FETCH_NEXT,
/// Fetch the first record in the list.
FetchFirst = odbc.SQL_FETCH_FIRST,
/// Fetch the first user record.
FetchFirstUser = odbc.SQL_FETCH_FIRST_USER,
/// Fetch the first system record.
FetchFirstSystem = odbc.SQL_FETCH_FIRST_SYSTEM
};
pub const DiagnosticIdentifier = enum(odbc.SQLSMALLINT) {
CursorRowCount = odbc.SQL_DIAG_CURSOR_ROW_COUNT,
DynamicFunction = odbc.SQL_DIAG_DYNAMIC_FUNCTION,
DynamicFunctionCode = odbc.SQL_DIAG_DYNAMIC_FUNCTION_CODE,
Number = odbc.SQL_DIAG_NUMBER,
ReturnCode = odbc.SQL_DIAG_RETURNCODE,
RowCount = odbc.SQL_DIAG_ROW_COUNT
};
pub const Nullable = enum(i32) {
Nullable = odbc.SQL_NULLABLE,
NonNullable = odbc.SQL_NO_NULLS,
Unknown = odbc.SQL_NULLABLE_UNKNOWN,
};
pub const CompletionType = enum(odbc.SQLSMALLINT) {
commit = odbc.SQL_COMMIT,
rollback = odbc.SQL_ROLLBACK,
};
/// The attributes that can be set or read for an Environment.
pub const EnvironmentAttribute = enum(i32) {
OdbcVersion = odbc.SQL_ATTR_ODBC_VERSION,
ConnectionPool = odbc.SQL_ATTR_CONNECTION_POOLING,
ConnectionPoolMatch = odbc.SQL_ATTR_CP_MATCH,
OutputNts = odbc.SQL_ATTR_OUTPUT_NTS,
/// Convert an integer attribute value into a structured AttributeValue. Uses the current active
/// Attribute to pick the correct union tag, since different attributes use the same underlying values
/// (i.e. `ConnectionPool.Off == ConnectionPoolMath.Strict`).
pub fn getAttributeValue(self: EnvironmentAttribute, value: i32) EnvironmentAttributeValue {
return switch (self) {
.OdbcVersion => .{ .OdbcVersion = @intToEnum(EnvironmentAttributeValue.OdbcVersion, value) },
.ConnectionPool => .{ .ConnectionPool = @intToEnum(EnvironmentAttributeValue.ConnectionPool, @intCast(u32, value)) },
.ConnectionPoolMatch => .{ .ConnectionPoolMatch = @intToEnum(EnvironmentAttributeValue.ConnectionPoolMatch, @intCast(u32, value)) },
.OutputNts => .{ .OutputNts = value != 0 },
};
}
};
/// The set of possible values for different environment attributes.
pub const EnvironmentAttributeValue = union(EnvironmentAttribute) {
ConnectionPool: ConnectionPool,
ConnectionPoolMatch: ConnectionPoolMatch,
OdbcVersion: OdbcVersion,
OutputNts: bool,
pub const ConnectionPool = enum(u32) {
Off = odbc.SQL_CP_OFF,
OnePerDriver = odbc.SQL_CP_ONE_PER_DRIVER,
OnePerEnvironment = odbc.SQL_CP_DRIVER_AWARE,
};
pub const ConnectionPoolMatch = enum(u32) {
Strict = odbc.SQL_CP_STRICT_MATCH,
Relaxed = odbc.SQL_CP_RELAXED_MATCH
};
pub const OdbcVersion = enum(i32) {
Odbc2 = odbc.SQL_OV_ODBC2,
Odbc3 = odbc.SQL_OV_ODBC3,
Odbc380 = odbc.SQL_OV_ODBC3_80,
};
/// Get the underlying integer value that the current attribute value represents.
pub fn getValue(self: EnvironmentAttributeValue) u32 {
const val = switch (self) {
.ConnectionPool => |v| @enumToInt(v),
.ConnectionPoolMatch => |v| @enumToInt(v),
.OdbcVersion => |v| @intCast(u32, @enumToInt(v)),
.OutputNts => |nts| if (nts) @as(u32, 1) else @as(u32, 0)
};
return @intCast(u32, val);
}
};
pub const ConnectionAttribute = enum(i32) {
AccessMode = odbc.SQL_ATTR_ACCESS_MODE,
EnableAsync = odbc.SQL_ATTR_ASYNC_ENABLE,
AutoIpd = odbc.SQL_ATTR_AUTO_IPD,
Autocommit = odbc.SQL_ATTR_AUTOCOMMIT,
ConnectionDead = odbc.SQL_ATTR_CONNECTION_DEAD,
ConnectionTimeout = odbc.SQL_ATTR_CONNECTION_TIMEOUT,
CurrentCatalog = odbc.SQL_ATTR_CURRENT_CATALOG,
EnlistInDtc = odbc.SQL_ATTR_ENLIST_IN_DTC,
LoginTimeout = odbc.SQL_ATTR_LOGIN_TIMEOUT,
MetadataId = odbc.SQL_ATTR_METADATA_ID,
OdbcCursors = odbc.SQL_ATTR_ODBC_CURSORS,
PacketSize = odbc.SQL_ATTR_PACKET_SIZE,
QuietMode = odbc.SQL_ATTR_QUIET_MODE,
Trace = odbc.SQL_ATTR_TRACE,
Tracefile = odbc.SQL_ATTR_TRACEFILE,
TranslateLib = odbc.SQL_ATTR_TRANSLATE_LIB,
TranslateOption = odbc.SQL_ATTR_TRANSLATE_OPTION,
TransactionIsolation = odbc.SQL_ATTR_TXN_ISOLATION,
pub fn getAttributeValue(comptime self: ConnectionAttribute, bytes: []u8) ConnectionAttributeValue {
return unionInitEnum(ConnectionAttributeValue, self, switch (self) {
.AccessMode => @intToEnum(ConnectionAttributeValue.AccessMode, sliceToValue(u32, bytes)),
.AsyncConnectEvent => sliceToValue(odbc.SQLPOINTER, bytes),
.EnableAsyncConnectFunctions => sliceToValue(u32, bytes) == odbc.SQL_ASYNC_DBC_ENABLE_ON,
.EnableAsync => sliceToValue(usize, bytes) == odbc.SQL_ASYNC_ENABLE_ON,
.AutoIpd => sliceToValue(u32, bytes) == odbc.SQL_TRUE,
.Autocommit => sliceToValue(u32, bytes) == odbc.SQL_AUTOCOMMIT_ON,
.ConnectionDead => sliceToValue(u32, bytes) == odbc.SQL_CD_TRUE,
.ConnectionTimeout => sliceToValue(u32, bytes),
.CurrentCatalog => bytes,
.EnlistInDtc => sliceToValue(odbc.SQLPOINTER, bytes),
.LoginTimeout => sliceToValue(u32, bytes),
.MetadataId => sliceToValue(u32, bytes) == odbc.SQL_TRUE,
.OdbcCursors => @intToEnum(ConnectionAttributeValue.OdbcCursors, sliceToValue(usize, bytes)),
.PacketSize => sliceToValue(u32, bytes),
.QuietMode => sliceToValue(odbc.HWND, bytes),
.Trace => sliceToValue(u32, bytes) == odbc.SQL_OPT_TRACE_ON,
.Tracefile => bytes[0..:0],
.TranslateLib => bytes[0..:0],
.TranslateOption => sliceToValue(u32, bytes),
.TransactionIsolation => sliceToValue(u32, bytes),
});
}
};
pub const ConnectionAttributeValue = union(ConnectionAttribute) {
AccessMode: AccessMode,
EnableAsync: bool,
AutoIpd: bool,
Autocommit: bool,
ConnectionDead: bool,
ConnectionTimeout: u32,
CurrentCatalog: []u8,
EnlistInDtc: odbc.SQLPOINTER,
LoginTimeout: u32,
MetadataId: bool,
OdbcCursors: OdbcCursors,
PacketSize: u32,
QuietMode: odbc.HWND,
Trace: bool,
Tracefile: [:0] u8,
TranslateLib: [:0]u8,
TranslateOption: u32,
TransactionIsolation: u32,
pub const AccessMode = enum(u32) {
ReadOnly = odbc.SQL_MODE_READ_ONLY,
ReadWrite = odbc.SQL_MODE_READ_WRITE
};
pub const OdbcCursors = enum(usize) {
UseOdbc = odbc.SQL_CUR_USE_ODBC,
UseIfNeeded = odbc.SQL_CUR_USE_IF_NEEDED,
UseDriver = odbc.SQL_CUR_USE_DRIVER
};
pub fn getValue(self: ConnectionAttributeValue, allocator: *std.mem.Allocator) ![]u8 {
const value_buffer: []u8 = switch (self) {
.AccessMode => |v| toBytes(@enumToInt(v))[0..],
.EnableAsync => |v| if (v) toBytes(@as(usize, odbc.SQL_ASYNC_ENABLE_ON))[0..] else toBytes(@as(usize, odbc.SQL_ASYNC_ENABLE_OFF))[0..],
.AutoIpd => |v| if (v) toBytes(@as(u32, odbc.SQL_TRUE))[0..] else toBytes(@as(u32, odbc.SQL_FALSE))[0..],
.Autocommit => |v| blk: {
const sql_val: u32 = if (v) odbc.SQL_AUTOCOMMIT_ON else odbc.SQL_AUTOCOMMIT_OFF;
break :blk toBytes(sql_val)[0..];
},
.ConnectionDead => |v| if (v) toBytes(@as(u32, odbc.SQL_CD_TRUE))[0..] else toBytes(@as(u32, odbc.SQL_CD_FALSE))[0..],
.ConnectionTimeout => |v| toBytes(v)[0..],
.CurrentCatalog => |v| v,
.EnlistInDtc => |v| toBytes(@ptrToInt(v))[0..],
.LoginTimeout => |v| toBytes(v)[0..],
.MetadataId => |v| if (v) toBytes(@as(u32, odbc.SQL_TRUE))[0..] else toBytes(@as(u32, odbc.SQL_FALSE))[0..],
.OdbcCursors => |v| toBytes(@enumToInt(v))[0..],
.PacketSize => |v| toBytes(v)[0..],
.QuietMode => |v| toBytes(@ptrToInt(v))[0..],
.Trace => |v| if (v) toBytes(@as(u32, odbc.SQL_OPT_TRACE_ON))[0..] else toBytes(@as(u32, odbc.SQL_OPT_TRACE_OFF))[0..],
.Tracefile => |v| v,
.TranslateLib => |v| v,
.TranslateOption => |v| toBytes(v)[0..],
.TransactionIsolation => |v| toBytes(v)[0..]
};
const result_buffer = try allocator.alloc(u8, value_buffer.len);
std.mem.copy(u8, result_buffer, value_buffer);
return result_buffer;
}
};
pub const FunctionId = enum(c_ushort) {
// ISO 92 standards-compliance level
SQLAllocHandle = odbc.SQL_API_SQLALLOCHANDLE,
SQLBindCol = odbc.SQL_API_SQLBINDCOL,
SQLCancel = odbc.SQL_API_SQLCANCEL,
SQLCloseCursor = odbc.SQL_API_SQLCLOSECURSOR,
SQLColAttribue = odbc.SQL_API_SQLCOLATTRIBUTE,
SQLConnect = odbc.SQL_API_SQLCONNECT,
SQLCopyDesc = odbc.SQL_API_SQLCOPYDESC,
SQLDataSources = odbc.SQL_API_SQLDATASOURCES,
SQLDescribeCol = odbc.SQL_API_SQLDESCRIBECOL,
SQLDisconnect = odbc.SQL_API_SQLDISCONNECT,
SQLDrivers = odbc.SQL_API_SQLDRIVERS,
SQLEndTran = odbc.SQL_API_SQLENDTRAN,
SQLExecDirect = odbc.SQL_API_SQLEXECDIRECT,
SQLExecute = odbc.SQL_API_SQLEXECUTE,
SQLFetch = odbc.SQL_API_SQLFETCH,
SQLFetchScroll = odbc.SQL_API_SQLFETCHSCROLL,
SQLFreeHandle = odbc.SQL_API_SQLFREEHANDLE,
SQLFreeStmt = odbc.SQL_API_SQLFREESTMT,
SQLGetConnectAttr = odbc.SQL_API_SQLGETCONNECTATTR,
SQLGetCursorName = odbc.SQL_API_SQLGETCURSORNAME,
SQLGetData = odbc.SQL_API_SQLGETDATA,
SQLGetDescField = odbc.SQL_API_SQLGETDESCFIELD,
SQLGetDescRec = odbc.SQL_API_SQLGETDESCREC,
SQLGetDiagField = odbc.SQL_API_SQLGETDIAGFIELD,
SQLGetDiagRec = odbc.SQL_API_SQLGETDIAGREC,
SQLGetEnvAttr = odbc.SQL_API_SQLGETENVATTR,
SQLGetFunctions = odbc.SQL_API_SQLGETFUNCTIONS,
SQLGetInfo = odbc.SQL_API_SQLGETINFO,
SQLGetStmtAttr = odbc.SQL_API_SQLGETSTMTATTR,
SQLGetTypeInfo = odbc.SQL_API_SQLGETTYPEINFO,
SQLNumResultCols = odbc.SQL_API_SQLNUMRESULTCOLS,
SQLParamData = odbc.SQL_API_SQLPARAMDATA,
SQLPrepare = odbc.SQL_API_SQLPREPARE,
SQLPutData = odbc.SQL_API_SQLPUTDATA,
SQLRowCount = odbc.SQL_API_SQLROWCOUNT,
SQLSetConnectAttr = odbc.SQL_API_SQLSETCONNECTATTR,
SQLSetCursorName = odbc.SQL_API_SQLSETCURSORNAME,
SQLSetDescField = odbc.SQL_API_SQLSETDESCFIELD,
SQLSetDescRec = odbc.SQL_API_SQLSETDESCREC,
SQLSetEnvAttr = odbc.SQL_API_SQLSETENVATTR,
SQLSetStmtAttr = odbc.SQL_API_SQLSETSTMTATTR,
// Open Groups standards-compliance level
SQLColumns = odbc.SQL_API_SQLCOLUMNS,
SQLSpecialColumns = odbc.SQL_API_SQLSPECIALCOLUMNS,
SQLStatistics = odbc.SQL_API_SQLSTATISTICS,
SQLTables = odbc.SQL_API_SQLTABLES,
// ODBC standards-compliance level
SQLBindParameter = odbc.SQL_API_SQLBINDPARAMETER,
SQLBrowseConnect = odbc.SQL_API_SQLBROWSECONNECT,
SQLBulkOperations = odbc.SQL_API_SQLBULKOPERATIONS,
SQLColumnPrivileges = odbc.SQL_API_SQLCOLUMNPRIVILEGES,
SQLDescribeParam = odbc.SQL_API_SQLDESCRIBEPARAM,
SQLDriverConnect = odbc.SQL_API_SQLDRIVERCONNECT,
SQLForeignKeys = odbc.SQL_API_SQLFOREIGNKEYS,
SQLMoreResults = odbc.SQL_API_SQLMORERESULTS,
SQLNativeSql = odbc.SQL_API_SQLNATIVESQL,
SQLNumParams = odbc.SQL_API_SQLNUMPARAMS,
SQLPrimaryKeys = odbc.SQL_API_SQLPRIMARYKEYS,
SQLProcedureColumns = odbc.SQL_API_SQLPROCEDURECOLUMNS,
SQLProcedures = odbc.SQL_API_SQLPROCEDURES,
SQLSetPos = odbc.SQL_API_SQLSETPOS,
SQLTablePrivileges = odbc.SQL_API_SQLTABLEPRIVILEGES,
};
/// Information types that are used with Connection.getInfo
pub const InformationType = enum(c_ushort) {
ActiveEnvironments = odbc.SQL_ACTIVE_ENVIRONMENTS,
AsyncConnectFunctions = odbc.SQL_ASYNC_DBC_FUNCTIONS,
AsyncMode = odbc.SQL_ASYNC_MODE,
AsyncNotification = odbc.SQL_ASYNC_NOTIFICATION,
BatchRowCount = odbc.SQL_BATCH_ROW_COUNT,
BatchSupport = odbc.SQL_BATCH_SUPPORT,
DataSourceName = odbc.SQL_DATA_SOURCE_NAME,
DriverAwarePoolingSupported = odbc.SQL_DRIVER_AWARE_POOLING_SUPPORTED,
DriverConnectionHandle = odbc.SQL_DRIVER_HDBC,
DriverDescriptorHandle = odbc.SQL_DRIVER_HDESC,
DriverEnvironmentHandle = odbc.SQL_DRIVER_HENV,
DriverLibraryHandle = odbc.SQL_DRIVER_HLIB,
DriverStatementHandle = odbc.SQL_DRIVER_HSTMT,
DriverName = odbc.SQL_DRIVER_NAME,
DriverOdbcVersion = odbc.SQL_DRIVER_ODBC_VER,
DriverVersion = odbc.SQL_DRIVER_VER,
DynamicCursorAttributes1 = odbc.SQL_DYNAMIC_CURSOR_ATTRIBUTES1,
DynamicCursorAttributes2 = odbc.SQL_DYNAMIC_CURSOR_ATTRIBUTES2,
ForwardOnlyCursorAttributes1 = odbc.SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1,
ForwardOnlyCursorAttributes2 = odbc.SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2,
FileUsage = odbc.SQL_FILE_USAGE,
GetDataExtensions = odbc.SQL_GETDATA_EXTENSIONS,
InfoSchemaViews = odbc.SQL_INFO_SCHEMA_VIEWS,
KeysetCursorAttributes1 = odbc.SQL_KEYSET_CURSOR_ATTRIBUTES1,
KeysetCursorAttributes2 = odbc.SQL_KEYSET_CURSOR_ATTRIBUTES2,
MaxAsyncConcurrentStatements = odbc.SQL_MAX_ASYNC_CONCURRENT_STATEMENTS,
MaxConcurrentActivities = odbc.SQL_MAX_CONCURRENT_ACTIVITIES,
MaxDriverConnections = odbc.SQL_MAX_DRIVER_CONNECTIONS,
OdbcInterfaceConformance = odbc.SQL_ODBC_INTERFACE_CONFORMANCE,
OdbcVersion = odbc.SQL_ODBC_VER,
ParamArrayRowCounts = odbc.SQL_PARAM_ARRAY_ROW_COUNTS,
ParamArraySelects = odbc.SQL_PARAM_ARRAY_SELECTS,
RowUpdates = odbc.SQL_ROW_UPDATES,
SearchPatternEscape = odbc.SQL_SEARCH_PATTERN_ESCAPE,
ServerName = odbc.SQL_SERVER_NAME,
StaticCursorAttributes1 = odbc.SQL_STATIC_CURSOR_ATTRIBUTES1,
StaticCursorAttributes2 = odbc.SQL_STATIC_CURSOR_ATTRIBUTES2,
// DBMS Product Information
DatabaseName = odbc.SQL_DATABASE_NAME,
DBMSName = odbc.SQL_DBMS_NAME,
DBMSVersion = odbc.SQL_DBMS_VER,
// Data Source Information
AccessibleProcedures = odbc.SQL_ACCESSIBLE_PROCEDURES,
AccessibleTables = odbc.SQL_ACCESSIBLE_TABLES,
BookmarkPersistence = odbc.SQL_BOOKMARK_PERSISTENCE,
CatalogTerm = odbc.SQL_CATALOG_TERM,
CollationSeq = odbc.SQL_COLLATION_SEQ,
ConcatNullBehavior = odbc.SQL_CONCAT_NULL_BEHAVIOR,
CursorCommitBehavior = odbc.SQL_CURSOR_COMMIT_BEHAVIOR,
CursorRollbackBehavior = odbc.SQL_CURSOR_ROLLBACK_BEHAVIOR,
CursorSensitivity = odbc.SQL_CURSOR_SENSITIVITY,
DataSourceReadOnly = odbc.SQL_DATA_SOURCE_READ_ONLY,
DefaultTransactionIsolation = odbc.SQL_DEFAULT_TXN_ISOLATION,
DescribeParameter = odbc.SQL_DESCRIBE_PARAMETER,
MultipleResultSets = odbc.SQL_MULT_RESULT_SETS,
MultipleActiveTransactions = odbc.SQL_MULTIPLE_ACTIVE_TXN,
NeedLongDataLength = odbc.SQL_NEED_LONG_DATA_LEN,
NullCollation = odbc.SQL_NULL_COLLATION,
ProcedureTerm = odbc.SQL_PROCEDURE_TERM,
SchemaTerm = odbc.SQL_SCHEMA_TERM,
ScrollOptions = odbc.SQL_SCROLL_OPTIONS,
TableTerm = odbc.SQL_TABLE_TERM,
TransactionCapable = odbc.SQL_TXN_CAPABLE,
TransactionIsolationOption = odbc.SQL_TXN_ISOLATION_OPTION,
Username = odbc.SQL_USER_NAME,
// Supported SQL
AggregateFunctions = odbc.SQL_AGGREGATE_FUNCTIONS,
AlterDomain = odbc.SQL_ALTER_DOMAIN,
AlterTable = odbc.SQL_ALTER_TABLE,
DatetimeLiterals = odbc.SQL_DATETIME_LITERALS,
CatalogLocation = odbc.SQL_CATALOG_LOCATION,
CatalogName = odbc.SQL_CATALOG_NAME,
CatalogNameSeparator = odbc.SQL_CATALOG_NAME_SEPARATOR,
CatalogUsage = odbc.SQL_CATALOG_USAGE,
ColumnAlias = odbc.SQL_COLUMN_ALIAS,
CorrelationName = odbc.SQL_CORRELATION_NAME,
CreateAssertion = odbc.SQL_CREATE_ASSERTION,
CreateCharacterSet = odbc.SQL_CREATE_CHARACTER_SET,
CreateCollation = odbc.SQL_CREATE_COLLATION,
CreateDomain = odbc.SQL_CREATE_DOMAIN,
CreateSchema = odbc.SQL_CREATE_SCHEMA,
CreateTable = odbc.SQL_CREATE_TABLE,
CreateTranslation = odbc.SQL_CREATE_TRANSLATION,
CreateView = odbc.SQL_CREATE_VIEW,
DDLIndex = odbc.SQL_DDL_INDEX,
DropAssertion = odbc.SQL_DROP_ASSERTION,
DropCharacterSet = odbc.SQL_DROP_CHARACTER_SET,
DropCollation = odbc.SQL_DROP_COLLATION,
DropDomain = odbc.SQL_DROP_DOMAIN,
DropSchema = odbc.SQL_DROP_SCHEMA,
DropTable = odbc.SQL_DROP_TABLE,
DropTranslation = odbc.SQL_DROP_TRANSLATION,
DropView = odbc.SQL_DROP_VIEW,
ExpressionsInOrderBy = odbc.SQL_EXPRESSIONS_IN_ORDERBY,
GroupBy = odbc.SQL_GROUP_BY,
IdentifierCase = odbc.SQL_IDENTIFIER_CASE,
IdentifierQuoteChar = odbc.SQL_IDENTIFIER_QUOTE_CHAR,
IndexKeywords = odbc.SQL_INDEX_KEYWORDS,
InsertStatement = odbc.SQL_INSERT_STATEMENT,
Integrity = odbc.SQL_INTEGRITY,
Keywords = odbc.SQL_KEYWORDS,
LikeEscapeClause = odbc.SQL_LIKE_ESCAPE_CLAUSE,
NonNullableColumns = odbc.SQL_NON_NULLABLE_COLUMNS,
OJCapabilities = odbc.SQL_OJ_CAPABILITIES,
OrderByColumnsInSelect = odbc.SQL_ORDER_BY_COLUMNS_IN_SELECT,
Procedures = odbc.SQL_PROCEDURES,
QuotedIdentifierCase = odbc.SQL_QUOTED_IDENTIFIER_CASE,
SchemaUsage = odbc.SQL_SCHEMA_USAGE,
SpecialCharacters = odbc.SQL_SPECIAL_CHARACTERS,
SQLConformance = odbc.SQL_SQL_CONFORMANCE,
SQLSubqueries = odbc.SQL_SUBQUERIES,
Union = odbc.SQL_UNION,
// SQL Limits
MaxBinaryLiteralLength = odbc.SQL_MAX_BINARY_LITERAL_LEN,
MaxCatalogNameLength = odbc.SQL_MAX_CATALOG_NAME_LEN,
MaxCharLiteralLength = odbc.SQL_MAX_CHAR_LITERAL_LEN,
MaxColumnNameLength = odbc.SQL_MAX_COLUMN_NAME_LEN,
MaxColumnsInGroupBy = odbc.SQL_MAX_COLUMNS_IN_GROUP_BY,
MaxColumnsInIndex = odbc.SQL_MAX_COLUMNS_IN_INDEX,
MaxColumnsInOrderBy = odbc.SQL_MAX_COLUMNS_IN_ORDER_BY,
MaxColumnsInSelect = odbc.SQL_MAX_COLUMNS_IN_SELECT,
MaxColumnsInTable = odbc.SQL_MAX_COLUMNS_IN_TABLE,
MaxCursorNameLength = odbc.SQL_MAX_CURSOR_NAME_LEN,
MaxIdentifierLength = odbc.SQL_MAX_IDENTIFIER_LEN,
MaxIndexSize = odbc.SQL_MAX_INDEX_SIZE,
MaxProcedureNameLength = odbc.SQL_MAX_PROCEDURE_NAME_LEN,
MaxRowSize = odbc.SQL_MAX_ROW_SIZE,
MaxRowSizeIncludesLong = odbc.SQL_MAX_ROW_SIZE_INCLUDES_LONG,
MaxSchemaNameLength = odbc.SQL_MAX_SCHEMA_NAME_LEN,
MaxStatementLength = odbc.SQL_MAX_STATEMENT_LEN,
MaxTableNameLength = odbc.SQL_MAX_TABLE_NAME_LEN,
MaxTablesInSelect = odbc.SQL_MAX_TABLES_IN_SELECT,
MaxUserNameLength = odbc.SQL_MAX_USER_NAME_LEN,
// Scalar Function Information
ConvertFunctions = odbc.SQL_CONVERT_FUNCTIONS,
NumericFunctions = odbc.SQL_NUMERIC_FUNCTIONS,
StringFunctions = odbc.SQL_STRING_FUNCTIONS,
SystemFunctions = odbc.SQL_SYSTEM_FUNCTIONS,
TimeDateAddIntervals = odbc.SQL_TIMEDATE_ADD_INTERVALS,
TimeDateDiffIntervals = odbc.SQL_TIMEDATE_DIFF_INTERVALS,
TimeDateFunctions = odbc.SQL_TIMEDATE_FUNCTIONS,
// Conversion Information
ConvertBigint = odbc.SQL_CONVERT_BIGINT,
ConvertBinary = odbc.SQL_CONVERT_BINARY,
ConvertBit = odbc.SQL_CONVERT_BIT,
ConvertChar = odbc.SQL_CONVERT_CHAR,
ConvertDate = odbc.SQL_CONVERT_DATE,
ConvertDecimal = odbc.SQL_CONVERT_DECIMAL,
ConvertDouble = odbc.SQL_CONVERT_DOUBLE,
ConvertFloat = odbc.SQL_CONVERT_FLOAT,
ConvertInteger = odbc.SQL_CONVERT_INTEGER,
ConvertIntervalDayTime = odbc.SQL_CONVERT_INTERVAL_DAY_TIME,
ConvertIntervalYearMonth = odbc.SQL_CONVERT_INTERVAL_YEAR_MONTH,
ConvertLongVarBinary = odbc.SQL_CONVERT_LONGVARBINARY,
ConvertLongVarChar = odbc.SQL_CONVERT_LONGVARCHAR,
ConvertNumeric = odbc.SQL_CONVERT_NUMERIC,
ConvertReal = odbc.SQL_CONVERT_REAL,
ConvertSmallInt = odbc.SQL_CONVERT_SMALLINT,
ConvertTime = odbc.SQL_CONVERT_TIME,
ConvertTimestamp = odbc.SQL_CONVERT_TIMESTAMP,
ConvertTinyInt = odbc.SQL_CONVERT_TINYINT,
ConvertVarBinary = odbc.SQL_CONVERT_VARBINARY,
ConvertVarChar = odbc.SQL_CONVERT_VARCHAR,
// Information types added for odbc 3.x
DMVersion = odbc.SQL_DM_VER,
XOpenCliYear = odbc.SQL_XOPEN_CLI_YEAR,
// Information types deprecated in odbc 3.x, but must still be supported
PosOperations = odbc.SQL_POS_OPERATIONS,
pub fn getValue(comptime self: InformationType, bytes: []u8, string_len: usize) InformationTypeValue {
return unionInitEnum(InformationTypeValue, self, switch (self) {
// Assorted bitmask attributes
.BatchRowCount => InformationTypeValue.BatchRowCount.applyBitmask(sliceToValue(u32, bytes)),
.BatchSupport => InformationTypeValue.BatchSupport.applyBitmask(sliceToValue(u32, bytes)),
.GetDataExtensions => InformationTypeValue.GetDataExtensions.applyBitmask(sliceToValue(u32, bytes)),
.InfoSchemaViews => InformationTypeValue.InfoSchemaViews.applyBitmask(sliceToValue(u32, bytes)),
.ParamArraySelects => InformationTypeValue.ParamArraySelects.applyBitmask(sliceToValue(u32, bytes)),
.BookmarkPersistence => InformationTypeValue.BookmarkPersistence.applyBitmask(sliceToValue(u32, bytes)),
.DefaultTransactionIsolation => InformationTypeValue.DefaultTransactionIsolation.applyBitmask(sliceToValue(u32, bytes)),
.ScrollOptions => InformationTypeValue.ScrollOptions.applyBitmask(sliceToValue(u32, bytes)),
.TransactionCapable => InformationTypeValue.TransactionCapable.applyBitmask(sliceToValue(u32, bytes)),
.TransactionIsolationOption => InformationTypeValue.TransactionIsolationOptions.applyBitmask(sliceToValue(u32, bytes)),
.AggregateFunctions => InformationTypeValue.AggregateFunctions.applyBitmask(sliceToValue(u32, bytes)),
.AlterDomain => InformationTypeValue.AlterDomain.applyBitmask(sliceToValue(u32, bytes)),
.AlterTable => InformationTypeValue.AlterTable.applyBitmask(sliceToValue(u32, bytes)),
.DatetimeLiterals => InformationTypeValue.DatetimeLiterals.applyBitmask(sliceToValue(u32, bytes)),
.CatalogUsage => InformationTypeValue.CatalogUsage.applyBitmask(sliceToValue(u32, bytes)),
.CreateAssertion => InformationTypeValue.CreateAssertion.applyBitmask(sliceToValue(u32, bytes)),
.CreateCharacterSet => InformationTypeValue.CreateCharacterSet.applyBitmask(sliceToValue(u32, bytes)),
.CreateCollation => InformationTypeValue.CreateCollation.applyBitmask(sliceToValue(u32, bytes)),
.CreateDomain => InformationTypeValue.CreateDomain.applyBitmask(sliceToValue(u32, bytes)),
.CreateSchema => InformationTypeValue.CreateSchema.applyBitmask(sliceToValue(u32, bytes)),
.CreateTable => InformationTypeValue.CreateTable.applyBitmask(sliceToValue(u32, bytes)),
.CreateTranslation => InformationTypeValue.CreateTranslation.applyBitmask(sliceToValue(u32, bytes)),
.CreateView => InformationTypeValue.CreateView.applyBitmask(sliceToValue(u32, bytes)),
.DDLIndex => InformationTypeValue.DDLIndex.applyBitmask(sliceToValue(u32, bytes)),
.DropAssertion => InformationTypeValue.DropAssertion.applyBitmask(sliceToValue(u32, bytes)),
.DropCharacterSet => InformationTypeValue.DropCharacterSet.applyBitmask(sliceToValue(u32, bytes)),
.DropCollation => InformationTypeValue.DropCollation.applyBitmask(sliceToValue(u32, bytes)),
.DropDomain => InformationTypeValue.DropDomain.applyBitmask(sliceToValue(u32, bytes)),
.DropSchema => InformationTypeValue.DropSchema.applyBitmask(sliceToValue(u32, bytes)),
.DropTable => InformationTypeValue.DropTable.applyBitmask(sliceToValue(u32, bytes)),
.DropTranslation => InformationTypeValue.DropTranslation.applyBitmask(sliceToValue(u32, bytes)),
.DropView => InformationTypeValue.DropView.applyBitmask(sliceToValue(u32, bytes)),
.IndexKeywords => InformationTypeValue.IndexKeywords.applyBitmask(sliceToValue(u32, bytes)),
.InsertStatement => InformationTypeValue.InsertStatement.applyBitmask(sliceToValue(u32, bytes)),
.OJCapabilities => InformationTypeValue.OJCapabilities.applyBitmask(sliceToValue(u32, bytes)),
.SchemaUsage => InformationTypeValue.SchemaUsage.applyBitmask(sliceToValue(u32, bytes)),
.SQLSubqueries => InformationTypeValue.Subqueries.applyBitmask(sliceToValue(u32, bytes)),
.Union => InformationTypeValue.Union.applyBitmask(sliceToValue(u32, bytes)),
.ConvertFunctions => InformationTypeValue.ConvertFunctions.applyBitmask(sliceToValue(u32, bytes)),
.NumericFunctions => InformationTypeValue.NumericFunctions.applyBitmask(sliceToValue(u32, bytes)),
.StringFunctions => InformationTypeValue.StringFunctions.applyBitmask(sliceToValue(u32, bytes)),
.SystemFunctions => InformationTypeValue.SystemFunctions.applyBitmask(sliceToValue(u32, bytes)),
.PosOperations => InformationTypeValue.PositionOperations.applyBitmask(sliceToValue(c_ushort, bytes)),
.TimeDateFunctions => InformationTypeValue.TimedateFunctions.applyBitmask(sliceToValue(u32, bytes)),
// Cursor Attributes bitmask attributes
.DynamicCursorAttributes1, .ForwardOnlyCursorAttributes1,
.KeysetCursorAttributes1, .StaticCursorAttributes1 => InformationTypeValue.CursorAttributes1.applyBitmask(sliceToValue(u32, bytes)),
.DynamicCursorAttributes2, .ForwardOnlyCursorAttributes2,
.KeysetCursorAttributes2, .StaticCursorAttributes2 => InformationTypeValue.CursorAttributes2.applyBitmask(sliceToValue(u32, bytes)),
// TimeDate interval bitmask attributes.
.TimeDateAddIntervals, .TimeDateDiffIntervals => InformationTypeValue.TimedateIntervals.applyBitmask(sliceToValue(u32, bytes)),
// Supported conversions bitmask attributes
.ConvertBigint, .ConvertBinary, .ConvertBit,
.ConvertChar, .ConvertDate, .ConvertDecimal, .ConvertDouble, .ConvertFloat, .ConvertInteger,
.ConvertIntervalDayTime, .ConvertIntervalYearMonth, .ConvertLongVarBinary, .ConvertLongVarChar, .ConvertNumeric,
.ConvertReal, .ConvertSmallInt, .ConvertTime, .ConvertTimestamp, .ConvertTinyInt, .ConvertVarBinary,
.ConvertVarChar => InformationTypeValue.SupportedConversion.applyBitmask(sliceToValue(u32, bytes)),
// Assorted enum attributes
.AsyncMode => @intToEnum(InformationTypeValue.AsyncMode, sliceToValue(u32, bytes)),
.FileUsage => @intToEnum(InformationTypeValue.FileUsage, sliceToValue(c_ushort, bytes)),
.OdbcInterfaceConformance => @intToEnum(InformationTypeValue.InterfaceConformance, sliceToValue(c_ushort, bytes)),
.ConcatNullBehavior => @intToEnum(InformationTypeValue.ConcatNullBehavior, sliceToValue(c_ushort, bytes)),
.CursorCommitBehavior => @intToEnum(InformationTypeValue.CursorCommitBehavior, sliceToValue(c_ushort, bytes)),
.CursorRollbackBehavior => @intToEnum(InformationTypeValue.CursorRollbackBehavior, sliceToValue(c_ushort, bytes)),
.CursorSensitivity => @intToEnum(InformationTypeValue.CursorSensitivity, sliceToValue(c_ushort, bytes)),
.NullCollation => @intToEnum(InformationTypeValue.NullCollation, sliceToValue(c_ushort, bytes)),
.CatalogLocation => @intToEnum(InformationTypeValue.CatalogLocation, sliceToValue(c_ushort, bytes)),
.CorrelationName => @intToEnum(InformationTypeValue.CorrelationName, sliceToValue(c_ushort, bytes)),
.GroupBy => @intToEnum(InformationTypeValue.GroupBy, sliceToValue(c_ushort, bytes)),
.IdentifierCase => @intToEnum(InformationTypeValue.IdentifierCase, sliceToValue(c_ushort, bytes)),
.QuotedIdentifierCase => @intToEnum(InformationTypeValue.QuotedIdentifierCase, sliceToValue(c_ushort, bytes)),
.SQLConformance => @intToEnum(InformationTypeValue.SQLConformance, sliceToValue(c_ushort, bytes)),
// String attributes
.DataSourceName, .DriverName, .DriverOdbcVersion,
.DriverVersion, .OdbcVersion, .SearchPatternEscape,
.ServerName, .DatabaseName, .DBMSName,
.DBMSVersion, .CatalogTerm, .CollationSeq,
.ProcedureTerm, .SchemaTerm, .TableTerm,
.Username, .CatalogNameSeparator, .IdentifierQuoteChar,
.Keywords, .DMVersion, .XOpenCliYear,
.SpecialCharacters => bytes[0..string_len:0],
// Boolean attributes
.AccessibleProcedures, .AccessibleTables, .AsyncConnectFunctions,
.AsyncNotification, .DriverAwarePoolingSupported, .ParamArrayRowCounts, .RowUpdates,
.DataSourceReadOnly, .DescribeParameter, .MultipleResultSets, .MultipleActiveTransactions,
.NeedLongDataLength, .CatalogName, .ColumnAlias, .ExpressionsInOrderBy, .Integrity,
.LikeEscapeClause, .NonNullableColumns, .OrderByColumnsInSelect, .Procedures,
.MaxRowSizeIncludesLong => bytes[0] == 'Y',
// usize attributes
.DriverConnectionHandle, .DriverDescriptorHandle,
.DriverEnvironmentHandle, .DriverLibraryHandle,
.DriverStatementHandle => sliceToValue(usize, bytes),
// u32 attributes
.MaxAsyncConcurrentStatements, .MaxBinaryLiteralLength, .MaxCharLiteralLength => sliceToValue(u32, bytes),
// c_ushort attributes
.ActiveEnvironments, .MaxConcurrentActivities,
.MaxDriverConnections, .MaxCatalogNameLength, .MaxColumnNameLength,
.MaxColumnsInGroupBy, .MaxColumnsInIndex,
.MaxColumnsInOrderBy, .MaxColumnsInSelect,
.MaxColumnsInTable, .MaxCursorNameLength, .MaxIdentifierLength,
.MaxIndexSize, .MaxProcedureNameLength, .MaxRowSize,
.MaxSchemaNameLength, .MaxStatementLength,
.MaxTableNameLength, .MaxTablesInSelect, .MaxUserNameLength => sliceToValue(c_ushort, bytes),
});
}
};
pub const InformationTypeValue = union(InformationType) {
AccessibleProcedures: bool,
AccessibleTables: bool,
ActiveEnvironments: c_ushort,
AggregateFunctions: AggregateFunctions.Result,
AlterDomain: AlterDomain.Result,
AlterTable: AlterTable.Result,
AsyncConnectFunctions: bool,
AsyncMode: AsyncMode,
AsyncNotification: bool,
BatchRowCount: BatchRowCount.Result,
BatchSupport: BatchSupport.Result,
BookmarkPersistence: BookmarkPersistence.Result,
CatalogLocation: CatalogLocation,
CatalogName: bool,
CatalogNameSeparator: [:0]const u8,
CatalogTerm: [:0]const u8,
CatalogUsage: CatalogUsage.Result,
CollationSeq: [:0]const u8,
ColumnAlias: bool,
ConcatNullBehavior: ConcatNullBehavior,
ConvertBigint: SupportedConversion.Result,
ConvertBinary: SupportedConversion.Result,
ConvertBit: SupportedConversion.Result,
ConvertChar: SupportedConversion.Result,
ConvertDate: SupportedConversion.Result,
ConvertDecimal: SupportedConversion.Result,
ConvertDouble: SupportedConversion.Result,
ConvertFloat: SupportedConversion.Result,
ConvertInteger: SupportedConversion.Result,
ConvertIntervalDayTime: SupportedConversion.Result,
ConvertIntervalYearMonth: SupportedConversion.Result,
ConvertLongVarBinary: SupportedConversion.Result,
ConvertLongVarChar: SupportedConversion.Result,
ConvertNumeric: SupportedConversion.Result,
ConvertReal: SupportedConversion.Result,
ConvertSmallInt: SupportedConversion.Result,
ConvertTime: SupportedConversion.Result,
ConvertTimestamp: SupportedConversion.Result,
ConvertTinyInt: SupportedConversion.Result,
ConvertVarBinary: SupportedConversion.Result,
ConvertVarChar: SupportedConversion.Result,
ConvertFunctions: ConvertFunctions.Result,
CorrelationName: CorrelationName,
CreateAssertion: CreateAssertion.Result,
CreateCharacterSet: CreateCharacterSet.Result,
CreateCollation: CreateCollation.Result,
CreateDomain: CreateDomain.Result,
CreateSchema: CreateSchema.Result,
CreateTable: CreateTable.Result,
CreateTranslation: CreateTranslation.Result,
CreateView: CreateView.Result,
CursorCommitBehavior: CursorCommitBehavior,
CursorRollbackBehavior: CursorRollbackBehavior,
CursorSensitivity: CursorSensitivity,
DataSourceName: [:0]const u8,
DataSourceReadOnly: bool,
DatabaseName: [:0]const u8,
DatetimeLiterals: DatetimeLiterals.Result,
DBMSName: [:0]const u8,
DBMSVersion: [:0]const u8,
DDLIndex: DDLIndex.Result,
DefaultTransactionIsolation: DefaultTransactionIsolation.Result,
DescribeParameter: bool,
DMVersion: [:0]const u8,
DriverAwarePoolingSupported: bool,
DriverConnectionHandle: usize,
DriverDescriptorHandle: usize,
DriverEnvironmentHandle: usize,
DriverLibraryHandle: usize,
DriverStatementHandle: usize,
DriverName: [:0]const u8,
DriverOdbcVersion: [:0]const u8,
DriverVersion: [:0]const u8,
DropAssertion: DropAssertion.Result,
DropCharacterSet: DropCharacterSet.Result,
DropCollation: DropCollation.Result,
DropDomain: DropDomain.Result,
DropSchema: DropSchema.Result,
DropTable: DropTable.Result,
DropTranslation: DropTranslation.Result,
DropView: DropView.Result,
DynamicCursorAttributes1: CursorAttributes1.Result,
DynamicCursorAttributes2: CursorAttributes2.Result,
ExpressionsInOrderBy: bool,
FileUsage: FileUsage,
ForwardOnlyCursorAttributes1: CursorAttributes1.Result,
ForwardOnlyCursorAttributes2: CursorAttributes2.Result,
GetDataExtensions: GetDataExtensions.Result,
GroupBy: GroupBy,
IdentifierCase: IdentifierCase,
IdentifierQuoteChar: [:0]const u8,
IndexKeywords: IndexKeywords.Result,
InfoSchemaViews: InfoSchemaViews.Result,
InsertStatement: InsertStatement.Result,
Integrity: bool,
KeysetCursorAttributes1: CursorAttributes1.Result,
KeysetCursorAttributes2: CursorAttributes2.Result,
Keywords: [:0]const u8,
LikeEscapeClause: bool,
MaxAsyncConcurrentStatements: u32,
MaxBinaryLiteralLength: u32,
MaxCatalogNameLength: c_ushort,
MaxCharLiteralLength: u32,
MaxColumnNameLength: c_ushort,
MaxColumnsInGroupBy: c_ushort,
MaxColumnsInIndex: c_ushort,
MaxColumnsInOrderBy: c_ushort,
MaxColumnsInSelect: c_ushort,
MaxColumnsInTable: c_ushort,
MaxConcurrentActivities: c_ushort,
MaxCursorNameLength: c_ushort,
MaxDriverConnections: c_ushort,
MaxIdentifierLength: c_ushort,
MaxIndexSize: u32,
MaxProcedureNameLength: c_ushort,
MaxRowSize: u32,
MaxRowSizeIncludesLong: bool,
MaxSchemaNameLength: c_ushort,
MaxStatementLength: u32,
MaxTableNameLength: c_ushort,
MaxTablesInSelect: c_ushort,
MaxUserNameLength: c_ushort,
MultipleResultSets: bool,
MultipleActiveTransactions: bool,
NeedLongDataLength: bool,
NonNullableColumns: bool,
NullCollation: NullCollation,
NumericFunctions: NumericFunctions.Result,
OdbcInterfaceConformance: InterfaceConformance,
OdbcVersion: [:0]const u8,
OJCapabilities: OJCapabilities.Result,
OrderByColumnsInSelect: bool,
ParamArrayRowCounts: bool,
ParamArraySelects: ParamArraySelects.Result,
PosOperations: PositionOperations.Result,
ProcedureTerm: [:0]const u8,
Procedures: bool,
QuotedIdentifierCase: QuotedIdentifierCase,
RowUpdates: bool,
SchemaTerm: [:0]const u8,
SchemaUsage: SchemaUsage.Result,
ScrollOptions: ScrollOptions.Result,
SearchPatternEscape: [:0]const u8,
ServerName: [:0]const u8,
SpecialCharacters: [:0]const u8,
SQLConformance: SQLConformance,
// OdbcStandardCliConformance: OdbcStandardCliConformance.Result,
StaticCursorAttributes1: CursorAttributes1.Result,
StaticCursorAttributes2: CursorAttributes2.Result,
StringFunctions: StringFunctions.Result,
SQLSubqueries: Subqueries.Result,
SystemFunctions: SystemFunctions.Result,
TableTerm: [:0]const u8,
TimeDateAddIntervals: TimedateIntervals.Result,
TimeDateDiffIntervals: TimedateIntervals.Result,
TimeDateFunctions: TimedateFunctions.Result,
TransactionCapable: TransactionCapable.Result,
TransactionIsolationOption: TransactionIsolationOptions.Result,
Union: Union.Result,
Username: [:0]const u8,
XOpenCliYear: [:0]const u8,
/// Return `true` if the payload type of the active union member is a zig string (slice of u8), `false` otherwise.
pub fn isStringType(info_value: InformationTypeValue) bool {
const active_tag = std.meta.activeTag(info_value);
const itv_info = @typeInfo(InformationTypeValue);
inline for (itv_info.Union.fields) |field| {
if (std.mem.eql(u8, field.name, @tagName(active_tag))) {
if (comptime std.meta.trait.isSlice(field.field_type)) {
return @typeInfo(field.field_type).Pointer.child == u8;
}
return false;
}
}
unreachable;
}
pub const AggregateFunctions = Bitmask(u32, .{
.{ "all", odbc.SQL_AF_ALL },
.{ "avg", odbc.SQL_AF_AVG },
.{ "count", odbc.SQL_AF_COUNT },
.{ "distinct", odbc.SQL_AF_DISTINCT },
.{ "max", odbc.SQL_AF_MAX },
.{ "min", odbc.SQL_AF_MIN },
.{ "sum", odbc.SQL_AF_SUM },
});
pub const AlterDomain = Bitmask(u32, .{
.{ "add_domain_constraint", odbc.SQL_AD_ADD_DOMAIN_CONSTRAINT },
.{ "add_domain_default", odbc.SQL_AD_ADD_DOMAIN_DEFAULT },
.{ "constraint_name_definition", odbc.SQL_AD_CONSTRAINT_NAME_DEFINITION },
.{ "drop_domain_constraint", odbc.SQL_AD_DROP_DOMAIN_CONSTRAINT },
.{ "add_constraint_deferrable", odbc.SQL_AD_ADD_CONSTRAINT_DEFERRABLE },
.{ "add_constraint_non_deferrable", odbc.SQL_AD_ADD_CONSTRAINT_NON_DEFERRABLE },
.{ "add_constraint_initially_deferred", odbc.SQL_AD_ADD_CONSTRAINT_INITIALLY_DEFERRED },
.{ "add_constraint_initially_immediate", odbc.SQL_AD_ADD_CONSTRAINT_INITIALLY_IMMEDIATE }
});
pub const AlterTable = Bitmask(u32, .{
.{ "add_column_collation", odbc.SQL_AT_ADD_COLUMN_COLLATION },
.{ "add_column_default", odbc.SQL_AT_ADD_COLUMN_DEFAULT },
.{ "add_column_single", odbc.SQL_AT_ADD_COLUMN_SINGLE },
.{ "add_constraint", odbc.SQL_AT_ADD_CONSTRAINT },
.{ "add_table_constraint", odbc.SQL_AT_ADD_TABLE_CONSTRAINT },
.{ "constraint_name_definition", odbc.SQL_AT_CONSTRAINT_NAME_DEFINITION },
.{ "drop_column_cascade", odbc.SQL_AT_DROP_COLUMN_CASCADE },
.{ "drop_column_default", odbc.SQL_AT_DROP_COLUMN_DEFAULT },
.{ "drop_column_restrict", odbc.SQL_AT_DROP_COLUMN_RESTRICT },
.{ "drop_table_constraint_cascade", odbc.SQL_AT_DROP_TABLE_CONSTRAINT_CASCADE },
.{ "drop_table_constraint_restrict", odbc.SQL_AT_DROP_TABLE_CONSTRAINT_RESTRICT },
.{ "set_column_default", odbc.SQL_AT_SET_COLUMN_DEFAULT },
});
pub const AsyncMode = enum(u32) {
Connection = odbc.SQL_AM_CONNECTION,
Statement = odbc.SQL_AM_STATEMENT,
None = odbc.SQL_AM_NONE
};
pub const BatchRowCount = Bitmask(u32, .{
.{ "rolled_up", odbc.SQL_BRC_ROLLED_UP },
.{ "procedures", odbc.SQL_BRC_PROCEDURES },
.{ "explicit", odbc.SQL_BRC_EXPLICIT }
});
pub const BatchSupport = Bitmask(u32, .{
.{ "select_explicit", odbc.SQL_BS_SELECT_EXPLICIT },
.{ "row_count_explicit", odbc.SQL_BS_ROW_COUNT_EXPLICIT },
.{ "select_proc", odbc.SQL_BS_SELECT_PROC },
.{ "row_count_proc", odbc.SQL_BS_ROW_COUNT_PROC },
});
pub const BookmarkPersistence = Bitmask(u32, .{
.{ "close", odbc.SQL_BP_CLOSE },
.{ "delete", odbc.SQL_BP_DELETE },
.{ "drop", odbc.SQL_BP_DROP },
.{ "transaction", odbc.SQL_BP_TRANSACTION },
.{ "update", odbc.SQL_BP_UPDATE },
.{ "other_statement", odbc.SQL_BP_OTHER_HSTMT }
});
pub const CatalogLocation = enum(c_ushort) {
Start = odbc.SQL_CL_START,
End = odbc.SQL_CL_END
};
pub const CatalogUsage = Bitmask(u32, .{
.{ "dml_statements", odbc.SQL_CU_DML_STATEMENTS },
.{ "table_definition", odbc.SQL_CU_TABLE_DEFINITION },
.{ "index_definition", odbc.SQL_CU_INDEX_DEFINITION },
.{ "privilege_definition", odbc.SQL_CU_PRIVILEGE_DEFINITION }
});
pub const ConcatNullBehavior = enum(c_ushort) {
Null = odbc.SQL_CB_NULL,
NonNull = odbc.SQL_CB_NON_NULL
};
pub const SupportedConversion = Bitmask(u32, .{
.{ "bigint", odbc.SQL_CVT_BIGINT },
.{ "binary", odbc.SQL_CVT_BINARY },
.{ "bit", odbc.SQL_CVT_BIT },
.{ "guid", odbc.SQL_CVT_BIT },
.{ "char", odbc.SQL_CVT_CHAR },
.{ "date", odbc.SQL_CVT_CHAR },
.{ "decimal", odbc.SQL_CVT_DECIMAL },
.{ "double", odbc.SQL_CVT_DOUBLE },
.{ "float", odbc.SQL_CVT_FLOAT },
.{ "integer", odbc.SQL_CVT_INTEGER },
.{ "interval_year_month", odbc.SQL_CVT_INTERVAL_YEAR_MONTH },
.{ "interval_day_time", odbc.SQL_CVT_INTERVAL_DAY_TIME },
.{ "long_var_binary", odbc.SQL_CVT_LONGVARBINARY },
.{ "long_var_char", odbc.SQL_CVT_LONGVARCHAR },
.{ "numeric", odbc.SQL_CVT_NUMERIC },
.{ "real", odbc.SQL_CVT_REAL },
.{ "small_int", odbc.SQL_CVT_SMALLINT },
.{ "time", odbc.SQL_CVT_TIME },
.{ "timestamp", odbc.SQL_CVT_TIMESTAMP },
.{ "tiny_int", odbc.SQL_CVT_TINYINT },
.{ "var_binary", odbc.SQL_CVT_VARBINARY },
.{ "var_char", odbc.SQL_CVT_VARCHAR }
});
pub const ConvertFunctions = Bitmask(u32, .{
.{ "cast", odbc.SQL_FN_CVT_CAST },
.{ "convert", odbc.SQL_FN_CVT_CONVERT }
});
pub const CorrelationName = enum(c_ushort) {
None = odbc.SQL_CN_NONE,
Different = odbc.SQL_CN_DIFFERENT,
Any = odbc.SQL_CN_ANY
};
pub const CreateAssertion = Bitmask(u32, .{
.{ "supported", odbc.SQL_CA_CREATE_ASSERTION },
.{ "constraint_initially_deferred", odbc.SQL_CA_CONSTRAINT_INITIALLY_DEFERRED },
.{ "constraint_initially_immediate", odbc.SQL_CA_CONSTRAINT_INITIALLY_IMMEDIATE },
.{ "constraint_deferrable", odbc.SQL_CA_CONSTRAINT_DEFERRABLE },
.{ "constraint_non_deferrable", odbc.SQL_CA_CONSTRAINT_NON_DEFERRABLE }
});
pub const CreateCharacterSet = Bitmask(u32, .{
.{ "supported", odbc.SQL_CCS_CREATE_CHARACTER_SET },
.{ "collate_clause", odbc.SQL_CCS_COLLATE_CLAUSE },
.{ "limited_collation", odbc.SQL_CCS_LIMITED_COLLATION }
});
pub const CreateCollation = Bitmask(u32, .{ .{ "supported", odbc.SQL_CCOL_CREATE_COLLATION }});
pub const CreateDomain = Bitmask(u32, .{
.{ "supported", odbc.SQL_CDO_CREATE_DOMAIN },
.{ "supports_defaults", odbc.SQL_CDO_DEFAULT },
.{ "supports_constraints", odbc.SQL_CDO_CONSTRAINT },
.{ "supports_collation", odbc.SQL_CDO_COLLATION },
.{ "constraint_initially_deferred", odbc.SQL_CDO_CONSTRAINT_INITIALLY_DEFERRED },
.{ "constraint_initially_immediate", odbc.SQL_CDO_CONSTRAINT_INITIALLY_IMMEDIATE },
.{ "constraint_deferrable", odbc.SQL_CDO_CONSTRAINT_DEFERRABLE },
.{ "constraint_non_deferrable", odbc.SQL_CDO_CONSTRAINT_NON_DEFERRABLE }
});
pub const CreateSchema = Bitmask(u32, .{
.{ "supported", odbc.SQL_CS_CREATE_SCHEMA },
.{ "authorization", odbc.SQL_CS_AUTHORIZATION },
.{ "default_character_set", odbc.SQL_CS_DEFAULT_CHARACTER_SET }
});
pub const CreateTable = Bitmask(u32, .{
.{ "supported", odbc.SQL_CT_CREATE_TABLE },
.{ "table_constraints", odbc.SQL_CT_TABLE_CONSTRAINT },
.{ "constraint_name_definition", odbc.SQL_CT_CONSTRAINT_NAME_DEFINITION },
.{ "commit_preserve", odbc.SQL_CT_COMMIT_PRESERVE },
.{ "commit_delete", odbc.SQL_CT_COMMIT_DELETE },
.{ "global_temporary", odbc.SQL_CT_GLOBAL_TEMPORARY },
.{ "local_temporary", odbc.SQL_CT_LOCAL_TEMPORARY },
.{ "column_constraint_supported", odbc.SQL_CT_COLUMN_CONSTRAINT },
.{ "column_default", odbc.SQL_CT_COLUMN_DEFAULT },
.{ "column_collation", odbc.SQL_CT_COLUMN_COLLATION },
.{ "constraint_initially_deferred", odbc.SQL_CT_CONSTRAINT_INITIALLY_DEFERRED },
.{ "constraint_initially_immediate", odbc.SQL_CT_CONSTRAINT_INITIALLY_IMMEDIATE },
.{ "constraint_deferrable", odbc.SQL_CT_CONSTRAINT_DEFERRABLE },
.{ "constraint_non_deferrable", odbc.SQL_CT_CONSTRAINT_NON_DEFERRABLE }
});
pub const CreateTranslation = Bitmask(u32, .{ .{ "supported", odbc.SQL_CTR_CREATE_TRANSLATION }});
pub const CreateView = Bitmask(u32, .{
.{ "supported", odbc.SQL_CV_CREATE_VIEW },
.{ "check_option", odbc.SQL_CV_CHECK_OPTION },
.{ "cascaded", odbc.SQL_CV_CASCADED },
.{ "local", odbc.SQL_CV_LOCAL }
});
pub const CursorCommitBehavior = enum(c_ushort) {
Delete = odbc.SQL_CB_DELETE,
Close = odbc.SQL_CB_CLOSE,
Preserve = odbc.SQL_CB_PRESERVE
};
pub const CursorRollbackBehavior = enum(c_ushort) {
Delete = odbc.SQL_CB_DELETE,
Close = odbc.SQL_CB_CLOSE,
Preserve = odbc.SQL_CB_PRESERVE
};
pub const CursorSensitivity = enum(u32) {
Insensitive = odbc.SQL_INSENSITIVE,
Unspecified = odbc.SQL_UNSPECIFIED,
Sensitive = odbc.SQL_SENSITIVE
};
pub const DatetimeLiterals = Bitmask(u32, .{
.{ "date", odbc.SQL_DL_SQL92_DATE },
.{ "time", odbc.SQL_DL_SQL92_TIME },
.{ "timestamp", odbc.SQL_DL_SQL92_TIMESTAMP },
.{ "interval_year", odbc.SQL_DL_SQL92_INTERVAL_YEAR },
.{ "interval_month", odbc.SQL_DL_SQL92_INTERVAL_MONTH },
.{ "interval_day", odbc.SQL_DL_SQL92_INTERVAL_DAY },
.{ "interval_hour", odbc.SQL_DL_SQL92_INTERVAL_HOUR },
.{ "interval_minute", odbc.SQL_DL_SQL92_INTERVAL_MINUTE },
.{ "interval_second", odbc.SQL_DL_SQL92_INTERVAL_SECOND },
.{ "interval_year_to_month", odbc.SQL_DL_SQL92_INTERVAL_YEAR_TO_MONTH },
.{ "interval_day_to_hour", odbc.SQL_DL_SQL92_INTERVAL_DAY_TO_HOUR },
.{ "interval_day_to_minute", odbc.SQL_DL_SQL92_INTERVAL_DAY_TO_MINUTE },
.{ "interval_day_to_second", odbc.SQL_DL_SQL92_INTERVAL_DAY_TO_SECOND },
.{ "interval_hour_to_minute", odbc.SQL_DL_SQL92_INTERVAL_HOUR_TO_MINUTE },
.{ "interval_hour_to_second", odbc.SQL_DL_SQL92_INTERVAL_HOUR_TO_SECOND },
.{ "interval_minute_to_second", odbc.SQL_DL_SQL92_INTERVAL_MINUTE_TO_SECOND },
});
pub const DDLIndex = Bitmask(u32, .{
.{ "create_index", odbc.SQL_DI_CREATE_INDEX },
.{ "drop_index", odbc.SQL_DI_DROP_INDEX }
});
pub const DefaultTransactionIsolation = Bitmask(u32, .{
.{ "read_uncommitted", odbc.SQL_TXN_READ_UNCOMMITTED },
.{ "read_committed", odbc.SQL_TXN_READ_COMMITTED },
.{ "repeatable_read", odbc.SQL_TXN_REPEATABLE_READ },
.{ "serializable", odbc.SQL_TXN_SERIALIZABLE }
});
pub const DropAssertion = Bitmask(u32, .{ .{ "supported", odbc.SQL_DA_DROP_ASSERTION }});
pub const DropCharacterSet = Bitmask(u32, .{ .{ "supported", odbc.SQL_DCS_DROP_CHARACTER_SET }});
pub const DropCollation = Bitmask(u32, .{ .{ "supported", odbc.SQL_DC_DROP_COLLATION }});
pub const DropDomain = Bitmask(u32, .{
.{ "supported", odbc.SQL_DD_DROP_DOMAIN },
.{ "cascade", odbc.SQL_DD_CASCADE },
.{ "restrict", odbc.SQL_DD_RESTRICT }
});
pub const DropSchema = Bitmask(u32, .{
.{ "supported", odbc.SQL_DS_DROP_SCHEMA },
.{ "cascade", odbc.SQL_DS_CASCADE },
.{ "restrict", odbc.SQL_DS_RESTRICT }
});
pub const DropTable = Bitmask(u32, .{
.{ "supported", odbc.SQL_DT_DROP_TABLE },
.{ "cascade", odbc.SQL_DT_CASCADE },
.{ "restrict", odbc.SQL_DT_RESTRICT }
});
pub const DropTranslation = Bitmask(u32, .{ .{ "supported", odbc.SQL_DTR_DROP_TRANSLATION }});
pub const DropView = Bitmask(u32, .{
.{ "supported", odbc.SQL_DV_DROP_VIEW },
.{ "cascade", odbc.SQL_DV_CASCADE },
.{ "restrict", odbc.SQL_DV_RESTRICT }
});
pub const CursorAttributes1 = Bitmask(u32, .{
.{ "next", odbc.SQL_CA1_NEXT },
.{ "absolute", odbc.SQL_CA1_ABSOLUTE },
.{ "relative", odbc.SQL_CA1_RELATIVE },
.{ "bookmark", odbc.SQL_CA1_BOOKMARK },
.{ "lock_exclusive", odbc.SQL_CA1_LOCK_EXCLUSIVE },
.{ "lock_no_change", odbc.SQL_CA1_LOCK_NO_CHANGE },
.{ "lock_unlock", odbc.SQL_CA1_LOCK_UNLOCK },
.{ "position", odbc.SQL_CA1_POS_POSITION },
.{ "position_update", odbc.SQL_CA1_POS_UPDATE },
.{ "position_delete", odbc.SQL_CA1_POS_DELETE },
.{ "position_refresh", odbc.SQL_CA1_POS_REFRESH },
.{ "positioned_update", odbc.SQL_CA1_POSITIONED_UPDATE },
.{ "positioned_delete", odbc.SQL_CA1_POSITIONED_DELETE },
.{ "select_for_update", odbc.SQL_CA1_SELECT_FOR_UPDATE },
.{ "bulk_add", odbc.SQL_CA1_BULK_ADD },
.{ "bulk_update_by_bookmark", odbc.SQL_CA1_BULK_UPDATE_BY_BOOKMARK },
.{ "bulk_delete_by_bookmark", odbc.SQL_CA1_BULK_DELETE_BY_BOOKMARK },
.{ "bulk_fetch_by_bookmark", odbc.SQL_CA1_BULK_FETCH_BY_BOOKMARK },
});
pub const CursorAttributes2 = Bitmask(u32, .{
.{ "read_only_concurrency", odbc.SQL_CA2_READ_ONLY_CONCURRENCY },
.{ "lock_concurrency", odbc.SQL_CA2_LOCK_CONCURRENCY },
.{ "optimistic_row_version_concurrency", odbc.SQL_CA2_OPT_ROWVER_CONCURRENCY },
.{ "optimistic_values_concurrency", odbc.SQL_CA2_OPT_VALUES_CONCURRENCY },
.{ "sensitivity_additions", odbc.SQL_CA2_SENSITIVITY_ADDITIONS },
.{ "sensitivity_deletions", odbc.SQL_CA2_SENSITIVITY_DELETIONS },
.{ "sensitivity_updates", odbc.SQL_CA2_SENSITIVITY_UPDATES },
.{ "max_rows_select", odbc.SQL_CA2_MAX_ROWS_SELECT },
.{ "max_rows_insert", odbc.SQL_CA2_MAX_ROWS_INSERT },
.{ "max_rows_delete", odbc.SQL_CA2_MAX_ROWS_DELETE },
.{ "max_rows_update", odbc.SQL_CA2_MAX_ROWS_UPDATE },
.{ "max_rows_catalog", odbc.SQL_CA2_MAX_ROWS_CATALOG },
.{ "max_rows_affects_all", odbc.SQL_CA2_MAX_ROWS_AFFECTS_ALL },
.{ "exact_cursor_row_count", odbc.SQL_CA2_CRC_EXACT },
.{ "approximate_cursor_row_count", odbc.SQL_CA2_CRC_APPROXIMATE },
.{ "simulate_non_unique", odbc.SQL_CA2_SIMULATE_NON_UNIQUE },
.{ "simulate_try_unique", odbc.SQL_CA2_SIMULATE_TRY_UNIQUE },
.{ "simulate_unique", odbc.SQL_CA2_SIMULATE_UNIQUE },
});
pub const FileUsage = enum(c_ushort) {
NotSupported = odbc.SQL_FILE_NOT_SUPPORTED,
Table = odbc.SQL_FILE_TABLE,
Catalog = odbc.SQL_FILE_CATALOG
};
pub const GetDataExtensions = Bitmask(u32, .{
.{ "any_column", odbc.SQL_GD_ANY_COLUMN },
.{ "any_order", odbc.SQL_GD_ANY_ORDER },
.{ "block", odbc.SQL_GD_BLOCK },
.{ "bound", odbc.SQL_GD_BOUND },
.{ "output_params", odbc.SQL_GD_OUTPUT_PARAMS }
});
pub const GroupBy = enum(c_ushort) {
Collate = odbc.SQL_GB_COLLATE,
NotSupported = odbc.SQL_GB_NOT_SUPPORTED,
GroupByEqualsSelect = odbc.SQL_GB_GROUP_BY_EQUALS_SELECT,
NoRelation = odbc.SQL_GB_NO_RELATION
};
pub const IdentifierCase = enum(c_ushort) {
Upper = odbc.SQL_IC_UPPER,
Lower = odbc.SQL_IC_LOWER,
Sensitive = odbc.SQL_IC_SENSITIVE,
Mixed = odbc.SQL_IC_MIXED
};
pub const IndexKeywords = Bitmask(u32, .{
.{ "none", odbc.SQL_IK_NONE },
.{ "asc", odbc.SQL_IK_ASC },
.{ "desc", odbc.SQL_IK_DESC },
.{ "all", odbc.SQL_IK_ALL }
});
pub const InfoSchemaViews = Bitmask(u32, .{
.{ "assertions", odbc.SQL_ISV_ASSERTIONS },
.{ "character_sets", odbc.SQL_ISV_CHARACTER_SETS },
.{ "check_constraints", odbc.SQL_ISV_CHECK_CONSTRAINTS },
.{ "collations", odbc.SQL_ISV_COLLATIONS },
.{ "column_domain_usage", odbc.SQL_ISV_COLUMN_DOMAIN_USAGE },
.{ "column_privileges", odbc.SQL_ISV_COLUMN_PRIVILEGES },
.{ "columns", odbc.SQL_ISV_COLUMNS },
.{ "constraint_column_usage", odbc.SQL_ISV_CONSTRAINT_COLUMN_USAGE },
.{ "constraint_table_usage", odbc.SQL_ISV_CONSTRAINT_TABLE_USAGE },
.{ "domain_constraints", odbc.SQL_ISV_DOMAIN_CONSTRAINTS },
.{ "domains", odbc.SQL_ISV_DOMAINS },
.{ "key_column_usage", odbc.SQL_ISV_KEY_COLUMN_USAGE },
.{ "referential_constraints", odbc.SQL_ISV_REFERENTIAL_CONSTRAINTS },
.{ "schemata", odbc.SQL_ISV_SCHEMATA },
.{ "sql_languages", odbc.SQL_ISV_SQL_LANGUAGES },
.{ "table_constraints", odbc.SQL_ISV_TABLE_CONSTRAINTS },
.{ "table_privileges", odbc.SQL_ISV_TABLE_PRIVILEGES },
.{ "tables", odbc.SQL_ISV_TABLES },
.{ "translations", odbc.SQL_ISV_TRANSLATIONS },
.{ "usage_privileges", odbc.SQL_ISV_USAGE_PRIVILEGES },
.{ "view_column_usage", odbc.SQL_ISV_VIEW_COLUMN_USAGE },
.{ "view_table_usage", odbc.SQL_ISV_VIEW_TABLE_USAGE },
.{ "views", odbc.SQL_ISV_VIEWS }
});
pub const InsertStatement = Bitmask(u32, .{
.{ "insert_literals", odbc.SQL_IS_INSERT_LITERALS },
.{ "insert_searched", odbc.SQL_IS_INSERT_SEARCHED },
.{ "select_into", odbc.SQL_IS_SELECT_INTO },
});
pub const NullCollation = enum(c_ushort) {
End = odbc.SQL_NC_END,
High = odbc.SQL_NC_HIGH,
Low = odbc.SQL_NC_LOW,
Start = odbc.SQL_NC_START
};
pub const NumericFunctions = Bitmask(u32, .{
.{ "abs", odbc.SQL_FN_NUM_ABS },
.{ "acos", odbc.SQL_FN_NUM_ACOS },
.{ "asin", odbc.SQL_FN_NUM_ASIN },
.{ "atan", odbc.SQL_FN_NUM_ATAN },
.{ "atan2", odbc.SQL_FN_NUM_ATAN2 },
.{ "ceiling", odbc.SQL_FN_NUM_CEILING },
.{ "cos", odbc.SQL_FN_NUM_COS },
.{ "cot", odbc.SQL_FN_NUM_COT },
.{ "degrees", odbc.SQL_FN_NUM_DEGREES },
.{ "exp", odbc.SQL_FN_NUM_EXP },
.{ "floor", odbc.SQL_FN_NUM_FLOOR },
.{ "log", odbc.SQL_FN_NUM_LOG },
.{ "log10", odbc.SQL_FN_NUM_LOG10 },
.{ "mod", odbc.SQL_FN_NUM_MOD },
.{ "pi", odbc.SQL_FN_NUM_PI },
.{ "power", odbc.SQL_FN_NUM_POWER },
.{ "radians", odbc.SQL_FN_NUM_RADIANS },
.{ "rand", odbc.SQL_FN_NUM_RAND },
.{ "round", odbc.SQL_FN_NUM_ROUND },
.{ "sign", odbc.SQL_FN_NUM_SIGN },
.{ "sin", odbc.SQL_FN_NUM_SIN },
.{ "sqrt", odbc.SQL_FN_NUM_SQRT },
.{ "tan", odbc.SQL_FN_NUM_TAN },
.{ "truncate", odbc.SQL_FN_NUM_TRUNCATE },
});
pub const InterfaceConformance = enum(u32) {
Core = odbc.SQL_OIC_CORE,
Level1 = odbc.SQL_OIC_LEVEL1,
Level2 = odbc.SQL_OIC_LEVEL2
};
pub const OJCapabilities = Bitmask(u32, .{
.{ "left", odbc.SQL_OJ_LEFT },
.{ "right", odbc.SQL_OJ_RIGHT },
.{ "full", odbc.SQL_OJ_FULL },
.{ "nested", odbc.SQL_OJ_NESTED },
.{ "not_ordered", odbc.SQL_OJ_NOT_ORDERED },
.{ "inner", odbc.SQL_OJ_INNER },
.{ "all_comparison_op", odbc.SQL_OJ_ALL_COMPARISON_OPS },
});
pub const ParamArraySelects = Bitmask(u32, .{
.{ "batch", odbc.SQL_PAS_BATCH },
.{ "no_batch", odbc.SQL_PAS_NO_BATCH },
.{ "no_select", odbc.SQL_PAS_NO_SELECT },
});
pub const PositionOperations = Bitmask(u32, .{
.{ "supported", odbc.SQL_POS_POSITION },
.{ "refresh", odbc.SQL_POS_REFRESH },
.{ "update", odbc.SQL_POS_UPDATE },
.{ "delete", odbc.SQL_POS_DELETE },
.{ "add", odbc.SQL_POS_ADD },
});
pub const QuotedIdentifierCase = enum(c_ushort) {
Upper = odbc.SQL_IC_UPPER,
Lower = odbc.SQL_IC_LOWER,
Sensitive = odbc.SQL_IC_SENSITIVE,
Mixed = odbc.SQL_IC_MIXED
};
pub const SchemaUsage = Bitmask(u32, .{
.{ "dml_statements", odbc.SQL_SU_DML_STATEMENTS },
.{ "procedure_invocation", odbc.SQL_SU_PROCEDURE_INVOCATION },
.{ "table_definition", odbc.SQL_SU_TABLE_DEFINITION },
.{ "index_definition", odbc.SQL_SU_INDEX_DEFINITION },
.{ "privilege_definition", odbc.SQL_SU_PRIVILEGE_DEFINITION },
});
pub const ScrollOptions = Bitmask(u32, .{
.{ "forward_only", odbc.SQL_SO_FORWARD_ONLY },
.{ "static", odbc.SQL_SO_STATIC },
.{ "keyset_driven", odbc.SQL_SO_KEYSET_DRIVEN },
.{ "dynamic", odbc.SQL_SO_DYNAMIC },
.{ "mixed", odbc.SQL_SO_MIXED },
});
pub const SQLConformance = enum(u32) {
SQL92Entry = odbc.SQL_SC_SQL92_ENTRY,
FIPS127_2 = odbc.SQL_SC_FIPS127_2_TRANSITIONAL,
SQL92Full = odbc.SQL_SC_SQL92_FULL,
SQL92Intermediate = odbc.SQL_SC_SQL92_INTERMEDIATE,
};
pub const DatetimeFunctions = Bitmask(u32, .{
.{ "current_date", odbc.SQL_SDF_CURRENT_DATE },
.{ "current_time", odbc.SQL_SDF_CURRENT_TIME },
.{ "current_timestamp", odbc.SQL_SDF_CURRENT_TIMESTAMP },
});
pub const OdbcStandardCliConformance = Bitmask(u32, .{
.{ "xopen_cli_version1", odbc.SQL_SCC_XOPEN_CLI_VERSION1 },
.{ "iso92_cli", odbc.SQL_SCC_ISO92_CLI },
});
pub const StringFunctions = Bitmask(u32, .{
.{ "ascii", odbc.SQL_FN_STR_ASCII },
.{ "bit_length", odbc.SQL_FN_STR_BIT_LENGTH },
.{ "char", odbc.SQL_FN_STR_CHAR },
.{ "char_length", odbc.SQL_FN_STR_CHAR_LENGTH },
.{ "character_length", odbc.SQL_FN_STR_CHARACTER_LENGTH },
.{ "concat", odbc.SQL_FN_STR_CONCAT },
.{ "difference", odbc.SQL_FN_STR_DIFFERENCE },
.{ "insert", odbc.SQL_FN_STR_INSERT },
.{ "lcase", odbc.SQL_FN_STR_LCASE },
.{ "left", odbc.SQL_FN_STR_LEFT },
.{ "length", odbc.SQL_FN_STR_LENGTH },
.{ "locate", odbc.SQL_FN_STR_LOCATE },
.{ "ltrim", odbc.SQL_FN_STR_LTRIM },
.{ "octet_length", odbc.SQL_FN_STR_OCTET_LENGTH },
.{ "position", odbc.SQL_FN_STR_POSITION },
.{ "repeat", odbc.SQL_FN_STR_REPEAT },
.{ "replace", odbc.SQL_FN_STR_REPLACE },
.{ "right", odbc.SQL_FN_STR_RIGHT },
.{ "rtrim", odbc.SQL_FN_STR_RTRIM },
.{ "soundex", odbc.SQL_FN_STR_SOUNDEX },
.{ "space", odbc.SQL_FN_STR_SPACE },
.{ "substring", odbc.SQL_FN_STR_SUBSTRING },
.{ "ucase", odbc.SQL_FN_STR_UCASE },
});
pub const Subqueries = Bitmask(u32, .{
.{ "correlated_subqueries", odbc.SQL_SQ_CORRELATED_SUBQUERIES },
.{ "comparison", odbc.SQL_SQ_COMPARISON },
.{ "exists", odbc.SQL_SQ_EXISTS },
});
pub const SystemFunctions = Bitmask(u32, .{
.{ "db_name", odbc.SQL_FN_SYS_DBNAME },
.{ "if_null", odbc.SQL_FN_SYS_IFNULL },
.{ "username", odbc.SQL_FN_SYS_USERNAME },
});
pub const TimedateIntervals = Bitmask(u32, .{
.{ "frac_second", odbc.SQL_FN_TSI_FRAC_SECOND },
.{ "second", odbc.SQL_FN_TSI_SECOND },
.{ "minute", odbc.SQL_FN_TSI_MINUTE },
.{ "hour", odbc.SQL_FN_TSI_HOUR },
.{ "day", odbc.SQL_FN_TSI_DAY },
.{ "week", odbc.SQL_FN_TSI_WEEK },
.{ "month", odbc.SQL_FN_TSI_MONTH },
.{ "quarter", odbc.SQL_FN_TSI_QUARTER },
.{ "year", odbc.SQL_FN_TSI_YEAR },
});
pub const TimedateFunctions = Bitmask(u32, .{
.{ "current_date", odbc.SQL_FN_TD_CURRENT_DATE },
.{ "current_time", odbc.SQL_FN_TD_CURRENT_TIME },
.{ "current_timestamp", odbc.SQL_FN_TD_CURRENT_TIMESTAMP },
.{ "curdate", odbc.SQL_FN_TD_CURDATE },
.{ "curtime", odbc.SQL_FN_TD_CURTIME },
.{ "day_name", odbc.SQL_FN_TD_DAYNAME },
.{ "day_of_month", odbc.SQL_FN_TD_DAYOFMONTH },
.{ "day_of_week", odbc.SQL_FN_TD_DAYOFWEEK },
.{ "day_of_year", odbc.SQL_FN_TD_DAYOFYEAR },
.{ "extract", odbc.SQL_FN_TD_EXTRACT },
.{ "hour", odbc.SQL_FN_TD_HOUR },
.{ "minute", odbc.SQL_FN_TD_MINUTE },
.{ "month", odbc.SQL_FN_TD_MONTH },
.{ "month_name", odbc.SQL_FN_TD_MONTHNAME },
.{ "now", odbc.SQL_FN_TD_NOW },
.{ "quarter", odbc.SQL_FN_TD_QUARTER },
.{ "second", odbc.SQL_FN_TD_SECOND },
.{ "timestamp_add", odbc.SQL_FN_TD_TIMESTAMPADD },
.{ "timestamp_diff", odbc.SQL_FN_TD_TIMESTAMPDIFF },
.{ "week", odbc.SQL_FN_TD_WEEK },
.{ "year", odbc.SQL_FN_TD_YEAR },
});
pub const TransactionCapable = Bitmask(u32, .{
.{ "none", odbc.SQL_TC_NONE },
.{ "dml", odbc.SQL_TC_DML },
.{ "ddl_commit", odbc.SQL_TC_DDL_COMMIT },
.{ "ddl_ignore", odbc.SQL_TC_DDL_IGNORE },
.{ "all", odbc.SQL_TC_ALL },
});
pub const TransactionIsolationOptions = Bitmask(u32, .{
.{ "read_uncommitted", odbc.SQL_TXN_READ_UNCOMMITTED },
.{ "read_committed", odbc.SQL_TXN_READ_COMMITTED },
.{ "repeatable_read", odbc.SQL_TXN_REPEATABLE_READ },
.{ "serializable", odbc.SQL_TXN_SERIALIZABLE },
});
pub const Union = Bitmask(u32, .{
.{ "union", odbc.SQL_U_UNION },
.{ "union_all", odbc.SQL_U_UNION_ALL },
});
};
pub const CType = enum(odbc.SQLSMALLINT) {
Char = odbc.SQL_C_CHAR,
WChar = odbc.SQL_C_WCHAR,
SShort = odbc.SQL_C_SSHORT,
UShort = odbc.SQL_C_USHORT,
SLong = odbc.SQL_C_SLONG,
ULong = odbc.SQL_C_ULONG,
Float = odbc.SQL_C_FLOAT,
Double = odbc.SQL_C_DOUBLE,
Bit = odbc.SQL_C_BIT,
STinyInt = odbc.SQL_C_STINYINT,
UTinyInt = odbc.SQL_C_UTINYINT,
SBigInt = odbc.SQL_C_SBIGINT,
UBigInt = odbc.SQL_C_UBIGINT, // @note: Use this for Bookmark values
Binary = odbc.SQL_C_BINARY, // @note: Use this for VarBookmark values
IntervalMonth = odbc.SQL_INTERVAL_MONTH,
IntervalYear = odbc.SQL_INTERVAL_YEAR,
IntervalYearToMonth = odbc.SQL_INTERVAL_YEAR_TO_MONTH,
IntervalDay = odbc.SQL_INTERVAL_DAY,
IntervalHour = odbc.SQL_INTERVAL_HOUR,
IntervalMinute = odbc.SQL_INTERVAL_MINUTE,
IntervalSecond = odbc.SQL_INTERVAL_SECOND,
IntervalDayToHour = odbc.SQL_INTERVAL_DAY_TO_HOUR,
IntervalDayToMinute = odbc.SQL_INTERVAL_DAY_TO_MINUTE,
IntervalDayToSecond = odbc.SQL_INTERVAL_DAY_TO_SECOND,
IntervalHourToMinute = odbc.SQL_INTERVAL_HOUR_TO_MINUTE,
IntervalHourToSecond = odbc.SQL_INTERVAL_HOUR_TO_SECOND,
IntervalMinuteToSecond = odbc.SQL_INTERVAL_MINUTE_TO_SECOND,
Date = odbc.SQL_C_TYPE_DATE,
Time = odbc.SQL_C_TYPE_TIME,
Timestamp = odbc.SQL_C_TYPE_TIMESTAMP,
Numeric = odbc.SQL_C_NUMERIC,
Guid = odbc.SQL_C_GUID,
pub const Interval = struct {
pub const IntervalType = enum(odbc.SQLSMALLINT) {
Year = 1,
Month = 2,
Day = 3,
Hour = 4,
Minute = 5,
Seconds = 6,
YearToMonth = 7,
DayToHour = 8,
DayToMinute = 9,
DayToSecond = 10,
HourToMinute = 11,
HourToSecond = 12,
MinuteToSecond = 13
};
pub const YearMonth = packed struct {
year: u32,
month: u32
};
pub const DaySecond = packed struct {
day: u32,
hour: u32,
minute: u32,
second: u32,
fraction: u32
};
interval_type: IntervalType,
// interval_sign: IntervalSign,
int_val: union(enum) {
year_month: YearMonth,
day_second: DaySecond
},
};
pub const SqlDate = packed struct {
year: odbc.SQLSMALLINT,
month: c_ushort,
day: c_ushort,
};
pub const SqlTime = packed struct {
hour: c_ushort,
minute: c_ushort,
second: c_ushort,
};
pub const SqlTimestamp = packed struct {
year: odbc.SQLSMALLINT,
month: c_ushort,
day: c_ushort,
hour: c_ushort,
minute: c_ushort,
second: c_ushort,
fraction: c_ushort,
};
pub const SqlNumeric = packed struct {
precision: odbc.SQLCHAR,
scale: odbc.SQLSCHAR,
sign: odbc.SQLCHAR,
val: [odbc.SQL_MAX_NUMERIC_LEN]odbc.SQLCHAR,
};
pub const SqlGuid = packed struct {
data_1: u32,
data_2: u16,
data_3: u16,
data_4: u8
};
pub fn toType(comptime odbc_type: CType) type {
return switch (odbc_type) {
.Char => u8,
.WChar => u16,
.SShort => c_short,
.UShort => c_ushort,
.SLong => c_long,
.ULong => c_ulong,
.Float => f32,
.Double => f64,
.Bit => u8,
.STinyInt => i8,
.UTinyInt => u8,
.SBigInt => i64,
.UBigInt => u64,
.Binary => u8,
.IntervalMonth, .IntervalYear, .IntervalYearToMonth, .IntervalDay,
.IntervalHour, .IntervalMinute, .IntervalSecond,
.IntervalDayToHour, .IntervalDayToMinute, .IntervalDayToSecond,
.IntervalHourToMinute, .IntervalHourToSecond, .IntervalMinuteToSecond => Interval,
.Date => SqlDate,
.Time => SqlTime,
.Timestamp => SqlTimestamp,
.Numeric => SqlNumeric,
.Guid => SqlGuid,
};
}
pub fn fromType(comptime T: type) ?CType {
if (std.meta.trait.isZigString(T)) return .Char;
switch (@typeInfo(T)) {
.Array => {
if (@typeInfo(T).Array.child == u8) return .Char;
if (@typeInfo(T).Array.child == u16) return .WChar;
},
else => {}
}
return switch (T) {
SqlDate => .Date,
SqlTime => .Time,
SqlTimestamp => .Timestamp,
SqlNumeric => .Numeric,
SqlGuid => .Guid,
c_short, i16 => .SShort,
c_ushort, u16 => .UShort,
c_long, i32 => .SLong,
c_ulong, u32 => .ULong,
f32 => .Float,
f64 => .Double,
i8 => .STinyInt,
u8 => .UTinyInt,
i64, c_longlong => .SBigInt,
u64, c_ulonglong => .UBigInt,
else => null
};
}
pub fn isSlice(c_type: CType) bool {
return switch (c_type) {
.Char, .WChar, .Binary, => true,
else => false
};
}
pub fn defaultSqlType(comptime c_type: CType) ?SqlType {
const zig_type = c_type.toType();
return SqlType.fromType(zig_type);
}
};
pub const SqlType = enum(odbc.SQLSMALLINT) {
Char = odbc.SQL_CHAR,
Varchar = odbc.SQL_VARCHAR,
LongVarchar = odbc.SQL_LONGVARCHAR,
WChar = odbc.SQL_WCHAR,
WVarchar = odbc.SQL_WVARCHAR,
WLongVarchar = odbc.SQL_WLONGVARCHAR,
Decimal = odbc.SQL_DECIMAL,
Numeric = odbc.SQL_NUMERIC,
SmallInt = odbc.SQL_SMALLINT,
Integer = odbc.SQL_INTEGER,
Real = odbc.SQL_REAL,
Float = odbc.SQL_FLOAT,
Double = odbc.SQL_DOUBLE,
Bit = odbc.SQL_BIT,
TinyInt = odbc.SQL_TINYINT,
BigInt = odbc.SQL_BIGINT,
Binary = odbc.SQL_BINARY,
VarBinary = odbc.SQL_VARBINARY,
LongVarBinary = odbc.SQL_LONGVARBINARY,
Date = odbc.SQL_TYPE_DATE,
Time = odbc.SQL_TYPE_TIME,
Timestamp = odbc.SQL_TYPE_TIMESTAMP,
// Snowflake - specific
TimestampLtz = 9,
IntervalMonth = odbc.SQL_INTERVAL_MONTH,
IntervalYear = odbc.SQL_INTERVAL_YEAR,
IntervalYearToMonth = odbc.SQL_INTERVAL_YEAR_TO_MONTH,
IntervalDay = odbc.SQL_INTERVAL_DAY,
IntervalHour = odbc.SQL_INTERVAL_HOUR,
IntervalMinute = odbc.SQL_INTERVAL_MINUTE,
IntervalSecond = odbc.SQL_INTERVAL_SECOND,
IntervalDayToHour = odbc.SQL_INTERVAL_DAY_TO_HOUR,
IntervalDayToMinute = odbc.SQL_INTERVAL_DAY_TO_MINUTE,
IntervalDayToSecond = odbc.SQL_INTERVAL_DAY_TO_SECOND,
IntervalHourToMinute = odbc.SQL_INTERVAL_HOUR_TO_MINUTE,
IntervalHourToSecond = odbc.SQL_INTERVAL_HOUR_TO_SECOND,
IntervalMinuteToSecond = odbc.SQL_INTERVAL_MINUTE_TO_SECOND,
Guid = odbc.SQL_GUID,
pub fn fromType(comptime T: type) ?SqlType {
if (std.meta.trait.isZigString(T)) return .Varchar;
return switch (T) {
u8 => .Char,
[]u8 => .Varchar,
u16 => .WChar,
[]u16 => .WVarchar,
i8 => .TinyInt,
i16 => .SmallInt,
i32, u32 => .Integer,
i64, u64 => .BigInt,
f32 => .Float,
f64 => .Double,
CType.SqlDate => .Date,
CType.SqlTime => .Time,
CType.SqlTimestamp => .Timestamp,
CType.SqlNumeric => .Numeric,
CType.SqlGuid => .Guid,
else => null
};
}
pub fn defaultCType(sql_type: SqlType) CType {
return switch (sql_type) {
.Char => .Char,
.Varchar => .Char,
.LongVarchar => .Char,
.WChar => .WChar,
.WVarchar => .WChar,
.WLongVarchar => .WChar,
.Decimal => .Float,
.Numeric => .Float,
.SmallInt => .STinyInt,
.Integer => .SLong,
.Real => .Double,
.Float => .Float,
.Double => .Double,
.Bit => .Bit,
.TinyInt => .STinyInt,
.BigInt => .SLong,
.Binary => .Bit,
.VarBinary => .Bit,
.LongVarBinary => .Bit,
.Date => .Date,
.Time => .Time,
.Timestamp, .TimestampLtz => .Timestamp,
.IntervalMonth => .IntervalMonth,
.IntervalYear => .IntervalYear,
.IntervalYearToMonth => .IntervalYearToMonth,
.IntervalDay => .IntervalDay,
.IntervalHour => .IntervalHour,
.IntervalMinute => .IntervalMinute,
.IntervalSecond => .IntervalSecond,
.IntervalDayToHour => .IntervalDayToHour,
.IntervalDayToMinute => .IntervalDayToMinute,
.IntervalDayToSecond => .IntervalDayToSecond,
.IntervalHourToMinute => .IntervalHourToMinute,
.IntervalHourToSecond => .IntervalHourToSecond,
.IntervalMinuteToSecond => .IntervalMinuteToSecond,
.Guid => .Guid,
};
}
};
pub const StatementAttribute = enum(i32) {
AppParamDescription = odbc.SQL_ATTR_APP_PARAM_DESC,
AppRowDescription = odbc.SQL_ATTR_APP_ROW_DESC,
EnableAsync = odbc.SQL_ATTR_ASYNC_ENABLE,
Concurrency = odbc.SQL_ATTR_CONCURRENCY,
CursorScrollable = odbc.SQL_ATTR_CURSOR_SCROLLABLE,
CursorSensitivity = odbc.SQL_ATTR_CURSOR_SENSITIVITY,
CursorType = odbc.SQL_ATTR_CURSOR_TYPE,
EnableAutoIpd = odbc.SQL_ATTR_ENABLE_AUTO_IPD,
FetchBookmarkPointer = odbc.SQL_ATTR_FETCH_BOOKMARK_PTR,
ImpParamDescription = odbc.SQL_ATTR_IMP_PARAM_DESC,
ImpRowDescription = odbc.SQL_ATTR_IMP_ROW_DESC,
KeysetSize = odbc.SQL_ATTR_KEYSET_SIZE,
MaxLength = odbc.SQL_ATTR_MAX_LENGTH,
MaxRows = odbc.SQL_ATTR_MAX_ROWS,
MetadataId = odbc.SQL_ATTR_METADATA_ID,
NoScan = odbc.SQL_ATTR_NOSCAN,
ParamBindOffsetPointer = odbc.SQL_ATTR_PARAM_BIND_OFFSET_PTR,
ParamBindType = odbc.SQL_ATTR_PARAM_BIND_TYPE,
ParamOperationPointer = odbc.SQL_ATTR_PARAM_OPERATION_PTR,
ParamStatusPointer = odbc.SQL_ATTR_PARAM_STATUS_PTR,
ParamsProcessedPointer = odbc.SQL_ATTR_PARAMS_PROCESSED_PTR,
ParamsetSize = odbc.SQL_ATTR_PARAMSET_SIZE,
QueryTimeout = odbc.SQL_ATTR_QUERY_TIMEOUT,
RetrieveData = odbc.SQL_ATTR_RETRIEVE_DATA,
RowArraySize = odbc.SQL_ATTR_ROW_ARRAY_SIZE,
RowBindOffsetPointer = odbc.SQL_ATTR_ROW_BIND_OFFSET_PTR,
RowBindType = odbc.SQL_ATTR_ROW_BIND_TYPE,
RowNumber = odbc.SQL_ATTR_ROW_NUMBER,
RowOperationPointer = odbc.SQL_ATTR_ROW_OPERATION_PTR,
RowStatusPointer = odbc.SQL_ATTR_ROW_STATUS_PTR,
RowsFetchedPointer = odbc.SQL_ATTR_ROWS_FETCHED_PTR,
SimulateCursor = odbc.SQL_ATTR_SIMULATE_CURSOR,
UseBookmarks = odbc.SQL_ATTR_USE_BOOKMARKS,
pub fn getValue(self: StatementAttribute, bytes: []u8) StatementAttributeValue {
const value = bytesToValue(usize, bytes[0..@sizeOf(usize)]);
return switch (self) {
.AppParamDescription => .{ .AppParamDescription = @intToPtr(*c_void, value) },
.AppRowDescription => .{ .AppRowDescription = @intToPtr(*c_void, value) },
.EnableAsync => .{ .EnableAsync = value == odbc.SQL_ASYNC_ENABLE_ON },
.Concurrency => .{ .Concurrency = @intToEnum(StatementAttributeValue.Concurrency, value) },
.CursorScrollable => .{ .CursorScrollable = value == odbc.SQL_SCROLLABLE },
.CursorSensitivity => .{ .CursorSensitivity = @intToEnum(StatementAttributeValue.CursorSensitivity, value) },
.CursorType => .{ .CursorType = @intToEnum(StatementAttributeValue.CursorType, value) },
.EnableAutoIpd => .{ .EnableAutoIpd = value == odbc.SQL_TRUE },
.FetchBookmarkPointer => .{ .FetchBookmarkPointer = @intToPtr(*isize, value) },
.ImpParamDescription => .{ .ImpParamDescription = @intToPtr(*c_void, value) },
.ImpRowDescription => .{ .ImpRowDescription = @intToPtr(*c_void, value) },
.KeysetSize => .{ .KeysetSize = value },
.MaxLength => .{ .MaxLength = value },
.MaxRows => .{ .MaxRows = value },
.MetadataId => .{ .MetadataId = value == odbc.SQL_TRUE },
.NoScan => .{ .NoScan = value == odbc.SQL_NOSCAN_ON },
.ParamBindOffsetPointer => .{ .ParamBindOffsetPointer = @intToPtr(?*c_void, value) },
.ParamBindType => .{ .ParamBindType = value },
.ParamOperationPointer => .{ .ParamOperationPointer = @alignCast(@alignOf(usize), std.mem.bytesAsSlice(StatementAttributeValue.ParamOperation, bytes)) },
.ParamStatusPointer => .{ .ParamStatusPointer = @alignCast(@alignOf(usize), std.mem.bytesAsSlice(StatementAttributeValue.ParamStatus, bytes)) },
.ParamsProcessedPointer => .{ .ParamsProcessedPointer = @intToPtr(*usize, value) },
.ParamsetSize => .{ .ParamsetSize = value },
.QueryTimeout => .{ .QueryTimeout = value },
.RetrieveData => .{ .RetrieveData = value == odbc.SQL_RD_ON },
.RowArraySize => .{ .RowArraySize = value },
.RowBindOffsetPointer => .{ .RowBindOffsetPointer = @intToPtr(*usize, value) },
.RowBindType => .{ .RowBindType = value },
.RowNumber => .{ .RowNumber = value },
.RowOperationPointer => .{ .RowOperationPointer = @alignCast(@alignOf(usize), std.mem.bytesAsSlice(StatementAttributeValue.RowOperation, bytes)) },
.RowStatusPointer => .{ .RowStatusPointer = @alignCast(@alignOf(usize), std.mem.bytesAsSlice(StatementAttributeValue.RowStatus, bytes)) },
.RowsFetchedPointer => .{ .RowsFetchedPointer = @intToPtr(*usize, value) },
.SimulateCursor => .{ .SimulateCursor = @intToEnum(StatementAttributeValue.SimulateCursor, value) },
.UseBookmarks => .{ .UseBookmarks = value == odbc.SQL_UB_VARIABLE },
};
}
};
pub const StatementAttributeValue = union(StatementAttribute) {
AppParamDescription: *c_void,
AppRowDescription: *c_void,
EnableAsync: bool,
Concurrency: Concurrency,
CursorScrollable: bool,
CursorSensitivity: CursorSensitivity,
CursorType: CursorType,
EnableAutoIpd: bool,
FetchBookmarkPointer: *isize,
ImpParamDescription: *c_void,
ImpRowDescription: *c_void,
KeysetSize: usize,
MaxLength: usize,
MaxRows: usize,
MetadataId: bool,
NoScan: bool,
ParamBindOffsetPointer: ?*c_void,
ParamBindType: usize,
ParamOperationPointer: []ParamOperation,
ParamStatusPointer: []ParamStatus,
ParamsProcessedPointer: *usize,
ParamsetSize: usize,
QueryTimeout: usize,
RetrieveData: bool,
RowArraySize: usize,
RowBindOffsetPointer: *usize,
RowBindType: usize,
RowNumber: usize,
RowOperationPointer: []RowOperation,
RowStatusPointer: []RowStatus,
RowsFetchedPointer: *usize,
SimulateCursor: SimulateCursor,
UseBookmarks: bool,
pub const Concurrency = enum(usize) {
ReadOnly = odbc.SQL_CONCUR_READ_ONLY,
Lock = odbc.SQL_CONCUR_LOCK,
RowVersion = odbc.SQL_CONCUR_ROWVER,
Values = odbc.SQL_CONCUR_VALUES,
};
pub const CursorSensitivity = enum(usize) {
Unspecified = odbc.SQL_UNSPECIFIED,
Insensitive = odbc.SQL_INSENSITIVE,
Sensitive = odbc.SQL_SENSITIVE,
};
pub const CursorType = enum(usize) {
ForwardOnly = odbc.SQL_CURSOR_FORWARD_ONLY,
Static = odbc.SQL_CURSOR_STATIC,
KeysetDriven = odbc.SQL_CURSOR_KEYSET_DRIVEN,
Dynamic = odbc.SQL_CURSOR_DYNAMIC,
};
pub const ParamOperation = enum(c_ushort) {
Proceed = odbc.SQL_PARAM_PROCEED,
Ignore = odbc.SQL_PARAM_IGNORE
};
pub const ParamStatus = enum(c_ushort) {
Success = odbc.SQL_PARAM_SUCCESS,
SuccessWithInfo = odbc.SQL_PARAM_SUCCESS_WITH_INFO,
Error = odbc.SQL_PARAM_ERROR,
Unused = odbc.SQL_PARAM_UNUSED,
DiagnosticUnavailable = odbc.SQL_PARAM_DIAG_UNAVAILABLE,
};
pub const RowOperation = enum(c_ushort) {
Proceed = odbc.SQL_ROW_PROCEED,
Ignore = odbc.SQL_ROW_IGNORE,
};
pub const RowStatus = enum(c_ushort) {
Success = odbc.SQL_ROW_SUCCESS,
SuccessWithInfo = odbc.SQL_ROW_SUCCESS_WITH_INFO,
Error = odbc.SQL_ROW_ERROR,
Updated = odbc.SQL_ROW_UPDATED,
Deleted = odbc.SQL_ROW_DELETED,
Added = odbc.SQL_ROW_ADDED,
NoRow = odbc.SQL_ROW_NOROW,
};
pub const SimulateCursor = enum(usize) {
NonUnique = odbc.SQL_SC_NON_UNIQUE,
TryUnique = odbc.SQL_SC_TRY_UNIQUE,
Unique = odbc.SQL_SC_UNIQUE,
};
pub fn valueAsBytes(attr_value: StatementAttributeValue, allocator: *std.mem.Allocator) ![]const u8 {
const bytes: []u8 = switch (attr_value) {
.AppParamDescription => |v| toBytes(@ptrToInt(v))[0..],
.AppRowDescription => |v| toBytes(@ptrToInt(v))[0..],
.EnableAsync => |v| blk: {
const value: usize = if (v) odbc.SQL_ASYNC_ENABLE_ON else odbc.SQL_ASYNC_ENABLE_OFF;
break :blk toBytes(value)[0..];
},
.Concurrency => |v| toBytes(@enumToInt(v))[0..],
.CursorScrollable => |v| blk: {
const value: usize = if (v) odbc.SQL_SCROLLABLE else odbc.SQL_NONSCROLLABLE;
break :blk toBytes(value)[0..];
},
.CursorSensitivity => |v| toBytes(@enumToInt(v))[0..],
.CursorType => |v| toBytes(@enumToInt(v))[0..],
.EnableAutoIpd => |v| blk: {
const value: usize = if (v) odbc.SQL_TRUE else odbc.SQL_FALSE;
break :blk toBytes(value)[0..];
},
.FetchBookmarkPointer => |v| toBytes(@ptrToInt(v))[0..],
.ImpParamDescription => |v| toBytes(@ptrToInt(v))[0..],
.ImpRowDescription => |v| toBytes(@ptrToInt(v))[0..],
.KeysetSize => |v| toBytes(v)[0..],
.MaxLength => |v| toBytes(v)[0..],
.MaxRows => |v| toBytes(v)[0..],
.MetadataId => |v| blk: {
const value: usize = if (v) odbc.SQL_TRUE else odbc.SQL_FALSE;
break :blk toBytes(value)[0..];
},
.NoScan => |v| blk: {
const value: usize = if (v) odbc.SQL_NOSCAN_ON else odbc.SQL_NOSCAN_OFF;
break :blk toBytes(value)[0..];
},
.ParamBindOffsetPointer => |v| toBytes(@ptrToInt(v))[0..],
.ParamBindType => |v| toBytes(v)[0..],
.ParamsProcessedPointer => |v| toBytes(@ptrToInt(v))[0..],
.ParamsetSize => |v| toBytes(v)[0..],
.QueryTimeout => |v| toBytes(v)[0..],
.RetrieveData => |v| blk: {
const value: usize = if (v) odbc.SQL_RD_ON else odbc.SQL_RD_OFF;
break :blk toBytes(value)[0..];
},
.RowArraySize => |v| toBytes(v)[0..],
.RowBindOffsetPointer => |v| toBytes(@ptrToInt(v))[0..],
.RowBindType => |v| toBytes(v)[0..],
.RowNumber => |v| toBytes(v)[0..],
.RowsFetchedPointer => |v| toBytes(@ptrToInt(v))[0..],
.SimulateCursor => |v| toBytes(@enumToInt(v))[0..],
.UseBookmarks => |v| blk: {
const value: usize = if (v) odbc.SQL_UB_VARIABLE else odbc.SQL_UB_OFF;
break :blk toBytes(value)[0..];
},
.ParamOperationPointer => |v| std.mem.sliceAsBytes(v)[0..],
.ParamStatusPointer => |v| std.mem.sliceAsBytes(v)[0..],
.RowOperationPointer => |v| std.mem.sliceAsBytes(v)[0..],
.RowStatusPointer => |v| std.mem.sliceAsBytes(v)[0..],
};
var result_buffer = try allocator.alloc(u8, bytes.len);
std.mem.copy(u8, result_buffer, bytes);
return result_buffer;
}
};
pub const InputOutputType = enum(odbc.SQLSMALLINT) {
Input = odbc.SQL_PARAM_INPUT,
InputOutput = odbc.SQL_PARAM_INPUT_OUTPUT,
Output = odbc.SQL_PARAM_OUTPUT,
};
pub const BulkOperation = enum(odbc.SQLUSMALLINT) {
Add = odbc.SQL_ADD,
UpdateByBookmark = odbc.SQL_UPDATE_BY_BOOKMARK,
DeleteByBookmark = odbc.SQL_DELETE_BY_BOOKMARK,
FetchByBookmark = odbc.SQL_FETCH_BY_BOOKMARK,
};
pub const ColumnAttribute = enum(odbc.SQLUSMALLINT) {
AutoUniqueValue = odbc.SQL_DESC_AUTO_UNIQUE_VALUE,
BaseColumnName = odbc.SQL_DESC_BASE_COLUMN_NAME,
BaseTableName = odbc.SQL_DESC_BASE_TABLE_NAME,
CaseSensitive = odbc.SQL_DESC_CASE_SENSITIVE,
CatalogName = odbc.SQL_DESC_CATALOG_NAME,
ConciseType = odbc.SQL_DESC_CONCISE_TYPE,
Count = odbc.SQL_DESC_COUNT,
DisplaySize = odbc.SQL_DESC_DISPLAY_SIZE,
FixedPrecisionScale = odbc.SQL_DESC_FIXED_PREC_SCALE,
Label = odbc.SQL_DESC_LABEL,
Length = odbc.SQL_DESC_LENGTH,
LiteralPrefix = odbc.SQL_DESC_LITERAL_PREFIX,
LiteralSuffix = odbc.SQL_DESC_LITERAL_SUFFIX,
LocalTypeName = odbc.SQL_DESC_LOCAL_TYPE_NAME,
Name = odbc.SQL_DESC_NAME,
Nullable = odbc.SQL_DESC_NULLABLE,
NumericPrecisionRadix = odbc.SQL_DESC_NUM_PREC_RADIX,
OctetLength = odbc.SQL_DESC_OCTET_LENGTH,
Precision = odbc.SQL_DESC_PRECISION,
Scale = odbc.SQL_DESC_SCALE,
SchemaName = odbc.SQL_DESC_SCHEMA_NAME,
Searchable = odbc.SQL_DESC_SEARCHABLE,
TableName = odbc.SQL_DESC_TABLE_NAME,
Type = odbc.SQL_DESC_TYPE,
TypeName = odbc.SQL_DESC_TYPE_NAME,
Unnamed = odbc.SQL_DESC_UNNAMED,
Unsigned = odbc.SQL_DESC_UNSIGNED,
Updatable = odbc.SQL_DESC_UPDATABLE,
};
pub const ColumnAttributeValue = union(ColumnAttribute) {
AutoUniqueValue: bool,
BaseColumnName: []const u8,
BaseTableName: []const u8,
CaseSensitive: bool,
CatalogName: []const u8,
ConciseType: SqlType,
Count: odbc.SQLLEN,
DisplaySize: odbc.SQLLEN,
FixedPrecisionScale: bool,
Label: []const u8,
Length: odbc.SQLLEN,
LiteralPrefix: []const u8,
LiteralSuffix: []const u8,
LocalTypeName: []const u8,
Name: []const u8,
Nullable: Nullable,
NumericPrecisionRadix: odbc.SQLLEN,
OctetLength: odbc.SQLLEN,
Precision: odbc.SQLLEN,
Scale: odbc.SQLLEN,
SchemaName: []const u8,
Searchable: Searchable,
TableName: []const u8,
Type: SqlType,
TypeName: []const u8,
Unnamed: bool,
Unsigned: bool,
Updatable: Updatable,
pub const Searchable = enum(odbc.SQLLEN) {
None = odbc.SQL_PRED_NONE,
Char = odbc.SQL_PRED_CHAR,
Basic = odbc.SQL_PRED_BASIC,
Searchable = odbc.SQL_PRED_SEARCHABLE,
};
pub const Updatable = enum(odbc.SQLLEN) {
ReadOnly = odbc.SQL_ATTR_READONLY,
Write = odbc.SQL_ATTR_WRITE,
Unknown = odbc.SQL_ATTR_READWRITE_UNKNOWN,
};
};
pub const ColumnDescriptor = struct {
name: [:0]const u8,
data_type: SqlType,
size: c_short,
decimal_digits: c_short,
nullable: Nullable,
};
pub const ParameterDescriptor = struct {
data_type: SqlType,
size: c_short,
decimal_digits: c_short,
nullable: Nullable,
};
pub const FetchOrientation = enum(odbc.SQLSMALLINT) {
Next = odbc.SQL_FETCH_NEXT,
Prior = odbc.SQL_FETCH_PRIOR,
First = odbc.SQL_FETCH_FIRST,
Last = odbc.SQL_FETCH_LAST,
Absolute = odbc.SQL_FETCH_ABSOLUTE,
Relative = odbc.SQL_FETCH_RELATIVE,
Bookmark = odbc.SQL_FETCH_BOOKMARK,
};
pub const CursorOperation = enum(odbc.SQLUSMALLINT) {
Position = odbc.SQL_POSITION,
Refresh = odbc.SQL_REFRESH,
Update = odbc.SQL_UPDATE,
Delete = odbc.SQL_DELETE,
};
pub const LockType = enum(odbc.SQLUSMALLINT) {
NoChange = odbc.SQL_LOCK_NO_CHANGE,
Exclusive = odbc.SQL_LOCK_EXCLUSIVE,
Unlock = odbc.SQL_LOCK_UNLOCK,
};
pub const ColumnIdentifierType = enum(odbc.SQLSMALLINT) {
BestRowID = odbc.SQL_BEST_ROWID,
RowVer = odbc.SQL_ROWVER,
};
pub const RowIdScope = enum(odbc.SQLSMALLINT) {
CurrentRow = odbc.SQL_SCOPE_CURROW,
Transaction = odbc.SQL_SCOPE_TRANSACTION,
Session = odbc.SQL_SCOPE_SESSION,
};
pub const Reserved = enum(odbc.SQLUSMALLINT) {
Ensure = odbc.SQL_ENSURE,
Quick = odbc.SQL_QUICK,
};
test "CType" {
const conforms = struct {
fn conforms(comptime base_type: type, comptime test_type: type) bool {
const BaseInfo = @typeInfo(base_type);
if (std.meta.activeTag(@typeInfo(test_type)) != .Struct) return false;
inline for (BaseInfo.Struct.fields) |field| {
if (!@hasField(test_type, field.name)) return false;
}
inline for (BaseInfo.Struct.decls) |decl| {
if (!@hasDecl(test_type, decl.name)) return false;
}
return true;
}
}.conforms;
std.testing.refAllDecls(CType);
const IntervalType = CType.toType(.IntervalHourToMinute);
try std.testing.expect(conforms(CType.Interval, IntervalType));
}
test "SqlType" {
std.testing.refAllDecls(SqlType);
}
test "SqlType to CType" {
const c_type = SqlType.Integer.defaultCType();
try std.testing.expect(c_type == CType.SLong);
const timestamp_type = SqlType.Timestamp.defaultCType();
try std.testing.expect(timestamp_type == CType.Timestamp);
} | src/types.zig |
const std = @import("std");
const Header = @import("Header.zig");
const Iterator = @import("iterator.zig").Iterator;
const DirectoryEntryMetadata = @import("DirectoryEntryMetadata.zig");
const PathComponents = @import("PathComponents.zig");
const File = @This();
path: []const u8,
file: std.fs.File,
header: Header,
pub fn open(path: []const u8) !File {
const file = try std.fs.cwd().openFile(path, .{});
const header = try Header.read(file.reader());
return File{
.path = path,
.file = file,
.header = header,
};
}
pub fn deinit(self: *File) void {
self.file.close();
}
pub const FileIterator = Iterator(std.fs.File.Reader);
pub fn iterate(self: *File) !FileIterator {
try self.file.seekTo(self.header.size());
return FileIterator.init(self.file.reader());
}
pub fn extractAll(self: *File, output: std.fs.Dir) !void {
var iterator = try self.iterate();
iterator.skip_preload_data = false;
// Directory entries are grouped by extension and then by
// path. This means that files with the same extension and path
// are in the directory tree in a linear sequence. We want to
// avoid opening and closing the output path for every file here,
// so we memorize it in case the next file is in the same output
// path. If not, close this directory and open a new one
var current_dir = output;
var current_path: ?[]const u8 = null;
defer if (current_path) |_| current_dir.close();
// The same goes for the external archives: Often, successive
// directory entries will be in the same external file
var current_archive_index: u16 = 0x7fff;
var current_external_archive_path: [1024]u8 = undefined;
var current_external_archive: std.fs.File = undefined;
defer if (current_archive_index != 0x7fff) current_external_archive.close();
while (try iterator.next()) |entry| {
const metadata = entry.metadata;
const path_components = entry.path_components;
// Open output path
var dir: std.fs.Dir = undefined;
if (path_components.path) |entry_path| {
if (current_path) |open_path| {
if (std.mem.eql(u8, entry_path, open_path)) {
// The same directory is already open
dir = current_dir;
} else {
// Another path is open, close that one and open
// the new path
current_dir.close();
dir = try output.makeOpenPath(entry_path, .{});
current_dir = dir;
}
} else {
// No path is currently open
dir = try output.makeOpenPath(entry_path, .{});
current_dir = dir;
}
current_path = entry_path;
} else {
dir = output;
}
// Open output file
var filename_buf: [1024]u8 = undefined;
var filename_buf_writer = std.io.fixedBufferStream(&filename_buf);
try path_components.joinIntoFilename(filename_buf_writer.writer());
const file = try dir.createFile(filename_buf_writer.getWritten(), .{});
defer file.close();
// Write file data
const buf_size = 4096;
var buf: [buf_size]u8 = undefined;
if (metadata.preload_bytes > 0) {
@panic("TODO write preload bytes");
}
if (metadata.archive_index == 0x7fff) {
// File contents are internally in this VPK file
const pos = try self.file.getPos();
try self.file.seekTo(self.header.size() + self.header.tree_size + metadata.offset);
var remaining = metadata.length;
while (remaining > 0) {
const amt = std.math.min(remaining, buf_size);
try self.file.reader().readNoEof(buf[0..amt]);
try file.writer().writeAll(buf[0..amt]);
remaining -= amt;
}
try self.file.seekTo(pos);
} else {
// File contents are externally in another VPK file
if (current_archive_index != metadata.archive_index) {
var external_path_writer = std.io.fixedBufferStream(¤t_external_archive_path);
try external_path_writer.writer().print("{s}{:0>3}.vpk", .{
self.path[0 .. self.path.len - "dir.vpk".len],
metadata.archive_index,
});
if (current_archive_index != 0x7fff) current_external_archive.close();
current_external_archive = try std.fs.cwd().openFile(external_path_writer.getWritten(), .{});
current_archive_index = metadata.archive_index;
}
try current_external_archive.seekTo(metadata.offset);
var remaining = metadata.length;
while (remaining > 0) {
const amt = std.math.min(remaining, buf_size);
try current_external_archive.reader().readNoEof(buf[0..amt]);
try file.writer().writeAll(buf[0..amt]);
remaining -= amt;
}
}
}
} | src/vpk/File.zig |
pub const VK_LBUTTON = 0x01;
pub const VK_RBUTTON = 0x02;
pub const VK_CANCEL = 0x03;
pub const VK_MBUTTON = 0x04;
pub const VK_XBUTTON1 = 0x05;
pub const VK_XBUTTON2 = 0x06;
pub const VK_BACK = 0x08;
pub const VK_TAB = 0x09;
pub const VK_CLEAR = 0x0C;
pub const VK_RETURN = 0x0D;
pub const VK_SHIFT = 0x10;
pub const VK_CONTROL = 0x11;
pub const VK_MENU = 0x12;
pub const VK_PAUSE = 0x13;
pub const VK_CAPITAL = 0x14;
pub const VK_KANA = 0x15;
pub const VK_HANGEUL = 0x15;
pub const VK_HANGUL = 0x15;
pub const VK_JUNJA = 0x17;
pub const VK_FINAL = 0x18;
pub const VK_HANJA = 0x19;
pub const VK_KANJI = 0x19;
pub const VK_ESCAPE = 0x1B;
pub const VK_CONVERT = 0x1C;
pub const VK_NONCONVERT = 0x1D;
pub const VK_ACCEPT = 0x1E;
pub const VK_MODECHANGE = 0x1F;
pub const VK_SPACE = 0x20;
pub const VK_PRIOR = 0x21;
pub const VK_NEXT = 0x22;
pub const VK_END = 0x23;
pub const VK_HOME = 0x24;
pub const VK_LEFT = 0x25;
pub const VK_UP = 0x26;
pub const VK_RIGHT = 0x27;
pub const VK_DOWN = 0x28;
pub const VK_SELECT = 0x29;
pub const VK_PRINT = 0x2A;
pub const VK_EXECUTE = 0x2B;
pub const VK_SNAPSHOT = 0x2C;
pub const VK_INSERT = 0x2D;
pub const VK_DELETE = 0x2E;
pub const VK_HELP = 0x2F;
pub const VK_LWIN = 0x5B;
pub const VK_RWIN = 0x5C;
pub const VK_APPS = 0x5D;
pub const VK_SLEEP = 0x5F;
pub const VK_NUMPAD0 = 0x60;
pub const VK_NUMPAD1 = 0x61;
pub const VK_NUMPAD2 = 0x62;
pub const VK_NUMPAD3 = 0x63;
pub const VK_NUMPAD4 = 0x64;
pub const VK_NUMPAD5 = 0x65;
pub const VK_NUMPAD6 = 0x66;
pub const VK_NUMPAD7 = 0x67;
pub const VK_NUMPAD8 = 0x68;
pub const VK_NUMPAD9 = 0x69;
pub const VK_MULTIPLY = 0x6A;
pub const VK_ADD = 0x6B;
pub const VK_SEPARATOR = 0x6C;
pub const VK_SUBTRACT = 0x6D;
pub const VK_DECIMAL = 0x6E;
pub const VK_DIVIDE = 0x6F;
pub const VK_F1 = 0x70;
pub const VK_F2 = 0x71;
pub const VK_F3 = 0x72;
pub const VK_F4 = 0x73;
pub const VK_F5 = 0x74;
pub const VK_F6 = 0x75;
pub const VK_F7 = 0x76;
pub const VK_F8 = 0x77;
pub const VK_F9 = 0x78;
pub const VK_F10 = 0x79;
pub const VK_F11 = 0x7A;
pub const VK_F12 = 0x7B;
pub const VK_F13 = 0x7C;
pub const VK_F14 = 0x7D;
pub const VK_F15 = 0x7E;
pub const VK_F16 = 0x7F;
pub const VK_F17 = 0x80;
pub const VK_F18 = 0x81;
pub const VK_F19 = 0x82;
pub const VK_F20 = 0x83;
pub const VK_F21 = 0x84;
pub const VK_F22 = 0x85;
pub const VK_F23 = 0x86;
pub const VK_F24 = 0x87;
pub const VK_NUMLOCK = 0x90;
pub const VK_SCROLL = 0x91;
pub const VK_OEM_NEC_EQUAL = 0x92;
pub const VK_OEM_FJ_JISHO = 0x92;
pub const VK_OEM_FJ_MASSHOU = 0x93;
pub const VK_OEM_FJ_TOUROKU = 0x94;
pub const VK_OEM_FJ_LOYA = 0x95;
pub const VK_OEM_FJ_ROYA = 0x96;
pub const VK_LSHIFT = 0xA0;
pub const VK_RSHIFT = 0xA1;
pub const VK_LCONTROL = 0xA2;
pub const VK_RCONTROL = 0xA3;
pub const VK_LMENU = 0xA4;
pub const VK_RMENU = 0xA5;
pub const VK_BROWSER_BACK = 0xA6;
pub const VK_BROWSER_FORWARD = 0xA7;
pub const VK_BROWSER_REFRESH = 0xA8;
pub const VK_BROWSER_STOP = 0xA9;
pub const VK_BROWSER_SEARCH = 0xAA;
pub const VK_BROWSER_FAVORITES = 0xAB;
pub const VK_BROWSER_HOME = 0xAC;
pub const VK_VOLUME_MUTE = 0xAD;
pub const VK_VOLUME_DOWN = 0xAE;
pub const VK_VOLUME_UP = 0xAF;
pub const VK_MEDIA_NEXT_TRACK = 0xB0;
pub const VK_MEDIA_PREV_TRACK = 0xB1;
pub const VK_MEDIA_STOP = 0xB2;
pub const VK_MEDIA_PLAY_PAUSE = 0xB3;
pub const VK_LAUNCH_MAIL = 0xB4;
pub const VK_LAUNCH_MEDIA_SELECT = 0xB5;
pub const VK_LAUNCH_APP1 = 0xB6;
pub const VK_LAUNCH_APP2 = 0xB7;
pub const VK_OEM_1 = 0xBA;
pub const VK_OEM_PLUS = 0xBB;
pub const VK_OEM_COMMA = 0xBC;
pub const VK_OEM_MINUS = 0xBD;
pub const VK_OEM_PERIOD = 0xBE;
pub const VK_OEM_2 = 0xBF;
pub const VK_OEM_3 = 0xC0;
pub const VK_OEM_4 = 0xDB;
pub const VK_OEM_5 = 0xDC;
pub const VK_OEM_6 = 0xDD;
pub const VK_OEM_7 = 0xDE;
pub const VK_OEM_8 = 0xDF;
pub const VK_OEM_AX = 0xE1;
pub const VK_OEM_102 = 0xE2;
pub const VK_ICO_HELP = 0xE3;
pub const VK_ICO_00 = 0xE4;
pub const VK_PROCESSKEY = 0xE5;
pub const VK_ICO_CLEAR = 0xE6;
pub const VK_PACKET = 0xE7;
pub const VK_OEM_RESET = 0xE9;
pub const VK_OEM_JUMP = 0xEA;
pub const VK_OEM_PA1 = 0xEB;
pub const VK_OEM_PA2 = 0xEC;
pub const VK_OEM_PA3 = 0xED;
pub const VK_OEM_WSCTRL = 0xEE;
pub const VK_OEM_CUSEL = 0xEF;
pub const VK_OEM_ATTN = 0xF0;
pub const VK_OEM_FINISH = 0xF1;
pub const VK_OEM_COPY = 0xF2;
pub const VK_OEM_AUTO = 0xF3;
pub const VK_OEM_ENLW = 0xF4;
pub const VK_OEM_BACKTAB = 0xF5;
pub const VK_ATTN = 0xF6;
pub const VK_CRSEL = 0xF7;
pub const VK_EXSEL = 0xF8;
pub const VK_EREOF = 0xF9;
pub const VK_PLAY = 0xFA;
pub const VK_ZOOM = 0xFB;
pub const VK_NONAME = 0xFC;
pub const VK_PA1 = 0xFD;
pub const VK_OEM_CLEAR = 0xFE; | src/vk_codes.zig |
//--------------------------------------------------------------------------------
// Section: Types (7)
//--------------------------------------------------------------------------------
const CLSID_WindowsMediaLibrarySharingServices_Value = @import("../zig.zig").Guid.initString("ad581b00-7b64-4e59-a38d-d2c5bf51ddb3");
pub const CLSID_WindowsMediaLibrarySharingServices = &CLSID_WindowsMediaLibrarySharingServices_Value;
pub const WindowsMediaLibrarySharingDeviceAuthorizationStatus = enum(i32) {
UNKNOWN = 0,
ALLOWED = 1,
DENIED = 2,
};
pub const DEVICE_AUTHORIZATION_UNKNOWN = WindowsMediaLibrarySharingDeviceAuthorizationStatus.UNKNOWN;
pub const DEVICE_AUTHORIZATION_ALLOWED = WindowsMediaLibrarySharingDeviceAuthorizationStatus.ALLOWED;
pub const DEVICE_AUTHORIZATION_DENIED = WindowsMediaLibrarySharingDeviceAuthorizationStatus.DENIED;
// TODO: this type is limited to platform 'windows6.1'
const IID_IWindowsMediaLibrarySharingDeviceProperty_Value = @import("../zig.zig").Guid.initString("81e26927-7a7d-40a7-81d4-bddc02960e3e");
pub const IID_IWindowsMediaLibrarySharingDeviceProperty = &IID_IWindowsMediaLibrarySharingDeviceProperty_Value;
pub const IWindowsMediaLibrarySharingDeviceProperty = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Name: fn(
self: *const IWindowsMediaLibrarySharingDeviceProperty,
name: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Value: fn(
self: *const IWindowsMediaLibrarySharingDeviceProperty,
value: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDeviceProperty_get_Name(self: *const T, name: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDeviceProperty.VTable, self.vtable).get_Name(@ptrCast(*const IWindowsMediaLibrarySharingDeviceProperty, self), name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDeviceProperty_get_Value(self: *const T, value: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDeviceProperty.VTable, self.vtable).get_Value(@ptrCast(*const IWindowsMediaLibrarySharingDeviceProperty, self), value);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IWindowsMediaLibrarySharingDeviceProperties_Value = @import("../zig.zig").Guid.initString("c4623214-6b06-40c5-a623-b2ff4c076bfd");
pub const IID_IWindowsMediaLibrarySharingDeviceProperties = &IID_IWindowsMediaLibrarySharingDeviceProperties_Value;
pub const IWindowsMediaLibrarySharingDeviceProperties = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Item: fn(
self: *const IWindowsMediaLibrarySharingDeviceProperties,
index: i32,
property: ?*?*IWindowsMediaLibrarySharingDeviceProperty,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const IWindowsMediaLibrarySharingDeviceProperties,
count: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetProperty: fn(
self: *const IWindowsMediaLibrarySharingDeviceProperties,
name: ?BSTR,
property: ?*?*IWindowsMediaLibrarySharingDeviceProperty,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDeviceProperties_get_Item(self: *const T, index: i32, property: ?*?*IWindowsMediaLibrarySharingDeviceProperty) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDeviceProperties.VTable, self.vtable).get_Item(@ptrCast(*const IWindowsMediaLibrarySharingDeviceProperties, self), index, property);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDeviceProperties_get_Count(self: *const T, count: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDeviceProperties.VTable, self.vtable).get_Count(@ptrCast(*const IWindowsMediaLibrarySharingDeviceProperties, self), count);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDeviceProperties_GetProperty(self: *const T, name: ?BSTR, property: ?*?*IWindowsMediaLibrarySharingDeviceProperty) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDeviceProperties.VTable, self.vtable).GetProperty(@ptrCast(*const IWindowsMediaLibrarySharingDeviceProperties, self), name, property);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IWindowsMediaLibrarySharingDevice_Value = @import("../zig.zig").Guid.initString("3dccc293-4fd9-4191-a25b-8e57c5d27bd4");
pub const IID_IWindowsMediaLibrarySharingDevice = &IID_IWindowsMediaLibrarySharingDevice_Value;
pub const IWindowsMediaLibrarySharingDevice = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_DeviceID: fn(
self: *const IWindowsMediaLibrarySharingDevice,
deviceID: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Authorization: fn(
self: *const IWindowsMediaLibrarySharingDevice,
authorization: ?*WindowsMediaLibrarySharingDeviceAuthorizationStatus,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Authorization: fn(
self: *const IWindowsMediaLibrarySharingDevice,
authorization: WindowsMediaLibrarySharingDeviceAuthorizationStatus,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Properties: fn(
self: *const IWindowsMediaLibrarySharingDevice,
deviceProperties: ?*?*IWindowsMediaLibrarySharingDeviceProperties,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDevice_get_DeviceID(self: *const T, deviceID: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDevice.VTable, self.vtable).get_DeviceID(@ptrCast(*const IWindowsMediaLibrarySharingDevice, self), deviceID);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDevice_get_Authorization(self: *const T, authorization: ?*WindowsMediaLibrarySharingDeviceAuthorizationStatus) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDevice.VTable, self.vtable).get_Authorization(@ptrCast(*const IWindowsMediaLibrarySharingDevice, self), authorization);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDevice_put_Authorization(self: *const T, authorization: WindowsMediaLibrarySharingDeviceAuthorizationStatus) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDevice.VTable, self.vtable).put_Authorization(@ptrCast(*const IWindowsMediaLibrarySharingDevice, self), authorization);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDevice_get_Properties(self: *const T, deviceProperties: ?*?*IWindowsMediaLibrarySharingDeviceProperties) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDevice.VTable, self.vtable).get_Properties(@ptrCast(*const IWindowsMediaLibrarySharingDevice, self), deviceProperties);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IWindowsMediaLibrarySharingDevices_Value = @import("../zig.zig").Guid.initString("1803f9d6-fe6d-4546-bf5b-992fe8ec12d1");
pub const IID_IWindowsMediaLibrarySharingDevices = &IID_IWindowsMediaLibrarySharingDevices_Value;
pub const IWindowsMediaLibrarySharingDevices = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Item: fn(
self: *const IWindowsMediaLibrarySharingDevices,
index: i32,
device: ?*?*IWindowsMediaLibrarySharingDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const IWindowsMediaLibrarySharingDevices,
count: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDevice: fn(
self: *const IWindowsMediaLibrarySharingDevices,
deviceID: ?BSTR,
device: ?*?*IWindowsMediaLibrarySharingDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDevices_get_Item(self: *const T, index: i32, device: ?*?*IWindowsMediaLibrarySharingDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDevices.VTable, self.vtable).get_Item(@ptrCast(*const IWindowsMediaLibrarySharingDevices, self), index, device);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDevices_get_Count(self: *const T, count: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDevices.VTable, self.vtable).get_Count(@ptrCast(*const IWindowsMediaLibrarySharingDevices, self), count);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingDevices_GetDevice(self: *const T, deviceID: ?BSTR, device: ?*?*IWindowsMediaLibrarySharingDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingDevices.VTable, self.vtable).GetDevice(@ptrCast(*const IWindowsMediaLibrarySharingDevices, self), deviceID, device);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IWindowsMediaLibrarySharingServices_Value = @import("../zig.zig").Guid.initString("01f5f85e-0a81-40da-a7c8-21ef3af8440c");
pub const IID_IWindowsMediaLibrarySharingServices = &IID_IWindowsMediaLibrarySharingServices_Value;
pub const IWindowsMediaLibrarySharingServices = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
showShareMediaCPL: fn(
self: *const IWindowsMediaLibrarySharingServices,
device: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_userHomeMediaSharingState: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingEnabled: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_userHomeMediaSharingState: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingEnabled: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_userHomeMediaSharingLibraryName: fn(
self: *const IWindowsMediaLibrarySharingServices,
libraryName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_userHomeMediaSharingLibraryName: fn(
self: *const IWindowsMediaLibrarySharingServices,
libraryName: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_computerHomeMediaSharingAllowedState: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingAllowed: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_computerHomeMediaSharingAllowedState: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingAllowed: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_userInternetMediaSharingState: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingEnabled: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_userInternetMediaSharingState: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingEnabled: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_computerInternetMediaSharingAllowedState: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingAllowed: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_computerInternetMediaSharingAllowedState: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingAllowed: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_internetMediaSharingSecurityGroup: fn(
self: *const IWindowsMediaLibrarySharingServices,
securityGroup: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_internetMediaSharingSecurityGroup: fn(
self: *const IWindowsMediaLibrarySharingServices,
securityGroup: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_allowSharingToAllDevices: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingEnabled: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_allowSharingToAllDevices: fn(
self: *const IWindowsMediaLibrarySharingServices,
sharingEnabled: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
setDefaultAuthorization: fn(
self: *const IWindowsMediaLibrarySharingServices,
MACAddresses: ?BSTR,
friendlyName: ?BSTR,
authorization: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
setAuthorizationState: fn(
self: *const IWindowsMediaLibrarySharingServices,
MACAddress: ?BSTR,
authorizationState: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
getAllDevices: fn(
self: *const IWindowsMediaLibrarySharingServices,
devices: ?*?*IWindowsMediaLibrarySharingDevices,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_customSettingsApplied: fn(
self: *const IWindowsMediaLibrarySharingServices,
customSettingsApplied: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_showShareMediaCPL(self: *const T, device: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).showShareMediaCPL(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), device);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_get_userHomeMediaSharingState(self: *const T, sharingEnabled: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).get_userHomeMediaSharingState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_put_userHomeMediaSharingState(self: *const T, sharingEnabled: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).put_userHomeMediaSharingState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_get_userHomeMediaSharingLibraryName(self: *const T, libraryName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).get_userHomeMediaSharingLibraryName(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), libraryName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_put_userHomeMediaSharingLibraryName(self: *const T, libraryName: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).put_userHomeMediaSharingLibraryName(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), libraryName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_get_computerHomeMediaSharingAllowedState(self: *const T, sharingAllowed: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).get_computerHomeMediaSharingAllowedState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingAllowed);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_put_computerHomeMediaSharingAllowedState(self: *const T, sharingAllowed: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).put_computerHomeMediaSharingAllowedState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingAllowed);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_get_userInternetMediaSharingState(self: *const T, sharingEnabled: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).get_userInternetMediaSharingState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_put_userInternetMediaSharingState(self: *const T, sharingEnabled: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).put_userInternetMediaSharingState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_get_computerInternetMediaSharingAllowedState(self: *const T, sharingAllowed: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).get_computerInternetMediaSharingAllowedState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingAllowed);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_put_computerInternetMediaSharingAllowedState(self: *const T, sharingAllowed: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).put_computerInternetMediaSharingAllowedState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingAllowed);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_get_internetMediaSharingSecurityGroup(self: *const T, securityGroup: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).get_internetMediaSharingSecurityGroup(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), securityGroup);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_put_internetMediaSharingSecurityGroup(self: *const T, securityGroup: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).put_internetMediaSharingSecurityGroup(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), securityGroup);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_get_allowSharingToAllDevices(self: *const T, sharingEnabled: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).get_allowSharingToAllDevices(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_put_allowSharingToAllDevices(self: *const T, sharingEnabled: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).put_allowSharingToAllDevices(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), sharingEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_setDefaultAuthorization(self: *const T, MACAddresses: ?BSTR, friendlyName: ?BSTR, authorization: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).setDefaultAuthorization(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), MACAddresses, friendlyName, authorization);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_setAuthorizationState(self: *const T, MACAddress: ?BSTR, authorizationState: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).setAuthorizationState(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), MACAddress, authorizationState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_getAllDevices(self: *const T, devices: ?*?*IWindowsMediaLibrarySharingDevices) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).getAllDevices(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), devices);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWindowsMediaLibrarySharingServices_get_customSettingsApplied(self: *const T, customSettingsApplied: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWindowsMediaLibrarySharingServices.VTable, self.vtable).get_customSettingsApplied(@ptrCast(*const IWindowsMediaLibrarySharingServices, self), customSettingsApplied);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (0)
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (4)
//--------------------------------------------------------------------------------
const BSTR = @import("../foundation.zig").BSTR;
const HRESULT = @import("../foundation.zig").HRESULT;
const IDispatch = @import("../system/com.zig").IDispatch;
const VARIANT = @import("../system/com.zig").VARIANT;
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/media/library_sharing_services.zig |
const std = @import("std");
const mem = std.mem;
const log = @import("log.zig");
const State = @import("ast.zig").State;
const Parser = @import("parse.zig").Parser;
const Node = @import("parse.zig").Node;
const Lexer = @import("lexer.zig").Lexer;
const TokenId = @import("token.zig").TokenId;
pub fn stateCodeBlock(p: *Parser) !void {
if (try p.lex.peekNext()) |tok| {
var openTok = p.lex.lastToken();
// log.Debugf("parse block code before openTok: '{}' id: {} len: {}, tok: '{}' id: {} len: {}\n", .{
// openTok.string, openTok.ID, openTok.string.len,
// tok.string, tok.ID, tok.string.len,
// });
var hazCodeBlockWhitespace: bool = false;
// var hazCodeBlockWhitespaceNextToken: bool = false;
if (openTok.ID == TokenId.Whitespace and openTok.string.len >= 1) {
if (mem.indexOf(u8, openTok.string, "\t") != null or openTok.string.len >= 4) {
hazCodeBlockWhitespace = true;
// } else if (try p.lex.peekNext()) |peekTok| {
// if (peekTok.ID == TokenId.Whitespace and peekTok.string.len >= 1) {
// if (mem.indexOf(u8, peekTok.string, "\t") != null or peekTok.string.len >= 4) {
// hazCodeBlockWhitespaceNextToken = true;
// }
// }
}
}
if (hazCodeBlockWhitespace and tok.ID == TokenId.Text) {
log.Debug("Found a code block!");
try p.lex.debugPrintToken("stateCodeBlock openTok", &openTok);
try p.lex.debugPrintToken("stateCodeBlock tok", &tok);
p.state = Parser.State.CodeBlock;
var newChild = Node{
.ID = Node.ID.CodeBlock,
.Value = openTok.string,
.PositionStart = Node.Position{
.Line = openTok.lineNumber,
.Column = openTok.column,
.Offset = openTok.startOffset,
},
.PositionEnd = undefined,
.Children = std.ArrayList(Node).init(p.allocator),
.Level = 0,
};
var buf = try std.ArrayListSentineled(u8, 0).init(p.allocator, tok.string);
defer buf.deinit();
// skip the whitespace after the codeblock opening
try p.lex.skipNext();
var startPos = Node.Position{
.Line = tok.lineNumber,
.Column = tok.column,
.Offset = tok.startOffset,
};
while (try p.lex.next()) |ntok| {
// if (ntok.ID == TokenId.Whitespace and mem.eql(u8, ntok.string, "\n")) {
if (ntok.ID == TokenId.Whitespace and ntok.column == 1) {
continue;
}
if (ntok.ID == TokenId.EOF) {
// FIXME: loop until de-indent
// FIXME: blanklines or eof should cause the state to exit
try p.lex.debugPrintToken("stateCodeBlock ntok", &ntok);
log.Debug("Found a newline, exiting state");
try buf.appendSlice(ntok.string);
try newChild.Children.append(Node{
.ID = Node.ID.Text,
.Value = buf.toOwnedSlice(),
.PositionStart = startPos,
.PositionEnd = Node.Position{
.Line = ntok.lineNumber,
.Column = ntok.column,
.Offset = ntok.endOffset - 1,
},
.Children = std.ArrayList(Node).init(p.allocator),
.Level = 0,
});
break;
}
try buf.appendSlice(ntok.string);
}
newChild.PositionEnd = newChild.Children.items[newChild.Children.items.len - 1].PositionEnd;
// p.lex.index = newChild.PositionEnd.Offset;
try p.root.append(newChild);
p.state = Parser.State.Start;
}
}
} | src/md/parse_codeblock.zig |
const std = @import("std");
const Sdk = @import("Sdk.zig");
pub fn build(b: *std.build.Builder) !void {
// Default-initialize SDK
const sdk = Sdk.init(b, null, .{});
const mode = b.standardReleaseOptions();
// Provide some KeyStore structure so we can sign our app.
// Recommendation: Don't hardcore your password here, everyone can read it.
// At least not for your production keystore ;)
const key_store = Sdk.KeyStore{
.file = "zig-cache/debug.keystore",
.alias = "default",
.password = "<PASSWORD>",
};
// This is a configuration for your application.
// Android requires several configurations to be done, this is a typical config
const config = Sdk.AppConfig{
// This is displayed to the user
.display_name = "Zig Android App Template",
// This is used internally for ... things?
.app_name = "zig-app-template",
// This is required for the APK name. This identifies your app, android will associate
// your signing key with this identifier and will prevent updates if the key changes.
.package_name = "net.random_projects.zig_android_template",
// This is a set of resources. It should at least contain a "mipmap/icon.png" resource that
// will provide the application icon.
.resources = &[_]Sdk.Resource{
.{ .path = "mipmap/icon.png", .content = .{ .path = "example/icon.png" } },
},
// This is a list of android permissions. Check out the documentation to figure out which you need.
.permissions = &[_][]const u8{
"android.permission.SET_RELEASE_APP",
//"android.permission.RECORD_AUDIO",
},
};
const app = sdk.createApp(
"app-template.apk",
"example/main.zig",
config,
mode,
.{
.aarch64 = b.option(bool, "aarch64", "Enable the aarch64 build") orelse true,
.arm = b.option(bool, "arm", "Enable the arm build") orelse false,
.x86_64 = b.option(bool, "x86_64", "Enable the x86_64 build") orelse true,
.x86 = b.option(bool, "x86", "Enable the x86 build") orelse false,
}, // default targets
key_store,
);
for (app.libraries) |exe| {
// Provide the "android" package in each executable we build
exe.addPackage(app.getAndroidPackage("android"));
}
// Make the app build when we invoke "zig build" or "zig build install"
b.getInstallStep().dependOn(app.final_step);
const keystore_step = b.step("keystore", "Initialize a fresh debug keystore");
const push_step = b.step("push", "Push the app to a connected android device");
const run_step = b.step("run", "Run the app on a connected android device");
keystore_step.dependOn(sdk.initKeystore(key_store, .{}));
push_step.dependOn(app.install());
run_step.dependOn(app.run());
} | build.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "XFree86-DRI", .global_id = 0 };
/// @brief DrmClipRect
pub const DrmClipRect = struct {
@"x1": i16,
@"y1": i16,
@"x2": i16,
@"x3": i16,
};
/// @brief QueryVersioncookie
pub const QueryVersioncookie = struct {
sequence: c_uint,
};
/// @brief QueryVersionRequest
pub const QueryVersionRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 0,
@"length": u16,
};
/// @brief QueryVersionReply
pub const QueryVersionReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"dri_major_version": u16,
@"dri_minor_version": u16,
@"dri_minor_patch": u32,
};
/// @brief QueryDirectRenderingCapablecookie
pub const QueryDirectRenderingCapablecookie = struct {
sequence: c_uint,
};
/// @brief QueryDirectRenderingCapableRequest
pub const QueryDirectRenderingCapableRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 1,
@"length": u16,
@"screen": u32,
};
/// @brief QueryDirectRenderingCapableReply
pub const QueryDirectRenderingCapableReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"is_capable": u8,
};
/// @brief OpenConnectioncookie
pub const OpenConnectioncookie = struct {
sequence: c_uint,
};
/// @brief OpenConnectionRequest
pub const OpenConnectionRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 2,
@"length": u16,
@"screen": u32,
};
/// @brief OpenConnectionReply
pub const OpenConnectionReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"sarea_handle_low": u32,
@"sarea_handle_high": u32,
@"bus_id_len": u32,
@"pad1": [12]u8,
@"bus_id": []u8,
};
/// @brief CloseConnectionRequest
pub const CloseConnectionRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 3,
@"length": u16,
@"screen": u32,
};
/// @brief GetClientDriverNamecookie
pub const GetClientDriverNamecookie = struct {
sequence: c_uint,
};
/// @brief GetClientDriverNameRequest
pub const GetClientDriverNameRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 4,
@"length": u16,
@"screen": u32,
};
/// @brief GetClientDriverNameReply
pub const GetClientDriverNameReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"client_driver_major_version": u32,
@"client_driver_minor_version": u32,
@"client_driver_patch_version": u32,
@"client_driver_name_len": u32,
@"pad1": [8]u8,
@"client_driver_name": []u8,
};
/// @brief CreateContextcookie
pub const CreateContextcookie = struct {
sequence: c_uint,
};
/// @brief CreateContextRequest
pub const CreateContextRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 5,
@"length": u16,
@"screen": u32,
@"visual": u32,
@"context": u32,
};
/// @brief CreateContextReply
pub const CreateContextReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"hw_context": u32,
};
/// @brief DestroyContextRequest
pub const DestroyContextRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 6,
@"length": u16,
@"screen": u32,
@"context": u32,
};
/// @brief CreateDrawablecookie
pub const CreateDrawablecookie = struct {
sequence: c_uint,
};
/// @brief CreateDrawableRequest
pub const CreateDrawableRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 7,
@"length": u16,
@"screen": u32,
@"drawable": u32,
};
/// @brief CreateDrawableReply
pub const CreateDrawableReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"hw_drawable_handle": u32,
};
/// @brief DestroyDrawableRequest
pub const DestroyDrawableRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 8,
@"length": u16,
@"screen": u32,
@"drawable": u32,
};
/// @brief GetDrawableInfocookie
pub const GetDrawableInfocookie = struct {
sequence: c_uint,
};
/// @brief GetDrawableInfoRequest
pub const GetDrawableInfoRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 9,
@"length": u16,
@"screen": u32,
@"drawable": u32,
};
/// @brief GetDrawableInfoReply
pub const GetDrawableInfoReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"drawable_table_index": u32,
@"drawable_table_stamp": u32,
@"drawable_origin_X": i16,
@"drawable_origin_Y": i16,
@"drawable_size_W": i16,
@"drawable_size_H": i16,
@"num_clip_rects": u32,
@"back_x": i16,
@"back_y": i16,
@"num_back_clip_rects": u32,
@"clip_rects": []xcb.xf86dri.DrmClipRect,
@"back_clip_rects": []xcb.xf86dri.DrmClipRect,
};
/// @brief GetDeviceInfocookie
pub const GetDeviceInfocookie = struct {
sequence: c_uint,
};
/// @brief GetDeviceInfoRequest
pub const GetDeviceInfoRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 10,
@"length": u16,
@"screen": u32,
};
/// @brief GetDeviceInfoReply
pub const GetDeviceInfoReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"framebuffer_handle_low": u32,
@"framebuffer_handle_high": u32,
@"framebuffer_origin_offset": u32,
@"framebuffer_size": u32,
@"framebuffer_stride": u32,
@"device_private_size": u32,
@"device_private": []u32,
};
/// @brief AuthConnectioncookie
pub const AuthConnectioncookie = struct {
sequence: c_uint,
};
/// @brief AuthConnectionRequest
pub const AuthConnectionRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 11,
@"length": u16,
@"screen": u32,
@"magic": u32,
};
/// @brief AuthConnectionReply
pub const AuthConnectionReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"authenticated": u32,
};
test "" {
@import("std").testing.refAllDecls(@This());
} | src/auto/xf86dri.zig |
const std = @import("std");
usingnamespace @import("ast.zig");
usingnamespace @import("common.zig");
usingnamespace @import("compiler.zig");
usingnamespace @import("job.zig");
usingnamespace @import("location.zig");
usingnamespace @import("native_function.zig");
usingnamespace @import("types.zig");
pub const SymbolKind = union(enum) {
NotSet,
Argument: struct {
decl: *const Ast,
typ: *const Type,
offset: usize,
},
Constant: struct {
decl: ?*const Ast = null,
typ: *const Type,
value: ?[]u8, // Null if not set yet.
},
GlobalVariable: struct {
decl: *const Ast,
typ: *const Type,
value: ?[]u8 = null,
},
NativeFunction: struct {
typ: *const Type,
wrapper: *NativeFunctionWrapper,
},
Type: struct {
typ: *const Type,
},
};
pub const Symbol = struct {
name: String,
kind: SymbolKind,
const Self = @This();
pub fn is(self: *const Self, tag: std.meta.Tag(SymbolKind)) bool {
return @as(std.meta.Tag(SymbolKind), self.kind) == tag;
}
};
pub const SymbolTable = struct {
allocator: *std.mem.Allocator,
parent: ?*SymbolTable,
symbols: std.StringHashMap(*Symbol),
const Self = @This();
pub fn init(parent: ?*Self, symbolAllocator: *std.mem.Allocator, mapAllocator: *std.mem.Allocator) Self {
return Self{
.allocator = symbolAllocator,
.parent = parent,
.symbols = std.StringHashMap(*Symbol).init(mapAllocator),
};
}
pub fn deinit(self: *Self) void {
self.symbols.deinit();
}
pub fn define(self: *Self, name: String) !?*Symbol {
if (self.symbols.contains(name)) {
return null;
}
var symbol = try self.allocator.create(Symbol);
symbol.* = Symbol{
.name = name,
.kind = .NotSet,
};
try self.symbols.put(name, symbol);
return symbol;
}
pub fn get(self: *Self, name: String, location: *Location) !?*Symbol {
if (self.parent == null) {
// Top level symbol table.
while (true) {
if (self.symbols.get(name)) |symbol| {
return symbol;
}
var condition = struct {
condition: FiberWaitCondition = .{
.evalFn = eval,
.reportErrorFn = reportError,
},
scope: *SymbolTable,
name: String,
location: *Location,
pub fn eval(condition: *FiberWaitCondition) bool {
const s = @fieldParentPtr(@This(), "condition", condition);
return s.scope.symbols.contains(s.name);
}
pub fn reportError(condition: *FiberWaitCondition, compiler: *Compiler) void {
const s = @fieldParentPtr(@This(), "condition", condition);
compiler.reportError(s.location, "Symbol not found: {s}", .{s.name});
}
}{
.scope = self,
.name = name,
.location = location,
};
var ctx = Coroutine.current().getUserData() orelse unreachable;
try ctx.waitUntil(&condition.condition);
}
}
if (self.symbols.get(name)) |symbol| {
return symbol;
}
if (self.parent) |p| {
return p.get(name, location);
}
return null;
}
pub fn format(
self: *const Self,
fmt: String,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
try std.fmt.format(writer, "scope", .{});
var it = self.symbols.iterator();
while (it.next()) |sym| {
try std.fmt.format(writer, "\n {s} -> {any}", .{ sym.key, sym.value });
}
}
}; | src/symbol.zig |
const std = @import("std");
const TokenType = @import("token.zig").TokenType;
const testing = std.testing;
const util = @import("util.zig");
const StackWidth = u128;
const StackElemWidth = u4; // TODO: we have an extra bit here so it's easier to debug - change this to u3 later?
const STACK_SHIFT = @bitSizeOf(StackElemWidth);
pub const MAX_STACK_SIZE = @bitSizeOf(StackWidth) / STACK_SHIFT; // add more stacks if we need more?
pub const State = enum {
ObjectBegin, // 0
ArrayBegin, // 1
MacroExprKey, // 2
MacroExprArgsBegin, // 3
MacroDeclParam, // 4
MacroExprBatchListBegin, // 5
MacroExprBatchArgsBegin, // 6
Value, // 7
Decl,
Key,
Equals,
ValueEnter,
ValueConcat,
ConsumeObjectEntry,
ObjectEnd,
ConsumeArrayItem,
ArrayEnd,
MacroDeclKey,
MacroDeclOptionalParams,
MacroDeclParamOptionalDefaultValue,
ConsumeMacroDeclParam,
ConsumeMacroDeclDefaultParam,
MacroDeclParamsEnd,
MacroExprOptionalArgsOrAccessors,
ConsumeMacroExprArgsOrBatchList,
MacroExprOptionalAccessors,
MacroExprAccessors,
MacroExprOptionalBatch,
ConsumeMacroExprBatchArgsList,
ConsumeMacroExprArg,
MacroExprArgsEnd,
ConsumeMacroExprBatchArgs,
MacroExprBatchListEnd,
};
pub const StateMachine = struct {
const Self = @This();
state: State = .Decl,
// NOTE: the following bit-stack setup is based on zig/lib/std/json.zig
stack: StackWidth = 0,
stack_size: u8 = 0,
pub fn push(self: *Self, state_: State) !void {
if (self.stack_size > MAX_STACK_SIZE) {
return error.TooManyStateStackPushes;
}
switch (state_) {
.ObjectBegin,
.ArrayBegin,
.MacroExprKey,
.MacroExprArgsBegin,
.MacroDeclParam,
.MacroExprBatchListBegin,
.MacroExprBatchArgsBegin,
.Value, => {},
else => return error.BadStatePush,
}
// update stack
self.stack <<= STACK_SHIFT;
self.stack |= @enumToInt(state_);
self.stack_size += 1;
// update state
self.state = @intToEnum(State, @enumToInt(state_));
}
pub fn pop(self: *Self) !void {
if (self.stack_size > 0) {
// update stack
self.stack >>= STACK_SHIFT;
self.stack_size -= 1;
// update state
if (self.top()) |state| {
// we always pop back to the corresponding consumption state
self.state = switch (state) {
.ObjectBegin => .ConsumeObjectEntry,
.ArrayBegin => .ConsumeArrayItem,
.MacroExprKey => .ConsumeMacroExprArgsOrBatchList,
.MacroExprArgsBegin => .ConsumeMacroExprArg,
.MacroDeclParam => .ConsumeMacroDeclDefaultParam,
.MacroExprBatchListBegin => .ConsumeMacroExprBatchArgsList,
.MacroExprBatchArgsBegin => .ConsumeMacroExprBatchArgs,
.Value => .ValueConcat,
else => return error.UnexpectedStateOnStack,
};
} else {
self.state = .Decl;
}
} else {
return error.TooManyStateStackPops;
}
}
pub fn top(self: Self) ?State {
if (self.stack_size == 0) {
return null;
}
return @intToEnum(State, self.stack & 0b1111);
}
pub fn log(self: Self, writer_: anytype) std.os.WriteError!void {
try writer_.print(
\\----[State Machine]----
\\State = {}
\\Stack = 0x{X:0>32}
\\Size = {}
\\
, .{ self.state, self.stack, self.stack_size }
);
}
/// Transition the state machine to the next state. This will catch all the
/// expected token type errors.
pub fn transition(self: *Self, token_: TokenType) !void {
if (util.DEBUG) {
std.debug.print("{} --({})--> ", .{self.state, token_});
}
// we can still transition even if the token type is .None
switch (self.state) {
.Decl => self.state = switch (token_) {
.MacroKey => .MacroDeclKey,
.String => .Key,
else => return error.UnexpectedDeclToken,
},
.Equals => switch (token_) {
.Equals => self.state = .ValueEnter,
else => return error.UnexpectedEqualsToken,
},
.ValueEnter => switch (token_) {
.CloseSquare => self.state = .ArrayEnd,
else => try self.push(.Value),
},
.Value => switch (token_) {
.String, .RawString, .MacroParamKey => self.state = .ValueConcat,
.MacroKey => try self.push(.MacroExprKey),
.OpenCurly => try self.push(.ObjectBegin),
.OpenSquare => try self.push(.ArrayBegin),
.Question => try self.pop(), // we forbid placeholder concatenation....TODO: do we really need to?
else => return error.UnexpectedValueToken,
},
.ValueConcat => switch (token_) {
.Plus, .RawString => self.state = .Value,
else => try self.pop(),
},
// Object
.ObjectBegin => self.state = switch (token_) {
.OpenCurly => .Key,
else => return error.UnexpectedObjectBeginToken,
},
.Key => self.state = switch (token_) {
.String => .Equals,
.CloseCurly => .ObjectEnd,
else => return error.UnexpectedKeyToken,
},
.ConsumeObjectEntry => self.state = .ObjectEnd,
.ObjectEnd => switch (token_) {
.String => self.state = .Key,
.CloseCurly => try self.pop(),
else => return error.UnexpectedObjectEndToken,
},
// Array
.ArrayBegin => switch (token_) {
.OpenSquare => self.state = .ValueEnter,
else => return error.UnexpectedArrayBeginToken,
},
.ConsumeArrayItem => self.state = .ArrayEnd,
.ArrayEnd => switch (token_) {
.CloseSquare => try self.pop(),
else => self.state = .ValueEnter,
},
// Macro Decl
.MacroDeclKey => self.state = switch (token_) {
.MacroKey => .MacroDeclOptionalParams,
else => return error.UnexpectedMacroDeclKeyToken,
},
.MacroDeclOptionalParams => switch (token_) {
.OpenParen => self.state = .MacroDeclParam,
.Equals => self.state = .ValueEnter,
else => return error.UnexpectedMacroDeclOptionalParamsToken,
},
.MacroDeclParam => switch (token_) {
.String => self.state = .MacroDeclParamOptionalDefaultValue,
.CloseParen => self.state = .MacroDeclParamsEnd,
else => return error.UnexpectedMacroDeclParamToken,
},
.MacroDeclParamOptionalDefaultValue => switch (token_) {
.Equals => {
try self.push(.MacroDeclParam);
self.state = .ValueEnter;
},
.String, .CloseParen => self.state = .ConsumeMacroDeclParam,
else => return error.UnexpectedMacroDeclParamOptionalDefaultValueToken,
},
.ConsumeMacroDeclParam => self.state = switch (token_) {
.String => .MacroDeclParam,
.CloseParen => .MacroDeclParamsEnd,
else => return error.UnexpectedConsumeMacroDeclParamToken,
},
.ConsumeMacroDeclDefaultParam => {
try self.pop();
self.state = switch (token_) {
.String => .MacroDeclParam,
.CloseParen => .MacroDeclParamsEnd,
else => return error.UnexpectedConsumeMacroDeclDefaultParamToken,
};
},
.MacroDeclParamsEnd => self.state = switch (token_) {
.CloseParen => .Equals,
else => return error.UnexpectedMacroDeclParamsEndToken,
},
// Macro Expr
.MacroExprKey => self.state = switch (token_) {
.MacroKey => .MacroExprOptionalArgsOrAccessors,
else => return error.UnexpectedMacroExprKeyToken,
},
.MacroExprOptionalArgsOrAccessors => switch (token_) {
.MacroAccessor => self.state = .MacroExprOptionalAccessors,
.OpenParen => try self.push(.MacroExprArgsBegin),
else => self.state = .MacroExprOptionalBatch,
},
.ConsumeMacroExprArgsOrBatchList => self.state = .MacroExprOptionalAccessors,
.MacroExprOptionalAccessors => self.state = switch (token_) {
.MacroAccessor => .MacroExprAccessors,
else => .MacroExprOptionalBatch,
},
.MacroExprAccessors => switch (token_) {
.MacroAccessor => {}, // stay here
else => self.state = .MacroExprOptionalBatch,
},
.MacroExprOptionalBatch => switch (token_) {
.Percent => try self.push(.MacroExprBatchListBegin),
else => try self.pop(),
},
.ConsumeMacroExprBatchArgsList => try self.pop(),
// Macro Expr Args
.MacroExprArgsBegin => switch (token_) {
.OpenParen => self.state = .ValueEnter,
else => return error.UnexpectedMacroExprArgsBeginToken,
},
.ConsumeMacroExprArg => self.state = .MacroExprArgsEnd,
.MacroExprArgsEnd => switch (token_) {
.CloseParen => try self.pop(),
else => self.state = .ValueEnter,
},
// Macro Expr Batch List (outter array)
.MacroExprBatchListBegin => switch (token_) {
.OpenSquare => try self.push(.MacroExprBatchArgsBegin),
else => return error.UnexpectedMacroExprBatchListBeginToken,
},
// Macro Expr Batch Args (inner arrays)
.MacroExprBatchArgsBegin => switch (token_) {
.OpenSquare => try self.push(.ArrayBegin),
else => return error.UnexpectedMacroExprBatchArgsBegin,
},
.ConsumeMacroExprBatchArgs => {
try self.pop();
self.state = .MacroExprBatchListEnd;
},
.MacroExprBatchListEnd => switch (token_) {
.CloseSquare => try self.pop(),
else => try self.push(.MacroExprBatchArgsBegin),
},
}
if (util.DEBUG) {
std.debug.print("{}\n", .{self.state});
}
}
};
test "general stack logic" {
var stack: u128 = 0;
var stack_size: u8 = 0;
const stack_size_limit: u8 = 64;
const shift = 2;
try testing.expectEqual(@as(u128, 0x0000_0000_0000_0000_0000_0000_0000_0000), stack);
// This loop should push 0, 1, 2, and 3 in sequence until the max stack size
// has been reached.
var t: u8 = 0;
while (stack_size < stack_size_limit) {
stack <<= shift;
stack |= t;
stack_size += 1;
t = (t + 1) % 4;
if (stack_size != stack_size_limit) {
try testing.expect(@as(u128, 0x1B1B_1B1B_1B1B_1B1B_1B1B_1B1B_1B1B_1B1B) != stack);
}
}
try testing.expectEqual(@as(u128, 0x1B1B_1B1B_1B1B_1B1B_1B1B_1B1B_1B1B_1B1B), stack);
while (stack_size > 0) {
t = if (t == 0) 3 else (t - 1);
try testing.expectEqual(@as(u128, t), (stack & 0b11));
stack >>= shift;
stack_size -= 1;
}
try testing.expectEqual(@as(u128, 0x0000_0000_0000_0000_0000_0000_0000_0000), stack);
} | src/state_machine.zig |
const std = @import("std");
const print = std.debug.print;
const Cell = struct {
value: i32,
marked: bool,
pub fn mark(self: *Cell) void {
self.marked = true;
}
};
const Winner = struct {
number: i32,
board: *Board
};
pub const Board = struct {
// Board is guaranteed to be 25 cells
board: [25]Cell,
pub fn setCell(self: *Board, x: usize, y: usize, value: i32) void {
self.board[y * 5 + x].value = value;
}
pub fn mark(self: *Board, value: i32) void {
for (self.board) |cell, i| {
if (cell.value == value) {
self.board[i].mark();
return;
}
}
}
pub fn getCell(self: *Board, x: usize, y: usize) *Cell {
return &self.board[y * 5 + x];
}
pub fn display(self: *Board) void {
var y: usize = 0;
while (y < 5) : (y += 1) {
var x: usize = 0;
while (x < 5): (x += 1) {
const cell = self.getCell(x, y);
if (cell.marked) {
print("\x1b[31m", .{});
}
if (cell.value < 10) {
print(" {d} ", .{cell.value});
} else {
print("{d} ", .{cell.value});
}
print("\x1b[0m", .{});
}
print("\n", .{});
}
}
pub fn fromReader(allocator: *std.mem.Allocator, reader: std.fs.File.Reader) !*Board {
var board = try allocator.create(Board);
var y: usize = 0;
while (y < 5) : (y += 1) {
// Lines are always 14 characters long
var buf: [15]u8 = undefined;
var line = try reader.readUntilDelimiter(&buf, '\n');
var x: usize = 0;
while (x < 5) : (x += 1) {
const offset = if (x == 0) 0 else x * 3;
const value = if (line[offset] == ' ') line[offset + 1..offset + 2] else line[offset..offset + 2];
var number = try std.fmt.parseInt(i32, value, 10);
board.setCell(x, y, number);
}
}
return board;
}
pub fn checkWin(self: *Board) bool {
// Check rows
var y: usize = 0;
while (y < 5) : (y += 1) {
// This was originally a loop but for some reason, that only God or Hades may know, it didn't work. I assume it was out of some form of torment.
if (self.getCell(0, y).marked and self.getCell(1, y).marked and self.getCell(2, y).marked and self.getCell(3, y).marked and self.getCell(4, y).marked) {
return true;
}
}
// Check columns
var x: usize = 0;
while (x < 5) : (x += 1) {
if (self.getCell(x, 0).marked and self.getCell(x, 1).marked and self.getCell(x, 2).marked and self.getCell(x, 3).marked and self.getCell(x, 4).marked) {
return true;
}
}
return false;
}
pub fn score(self: *Board, number: i32) i32 {
var sum: i32 = 0;
for (self.board) |cell| {
// This language is apparently broken somehow because doing if (!cell.marked) or if (cell.marked == false) straight up didn't work
if (cell.marked) {
continue;
}
sum += cell.value;
}
return sum * number;
}
};
pub fn run(boards: []*Board, numbers: []const i32) Winner {
for (numbers) |number| {
for (boards) |board| {
board.mark(number);
if (board.checkWin()) {
return Winner { .number = number, .board = board, };
}
}
}
unreachable;
}
pub fn findLastBoard(allocator: *std.mem.Allocator, boards: []*Board, numbers: []const i32) !Winner {
var board_list = std.ArrayList(*Board).fromOwnedSlice(allocator, boards);
var round_winners = std.ArrayList(usize).init(allocator);
defer round_winners.deinit();
for (numbers) |number| {
for (board_list.items) |board, i| {
board.mark(number);
if (board.checkWin()) {
if (board_list.items.len == 1) {
return Winner { .number = number, .board = board, };
}
try round_winners.append(i);
}
}
var i: usize = 0;
const winners = round_winners.items.len;
while (i < winners) : (i += 1) {
_ = board_list.orderedRemove(round_winners.pop());
}
}
unreachable;
} | Day4/src/game.zig |
const builtin = @import("builtin");
const std = @import("std");
const fs = std.fs;
const log = std.log;
const mem = std.mem;
const os = std.os;
const gzip = std.compress.gzip;
const MAGIC = "FOILZ";
const MAX_READ_SIZE = 1000000000;
pub fn pack_directory(path: []const u8, archive_path: []const u8) anyerror!void {
const stdout = std.io.getStdOut().writer();
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
const a = &arena.allocator;
// Open a file for the archive
_ = try fs.cwd().createFile(archive_path, .{ .truncate = true });
const arch_file = try fs.cwd().openFile(archive_path, .{ .write = true });
const foilz_writer = fs.File.writer(arch_file);
var dir = try fs.openDirAbsolute(path, .{ .iterate = true });
var walker = try dir.walk(a);
var count: u32 = 0;
try write_magic_number(&foilz_writer);
while (try walker.next()) |entry| {
if (entry.kind == .File) {
// Replace some path string data for the tar index name
// specifically replace: '../_build/prod/rel/' --> ''
// This just makes it easier to write the files out later on the destination machine
const needle = path;
const replacement = "";
const replacement_size = mem.replacementSize(u8, entry.path, needle, replacement);
var dest_buff: [fs.MAX_PATH_BYTES]u8 = undefined;
const index = dest_buff[0..replacement_size];
_ = mem.replace(u8, entry.path, needle, replacement, index);
// Read the entire contents of the file into a buffer
const file = try entry.dir.openFile(entry.basename, .{});
defer file.close();
// Allocate memory for the file
var file_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer file_arena.deinit();
var allocator = &file_arena.allocator;
// Read the file
const file_buffer = try file.readToEndAlloc(allocator, MAX_READ_SIZE);
const stat = try file.stat();
// Write file record to archive
try write_file_record(&foilz_writer, index, file_buffer, stat.mode);
count = count + 1;
try stdout.print("\rinfo: 🔍 Files Packed: {}", .{count});
}
}
// Log success
try stdout.print("\nArchived {} files into payload! 📥", .{count});
// Clean up memory
walker.deinit();
arena.deinit();
// Close the archive file
try write_magic_number(&foilz_writer);
arch_file.close();
}
pub fn write_magic_number(foilz_writer: *const fs.File.Writer) !void {
_ = try foilz_writer.write(MAGIC);
}
pub fn write_file_record(foilz_writer: *const fs.File.Writer, name: []const u8, data: []const u8, mode: u64) !void {
_ = try foilz_writer.writeInt(u64, name.len, .Little);
_ = try foilz_writer.write(name);
_ = try foilz_writer.writeInt(u64, data.len, .Little);
_ = try foilz_writer.write(data);
_ = try foilz_writer.writeInt(u64, mode, .Little);
}
pub fn validate_magic(first_bytes: []const u8) bool {
return mem.eql(u8, first_bytes, MAGIC);
}
pub fn unpack_files(data: []const u8, dest_path: []const u8) !void {
// Decompress the data in the payload
var decompress_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer decompress_arena.deinit();
var allocator = &decompress_arena.allocator;
var stream = std.io.fixedBufferStream(data);
var gzip_stream = try gzip.gzipStream(allocator, stream.reader());
defer gzip_stream.deinit();
// Raw payload data
const decompressed = try gzip_stream.reader().readAllAlloc(allocator, MAX_READ_SIZE);
// Validate the header of the payload
if (!validate_magic(decompressed[0..5])) {
return error.BadHeader;
}
// We start at position 5 to skip the header
var cursor: u64 = 5;
var file_count: u64 = 0;
//////
// Read until we reach the end of the trailer
// Look ahead 5 bytes and see
while (cursor < decompressed.len - 5) {
//////
// Read the file name
var string_len = std.mem.readIntSliceLittle(u64, decompressed[cursor .. cursor + @sizeOf(u64)]);
cursor = cursor + @sizeOf(u64);
var file_name = decompressed[cursor .. cursor + string_len];
cursor = cursor + string_len;
//////
// Read the file data from the payload
var file_len = std.mem.readIntSliceLittle(u64, decompressed[cursor .. cursor + @sizeOf(u64)]);
cursor = cursor + @sizeOf(u64);
var file_data = decompressed[cursor .. cursor + file_len];
cursor = cursor + file_len;
//////
// Read the mode for this file
var file_mode = std.mem.readIntSliceLittle(u64, decompressed[cursor .. cursor + @sizeOf(u64)]);
cursor = cursor + @sizeOf(u64);
//////
// Write the file
const full_file_path = try fs.path.join(allocator, &[_][]const u8{ dest_path[0..], file_name });
//////
// Create any directories needed
const dir_name = fs.path.dirname(file_name);
try create_dirs(dest_path[0..], dir_name.?, allocator);
log.debug("Unpacked File: {s}", .{full_file_path});
//////
// Write the file to disk!
// If we're on windows don't try and use file_mode because NTFS doesn't have that!
if (builtin.os.tag == .windows) {
const file = try fs.createFileAbsolute(full_file_path, .{ .truncate = true });
try file.writeAll(file_data);
file.close();
} else {
const file = try fs.createFileAbsolute(full_file_path, .{ .truncate = true, .mode = @intCast(os.mode_t, file_mode) });
try file.writeAll(file_data);
file.close();
}
file_count = file_count + 1;
}
log.debug("Unpacked {} files", .{file_count});
}
fn create_dirs(dest_path: []const u8, sub_dir_names: []const u8, allocator: *std.mem.Allocator) !void {
var iterator = mem.split(u8, sub_dir_names, "/");
var full_dir_path = try fs.path.join(allocator, &[_][]const u8{ dest_path, "" });
while (iterator.next()) |sub_dir| {
full_dir_path = try fs.path.join(allocator, &[_][]const u8{ full_dir_path, sub_dir });
os.mkdir(full_dir_path, 0o755) catch {};
}
} | src/archiver.zig |
const std = @import("std");
const builtin = @import("builtin");
const layers = @import("layers.zig");
const indented = @import("util.zig").rightAlign;
const getlogo = @import("logos.zig").getlogo;
const res = @import("resources.zig");
const mem = std.mem;
const fs = std.fs;
const os = std.os;
const stdout = std.io.getStdOut().writer();
const print = stdout.print;
const List = std.ArrayList;
const Args = res.Args;
const OsEnum = res.OsEnum;
fn parseArgs(allocator: *mem.Allocator) !Args {
const args = try std.process.argsAlloc(allocator);
defer std.process.argsFree(allocator, args);
var parsed = Args{
.colors = true,
.help = false,
.layer_names = true,
.logo = null,
};
for (args) |arg, i| {
const arg_word = std.mem.trim(u8, arg, "-");
//* Boolean options
// monochrome mode
if (mem.eql(u8, arg_word, "mono") or mem.eql(u8, arg_word, "m")) {
parsed.colors = false;
}
// display help message
if (mem.eql(u8, arg_word, "help") or mem.eql(u8, arg_word, "h")) {
parsed.help = true;
}
// disable layer names
if (mem.eql(u8, arg_word, "no-names") or mem.eql(u8, arg_word, "nn")) {
parsed.layer_names = false;
}
//* 1-arity options
// choose between OS logos
if (mem.eql(u8, arg_word, "logo") or mem.eql(u8, arg_word, "l")) {
if (args.len > i + 1) {
const os_id = try std.ascii.allocLowerString(allocator, args[i + 1]);
defer allocator.free(os_id);
parsed.logo = std.meta.stringToEnum(OsEnum, os_id) orelse OsEnum.generic;
}
}
}
return parsed;
}
fn help(colorset: res.Colors) !void {
const ansi = colorset;
try print(
\\{s}tuatara is a CLI system information tool written in Zig{s}
\\
\\{s}syntax:{s}
\\ tuatara {s}[options]{s}
\\{s}options:{s}
\\ {s}-h, --help{s} {s}prints this message{s}
\\ {s}-l, --logo{s} {s}sets distro logo to print{s}
\\ {s}-m, --mono{s} {s}enables monochrome mode{s}
\\ {s}-nn, --no-names{s} {s}disables layer names{s}
\\
,
.{
ansi.yy, ansi.x, ansi.z, ansi.x,
ansi.gg, ansi.x, ansi.z, ansi.x,
ansi.gg, ansi.x, ansi.yy, ansi.x,
ansi.gg, ansi.x, ansi.yy, ansi.x,
ansi.gg, ansi.x, ansi.yy, ansi.x,
ansi.gg, ansi.x, ansi.yy, ansi.x,
},
);
}
pub fn main() !void {
var GPA = std.heap.GeneralPurposeAllocator(.{}){};
const gpa = &GPA.allocator;
defer {
_ = GPA.deinit();
}
var ansi: res.Colors = res.ansi;
// argv
const args = try parseArgs(gpa);
if (!args.colors) {
ansi = res.mono;
}
if (args.help) {
try help(ansi);
return;
}
// layers list
var info = List([]const []const u8).init(gpa);
defer {
for (info.items) |item| {
for (item) |v| {
gpa.free(v);
}
}
info.deinit();
}
const layer_names = if (args.layer_names)
[7][]const u8{
" | [os]", " | [kernel]",
" | [arch]", " | [uptime]",
" | [shell]", " | [editor]",
" | [browser]",
}
else
[7][]const u8{
" |", " |",
" |", " |",
" |", " |",
" |",
};
// user@host layer
var home = mem.tokenize(u8, os.getenv("HOME").?, fs.path.sep_str);
var username: []const u8 = undefined;
while (true) {
username = home.next() orelse break;
}
var buf: [os.HOST_NAME_MAX]u8 = undefined;
const hostname = try os.gethostname(&buf);
// OS layer
const os_struct = layers.osname(gpa);
var logo: [8][]const u8 = undefined;
var motif: []const u8 = undefined;
defer for (logo) |line| {
gpa.free(line);
};
if (os_struct) |os_name| {
defer gpa.free(os_name.id);
defer gpa.free(os_name.name);
const os_name_upper = try std.ascii.allocUpperString(gpa, os_name.name);
try info.append(&[_][]const u8{
os_name_upper,
try gpa.dupe(u8, layer_names[0]),
});
var logo_struct: res.Logo = undefined;
if (args.logo == null) {
const os_id = try std.ascii.allocLowerString(gpa, os_name.id);
defer gpa.free(os_id);
logo_struct = try getlogo(gpa, os_id, ansi);
} else {
logo_struct = try getlogo(gpa, args.logo, ansi);
}
logo = logo_struct.logo;
motif = logo_struct.motif;
} else |_| {}
// kernel layer
if (layers.kernel(gpa)) |kernel_ver| {
defer gpa.free(kernel_ver);
const kernel_ver_upper = try std.ascii.allocUpperString(gpa, kernel_ver);
try info.append(&[_][]const u8{
kernel_ver_upper,
try gpa.dupe(u8, layer_names[1]),
});
} else |_| {}
// arch layer
const arch = std.meta.tagName(builtin.cpu.arch);
const arch_upper = try std.ascii.allocUpperString(gpa, arch);
try info.append(&[_][]const u8{
arch_upper,
try gpa.dupe(u8, layer_names[2]),
});
// uptime layer
if (layers.uptime(gpa)) |uptime| {
defer gpa.free(uptime);
const uptime_upper = try std.ascii.allocUpperString(gpa, uptime);
try info.append(&[_][]const u8{
uptime_upper,
try gpa.dupe(u8, layer_names[3]),
});
} else |_| {}
// shell layer
const shell_env = os.getenv("SHELL");
if (shell_env) |shell_exists| {
var shell = mem.tokenize(u8, shell_exists, fs.path.sep_str);
var shell_bin: []const u8 = undefined;
while (true) {
shell_bin = shell.next() orelse break;
}
const shell_upper = try std.ascii.allocUpperString(gpa, shell_bin);
try info.append(&[_][]const u8{
shell_upper,
try gpa.dupe(u8, layer_names[4]),
});
}
// editor layer
const editor_env = os.getenv("EDITOR");
if (editor_env) |editor_exists| {
var editor = mem.tokenize(u8, editor_exists, fs.path.sep_str);
var editor_bin: []const u8 = undefined;
while (true) {
editor_bin = editor.next() orelse break;
}
const editor_upper = try std.ascii.allocUpperString(gpa, editor_bin);
try info.append(&[_][]const u8{
editor_upper,
try gpa.dupe(u8, layer_names[5]),
});
}
// browser layer
const browser_env = os.getenv("BROWSER");
if (browser_env) |browser_exists| {
var browser = mem.tokenize(u8, browser_exists, fs.path.sep_str);
var browser_bin: []const u8 = undefined;
while (true) {
browser_bin = browser.next() orelse break;
}
const browser_upper = try std.ascii.allocUpperString(gpa, browser_bin);
try info.append(&[_][]const u8{
browser_upper,
try gpa.dupe(u8, layer_names[6]),
});
}
// getting length of the longest layer
var max_length: usize = 0;
for (info.items) |layer| {
var current_len = layer[0].len;
if (current_len > max_length) {
max_length = layer[0].len;
}
}
// try print out user@host
const user_indent = try indented(gpa, max_length - username.len + 1);
defer gpa.free(user_indent);
try print(" {s}", .{
logo[0],
});
try print("{s}{s}{s}{s}{s} @ {s}{s}{s}{s}\n", .{
user_indent, motif,
ansi.z, username,
ansi.x, motif,
ansi.z, hostname,
ansi.x,
});
// try print layers
for (logo[1..]) |logo_line, index| {
try print(" {s}", .{
logo_line,
});
if (index < (info.items.len)) {
const info_layer = info.items[index][0];
const layer_name = info.items[index][1];
const layer_indent = try indented(gpa, max_length - info_layer.len + 1);
defer gpa.free(layer_indent);
try print("{s}{s}", .{
layer_indent,
info_layer,
});
try print("{s}{s}{s}{s}\n", .{
motif, ansi.z,
layer_name, ansi.x,
});
} else {
try print("\n", .{});
}
}
} | src/main.zig |
const std = @import("std");
const c = @import("internal/c.zig");
const internal = @import("internal/internal.zig");
const log = std.log.scoped(.git);
const git = @import("git.zig");
pub const Repository = opaque {
pub fn deinit(self: *Repository) void {
log.debug("Repository.deinit called", .{});
c.git_repository_free(@ptrCast(*c.git_repository, self));
log.debug("repository closed successfully", .{});
}
pub fn state(self: *Repository) RepositoryState {
log.debug("Repository.state called", .{});
const ret = @intToEnum(RepositoryState, c.git_repository_state(@ptrCast(*c.git_repository, self)));
log.debug("repository state: {s}", .{@tagName(ret)});
return ret;
}
pub const RepositoryState = enum(c_int) {
none,
merge,
revert,
revert_sequence,
cherrypick,
cherrypick_sequence,
bisect,
rebase,
rebase_interactive,
rebase_merge,
apply_mailbox,
apply_mailbox_or_rebase,
};
/// Describe a commit
///
/// Perform the describe operation on the current commit and the worktree.
pub fn describe(self: *Repository, options: git.DescribeOptions) !*git.DescribeResult {
log.debug("Repository.describe called, options: {}", .{options});
var result: *git.DescribeResult = undefined;
var c_options = internal.make_c_option.describeOptions(options);
try internal.wrapCall("git_describe_workdir", .{
@ptrCast(*?*c.git_describe_result, &result),
@ptrCast(*c.git_repository, self),
&c_options,
});
log.debug("successfully described commitish object", .{});
return result;
}
/// Retrieve the configured identity to use for reflogs
pub fn identityGet(self: *const Repository) !Identity {
log.debug("Repository.identityGet called", .{});
var c_name: ?[*:0]u8 = undefined;
var c_email: ?[*:0]u8 = undefined;
try internal.wrapCall("git_repository_ident", .{ &c_name, &c_email, @ptrCast(*const c.git_repository, self) });
const name: ?[:0]const u8 = if (c_name) |ptr| std.mem.sliceTo(ptr, 0) else null;
const email: ?[:0]const u8 = if (c_email) |ptr| std.mem.sliceTo(ptr, 0) else null;
log.debug("identity acquired: name: {s}, email: {s}", .{ name, email });
return Identity{ .name = name, .email = email };
}
/// Set the identity to be used for writing reflogs
///
/// If both are set, this name and email will be used to write to the reflog.
/// Set to `null` to unset; When unset, the identity will be taken from the repository's configuration.
pub fn identitySet(self: *Repository, identity: Identity) !void {
log.debug("Repository.identitySet called, identity.name: {s}, identity.email: {s}", .{ identity.name, identity.email });
const name_temp = if (identity.name) |slice| slice.ptr else null;
const email_temp = if (identity.email) |slice| slice.ptr else null;
try internal.wrapCall("git_repository_set_ident", .{ @ptrCast(*c.git_repository, self), name_temp, email_temp });
log.debug("successfully set identity", .{});
}
pub const Identity = struct {
name: ?[:0]const u8,
email: ?[:0]const u8,
};
pub fn namespaceGet(self: *Repository) !?[:0]const u8 {
log.debug("Repository.namespaceGet called", .{});
const ret = c.git_repository_get_namespace(@ptrCast(*c.git_repository, self));
if (ret) |ptr| {
const slice = std.mem.sliceTo(ptr, 0);
log.debug("namespace: {s}", .{slice});
return slice;
}
log.debug("no namespace", .{});
return null;
}
/// Sets the active namespace for this Git Repository
///
/// This namespace affects all reference operations for the repo. See `man gitnamespaces`
///
/// ## Parameters
/// * `namespace` - The namespace. This should not include the refs folder, e.g. to namespace all references under
/// "refs/namespaces/foo/", use "foo" as the namespace.
pub fn namespaceSet(self: *Repository, namespace: [:0]const u8) !void {
log.debug("Repository.namespaceSet called, namespace: {s}", .{namespace});
try internal.wrapCall("git_repository_set_namespace", .{ @ptrCast(*c.git_repository, self), namespace.ptr });
log.debug("successfully set namespace", .{});
}
pub fn isHeadDetached(self: *Repository) !bool {
log.debug("Repository.isHeadDetached called", .{});
const ret = (try internal.wrapCallWithReturn("git_repository_head_detached", .{
@ptrCast(*c.git_repository, self),
})) == 1;
log.debug("is head detached: {}", .{ret});
return ret;
}
pub fn head(self: *Repository) !*git.Reference {
log.debug("Repository.head called", .{});
var ref: *git.Reference = undefined;
try internal.wrapCall("git_repository_head", .{
@ptrCast(*?*c.git_reference, &ref),
@ptrCast(*c.git_repository, self),
});
log.debug("reference opened successfully", .{});
return ref;
}
/// Make the repository HEAD point to the specified reference.
///
/// If the provided reference points to a Tree or a Blob, the HEAD is unaltered and an error is returned.
///
/// If the provided reference points to a branch, the HEAD will point to that branch, staying attached, or become attached if
/// it isn't yet. If the branch doesn't exist yet, the HEAD will be attached to an unborn branch.
///
/// Otherwise, the HEAD will be detached and will directly point to the commit.
///
/// ## Parameters
/// * `ref_name` - Canonical name of the reference the HEAD should point at
pub fn headSet(self: *Repository, ref_name: [:0]const u8) !void {
log.debug("Repository.headSet called, workdir: {s}", .{ref_name});
try internal.wrapCall("git_repository_set_head", .{ @ptrCast(*c.git_repository, self), ref_name.ptr });
log.debug("successfully set head", .{});
}
/// Make the repository HEAD directly point to a commit.
///
/// If the provided commit cannot be found in the repository `GitError.NotFound` is returned.
/// If the provided commit cannot be peeled into a commit, the HEAD is unaltered and an error is returned.
/// Otherwise, the HEAD will eventually be detached and will directly point to the peeled commit.
///
/// ## Parameters
/// * `commit` - Object id of the commit the HEAD should point to
pub fn headDetachedSet(self: *Repository, commit: git.Oid) !void {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try commit.formatHex(&buf);
log.debug("Repository.headDetachedSet called, commit: {s}", .{slice});
}
try internal.wrapCall("git_repository_set_head_detached", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, &commit),
});
log.debug("successfully set head", .{});
}
/// Make the repository HEAD directly point to the commit.
///
/// This behaves like `Repository.setHeadDetached` but takes an annotated commit, which lets you specify which
/// extended sha syntax string was specified by a user, allowing for more exact reflog messages.
///
/// See the documentation for `Repository.setHeadDetached`.
pub fn setHeadDetachedFromAnnotated(self: *Repository, commitish: *git.AnnotatedCommit) !void {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const oid = try commitish.commitId();
const slice = try oid.formatHex(&buf);
log.debug("Repository.setHeadDetachedFromAnnotated called, commitish: {s}", .{slice});
}
try internal.wrapCall("git_repository_set_head_detached_from_annotated", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_annotated_commit, commitish),
});
log.debug("successfully set head", .{});
}
/// Detach the HEAD.
///
/// If the HEAD is already detached and points to a Tag, the HEAD is updated into making it point to the peeled commit.
/// If the HEAD is already detached and points to a non commitish, the HEAD is unaltered, and an error is returned.
///
/// Otherwise, the HEAD will be detached and point to the peeled commit.
pub fn detachHead(self: *Repository) !void {
log.debug("Repository.detachHead called", .{});
try internal.wrapCall("git_repository_detach_head", .{@ptrCast(*c.git_repository, self)});
log.debug("successfully detached the head", .{});
}
pub fn isHeadForWorktreeDetached(self: *Repository, name: [:0]const u8) !bool {
log.debug("Repository.isHeadForWorktreeDetached called, name: {s}", .{name});
const ret = (try internal.wrapCallWithReturn(
"git_repository_head_detached_for_worktree",
.{ @ptrCast(*c.git_repository, self), name.ptr },
)) == 1;
log.debug("head for worktree {s} is detached: {}", .{ name, ret });
return ret;
}
pub fn headForWorktree(self: *Repository, name: [:0]const u8) !*git.Reference {
log.debug("Repository.headForWorktree called, name: {s}", .{name});
var ref: *git.Reference = undefined;
try internal.wrapCall("git_repository_head_for_worktree", .{
@ptrCast(*?*c.git_reference, &ref),
@ptrCast(*c.git_repository, self),
name.ptr,
});
log.debug("reference opened successfully", .{});
return ref;
}
pub fn isHeadUnborn(self: *Repository) !bool {
log.debug("Repository.isHeadUnborn called", .{});
const ret = (try internal.wrapCallWithReturn("git_repository_head_unborn", .{@ptrCast(*c.git_repository, self)})) == 1;
log.debug("is head unborn: {}", .{ret});
return ret;
}
pub fn isShallow(self: *Repository) bool {
log.debug("Repository.isShallow called", .{});
const ret = c.git_repository_is_shallow(@ptrCast(*c.git_repository, self)) == 1;
log.debug("is repository a shallow clone: {}", .{ret});
return ret;
}
pub fn isEmpty(self: *Repository) !bool {
log.debug("Repository.isEmpty called", .{});
const ret = (try internal.wrapCallWithReturn("git_repository_is_empty", .{@ptrCast(*c.git_repository, self)})) == 1;
log.debug("is repository empty: {}", .{ret});
return ret;
}
pub fn isBare(self: *const Repository) bool {
log.debug("Repository.isBare called", .{});
const ret = c.git_repository_is_bare(@ptrCast(*const c.git_repository, self)) == 1;
log.debug("is repository bare: {}", .{ret});
return ret;
}
pub fn isWorktree(self: *const Repository) bool {
log.debug("Repository.isWorktree called", .{});
const ret = c.git_repository_is_worktree(@ptrCast(*const c.git_repository, self)) == 1;
log.debug("is repository worktree: {}", .{ret});
return ret;
}
/// Get the location of a specific repository file or directory
pub fn itemPath(self: *const Repository, item: RepositoryItem) !git.Buf {
log.debug("Repository.itemPath called, item: {s}", .{item});
var buf: git.Buf = .{};
try internal.wrapCall("git_repository_item_path", .{
@ptrCast(*c.git_buf, &buf),
@ptrCast(*const c.git_repository, self),
@enumToInt(item),
});
log.debug("item path: {s}", .{buf.toSlice()});
return buf;
}
pub const RepositoryItem = enum(c_uint) {
gitdir,
workdir,
commondir,
index,
objects,
refs,
packed_refs,
remotes,
config,
info,
hooks,
logs,
modules,
worktrees,
};
pub fn pathGet(self: *const Repository) [:0]const u8 {
log.debug("Repository.pathGet called", .{});
const slice = std.mem.sliceTo(c.git_repository_path(@ptrCast(*const c.git_repository, self)), 0);
log.debug("path: {s}", .{slice});
return slice;
}
pub fn workdirGet(self: *const Repository) ?[:0]const u8 {
log.debug("Repository.workdirGet called", .{});
if (c.git_repository_workdir(@ptrCast(*const c.git_repository, self))) |ret| {
const slice = std.mem.sliceTo(ret, 0);
log.debug("workdir: {s}", .{slice});
return slice;
}
log.debug("no workdir", .{});
return null;
}
pub fn workdirSet(self: *Repository, workdir: [:0]const u8, update_gitlink: bool) !void {
log.debug("Repository.workdirSet called, workdir: {s}, update_gitlink: {}", .{ workdir, update_gitlink });
try internal.wrapCall("git_repository_set_workdir", .{
@ptrCast(*c.git_repository, self),
workdir.ptr,
@boolToInt(update_gitlink),
});
log.debug("successfully set workdir", .{});
}
pub fn commondir(self: *const Repository) ?[:0]const u8 {
log.debug("Repository.commondir called", .{});
if (c.git_repository_commondir(@ptrCast(*const c.git_repository, self))) |ret| {
const slice = std.mem.sliceTo(ret, 0);
log.debug("commondir: {s}", .{slice});
return slice;
}
log.debug("no commondir", .{});
return null;
}
/// Get the configuration file for this repository.
///
/// If a configuration file has not been set, the default config set for the repository will be returned, including any global
/// and system configurations.
pub fn configGet(self: *Repository) !*git.Config {
log.debug("Repository.configGet called", .{});
var config: *git.Config = undefined;
try internal.wrapCall("git_repository_config", .{
@ptrCast(*?*c.git_config, &config),
@ptrCast(*c.git_repository, self),
});
log.debug("repository config acquired successfully", .{});
return config;
}
/// Get a snapshot of the repository's configuration
///
/// The contents of this snapshot will not change, even if the underlying config files are modified.
pub fn configSnapshot(self: *Repository) !*git.Config {
log.debug("Repository.configSnapshot called", .{});
var config: *git.Config = undefined;
try internal.wrapCall("git_repository_config_snapshot", .{
@ptrCast(*?*c.git_config, &config),
@ptrCast(*c.git_repository, self),
});
log.debug("repository config acquired successfully", .{});
return config;
}
pub fn odbGet(self: *Repository) !*git.Odb {
log.debug("Repository.odbGet called", .{});
var odb: *git.Odb = undefined;
try internal.wrapCall("git_repository_odb", .{
@ptrCast(*?*c.git_odb, &odb),
@ptrCast(*c.git_repository, self),
});
log.debug("repository odb acquired successfully", .{});
return odb;
}
pub fn refDb(self: *Repository) !*git.Refdb {
log.debug("Repository.refDb called", .{});
var ref_db: *git.Refdb = undefined;
try internal.wrapCall("git_repository_refdb", .{
@ptrCast(*?*c.git_refdb, &ref_db),
@ptrCast(*c.git_repository, self),
});
log.debug("repository refdb acquired successfully", .{});
return ref_db;
}
pub fn indexGet(self: *Repository) !*git.Index {
log.debug("Repository.indexGet called", .{});
var index: *git.Index = undefined;
try internal.wrapCall("git_repository_index", .{
@ptrCast(*?*c.git_index, &index),
@ptrCast(*c.git_repository, self),
});
log.debug("repository index acquired successfully", .{});
return index;
}
/// Retrieve git's prepared message
///
/// Operations such as git revert/cherry-pick/merge with the -n option stop just short of creating a commit with the changes
/// and save their prepared message in .git/MERGE_MSG so the next git-commit execution can present it to the user for them to
/// amend if they wish.
///
/// Use this function to get the contents of this file. Don't forget to remove the file after you create the commit.
pub fn preparedMessage(self: *Repository) !git.Buf {
log.debug("Repository.preparedMessage called", .{});
var buf: git.Buf = .{};
try internal.wrapCall("git_repository_message", .{
@ptrCast(*c.git_buf, &buf),
@ptrCast(*c.git_repository, self),
});
log.debug("prepared message: {s}", .{buf.toSlice()});
return buf;
}
/// Remove git's prepared message file.
pub fn preparedMessageRemove(self: *Repository) !void {
log.debug("Repository.preparedMessageRemove called", .{});
try internal.wrapCall("git_repository_message_remove", .{@ptrCast(*c.git_repository, self)});
log.debug("successfully removed prepared message", .{});
}
/// Remove all the metadata associated with an ongoing command like merge, revert, cherry-pick, etc.
/// For example: MERGE_HEAD, MERGE_MSG, etc.
pub fn stateCleanup(self: *Repository) !void {
log.debug("Repository.stateCleanup called", .{});
try internal.wrapCall("git_repository_state_cleanup", .{@ptrCast(*c.git_repository, self)});
log.debug("successfully cleaned state", .{});
}
/// Invoke `callback_fn` for each entry in the given FETCH_HEAD file.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `ref_name` - The reference name
/// * `remote_url` - The remote URL
/// * `oid` - The reference OID
/// * `is_merge` - Was the reference the result of a merge
pub fn fetchHeadForeach(
self: *Repository,
comptime callback_fn: fn (
ref_name: [:0]const u8,
remote_url: [:0]const u8,
oid: *const git.Oid,
is_merge: bool,
) c_int,
) !c_int {
const cb = struct {
pub fn cb(
ref_name: [:0]const u8,
remote_url: [:0]const u8,
oid: *const git.Oid,
is_merge: bool,
_: *u8,
) c_int {
return callback_fn(ref_name, remote_url, oid, is_merge);
}
}.cb;
var dummy_data: u8 = undefined;
return self.fetchHeadForeachWithUserData(&dummy_data, cb);
}
/// Invoke `callback_fn` for each entry in the given FETCH_HEAD file.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `user_data` - Pointer to user data to be passed to the callback
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `ref_name` - The reference name
/// * `remote_url` - The remote URL
/// * `oid` - The reference OID
/// * `is_merge` - Was the reference the result of a merge
/// * `user_data_ptr` - Pointer to user data
pub fn fetchHeadForeachWithUserData(
self: *Repository,
user_data: anytype,
comptime callback_fn: fn (
ref_name: [:0]const u8,
remote_url: [:0]const u8,
oid: *const git.Oid,
is_merge: bool,
user_data_ptr: @TypeOf(user_data),
) c_int,
) !c_int {
const UserDataType = @TypeOf(user_data);
const cb = struct {
pub fn cb(
c_ref_name: ?[*:0]const u8,
c_remote_url: ?[*:0]const u8,
c_oid: ?*const c.git_oid,
c_is_merge: c_uint,
payload: ?*anyopaque,
) callconv(.C) c_int {
return callback_fn(
std.mem.sliceTo(c_ref_name.?, 0),
std.mem.sliceTo(c_remote_url.?, 0),
@ptrCast(*const git.Oid, c_oid),
c_is_merge == 1,
@ptrCast(UserDataType, payload),
);
}
}.cb;
log.debug("Repository.fetchHeadForeachWithUserData called", .{});
const ret = try internal.wrapCallWithReturn("git_repository_fetchhead_foreach", .{
@ptrCast(*c.git_repository, self),
cb,
user_data,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
/// If a merge is in progress, invoke 'callback' for each commit ID in the MERGE_HEAD file.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `oid` - The merge OID
pub fn mergeHeadForeach(
self: *Repository,
comptime callback_fn: fn (oid: *const git.Oid) c_int,
) !c_int {
const cb = struct {
pub fn cb(oid: *const git.Oid, _: *u8) c_int {
return callback_fn(oid);
}
}.cb;
var dummy_data: u8 = undefined;
return self.mergeHeadForeachWithUserData(&dummy_data, cb);
}
/// If a merge is in progress, invoke 'callback' for each commit ID in the MERGE_HEAD file.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `user_data` - Pointer to user data to be passed to the callback
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `oid` - The merge OID
/// * `user_data_ptr` - Pointer to user data
pub fn mergeHeadForeachWithUserData(
self: *Repository,
user_data: anytype,
comptime callback_fn: fn (
oid: *const git.Oid,
user_data_ptr: @TypeOf(user_data),
) c_int,
) !c_int {
const UserDataType = @TypeOf(user_data);
const cb = struct {
pub fn cb(c_oid: ?*const c.git_oid, payload: ?*anyopaque) callconv(.C) c_int {
return callback_fn(@ptrCast(*const git.Oid, c_oid), @ptrCast(UserDataType, payload));
}
}.cb;
log.debug("Repository.mergeHeadForeachWithUserData called", .{});
const ret = try internal.wrapCallWithReturn("git_repository_mergehead_foreach", .{
@ptrCast(*c.git_repository, self),
cb,
user_data,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
/// Calculate hash of file using repository filtering rules.
///
/// If you simply want to calculate the hash of a file on disk with no filters, you can just use `git.Odb.hashFile`.
/// However, if you want to hash a file in the repository and you want to apply filtering rules (e.g. crlf filters) before
/// generating the SHA, then use this function.
///
/// Note: if the repository has `core.safecrlf` set to fail and the filtering triggers that failure, then this function will
/// return an error and not calculate the hash of the file.
///
/// ## Parameters
/// * `path` - Path to file on disk whose contents should be hashed. This can be a relative path.
/// * `object_type` - The object type to hash as (e.g. `ObjectType.blob`)
/// * `as_path` - The path to use to look up filtering rules. If this is `null`, then the `path` parameter will be used
/// instead. If this is passed as the empty string, then no filters will be applied when calculating the hash.
pub fn hashFile(
self: *Repository,
path: [:0]const u8,
object_type: git.ObjectType,
as_path: ?[:0]const u8,
) !git.Oid {
log.debug("Repository.hashFile called, path: {s}, object_type: {}, as_path: {s}", .{ path, object_type, as_path });
var oid: git.Oid = undefined;
const as_path_temp = if (as_path) |slice| slice.ptr else null;
try internal.wrapCall("git_repository_hashfile", .{
@ptrCast(*c.git_oid, &oid),
@ptrCast(*c.git_repository, self),
path.ptr,
@enumToInt(object_type),
as_path_temp,
});
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("file hash acquired successfully, hash: {s}", .{slice});
}
return oid;
}
/// Get file status for a single file.
///
/// This tries to get status for the filename that you give. If no files match that name (in either the HEAD, index, or
/// working directory), this returns `GitError.NotFound`.
///
/// If the name matches multiple files (for example, if the `path` names a directory or if running on a case- insensitive
/// filesystem and yet the HEAD has two entries that both match the path), then this returns `GitError.Ambiguous`.
///
/// This does not do any sort of rename detection.
pub fn fileStatus(self: *Repository, path: [:0]const u8) !git.FileStatus {
log.debug("Repository.fileStatus called, path: {s}", .{path});
var flags: c_uint = undefined;
try internal.wrapCall("git_status_file", .{ &flags, @ptrCast(*c.git_repository, self), path.ptr });
const ret = @bitCast(git.FileStatus, flags);
log.debug("file status: {}", .{ret});
return ret;
}
/// Gather file statuses and run a callback for each one.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `path` - The file path
/// * `status` - The status of the file
pub fn fileStatusForeach(
self: *Repository,
comptime callback_fn: fn (path: [:0]const u8, status: git.FileStatus) c_int,
) !c_int {
const cb = struct {
pub fn cb(path: [:0]const u8, status: git.FileStatus, _: *u8) c_int {
return callback_fn(path, status);
}
}.cb;
var dummy_data: u8 = undefined;
return self.foreachFileStatusWithUserData(&dummy_data, cb);
}
/// Gather file statuses and run a callback for each one.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `user_data` - Pointer to user data to be passed to the callback
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `path` - The file path
/// * `status` - The status of the file
/// * `user_data_ptr` - Pointer to user data
pub fn fileStatusForeachWithUserData(
self: *Repository,
user_data: anytype,
comptime callback_fn: fn (
path: [:0]const u8,
status: git.FileStatus,
user_data_ptr: @TypeOf(user_data),
) c_int,
) !c_int {
const UserDataType = @TypeOf(user_data);
const ptr_info = @typeInfo(UserDataType);
comptime std.debug.assert(ptr_info == .Pointer); // Must be a pointer
const alignment = ptr_info.Pointer.alignment;
const cb = struct {
pub fn cb(path: ?[*:0]const u8, status: c_uint, payload: ?*anyopaque) callconv(.C) c_int {
return callback_fn(
std.mem.sliceTo(path.?, 0),
@bitCast(git.FileStatus, status),
@ptrCast(UserDataType, @alignCast(alignment, payload)),
);
}
}.cb;
log.debug("Repository.fileStatusForeachWithUserData called", .{});
const ret = try internal.wrapCallWithReturn("git_status_foreach", .{
@ptrCast(*c.git_repository, self),
cb,
user_data,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
/// Gather file status information and run callbacks as requested.
///
/// This is an extended version of the `foreachFileStatus` function that allows for more granular control over which paths
/// will be processed. See `FileStatusOptions` for details about the additional options that this makes available.
///
/// Note that if a `pathspec` is given in the `FileStatusOptions` to filter the status, then the results from rename
/// detection (if you enable it) may not be accurate. To do rename detection properly, this must be called with no `pathspec`
/// so that all files can be considered.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `options` - Callback options
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `path` - The file path
/// * `status` - The status of the file
pub fn fileStatusForeachExtended(
self: *Repository,
options: FileStatusOptions,
comptime callback_fn: fn (path: [:0]const u8, status: git.FileStatus) c_int,
) !c_int {
const cb = struct {
pub fn cb(path: [:0]const u8, status: git.FileStatus, _: *u8) c_int {
return callback_fn(path, status);
}
}.cb;
var dummy_data: u8 = undefined;
return self.foreachFileStatusExtendedWithUserData(options, &dummy_data, cb);
}
/// Gather file status information and run callbacks as requested.
///
/// This is an extended version of the `foreachFileStatus` function that allows for more granular control over which paths
/// will be processed. See `FileStatusOptions` for details about the additional options that this makes available.
///
/// Note that if a `pathspec` is given in the `FileStatusOptions` to filter the status, then the results from rename
/// detection (if you enable it) may not be accurate. To do rename detection properly, this must be called with no `pathspec`
/// so that all files can be considered.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `options` - Callback options
/// * `user_data` - Pointer to user data to be passed to the callback
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `path` - The file path
/// * `status` - The status of the file
/// * `user_data_ptr` - Pointer to user data
pub fn fileStatusForeachExtendedWithUserData(
self: *Repository,
options: FileStatusOptions,
user_data: anytype,
comptime callback_fn: fn (
path: [:0]const u8,
status: git.FileStatus,
user_data_ptr: @TypeOf(user_data),
) c_int,
) !c_int {
const UserDataType = @TypeOf(user_data);
const ptr_info = @typeInfo(UserDataType);
comptime std.debug.assert(ptr_info == .Pointer); // Must be a pointer
const alignment = ptr_info.Pointer.alignment;
const cb = struct {
pub fn cb(path: ?[*:0]const u8, status: c_uint, payload: ?*anyopaque) callconv(.C) c_int {
return callback_fn(
std.mem.sliceTo(path.?, 0),
@bitCast(git.FileStatus, status),
@ptrCast(UserDataType, @alignCast(alignment, payload)),
);
}
}.cb;
log.debug("Repository.fileStatusForeachExtendedWithUserData called, options: {}", .{options});
const c_options = internal.make_c_option.fileStatusOptions(options);
const ret = try internal.wrapCallWithReturn("git_status_foreach_ext", .{
@ptrCast(*c.git_repository, self),
&c_options,
cb,
user_data,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
/// Gather file status information and populate a `git.StatusList`.
///
/// Note that if a `pathspec` is given in the `FileStatusOptions` to filter the status, then the results from rename detection
/// (if you enable it) may not be accurate. To do rename detection properly, this must be called with no `pathspec` so that
/// all files can be considered.
///
/// ## Parameters
/// * `options` - Options regarding which files to get the status of
pub fn statusList(self: *Repository, options: FileStatusOptions) !*git.StatusList {
log.debug("Repository.statusList called, options: {}", .{options});
var status_list: *git.StatusList = undefined;
const c_options = internal.make_c_option.fileStatusOptions(options);
try internal.wrapCall("git_status_list_new", .{
@ptrCast(*?*c.git_status_list, &status_list),
@ptrCast(*c.git_repository, self),
&c_options,
});
log.debug("successfully fetched status list", .{});
return status_list;
}
/// Test if the ignore rules apply to a given file.
///
/// ## Parameters
/// * `path` - The file to check ignores for, rooted at the repo's workdir.
pub fn statusShouldIgnore(self: *Repository, path: [:0]const u8) !bool {
log.debug("Repository.statusShouldIgnore called, path: {s}", .{path});
var result: c_int = undefined;
try internal.wrapCall("git_status_should_ignore", .{ &result, @ptrCast(*c.git_repository, self), path.ptr });
const ret = result == 1;
log.debug("status should ignore: {}", .{ret});
return ret;
}
pub fn annotatedCommitCreateFromFetchHead(
self: *git.Repository,
branch_name: [:0]const u8,
remote_url: [:0]const u8,
id: git.Oid,
) !*git.AnnotatedCommit {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try id.formatHex(&buf);
log.debug(
"Repository.annotatedCommitCreateFromFetchHead called, branch_name: {s}, remote_url: {s}, id: {s}",
.{
branch_name,
remote_url,
slice,
},
);
}
var result: *git.AnnotatedCommit = undefined;
try internal.wrapCall("git_annotated_commit_from_fetchhead", .{
@ptrCast(*?*c.git_annotated_commit, &result),
@ptrCast(*c.git_repository, self),
branch_name.ptr,
remote_url.ptr,
@ptrCast(*const c.git_oid, &id),
});
log.debug("successfully created annotated commit", .{});
return result;
}
pub fn annotatedCommitCreateFromLookup(self: *Repository, id: git.Oid) !*git.AnnotatedCommit {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try id.formatHex(&buf);
log.debug("Repository.annotatedCommitCreateFromLookup called, id: {s}", .{slice});
}
var result: *git.AnnotatedCommit = undefined;
try internal.wrapCall("git_annotated_commit_lookup", .{
@ptrCast(*?*c.git_annotated_commit, &result),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, &id),
});
log.debug("successfully created annotated commit", .{});
return result;
}
pub fn annotatedCommitCreateFromRevisionString(self: *Repository, revspec: [:0]const u8) !*git.AnnotatedCommit {
log.debug("Repository.annotatedCommitCreateFromRevisionString called, revspec: {s}", .{revspec});
var result: *git.AnnotatedCommit = undefined;
try internal.wrapCall("git_annotated_commit_from_revspec", .{
@ptrCast(*?*c.git_annotated_commit, &result),
@ptrCast(*c.git_repository, self),
revspec.ptr,
});
log.debug("successfully created annotated commit", .{});
return result;
}
/// Apply a `Diff` to the given repository, making changes directly in the working directory, the index, or both.
///
/// ## Parameters
/// * `diff` - The diff to apply
/// * `location` - The location to apply (workdir, index or both)
/// * `options` - The options for the apply (or null for defaults)
pub fn applyDiff(
self: *Repository,
diff: *git.Diff,
location: git.ApplyLocation,
options: git.ApplyOptions,
) !void {
log.debug("Repository.applyDiff called, diff: {*}, location: {}, options: {}", .{ diff, location, options });
const c_options = internal.make_c_option.applyOptions(options);
try internal.wrapCall("git_apply", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_diff, diff),
@enumToInt(location),
&c_options,
});
log.debug("apply completed", .{});
}
/// Apply a `Diff` to the given repository, making changes directly in the working directory, the index, or both.
///
/// ## Parameters
/// * `diff` - The diff to apply
/// * `location` - The location to apply (workdir, index or both)
/// * `user_data` - User data to be passed to callbacks
/// * `options` - The options for the apply (or null for defaults)
pub fn applyDiffWithUserData(
comptime T: type,
self: *Repository,
diff: *git.Diff,
location: git.ApplyLocation,
options: git.ApplyOptionsWithUserData(T),
) !void {
log.debug("Repository.applyDiffWithUserData(" ++ @typeName(T) ++ ") called, diff: {*}, location: {}, options: {}", .{ diff, location, options });
const c_options = internal.make_c_option.applyOptionsWithUserData(T, options);
try internal.wrapCall("git_apply", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_diff, self),
@bitCast(c_int, location),
&c_options,
});
log.debug("apply completed", .{});
}
/// Apply a `Diff` to a `Tree`, and return the resulting image as an index.
///
/// ## Parameters
/// * `diff` - The diff to apply`
/// * `preimage` - The tree to apply the diff to
/// * `options` - The options for the apply (or null for defaults)
pub fn applyDiffToTree(
self: *Repository,
diff: *git.Diff,
preimage: *git.Tree,
options: git.ApplyOptions,
) !*git.Index {
log.debug(
"Repository.applyDiffToTree called, diff: {*}, preimage: {*}, options: {}",
.{ diff, preimage, options },
);
var ret: *git.Index = undefined;
const c_options = internal.make_c_option.applyOptions(options);
try internal.wrapCall("git_apply_to_tree", .{
@ptrCast(*?*c.git_index, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_tree, preimage),
@ptrCast(*c.git_diff, diff),
&c_options,
});
log.debug("apply completed, index: {*}", .{ret});
return ret;
}
/// Apply a `Diff` to a `Tree`, and return the resulting image as an index.
///
/// ## Parameters
/// * `diff` - The diff to apply`
/// * `preimage` - The tree to apply the diff to
/// * `options` - The options for the apply (or null for defaults)
pub fn applyDiffToTreeWithUserData(
comptime T: type,
self: *Repository,
diff: *git.Diff,
preimage: *git.Tree,
options: git.ApplyOptionsWithUserData(T),
) !*git.Index {
log.debug(
"Repository.applyDiffToTreeWithUserData(" ++ @typeName(T) ++ ") called, diff: {*}, preimage: {*}, options: {}",
.{ diff, preimage, options },
);
var ret: *git.Index = undefined;
const c_options = internal.make_c_option.applyOptionsWithUserData(T, options);
try internal.wrapCall("git_apply_to_tree", .{
@ptrCast(*?*c.git_index, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_tree, preimage),
@ptrCast(*c.git_diff, diff),
&c_options,
});
log.debug("apply completed, index: {*}", .{ret});
return ret;
}
/// Look up the value of one git attribute for path.
///
/// ## Parameters
/// * `flags` - Options for fetching attributes
/// * `path` - The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not
/// have to exist, but if it does not, then it will be treated as a plain file (not a directory).
/// * `name` - The name of the attribute to look up.
pub fn attribute(self: *Repository, flags: git.AttributeFlags, path: [:0]const u8, name: [:0]const u8) !git.Attribute {
log.debug("Repository.attribute called, flags: {}, path: {s}, name: {s}", .{ flags, path, name });
var result: ?[*:0]const u8 = undefined;
try internal.wrapCall("git_attr_get", .{
&result,
@ptrCast(*c.git_repository, self),
internal.make_c_option.attributeFlags(flags),
path.ptr,
name.ptr,
});
log.debug("fetched attribute", .{});
return git.Attribute{
.z_attr = result,
};
}
/// Look up a list of git attributes for path.
///
/// Use this if you have a known list of attributes that you want to look up in a single call. This is somewhat more efficient
/// than calling `attributeGet` multiple times.
///
/// ## Parameters
/// * `output_buffer` - Output buffer, *must* be atleast as long as `names`
/// * `flags` - Options for fetching attributes
/// * `path` - The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not
/// have to exist, but if it does not, then it will be treated as a plain file (not a directory).
/// * `names` - He names of the attributes to look up.
pub fn attributeMany(
self: *Repository,
output_buffer: [][*:0]const u8,
flags: git.AttributeFlags,
path: [:0]const u8,
names: [][*:0]const u8,
) ![]const [*:0]const u8 {
if (output_buffer.len < names.len) return error.BufferTooShort;
log.debug("Repository.attributeMany called, flags: {}, path: {s}", .{ flags, path });
try internal.wrapCall("git_attr_get_many", .{
@ptrCast([*]?[*:0]const u8, output_buffer.ptr),
@ptrCast(*c.git_repository, self),
internal.make_c_option.attributeFlags(flags),
path.ptr,
names.len,
@ptrCast([*]?[*:0]const u8, names.ptr),
});
log.debug("fetched attributes", .{});
return output_buffer[0..names.len];
}
/// Invoke `callback_fn` for all the git attributes for a path.
///
///
/// ## Parameters
/// * `flags` - Options for fetching attributes
/// * `path` - The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not
/// have to exist, but if it does not, then it will be treated as a plain file (not a directory).
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `name` - The attribute name
/// * `value` - The attribute value. May be `null` if the attribute is explicitly set to unspecified using the '!' sign.
pub fn attributeForeach(
self: *const Repository,
flags: git.AttributeFlags,
path: [:0]const u8,
comptime callback_fn: fn (
name: [:0]const u8,
value: ?[:0]const u8,
) c_int,
) !c_int {
const cb = struct {
pub fn cb(
name: ?[*:0]const u8,
value: ?[*:0]const u8,
payload: ?*anyopaque,
) callconv(.C) c_int {
_ = payload;
return callback_fn(
std.mem.sliceTo(name.?, 0),
if (value) |ptr| std.mem.sliceTo(ptr, 0) else null,
);
}
}.cb;
log.debug("Repository.attributeForeach called, flags: {}, path: {s}", .{ flags, path });
const ret = try internal.wrapCallWithReturn("git_attr_foreach", .{
@ptrCast(*const c.git_repository, self),
internal.make_c_option.attributeFlags(flags),
path.ptr,
cb,
null,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
/// Invoke `callback_fn` for all the git attributes for a path.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `flags` - Options for fetching attributes
/// * `path` - The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not
/// have to exist, but if it does not, then it will be treated as a plain file (not a directory).
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `name` - The attribute name
/// * `value` - The attribute value. May be `null` if the attribute is explicitly set to unspecified using the '!' sign.
/// * `user_data_ptr` - Pointer to user data
pub fn attributeForeachWithUserData(
self: *const Repository,
flags: git.AttributeFlags,
path: [:0]const u8,
user_data: anytype,
comptime callback_fn: fn (
name: [:0]const u8,
value: ?[:0]const u8,
user_data_ptr: @TypeOf(user_data),
) c_int,
) !c_int {
const UserDataType = @TypeOf(user_data);
const cb = struct {
pub fn cb(
name: ?[*:0]const u8,
value: ?[*:0]const u8,
payload: ?*anyopaque,
) callconv(.C) c_int {
return callback_fn(
std.mem.sliceTo(name.?, 0),
if (value) |ptr| std.mem.sliceTo(ptr, 0) else null,
@ptrCast(UserDataType, payload),
);
}
}.cb;
log.debug("Repository.attributeForeachWithUserData called, flags: {}, path: {s}", .{ flags, path });
const ret = try internal.wrapCallWithReturn("git_attr_foreach", .{
@ptrCast(*const c.git_repository, self),
internal.make_c_option.attributeFlags(flags),
path.ptr,
cb,
user_data,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
pub fn attributeCacheFlush(self: *Repository) !void {
log.debug("Repository.attributeCacheFlush called", .{});
try internal.wrapCall("git_attr_cache_flush", .{@ptrCast(*c.git_repository, self)});
log.debug("successfully flushed attribute cache", .{});
}
pub fn attributeAddMacro(self: *Repository, name: [:0]const u8, values: [:0]const u8) !void {
log.debug("Repository.attributeCacheFlush called, name: {s}, values: {s}", .{ name, values });
try internal.wrapCall("git_attr_add_macro", .{ @ptrCast(*c.git_repository, self), name.ptr, values.ptr });
log.debug("successfully added macro", .{});
}
pub fn blameFile(self: *Repository, path: [:0]const u8, options: git.BlameOptions) !*git.Blame {
log.debug("Repository.blameFile called, path: {s}, options: {}", .{ path, options });
var blame: *git.Blame = undefined;
var c_options = internal.make_c_option.blameOptions(options);
try internal.wrapCall("git_blame_file", .{
@ptrCast(*?*c.git_blame, &blame),
@ptrCast(*c.git_repository, self),
path.ptr,
&c_options,
});
log.debug("successfully fetched file blame", .{});
return blame;
}
pub fn blobLookup(self: *Repository, id: *const git.Oid) !*git.Blob {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try id.formatHex(&buf);
log.debug("Repository.blobLookup called, id: {s}", .{slice});
}
var blob: *git.Blob = undefined;
try internal.wrapCall("git_blob_lookup", .{
@ptrCast(*?*c.git_blob, &blob),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, id),
});
log.debug("successfully fetched blob {*}", .{blob});
return blob;
}
/// Lookup a blob object from a repository, given a prefix of its identifier (short id).
pub fn blobLookupPrefix(self: *Repository, id: *const git.Oid, len: usize) !*git.Blob {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try id.formatHex(&buf);
log.debug("Repository.blobLookup called, id: {s}, len: {}", .{ slice, len });
}
var blob: *git.Blob = undefined;
try internal.wrapCall("git_blob_lookup_prefix", .{
@ptrCast(*?*c.git_blob, &blob),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, id),
len,
});
log.debug("successfully fetched blob {*}", .{blob});
return blob;
}
/// Create a new branch pointing at a target commit
///
/// A new direct reference will be created pointing to this target commit. If `force` is true and a reference already exists
/// with the given name, it'll be replaced.
///
/// The returned reference must be freed by the user.
///
/// The branch name will be checked for validity.
///
/// ## Parameters
/// * `branch_name` - Name for the branch; this name is validated for consistency. It should also not conflict with an already
/// existing branch name.
/// * `target` - Commit to which this branch should point. This object must belong to the given `repo`.
/// * `force` - Overwrite existing branch.
pub fn branchCreate(self: *Repository, branch_name: [:0]const u8, target: *const git.Commit, force: bool) !*git.Reference {
log.debug("Repository.branchCreate called, branch_name: {s}, target: {*}, force: {}", .{ branch_name, target, force });
var reference: *git.Reference = undefined;
try internal.wrapCall("git_branch_create", .{
@ptrCast(*?*c.git_reference, &reference),
@ptrCast(*c.git_repository, self),
branch_name.ptr,
@ptrCast(*const c.git_commit, target),
@boolToInt(force),
});
log.debug("successfully created branch", .{});
return reference;
}
/// Create a new branch pointing at a target commit
///
/// This behaves like `branchCreate` but takes an annotated commit, which lets you specify which extended sha syntax string
/// was specified by a user, allowing for more exact reflog messages.
///
/// ## Parameters
/// * `branch_name` - Name for the branch; this name is validated for consistency. It should also not conflict with an already
/// existing branch name.
/// * `target` - Commit to which this branch should point. This object must belong to the given `repo`.
/// * `force` - Overwrite existing branch.
pub fn branchCreateFromAnnotated(
self: *Repository,
branch_name: [:0]const u8,
target: *const git.AnnotatedCommit,
force: bool,
) !*git.Reference {
log.debug("Repository.branchCreateFromAnnotated called, branch_name: {s}, target: {*}, force: {}", .{ branch_name, target, force });
var reference: *git.Reference = undefined;
try internal.wrapCall("git_branch_create_from_annotated", .{
@ptrCast(*?*c.git_reference, &reference),
@ptrCast(*c.git_repository, self),
branch_name.ptr,
@ptrCast(*const c.git_annotated_commit, target),
@boolToInt(force),
});
log.debug("successfully created branch", .{});
return reference;
}
pub fn iterateBranches(self: *Repository, branch_type: BranchType) !*BranchIterator {
log.debug("Repository.iterateBranches called", .{});
var iterator: *BranchIterator = undefined;
try internal.wrapCall("git_branch_iterator_new", .{
@ptrCast(*?*c.git_branch_iterator, &iterator),
@ptrCast(*c.git_repository, self),
@enumToInt(branch_type),
});
log.debug("branch iterator created successfully", .{});
return iterator;
}
pub const BranchType = enum(c_uint) {
local = 1,
remote = 2,
all = 3,
};
pub const BranchIterator = opaque {
pub fn next(self: *BranchIterator) !?Item {
log.debug("BranchIterator.next called", .{});
var reference: *git.Reference = undefined;
var branch_type: c.git_branch_t = undefined;
internal.wrapCall("git_branch_next", .{
@ptrCast(*?*c.git_reference, &reference),
&branch_type,
@ptrCast(*c.git_branch_iterator, self),
}) catch |err| switch (err) {
git.GitError.IterOver => {
log.debug("end of iteration reached", .{});
return null;
},
else => return err,
};
const ret = Item{
.reference = reference,
.branch_type = @intToEnum(BranchType, branch_type),
};
log.debug("successfully fetched branch: {}", .{ret});
return ret;
}
pub const Item = struct {
reference: *git.Reference,
branch_type: BranchType,
};
pub fn deinit(self: *BranchIterator) void {
log.debug("BranchIterator.deinit called", .{});
c.git_branch_iterator_free(@ptrCast(*c.git_branch_iterator, self));
log.debug("branch iterator freed successfully", .{});
}
comptime {
std.testing.refAllDecls(@This());
}
};
/// Lookup a branch by its name in a repository.
///
/// The generated reference must be freed by the user.
/// The branch name will be checked for validity.
pub fn branchLookup(self: *Repository, branch_name: [:0]const u8, branch_type: BranchType) !*git.Reference {
log.debug("Repository.branchLookup called, branch_name: {s}, branch_type: {}", .{ branch_name, branch_type });
var ref: *git.Reference = undefined;
try internal.wrapCall("git_branch_lookup", .{
@ptrCast(*?*c.git_reference, &ref),
@ptrCast(*c.git_repository, self),
branch_name.ptr,
@enumToInt(branch_type),
});
log.debug("successfully fetched branch: {*}", .{ref});
return ref;
}
/// Find the remote name of a remote-tracking branch
///
/// This will return the name of the remote whose fetch refspec is matching the given branch. E.g. given a branch
/// "refs/remotes/test/master", it will extract the "test" part. If refspecs from multiple remotes match, the function will
/// return `GitError.Ambiguous`.
pub fn remoteGetName(self: *Repository, refname: [:0]const u8) !git.Buf {
log.debug("Repository.remoteGetName called, refname: {s}", .{refname});
var buf: git.Buf = .{};
try internal.wrapCall("git_branch_remote_name", .{
@ptrCast(*c.git_buf, &buf),
@ptrCast(*c.git_repository, self),
refname.ptr,
});
log.debug("remote name acquired successfully, name: {s}", .{buf.toSlice()});
return buf;
}
/// Retrieve the upstream remote of a local branch
///
/// This will return the currently configured "branch.*.remote" for a given branch. This branch must be local.
pub fn remoteUpstreamRemote(self: *Repository, refname: [:0]const u8) !git.Buf {
log.debug("Repository.remoteUpstreamRemote called, refname: {s}", .{refname});
var buf: git.Buf = .{};
try internal.wrapCall("git_branch_upstream_remote", .{
@ptrCast(*c.git_buf, &buf),
@ptrCast(*c.git_repository, self),
refname.ptr,
});
log.debug("upstream remote name acquired successfully, name: {s}", .{buf.toSlice()});
return buf;
}
/// Get the upstream name of a branch
///
/// Given a local branch, this will return its remote-tracking branch information, as a full reference name, ie.
/// "feature/nice" would become "refs/remote/origin/feature/nice", depending on that branch's configuration.
pub fn upstreamGetName(self: *Repository, refname: [:0]const u8) !git.Buf {
log.debug("Repository.upstreamGetName called, refname: {s}", .{refname});
var buf: git.Buf = .{};
try internal.wrapCall("git_branch_upstream_name", .{
@ptrCast(*c.git_buf, &buf),
@ptrCast(*c.git_repository, self),
refname.ptr,
});
log.debug("upstream name acquired successfully, name: {s}", .{buf.toSlice()});
return buf;
}
/// Updates files in the index and the working tree to match the content of the commit pointed at by HEAD.
///
/// Note that this is _not_ the correct mechanism used to switch branches; do not change your `HEAD` and then call this
/// method, that would leave you with checkout conflicts since your working directory would then appear to be dirty.
/// Instead, checkout the target of the branch and then update `HEAD` using `git_repository_set_head` to point to the branch
/// you checked out.
///
/// Returns a non-zero value is the `notify_cb` callback returns non-zero.
pub fn checkoutHead(self: *Repository, options: CheckoutOptions) !c_uint {
log.debug("Repository.checkoutHead called, options: {}", .{options});
const c_options = internal.make_c_option.checkoutOptions(options);
const ret = try internal.wrapCallWithReturn("git_checkout_head", .{
@ptrCast(*c.git_repository, self),
&c_options,
});
log.debug("successfully checked out HEAD", .{});
return @intCast(c_uint, ret);
}
/// Updates files in the working tree to match the content of the index.
///
/// Returns a non-zero value is the `notify_cb` callback returns non-zero.
pub fn checkoutIndex(self: *Repository, index: *git.Index, options: CheckoutOptions) !c_uint {
log.debug("Repository.checkoutHead called, options: {}", .{options});
const c_options = internal.make_c_option.checkoutOptions(options);
const ret = try internal.wrapCallWithReturn("git_checkout_index", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_index, index),
&c_options,
});
log.debug("successfully checked out index", .{});
return @intCast(c_uint, ret);
}
/// Updates files in the working tree to match the content of the index.
///
/// Returns a non-zero value is the `notify_cb` callback returns non-zero.
pub fn checkoutTree(self: *Repository, treeish: *const git.Object, options: CheckoutOptions) !c_uint {
log.debug("Repository.checkoutHead called, options: {}", .{options});
const c_option = internal.make_c_option.checkoutOptions(options);
const ret = try internal.wrapCallWithReturn("git_checkout_tree", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_object, treeish),
&c_option,
});
log.debug("successfully checked out tree", .{});
return @intCast(c_uint, ret);
}
pub fn cherrypickCommit(
self: *Repository,
cherrypick_commit: *git.Commit,
our_commit: *git.Commit,
mainline: bool,
options: git.MergeOptions,
) !*git.Index {
log.debug(
"Repository.cherrypickCommit called, cherrypick_commit: {*}, our_commit: {*}, mainline: {}, options: {}",
.{ cherrypick_commit, our_commit, mainline, options },
);
var index: *git.Index = undefined;
const c_options = internal.make_c_option.mergeOptions(options);
try internal.wrapCall("git_cherrypick_commit", .{
@ptrCast(*?*c.git_index, &index),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_commit, cherrypick_commit),
@ptrCast(*c.git_commit, our_commit),
@boolToInt(mainline),
&c_options,
});
log.debug("successfully cherrypicked, index: {*}", .{index});
return index;
}
pub fn cherrypick(
self: *Repository,
commit: *git.Commit,
options: CherrypickOptions,
) !void {
log.debug(
"Repository.cherrypick called, commit: {*}, options: {}",
.{ commit, options },
);
const c_options = internal.make_c_option.cherrypickOptions(options);
try internal.wrapCall("git_cherrypick", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_commit, commit),
&c_options,
});
log.debug("successfully cherrypicked", .{});
}
/// Lookup a commit object from a repository.
pub fn commitLookup(self: *Repository, oid: *const git.Oid) !*git.Commit {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("Repository.commitLookup called, oid: {s}", .{slice});
}
var commit: *git.Commit = undefined;
try internal.wrapCall("git_commit_lookup", .{
@ptrCast(*?*c.git_commit, &commit),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, oid),
});
log.debug("successfully looked up commit, commit: {*}", .{commit});
return commit;
}
/// Lookup a commit object from a repository, given a prefix of its identifier (short id).
pub fn commitLookupPrefix(self: *Repository, oid: *const git.Oid, size: usize) !*git.Commit {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("Repository.commitLookupPrefix called, oid: {s}, size: {}", .{ slice, size });
}
var commit: *git.Commit = undefined;
try internal.wrapCall("git_commit_lookup_prefix", .{
@ptrCast(*?*c.git_commit, &commit),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, oid),
size,
});
log.debug("successfully looked up commit, commit: {*}", .{commit});
return commit;
}
pub fn commitExtractSignature(self: *Repository, commit: *git.Oid, field: ?[:0]const u8) !ExtractSignatureResult {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try commit.formatHex(&buf);
log.debug("Repository.commitExtractSignature called, commit: {s}, field: {s}", .{ slice, field });
}
var result: ExtractSignatureResult = .{};
const field_temp = if (field) |slice| slice.ptr else null;
try internal.wrapCall("git_commit_extract_signature", .{
@ptrCast(*c.git_buf, &result.signature),
@ptrCast(*c.git_buf, &result.signed_data),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_oid, commit),
field_temp,
});
return result;
}
pub const ExtractSignatureResult = struct {
signature: git.Buf = .{},
signed_data: git.Buf = .{},
};
pub fn commitCreate(
self: *Repository,
update_ref: ?[:0]const u8,
author: *const git.Signature,
committer: *const git.Signature,
message_encoding: ?[:0]const u8,
message: [:0]const u8,
tree: *const git.Tree,
parents: []*const git.Commit,
) !git.Oid {
log.debug("Repository.commitCreate called, update_ref: {s}, author: {*}, committer: {*}, message_encoding: {s}, message: {s}, tree: {*}", .{
update_ref,
author,
committer,
message_encoding,
message,
tree,
});
var ret: git.Oid = undefined;
const update_ref_temp = if (update_ref) |slice| slice.ptr else null;
const encoding_temp = if (message_encoding) |slice| slice.ptr else null;
try internal.wrapCall("git_commit_create", .{
@ptrCast(*c.git_oid, &ret),
@ptrCast(*c.git_repository, self),
update_ref_temp,
@ptrCast(*const c.git_signature, author),
@ptrCast(*const c.git_signature, committer),
encoding_temp,
message.ptr,
@ptrCast(*const c.git_tree, tree),
parents.len,
@ptrCast([*]?*const c.git_commit, parents.ptr),
});
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try ret.formatHex(&buf);
log.debug("successfully created commit: {s}", .{slice});
}
return ret;
}
pub fn commitCreateBuffer(
self: *Repository,
author: *const git.Signature,
committer: *const git.Signature,
message_encoding: ?[:0]const u8,
message: [:0]const u8,
tree: *const git.Tree,
parents: []*const git.Commit,
) !git.Buf {
log.debug("Repository.commitCreateBuffer called, author: {*}, committer: {*}, message_encoding: {s}, message: {s}, tree: {*}", .{
author,
committer,
message_encoding,
message,
tree,
});
var ret: git.Buf = .{};
const encoding_temp = if (message_encoding) |slice| slice.ptr else null;
try internal.wrapCall("git_commit_create_buffer", .{
@ptrCast(*c.git_buf, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_signature, author),
@ptrCast(*const c.git_signature, committer),
encoding_temp,
message.ptr,
@ptrCast(*const c.git_tree, tree),
parents.len,
@ptrCast([*]?*const c.git_commit, parents.ptr),
});
log.debug("successfully created commit: {s}", .{ret.toSlice()});
return ret;
}
pub fn commitCreateWithSignature(
self: *Repository,
commit_content: [:0]const u8,
signature: ?[:0]const u8,
signature_field: ?[:0]const u8,
) !git.Oid {
log.debug("Repository.commitCreateWithSignature called, commit_content: {s}, signature: {s}, signature_field: {s}", .{
commit_content,
signature,
signature_field,
});
var ret: git.Oid = undefined;
const signature_temp = if (signature) |slice| slice.ptr else null;
const signature_field_temp = if (signature_field) |slice| slice.ptr else null;
try internal.wrapCall("git_commit_create_with_signature", .{
@ptrCast(*c.git_oid, &ret),
@ptrCast(*c.git_repository, self),
commit_content.ptr,
signature_temp,
signature_field_temp,
});
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try ret.formatHex(&buf);
log.debug("successfully created commit: {s}", .{slice});
}
return ret;
}
/// Create a new mailmap instance from a repository, loading mailmap files based on the repository's configuration.
///
/// Mailmaps are loaded in the following order:
/// 1. '.mailmap' in the root of the repository's working directory, if present.
/// 2. The blob object identified by the 'mailmap.blob' config entry, if set.
/// [NOTE: 'mailmap.blob' defaults to 'HEAD:.mailmap' in bare repositories]
/// 3. The path in the 'mailmap.file' config entry, if set.
pub fn mailmapFromRepo(self: *Repository) !*git.Mailmap {
log.debug("Repository.mailmapFromRepo called", .{});
var mailmap: *git.Mailmap = undefined;
try internal.wrapCall("git_mailmap_from_repository", .{
@ptrCast(*?*c.git_mailmap, &mailmap),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully loaded mailmap from repo: {*}", .{mailmap});
return mailmap;
}
/// Load the filter list for a given path.
///
/// This will return null if no filters are requested for the given file.
///
/// ## Parameters
/// * `blob` - The blob to which the filter will be applied (if known)
/// * `path` - Relative path of the file to be filtered
/// * `mode` - Filtering direction (WT->ODB or ODB->WT)
/// * `flags` - Filter flags
pub fn filterListLoad(
self: *Repository,
blob: ?*git.Blob,
path: [:0]const u8,
mode: git.FilterMode,
flags: git.FilterFlags,
) !?*git.FilterList {
log.debug(
"Repository.filterListLoad called, blob: {*}, path: {s}, mode: {}, flags: {}",
.{ blob, path, mode, flags },
);
var opt: ?*git.FilterList = undefined;
try internal.wrapCall("git_filter_list_load", .{
@ptrCast(*?*c.git_filter_list, &opt),
@ptrCast(*c.git_repository, self),
@ptrCast(?*c.git_blob, blob),
path.ptr,
@enumToInt(mode),
@bitCast(c_uint, flags),
});
if (opt) |ret| {
log.debug("successfully acquired filters for the given path: {*}", .{ret});
return ret;
}
log.debug("no filters for the given path", .{});
return null;
}
/// Count the number of unique commits between two commit objects
///
/// There is no need for branches containing the commits to have any upstream relationship, but it helps to think of one as a
// branch and the other as its upstream, the `ahead` and `behind` values will be what git would report for the branches.
///
/// ## Parameters
/// * `local` - The commit for local
/// * `upstream` - The commit for upstream
pub fn graphAheadBehind(
self: *Repository,
local: *const git.Oid,
upstream: *const git.Oid,
) !GraphAheadBehindResult {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf1: [git.Oid.hex_buffer_size]u8 = undefined;
var buf2: [git.Oid.hex_buffer_size]u8 = undefined;
const slice1 = try local.formatHex(&buf1);
const slice2 = try upstream.formatHex(&buf2);
log.debug("Repository.graphAheadBehind called, local: {s}, upstream: {s}", .{ slice1, slice2 });
}
var ret: GraphAheadBehindResult = undefined;
try internal.wrapCall("git_graph_ahead_behind", .{
&ret.ahead,
&ret.behind,
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, local),
@ptrCast(*const c.git_oid, upstream),
});
log.debug("successfully got unique commits: {}", .{ret});
return ret;
}
pub const GraphAheadBehindResult = struct { ahead: usize, behind: usize };
/// Determine if a commit is the descendant of another commit.
///
/// Note that a commit is not considered a descendant of itself, in contrast to `git merge-base --is-ancestor`.
///
/// ## Parameters
/// * `commit` - A previously loaded commit
/// * `ancestor` - A potential ancestor commit
pub fn graphDecendantOf(self: *Repository, commit: *const git.Oid, ancestor: *const git.Oid) !bool {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf1: [git.Oid.hex_buffer_size]u8 = undefined;
var buf2: [git.Oid.hex_buffer_size]u8 = undefined;
const slice1 = try commit.formatHex(&buf1);
const slice2 = try ancestor.formatHex(&buf2);
log.debug("Repository.graphDecendantOf called, commit: {s}, ancestor: {s}", .{ slice1, slice2 });
}
const ret = (try internal.wrapCallWithReturn("git_graph_descendant_of", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, commit),
@ptrCast(*const c.git_oid, ancestor),
})) != 0;
log.debug("commit is an ancestor: {}", .{ret});
return ret;
}
/// Add ignore rules for a repository.
///
/// Excludesfile rules (i.e. .gitignore rules) are generally read from .gitignore files in the repository tree or from a
/// shared system file only if a "core.excludesfile" config value is set. The library also keeps a set of per-repository
/// internal ignores that can be configured in-memory and will not persist. This function allows you to add to that internal
/// rules list.
///
/// Example usage:
/// ```zig
/// try repo.ignoreAddRule("*.c\ndir/\nFile with space\n");
/// ```
///
/// This would add three rules to the ignores.
///
/// ## Parameters
/// * `rules` - Text of rules, a la the contents of a .gitignore file. It is okay to have multiple rules in the text; if so,
/// each rule should be terminated with a newline.
pub fn ignoreAddRule(self: *Repository, rules: [:0]const u8) !void {
log.debug("Repository.ignoreAddRule called, rules: {s}", .{rules});
try internal.wrapCall("git_ignore_add_rule", .{ @ptrCast(*c.git_repository, self), rules.ptr });
log.debug("successfully added ignore rules", .{});
}
/// Clear ignore rules that were explicitly added.
///
/// Resets to the default internal ignore rules. This will not turn off
/// rules in .gitignore files that actually exist in the filesystem.
///
/// The default internal ignores ignore ".", ".." and ".git" entries.
pub fn ignoreClearRules(self: *Repository) !void {
log.debug("Repository.git_ignore_clear_internal_rules called", .{});
try internal.wrapCall("git_ignore_clear_internal_rules", .{@ptrCast(*c.git_repository, self)});
log.debug("successfully cleared ignore rules", .{});
}
/// Test if the ignore rules apply to a given path.
///
/// This function checks the ignore rules to see if they would apply to the given file. This indicates if the file would be
/// ignored regardless of whether the file is already in the index or committed to the repository.
///
/// One way to think of this is if you were to do "git check-ignore --no-index" on the given file, would it be shown or not?
///
/// ## Parameters
/// * `path` - The file to check ignores for, relative to the repo's workdir.
pub fn ignorePathIsIgnored(self: *Repository, path: [:0]const u8) !bool {
log.debug("Repository.ignorePathIsIgnored called, path: {s}", .{path});
var ignored: c_int = undefined;
try internal.wrapCall("git_ignore_path_is_ignored", .{
&ignored,
@ptrCast(*c.git_repository, self),
path.ptr,
});
const ret = ignored != 0;
log.debug("ignore path is ignored: {}", .{ret});
return ret;
}
/// Load the filter list for a given path.
///
/// This will return null if no filters are requested for the given file.
///
/// ## Parameters
/// * `blob` - The blob to which the filter will be applied (if known)
/// * `path` - Relative path of the file to be filtered
/// * `mode` - Filtering direction (WT->ODB or ODB->WT)
/// * `options` - Filter options
pub fn filterListLoadExtended(
self: *Repository,
blob: ?*git.Blob,
path: [:0]const u8,
mode: git.FilterMode,
options: git.FilterOptions,
) !?*git.FilterList {
log.debug(
"Repository.filterListLoad called, blob: {*}, path: {s}, mode: {}, options: {}",
.{ blob, path, mode, options },
);
var opt: ?*git.FilterList = undefined;
var c_options = internal.make_c_option.filterOptions(options);
try internal.wrapCall("git_filter_list_load_ext", .{
@ptrCast(*?*c.git_filter_list, &opt),
@ptrCast(*c.git_repository, self),
@ptrCast(?*c.git_blob, blob),
path.ptr,
@enumToInt(mode),
&c_options,
});
if (opt) |ret| {
log.debug("successfully acquired filters for the given path: {*}", .{ret});
return ret;
}
log.debug("no filters for the given path", .{});
return null;
}
/// Determine if a commit is reachable from any of a list of commits by following parent edges.
///
/// ## Parameters
/// * `commit` - A previously loaded commit
/// * `decendants` - Oids of the commits
pub fn graphReachableFromAny(
self: *Repository,
commit: *const git.Oid,
decendants: []const git.Oid,
) !bool {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try commit.formatHex(&buf);
log.debug("Repository.graphReachableFromAny called, commit: {s}, number of decendants: {}", .{ slice, decendants.len });
}
const ret = (try internal.wrapCallWithReturn("git_graph_reachable_from_any", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, commit),
@ptrCast([*]const c.git_oid, decendants.ptr),
decendants.len,
})) != 0;
log.debug("commit is an ancestor: {}", .{ret});
return ret;
}
/// Retrieve the upstream merge of a local branch
///
/// This will return the currently configured "branch.*.remote" for a given branch. This branch must be local.
pub fn remoteUpstreamMerge(self: *Repository, refname: [:0]const u8) !git.Buf {
log.debug("Repository.remoteUpstreamMerge called, refname: {s}", .{refname});
var buf: git.Buf = .{};
try internal.wrapCall("git_branch_upstream_merge", .{
@ptrCast(*c.git_buf, &buf),
@ptrCast(*c.git_repository, self),
refname.ptr,
});
log.debug("upstream remote name acquired successfully, name: {s}", .{buf.toSlice()});
return buf;
}
/// Look up the value of one git attribute for path with extended options.
///
/// ## Parameters
/// * `options` - Options for fetching attributes
/// * `path` - The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not
/// have to exist, but if it does not, then it will be treated as a plain file (not a directory).
/// * `name` - The name of the attribute to look up.
pub fn attributeExtended(
self: *Repository,
options: git.AttributeOptions,
path: [:0]const u8,
name: [:0]const u8,
) !git.Attribute {
log.debug("Repository.attributeExtended called, options: {}, path: {s}, name: {s}", .{ options, path, name });
var c_options = internal.make_c_option.attributeOptions(options);
var result: ?[*:0]const u8 = undefined;
try internal.wrapCall("git_attr_get_ext", .{
&result,
@ptrCast(*c.git_repository, self),
&c_options,
path.ptr,
name.ptr,
});
log.debug("fetched attribute", .{});
return git.Attribute{
.z_attr = result,
};
}
/// Look up a list of git attributes for path with extended options.
///
/// Use this if you have a known list of attributes that you want to look up in a single call. This is somewhat more efficient
/// than calling `attributeGet` multiple times.
///
/// ## Parameters
/// * `output_buffer` - Output buffer, *must* be atleast as long as `names`
/// * `options` - Options for fetching attributes
/// * `path` - The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not
/// have to exist, but if it does not, then it will be treated as a plain file (not a directory).
/// * `names` - The names of the attributes to look up.
pub fn attributeManyExtended(
self: *Repository,
output_buffer: [][*:0]const u8,
options: git.AttributeOptions,
path: [:0]const u8,
names: [][*:0]const u8,
) ![]const [*:0]const u8 {
if (output_buffer.len < names.len) return error.BufferTooShort;
log.debug("Repository.attributeManyExtended called, options: {}, path: {s}", .{ options, path });
var c_options = internal.make_c_option.attributeOptions(options);
try internal.wrapCall("git_attr_get_many_ext", .{
@ptrCast([*]?[*:0]const u8, output_buffer.ptr),
@ptrCast(*c.git_repository, self),
&c_options,
path.ptr,
names.len,
@ptrCast([*]?[*:0]const u8, names.ptr),
});
log.debug("fetched attributes", .{});
return output_buffer[0..names.len];
}
/// Invoke `callback_fn` for all the git attributes for a path with extended options.
///
///
/// ## Parameters
/// * `options` - Options for fetching attributes
/// * `path` - The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not
/// have to exist, but if it does not, then it will be treated as a plain file (not a directory).
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `name` - The attribute name
/// * `value` - The attribute value. May be `null` if the attribute is explicitly set to unspecified using the '!' sign.
pub fn attributeForeachExtended(
self: *const Repository,
options: git.AttributeOptions,
path: [:0]const u8,
comptime callback_fn: fn (
name: [:0]const u8,
value: ?[:0]const u8,
) c_int,
) !c_int {
const cb = struct {
pub fn cb(
name: ?[*:0]const u8,
value: ?[*:0]const u8,
payload: ?*anyopaque,
) callconv(.C) c_int {
_ = payload;
return callback_fn(
std.mem.sliceTo(name.?, 0),
if (value) |ptr| std.mem.sliceTo(ptr, 0) else null,
);
}
}.cb;
log.debug("Repository.attributeForeach called, options: {}, path: {s}", .{ options, path });
const c_options = internal.make_c_option.attributeOptions(options);
const ret = try internal.wrapCallWithReturn("git_attr_foreach_ext", .{
@ptrCast(*const c.git_repository, self),
&c_options,
path.ptr,
cb,
null,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
/// Invoke `callback_fn` for all the git attributes for a path with extended options.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `options` - Options for fetching attributes
/// * `path` - The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not
/// have to exist, but if it does not, then it will be treated as a plain file (not a directory).
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `name` - The attribute name
/// * `value` - The attribute value. May be `null` if the attribute is explicitly set to unspecified using the '!' sign.
/// * `user_data_ptr` - Pointer to user data
pub fn attributeForeachWithUserDataExtended(
self: *const Repository,
options: git.AttributeOptions,
path: [:0]const u8,
user_data: anytype,
comptime callback_fn: fn (
name: [:0]const u8,
value: ?[:0]const u8,
user_data_ptr: @TypeOf(user_data),
) c_int,
) !c_int {
const UserDataType = @TypeOf(user_data);
const cb = struct {
pub fn cb(
name: ?[*:0]const u8,
value: ?[*:0]const u8,
payload: ?*anyopaque,
) callconv(.C) c_int {
return callback_fn(
std.mem.sliceTo(name.?, 0),
if (value) |ptr| std.mem.sliceTo(ptr, 0) else null,
@ptrCast(UserDataType, payload),
);
}
}.cb;
log.debug("Repository.attributeForeachWithUserData called, options: {}, path: {s}", .{ options, path });
const c_options = internal.make_c_option.attributeOptions(options);
const ret = try internal.wrapCallWithReturn("git_attr_foreach_ext", .{
@ptrCast(*const c.git_repository, self),
&c_options,
path.ptr,
cb,
user_data,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
/// Read a file from the filesystem and write its content to the Object Database as a loose blob
pub fn blobFromBuffer(self: *Repository, buffer: []const u8) !git.Oid {
log.debug("Repository.blobFromBuffer called, buffer: {s}", .{buffer});
var ret: git.Oid = undefined;
try internal.wrapCall("git_blob_create_from_buffer", .{
@ptrCast(*c.git_oid, &ret),
@ptrCast(*c.git_repository, self),
buffer.ptr,
buffer.len,
});
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try ret.formatHex(&buf);
log.debug("successfully read blob: {s}", .{slice});
}
return ret;
}
/// Create a stream to write a new blob into the object db
///
/// This function may need to buffer the data on disk and will in general not be the right choice if you know the size of the
/// data to write. If you have data in memory, use `blobFromBuffer()`. If you do not, but know the size of the contents
/// (and don't want/need to perform filtering), use `Odb.openWriteStream()`.
///
/// Don't close this stream yourself but pass it to `WriteStream.commit()` to commit the write to the object db and get the
/// object id.
///
/// If the `hintpath` parameter is filled, it will be used to determine what git filters should be applied to the object
/// before it is written to the object database.
pub fn blobFromStream(self: *Repository, hint_path: ?[:0]const u8) !*git.WriteStream {
log.debug("Repository.blobFromDisk called, hint_path: {s}", .{hint_path});
var write_stream: *git.WriteStream = undefined;
const hint_path_c = if (hint_path) |ptr| ptr.ptr else null;
try internal.wrapCall("git_blob_create_from_stream", .{
@ptrCast(*?*c.git_writestream, &write_stream),
@ptrCast(*c.git_repository, self),
hint_path_c,
});
log.debug("successfully created writestream {*}", .{write_stream});
return write_stream;
}
/// Read a file from the filesystem and write its content to the Object Database as a loose blob
pub fn blobFromDisk(self: *Repository, path: [:0]const u8) !git.Oid {
log.debug("Repository.blobFromDisk called, path: {s}", .{path});
var ret: git.Oid = undefined;
try internal.wrapCall("git_blob_create_from_disk", .{
@ptrCast(*c.git_oid, &ret),
@ptrCast(*c.git_repository, self),
path.ptr,
});
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try ret.formatHex(&buf);
log.debug("successfully read blob: {s}", .{slice});
}
return ret;
}
/// Read a file from the working folder of a repository and write it to the Object Database as a loose blob
pub fn blobFromWorkdir(self: *Repository, relative_path: [:0]const u8) !git.Oid {
log.debug("Repository.blobFromWorkdir called, relative_path: {s}", .{relative_path});
var ret: git.Oid = undefined;
try internal.wrapCall("git_blob_create_from_workdir", .{
@ptrCast(*c.git_oid, &ret),
@ptrCast(*c.git_repository, self),
relative_path.ptr,
});
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try ret.formatHex(&buf);
log.debug("successfully read blob: {s}", .{slice});
}
return ret;
}
/// List names of linked working trees
///
/// The returned list needs to be `deinit`-ed
pub fn worktreeList(self: *Repository) !git.StrArray {
log.debug("Repository.worktreeList called", .{});
var ret: git.StrArray = .{};
try internal.wrapCall("git_worktree_list", .{
@ptrCast(*c.git_strarray, &ret),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully fetched worktree list of {} items", .{ret.count});
return ret;
}
/// Lookup a working tree by its name for a given repository
pub fn worktreeByName(self: *Repository, name: [:0]const u8) !*git.Worktree {
log.debug("Repository.worktreeByName called, name: {s}", .{name});
var ret: *git.Worktree = undefined;
try internal.wrapCall("git_worktree_lookup", .{
@ptrCast(*?*c.git_worktree, &ret),
@ptrCast(*c.git_repository, self),
name.ptr,
});
log.debug("successfully fetched worktree {*}", .{ret});
return ret;
}
/// Open a worktree of a given repository
///
/// If a repository is not the main tree but a worktree, this function will look up the worktree inside the parent
/// repository and create a new `git.Worktree` structure.
pub fn worktreeOpenFromRepository(self: *Repository) !*git.Worktree {
log.debug("Repository.worktreeOpenFromRepository called", .{});
var ret: *git.Worktree = undefined;
try internal.wrapCall("git_worktree_open_from_repository", .{
@ptrCast(*?*c.git_worktree, &ret),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully fetched worktree {*}", .{ret});
return ret;
}
/// Add a new working tree
///
/// Add a new working tree for the repository, that is create the required data structures inside the repository and
/// check out the current HEAD at `path`
///
/// ## Parameters
/// * `name` - Name of the working tree
/// * `path` - Path to create working tree at
/// * `options` - Options to modify default behavior.
pub fn worktreeAdd(self: *Repository, name: [:0]const u8, path: [:0]const u8, options: git.WorktreeAddOptions) !*git.Worktree {
log.debug("Repository.worktreeAdd called, name: {s}, path: {s}, options: {}", .{ name, path, options });
var ret: *git.Worktree = undefined;
const c_options = internal.make_c_option.worktreeAddOptions(options);
try internal.wrapCall("git_worktree_add", .{
@ptrCast(*?*c.git_worktree, &ret),
@ptrCast(*c.git_repository, self),
name.ptr,
path.ptr,
&c_options,
});
log.debug("successfully created worktree {*}", .{ret});
return ret;
}
/// Lookup a tree object from the repository.
///
/// ## Parameters
/// * `id` - Identity of the tree to locate.
pub fn treeLookup(self: *Repository, id: *const git.Oid) !*git.Tree {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try id.formatHex(&buf);
log.debug("Repository.treeLookup called, id: {s}", .{slice});
}
var ret: *git.Tree = undefined;
try internal.wrapCall("git_tree_lookup", .{
@ptrCast(*?*c.git_tree, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, id),
});
log.debug("successfully located tree: {*}", .{ret});
return ret;
}
/// Lookup a tree object from the repository, given a prefix of its identifier (short id).
///
/// ## Parameters
/// * `id` - Identity of the tree to locate.
/// * `len` - The length of the short identifier
pub fn treeLookupPrefix(self: *Repository, id: *const git.Oid, len: usize) !*git.Tree {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try id.formatHexCount(&buf, len);
log.debug("Repository.treeLookupPrefix, id: {s}, len: {}", .{ slice, len });
}
var ret: *git.Tree = undefined;
try internal.wrapCall("git_tree_lookup_prefix", .{
@ptrCast(*?*c.git_tree, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, id),
len,
});
log.debug("successfully located tree: {*}", .{ret});
return ret;
}
/// Convert a tree entry to the git_object it points to.
///
/// You must call `git.Object.deint` on the object when you are done with it.
pub fn treeEntrytoObject(self: *Repository, entry: *const git.TreeEntry) !*git.Object {
log.debug("Repository.treeEntrytoObject called, entry: {*}", .{entry});
var ret: *git.Object = undefined;
try internal.wrapCall("git_tree_entry_to_object", .{
@ptrCast(*?*c.git_object, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_tree_entry, entry),
});
log.debug("successfully fetched object: {*}", .{ret});
return ret;
}
/// Create a new tree builder.
///
/// The tree builder can be used to create or modify trees in memory and write them as tree objects to the database.
///
/// If the `source` parameter is not `null`, the tree builder will be initialized with the entries of the given tree.
///
/// If the `source` parameter is `null`, the tree builder will start with no entries and will have to be filled manually.
pub fn treebuilderNew(self: *Repository, source: ?*const git.Tree) !*git.TreeBuilder {
log.debug("Repository.treebuilderNew called, source: {*}", .{source});
var ret: *git.TreeBuilder = undefined;
try internal.wrapCall("git_treebuilder_new", .{
@ptrCast(*?*c.git_treebuilder, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(?*const c.git_tree, source),
});
log.debug("successfully created treebuilder: {*}", .{ret});
return ret;
}
pub const TreeUpdateAction = extern struct {
/// Update action. If it's an removal, only the path is looked at
action: Action,
/// The entry's id
id: git.Oid,
/// The filemode/kind of object
filemode: git.FileMode,
// The full path from the root tree
path: [*:0]const u8,
pub const Action = enum(c_uint) {
/// Update or insert an entry at the specified path
upsert = 0,
/// Remove an entry from the specified path
remove = 1,
};
test {
try std.testing.expectEqual(@sizeOf(c.git_tree_update), @sizeOf(TreeUpdateAction));
try std.testing.expectEqual(@bitSizeOf(c.git_tree_update), @bitSizeOf(TreeUpdateAction));
}
comptime {
std.testing.refAllDecls(@This());
}
};
/// Create a tree based on another one with the specified modifications
///
/// Given the `baseline` perform the changes described in the list of `updates` and create a new tree.
///
/// This function is optimized for common file/directory addition, removal and replacement in trees.
/// It is much more efficient than reading the tree into a `git.Index` and modifying that, but in exchange it is not as
/// flexible.
///
/// Deleting and adding the same entry is undefined behaviour, changing a tree to a blob or viceversa is not supported.
///
/// ## Parameters
/// * `baseline` - The tree to base these changes on, must be the repository `baseline` is in
/// * `updates` - The updates to perform
pub fn createUpdatedTree(self: *Repository, baseline: *git.Tree, updates: []const TreeUpdateAction) !git.Oid {
log.debug("Repository.createUpdatedTree called, baseline: {*}, number of updates: {}", .{ baseline, updates.len });
var ret: git.Oid = undefined;
try internal.wrapCall("git_tree_create_updated", .{
@ptrCast(*c.git_oid, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_tree, baseline),
updates.len,
@ptrCast([*]const c.git_tree_update, updates.ptr),
});
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try ret.formatHex(&buf);
log.debug("successfully created new tree: {s}", .{slice});
}
return ret;
}
/// Creates a new iterator for notes
///
/// ## Parameters
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
pub fn noteIterator(self: *Repository, notes_ref: ?[:0]const u8) !*git.NoteIterator {
log.debug("Repository.noteIterator called, notes_ref: {s}", .{notes_ref});
var ret: *git.NoteIterator = undefined;
const c_notes = if (notes_ref) |p| p.ptr else null;
try internal.wrapCall("git_note_iterator_new", .{
@ptrCast(*?*c.git_note_iterator, &ret),
@ptrCast(*c.git_repository, self),
c_notes,
});
return ret;
}
/// Read the note for an object
///
/// ## Parameters
/// * `oid` - OID of the git object to read the note from
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
pub fn noteRead(self: *Repository, oid: *const git.Oid, notes_ref: ?[:0]const u8) !*git.Note {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("Repository.noteRead called, oid: {s}, notes_ref: {s}", .{ slice, notes_ref });
}
var ret: *git.Note = undefined;
const c_notes = if (notes_ref) |p| p.ptr else null;
try internal.wrapCall("git_note_read", .{
@ptrCast(*?*c.git_note, &ret),
@ptrCast(*c.git_repository, self),
c_notes,
@ptrCast(*const c.git_oid, oid),
});
log.debug("successfully read note: {*}", .{ret});
return ret;
}
/// Read the note for an object
///
/// ## Parameters
/// * `oid` - OID of the git object to read the note from
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
pub fn noteReadFromNoteCommit(self: *Repository, oid: *const git.Oid, note_commit: *git.Commit) !*git.Note {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("Repository.noteReadFromNoteCommit called, oid: {s}, note_commit: {*}", .{ slice, note_commit });
}
var ret: *git.Note = undefined;
try internal.wrapCall("git_note_commit_read", .{
@ptrCast(*?*c.git_note, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_commit, note_commit),
@ptrCast(*const c.git_oid, oid),
});
log.debug("successfully read note: {*}", .{ret});
return ret;
}
/// Add a note for an object
///
/// ## Parameters
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
/// * `author` - Signature of the notes commit author
/// * `commiter` - Signature of the notes commit committer
/// * `oid` - OID of the git object to decorate
/// * `note` - Content of the note to add for object oid
/// * `force` - Overwrite existing note
pub fn noteCreate(
self: *Repository,
notes_ref: ?[:0]const u8,
author: *const git.Signature,
commiter: *const git.Signature,
oid: *const git.Oid,
note: [:0]const u8,
force: bool,
) !git.Oid {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("Repository.noteCreate called, notes_ref: {s}, author: {s}, commiter: {s}, oid: {s}, note: {s}, force: {}", .{
notes_ref,
author.name(),
commiter.name(),
slice,
note,
force,
});
}
var ret: git.Oid = undefined;
const c_notes = if (notes_ref) |p| p.ptr else null;
try internal.wrapCall("git_note_create", .{
@ptrCast(*c.git_oid, &ret),
@ptrCast(*c.git_repository, self),
c_notes,
@ptrCast(*const c.git_signature, author),
@ptrCast(*const c.git_signature, commiter),
@ptrCast(*const c.git_oid, oid),
note.ptr,
@boolToInt(force),
});
log.debug("successfully created note", .{});
return ret;
}
pub const NoteCommitResult = struct {
note_commit: git.Oid,
note_blob: git.Oid,
};
/// Add a note for an object from a commit
///
/// This function will create a notes commit for a given object, the commit is a dangling commit, no reference is created.
///
/// ## Parameters
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
/// * `author` - Signature of the notes commit author
/// * `commiter` - Signature of the notes commit committer
/// * `oid` - OID of the git object to decorate
/// * `note` - Content of the note to add for object oid
/// * `allow_note_overwrite` - Overwrite existing note
pub fn noteCommitCreate(
self: *Repository,
parent: *git.Commit,
author: *const git.Signature,
commiter: *const git.Signature,
oid: *const git.Oid,
note: [:0]const u8,
allow_note_overwrite: bool,
) !NoteCommitResult {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("Repository.noteCommitCreate called, parent: {*}, author: {s}, commiter: {s}, oid: {s}, note: {s}, allow_note_overwrite: {}", .{
parent,
author.name(),
commiter.name(),
slice,
note,
allow_note_overwrite,
});
}
var ret: NoteCommitResult = undefined;
try internal.wrapCall("git_note_commit_create", .{
@ptrCast(*c.git_oid, &ret.note_commit),
@ptrCast(*c.git_oid, &ret.note_blob),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_commit, parent),
@ptrCast(*const c.git_signature, author),
@ptrCast(*const c.git_signature, commiter),
@ptrCast(*const c.git_oid, oid),
note.ptr,
@boolToInt(allow_note_overwrite),
});
log.debug("successfully created note commit", .{});
return ret;
}
/// Remove the note for an object
///
/// ## Parameters
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
/// * `author` - Signature of the notes commit author
/// * `commiter` - Signature of the notes commit committer
/// * `oid` - OID of the git object to remove the note from
pub fn noteRemove(
self: *Repository,
notes_ref: ?[:0]const u8,
author: *const git.Signature,
commiter: *const git.Signature,
oid: *const git.Oid,
) !void {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("Repository.noteRemove called, notes_ref: {s}, author: {s}, commiter: {s}, oid: {s}", .{
notes_ref,
author.name(),
commiter.name(),
slice,
});
}
const c_notes = if (notes_ref) |p| p.ptr else null;
try internal.wrapCall("git_note_remove", .{
@ptrCast(*c.git_repository, self),
c_notes,
@ptrCast(*const c.git_signature, author),
@ptrCast(*const c.git_signature, commiter),
@ptrCast(*const c.git_oid, oid),
});
log.debug("successfully removed note", .{});
}
/// Remove the note for an object
///
/// ## Parameters
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
/// * `author` - Signature of the notes commit author
/// * `commiter` - Signature of the notes commit committer
/// * `oid` - OID of the git object to remove the note from
pub fn noteCommitRemove(
self: *Repository,
note_commit: *git.Commit,
author: *const git.Signature,
commiter: *const git.Signature,
oid: *const git.Oid,
) !git.Oid {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try oid.formatHex(&buf);
log.debug("Repository.noteCommitRemove called, note_commit: {*}, author: {s}, commiter: {s}, oid: {s}", .{
note_commit,
author.name(),
commiter.name(),
slice,
});
}
var ret: git.Oid = undefined;
try internal.wrapCall("git_note_commit_remove", .{
@ptrCast(*c.git_oid, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_commit, note_commit),
@ptrCast(*const c.git_signature, author),
@ptrCast(*const c.git_signature, commiter),
@ptrCast(*const c.git_oid, oid),
});
log.debug("successfully removed note commit", .{});
return ret;
}
/// Get the default notes reference for a repository
pub fn noteDefaultRef(self: *Repository) !git.Buf {
log.debug("Repository.noteDefaultRef called", .{});
var ret: git.Buf = .{};
try internal.wrapCall("git_note_default_ref", .{
@ptrCast(*c.git_buf, &ret),
@ptrCast(*c.git_repository, self),
});
log.debug("default ref: {s}", .{ret.toSlice()});
return ret;
}
/// Loop over all the notes within a specified namespace and issue a callback for each one.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `blob_id` - Oid of the blob containing the message
/// * `annotated_object_id` - Oid of the git object being annotated
pub fn noteForeach(
self: *Repository,
notes_ref: ?[:0]const u8,
comptime callback_fn: fn (
blob_id: *const git.Oid,
annotated_object_id: *const git.Oid,
) c_int,
) !c_int {
const cb = struct {
pub fn cb(
blob_id: *const git.Oid,
annotated_object_id: *const git.Oid,
_: *u8,
) c_int {
return callback_fn(blob_id, annotated_object_id);
}
}.cb;
var dummy_data: u8 = undefined;
return self.noteForeachWithUserData(&dummy_data, notes_ref, cb);
}
/// Loop over all the notes within a specified namespace and issue a callback for each one.
///
/// Return a non-zero value from the callback to stop the loop. This non-zero value is returned by the function.
///
/// ## Parameters
/// * `notes_ref` - Canonical name of the reference to use; if `null` defaults to "refs/notes/commits"
/// * `user_data` - Pointer to user data to be passed to the callback
/// * `callback_fn` - The callback function
///
/// ## Callback Parameters
/// * `blob_id` - Oid of the blob containing the message
/// * `annotated_object_id` - Oid of the git object being annotated
/// * `user_data_ptr` - Pointer to user data
pub fn noteForeachWithUserData(
self: *Repository,
notes_ref: ?[:0]const u8,
user_data: anytype,
comptime callback_fn: fn (
blob_id: *const git.Oid,
annotated_object_id: *const git.Oid,
user_data_ptr: @TypeOf(user_data),
) c_int,
) !c_int {
const UserDataType = @TypeOf(user_data);
const cb = struct {
pub fn cb(
blob_id: *const c.git_oid,
annotated_object_id: *const c.git_oid,
payload: ?*anyopaque,
) callconv(.C) c_int {
return callback_fn(
@ptrCast(*const git.Oid, blob_id),
@ptrCast(*const git.Oid, annotated_object_id),
@ptrCast(UserDataType, payload),
);
}
}.cb;
log.debug("Repository.noteForeachWithUserData called, notes_ref: {s}", .{notes_ref});
const c_notes = if (notes_ref) |p| p.ptr else null;
const ret = try internal.wrapCallWithReturn("git_note_foreach", .{
@ptrCast(*c.git_repository, self),
c_notes,
cb,
user_data,
});
log.debug("callback returned: {}", .{ret});
return ret;
}
/// Lookup a reference to one of the objects in a repository.
///
/// The generated reference is owned by the repository and should be closed with `git.Object.deinit`.
///
/// The 'object_type' parameter must match the type of the object in the odb; the method will fail otherwise.
/// The special value 'git.ObjectType.any' may be passed to let the method guess the object's type.
///
/// ## Parameters
/// * `id` - The unique identifier for the object
/// * `object_type` - The type of the object
pub fn objectLookup(self: *Repository, id: *const git.Oid, object_type: git.ObjectType) !*git.Object {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try id.formatHex(&buf);
log.debug("Repository.objectLookup called, id: {s}, object_type: {}", .{
slice,
object_type,
});
}
var ret: *git.Object = undefined;
try internal.wrapCall("git_object_lookup", .{
@ptrCast(*?*c.git_object, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, id),
@enumToInt(object_type),
});
log.debug("successfully located object: {*}", .{ret});
return ret;
}
/// Lookup a reference to one of the objects in a repository, given a prefix of its identifier (short id).
///
/// The object obtained will be so that its identifier matches the first 'len' hexadecimal characters (packets of 4 bits) of
/// the given 'id'.
/// 'len' must be at least `git.Oid.min_prefix_len`, and long enough to identify a unique object matching/ the prefix;
/// otherwise the method will fail.
///
/// The generated reference is owned by the repository and should be closed with `git.Object.deinit`.
///
/// The 'object_type' parameter must match the type of the object in the odb; the method will fail otherwise.
/// The special value 'git.ObjectType.any' may be passed to let the method guess the object's type.
///
/// ## Parameters
/// * `id` - A short identifier for the object
/// * `len` - The length of the short identifier
/// * `object_type` - The type of the object
pub fn objectLookupPrefix(self: *Repository, id: *const git.Oid, len: usize, object_type: git.ObjectType) !*git.Object {
// This check is to prevent formating the oid when we are not going to print anything
if (@enumToInt(std.log.Level.debug) <= @enumToInt(std.log.level)) {
var buf: [git.Oid.hex_buffer_size]u8 = undefined;
const slice = try id.formatHexCount(&buf, len);
log.debug("Repository.objectLookupPrefix called, id: {s}, object_type: {}", .{
slice,
object_type,
});
}
var ret: *git.Object = undefined;
try internal.wrapCall("git_object_lookup_prefix", .{
@ptrCast(*?*c.git_object, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_oid, id),
len,
@enumToInt(object_type),
});
log.debug("successfully located object: {*}", .{ret});
return ret;
}
/// Initialize a new packbuilder
pub fn packbuilderNew(self: *Repository) !*git.PackBuilder {
log.debug("Repository.packbuilderNew called", .{});
var ret: *git.PackBuilder = undefined;
try internal.wrapCall("git_packbuilder_new", .{
@ptrCast(*?*c.git_packbuilder, &ret),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully created a new packbuilder: {*}", .{ret});
return ret;
}
/// Add a remote with the default fetch refspec to the repository's configuration.
///
/// ## Parameters
/// * `name` - The remote's name.
/// * `url` - The remote's url.
pub fn remoteCreate(self: *Repository, name: [:0]const u8, url: [:0]const u8) !*git.Remote {
log.debug("Repository.remoteCreate called, name: {s}, url: {s}", .{ name, url });
var remote: *git.Remote = undefined;
try internal.wrapCall("git_remote_create", .{
@ptrCast(*?*c.git_remote, &remote),
@ptrCast(*c.git_repository, self),
name.ptr,
url.ptr,
});
log.debug("successfully created remote", .{});
return remote;
}
/// Add a remote with the provided refspec (or default if `null`) to the repository's configuration.
///
/// ## Parameters
/// * `name` - The remote's name.
/// * `url` - The remote's url.
/// * `fetch` - The remote fetch value.
pub fn remoteCreateWithFetchspec(
repository: *Repository,
name: [:0]const u8,
url: [:0]const u8,
fetch: ?[:0]const u8,
) !*git.Remote {
log.debug("Repository.remoteCreateWithFetchspec called, name: {s}, url: {s}, fetch: {s}", .{ name, url, fetch });
var remote: *git.Remote = undefined;
const c_fetch = if (fetch) |s| s.ptr else null;
try internal.wrapCall("git_remote_create_with_fetchspec", .{
@ptrCast(*?*c.git_remote, &remote),
@ptrCast(*c.git_repository, repository),
name.ptr,
url.ptr,
c_fetch,
});
log.debug("successfully created remote: {*}", .{remote});
return remote;
}
/// Create a remote with the given url in-memory. You can use this when you have a url instead of a remote's name.
///
/// ## Parameters
/// * `name` - The remote's name.
/// * `url` - The remote's url.
pub fn remoteCreateAnonymous(repository: *Repository, url: [:0]const u8) !*git.Remote {
log.debug("Repository.remoteCreateAnonymous called, url: {s}", .{url});
var remote: *git.Remote = undefined;
try internal.wrapCall("git_remote_create_anonymous", .{
@ptrCast(*?*c.git_remote, &remote),
@ptrCast(*c.git_repository, repository),
url.ptr,
});
log.debug("successfully created remote: {*}", .{remote});
return remote;
}
/// Get the information for a particular remote.
///
/// ## Parameters
/// * `name` - The remote's name
pub fn remoteLookup(repository: *Repository, name: [:0]const u8) !*git.Remote {
log.debug("Repository.remoteLookup called, name=\"{s}\"", .{name});
var remote: *git.Remote = undefined;
try internal.wrapCall("git_remote_lookup", .{
@ptrCast(*?*c.git_remote, &remote),
@ptrCast(*c.git_repository, repository),
name.ptr,
});
log.debug("successfully found remote: {*}", .{remote});
return remote;
}
/// Set the remote's url in the configuration
///
/// Remote objects already in memory will not be affected. This assumes the common case of a single-url remote and will
/// otherwise return an error.
///
/// ## Parameters
/// * `remote` - The remote's name.
/// * `url` - The url to set.
pub fn remoteSetUrl(repository: *Repository, remote: [:0]const u8, url: [:0]const u8) !void {
log.debug("Repository.remoteSetUrl called, remote: {s}, url: {s}", .{ remote, url });
try internal.wrapCall("git_remote_set_url", .{
@ptrCast(*c.git_repository, repository),
remote.ptr,
url.ptr,
});
log.debug("successfully set url", .{});
}
/// Set the remote's url for pushing in the configuration.
///
/// Remote objects already in memory will not be affected. This assumes the common case of a single-url remote and will
/// otherwise return an error.
///
/// ## Parameters
/// * `remote` - The remote's name.
/// * `url` - The url to set.
pub fn remoteSetPushurl(repository: *Repository, remote: [:0]const u8, url: [:0]const u8) !void {
log.debug("Repository.remoteSetPushurl called, remote: {s}, url: {s}", .{ remote, url });
try internal.wrapCall("git_remote_set_pushurl", .{
@ptrCast(*c.git_repository, repository),
remote.ptr,
url.ptr,
});
log.debug("successfully set pushurl", .{});
}
/// Add a fetch refspec to the remote's configuration.
///
/// Add the given refspec to the fetch list in the configuration. No loaded remote instances will be affected.
///
/// ## Parameters
/// * `remote` - Name of the remote to change.
/// * `refspec` - The new fetch refspec.
pub fn remoteAddFetch(repository: *Repository, remote: [:0]const u8, refspec: [:0]const u8) !void {
log.debug("Repository.remoteAddFetch called, remote: {s}, refspec: {s}", .{ remote, refspec });
try internal.wrapCall("git_remote_add_fetch", .{
@ptrCast(*c.git_repository, repository),
remote.ptr,
refspec.ptr,
});
log.debug("successfully added fetch", .{});
}
/// Add a pull refspec to the remote's configuration.
///
/// Add the given refspec to the push list in the configuration. No loaded remote instances will be affected.
///
/// ## Parameters
/// * `remote` - Name of the remote to change.
/// * `refspec` - The new push refspec.
pub fn remoteAddPush(repository: *Repository, remote: [:0]const u8, refspec: [:0]const u8) !void {
log.debug("Repository.remoteAddPush called, remote: {s}, refspecs: {s}", .{ remote, refspec });
try internal.wrapCall("git_remote_add_push", .{
@ptrCast(*c.git_repository, repository),
remote.ptr,
refspec.ptr,
});
log.debug("successfully added push", .{});
}
/// Get a list of the configured remotes for a repo
///
/// The returned array must be deinit by user.
pub fn remoteList(self: *Repository) !git.StrArray {
log.debug("Repository.remoteList called", .{});
var str: git.StrArray = .{};
try internal.wrapCall("git_remote_list", .{
@ptrCast(*c.git_strarray, &str),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully got remotes list", .{});
return str;
}
/// Set the remote's tag following setting.
///
/// The change will be made in the configuration. No loaded remotes will be affected.
///
/// ## Parameters
/// * `remote` - The name of the remote.
/// * `value` - The new value to take.
pub fn remoteSetAutotag(self: *Repository, remote: [:0]const u8, value: git.RemoteAutoTagOption) !void {
log.debug("Remote.setAutotag called, remote: {s}, value: {}", .{ remote, value });
try internal.wrapCall("git_remote_set_autotag", .{
@ptrCast(*c.git_repository, self),
remote.ptr,
@enumToInt(value),
});
log.debug("successfully set autotag", .{});
}
/// Give the remote a new name
///
/// All remote-tracking branches and configuration settings for the remote are updated.
///
/// TODO: Fix `git_tag_create()` once tag.h has been done
/// The new name will be checked for validity. See git_tag_create() for rules about valid names.
///
/// No loaded instances of a the remote with the old name will change their name or their list of refspecs.
///
/// Non-default refspecs cannot be renamed and will be returned for further processing by the caller.
/// Always free the returned `git.StrArray`.
///
/// ## Problems
/// * `name` - The current name of the remote
/// * `new_name` - The new name the remote should bear
pub fn remoteRename(self: *Repository, name: [:0]const u8, new_name: [:0]const u8) !git.StrArray {
log.debug("Repository.remoteRename called, name: {s}, new_name: {s}", .{ name, new_name });
var problems: git.StrArray = .{};
try internal.wrapCall("git_remote_rename", .{
@ptrCast(*c.git_strarray, &problems),
@ptrCast(*c.git_repository, self),
name.ptr,
new_name.ptr,
});
log.debug("successfully renamed remote", .{});
return problems;
}
/// Delete an existing persisted remote.
///
/// All remote-tracking branches and configuration settings for the remote will be removed.
///
/// ## Parameters
/// * `name` - The remote to delete
pub fn remoteDelete(self: *Repository, name: [:0]const u8) !void {
log.debug("Repository.remoteDelete called, name: {s}", .{name});
try internal.wrapCall("git_remote_delete", .{
@ptrCast(*c.git_repository, self),
name.ptr,
});
log.debug("successfully deleted remote", .{});
}
/// Match a pathspec against the working directory of a repository.
///
/// This matches the pathspec against the current files in the working directory of the repository. It is an error to invoke
/// this on a bare repo. This handles git ignores (i.e. ignored files will not be considered to match the `pathspec` unless
/// the file is tracked in the index).
///
/// If `match_list` is not `null`, this returns a `git.PathspecMatchList`. That contains the list of all matched filenames
/// (unless you pass the `MatchOptions.failures_only` options) and may also contain the list of pathspecs with no match (if
/// you used the `MatchOptions.find_failures` option).
/// You must call `PathspecMatchList.deinit()` on this object.
///
/// ## Parameters
/// * `pathspec` - Pathspec to be matched
/// * `options` - Options to control match
/// * `match_list` - Output list of matches; pass `null` to just get return value
pub fn pathspecMatchWorkdir(
self: *Repository,
pathspec: *git.Pathspec,
options: git.PathspecMatchOptions,
match_list: ?**git.PathspecMatchList,
) !bool {
log.debug("Repository.pathspecMatchWorkdir called, options: {}, pathspec: {*}", .{ options, pathspec });
const ret = (try internal.wrapCallWithReturn("git_pathspec_match_workdir", .{
@ptrCast(?*?*c.git_pathspec_match_list, match_list),
@ptrCast(*c.git_repository, self),
@bitCast(c.git_pathspec_flag_t, options),
@ptrCast(*c.git_pathspec, pathspec),
})) != 0;
log.debug("match: {}", .{ret});
return ret;
}
/// Find a single object, as specified by a revision string.
///
/// See `man gitrevisions`, or http://git-scm.com/docs/git-rev-parse.html#_specifying_revisions for information on the syntax
/// accepted.
///
/// The returned object should be released with `Object.deinit()` when no longer needed.
///
/// ## Parameters
/// * `spec` - The textual specification for an object
pub fn revisionParseSingle(self: *Repository, spec: [:0]const u8) !*git.Object {
log.debug("Repository.revisionParseSingle called, spec: {s}", .{spec});
var ret: *git.Object = undefined;
try internal.wrapCall("git_revparse_single", .{
@ptrCast(*?*c.git_object, &ret),
@ptrCast(*c.git_repository, self),
spec.ptr,
});
log.debug("successfully found object: {*}", .{ret});
return ret;
}
/// Find a single object and intermediate reference by a revision string.
///
/// See `man gitrevisions`, or http://git-scm.com/docs/git-rev-parse.html#_specifying_revisions for information on the syntax
/// accepted.
///
/// In some cases (`@{<-n>}` or `<branchname>@{upstream}`), the expression may point to an intermediate reference. When such
//// expressions are being passed in, `reference` will be valued as well.
///
/// The returned object should be released with `Object.deinit()` when no longer needed.
///
/// ## Parameters
/// * `reference` - Pointer to output reference or `null`
/// * `spec` - The textual specification for an object
pub fn revisionParseExtended(
self: *Repository,
reference: ?**git.Reference,
spec: [:0]const u8,
) !*git.Object {
log.debug("Repository.revisionParseExtended called, reference: {*}, spec: {s}", .{ reference, spec });
var ret: *git.Object = undefined;
try internal.wrapCall("git_revparse_ext", .{
@ptrCast(*?*c.git_object, &ret),
@ptrCast(?*?*c.git_reference, reference),
@ptrCast(*c.git_repository, self),
spec.ptr,
});
log.debug("successfully found object: {*}", .{ret});
return ret;
}
/// Parse a revision string for `from`, `to`, and intent.
///
/// See `man gitrevisions`, or http://git-scm.com/docs/git-rev-parse.html#_specifying_revisions for information on the syntax
/// accepted.
///
/// The returned `RevSpec` contains two `git.Object`'s that should be freed by the user.
///
/// ## Parameters
/// * `spec` - The rev-parse spec to parse
pub fn revisionParse(self: *Repository, spec: [:0]const u8) !RevSpec {
log.debug("Repository.revisionParse called, spec: {s}", .{spec});
var ret: RevSpec = undefined;
try internal.wrapCall("git_revparse", .{
@ptrCast(*c.git_revspec, &ret),
@ptrCast(*c.git_repository, self),
spec.ptr,
});
log.debug("successfully parsed revision string", .{});
return ret;
}
/// Read the reflog for the given reference
///
/// If there is no reflog file for the given reference yet, an empty reflog object will be returned.
///
/// ## Parameters
/// * `name` - Reference to look up
pub fn reflogRead(self: *Repository, name: [:0]const u8) !*git.Reflog {
log.debug("Repository.reflogRead called, name: {s}", .{name});
var ret: *git.Reflog = undefined;
try internal.wrapCall("git_reflog_read", .{
@ptrCast(*?*c.git_reflog, &ret),
@ptrCast(*c.git_repository, self),
name.ptr,
});
log.debug("successfully read reflog: {*}", .{ret});
return ret;
}
/// Rename a reflog
///
/// The reflog to be renamed is expected to already exist
///
/// The new name will be checked for validity. `Repository.referenceSymbolicCreate()` for rules about valid names.
///
/// ## Parameters
/// * `old_name` - The old name of the reference
/// * `name` - The new name of the reference
pub fn reflogRename(self: *Repository, old_name: [:0]const u8, name: [:0]const u8) !void {
log.debug("Repository.reflogRename called, old_name: {s}, name: {s}", .{ old_name, name });
try internal.wrapCall("git_reflog_rename", .{
@ptrCast(*c.git_repository, self),
old_name.ptr,
name.ptr,
});
log.debug("successfully renamed reflog", .{});
}
/// Delete the reflog for the given reference
///
/// ## Parameters
/// * `name` - The reflog to delete
pub fn reflogDelete(self: *Repository, name: [:0]const u8) !void {
log.debug("Repository.reflogDelete called, name: {s}", .{name});
try internal.wrapCall("git_reflog_delete", .{
@ptrCast(*c.git_repository, self),
name.ptr,
});
log.debug("successfully deleted reflog", .{});
}
/// Create a new reference database with no backends.
///
/// Before the Ref DB can be used for read/writing, a custom database backend must be manually set using `Refdb.setBackend()`
pub fn refdbNew(self: *Repository) !*git.Refdb {
log.debug("Repository.refdbNew called", .{});
var ret: *git.Refdb = undefined;
try internal.wrapCall("git_refdb_new", .{
@ptrCast(*?*c.git_refdb, &ret),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully created refdb: {*}", .{ret});
return ret;
}
/// Create a new reference database and automatically add the default backends:
///
/// * git_refdb_dir: read and write loose and packed refs from disk, assuming the repository dir as the folder
pub fn refdbOpen(self: *Repository) !*git.Refdb {
log.debug("Repository.refdbOpen called", .{});
var ret: *git.Refdb = undefined;
try internal.wrapCall("git_refdb_open", .{
@ptrCast(*?*c.git_refdb, &ret),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully opened refdb: {*}", .{ret});
return ret;
}
/// Reverts the given commit against the given "our" commit, producing an index that reflects the result of the revert.
///
/// ## Parameters
/// * `revert_commit` - The commit to revert
/// * `our_commit` - The commit to revert against (eg, HEAD)
/// * `mainline` - The parent of the revert commit, if it is a merge
/// * `merge_options` - The merge options
pub fn revertCommit(
self: *Repository,
revert_commit: *git.Commit,
our_commit: *git.Commit,
mainline: bool,
merge_options: git.MergeOptions,
) !*git.Index {
log.debug("Repository.revertCommit called, revert_commit: {*}, our_commit: {*}, mainline: {}, merge_options: {}", .{
revert_commit,
our_commit,
mainline,
merge_options,
});
const c_options = internal.make_c_option.mergeOptions(merge_options);
var ret: *git.Index = undefined;
try internal.wrapCall("git_revert_commit", .{
@ptrCast(*?*c.git_index, &ret),
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_commit, revert_commit),
@ptrCast(*c.git_commit, our_commit),
@boolToInt(mainline),
&c_options,
});
log.debug("successfully reverted commit", .{});
return ret;
}
/// Reverts the given commit, producing changes in the index and working directory.
///
/// ## Parameters
/// * `commit` - The commit to revert
/// * `options` - The revert options
pub fn revert(self: *Repository, commit: *git.Commit, options: git.RevertOptions) !void {
log.debug("Repository.revert called, commit: {*}, options: {}", .{
commit,
options,
});
const c_options = internal.make_c_option.revertOptions(options);
try internal.wrapCall("git_revert", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*c.git_commit, commit),
&c_options,
});
log.debug("successfully reverted commit", .{});
}
/// Create a new action signature with default user and now timestamp.
///
/// This looks up the user.name and user.email from the configuration and uses the current time as the timestamp, and creates
/// a new signature based on that information.
/// It will return `GitError.NotFound` if either the user.name or user.email are not set.
///
/// ## Parameters
/// * `name` - Name of the person
/// * `email` - Email of the person
pub fn signatureInitDefault(self: *git.Repository) !*git.Signature {
log.debug("Repository.signatureInitDefault called", .{});
var ret: *git.Signature = undefined;
try internal.wrapCall("git_signature_default", .{
@ptrCast(*?*c.git_signature, &ret),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully initalized signature: {*}", .{ret});
return ret;
}
/// Sets the current head to the specified commit oid and optionally resets the index and working tree to match.
///
/// `ResetType.soft` reset means the Head will be moved to the commit.
///
/// `ResetType.mixed` reset will trigger a SOFT reset, plus the index will be replaced with the content of the commit tree.
///
/// `ResetType.hard` reset will trigger a MIXED reset and the working directory will be replaced with the content of the index.
/// (Untracked and ignored files will be left alone, however.)
///
/// ## Parameters
/// * `target` - Committish to which the Head should be moved to. This object must belong to the given `repo` and can either
/// be a commit or a tag. When a tag is being passed, it should be dereferencable to a commit which oid will be
/// used as the target of the branch.
/// * `reset_type` - Kind of reset operation to perform.
/// * `checkout_options` - Checkout options to be used for a HARD reset. The checkout_strategy field will be overridden
/// (based on reset_type). This parameter can be used to propagate notify and progress callbacks.
pub fn reset(self: *Repository, target: *const git.Object, reset_type: ResetType, checkout_options: CheckoutOptions) !void {
log.debug("Repository.reset called, target={*}, reset_type={}, checkout_options={}", .{
target,
reset_type,
checkout_options,
});
const c_options = internal.make_c_option.checkoutOptions(checkout_options);
try internal.wrapCall("git_reset", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_object, self),
@enumToInt(reset_type),
&c_options,
});
log.debug("successfully reset", .{});
}
/// Sets the current head to the specified commit oid and optionally resets the index and working tree to match.
///
/// This behaves like `Repository.reset` but takes an annotated commit, which lets you specify which extended sha syntax
/// string was specified by a user, allowing for more exact reflog messages.
///
/// ## Parameters
/// * `commit` - Target annotated commit
/// * `reset_type` - Kind of reset operation to perform.
/// * `checkout_options` - Checkout options to be used for a HARD reset. The checkout_strategy field will be overridden
/// (based on reset_type). This parameter can be used to propagate notify and progress callbacks.
pub fn resetFromAnnotated(
self: *Repository,
commit: *const git.AnnotatedCommit,
reset_type: ResetType,
checkout_options: CheckoutOptions,
) !void {
log.debug("Repository.resetFromAnnotated called, commit={*}, reset_type={}, checkout_options={}", .{
commit,
reset_type,
checkout_options,
});
const c_options = internal.make_c_option.checkoutOptions(checkout_options);
try internal.wrapCall("git_reset_from_annotated", .{
@ptrCast(*c.git_repository, self),
@ptrCast(*const c.git_annotated_commit, self),
@enumToInt(reset_type),
&c_options,
});
log.debug("successfully reset", .{});
}
/// Updates some entries in the index from the target commit tree.
///
/// The scope of the updated entries is determined by the paths being passed in the `pathspec` parameters.
///
/// Passing a `null` `target` will result in removing entries in the index matching the provided pathspecs.
///
/// ## Parameters
/// * `target` - The committish which content will be used to reset the content of the index.
/// * `pathspecs` - List of pathspecs to operate on.
pub fn resetDefault(self: *Repository, target: ?*const git.Object, pathspecs: git.StrArray) !void {
log.debug("Repository.resetDefault called, target={*}", .{target});
try internal.wrapCall("git_reset_default", .{
@ptrCast(*c.git_repository, self),
@ptrCast(?*const c.git_object, self),
@ptrCast(*const c.git_strarray, &pathspecs),
});
log.debug("successfully reset", .{});
}
/// Create a new transaction object
///
/// This does not lock anything, but sets up the transaction object to know from which repository to lock.
pub fn transactionInit(self: *Repository) !*git.Transaction {
log.debug("Repository.transactionInit called", .{});
var ret: *git.Transaction = undefined;
try internal.wrapCall("git_transaction_new", .{
@ptrCast(*?*c.git_transaction, &ret),
@ptrCast(*c.git_repository, self),
});
log.debug("successfully initalized transaction: {*}", .{ret});
return ret;
}
comptime {
std.testing.refAllDecls(@This());
}
};
/// Kinds of reset operation
pub const ResetType = enum(c_uint) {
/// Move the head to the given commit
soft = 1,
/// `soft` plus reset index to the commit
mixed = 2,
/// `mixed` plus changes in working tree discarded
hard = 3,
};
pub const RepositoryInitOptions = struct {
flags: RepositoryInitExtendedFlags = .{},
mode: InitMode = .shared_umask,
/// The path to the working dir or `null` for default (i.e. repo_path parent on non-bare repos).
/// *NOTE*: if this is a relative path, it must be relative to the repository path.
/// If this is not the "natural" working directory, a .git gitlink file will be created linking to the repository path.
workdir_path: ?[:0]const u8 = null,
/// A "description" file to be used in the repository, instead of using the template content.
description: ?[:0]const u8 = null,
/// When `RepositoryInitExtendedFlags.external_template` is set, this must contain the path to use for the template
/// directory. If this is `null`, the config or default directory options will be used instead.
template_path: ?[:0]const u8 = null,
/// The name of the head to point HEAD at. If `null`, then this will be treated as "master" and the HEAD ref will be set
/// to "refs/heads/master".
/// If this begins with "refs/" it will be used verbatim; otherwise "refs/heads/" will be prefixed.
initial_head: ?[:0]const u8 = null,
/// If this is non-`null`, then after the rest of the repository initialization is completed, an "origin" remote will be
/// added pointing to this URL.
origin_url: ?[:0]const u8 = null,
pub const RepositoryInitExtendedFlags = packed struct {
/// Create a bare repository with no working directory.
bare: bool = false,
/// Return an `GitError.EXISTS` error if the path appears to already be an git repository.
no_reinit: bool = false,
/// Normally a "/.git/" will be appended to the repo path for non-bare repos (if it is not already there), but passing
/// this flag prevents that behavior.
no_dotgit_dir: bool = false,
/// Make the repo_path (and workdir_path) as needed. Init is always willing to create the ".git" directory even
/// without this flag. This flag tells init to create the trailing component of the repo and workdir paths as needed.
mkdir: bool = false,
/// Recursively make all components of the repo and workdir paths as necessary.
mkpath: bool = false,
/// libgit2 normally uses internal templates to initialize a new repo.
/// This flag enables external templates, looking at the "template_path" from the options if set, or the
/// `init.templatedir` global config if not, or falling back on "/usr/share/git-core/templates" if it exists.
external_template: bool = false,
/// If an alternate workdir is specified, use relative paths for the gitdir and core.worktree.
relative_gitlink: bool = false,
z_padding: std.meta.Int(.unsigned, @bitSizeOf(c_uint) - 7) = 0,
pub fn toInt(self: RepositoryInitExtendedFlags) c_uint {
return @bitCast(c_uint, self);
}
pub fn format(
value: RepositoryInitExtendedFlags,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
_ = fmt;
return internal.formatWithoutFields(
value,
options,
writer,
&.{"z_padding"},
);
}
test {
try std.testing.expectEqual(@sizeOf(c_uint), @sizeOf(RepositoryInitExtendedFlags));
try std.testing.expectEqual(@bitSizeOf(c_uint), @bitSizeOf(RepositoryInitExtendedFlags));
}
comptime {
std.testing.refAllDecls(@This());
}
};
pub const InitMode = union(enum) {
/// Use permissions configured by umask - the default.
shared_umask: void,
/// Use "--shared=group" behavior, chmod'ing the new repo to be group writable and "g+sx" for sticky group assignment.
shared_group: void,
/// Use "--shared=all" behavior, adding world readability.
shared_all: void,
custom: c_uint,
pub fn toInt(self: InitMode) c_uint {
return switch (self) {
.shared_umask => 0,
.shared_group => 0o2775,
.shared_all => 0o2777,
.custom => |custom| custom,
};
}
};
comptime {
std.testing.refAllDecls(@This());
}
};
pub const FileStatusOptions = struct {
/// which files to scan
show: Show = .index_and_workdir,
/// Flags to control status callbacks
flags: Flags = .{},
/// The `pathspec` is an array of path patterns to match (using fnmatch-style matching), or just an array of paths to
/// match exactly if `Flags.disable_pathspec_match` is specified in the flags.
pathspec: git.StrArray = .{},
/// The `baseline` is the tree to be used for comparison to the working directory and index; defaults to HEAD.
baseline: ?*git.Tree = null,
/// Select the files on which to report status.
pub const Show = enum(c_uint) {
/// The default. This roughly matches `git status --porcelain` regarding which files are included and in what order.
index_and_workdir,
/// Only gives status based on HEAD to index comparison, not looking at working directory changes.
index_only,
/// Only gives status based on index to working directory comparison, not comparing the index to the HEAD.
workdir_only,
};
/// Flags to control status callbacks
///
/// Calling `Repository.forEachFileStatus` is like calling the extended version with: `include_ignored`,
/// `include_untracked`, and `recurse_untracked_dirs`. Those options are provided as `Options.Defaults`.
pub const Flags = packed struct {
/// Says that callbacks should be made on untracked files.
/// These will only be made if the workdir files are included in the status
/// "show" option.
include_untracked: bool = true,
/// Says that ignored files get callbacks.
/// Again, these callbacks will only be made if the workdir files are
/// included in the status "show" option.
include_ignored: bool = true,
/// Indicates that callback should be made even on unmodified files.
include_unmodified: bool = false,
/// Indicates that submodules should be skipped.
/// This only applies if there are no pending typechanges to the submodule
/// (either from or to another type).
exclude_submodules: bool = false,
/// Indicates that all files in untracked directories should be included.
/// Normally if an entire directory is new, then just the top-level
/// directory is included (with a trailing slash on the entry name).
/// This flag says to include all of the individual files in the directory
/// instead.
recurse_untracked_dirs: bool = true,
/// Indicates that the given path should be treated as a literal path,
/// and not as a pathspec pattern.
disable_pathspec_match: bool = false,
/// Indicates that the contents of ignored directories should be included
/// in the status. This is like doing `git ls-files -o -i --exclude-standard`
/// with core git.
recurse_ignored_dirs: bool = false,
/// Indicates that rename detection should be processed between the head and
/// the index and enables the GIT_STATUS_INDEX_RENAMED as a possible status
/// flag.
renames_head_to_index: bool = false,
/// Indicates that rename detection should be run between the index and the
/// working directory and enabled GIT_STATUS_WT_RENAMED as a possible status
/// flag.
renames_index_to_workdir: bool = false,
/// Overrides the native case sensitivity for the file system and forces
/// the output to be in case-sensitive order.
sort_case_sensitively: bool = false,
/// Overrides the native case sensitivity for the file system and forces
/// the output to be in case-insensitive order.
sort_case_insensitively: bool = false,
/// Iindicates that rename detection should include rewritten files.
renames_from_rewrites: bool = false,
/// Bypasses the default status behavior of doing a "soft" index reload
/// (i.e. reloading the index data if the file on disk has been modified
/// outside libgit2).
no_refresh: bool = false,
/// Tells libgit2 to refresh the stat cache in the index for files that are
/// unchanged but have out of date stat einformation in the index.
/// It will result in less work being done on subsequent calls to get status.
/// This is mutually exclusive with the no_refresh option.
update_index: bool = false,
/// Normally files that cannot be opened or read are ignored as
/// these are often transient files; this option will return
/// unreadable files as `GIT_STATUS_WT_UNREADABLE`.
include_unreadable: bool = false,
/// Unreadable files will be detected and given the status
/// untracked instead of unreadable.
include_unreadable_as_untracked: bool = false,
z_padding: u16 = 0,
pub fn format(
value: Flags,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
_ = fmt;
return internal.formatWithoutFields(
value,
options,
writer,
&.{"z_padding"},
);
}
test {
try std.testing.expectEqual(@sizeOf(c_uint), @sizeOf(Flags));
try std.testing.expectEqual(@bitSizeOf(c_uint), @bitSizeOf(Flags));
}
comptime {
std.testing.refAllDecls(@This());
}
};
comptime {
std.testing.refAllDecls(@This());
}
};
pub const RepositoryOpenOptions = packed struct {
/// Only open the repository if it can be immediately found in the path. Do not walk up the directory tree to look for it.
no_search: bool = false,
/// Unless this flag is set, open will not search across filesystem boundaries.
cross_fs: bool = false,
/// Open repository as a bare repo regardless of core.bare config.
bare: bool = false,
/// Do not check for a repository by appending /.git to the path; only open the repository if path itself points to the
/// git directory.
no_dotgit: bool = false,
/// Find and open a git repository, respecting the environment variables used by the git command-line tools. If set,
/// `Handle.repositoryOpenExtended` will ignore the other flags and the `ceiling_dirs` argument, and will allow a `null`
/// `path` to use `GIT_DIR` or search from the current directory.
open_from_env: bool = false,
z_padding: std.meta.Int(.unsigned, @bitSizeOf(c_uint) - 5) = 0,
pub fn toInt(self: RepositoryOpenOptions) c_uint {
return @bitCast(c_uint, self);
}
pub fn format(
value: RepositoryOpenOptions,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
_ = fmt;
return internal.formatWithoutFields(
value,
options,
writer,
&.{"z_padding"},
);
}
test {
try std.testing.expectEqual(@sizeOf(c_uint), @sizeOf(RepositoryOpenOptions));
try std.testing.expectEqual(@bitSizeOf(c_uint), @bitSizeOf(RepositoryOpenOptions));
}
comptime {
std.testing.refAllDecls(@This());
}
};
/// Valid modes for index and tree entries.
pub const FileMode = enum(u16) {
unreadable = 0o000000,
tree = 0o040000,
blob = 0o100644,
blob_executable = 0o100755,
link = 0o120000,
commit = 0o160000,
};
pub const FileStatus = packed struct {
current: bool = false,
index_new: bool = false,
index_modified: bool = false,
index_deleted: bool = false,
index_renamed: bool = false,
index_typechange: bool = false,
wt_new: bool = false,
wt_modified: bool = false,
wt_deleted: bool = false,
wt_typechange: bool = false,
wt_renamed: bool = false,
wt_unreadable: bool = false,
ignored: bool = false,
conflicted: bool = false,
z_padding1: u2 = 0,
z_padding2: u16 = 0,
pub fn format(
value: FileStatus,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
_ = fmt;
return internal.formatWithoutFields(
value,
options,
writer,
&.{ "z_padding1", "z_padding2" },
);
}
test {
try std.testing.expectEqual(@sizeOf(c_uint), @sizeOf(FileStatus));
try std.testing.expectEqual(@bitSizeOf(c_uint), @bitSizeOf(FileStatus));
}
comptime {
std.testing.refAllDecls(@This());
}
};
pub const RevSpec = extern struct {
/// The left element of the revspec; must be freed by the user
from: ?*git.Object,
/// The right element of the revspec; must be freed by the user
to: ?*git.Object,
/// The intent of the revspec
flags: RevSpecFlags,
pub const RevSpecFlags = packed struct {
/// The spec targeted a single object.
single: bool = false,
/// The spec targeted a range of commits.
range: bool = false,
/// The spec used the '...' operator, which invokes special semantics.
merge_base: bool = false,
z_padding: u29 = 0,
pub fn format(
value: RevSpecFlags,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
_ = fmt;
return internal.formatWithoutFields(
value,
options,
writer,
&.{"z_padding"},
);
}
test {
try std.testing.expectEqual(@sizeOf(c.git_revspec_t), @sizeOf(RevSpecFlags));
try std.testing.expectEqual(@bitSizeOf(c.git_revspec_t), @bitSizeOf(RevSpecFlags));
}
comptime {
std.testing.refAllDecls(@This());
}
};
test {
try std.testing.expectEqual(@sizeOf(c.git_revspec), @sizeOf(RevSpec));
try std.testing.expectEqual(@bitSizeOf(c.git_revspec), @bitSizeOf(RevSpec));
}
comptime {
std.testing.refAllDecls(@This());
}
};
pub const CheckoutOptions = struct {
/// default will be a safe checkout
checkout_strategy: Strategy = .{
.safe = true,
},
/// don't apply filters like CRLF conversion
disable_filters: bool = false,
/// default is 0o755
dir_mode: c_uint = 0,
/// default is 0o644 or 0o755 as dictated by blob
file_mode: c_uint = 0,
/// default is O_CREAT | O_TRUNC | O_WRONLY
file_open_flags: c_int = 0,
/// Optional callback to get notifications on specific file states.
notify_flags: Notification = .{},
/// Optional callback to get notifications on specific file states.
notify_cb: ?fn (
why: Notification,
path: [*:0]const u8,
baseline: *git.DiffFile,
target: *git.DiffFile,
workdir: *git.DiffFile,
payload: ?*anyopaque,
) callconv(.C) c_int = null,
/// Payload passed to notify_cb
notify_payload: ?*anyopaque = null,
/// Optional callback to notify the consumer of checkout progress
progress_cb: ?fn (
path: [*:0]const u8,
completed_steps: usize,
total_steps: usize,
payload: ?*anyopaque,
) callconv(.C) void = null,
/// Payload passed to progress_cb
progress_payload: ?*anyopaque = null,
/// A list of wildmatch patterns or paths.
///
/// By default, all paths are processed. If you pass an array of wildmatch patterns, those will be used to filter which
/// paths should be taken into account.
///
/// Use GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH to treat as a simple list.
paths: git.StrArray = .{},
/// The expected content of the working directory; defaults to HEAD.
///
/// If the working directory does not match this baseline information, that will produce a checkout conflict.
baseline: ?*git.Tree = null,
/// Like `baseline` above, though expressed as an index. This option overrides `baseline`.
baseline_index: ?*git.Index = null,
/// alternative checkout path to workdir
target_directory: ?[:0]const u8 = null,
/// the name of the common ancestor side of conflicts
ancestor_label: ?[:0]const u8 = null,
/// the name of the "our" side of conflicts
our_label: ?[:0]const u8 = null,
/// the name of the "their" side of conflicts
their_label: ?[:0]const u8 = null,
/// Optional callback to notify the consumer of performance data.
perfdata_cb: ?fn (perfdata: *const PerfData, payload: *anyopaque) callconv(.C) void = null,
/// Payload passed to perfdata_cb
perfdata_payload: ?*anyopaque = null,
pub const PerfData = extern struct {
mkdir_calls: usize,
stat_calls: usize,
chmod_calls: usize,
test {
try std.testing.expectEqual(@sizeOf(c.git_checkout_perfdata), @sizeOf(PerfData));
try std.testing.expectEqual(@bitSizeOf(c.git_checkout_perfdata), @bitSizeOf(PerfData));
}
comptime {
std.testing.refAllDecls(@This());
}
};
pub const Strategy = packed struct {
/// Allow safe updates that cannot overwrite uncommitted data.
/// If the uncommitted changes don't conflict with the checked out files,
/// the checkout will still proceed, leaving the changes intact.
///
/// Mutually exclusive with force.
/// force takes precedence over safe.
safe: bool = false,
/// Allow all updates to force working directory to look like index.
///
/// Mutually exclusive with safe.
/// force takes precedence over safe.
force: bool = false,
/// Allow checkout to recreate missing files
recreate_missing: bool = false,
z_padding: bool = false,
/// Allow checkout to make safe updates even if conflicts are found
allow_conflicts: bool = false,
/// Remove untracked files not in index (that are not ignored)
remove_untracked: bool = false,
/// Remove ignored files not in index
remove_ignored: bool = false,
/// Only update existing files, don't create new ones
update_only: bool = false,
/// Normally checkout updates index entries as it goes; this stops that.
/// Implies `dont_write_index`.
dont_update_index: bool = false,
/// Don't refresh index/config/etc before doing checkout
no_refresh: bool = false,
/// Allow checkout to skip unmerged files
skip_unmerged: bool = false,
/// For unmerged files, checkout stage 2 from index
use_ours: bool = false,
/// For unmerged files, checkout stage 3 from index
use_theirs: bool = false,
/// Treat pathspec as simple list of exact match file paths
disable_pathspec_match: bool = false,
z_padding2: u2 = 0,
/// Recursively checkout submodules with same options (NOT IMPLEMENTED)
update_submodules: bool = false,
/// Recursively checkout submodules if HEAD moved in super repo (NOT IMPLEMENTED)
update_submodules_if_changed: bool = false,
/// Ignore directories in use, they will be left empty
skip_locked_directories: bool = false,
/// Don't overwrite ignored files that exist in the checkout target
dont_overwrite_ignored: bool = false,
/// Write normal merge files for conflicts
conflict_style_merge: bool = false,
/// Include common ancestor data in diff3 format files for conflicts
conflict_style_diff3: bool = false,
/// Don't overwrite existing files or folders
dont_remove_existing: bool = false,
/// Normally checkout writes the index upon completion; this prevents that.
dont_write_index: bool = false,
z_padding3: u8 = 0,
pub fn format(
value: Strategy,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
_ = fmt;
return internal.formatWithoutFields(
value,
options,
writer,
&.{ "z_padding", "z_padding2", "z_padding3" },
);
}
test {
try std.testing.expectEqual(@sizeOf(c_uint), @sizeOf(Strategy));
try std.testing.expectEqual(@bitSizeOf(c_uint), @bitSizeOf(Strategy));
}
comptime {
std.testing.refAllDecls(@This());
}
};
pub const Notification = packed struct {
/// Invokes checkout on conflicting paths.
conflict: bool = false,
/// Notifies about "dirty" files, i.e. those that do not need an update
/// but no longer match the baseline. Core git displays these files when
/// checkout runs, but won't stop the checkout.
dirty: bool = false,
/// Sends notification for any file changed.
updated: bool = false,
/// Notifies about untracked files.
untracked: bool = false,
/// Notifies about ignored files.
ignored: bool = false,
z_padding: u11 = 0,
z_padding2: u16 = 0,
pub const all = @bitCast(Notification, @as(c_uint, 0xFFFF));
test {
try std.testing.expectEqual(@sizeOf(c_uint), @sizeOf(Notification));
try std.testing.expectEqual(@bitSizeOf(c_uint), @bitSizeOf(Notification));
}
comptime {
std.testing.refAllDecls(@This());
}
};
comptime {
std.testing.refAllDecls(@This());
}
};
pub const CherrypickOptions = struct {
mainline: bool = false,
merge_options: git.MergeOptions = .{},
checkout_options: git.CheckoutOptions = .{},
comptime {
std.testing.refAllDecls(@This());
}
};
comptime {
std.testing.refAllDecls(@This());
} | src/repository.zig |
const gpio = @import("gpio.zig");
const Self = @This();
//Brightness levels
const brightness_levels = [8]u8{ 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, 0x01 };
const hex_digits = [16]u8{ 0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71 };
const letters = [26]u8{ 0x77, 0x7c, 0x58, 0x5e, 0x79, 0x71, 0x3d, 0x74, 0x30, 0x0e, 0, 0x38, 0, 0x54, 0x5c, 0x73, 0x67, 0x50, 0x78, 0x3e, 0, 0, 0, 0x72, 0x5b };
//Digital tube selection
const led_byte = [4]u8{ 0x68, 0x6A, 0x6C, 0x6E };
//Both in port C
const SDA_pin = 18;
const SCL_pin = 19;
pub const Tube = packed struct {
top: u1 = 0,
top_right: u1 = 0,
bottom_right: u1 = 0,
bottom: u1 = 0,
bottom_left: u1 = 0,
top_left: u1 = 0,
middle: u1 = 0,
dot: u1 = 0,
pub fn getByte(self: Tube) u8 {
return @bitCast(u8, self);
}
pub fn fromByte(byte: u8) Tube {
return @bitCast(Tube, byte);
}
pub fn fromHexDigit(digit: u4) Tube {
return fromByte(hex_digits[digit]);
}
};
pub fn init() void {
gpio.pinMode(SDA_pin, .output);
gpio.pinMode(SCL_pin, .output);
}
pub fn setBrightness(brightness: u3) void {
Tm1650.send(0x48, brightness_levels[brightness]);
}
pub fn setTube(which_tube: u2, tube: Tube) void {
Tm1650.send(led_byte[which_tube], tube.getByte());
}
pub fn writeHexDigit(which_tube: u2, digit: u4) void {
Tm1650.send(led_byte[which_tube], hex_digits[digit]);
}
pub fn writeU16Hex(short: u16) void {
inline for (led_byte) |tube, i| {
Tm1650.send(tube, hex_digits[@truncate(u4, ((short << (i * 4)) & 0xf000) >> 12)]);
}
}
pub fn writeInt(int: i16) !void {
if (int < -999 or int > 9999)
return error.TooBig;
if (int < 0)
setTube(0, Tube{ .middle = 1 });
var i: u16 = @intCast(u16, if (int < 0) -int else int);
var tube: u2 = 3;
while (tube > 0) : (tube -= 1) {
writeHexDigit(tube, @intCast(u4, @mod(i, 10)));
i /= 10;
} else if (int >= 1000)
writeHexDigit(tube, @intCast(u4, i));
}
pub fn writeErr() void {
init();
setBrightness(0b111);
const tubes = comptime blk: {
var ret: [4]u8 = undefined;
ret[0] = hex_digits[0xE];
ret[1] = (Tube{ .bottom_left = 1, .middle = 1 }).getByte();
ret[2] = ret[1];
ret[3] = (Tube{ .top_right = 1, .dot = 1 }).getByte();
break :blk ret;
};
inline for (led_byte) |tube, i| {
Tm1650.send(tube, tubes[i]);
}
}
pub fn displayZig() void {
Tm1650.send(led_byte[0], 0x5B);
Tm1650.send(led_byte[1], 0x06);
Tm1650.send(led_byte[2], 0x3D);
Tm1650.send(led_byte[3], 0x82);
}
pub fn clear() void {
inline for (led_byte) |tube| {
Tm1650.send(tube, 0);
}
}
fn letterTransform(letter: u7) u8 {
if (letter < 10) {
return letter;
} else if (letter <= 45) {
return 16;
} else if (letter < 58) {
return (letter - 48);
} else if (letter < 91) {
return (letter - 55);
} else if (letter < 123) {
return (letter - 87);
}
}
const Tm1650 = struct {
fn begin() void {
gpio.digitalWrite(SCL_pin, .high);
gpio.digitalWrite(SDA_pin, .high);
delayMicroseconds(2);
gpio.digitalWrite(SDA_pin, .low);
delayMicroseconds(2);
gpio.digitalWrite(SCL_pin, .low);
}
fn stop() void {
gpio.digitalWrite(SCL_pin, .high);
gpio.digitalWrite(SDA_pin, .low);
delayMicroseconds(2);
gpio.digitalWrite(SDA_pin, .high);
delayMicroseconds(2);
}
fn write(byte: u8) void {
var b = byte;
var i: u4 = 0;
while (i < 8) : (i += 1) {
if ((b & 0x80) != 0) {
gpio.digitalWrite(SDA_pin, .high);
} else gpio.digitalWrite(SDA_pin, .low);
delayMicroseconds(2);
gpio.digitalWrite(SCL_pin, .high);
b <<= 1;
delayMicroseconds(2);
gpio.digitalWrite(SCL_pin, .low);
}
gpio.digitalWrite(SDA_pin, .high);
delayMicroseconds(2);
gpio.digitalWrite(SCL_pin, .high);
delayMicroseconds(2);
gpio.digitalWrite(SCL_pin, .low);
}
fn send(address: u8, byte: u8) void {
begin();
write(address);
write(byte);
stop();
}
fn delayMicroseconds(comptime microseconds: comptime_int) void {
var count: u32 = 0;
while (count < microseconds * 2) : (count += 1) {
asm volatile ("nop");
}
}
}; | src/led_keypad.zig |
const std = @import("std");
const Arena = std.heap.ArenaAllocator;
const assert = std.debug.assert;
const panic = std.debug.panic;
const initCodebase = @import("init_codebase.zig").initCodebase;
const ecs = @import("ecs.zig");
const Entity = ecs.Entity;
const ECS = ecs.ECS;
const List = @import("list.zig").List;
const Strings = @import("strings.zig").Strings;
const literalOf = @import("query.zig").literalOf;
const components = @import("components.zig");
const Source = struct {
code: []const u8,
position: components.Position,
fn init(code: []const u8) Source {
return Source{
.code = code,
.position = .{
.column = 0,
.row = 0,
},
};
}
fn advance(self: *Source, columns: u64) []const u8 {
const result = self.code[0..columns];
self.code = self.code[columns..];
self.position.column += columns;
return result;
}
fn trimWhitespace(self: *Source) void {
var i: u64 = 0;
while (i < self.code.len) : (i += 1) {
switch (self.code[i]) {
'\r' => continue,
' ' => self.position.column += 1,
else => break,
}
}
self.code = self.code[i..];
}
};
pub const Tokens = struct {
entities: []const Entity,
pub fn init(entities: []const Entity) Tokens {
return Tokens{ .entities = entities };
}
pub fn next(self: *Tokens) ?Entity {
if (self.entities.len == 0) return null;
const entity = self.entities[0];
self.entities = self.entities[1..];
return entity;
}
pub fn peek(self: Tokens) ?Entity {
if (self.entities.len == 0) return null;
return self.entities[0];
}
pub fn consume(self: *Tokens, kind: components.TokenKind) Entity {
const token = self.next().?;
assert(token.get(components.TokenKind) == kind);
return token;
}
};
fn tokenizeNewLine(module: Entity, source: *Source) !Entity {
const begin = source.position;
source.position.column = 0;
source.position.row += 1;
source.code = source.code[1..];
const end = source.position;
const span = components.Span.init(begin, end);
return try module.ecs.createEntity(.{
components.TokenKind.new_line,
span,
});
}
pub fn tokenize(module: Entity, code: []const u8) !Tokens {
var entities = List(Entity, .{ .initial_capacity = 1024 }).init(module.ecs.arena.allocator());
var source = Source.init(code);
while (true) {
source.trimWhitespace();
if (source.code.len == 0) return Tokens.init(entities.slice());
const token = switch (source.code[0]) {
'0'...'9', '-' => try tokenizeNumber(module, &source, false),
'.' => try tokenizeNumber(module, &source, true),
'"' => try tokenizeString(module, &source),
'\'' => try tokenizeChar(module, &source),
'(' => try tokenizeOne(module, &source, .left_paren),
')' => try tokenizeOne(module, &source, .right_paren),
'[' => try tokenizeOne(module, &source, .left_bracket),
']' => try tokenizeOne(module, &source, .right_bracket),
'{' => try tokenizeOne(module, &source, .left_brace),
'}' => try tokenizeOne(module, &source, .right_brace),
'/' => try tokenizeOne(module, &source, .slash),
'%' => try tokenizeOne(module, &source, .percent),
'&' => try tokenizeOne(module, &source, .ampersand),
'^' => try tokenizeOne(module, &source, .caret),
',' => try tokenizeOne(module, &source, .comma),
':' => try tokenizeOne(module, &source, .colon),
'|' => try tokenizeOne(module, &source, .bar),
'+' => try tokenizeOneOrTwo(module, &source, .plus, &.{'='}, &.{.plus_equal}),
'*' => try tokenizeOneOrTwo(module, &source, .times, &.{'='}, &.{.times_equal}),
'=' => try tokenizeOneOrTwo(module, &source, .equal, &.{'='}, &.{.equal_equal}),
'>' => try tokenizeOneOrTwo(module, &source, .greater_than, &.{ '=', '>' }, &.{ .greater_equal, .greater_greater }),
'<' => try tokenizeOneOrTwo(module, &source, .less_than, &.{ '=', '<' }, &.{ .less_equal, .less_less }),
'!' => try tokenizeTwo(module, &source, '=', .bang_equal),
'@' => try tokenizeAttribute(module, &source),
'\n' => try tokenizeNewLine(module, &source),
else => try tokenizeSymbol(module, &source),
};
try entities.append(token);
}
}
fn validSymbol(char: u8) bool {
return switch (char) {
'(', ')', '[', ']', '{', '}', ' ', ':', '+', '-', '*', '/', '&', '|', '<', '>', ',', '\n', '\r', '.', '=' => false,
else => true,
};
}
fn tokenizeSymbol(module: Entity, source: *Source) !Entity {
const begin = source.position;
var i: u64 = 1;
while (i < source.code.len) : (i += 1) {
if (!validSymbol(source.code[i])) {
break;
}
}
const string = source.advance(i);
const span = components.Span{ .begin = begin, .end = source.position };
const symbols = [_][]const u8{
"import", "fn", "if", "else", "while", "for", "in", "struct", "_",
};
const tokens = [_]components.TokenKind{
.import, .fn_, .if_, .else_, .while_, .for_, .in, .struct_, .underscore,
};
for (symbols) |symbol, j| {
if (std.mem.eql(u8, string, symbol)) {
return try module.ecs.createEntity(.{ tokens[j], span });
}
}
const interned = try module.ecs.getPtr(Strings).intern(string);
return try module.ecs.createEntity(.{
components.Literal.init(interned),
components.TokenKind.symbol,
span,
});
}
fn tokenizeAttribute(module: Entity, source: *Source) !Entity {
const begin = source.position;
var i: u64 = 1;
while (i < source.code.len) : (i += 1) {
if (!validSymbol(source.code[i])) {
break;
}
}
const string = source.advance(i)[1..];
const span = components.Span{ .begin = begin, .end = source.position };
const symbols = [_][]const u8{ "export", "import" };
const tokens = [_]components.TokenKind{ .attribute_export, .attribute_import };
for (symbols) |symbol, j| {
if (std.mem.eql(u8, string, symbol)) {
return try module.ecs.createEntity(.{ tokens[j], span });
}
}
panic("\ninvalid attribute {s}\n", .{string});
}
fn tokenizeNumber(module: Entity, source: *Source, starts_with_decimal: bool) !Entity {
var decimals_seen: u64 = if (starts_with_decimal) 1 else 0;
const begin = source.position;
var i: u64 = 1;
while (i < source.code.len) : (i += 1) {
const c = source.code[i];
switch (c) {
'0'...'9' => continue,
'.' => decimals_seen += 1,
else => {
if (validSymbol(c) and i > 1 and source.code[i - 1] == '.') {
decimals_seen -= 1;
i -= 1;
}
break;
},
}
}
const string = source.advance(i);
const span = components.Span{ .begin = begin, .end = source.position };
if (i == 1) {
if (starts_with_decimal) return try module.ecs.createEntity(.{ components.TokenKind.dot, span });
if (string[0] == '-') return try module.ecs.createEntity(.{ components.TokenKind.minus, span });
}
const interned = try module.ecs.getPtr(Strings).intern(string);
const kind: components.TokenKind = if (decimals_seen == 0) .int else .float;
const entity = try module.ecs.createEntity(.{
components.Literal.init(interned),
kind,
span,
});
if (decimals_seen > 1) {
const error_component = components.Error{
.header = "TOKENIZER ERROR",
.body = "Number should not have more than 1 decimal.",
.span = span,
.hint = "Remove the additional decimals.",
.module = module,
};
_ = try entity.set(.{error_component});
}
return entity;
}
fn tokenizeString(module: Entity, source: *Source) !Entity {
const begin = source.position;
var i: u64 = 1;
while (i < source.code.len) {
switch (source.code[i]) {
'"' => {
i += 1;
source.position.column += 1;
break;
},
'\n' => {
i += 1;
source.position.row += 1;
source.position.column = 0;
},
else => {
i += 1;
source.position.column += 1;
},
}
}
const string = source.code[0..i];
source.code = source.code[i..];
const span = components.Span{ .begin = begin, .end = source.position };
source.position.column += 1;
const interned = try module.ecs.getPtr(Strings).intern(string[1 .. i - 1]);
const length = components.Length{ .value = @intCast(i32, string.len - 2) };
return try module.ecs.createEntity(.{
components.Literal.init(interned),
components.TokenKind.string,
length,
span,
});
}
fn tokenizeChar(module: Entity, source: *Source) !Entity {
const begin = source.position;
var i: u64 = 1;
while (i < source.code.len) : (i += 1) {
switch (source.code[i]) {
'\'' => {
i += 1;
break;
},
else => continue,
}
}
const string = source.advance(i);
const span = components.Span{ .begin = begin, .end = source.position };
const interned = try module.ecs.getPtr(Strings).intern(string[1 .. i - 1]);
assert(string.len == 3);
return try module.ecs.createEntity(.{
components.Literal.init(interned),
components.TokenKind.char,
span,
});
}
fn tokenizeOne(module: Entity, source: *Source, kind: components.TokenKind) !Entity {
const begin = source.position;
_ = source.advance(1);
const span = components.Span{ .begin = begin, .end = source.position };
return try module.ecs.createEntity(.{ kind, span });
}
fn tokenizeOneOrTwo(module: Entity, source: *Source, first: components.TokenKind, chars: []const u8, second: []const components.TokenKind) !Entity {
const begin = source.position;
if (source.code.len > 1) {
const actual = source.code[1];
for (chars) |expected, i| {
if (actual == expected) {
_ = source.advance(2);
const span = components.Span{ .begin = begin, .end = source.position };
return try module.ecs.createEntity(.{ second[i], span });
}
}
}
_ = source.advance(1);
const span = components.Span{ .begin = begin, .end = source.position };
return try module.ecs.createEntity(.{ first, span });
}
fn tokenizeTwo(module: Entity, source: *Source, char: u8, kind: components.TokenKind) !Entity {
const begin = source.position;
assert(source.code.len > 1 and source.code[1] == char);
_ = source.advance(2);
const span = components.Span{ .begin = begin, .end = source.position };
return try module.ecs.createEntity(.{ kind, span });
} | src/tokenizer.zig |
const Allocator = std.mem.Allocator;
const Headers = @import("http").Headers;
const parseHeaders = @import("headers.zig").parse;
const Method = @import("http").Method;
const ParsingError = @import("errors.zig").ParsingError;
const readUri = @import("utils.zig").readUri;
const std = @import("std");
const Version = @import("http").Version;
pub const Request = struct {
method: Method,
target: []const u8,
version: Version,
headers: Headers,
pub const Error = error{
MissingHost,
TooManyHost,
};
pub fn init(method: Method, target: []const u8, version: Version, headers: Headers) Error!Request {
// A single 'Host' header is mandatory for HTTP/1.1
// Cf: https://tools.ietf.org/html/rfc7230#section-5.4
var hostCount: u32 = 0;
for (headers.items()) |header| {
if (header.name.type == .Host) {
hostCount += 1;
}
}
if (hostCount == 0 and version == .Http11) {
return error.MissingHost;
}
if (hostCount > 1) {
return error.TooManyHost;
}
return Request{
.method = method,
.target = target,
.version = version,
.headers = headers,
};
}
pub fn default(allocator: *Allocator) Request {
return Request{
.method = .Get,
.target = "/",
.version = .Http11,
.headers = Headers.init(allocator),
};
}
pub fn deinit(self: *Request) void {
self.headers.deinit();
}
pub fn parse(allocator: *Allocator, buffer: []const u8) ParsingError!Request {
var line_end = std.mem.indexOfPosLinear(u8, buffer, 0, "\r\n") orelse return error.Incomplete;
var requestLine = buffer[0..line_end];
var cursor: usize = 0;
var method = for (requestLine) |char, i| {
if (char == ' ') {
cursor += i + 1;
var value = try Method.from_bytes(requestLine[0..i]);
break value;
}
} else {
return error.Invalid;
};
const target = try readUri(requestLine[cursor..]);
cursor += target.len + 1;
const version = Version.from_bytes(requestLine[cursor..]) orelse return error.Invalid;
if (version != .Http11) {
return error.Invalid;
}
var _headers = try parseHeaders(allocator, buffer[requestLine.len + 2 ..], 128);
return Request{
.headers = _headers,
.version = version,
.method = method,
.target = target,
};
}
pub fn serialize(self: Request, allocator: *Allocator) ![]const u8 {
var buffer = std.ArrayList(u8).init(allocator);
// Serialize the request line
try buffer.appendSlice(self.method.to_bytes());
try buffer.append(' ');
try buffer.appendSlice(self.target);
try buffer.append(' ');
try buffer.appendSlice(self.version.to_bytes());
try buffer.appendSlice("\r\n");
// Serialize the headers
for (self.headers.items()) |header| {
try buffer.appendSlice(header.name.raw());
try buffer.appendSlice(": ");
try buffer.appendSlice(header.value);
try buffer.appendSlice("\r\n");
}
try buffer.appendSlice("\r\n");
return buffer.toOwnedSlice();
}
};
const expect = std.testing.expect;
const expectEqualStrings = std.testing.expectEqualStrings;
const expectError = std.testing.expectError;
test "Init - An HTTP/1.1 request must contain a 'Host' header" {
var headers = Headers.init(std.testing.allocator);
defer headers.deinit();
var request = Request.init(Method.Get, "/news/", Version.Http11, headers);
try expectError(error.MissingHost, request);
}
test "Init - An HTTP/1.0 request may not contain a 'Host' header" {
var headers = Headers.init(std.testing.allocator);
defer headers.deinit();
_ = try Request.init(Method.Get, "/news/", Version.Http10, headers);
}
test "Init - A request must not contain multiple 'Host' header" {
var headers = Headers.init(std.testing.allocator);
_ = try headers.append("Host", "ziglang.org");
_ = try headers.append("Host", "ziglang.org");
defer headers.deinit();
var request = Request.init(Method.Get, "/news/", Version.Http11, headers);
try expectError(error.TooManyHost, request);
}
test "Serialize" {
var headers = Headers.init(std.testing.allocator);
defer headers.deinit();
_ = try headers.append("Host", "ziglang.org");
_ = try headers.append("GOTTA-GO", "FAST!!");
var request = try Request.init(Method.Get, "/news/", Version.Http11, headers);
var result = try request.serialize(std.testing.allocator);
defer std.testing.allocator.free(result);
try expectEqualStrings(result, "GET /news/ HTTP/1.1\r\nHost: ziglang.org\r\nGOTTA-GO: FAST!!\r\n\r\n");
}
test "Parse - Success" {
const content = "GET http://www.example.org/where?q=now HTTP/1.1\r\nUser-Agent: h11\r\nAccept-Language: en\r\n\r\n";
var request = try Request.parse(std.testing.allocator, content);
defer request.deinit();
try expect(request.method == .Get);
try expectEqualStrings(request.target, "http://www.example.org/where?q=now");
try expect(request.version == .Http11);
try expect(request.headers.len() == 2);
}
test "Parse - When the request line does not ends with a CRLF - Returns Incomplete" {
const content = "GET http://www.example.org/where?q=now HTTP/1.1";
const failure = Request.parse(std.testing.allocator, content);
try expectError(error.Incomplete, failure);
}
test "Parse - When the method contains an invalid character - Returns Invalid" {
const content = "G\tET http://www.example.org/where?q=now HTTP/1.1\r\n\r\n\r\n";
const failure = Request.parse(std.testing.allocator, content);
try expectError(error.Invalid, failure);
}
test "Parse - When the method and the target are not separated by a whitespace - Returns Invalid" {
const content = "GEThttp://www.example.org/where?q=now HTTP/1.1\r\n\r\n\r\n";
const failure = Request.parse(std.testing.allocator, content);
try expectError(error.Invalid, failure);
}
test "Parse - When the target contains an invalid character - Returns Invalid" {
const content = "GET http://www.\texample.org/where?q=now HTTP/1.1\r\n\r\n\r\n";
const failure = Request.parse(std.testing.allocator, content);
try expectError(error.Invalid, failure);
}
test "Parse - When the target and the http version are not separated by a whitespace - Returns Invalid" {
const content = "GET http://www.example.org/where?q=nowHTTP/1.1\r\n\r\n\r\n";
const failure = Request.parse(std.testing.allocator, content);
try expectError(error.Invalid, failure);
}
test "Parse - When the http version is not HTTP 1.1 - Returns Invalid" {
const content = "GET http://www.example.org/where?q=now HTTP/4.2\r\n\r\n\r\n";
const failure = Request.parse(std.testing.allocator, content);
try expectError(error.Invalid, failure);
} | src/events/request.zig |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.