ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-06 15:48:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Strip unneeded semicolons from vendor library

Browse Source
This commit is contained in:
gingerBill
2021-08-31 22:26:58 +01:00
parent 251da264ed
commit b450a853d5
46 changed files with 7234 additions and 7234 deletions
Download Patch File Download Diff File Expand all files Collapse all files
vendor/OpenGL/constants.odin
Vendored
+1387 -1387
View File
File diff suppressed because it is too large Load Diff
vendor/OpenGL/helpers.odin
Vendored
+105 -105
View File
@@ -19,27 +19,27 @@ Shader_Type :: enum i32 {
@(private, thread_local) @(private, thread_local)
last_compile_error_message: []byte; last_compile_error_message: []byte
@(private, thread_local) @(private, thread_local)
last_link_error_message: []byte; last_link_error_message: []byte
@(private, thread_local) @(private, thread_local)
last_compile_error_type: Shader_Type; last_compile_error_type: Shader_Type
@(private, thread_local) @(private, thread_local)
last_link_error_type: Shader_Type; last_link_error_type: Shader_Type
get_last_error_messages :: proc() -> (compile_message: string, compile_type: Shader_Type, link_message: string, link_type: Shader_Type) { get_last_error_messages :: proc() -> (compile_message: string, compile_type: Shader_Type, link_message: string, link_type: Shader_Type) {
compile_message = string(last_compile_error_message[:max(0, len(last_compile_error_message)-1)]); compile_message = string(last_compile_error_message[:max(0, len(last_compile_error_message)-1)])
compile_type = last_compile_error_type; compile_type = last_compile_error_type
link_message = string(last_link_error_message[:max(0, len(last_link_error_message)-1)]); link_message = string(last_link_error_message[:max(0, len(last_link_error_message)-1)])
link_type = last_link_error_type; link_type = last_link_error_type
return; return
} }
get_last_error_message :: proc() -> (compile_message: string, compile_type: Shader_Type) { get_last_error_message :: proc() -> (compile_message: string, compile_type: Shader_Type) {
compile_message = string(last_compile_error_message[:max(0, len(last_compile_error_message)-1)]); compile_message = string(last_compile_error_message[:max(0, len(last_compile_error_message)-1)])
compile_type = last_compile_error_type; compile_type = last_compile_error_type
return; return
} }
// Shader checking and linking checking are identical // Shader checking and linking checking are identical
@@ -55,32 +55,32 @@ when ODIN_DEBUG {
log_func: proc "c" (u32, i32, ^i32, [^]u8, runtime.Source_Code_Location), log_func: proc "c" (u32, i32, ^i32, [^]u8, runtime.Source_Code_Location),
loc := #caller_location, loc := #caller_location,
) -> (success: bool) { ) -> (success: bool) {
result, info_log_length: i32; result, info_log_length: i32
iv_func(id, status, &result, loc); iv_func(id, status, &result, loc)
iv_func(id, INFO_LOG_LENGTH, &info_log_length, loc); iv_func(id, INFO_LOG_LENGTH, &info_log_length, loc)
if result == 0 { if result == 0 {
if log_func == GetShaderInfoLog { if log_func == GetShaderInfoLog {
delete(last_compile_error_message); delete(last_compile_error_message)
last_compile_error_message = make([]byte, info_log_length); last_compile_error_message = make([]byte, info_log_length)
last_compile_error_type = type; last_compile_error_type = type
log_func(id, i32(info_log_length), nil, raw_data(last_compile_error_message), loc); log_func(id, i32(info_log_length), nil, raw_data(last_compile_error_message), loc)
//fmt.printf_err("Error in %v:\n%s", type, string(last_compile_error_message[0:len(last_compile_error_message)-1])); //fmt.printf_err("Error in %v:\n%s", type, string(last_compile_error_message[0:len(last_compile_error_message)-1]));
} else { } else {
delete(last_link_error_message); delete(last_link_error_message)
last_link_error_message = make([]byte, info_log_length); last_link_error_message = make([]byte, info_log_length)
last_compile_error_type = type; last_compile_error_type = type
log_func(id, i32(info_log_length), nil, raw_data(last_link_error_message), loc); log_func(id, i32(info_log_length), nil, raw_data(last_link_error_message), loc)
//fmt.printf_err("Error in %v:\n%s", type, string(last_link_error_message[0:len(last_link_error_message)-1])); //fmt.printf_err("Error in %v:\n%s", type, string(last_link_error_message[0:len(last_link_error_message)-1]));
} }
return false; return false
} }
return true; return true
} }
} else { } else {
@private @private
@@ -89,103 +89,103 @@ when ODIN_DEBUG {
iv_func: proc "c" (u32, u32, [^]i32), iv_func: proc "c" (u32, u32, [^]i32),
log_func: proc "c" (u32, i32, ^i32, [^]u8), log_func: proc "c" (u32, i32, ^i32, [^]u8),
) -> (success: bool) { ) -> (success: bool) {
result, info_log_length: i32; result, info_log_length: i32
iv_func(id, status, &result); iv_func(id, status, &result)
iv_func(id, INFO_LOG_LENGTH, &info_log_length); iv_func(id, INFO_LOG_LENGTH, &info_log_length)
if result == 0 { if result == 0 {
if log_func == GetShaderInfoLog { if log_func == GetShaderInfoLog {
delete(last_compile_error_message); delete(last_compile_error_message)
last_compile_error_message = make([]u8, info_log_length); last_compile_error_message = make([]u8, info_log_length)
last_link_error_type = type; last_link_error_type = type
log_func(id, i32(info_log_length), nil, raw_data(last_compile_error_message)); log_func(id, i32(info_log_length), nil, raw_data(last_compile_error_message))
fmt.eprintf("Error in %v:\n%s", type, string(last_compile_error_message[0:len(last_compile_error_message)-1])); fmt.eprintf("Error in %v:\n%s", type, string(last_compile_error_message[0:len(last_compile_error_message)-1]))
} else { } else {
delete(last_link_error_message); delete(last_link_error_message)
last_link_error_message = make([]u8, info_log_length); last_link_error_message = make([]u8, info_log_length)
last_link_error_type = type; last_link_error_type = type
log_func(id, i32(info_log_length), nil, raw_data(last_link_error_message)); log_func(id, i32(info_log_length), nil, raw_data(last_link_error_message))
fmt.eprintf("Error in %v:\n%s", type, string(last_link_error_message[0:len(last_link_error_message)-1])); fmt.eprintf("Error in %v:\n%s", type, string(last_link_error_message[0:len(last_link_error_message)-1]))
} }
return false; return false
} }
return true; return true
} }
} }
// Compiling shaders are identical for any shader (vertex, geometry, fragment, tesselation, (maybe compute too)) // Compiling shaders are identical for any shader (vertex, geometry, fragment, tesselation, (maybe compute too))
@private @private
compile_shader_from_source :: proc(shader_data: string, shader_type: Shader_Type) -> (shader_id: u32, ok: bool) { compile_shader_from_source :: proc(shader_data: string, shader_type: Shader_Type) -> (shader_id: u32, ok: bool) {
shader_id = CreateShader(cast(u32)shader_type); shader_id = CreateShader(cast(u32)shader_type)
length := i32(len(shader_data)); length := i32(len(shader_data))
shader_data_copy := cstring(raw_data(shader_data)); shader_data_copy := cstring(raw_data(shader_data))
ShaderSource(shader_id, 1, &shader_data_copy, &length); ShaderSource(shader_id, 1, &shader_data_copy, &length)
CompileShader(shader_id); CompileShader(shader_id)
check_error(shader_id, shader_type, COMPILE_STATUS, GetShaderiv, GetShaderInfoLog) or_return; check_error(shader_id, shader_type, COMPILE_STATUS, GetShaderiv, GetShaderInfoLog) or_return
ok = true; ok = true
return; return
} }
// only used once, but I'd just make a subprocedure(?) for consistency // only used once, but I'd just make a subprocedure(?) for consistency
@private @private
create_and_link_program :: proc(shader_ids: []u32, binary_retrievable := false) -> (program_id: u32, ok: bool) { create_and_link_program :: proc(shader_ids: []u32, binary_retrievable := false) -> (program_id: u32, ok: bool) {
program_id = CreateProgram(); program_id = CreateProgram()
for id in shader_ids { for id in shader_ids {
AttachShader(program_id, id); AttachShader(program_id, id)
} }
if binary_retrievable { if binary_retrievable {
ProgramParameteri(program_id, PROGRAM_BINARY_RETRIEVABLE_HINT, 1/*true*/); ProgramParameteri(program_id, PROGRAM_BINARY_RETRIEVABLE_HINT, 1/*true*/)
} }
LinkProgram(program_id); LinkProgram(program_id)
check_error(program_id, Shader_Type.SHADER_LINK, LINK_STATUS, GetProgramiv, GetProgramInfoLog) or_return; check_error(program_id, Shader_Type.SHADER_LINK, LINK_STATUS, GetProgramiv, GetProgramInfoLog) or_return
ok = true; ok = true
return; return
} }
load_compute_file :: proc(filename: string, binary_retrievable := false) -> (program_id: u32, ok: bool) { load_compute_file :: proc(filename: string, binary_retrievable := false) -> (program_id: u32, ok: bool) {
cs_data := os.read_entire_file(filename) or_return; cs_data := os.read_entire_file(filename) or_return
defer delete(cs_data); defer delete(cs_data)
// Create the shaders // Create the shaders
compute_shader_id := compile_shader_from_source(string(cs_data), Shader_Type(COMPUTE_SHADER)) or_return; compute_shader_id := compile_shader_from_source(string(cs_data), Shader_Type(COMPUTE_SHADER)) or_return
return create_and_link_program([]u32{compute_shader_id}, binary_retrievable); return create_and_link_program([]u32{compute_shader_id}, binary_retrievable)
} }
load_compute_source :: proc(cs_data: string, binary_retrievable := false) -> (program_id: u32, ok: bool) { load_compute_source :: proc(cs_data: string, binary_retrievable := false) -> (program_id: u32, ok: bool) {
// Create the shaders // Create the shaders
compute_shader_id := compile_shader_from_source(cs_data, Shader_Type(COMPUTE_SHADER)) or_return; compute_shader_id := compile_shader_from_source(cs_data, Shader_Type(COMPUTE_SHADER)) or_return
return create_and_link_program([]u32{compute_shader_id}, binary_retrievable); return create_and_link_program([]u32{compute_shader_id}, binary_retrievable)
} }
load_shaders_file :: proc(vs_filename, fs_filename: string, binary_retrievable := false) -> (program_id: u32, ok: bool) { load_shaders_file :: proc(vs_filename, fs_filename: string, binary_retrievable := false) -> (program_id: u32, ok: bool) {
vs_data := os.read_entire_file(vs_filename) or_return; vs_data := os.read_entire_file(vs_filename) or_return
defer delete(vs_data); defer delete(vs_data)
fs_data := os.read_entire_file(fs_filename) or_return; fs_data := os.read_entire_file(fs_filename) or_return
defer delete(fs_data); defer delete(fs_data)
return load_shaders_source(string(vs_data), string(fs_data), binary_retrievable); return load_shaders_source(string(vs_data), string(fs_data), binary_retrievable)
} }
load_shaders_source :: proc(vs_source, fs_source: string, binary_retrievable := false) -> (program_id: u32, ok: bool) { load_shaders_source :: proc(vs_source, fs_source: string, binary_retrievable := false) -> (program_id: u32, ok: bool) {
// actual function from here // actual function from here
vertex_shader_id := compile_shader_from_source(vs_source, Shader_Type.VERTEX_SHADER) or_return; vertex_shader_id := compile_shader_from_source(vs_source, Shader_Type.VERTEX_SHADER) or_return
defer DeleteShader(vertex_shader_id); defer DeleteShader(vertex_shader_id)
fragment_shader_id := compile_shader_from_source(fs_source, Shader_Type.FRAGMENT_SHADER) or_return; fragment_shader_id := compile_shader_from_source(fs_source, Shader_Type.FRAGMENT_SHADER) or_return
defer DeleteShader(fragment_shader_id); defer DeleteShader(fragment_shader_id)
return create_and_link_program([]u32{vertex_shader_id, fragment_shader_id}, binary_retrievable); return create_and_link_program([]u32{vertex_shader_id, fragment_shader_id}, binary_retrievable)
} }
load_shaders :: proc{load_shaders_file}; load_shaders :: proc{load_shaders_file}
when ODIN_OS == "windows" { when ODIN_OS == "windows" {
@@ -198,23 +198,23 @@ when ODIN_OS == "windows" {
current_vertex_time, current_fragment_time: os.File_Time, current_vertex_time, current_fragment_time: os.File_Time,
updated: bool, updated: bool,
) { ) {
current_vertex_time, _ = os.last_write_time_by_name(vertex_name); current_vertex_time, _ = os.last_write_time_by_name(vertex_name)
current_fragment_time, _ = os.last_write_time_by_name(fragment_name); current_fragment_time, _ = os.last_write_time_by_name(fragment_name)
old_program = program; old_program = program
if current_vertex_time != last_vertex_time || current_fragment_time != last_fragment_time { if current_vertex_time != last_vertex_time || current_fragment_time != last_fragment_time {
new_program, success := load_shaders(vertex_name, fragment_name); new_program, success := load_shaders(vertex_name, fragment_name)
if success { if success {
DeleteProgram(old_program); DeleteProgram(old_program)
old_program = new_program; old_program = new_program
fmt.println("Updated shaders"); fmt.println("Updated shaders")
updated = true; updated = true
} else { } else {
fmt.println("Failed to update shaders"); fmt.println("Failed to update shaders")
} }
} }
return old_program, current_vertex_time, current_fragment_time, updated; return old_program, current_vertex_time, current_fragment_time, updated
} }
update_shader_if_changed_compute :: proc( update_shader_if_changed_compute :: proc(
@@ -226,22 +226,22 @@ when ODIN_OS == "windows" {
current_compute_time: os.File_Time, current_compute_time: os.File_Time,
updated: bool, updated: bool,
) { ) {
current_compute_time, _ = os.last_write_time_by_name(compute_name); current_compute_time, _ = os.last_write_time_by_name(compute_name)
old_program = program; old_program = program
if current_compute_time != last_compute_time { if current_compute_time != last_compute_time {
new_program, success := load_compute_file(compute_name); new_program, success := load_compute_file(compute_name)
if success { if success {
DeleteProgram(old_program); DeleteProgram(old_program)
old_program = new_program; old_program = new_program
fmt.println("Updated shaders"); fmt.println("Updated shaders")
updated = true; updated = true
} else { } else {
fmt.println("Failed to update shaders"); fmt.println("Failed to update shaders")
} }
} }
return old_program, current_compute_time, updated; return old_program, current_compute_time, updated
} }
} }
@@ -377,34 +377,34 @@ Uniform_Info :: struct {
name: string, // NOTE: This will need to be freed name: string, // NOTE: This will need to be freed
} }
Uniforms :: map[string]Uniform_Info; Uniforms :: map[string]Uniform_Info
destroy_uniforms :: proc(u: Uniforms) { destroy_uniforms :: proc(u: Uniforms) {
for _, v in u { for _, v in u {
delete(v.name); delete(v.name)
} }
delete(u); delete(u)
} }
get_uniforms_from_program :: proc(program: u32) -> (uniforms: Uniforms) { get_uniforms_from_program :: proc(program: u32) -> (uniforms: Uniforms) {
uniform_count: i32; uniform_count: i32
GetProgramiv(program, ACTIVE_UNIFORMS, &uniform_count); GetProgramiv(program, ACTIVE_UNIFORMS, &uniform_count)
if uniform_count > 0 { if uniform_count > 0 {
reserve(&uniforms, int(uniform_count)); reserve(&uniforms, int(uniform_count))
} }
for i in 0..<uniform_count { for i in 0..<uniform_count {
uniform_info: Uniform_Info; uniform_info: Uniform_Info
length: i32; length: i32
cname: [256]u8; cname: [256]u8
GetActiveUniform(program, u32(i), 256, &length, &uniform_info.size, cast(^u32)&uniform_info.kind, &cname[0]); GetActiveUniform(program, u32(i), 256, &length, &uniform_info.size, cast(^u32)&uniform_info.kind, &cname[0])
uniform_info.location = GetUniformLocation(program, cstring(&cname[0])); uniform_info.location = GetUniformLocation(program, cstring(&cname[0]))
uniform_info.name = strings.clone(string(cname[:length])); // @NOTE: These need to be freed uniform_info.name = strings.clone(string(cname[:length])) // @NOTE: These need to be freed
uniforms[uniform_info.name] = uniform_info; uniforms[uniform_info.name] = uniform_info
} }
return uniforms; return uniforms
} }
vendor/OpenGL/impl.odin
Vendored
+1430 -1430
View File
File diff suppressed because it is too large Load Diff
vendor/OpenGL/wrappers.odin
Vendored
+17 -17
View File
@@ -744,7 +744,7 @@ when !ODIN_DEBUG {
import "core:fmt" import "core:fmt"
debug_helper :: #force_inline proc"c"(from_loc: runtime.Source_Code_Location, num_ret: int, args: ..any, loc := #caller_location) { debug_helper :: #force_inline proc"c"(from_loc: runtime.Source_Code_Location, num_ret: int, args: ..any, loc := #caller_location) {
context = runtime.default_context(); context = runtime.default_context()
Error_Enum :: enum { Error_Enum :: enum {
NO_ERROR = NO_ERROR, NO_ERROR = NO_ERROR,
@@ -756,50 +756,50 @@ when !ODIN_DEBUG {
STACK_UNDERFLOW = STACK_UNDERFLOW, STACK_UNDERFLOW = STACK_UNDERFLOW,
STACK_OVERFLOW = STACK_OVERFLOW, STACK_OVERFLOW = STACK_OVERFLOW,
// TODO: What if the return enum is invalid? // TODO: What if the return enum is invalid?
}; }
// There can be multiple errors, so we're required to continuously call glGetError until there are no more errors // There can be multiple errors, so we're required to continuously call glGetError until there are no more errors
for i := 0; /**/; i += 1 { for i := 0; /**/; i += 1 {
err := cast(Error_Enum)impl_GetError(); err := cast(Error_Enum)impl_GetError()
if err == .NO_ERROR do break; if err == .NO_ERROR do break
fmt.printf("%d: glGetError() returned GL_%v\n", i, err); fmt.printf("%d: glGetError() returned GL_%v\n", i, err)
// add function call // add function call
fmt.printf(" call: gl%s(", loc.procedure); fmt.printf(" call: gl%s(", loc.procedure)
{ {
// add input arguments // add input arguments
for arg, i in args[num_ret:] { for arg, i in args[num_ret:] {
if i > 0 do fmt.printf(", "); if i > 0 do fmt.printf(", ")
if v, ok := arg.(u32); ok { // TODO: Assumes all u32 are GLenum (they're not, GLbitfield and GLuint are also mapped to u32), fix later by better typing if v, ok := arg.(u32); ok { // TODO: Assumes all u32 are GLenum (they're not, GLbitfield and GLuint are also mapped to u32), fix later by better typing
if err == .INVALID_ENUM { if err == .INVALID_ENUM {
fmt.printf("INVALID_ENUM=%d", v); fmt.printf("INVALID_ENUM=%d", v)
} else { } else {
fmt.printf("GL_%v=%d", GL_Enum(v), v); fmt.printf("GL_%v=%d", GL_Enum(v), v)
} }
} else { } else {
fmt.printf("%v", arg); fmt.printf("%v", arg)
} }
} }
// add return arguments // add return arguments
if num_ret == 1 { if num_ret == 1 {
fmt.printf(") -> %v \n", args[0]); fmt.printf(") -> %v \n", args[0])
} else if num_ret > 1 { } else if num_ret > 1 {
fmt.printf(") -> ("); fmt.printf(") -> (")
for arg, i in args[1:num_ret] { for arg, i in args[1:num_ret] {
if i > 0 do fmt.printf(", "); if i > 0 do fmt.printf(", ")
fmt.printf("%v", arg); fmt.printf("%v", arg)
} }
fmt.printf(")\n"); fmt.printf(")\n")
} else { } else {
fmt.printf(")\n"); fmt.printf(")\n")
} }
} }
// add location // add location
fmt.printf(" in: %s(%d:%d)\n", from_loc.file_path, from_loc.line, from_loc.column); fmt.printf(" in: %s(%d:%d)\n", from_loc.file_path, from_loc.line, from_loc.column)
} }
} }
vendor/glfw/bindings/types.odin
Vendored
+24 -24
View File
@@ -2,9 +2,9 @@ package glfw_bindings
import "core:c" import "core:c"
WindowHandle :: distinct rawptr; WindowHandle :: distinct rawptr
MonitorHandle :: distinct rawptr; MonitorHandle :: distinct rawptr
CursorHandle :: distinct rawptr; CursorHandle :: distinct rawptr
VidMode :: struct { VidMode :: struct {
width: c.int, width: c.int,
@@ -13,7 +13,7 @@ VidMode :: struct {
green_bits: c.int, green_bits: c.int,
blue_bits: c.int, blue_bits: c.int,
refresh_rate: c.int, refresh_rate: c.int,
}; }
GammaRamp :: struct { GammaRamp :: struct {
red, green, blue: [^]c.ushort, red, green, blue: [^]c.ushort,
@@ -31,25 +31,25 @@ GamepadState :: struct {
} }
/*** Procedure type declarations ***/ /*** Procedure type declarations ***/
WindowIconifyProc :: #type proc "c" (window: WindowHandle, iconified: c.int); WindowIconifyProc :: #type proc "c" (window: WindowHandle, iconified: c.int)
WindowRefreshProc :: #type proc "c" (window: WindowHandle); WindowRefreshProc :: #type proc "c" (window: WindowHandle)
WindowFocusProc :: #type proc "c" (window: WindowHandle, focused: c.int); WindowFocusProc :: #type proc "c" (window: WindowHandle, focused: c.int)
WindowCloseProc :: #type proc "c" (window: WindowHandle); WindowCloseProc :: #type proc "c" (window: WindowHandle)
WindowSizeProc :: #type proc "c" (window: WindowHandle, width, height: c.int); WindowSizeProc :: #type proc "c" (window: WindowHandle, width, height: c.int)
WindowPosProc :: #type proc "c" (window: WindowHandle, xpos, ypos: c.int); WindowPosProc :: #type proc "c" (window: WindowHandle, xpos, ypos: c.int)
WindowMaximizeProc :: #type proc "c" (window: WindowHandle, iconified: c.int); WindowMaximizeProc :: #type proc "c" (window: WindowHandle, iconified: c.int)
WindowContentScaleProc :: #type proc "c" (window: WindowHandle, xscale, yscale: f32); WindowContentScaleProc :: #type proc "c" (window: WindowHandle, xscale, yscale: f32)
FramebufferSizeProc :: #type proc "c" (window: WindowHandle, width, height: c.int); FramebufferSizeProc :: #type proc "c" (window: WindowHandle, width, height: c.int)
DropProc :: #type proc "c" (window: WindowHandle, count: c.int, paths: [^]cstring); DropProc :: #type proc "c" (window: WindowHandle, count: c.int, paths: [^]cstring)
MonitorProc :: #type proc "c" (window: WindowHandle); MonitorProc :: #type proc "c" (window: WindowHandle)
KeyProc :: #type proc "c" (window: WindowHandle, key, scancode, action, mods: c.int); KeyProc :: #type proc "c" (window: WindowHandle, key, scancode, action, mods: c.int)
MouseButtonProc :: #type proc "c" (window: WindowHandle, button, action, mods: c.int); MouseButtonProc :: #type proc "c" (window: WindowHandle, button, action, mods: c.int)
CursorPosProc :: #type proc "c" (window: WindowHandle, xpos, ypos: f64); CursorPosProc :: #type proc "c" (window: WindowHandle, xpos, ypos: f64)
ScrollProc :: #type proc "c" (window: WindowHandle, xoffset, yoffset: f64); ScrollProc :: #type proc "c" (window: WindowHandle, xoffset, yoffset: f64)
CharProc :: #type proc "c" (window: WindowHandle, codepoint: rune); CharProc :: #type proc "c" (window: WindowHandle, codepoint: rune)
CharModsProc :: #type proc "c" (window: WindowHandle, codepoint: rune, mods: c.int); CharModsProc :: #type proc "c" (window: WindowHandle, codepoint: rune, mods: c.int)
CursorEnterProc :: #type proc "c" (window: WindowHandle, entered: c.int); CursorEnterProc :: #type proc "c" (window: WindowHandle, entered: c.int)
JoystickProc :: #type proc "c" (joy, event: c.int); JoystickProc :: #type proc "c" (joy, event: c.int)
ErrorProc :: #type proc "c" (error: c.int, description: cstring); ErrorProc :: #type proc "c" (error: c.int, description: cstring)
vendor/glfw/constants.odin
Vendored
+293 -293
View File
@@ -2,371 +2,371 @@ package glfw
/*** Constants ***/ /*** Constants ***/
/* Versions */ /* Versions */
VERSION_MAJOR :: 3; VERSION_MAJOR :: 3
VERSION_MINOR :: 3; VERSION_MINOR :: 3
VERSION_REVISION :: 4; VERSION_REVISION :: 4
/* Booleans */ /* Booleans */
TRUE :: true; TRUE :: true
FALSE :: false; FALSE :: false
/* Button/Key states */ /* Button/Key states */
RELEASE :: 0; RELEASE :: 0
PRESS :: 1; PRESS :: 1
REPEAT :: 2; REPEAT :: 2
/* Joystick hat states. */ /* Joystick hat states. */
HAT_CENTERED :: 0; HAT_CENTERED :: 0
HAT_UP :: 1; HAT_UP :: 1
HAT_RIGHT :: 2; HAT_RIGHT :: 2
HAT_DOWN :: 4; HAT_DOWN :: 4
HAT_LEFT :: 8; HAT_LEFT :: 8
HAT_RIGHT_UP :: (HAT_RIGHT | HAT_UP); HAT_RIGHT_UP :: (HAT_RIGHT | HAT_UP)
HAT_RIGHT_DOWN :: (HAT_RIGHT | HAT_DOWN); HAT_RIGHT_DOWN :: (HAT_RIGHT | HAT_DOWN)
HAT_LEFT_UP :: (HAT_LEFT | HAT_UP); HAT_LEFT_UP :: (HAT_LEFT | HAT_UP)
HAT_LEFT_DOWN :: (HAT_LEFT | HAT_DOWN); HAT_LEFT_DOWN :: (HAT_LEFT | HAT_DOWN)
/* The unknown key */ /* The unknown key */
KEY_UNKNOWN :: -1; KEY_UNKNOWN :: -1
/** Printable keys **/ /** Printable keys **/
/* Named printable keys */ /* Named printable keys */
KEY_SPACE :: 32; KEY_SPACE :: 32
KEY_APOSTROPHE :: 39; /* ' */ KEY_APOSTROPHE :: 39 /* ' */
KEY_COMMA :: 44; /* , */ KEY_COMMA :: 44 /* , */
KEY_MINUS :: 45; /* - */ KEY_MINUS :: 45 /* - */
KEY_PERIOD :: 46; /* . */ KEY_PERIOD :: 46 /* . */
KEY_SLASH :: 47; /* / */ KEY_SLASH :: 47 /* / */
KEY_SEMICOLON :: 59; /* ; */ KEY_SEMICOLON :: 59 /* ; */
KEY_EQUAL :: 61; /* :: */ KEY_EQUAL :: 61 /* :: */
KEY_LEFT_BRACKET :: 91; /* [ */ KEY_LEFT_BRACKET :: 91 /* [ */
KEY_BACKSLASH :: 92; /* \ */ KEY_BACKSLASH :: 92 /* \ */
KEY_RIGHT_BRACKET :: 93; /* ] */ KEY_RIGHT_BRACKET :: 93 /* ] */
KEY_GRAVE_ACCENT :: 96; /* ` */ KEY_GRAVE_ACCENT :: 96 /* ` */
KEY_WORLD_1 :: 161; /* non-US #1 */ KEY_WORLD_1 :: 161 /* non-US #1 */
KEY_WORLD_2 :: 162; /* non-US #2 */ KEY_WORLD_2 :: 162 /* non-US #2 */
/* Alphanumeric characters */ /* Alphanumeric characters */
KEY_0 :: 48; KEY_0 :: 48
KEY_1 :: 49; KEY_1 :: 49
KEY_2 :: 50; KEY_2 :: 50
KEY_3 :: 51; KEY_3 :: 51
KEY_4 :: 52; KEY_4 :: 52
KEY_5 :: 53; KEY_5 :: 53
KEY_6 :: 54; KEY_6 :: 54
KEY_7 :: 55; KEY_7 :: 55
KEY_8 :: 56; KEY_8 :: 56
KEY_9 :: 57; KEY_9 :: 57
KEY_A :: 65; KEY_A :: 65
KEY_B :: 66; KEY_B :: 66
KEY_C :: 67; KEY_C :: 67
KEY_D :: 68; KEY_D :: 68
KEY_E :: 69; KEY_E :: 69
KEY_F :: 70; KEY_F :: 70
KEY_G :: 71; KEY_G :: 71
KEY_H :: 72; KEY_H :: 72
KEY_I :: 73; KEY_I :: 73
KEY_J :: 74; KEY_J :: 74
KEY_K :: 75; KEY_K :: 75
KEY_L :: 76; KEY_L :: 76
KEY_M :: 77; KEY_M :: 77
KEY_N :: 78; KEY_N :: 78
KEY_O :: 79; KEY_O :: 79
KEY_P :: 80; KEY_P :: 80
KEY_Q :: 81; KEY_Q :: 81
KEY_R :: 82; KEY_R :: 82
KEY_S :: 83; KEY_S :: 83
KEY_T :: 84; KEY_T :: 84
KEY_U :: 85; KEY_U :: 85
KEY_V :: 86; KEY_V :: 86
KEY_W :: 87; KEY_W :: 87
KEY_X :: 88; KEY_X :: 88
KEY_Y :: 89; KEY_Y :: 89
KEY_Z :: 90; KEY_Z :: 90
/** Function keys **/ /** Function keys **/
/* Named non-printable keys */ /* Named non-printable keys */
KEY_ESCAPE :: 256; KEY_ESCAPE :: 256
KEY_ENTER :: 257; KEY_ENTER :: 257
KEY_TAB :: 258; KEY_TAB :: 258
KEY_BACKSPACE :: 259; KEY_BACKSPACE :: 259
KEY_INSERT :: 260; KEY_INSERT :: 260
KEY_DELETE :: 261; KEY_DELETE :: 261
KEY_RIGHT :: 262; KEY_RIGHT :: 262
KEY_LEFT :: 263; KEY_LEFT :: 263
KEY_DOWN :: 264; KEY_DOWN :: 264
KEY_UP :: 265; KEY_UP :: 265
KEY_PAGE_UP :: 266; KEY_PAGE_UP :: 266
KEY_PAGE_DOWN :: 267; KEY_PAGE_DOWN :: 267
KEY_HOME :: 268; KEY_HOME :: 268
KEY_END :: 269; KEY_END :: 269
KEY_CAPS_LOCK :: 280; KEY_CAPS_LOCK :: 280
KEY_SCROLL_LOCK :: 281; KEY_SCROLL_LOCK :: 281
KEY_NUM_LOCK :: 282; KEY_NUM_LOCK :: 282
KEY_PRINT_SCREEN :: 283; KEY_PRINT_SCREEN :: 283
KEY_PAUSE :: 284; KEY_PAUSE :: 284
/* Function keys */ /* Function keys */
KEY_F1 :: 290; KEY_F1 :: 290
KEY_F2 :: 291; KEY_F2 :: 291
KEY_F3 :: 292; KEY_F3 :: 292
KEY_F4 :: 293; KEY_F4 :: 293
KEY_F5 :: 294; KEY_F5 :: 294
KEY_F6 :: 295; KEY_F6 :: 295
KEY_F7 :: 296; KEY_F7 :: 296
KEY_F8 :: 297; KEY_F8 :: 297
KEY_F9 :: 298; KEY_F9 :: 298
KEY_F10 :: 299; KEY_F10 :: 299
KEY_F11 :: 300; KEY_F11 :: 300
KEY_F12 :: 301; KEY_F12 :: 301
KEY_F13 :: 302; KEY_F13 :: 302
KEY_F14 :: 303; KEY_F14 :: 303
KEY_F15 :: 304; KEY_F15 :: 304
KEY_F16 :: 305; KEY_F16 :: 305
KEY_F17 :: 306; KEY_F17 :: 306
KEY_F18 :: 307; KEY_F18 :: 307
KEY_F19 :: 308; KEY_F19 :: 308
KEY_F20 :: 309; KEY_F20 :: 309
KEY_F21 :: 310; KEY_F21 :: 310
KEY_F22 :: 311; KEY_F22 :: 311
KEY_F23 :: 312; KEY_F23 :: 312
KEY_F24 :: 313; KEY_F24 :: 313
KEY_F25 :: 314; KEY_F25 :: 314
/* Keypad numbers */ /* Keypad numbers */
KEY_KP_0 :: 320; KEY_KP_0 :: 320
KEY_KP_1 :: 321; KEY_KP_1 :: 321
KEY_KP_2 :: 322; KEY_KP_2 :: 322
KEY_KP_3 :: 323; KEY_KP_3 :: 323
KEY_KP_4 :: 324; KEY_KP_4 :: 324
KEY_KP_5 :: 325; KEY_KP_5 :: 325
KEY_KP_6 :: 326; KEY_KP_6 :: 326
KEY_KP_7 :: 327; KEY_KP_7 :: 327
KEY_KP_8 :: 328; KEY_KP_8 :: 328
KEY_KP_9 :: 329; KEY_KP_9 :: 329
/* Keypad named function keys */ /* Keypad named function keys */
KEY_KP_DECIMAL :: 330; KEY_KP_DECIMAL :: 330
KEY_KP_DIVIDE :: 331; KEY_KP_DIVIDE :: 331
KEY_KP_MULTIPLY :: 332; KEY_KP_MULTIPLY :: 332
KEY_KP_SUBTRACT :: 333; KEY_KP_SUBTRACT :: 333
KEY_KP_ADD :: 334; KEY_KP_ADD :: 334
KEY_KP_ENTER :: 335; KEY_KP_ENTER :: 335
KEY_KP_EQUAL :: 336; KEY_KP_EQUAL :: 336
/* Modifier keys */ /* Modifier keys */
KEY_LEFT_SHIFT :: 340; KEY_LEFT_SHIFT :: 340
KEY_LEFT_CONTROL :: 341; KEY_LEFT_CONTROL :: 341
KEY_LEFT_ALT :: 342; KEY_LEFT_ALT :: 342
KEY_LEFT_SUPER :: 343; KEY_LEFT_SUPER :: 343
KEY_RIGHT_SHIFT :: 344; KEY_RIGHT_SHIFT :: 344
KEY_RIGHT_CONTROL :: 345; KEY_RIGHT_CONTROL :: 345
KEY_RIGHT_ALT :: 346; KEY_RIGHT_ALT :: 346
KEY_RIGHT_SUPER :: 347; KEY_RIGHT_SUPER :: 347
KEY_MENU :: 348; KEY_MENU :: 348
KEY_LAST :: KEY_MENU; KEY_LAST :: KEY_MENU
/* Bitmask for modifier keys */ /* Bitmask for modifier keys */
MOD_SHIFT :: 0x0001; MOD_SHIFT :: 0x0001
MOD_CONTROL :: 0x0002; MOD_CONTROL :: 0x0002
MOD_ALT :: 0x0004; MOD_ALT :: 0x0004
MOD_SUPER :: 0x0008; MOD_SUPER :: 0x0008
MOD_CAPS_LOCK :: 0x0010; MOD_CAPS_LOCK :: 0x0010
MOD_NUM_LOCK :: 0x0020; MOD_NUM_LOCK :: 0x0020
/* Mouse buttons */ /* Mouse buttons */
MOUSE_BUTTON_1 :: 0; MOUSE_BUTTON_1 :: 0
MOUSE_BUTTON_2 :: 1; MOUSE_BUTTON_2 :: 1
MOUSE_BUTTON_3 :: 2; MOUSE_BUTTON_3 :: 2
MOUSE_BUTTON_4 :: 3; MOUSE_BUTTON_4 :: 3
MOUSE_BUTTON_5 :: 4; MOUSE_BUTTON_5 :: 4
MOUSE_BUTTON_6 :: 5; MOUSE_BUTTON_6 :: 5
MOUSE_BUTTON_7 :: 6; MOUSE_BUTTON_7 :: 6
MOUSE_BUTTON_8 :: 7; MOUSE_BUTTON_8 :: 7
/* Mousebutton aliases */ /* Mousebutton aliases */
MOUSE_BUTTON_LAST :: MOUSE_BUTTON_8; MOUSE_BUTTON_LAST :: MOUSE_BUTTON_8
MOUSE_BUTTON_LEFT :: MOUSE_BUTTON_1; MOUSE_BUTTON_LEFT :: MOUSE_BUTTON_1
MOUSE_BUTTON_RIGHT :: MOUSE_BUTTON_2; MOUSE_BUTTON_RIGHT :: MOUSE_BUTTON_2
MOUSE_BUTTON_MIDDLE :: MOUSE_BUTTON_3; MOUSE_BUTTON_MIDDLE :: MOUSE_BUTTON_3
/* Joystick buttons */ /* Joystick buttons */
JOYSTICK_1 :: 0; JOYSTICK_1 :: 0
JOYSTICK_2 :: 1; JOYSTICK_2 :: 1
JOYSTICK_3 :: 2; JOYSTICK_3 :: 2
JOYSTICK_4 :: 3; JOYSTICK_4 :: 3
JOYSTICK_5 :: 4; JOYSTICK_5 :: 4
JOYSTICK_6 :: 5; JOYSTICK_6 :: 5
JOYSTICK_7 :: 6; JOYSTICK_7 :: 6
JOYSTICK_8 :: 7; JOYSTICK_8 :: 7
JOYSTICK_9 :: 8; JOYSTICK_9 :: 8
JOYSTICK_10 :: 9; JOYSTICK_10 :: 9
JOYSTICK_11 :: 10; JOYSTICK_11 :: 10
JOYSTICK_12 :: 11; JOYSTICK_12 :: 11
JOYSTICK_13 :: 12; JOYSTICK_13 :: 12
JOYSTICK_14 :: 13; JOYSTICK_14 :: 13
JOYSTICK_15 :: 14; JOYSTICK_15 :: 14
JOYSTICK_16 :: 15; JOYSTICK_16 :: 15
JOYSTICK_LAST :: JOYSTICK_16; JOYSTICK_LAST :: JOYSTICK_16
/* Gamepad buttons */ /* Gamepad buttons */
GAMEPAD_BUTTON_A :: 0; GAMEPAD_BUTTON_A :: 0
GAMEPAD_BUTTON_B :: 1; GAMEPAD_BUTTON_B :: 1
GAMEPAD_BUTTON_X :: 2; GAMEPAD_BUTTON_X :: 2
GAMEPAD_BUTTON_Y :: 3; GAMEPAD_BUTTON_Y :: 3
GAMEPAD_BUTTON_LEFT_BUMPER :: 4; GAMEPAD_BUTTON_LEFT_BUMPER :: 4
GAMEPAD_BUTTON_RIGHT_BUMPER :: 5; GAMEPAD_BUTTON_RIGHT_BUMPER :: 5
GAMEPAD_BUTTON_BACK :: 6; GAMEPAD_BUTTON_BACK :: 6
GAMEPAD_BUTTON_START :: 7; GAMEPAD_BUTTON_START :: 7
GAMEPAD_BUTTON_GUIDE :: 8; GAMEPAD_BUTTON_GUIDE :: 8
GAMEPAD_BUTTON_LEFT_THUMB :: 9; GAMEPAD_BUTTON_LEFT_THUMB :: 9
GAMEPAD_BUTTON_RIGHT_THUMB :: 10; GAMEPAD_BUTTON_RIGHT_THUMB :: 10
GAMEPAD_BUTTON_DPAD_UP :: 11; GAMEPAD_BUTTON_DPAD_UP :: 11
GAMEPAD_BUTTON_DPAD_RIGHT :: 12; GAMEPAD_BUTTON_DPAD_RIGHT :: 12
GAMEPAD_BUTTON_DPAD_DOWN :: 13; GAMEPAD_BUTTON_DPAD_DOWN :: 13
GAMEPAD_BUTTON_DPAD_LEFT :: 14; GAMEPAD_BUTTON_DPAD_LEFT :: 14
GAMEPAD_BUTTON_LAST :: GAMEPAD_BUTTON_DPAD_LEFT; GAMEPAD_BUTTON_LAST :: GAMEPAD_BUTTON_DPAD_LEFT
GAMEPAD_BUTTON_CROSS :: GAMEPAD_BUTTON_A; GAMEPAD_BUTTON_CROSS :: GAMEPAD_BUTTON_A
GAMEPAD_BUTTON_CIRCLE :: GAMEPAD_BUTTON_B; GAMEPAD_BUTTON_CIRCLE :: GAMEPAD_BUTTON_B
GAMEPAD_BUTTON_SQUARE :: GAMEPAD_BUTTON_X; GAMEPAD_BUTTON_SQUARE :: GAMEPAD_BUTTON_X
GAMEPAD_BUTTON_TRIANGLE :: GAMEPAD_BUTTON_Y; GAMEPAD_BUTTON_TRIANGLE :: GAMEPAD_BUTTON_Y
/* Gamepad axes */ /* Gamepad axes */
GAMEPAD_AXIS_LEFT_X :: 0; GAMEPAD_AXIS_LEFT_X :: 0
GAMEPAD_AXIS_LEFT_Y :: 1; GAMEPAD_AXIS_LEFT_Y :: 1
GAMEPAD_AXIS_RIGHT_X :: 2; GAMEPAD_AXIS_RIGHT_X :: 2
GAMEPAD_AXIS_RIGHT_Y :: 3; GAMEPAD_AXIS_RIGHT_Y :: 3
GAMEPAD_AXIS_LEFT_TRIGGER :: 4; GAMEPAD_AXIS_LEFT_TRIGGER :: 4
GAMEPAD_AXIS_RIGHT_TRIGGER :: 5; GAMEPAD_AXIS_RIGHT_TRIGGER :: 5
GAMEPAD_AXIS_LAST :: GAMEPAD_AXIS_RIGHT_TRIGGER; GAMEPAD_AXIS_LAST :: GAMEPAD_AXIS_RIGHT_TRIGGER
/* Error constants */ /* Error constants */
NO_ERROR :: 0x00000000; NO_ERROR :: 0x00000000
NOT_INITIALIZED :: 0x00010001; NOT_INITIALIZED :: 0x00010001
NO_CURRENT_CONTEXT :: 0x00010002; NO_CURRENT_CONTEXT :: 0x00010002
INVALID_ENUM :: 0x00010003; INVALID_ENUM :: 0x00010003
INVALID_VALUE :: 0x00010004; INVALID_VALUE :: 0x00010004
OUT_OF_MEMORY :: 0x00010005; OUT_OF_MEMORY :: 0x00010005
API_UNAVAILABLE :: 0x00010006; API_UNAVAILABLE :: 0x00010006
VERSION_UNAVAILABLE :: 0x00010007; VERSION_UNAVAILABLE :: 0x00010007
PLATFORM_ERROR :: 0x00010008; PLATFORM_ERROR :: 0x00010008
FORMAT_UNAVAILABLE :: 0x00010009; FORMAT_UNAVAILABLE :: 0x00010009
NO_WINDOW_CONTEXT :: 0x0001000A; NO_WINDOW_CONTEXT :: 0x0001000A
/* Window attributes */ /* Window attributes */
FOCUSED :: 0x00020001; FOCUSED :: 0x00020001
ICONIFIED :: 0x00020002; ICONIFIED :: 0x00020002
RESIZABLE :: 0x00020003; RESIZABLE :: 0x00020003
VISIBLE :: 0x00020004; VISIBLE :: 0x00020004
DECORATED :: 0x00020005; DECORATED :: 0x00020005
AUTO_ICONIFY :: 0x00020006; AUTO_ICONIFY :: 0x00020006
FLOATING :: 0x00020007; FLOATING :: 0x00020007
MAXIMIZED :: 0x00020008; MAXIMIZED :: 0x00020008
CENTER_CURSOR :: 0x00020009; CENTER_CURSOR :: 0x00020009
TRANSPARENT_FRAMEBUFFER :: 0x0002000A; TRANSPARENT_FRAMEBUFFER :: 0x0002000A
HOVERED :: 0x0002000B; HOVERED :: 0x0002000B
FOCUS_ON_SHOW :: 0x0002000C; FOCUS_ON_SHOW :: 0x0002000C
/* Pixel window attributes */ /* Pixel window attributes */
RED_BITS :: 0x00021001; RED_BITS :: 0x00021001
GREEN_BITS :: 0x00021002; GREEN_BITS :: 0x00021002
BLUE_BITS :: 0x00021003; BLUE_BITS :: 0x00021003
ALPHA_BITS :: 0x00021004; ALPHA_BITS :: 0x00021004
DEPTH_BITS :: 0x00021005; DEPTH_BITS :: 0x00021005
STENCIL_BITS :: 0x00021006; STENCIL_BITS :: 0x00021006
ACCUM_RED_BITS :: 0x00021007; ACCUM_RED_BITS :: 0x00021007
ACCUM_GREEN_BITS :: 0x00021008; ACCUM_GREEN_BITS :: 0x00021008
ACCUM_BLUE_BITS :: 0x00021009; ACCUM_BLUE_BITS :: 0x00021009
ACCUM_ALPHA_BITS :: 0x0002100A; ACCUM_ALPHA_BITS :: 0x0002100A
AUX_BUFFERS :: 0x0002100B; AUX_BUFFERS :: 0x0002100B
STEREO :: 0x0002100C; STEREO :: 0x0002100C
SAMPLES :: 0x0002100D; SAMPLES :: 0x0002100D
SRGB_CAPABLE :: 0x0002100E; SRGB_CAPABLE :: 0x0002100E
REFRESH_RATE :: 0x0002100F; REFRESH_RATE :: 0x0002100F
DOUBLEBUFFER :: 0x00021010; DOUBLEBUFFER :: 0x00021010
/* Context window attributes */ /* Context window attributes */
CLIENT_API :: 0x00022001; CLIENT_API :: 0x00022001
CONTEXT_VERSION_MAJOR :: 0x00022002; CONTEXT_VERSION_MAJOR :: 0x00022002
CONTEXT_VERSION_MINOR :: 0x00022003; CONTEXT_VERSION_MINOR :: 0x00022003
CONTEXT_REVISION :: 0x00022004; CONTEXT_REVISION :: 0x00022004
CONTEXT_ROBUSTNESS :: 0x00022005; CONTEXT_ROBUSTNESS :: 0x00022005
OPENGL_FORWARD_COMPAT :: 0x00022006; OPENGL_FORWARD_COMPAT :: 0x00022006
OPENGL_DEBUG_CONTEXT :: 0x00022007; OPENGL_DEBUG_CONTEXT :: 0x00022007
OPENGL_PROFILE :: 0x00022008; OPENGL_PROFILE :: 0x00022008
CONTEXT_RELEASE_BEHAVIOR :: 0x00022009; CONTEXT_RELEASE_BEHAVIOR :: 0x00022009
CONTEXT_NO_ERROR :: 0x0002200A; CONTEXT_NO_ERROR :: 0x0002200A
CONTEXT_CREATION_API :: 0x0002200B; CONTEXT_CREATION_API :: 0x0002200B
SCALE_TO_MONITOR :: 0x0002200C; SCALE_TO_MONITOR :: 0x0002200C
/* Cross platform attributes */ /* Cross platform attributes */
COCOA_RETINA_FRAMEBUFFER :: 0x00023001; COCOA_RETINA_FRAMEBUFFER :: 0x00023001
COCOA_FRAME_NAME :: 0x00023002; COCOA_FRAME_NAME :: 0x00023002
COCOA_GRAPHICS_SWITCHING :: 0x00023003; COCOA_GRAPHICS_SWITCHING :: 0x00023003
X11_CLASS_NAME :: 0x00024001; X11_CLASS_NAME :: 0x00024001
X11_INSTANCE_NAME :: 0x00024002; X11_INSTANCE_NAME :: 0x00024002
/* APIs */ /* APIs */
NO_API :: 0; NO_API :: 0
OPENGL_API :: 0x00030001; OPENGL_API :: 0x00030001
OPENGL_ES_API :: 0x00030002; OPENGL_ES_API :: 0x00030002
/* Robustness? */ /* Robustness? */
NO_ROBUSTNESS :: 0; NO_ROBUSTNESS :: 0
NO_RESET_NOTIFICATION :: 0x00031001; NO_RESET_NOTIFICATION :: 0x00031001
LOSE_CONTEXT_ON_RESET :: 0x00031002; LOSE_CONTEXT_ON_RESET :: 0x00031002
/* OpenGL Profiles */ /* OpenGL Profiles */
OPENGL_ANY_PROFILE :: 0; OPENGL_ANY_PROFILE :: 0
OPENGL_CORE_PROFILE :: 0x00032001; OPENGL_CORE_PROFILE :: 0x00032001
OPENGL_COMPAT_PROFILE :: 0x00032002; OPENGL_COMPAT_PROFILE :: 0x00032002
/* Cursor draw state and whether keys are sticky */ /* Cursor draw state and whether keys are sticky */
CURSOR :: 0x00033001; CURSOR :: 0x00033001
STICKY_KEYS :: 0x00033002; STICKY_KEYS :: 0x00033002
STICKY_MOUSE_BUTTONS :: 0x00033003; STICKY_MOUSE_BUTTONS :: 0x00033003
LOCK_KEY_MODS :: 0x00033004; LOCK_KEY_MODS :: 0x00033004
/* Cursor draw state */ /* Cursor draw state */
CURSOR_NORMAL :: 0x00034001; CURSOR_NORMAL :: 0x00034001
CURSOR_HIDDEN :: 0x00034002; CURSOR_HIDDEN :: 0x00034002
CURSOR_DISABLED :: 0x00034003; CURSOR_DISABLED :: 0x00034003
/* Behavior? */ /* Behavior? */
ANY_RELEASE_BEHAVIOR :: 0; ANY_RELEASE_BEHAVIOR :: 0
RELEASE_BEHAVIOR_FLUSH :: 0x00035001; RELEASE_BEHAVIOR_FLUSH :: 0x00035001
RELEASE_BEHAVIOR_NONE :: 0x00035002; RELEASE_BEHAVIOR_NONE :: 0x00035002
/* Context API ? */ /* Context API ? */
NATIVE_CONTEXT_API :: 0x00036001; NATIVE_CONTEXT_API :: 0x00036001
EGL_CONTEXT_API :: 0x00036002; EGL_CONTEXT_API :: 0x00036002
OSMESA_CONTEXT_API :: 0x00036003; OSMESA_CONTEXT_API :: 0x00036003
/* Types of cursors */ /* Types of cursors */
ARROW_CURSOR :: 0x00036001; ARROW_CURSOR :: 0x00036001
IBEAM_CURSOR :: 0x00036002; IBEAM_CURSOR :: 0x00036002
CROSSHAIR_CURSOR :: 0x00036003; CROSSHAIR_CURSOR :: 0x00036003
HAND_CURSOR :: 0x00036004; HAND_CURSOR :: 0x00036004
HRESIZE_CURSOR :: 0x00036005; HRESIZE_CURSOR :: 0x00036005
VRESIZE_CURSOR :: 0x00036006; VRESIZE_CURSOR :: 0x00036006
RESIZE_NWSE_CURSOR :: 0x00036007; RESIZE_NWSE_CURSOR :: 0x00036007
RESIZE_NESW_CURSOR :: 0x00036008; RESIZE_NESW_CURSOR :: 0x00036008
/* Joystick? */ /* Joystick? */
CONNECTED :: 0x00040001; CONNECTED :: 0x00040001
DISCONNECTED :: 0x00040002; DISCONNECTED :: 0x00040002
/* macOS specific init hint. */ /* macOS specific init hint. */
JOYSTICK_HAT_BUTTONS :: 0x00050001; JOYSTICK_HAT_BUTTONS :: 0x00050001
COCOA_CHDIR_RESOURCES :: 0x00051001; COCOA_CHDIR_RESOURCES :: 0x00051001
COCOA_MENUBAR :: 0x00051002; COCOA_MENUBAR :: 0x00051002
/* */ /* */
DONT_CARE :: -1; DONT_CARE :: -1
vendor/glfw/types.odin
Vendored
+27 -27
View File
@@ -2,35 +2,35 @@ package glfw
import glfw "bindings" import glfw "bindings"
WindowHandle :: glfw.WindowHandle; WindowHandle :: glfw.WindowHandle
MonitorHandle :: glfw.MonitorHandle; MonitorHandle :: glfw.MonitorHandle
CursorHandle :: glfw.CursorHandle; CursorHandle :: glfw.CursorHandle
VidMode :: glfw.VidMode; VidMode :: glfw.VidMode
GammaRamp :: glfw.GammaRamp; GammaRamp :: glfw.GammaRamp
Image :: glfw.Image; Image :: glfw.Image
GamepadState :: glfw.GamepadState; GamepadState :: glfw.GamepadState
/*** Procedure type declarations ***/ /*** Procedure type declarations ***/
WindowIconifyProc :: glfw.WindowIconifyProc; WindowIconifyProc :: glfw.WindowIconifyProc
WindowRefreshProc :: glfw.WindowRefreshProc; WindowRefreshProc :: glfw.WindowRefreshProc
WindowFocusProc :: glfw.WindowFocusProc; WindowFocusProc :: glfw.WindowFocusProc
WindowCloseProc :: glfw.WindowCloseProc; WindowCloseProc :: glfw.WindowCloseProc
WindowSizeProc :: glfw.WindowSizeProc; WindowSizeProc :: glfw.WindowSizeProc
WindowPosProc :: glfw.WindowPosProc; WindowPosProc :: glfw.WindowPosProc
WindowMaximizeProc :: glfw.WindowMaximizeProc; WindowMaximizeProc :: glfw.WindowMaximizeProc
WindowContentScaleProc :: glfw.WindowContentScaleProc; WindowContentScaleProc :: glfw.WindowContentScaleProc
FramebufferSizeProc :: glfw.FramebufferSizeProc; FramebufferSizeProc :: glfw.FramebufferSizeProc
DropProc :: glfw.DropProc; DropProc :: glfw.DropProc
MonitorProc :: glfw.MonitorProc; MonitorProc :: glfw.MonitorProc
KeyProc :: glfw.KeyProc; KeyProc :: glfw.KeyProc
MouseButtonProc :: glfw.MouseButtonProc; MouseButtonProc :: glfw.MouseButtonProc
CursorPosProc :: glfw.CursorPosProc; CursorPosProc :: glfw.CursorPosProc
ScrollProc :: glfw.ScrollProc; ScrollProc :: glfw.ScrollProc
CharProc :: glfw.CharProc; CharProc :: glfw.CharProc
CharModsProc :: glfw.CharModsProc; CharModsProc :: glfw.CharModsProc
CursorEnterProc :: glfw.CursorEnterProc; CursorEnterProc :: glfw.CursorEnterProc
JoystickProc :: glfw.JoystickProc; JoystickProc :: glfw.JoystickProc
ErrorProc :: glfw.ErrorProc; ErrorProc :: glfw.ErrorProc
vendor/glfw/wrapper.odin
Vendored
+143 -143
View File
@@ -3,229 +3,229 @@ package glfw
import "core:c" import "core:c"
import glfw "bindings" import glfw "bindings"
Init :: glfw.Init; Init :: glfw.Init
Terminate :: glfw.Terminate; Terminate :: glfw.Terminate
InitHint :: glfw.InitHint; InitHint :: glfw.InitHint
GetVersion :: proc "c" () -> (major, minor, rev: c.int) { GetVersion :: proc "c" () -> (major, minor, rev: c.int) {
glfw.GetVersion(&major, &minor, &rev); glfw.GetVersion(&major, &minor, &rev)
return; return
} }
GetError :: proc "c" () -> (description: string, code: c.int) { GetError :: proc "c" () -> (description: string, code: c.int) {
desc: cstring; desc: cstring
code = glfw.GetError(&desc); code = glfw.GetError(&desc)
description = string(desc); description = string(desc)
return; return
} }
GetPrimaryMonitor :: glfw.GetPrimaryMonitor; GetPrimaryMonitor :: glfw.GetPrimaryMonitor
GetMonitors :: proc "c" () -> []MonitorHandle { GetMonitors :: proc "c" () -> []MonitorHandle {
count: c.int; count: c.int
monitors := glfw.GetMonitors(&count); monitors := glfw.GetMonitors(&count)
return monitors[:count]; return monitors[:count]
} }
GetMonitorPos :: proc "c" (monitor: MonitorHandle) -> (xpos, ypos: c.int) { GetMonitorPos :: proc "c" (monitor: MonitorHandle) -> (xpos, ypos: c.int) {
glfw.GetMonitorPos(monitor, &xpos, &ypos); glfw.GetMonitorPos(monitor, &xpos, &ypos)
return; return
} }
GetMonitorPhysicalSize :: proc "c" (monitor: MonitorHandle) -> (widthMM, heightMM: c.int) { GetMonitorPhysicalSize :: proc "c" (monitor: MonitorHandle) -> (widthMM, heightMM: c.int) {
glfw.GetMonitorPhysicalSize(monitor, &widthMM, &heightMM); glfw.GetMonitorPhysicalSize(monitor, &widthMM, &heightMM)
return; return
} }
GetMonitorContentScale :: proc "c" (monitor: MonitorHandle) -> (xscale, yscale: f32) { GetMonitorContentScale :: proc "c" (monitor: MonitorHandle) -> (xscale, yscale: f32) {
glfw.GetMonitorContentScale(monitor, &xscale, &yscale); glfw.GetMonitorContentScale(monitor, &xscale, &yscale)
return; return
} }
SetMonitorUserPointer :: glfw.SetMonitorUserPointer; SetMonitorUserPointer :: glfw.SetMonitorUserPointer
GetMonitorUserPointer :: glfw.GetMonitorUserPointer; GetMonitorUserPointer :: glfw.GetMonitorUserPointer
GetVideoMode :: glfw.GetVideoMode; GetVideoMode :: glfw.GetVideoMode
SetGamma :: glfw.SetGamma; SetGamma :: glfw.SetGamma
GetGammaRamp :: glfw.GetGammaRamp; GetGammaRamp :: glfw.GetGammaRamp
SetGammaRamp :: glfw.SetGammaRamp; SetGammaRamp :: glfw.SetGammaRamp
CreateWindow :: glfw.CreateWindow; CreateWindow :: glfw.CreateWindow
DestroyWindow :: glfw.DestroyWindow; DestroyWindow :: glfw.DestroyWindow
WindowHint :: glfw.WindowHint; WindowHint :: glfw.WindowHint
DefaultWindowHints :: glfw.DefaultWindowHints; DefaultWindowHints :: glfw.DefaultWindowHints
WindowHintString :: glfw.WindowHintString; WindowHintString :: glfw.WindowHintString
WindowShouldClose :: glfw.WindowShouldClose; WindowShouldClose :: glfw.WindowShouldClose
SwapInterval :: glfw.SwapInterval; SwapInterval :: glfw.SwapInterval
SwapBuffers :: glfw.SwapBuffers; SwapBuffers :: glfw.SwapBuffers
SetWindowTitle :: glfw.SetWindowTitle; SetWindowTitle :: glfw.SetWindowTitle
SetWindowIcon :: proc "c" (window: WindowHandle, images: []Image) { SetWindowIcon :: proc "c" (window: WindowHandle, images: []Image) {
glfw.SetWindowIcon(window, c.int(len(images)), raw_data(images)); glfw.SetWindowIcon(window, c.int(len(images)), raw_data(images))
} }
SetWindowPos :: glfw.SetWindowPos; SetWindowPos :: glfw.SetWindowPos
SetWindowSizeLimits :: glfw.SetWindowSizeLimits; SetWindowSizeLimits :: glfw.SetWindowSizeLimits
SetWindowAspectRatio :: glfw.SetWindowAspectRatio; SetWindowAspectRatio :: glfw.SetWindowAspectRatio
SetWindowSize :: glfw.SetWindowSize; SetWindowSize :: glfw.SetWindowSize
GetWindowPos :: proc "c" (window: WindowHandle) -> (xpos, ypos: c.int) { GetWindowPos :: proc "c" (window: WindowHandle) -> (xpos, ypos: c.int) {
glfw.GetWindowPos(window, &xpos, &ypos); glfw.GetWindowPos(window, &xpos, &ypos)
return; return
} }
GetWindowSize :: proc "c" (window: WindowHandle) -> (width, height: c.int) { GetWindowSize :: proc "c" (window: WindowHandle) -> (width, height: c.int) {
glfw.GetWindowSize(window, &width, &height); glfw.GetWindowSize(window, &width, &height)
return; return
} }
GetFramebufferSize :: proc "c" (window: WindowHandle) -> (width, height: c.int) { GetFramebufferSize :: proc "c" (window: WindowHandle) -> (width, height: c.int) {
glfw.GetFramebufferSize(window, &width, &height); glfw.GetFramebufferSize(window, &width, &height)
return; return
} }
GetWindowFrameSize :: proc "c" (window: WindowHandle) -> (left, top, right, bottom: c.int) { GetWindowFrameSize :: proc "c" (window: WindowHandle) -> (left, top, right, bottom: c.int) {
glfw.GetWindowFrameSize(window, &left, &top, &right, &bottom); glfw.GetWindowFrameSize(window, &left, &top, &right, &bottom)
return; return
} }
GetWindowContentScale :: proc "c" (window: WindowHandle) -> (xscale, yscale: f32) { GetWindowContentScale :: proc "c" (window: WindowHandle) -> (xscale, yscale: f32) {
glfw.GetWindowContentScale(window, &xscale, &yscale); glfw.GetWindowContentScale(window, &xscale, &yscale)
return; return
} }
GetWindowOpacity :: glfw.GetWindowOpacity; GetWindowOpacity :: glfw.GetWindowOpacity
SetWindowOpacity :: glfw.SetWindowOpacity; SetWindowOpacity :: glfw.SetWindowOpacity
GetVersionString :: proc "c" () -> string { GetVersionString :: proc "c" () -> string {
return string(glfw.GetVersionString()); return string(glfw.GetVersionString())
} }
GetMonitorName :: proc "c" (monitor: MonitorHandle) -> string { GetMonitorName :: proc "c" (monitor: MonitorHandle) -> string {
return string(glfw.GetMonitorName(monitor)); return string(glfw.GetMonitorName(monitor))
} }
GetClipboardString :: proc "c" (window: WindowHandle) -> string { GetClipboardString :: proc "c" (window: WindowHandle) -> string {
return string(glfw.GetClipboardString(window)); return string(glfw.GetClipboardString(window))
} }
GetVideoModes :: proc "c" (monitor: MonitorHandle) -> []VidMode { GetVideoModes :: proc "c" (monitor: MonitorHandle) -> []VidMode {
count: c.int; count: c.int
modes := glfw.GetVideoModes(monitor, &count); modes := glfw.GetVideoModes(monitor, &count)
return modes[:count]; return modes[:count]
} }
GetKey :: glfw.GetKey; GetKey :: glfw.GetKey
GetKeyName :: proc "c" (key, scancode: c.int) -> string { GetKeyName :: proc "c" (key, scancode: c.int) -> string {
return string(glfw.GetKeyName(key, scancode)); return string(glfw.GetKeyName(key, scancode))
} }
SetWindowShouldClose :: glfw.SetWindowShouldClose; SetWindowShouldClose :: glfw.SetWindowShouldClose
JoystickPresent :: glfw.JoystickPresent; JoystickPresent :: glfw.JoystickPresent
GetJoystickName :: proc "c" (joy: c.int) -> string { GetJoystickName :: proc "c" (joy: c.int) -> string {
return string(glfw.GetJoystickName(joy)); return string(glfw.GetJoystickName(joy))
} }
GetKeyScancode :: glfw.GetKeyScancode; GetKeyScancode :: glfw.GetKeyScancode
IconifyWindow :: glfw.IconifyWindow; IconifyWindow :: glfw.IconifyWindow
RestoreWindow :: glfw.RestoreWindow; RestoreWindow :: glfw.RestoreWindow
MaximizeWindow :: glfw.MaximizeWindow; MaximizeWindow :: glfw.MaximizeWindow
ShowWindow :: glfw.ShowWindow; ShowWindow :: glfw.ShowWindow
HideWindow :: glfw.HideWindow; HideWindow :: glfw.HideWindow
FocusWindow :: glfw.FocusWindow; FocusWindow :: glfw.FocusWindow
RequestWindowAttention :: glfw.RequestWindowAttention; RequestWindowAttention :: glfw.RequestWindowAttention
GetWindowMonitor :: glfw.GetWindowMonitor; GetWindowMonitor :: glfw.GetWindowMonitor
SetWindowMonitor :: glfw.SetWindowMonitor; SetWindowMonitor :: glfw.SetWindowMonitor
GetWindowAttrib :: glfw.GetWindowAttrib; GetWindowAttrib :: glfw.GetWindowAttrib
SetWindowUserPointer :: glfw.SetWindowUserPointer; SetWindowUserPointer :: glfw.SetWindowUserPointer
GetWindowUserPointer :: glfw.GetWindowUserPointer; GetWindowUserPointer :: glfw.GetWindowUserPointer
SetWindowAttrib :: glfw.SetWindowAttrib; SetWindowAttrib :: glfw.SetWindowAttrib
PollEvents :: glfw.PollEvents; PollEvents :: glfw.PollEvents
WaitEvents :: glfw.WaitEvents; WaitEvents :: glfw.WaitEvents
WaitEventsTimeout :: glfw.WaitEventsTimeout; WaitEventsTimeout :: glfw.WaitEventsTimeout
PostEmptyEvent :: glfw.PostEmptyEvent; PostEmptyEvent :: glfw.PostEmptyEvent
GetInputMode :: glfw.GetInputMode; GetInputMode :: glfw.GetInputMode
SetInputMode :: glfw.SetInputMode; SetInputMode :: glfw.SetInputMode
GetMouseButton :: glfw.GetMouseButton; GetMouseButton :: glfw.GetMouseButton
GetCursorPos :: proc "c" (window: WindowHandle) -> (xpos, ypos: f64) { GetCursorPos :: proc "c" (window: WindowHandle) -> (xpos, ypos: f64) {
glfw.GetCursorPos(window, &xpos, &ypos); glfw.GetCursorPos(window, &xpos, &ypos)
return; return
} }
SetCursorPos :: glfw.SetCursorPos; SetCursorPos :: glfw.SetCursorPos
CreateCursor :: glfw.CreateCursor; CreateCursor :: glfw.CreateCursor
DestroyCursor :: glfw.DestroyCursor; DestroyCursor :: glfw.DestroyCursor
SetCursor :: glfw.SetCursor; SetCursor :: glfw.SetCursor
CreateStandardCursor :: glfw.CreateStandardCursor; CreateStandardCursor :: glfw.CreateStandardCursor
GetJoystickAxes :: proc "c" (joy: c.int) -> []f32 { GetJoystickAxes :: proc "c" (joy: c.int) -> []f32 {
count: c.int; count: c.int
axes := glfw.GetJoystickAxes(joy, &count); axes := glfw.GetJoystickAxes(joy, &count)
return axes[:count]; return axes[:count]
} }
GetJoystickButtons :: proc "c" (joy: c.int) -> []u8 { GetJoystickButtons :: proc "c" (joy: c.int) -> []u8 {
count: c.int; count: c.int
buttons := glfw.GetJoystickButtons(joy, &count); buttons := glfw.GetJoystickButtons(joy, &count)
return buttons[:count]; return buttons[:count]
} }
GetJoystickHats :: proc "c" (jid: c.int) -> []u8 { GetJoystickHats :: proc "c" (jid: c.int) -> []u8 {
count: c.int; count: c.int
hats := glfw.GetJoystickHats(jid, &count); hats := glfw.GetJoystickHats(jid, &count)
return hats[:count]; return hats[:count]
} }
GetJoystickGUID :: proc "c" (jid: c.int) -> string { GetJoystickGUID :: proc "c" (jid: c.int) -> string {
return string(glfw.GetJoystickGUID(jid)); return string(glfw.GetJoystickGUID(jid))
} }
SetJoystickUserPointer :: glfw.SetJoystickUserPointer; SetJoystickUserPointer :: glfw.SetJoystickUserPointer
GetJoystickUserPointer :: glfw.GetJoystickUserPointer; GetJoystickUserPointer :: glfw.GetJoystickUserPointer
JoystickIsGamepad :: glfw.JoystickIsGamepad; JoystickIsGamepad :: glfw.JoystickIsGamepad
UpdateGamepadMappings :: glfw.UpdateGamepadMappings; UpdateGamepadMappings :: glfw.UpdateGamepadMappings
GetGamepadName :: proc "c" (jid: c.int) -> string { GetGamepadName :: proc "c" (jid: c.int) -> string {
return string(glfw.GetGamepadName(jid)); return string(glfw.GetGamepadName(jid))
} }
GetGamepadState :: glfw.GetGamepadState; GetGamepadState :: glfw.GetGamepadState
SetClipboardString :: glfw.SetClipboardString; SetClipboardString :: glfw.SetClipboardString
SetTime :: glfw.SetTime; SetTime :: glfw.SetTime
GetTime :: glfw.GetTime; GetTime :: glfw.GetTime
GetTimerValue :: glfw.GetTimerValue; GetTimerValue :: glfw.GetTimerValue
GetTimerFrequency :: glfw.GetTimerFrequency; GetTimerFrequency :: glfw.GetTimerFrequency
MakeContextCurrent :: glfw.MakeContextCurrent; MakeContextCurrent :: glfw.MakeContextCurrent
GetCurrentContext :: glfw.GetCurrentContext; GetCurrentContext :: glfw.GetCurrentContext
GetProcAddress :: glfw.GetProcAddress; GetProcAddress :: glfw.GetProcAddress
ExtensionSupported :: glfw.ExtensionSupported; ExtensionSupported :: glfw.ExtensionSupported
VulkanSupported :: glfw.VulkanSupported; VulkanSupported :: glfw.VulkanSupported
GetRequiredInstanceExtensions :: proc "c" () -> []cstring { GetRequiredInstanceExtensions :: proc "c" () -> []cstring {
count: u32; count: u32
exts := glfw.GetRequiredInstanceExtensions(&count); exts := glfw.GetRequiredInstanceExtensions(&count)
return exts[:count]; return exts[:count]
} }
GetInstanceProcAddress :: glfw.GetInstanceProcAddress; GetInstanceProcAddress :: glfw.GetInstanceProcAddress
GetPhysicalDevicePresentationSupport :: glfw.GetPhysicalDevicePresentationSupport; GetPhysicalDevicePresentationSupport :: glfw.GetPhysicalDevicePresentationSupport
CreateWindowSurface :: glfw.CreateWindowSurface; CreateWindowSurface :: glfw.CreateWindowSurface
SetWindowIconifyCallback :: glfw.SetWindowIconifyCallback; SetWindowIconifyCallback :: glfw.SetWindowIconifyCallback
SetWindowRefreshCallback :: glfw.SetWindowRefreshCallback; SetWindowRefreshCallback :: glfw.SetWindowRefreshCallback
SetWindowFocusCallback :: glfw.SetWindowFocusCallback; SetWindowFocusCallback :: glfw.SetWindowFocusCallback
SetWindowCloseCallback :: glfw.SetWindowCloseCallback; SetWindowCloseCallback :: glfw.SetWindowCloseCallback
SetWindowSizeCallback :: glfw.SetWindowSizeCallback; SetWindowSizeCallback :: glfw.SetWindowSizeCallback
SetWindowPosCallback :: glfw.SetWindowPosCallback; SetWindowPosCallback :: glfw.SetWindowPosCallback
SetFramebufferSizeCallback :: glfw.SetFramebufferSizeCallback; SetFramebufferSizeCallback :: glfw.SetFramebufferSizeCallback
SetDropCallback :: glfw.SetDropCallback; SetDropCallback :: glfw.SetDropCallback
SetMonitorCallback :: glfw.SetMonitorCallback; SetMonitorCallback :: glfw.SetMonitorCallback
SetWindowMaximizeCallback :: glfw.SetWindowMaximizeCallback; SetWindowMaximizeCallback :: glfw.SetWindowMaximizeCallback
SetWindowContentScaleCallback :: glfw.SetWindowContentScaleCallback; SetWindowContentScaleCallback :: glfw.SetWindowContentScaleCallback
SetKeyCallback :: glfw.SetKeyCallback; SetKeyCallback :: glfw.SetKeyCallback
SetMouseButtonCallback :: glfw.SetMouseButtonCallback; SetMouseButtonCallback :: glfw.SetMouseButtonCallback
SetCursorPosCallback :: glfw.SetCursorPosCallback; SetCursorPosCallback :: glfw.SetCursorPosCallback
SetScrollCallback :: glfw.SetScrollCallback; SetScrollCallback :: glfw.SetScrollCallback
SetCharCallback :: glfw.SetCharCallback; SetCharCallback :: glfw.SetCharCallback
SetCharModsCallback :: glfw.SetCharModsCallback; SetCharModsCallback :: glfw.SetCharModsCallback
SetCursorEnterCallback :: glfw.SetCursorEnterCallback; SetCursorEnterCallback :: glfw.SetCursorEnterCallback
SetJoystickCallback :: glfw.SetJoystickCallback; SetJoystickCallback :: glfw.SetJoystickCallback
SetErrorCallback :: glfw.SetErrorCallback; SetErrorCallback :: glfw.SetErrorCallback
// Used by vendor:OpenGL // Used by vendor:OpenGL
gl_set_proc_address :: proc(p: rawptr, name: cstring) { gl_set_proc_address :: proc(p: rawptr, name: cstring) {
(^rawptr)(p)^ = GetProcAddress(name); (^rawptr)(p)^ = GetProcAddress(name)
} }
vendor/portmidi/portmidi.odin
Vendored
+40 -40
View File
@@ -7,7 +7,7 @@ when ODIN_OS == "windows" do foreign import lib "portmidi.lib"
#assert(size_of(b32) == size_of(c.int)); #assert(size_of(b32) == size_of(c.int));
DEFAULT_SYSEX_BUFFER_SIZE :: 1024; DEFAULT_SYSEX_BUFFER_SIZE :: 1024
Error :: enum c.int { Error :: enum c.int {
NoError = 0, NoError = 0,
@@ -33,7 +33,7 @@ Error :: enum c.int {
/** A single Stream is a descriptor for an open MIDI device. /** A single Stream is a descriptor for an open MIDI device.
*/ */
Stream :: distinct rawptr; Stream :: distinct rawptr
@(default_calling_convention="c", link_prefix="Pm_") @(default_calling_convention="c", link_prefix="Pm_")
foreign lib { foreign lib {
@@ -75,7 +75,7 @@ GetErrorText :: proc (errnum: Error) -> string {
foreign lib { foreign lib {
Pm_GetErrorText :: proc(errnum: Error) -> cstring --- Pm_GetErrorText :: proc(errnum: Error) -> cstring ---
} }
return string(Pm_GetErrorText(errnum)); return string(Pm_GetErrorText(errnum))
} }
/** Translate portmidi host error into human readable message. /** Translate portmidi host error into human readable message.
@@ -87,18 +87,18 @@ GetHostErrorText :: proc (buf: []byte) -> string {
foreign lib { foreign lib {
Pm_GetHostErrorText :: proc(msg: [^]u8, len: c.uint) --- Pm_GetHostErrorText :: proc(msg: [^]u8, len: c.uint) ---
} }
Pm_GetHostErrorText(raw_data(buf), u32(len(buf))); Pm_GetHostErrorText(raw_data(buf), u32(len(buf)))
str := string(buf[:]); str := string(buf[:])
return strings.truncate_to_byte(str, 0); return strings.truncate_to_byte(str, 0)
} }
HDRLENGTH :: 50; HDRLENGTH :: 50
HOST_ERROR_MSG_LEN :: 256; /* any host error msg will occupy less HOST_ERROR_MSG_LEN :: 256 /* any host error msg will occupy less
than this number of characters */ than this number of characters */
DeviceID :: distinct c.int; DeviceID :: distinct c.int
NoDevice :: DeviceID(-1); NoDevice :: DeviceID(-1)
DeviceInfo :: struct { DeviceInfo :: struct {
structVersion: c.int, /**< this internal structure version */ structVersion: c.int, /**< this internal structure version */
interf: cstring, /**< underlying MIDI API, e.g. MMSystem or DirectX */ interf: cstring, /**< underlying MIDI API, e.g. MMSystem or DirectX */
@@ -122,11 +122,11 @@ foreign lib {
Timestamp is used to represent a millisecond clock with arbitrary Timestamp is used to represent a millisecond clock with arbitrary
start time. The type is used for all MIDI timestampes and clocks. start time. The type is used for all MIDI timestampes and clocks.
*/ */
Timestamp :: distinct i32; Timestamp :: distinct i32
TimeProc :: proc "c" (time_info: rawptr) -> Timestamp; TimeProc :: proc "c" (time_info: rawptr) -> Timestamp
Before :: #force_inline proc "c" (t1, t2: Timestamp) -> b32 { Before :: #force_inline proc "c" (t1, t2: Timestamp) -> b32 {
return b32((t1-t2) < 0); return b32((t1-t2) < 0)
} }
@(default_calling_convention="c", link_prefix="Pm_") @(default_calling_convention="c", link_prefix="Pm_")
@@ -245,50 +245,50 @@ foreign lib {
/* Filter bit-mask definitions */ /* Filter bit-mask definitions */
/** filter active sensing messages (0xFE): */ /** filter active sensing messages (0xFE): */
FILT_ACTIVE :: 1 << 0x0E; FILT_ACTIVE :: 1 << 0x0E
/** filter system exclusive messages (0xF0): */ /** filter system exclusive messages (0xF0): */
FILT_SYSEX :: 1 << 0x00; FILT_SYSEX :: 1 << 0x00
/** filter MIDI clock message (0xF8) */ /** filter MIDI clock message (0xF8) */
FILT_CLOCK :: 1 << 0x08; FILT_CLOCK :: 1 << 0x08
/** filter play messages (start 0xFA, stop 0xFC, continue 0xFB) */ /** filter play messages (start 0xFA, stop 0xFC, continue 0xFB) */
FILT_PLAY :: (1 << 0x0A) | (1 << 0x0C) | (1 << 0x0B); FILT_PLAY :: (1 << 0x0A) | (1 << 0x0C) | (1 << 0x0B)
/** filter tick messages (0xF9) */ /** filter tick messages (0xF9) */
FILT_TICK :: 1 << 0x09; FILT_TICK :: 1 << 0x09
/** filter undefined FD messages */ /** filter undefined FD messages */
FILT_FD :: 1 << 0x0D; FILT_FD :: 1 << 0x0D
/** filter undefined real-time messages */ /** filter undefined real-time messages */
FILT_UNDEFINED :: FILT_FD; FILT_UNDEFINED :: FILT_FD
/** filter reset messages (0xFF) */ /** filter reset messages (0xFF) */
FILT_RESET :: 1 << 0x0F; FILT_RESET :: 1 << 0x0F
/** filter all real-time messages */ /** filter all real-time messages */
FILT_REALTIME :: FILT_ACTIVE | FILT_SYSEX | FILT_CLOCK | FILT_PLAY | FILT_UNDEFINED | FILT_RESET | FILT_TICK; FILT_REALTIME :: FILT_ACTIVE | FILT_SYSEX | FILT_CLOCK | FILT_PLAY | FILT_UNDEFINED | FILT_RESET | FILT_TICK
/** filter note-on and note-off (0x90-0x9F and 0x80-0x8F */ /** filter note-on and note-off (0x90-0x9F and 0x80-0x8F */
FILT_NOTE :: (1 << 0x19) | (1 << 0x18); FILT_NOTE :: (1 << 0x19) | (1 << 0x18)
/** filter channel aftertouch (most midi controllers use this) (0xD0-0xDF)*/ /** filter channel aftertouch (most midi controllers use this) (0xD0-0xDF)*/
FILT_CHANNEL_AFTERTOUCH :: 1 << 0x1D; FILT_CHANNEL_AFTERTOUCH :: 1 << 0x1D
/** per-note aftertouch (0xA0-0xAF) */ /** per-note aftertouch (0xA0-0xAF) */
FILT_POLY_AFTERTOUCH :: 1 << 0x1A; FILT_POLY_AFTERTOUCH :: 1 << 0x1A
/** filter both channel and poly aftertouch */ /** filter both channel and poly aftertouch */
FILT_AFTERTOUCH :: FILT_CHANNEL_AFTERTOUCH | FILT_POLY_AFTERTOUCH; FILT_AFTERTOUCH :: FILT_CHANNEL_AFTERTOUCH | FILT_POLY_AFTERTOUCH
/** Program changes (0xC0-0xCF) */ /** Program changes (0xC0-0xCF) */
FILT_PROGRAM :: 1 << 0x1C; FILT_PROGRAM :: 1 << 0x1C
/** Control Changes (CC's) (0xB0-0xBF)*/ /** Control Changes (CC's) (0xB0-0xBF)*/
FILT_CONTROL :: 1 << 0x1B; FILT_CONTROL :: 1 << 0x1B
/** Pitch Bender (0xE0-0xEF*/ /** Pitch Bender (0xE0-0xEF*/
FILT_PITCHBEND :: 1 << 0x1E; FILT_PITCHBEND :: 1 << 0x1E
/** MIDI Time Code (0xF1)*/ /** MIDI Time Code (0xF1)*/
FILT_MTC :: 1 << 0x01; FILT_MTC :: 1 << 0x01
/** Song Position (0xF2) */ /** Song Position (0xF2) */
FILT_SONG_POSITION :: 1 << 0x02; FILT_SONG_POSITION :: 1 << 0x02
/** Song Select (0xF3)*/ /** Song Select (0xF3)*/
FILT_SONG_SELECT :: 1 << 0x03; FILT_SONG_SELECT :: 1 << 0x03
/** Tuning request (0xF6)*/ /** Tuning request (0xF6)*/
FILT_TUNE :: 1 << 0x06; FILT_TUNE :: 1 << 0x06
/** All System Common messages (mtc, song position, song select, tune request) */ /** All System Common messages (mtc, song position, song select, tune request) */
FILT_SYSTEMCOMMON :: FILT_MTC | FILT_SONG_POSITION | FILT_SONG_SELECT | FILT_TUNE; FILT_SYSTEMCOMMON :: FILT_MTC | FILT_SONG_POSITION | FILT_SONG_SELECT | FILT_TUNE
Channel :: #force_inline proc "c" (channel: c.int) -> c.int { Channel :: #force_inline proc "c" (channel: c.int) -> c.int {
return 1<<c.uint(channel); return 1<<c.uint(channel)
} }
@(default_calling_convention="c", link_prefix="Pm_") @(default_calling_convention="c", link_prefix="Pm_")
@@ -361,19 +361,19 @@ foreign lib {
MessageData2() extract fields from a 32-bit midi message. MessageData2() extract fields from a 32-bit midi message.
*/ */
MessageMake :: #force_inline proc "c" (status: c.int, data1, data2: c.int) -> Message { MessageMake :: #force_inline proc "c" (status: c.int, data1, data2: c.int) -> Message {
return Message(((data2 << 16) & 0xFF0000) | ((data1 << 8) & 0xFF00) | (status & 0xFF)); return Message(((data2 << 16) & 0xFF0000) | ((data1 << 8) & 0xFF00) | (status & 0xFF))
} }
MessageStatus :: #force_inline proc "c" (msg: Message) -> c.int { MessageStatus :: #force_inline proc "c" (msg: Message) -> c.int {
return c.int(msg & 0xFF); return c.int(msg & 0xFF)
} }
MessageData1 :: #force_inline proc "c" (msg: Message) -> c.int { MessageData1 :: #force_inline proc "c" (msg: Message) -> c.int {
return c.int((msg >> 8) & 0xFF); return c.int((msg >> 8) & 0xFF)
} }
MessageData2 :: #force_inline proc "c" (msg: Message) -> c.int { MessageData2 :: #force_inline proc "c" (msg: Message) -> c.int {
return c.int((msg >> 16) & 0xFF); return c.int((msg >> 16) & 0xFF)
} }
Message :: distinct i32; Message :: distinct i32
/** /**
All midi data comes in the form of Event structures. A sysex All midi data comes in the form of Event structures. A sysex
message is encoded as a sequence of Event structures, with each message is encoded as a sequence of Event structures, with each
vendor/portmidi/util.odin
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ import "core:c"
when ODIN_OS == "windows" do foreign import lib "portmidi_s.lib" when ODIN_OS == "windows" do foreign import lib "portmidi_s.lib"
Queue :: distinct rawptr; Queue :: distinct rawptr
/* /*
vendor/sdl2/image/sdl_image.odin
Vendored
+11 -11
View File
@@ -8,11 +8,11 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2_image"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2_image" when ODIN_OS == "darwin" do foreign import lib "system:SDL2_image"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2_image" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2_image"
bool :: SDL.bool; bool :: SDL.bool
MAJOR_VERSION :: 2; MAJOR_VERSION :: 2
MINOR_VERSION :: 0; MINOR_VERSION :: 0
PATCHLEVEL :: 5; PATCHLEVEL :: 5
@(default_calling_convention="c", link_prefix="IMG_") @(default_calling_convention="c", link_prefix="IMG_")
foreign lib { foreign lib {
@@ -26,12 +26,12 @@ InitFlag :: enum c.int {
WEBP = 3, WEBP = 3,
} }
InitFlags :: distinct bit_set[InitFlag; c.int]; InitFlags :: distinct bit_set[InitFlag; c.int]
INIT_JPG :: InitFlags{.JPG}; INIT_JPG :: InitFlags{.JPG}
INIT_PNG :: InitFlags{.PNG}; INIT_PNG :: InitFlags{.PNG}
INIT_TIF :: InitFlags{.TIF}; INIT_TIF :: InitFlags{.TIF}
INIT_WEBP :: InitFlags{.WEBP}; INIT_WEBP :: InitFlags{.WEBP}
/* Animated image support /* Animated image support
Currently only animated GIFs are supported. Currently only animated GIFs are supported.
@@ -44,8 +44,8 @@ Animation :: struct {
} }
/* We'll use SDL for reporting errors */ /* We'll use SDL for reporting errors */
SetError :: SDL.SetError; SetError :: SDL.SetError
GetError :: SDL.GetError; GetError :: SDL.GetError
@(default_calling_convention="c", link_prefix="IMG_") @(default_calling_convention="c", link_prefix="IMG_")
foreign lib { foreign lib {
vendor/sdl2/mixer/sdl_mixer.odin
Vendored
+42 -42
View File
@@ -9,14 +9,14 @@ when ODIN_OS == "darwin" do foreign import lib "system:SDL2_mixer"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2_mixer" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2_mixer"
MAJOR_VERSION :: 2; MAJOR_VERSION :: 2
MINOR_VERSION :: 0; MINOR_VERSION :: 0
PATCHLEVEL :: 4; PATCHLEVEL :: 4
CHANNELS :: 8; CHANNELS :: 8
bool :: SDL.bool; bool :: SDL.bool
InitFlag :: enum c.int { InitFlag :: enum c.int {
@@ -28,19 +28,19 @@ InitFlag :: enum c.int {
OPUS = 6, OPUS = 6,
} }
InitFlags :: distinct bit_set[InitFlag; c.int]; InitFlags :: distinct bit_set[InitFlag; c.int]
INIT_FLAC :: InitFlags{.FLAC}; INIT_FLAC :: InitFlags{.FLAC}
INIT_MOD :: InitFlags{.MOD}; INIT_MOD :: InitFlags{.MOD}
INIT_MP3 :: InitFlags{.MP3}; INIT_MP3 :: InitFlags{.MP3}
INIT_OGG :: InitFlags{.OGG}; INIT_OGG :: InitFlags{.OGG}
INIT_MID :: InitFlags{.MID}; INIT_MID :: InitFlags{.MID}
INIT_OPUS :: InitFlags{.OPUS}; INIT_OPUS :: InitFlags{.OPUS}
DEFAULT_FREQUENCY :: 44100; DEFAULT_FREQUENCY :: 44100
DEFAULT_FORMAT :: SDL.AUDIO_S16SYS; DEFAULT_FORMAT :: SDL.AUDIO_S16SYS
DEFAULT_CHANNELS :: 2; DEFAULT_CHANNELS :: 2
MAX_VOLUME :: SDL.MIX_MAXVOLUME; MAX_VOLUME :: SDL.MIX_MAXVOLUME
Chunk :: struct { Chunk :: struct {
allocated: c.int, allocated: c.int,
@@ -55,9 +55,9 @@ Fading :: enum c.int {
FADING_IN, FADING_IN,
} }
NO_FADING :: Fading.NO_FADING; NO_FADING :: Fading.NO_FADING
FADING_OUT :: Fading.FADING_OUT; FADING_OUT :: Fading.FADING_OUT
FADING_IN :: Fading.FADING_IN; FADING_IN :: Fading.FADING_IN
MusicType :: enum c.int { MusicType :: enum c.int {
NONE, NONE,
@@ -73,33 +73,33 @@ MusicType :: enum c.int {
OPUS, OPUS,
} }
MUS_NONE :: MusicType.NONE; MUS_NONE :: MusicType.NONE
MUS_CMD :: MusicType.CMD; MUS_CMD :: MusicType.CMD
MUS_WAV :: MusicType.WAV; MUS_WAV :: MusicType.WAV
MUS_MOD :: MusicType.MOD; MUS_MOD :: MusicType.MOD
MUS_MID :: MusicType.MID; MUS_MID :: MusicType.MID
MUS_OGG :: MusicType.OGG; MUS_OGG :: MusicType.OGG
MUS_MP3 :: MusicType.MP3; MUS_MP3 :: MusicType.MP3
MUS_MP3_MAD_UNUSED :: MusicType.MP3_MAD_UNUSED; MUS_MP3_MAD_UNUSED :: MusicType.MP3_MAD_UNUSED
MUS_FLAC :: MusicType.FLAC; MUS_FLAC :: MusicType.FLAC
MUS_MODPLUG_UNUSED :: MusicType.MODPLUG_UNUSED; MUS_MODPLUG_UNUSED :: MusicType.MODPLUG_UNUSED
MUS_OPUS :: MusicType.OPUS; MUS_OPUS :: MusicType.OPUS
Music :: struct {}; Music :: struct {}
/* We'll use SDL for reporting errors */ /* We'll use SDL for reporting errors */
SetError :: SDL.SetError; SetError :: SDL.SetError
GetError :: SDL.GetError; GetError :: SDL.GetError
ClearError :: SDL.ClearError; ClearError :: SDL.ClearError
Mix_LoadWAV :: #force_inline proc "c" (file: cstring) -> ^Chunk { Mix_LoadWAV :: #force_inline proc "c" (file: cstring) -> ^Chunk {
return LoadWAV_RW(SDL.RWFromFile(file, "rb"), true); return LoadWAV_RW(SDL.RWFromFile(file, "rb"), true)
} }
MixFunc :: proc "c" (udata: rawptr, stream: [^]u8, len: c.int); MixFunc :: proc "c" (udata: rawptr, stream: [^]u8, len: c.int)
@(default_calling_convention="c", link_prefix="Mix_") @(default_calling_convention="c", link_prefix="Mix_")
foreign lib { foreign lib {
@@ -141,18 +141,18 @@ foreign lib {
ChannelFinished :: proc(channel_finished: proc "c" (channel: c.int)) --- ChannelFinished :: proc(channel_finished: proc "c" (channel: c.int)) ---
} }
CHANNEL_POST :: -2; CHANNEL_POST :: -2
EffectFunc_t :: proc "c" (chan: c.int, stream: rawptr, len: c.int, udata: rawptr); EffectFunc_t :: proc "c" (chan: c.int, stream: rawptr, len: c.int, udata: rawptr)
EffectDone_t :: proc "c" (chan: c.int, udata: rawptr); EffectDone_t :: proc "c" (chan: c.int, udata: rawptr)
EFFECTSMAXSPEED :: "MIX_EFFECTSMAXSPEED"; EFFECTSMAXSPEED :: "MIX_EFFECTSMAXSPEED"
PlayChannel :: #force_inline proc "c" (channel: c.int, chunk: ^Chunk, loops: c.int) -> c.int { PlayChannel :: #force_inline proc "c" (channel: c.int, chunk: ^Chunk, loops: c.int) -> c.int {
return PlayChannelTimed(channel, chunk, loops, -1); return PlayChannelTimed(channel, chunk, loops, -1)
} }
FadeInChannel :: #force_inline proc "c" (channel: c.int, chunk: ^Chunk, loops: c.int, ms: c.int) -> c.int { FadeInChannel :: #force_inline proc "c" (channel: c.int, chunk: ^Chunk, loops: c.int, ms: c.int) -> c.int {
return FadeInChannelTimed(channel, chunk, loops, ms, -1); return FadeInChannelTimed(channel, chunk, loops, ms, -1)
} }
vendor/sdl2/net/sdl_net.odin
Vendored
+36 -36
View File
@@ -8,21 +8,21 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2_net"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2_net" when ODIN_OS == "darwin" do foreign import lib "system:SDL2_net"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2_net" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2_net"
bool :: SDL.bool; bool :: SDL.bool
MAJOR_VERSION :: 2; MAJOR_VERSION :: 2
MINOR_VERSION :: 0; MINOR_VERSION :: 0
PATCHLEVEL :: 1; PATCHLEVEL :: 1
IPaddress :: struct { IPaddress :: struct {
host: u32, /* 32-bit IPv4 host address */ host: u32, /* 32-bit IPv4 host address */
port: u16, /* 16-bit protocol port */ port: u16, /* 16-bit protocol port */
} }
INADDR_ANY :: 0x00000000; INADDR_ANY :: 0x00000000
INADDR_NONE :: 0xFFFFFFFF; INADDR_NONE :: 0xFFFFFFFF
INADDR_LOOPBACK :: 0x7f000001; INADDR_LOOPBACK :: 0x7f000001
INADDR_BROADCAST :: 0xFFFFFFFF; INADDR_BROADCAST :: 0xFFFFFFFF
@(default_calling_convention="c", link_prefix="SDLNet_") @(default_calling_convention="c", link_prefix="SDLNet_")
@@ -42,7 +42,7 @@ foreign lib {
/* TCP network API */ /* TCP network API */
/***********************************************************************/ /***********************************************************************/
TCPsocket :: distinct rawptr; TCPsocket :: distinct rawptr
@(default_calling_convention="c", link_prefix="SDLNet_") @(default_calling_convention="c", link_prefix="SDLNet_")
foreign lib { foreign lib {
@@ -56,11 +56,11 @@ foreign lib {
/* The maximum channels on a a UDP socket */ /* The maximum channels on a a UDP socket */
MAX_UDPCHANNELS :: 32; MAX_UDPCHANNELS :: 32
/* The maximum addresses bound to a single UDP socket channel */ /* The maximum addresses bound to a single UDP socket channel */
MAX_UDPADDRESSES :: 4; MAX_UDPADDRESSES :: 4
UDPsocket :: distinct rawptr; UDPsocket :: distinct rawptr
UDPpacket :: struct { UDPpacket :: struct {
channel: c.int, /* The src/dst channel of the packet */ channel: c.int, /* The src/dst channel of the packet */
data: [^]u8, /* The packet data */ data: [^]u8, /* The packet data */
@@ -99,16 +99,16 @@ foreign lib {
AllocPacketSlice :: proc "c" (howmany: c.int, size: c.int) -> []^UDPpacket { AllocPacketSlice :: proc "c" (howmany: c.int, size: c.int) -> []^UDPpacket {
if packets := AllocPacketV(howmany, size); packets != nil { if packets := AllocPacketV(howmany, size); packets != nil {
return packets[:howmany]; return packets[:howmany]
} }
return nil; return nil
} }
FreePacketSlice :: proc "c" (packets: []^UDPpacket) { FreePacketSlice :: proc "c" (packets: []^UDPpacket) {
FreePacketV(raw_data(packets)); FreePacketV(raw_data(packets))
} }
UDP_SendSlice :: proc "c" (sock: UDPsocket, packets: []^UDPpacket) -> c.int { UDP_SendSlice :: proc "c" (sock: UDPsocket, packets: []^UDPpacket) -> c.int {
return UDP_SendV(sock, raw_data(packets), c.int(len(packets))); return UDP_SendV(sock, raw_data(packets), c.int(len(packets)))
} }
@@ -116,27 +116,27 @@ UDP_SendSlice :: proc "c" (sock: UDPsocket, packets: []^UDPpacket) -> c.int {
/* Hooks for checking sockets for available data */ /* Hooks for checking sockets for available data */
/***********************************************************************/ /***********************************************************************/
SocketSet :: distinct rawptr; SocketSet :: distinct rawptr
/* Any network socket can be safely cast to this socket type */ /* Any network socket can be safely cast to this socket type */
GenericSocket :: ^struct { ready: c.int }; GenericSocket :: ^struct { ready: c.int }
TCP_AddSocket :: #force_inline proc "c" (set: SocketSet, sock: TCPsocket) -> c.int { TCP_AddSocket :: #force_inline proc "c" (set: SocketSet, sock: TCPsocket) -> c.int {
return AddSocket(set, (GenericSocket)(sock)); return AddSocket(set, (GenericSocket)(sock))
} }
UDP_AddSocket :: #force_inline proc "c" (set: SocketSet, sock: UDPsocket) -> c.int { UDP_AddSocket :: #force_inline proc "c" (set: SocketSet, sock: UDPsocket) -> c.int {
return AddSocket(set, (GenericSocket)(sock)); return AddSocket(set, (GenericSocket)(sock))
} }
TCP_DelSocket :: #force_inline proc "c" (set: SocketSet, sock: TCPsocket) -> c.int { TCP_DelSocket :: #force_inline proc "c" (set: SocketSet, sock: TCPsocket) -> c.int {
return DelSocket(set, (GenericSocket)(sock)); return DelSocket(set, (GenericSocket)(sock))
} }
UDP_DelSocket :: #force_inline proc "c" (set: SocketSet, sock: UDPsocket) -> c.int { UDP_DelSocket :: #force_inline proc "c" (set: SocketSet, sock: UDPsocket) -> c.int {
return DelSocket(set, (GenericSocket)(sock)); return DelSocket(set, (GenericSocket)(sock))
} }
SocketReady :: #force_inline proc "c" (sock: rawptr) -> bool { SocketReady :: #force_inline proc "c" (sock: rawptr) -> bool {
s := (GenericSocket)(sock); s := (GenericSocket)(sock)
return bool(s != nil && s.ready != 0); return bool(s != nil && s.ready != 0)
} }
@@ -167,25 +167,25 @@ foreign lib {
/* Write a 16/32-bit value to network packet buffer */ /* Write a 16/32-bit value to network packet buffer */
Write16 :: #force_inline proc "c" (value: u16, areap: rawptr) { Write16 :: #force_inline proc "c" (value: u16, areap: rawptr) {
area := (^[2]u8)(areap); area := (^[2]u8)(areap)
area[0] = u8((value >> 8) & 0xFF); area[0] = u8((value >> 8) & 0xFF)
area[1] = u8( value & 0xFF); area[1] = u8( value & 0xFF)
} }
Write32 :: #force_inline proc "c" (value: u32, areap: rawptr) { Write32 :: #force_inline proc "c" (value: u32, areap: rawptr) {
area := (^[4]u8)(areap); area := (^[4]u8)(areap)
area[0] = u8((value >> 24) & 0xFF); area[0] = u8((value >> 24) & 0xFF)
area[1] = u8((value >> 16) & 0xFF); area[1] = u8((value >> 16) & 0xFF)
area[2] = u8((value >> 8) & 0xFF); area[2] = u8((value >> 8) & 0xFF)
area[3] = u8( value & 0xFF); area[3] = u8( value & 0xFF)
} }
/* Read a 16/32-bit value from network packet buffer */ /* Read a 16/32-bit value from network packet buffer */
Read16 :: #force_inline proc "c" (areap: rawptr) -> u16 { Read16 :: #force_inline proc "c" (areap: rawptr) -> u16 {
area := (^[2]u8)(areap); area := (^[2]u8)(areap)
return u16(area[0])<<8 | u16(area[1]); return u16(area[0])<<8 | u16(area[1])
} }
Read32 :: #force_inline proc "c" (areap: rawptr) -> u32 { Read32 :: #force_inline proc "c" (areap: rawptr) -> u32 {
area := (^[4]u8)(areap); area := (^[4]u8)(areap)
return u32(area[0])<<24 | u32(area[1])<<16 | u32(area[2])<<8 | u32(area[3]); return u32(area[0])<<24 | u32(area[1])<<16 | u32(area[2])<<8 | u32(area[3])
} }
vendor/sdl2/sdl2.odin
Vendored
+31 -31
View File
@@ -34,11 +34,11 @@ version :: struct {
major: u8, /**< major version */ major: u8, /**< major version */
minor: u8, /**< minor version */ minor: u8, /**< minor version */
patch: u8, /**< update version */ patch: u8, /**< update version */
}; }
MAJOR_VERSION :: 2; MAJOR_VERSION :: 2
MINOR_VERSION :: 0; MINOR_VERSION :: 0
PATCHLEVEL :: 16; PATCHLEVEL :: 16
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -59,18 +59,18 @@ InitFlag :: enum u32 {
NOPARACHUTE = 0x14, NOPARACHUTE = 0x14,
} }
InitFlags :: bit_set[InitFlag; u32]; InitFlags :: bit_set[InitFlag; u32]
INIT_TIMER :: InitFlags{.TIMER}; INIT_TIMER :: InitFlags{.TIMER}
INIT_AUDIO :: InitFlags{.AUDIO}; INIT_AUDIO :: InitFlags{.AUDIO}
INIT_VIDEO :: InitFlags{.VIDEO}; /**< INIT_VIDEO implies INIT_EVENTS */ INIT_VIDEO :: InitFlags{.VIDEO} /**< INIT_VIDEO implies INIT_EVENTS */
INIT_JOYSTICK :: InitFlags{.JOYSTICK}; /**< INIT_JOYSTICK implies INIT_EVENTS */ INIT_JOYSTICK :: InitFlags{.JOYSTICK} /**< INIT_JOYSTICK implies INIT_EVENTS */
INIT_HAPTIC :: InitFlags{.HAPTIC}; INIT_HAPTIC :: InitFlags{.HAPTIC}
INIT_GAMECONTROLLER :: InitFlags{.GAMECONTROLLER}; /**< INIT_GAMECONTROLLER implies INIT_JOYSTICK */ INIT_GAMECONTROLLER :: InitFlags{.GAMECONTROLLER} /**< INIT_GAMECONTROLLER implies INIT_JOYSTICK */
INIT_EVENTS :: InitFlags{.EVENTS}; INIT_EVENTS :: InitFlags{.EVENTS}
INIT_SENSOR :: InitFlags{.SENSOR}; INIT_SENSOR :: InitFlags{.SENSOR}
INIT_NOPARACHUTE :: InitFlags{.NOPARACHUTE}; /**< compatibility; this flag is ignored. */ INIT_NOPARACHUTE :: InitFlags{.NOPARACHUTE} /**< compatibility; this flag is ignored. */
INIT_EVERYTHING :: InitFlags{.TIMER, .AUDIO, .VIDEO, .EVENTS, .JOYSTICK, .HAPTIC, .GAMECONTROLLER, .SENSOR}; INIT_EVERYTHING :: InitFlags{.TIMER, .AUDIO, .VIDEO, .EVENTS, .JOYSTICK, .HAPTIC, .GAMECONTROLLER, .SENSOR}
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -85,8 +85,8 @@ foreign lib {
// Atomic // Atomic
// NOTE: Prefer the intrinsics built into Odin 'package intrinsics' // NOTE: Prefer the intrinsics built into Odin 'package intrinsics'
SpinLock :: distinct c.int; SpinLock :: distinct c.int
atomic_t :: struct { value: c.int }; atomic_t :: struct { value: c.int }
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -107,11 +107,11 @@ foreign lib {
// Bits // Bits
MostSignificantBitIndex32 :: #force_inline proc "c" (x: u32) -> c.int { MostSignificantBitIndex32 :: #force_inline proc "c" (x: u32) -> c.int {
return c.int(intrinsics.count_leading_zeros(x)); return c.int(intrinsics.count_leading_zeros(x))
} }
HasExactlyOneBitSet32 :: #force_inline proc "c" (x: u32) -> bool { HasExactlyOneBitSet32 :: #force_inline proc "c" (x: u32) -> bool {
return intrinsics.count_ones(x) == 1; return intrinsics.count_ones(x) == 1
} }
// Clipboard // Clipboard
@@ -135,11 +135,11 @@ foreign lib {
} }
GetErrorString :: proc "c" () -> string { GetErrorString :: proc "c" () -> string {
return string(GetError()); return string(GetError())
} }
GetErrorMsgString :: proc "c" (buf: []u8) -> string { GetErrorMsgString :: proc "c" (buf: []u8) -> string {
cstr := GetErrorMsg(raw_data(buf), c.int(len(buf))); cstr := GetErrorMsg(raw_data(buf), c.int(len(buf)))
return string(cstr); return string(cstr)
} }
@@ -234,16 +234,16 @@ foreign lib {
// quit // quit
QuitRequested :: #force_inline proc "c" () -> bool { QuitRequested :: #force_inline proc "c" () -> bool {
PumpEvents(); PumpEvents()
return bool(PeepEvents(nil, 0, .PEEKEVENT, .QUIT, .QUIT) > 0); return bool(PeepEvents(nil, 0, .PEEKEVENT, .QUIT, .QUIT) > 0)
} }
// sensor // sensor
Sensor :: struct {}; Sensor :: struct {}
SensorID :: distinct i32; SensorID :: distinct i32
SensorType :: enum c.int { SensorType :: enum c.int {
INVALID = -1, /**< Returned for an invalid sensor */ INVALID = -1, /**< Returned for an invalid sensor */
@@ -252,7 +252,7 @@ SensorType :: enum c.int {
GYRO, /**< Gyroscope */ GYRO, /**< Gyroscope */
} }
STANDARD_GRAVITY :: 9.80665; STANDARD_GRAVITY :: 9.80665
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
@@ -278,9 +278,9 @@ foreign lib {
// shape // shape
NONSHAPEABLE_WINDOW :: -1; NONSHAPEABLE_WINDOW :: -1
INVALID_SHAPE_ARGUMENT :: -2; INVALID_SHAPE_ARGUMENT :: -2
WINDOW_LACKS_SHAPE :: -3; WINDOW_LACKS_SHAPE :: -3
WindowShapeModeEnum :: enum c.int { WindowShapeModeEnum :: enum c.int {
/** \brief The default mode, a binarized alpha cutoff of 1. */ /** \brief The default mode, a binarized alpha cutoff of 1. */
@@ -294,7 +294,7 @@ WindowShapeModeEnum :: enum c.int {
} }
SDL_SHAPEMODEALPHA :: #force_inline proc "c" (mode: WindowShapeModeEnum) -> bool { SDL_SHAPEMODEALPHA :: #force_inline proc "c" (mode: WindowShapeModeEnum) -> bool {
return bool(mode == .Default || mode == .BinarizeAlpha || mode == .ReverseBinarizeAlpha); return bool(mode == .Default || mode == .BinarizeAlpha || mode == .ReverseBinarizeAlpha)
} }
vendor/sdl2/sdl_audio.odin
Vendored
+39 -39
View File
@@ -27,13 +27,13 @@ when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
* *
* There are macros in SDL 2.0 and later to query these bits. * There are macros in SDL 2.0 and later to query these bits.
*/ */
AudioFormat :: distinct u16; AudioFormat :: distinct u16
AUDIO_MASK_BITSIZE :: 0xFF; AUDIO_MASK_BITSIZE :: 0xFF
AUDIO_MASK_DATATYPE :: 1<<8; AUDIO_MASK_DATATYPE :: 1<<8
AUDIO_MASK_ENDIAN :: 1<<12; AUDIO_MASK_ENDIAN :: 1<<12
AUDIO_MASK_SIGNED :: 1<<15; AUDIO_MASK_SIGNED :: 1<<15
AUDIO_BITSIZE :: #force_inline proc "c" (x: AudioFormat) -> u8 { return u8(x & AUDIO_MASK_BITSIZE) } AUDIO_BITSIZE :: #force_inline proc "c" (x: AudioFormat) -> u8 { return u8(x & AUDIO_MASK_BITSIZE) }
AUDIO_ISFLOAT :: #force_inline proc "c" (x: AudioFormat) -> bool { return (x & AUDIO_MASK_DATATYPE) == AUDIO_MASK_DATATYPE } AUDIO_ISFLOAT :: #force_inline proc "c" (x: AudioFormat) -> bool { return (x & AUDIO_MASK_DATATYPE) == AUDIO_MASK_DATATYPE }
AUDIO_ISBIGENDIAN :: #force_inline proc "c" (x: AudioFormat) -> bool { return (x & AUDIO_MASK_ENDIAN) == AUDIO_MASK_ENDIAN } AUDIO_ISBIGENDIAN :: #force_inline proc "c" (x: AudioFormat) -> bool { return (x & AUDIO_MASK_ENDIAN) == AUDIO_MASK_ENDIAN }
@@ -42,43 +42,43 @@ AUDIO_ISINT :: #force_inline proc "c" (x: AudioFormat) -> bool { return
AUDIO_ISLITTLEENDIAN :: #force_inline proc "c" (x: AudioFormat) -> bool { return !AUDIO_ISBIGENDIAN(x) } AUDIO_ISLITTLEENDIAN :: #force_inline proc "c" (x: AudioFormat) -> bool { return !AUDIO_ISBIGENDIAN(x) }
AUDIO_ISUNSIGNED :: #force_inline proc "c" (x: AudioFormat) -> bool { return !AUDIO_ISSIGNED(x) } AUDIO_ISUNSIGNED :: #force_inline proc "c" (x: AudioFormat) -> bool { return !AUDIO_ISSIGNED(x) }
AUDIO_U8 :: 0x0008; /**< Unsigned 8-bit samples */ AUDIO_U8 :: 0x0008 /**< Unsigned 8-bit samples */
AUDIO_S8 :: 0x8008; /**< Signed 8-bit samples */ AUDIO_S8 :: 0x8008 /**< Signed 8-bit samples */
AUDIO_U16LSB :: 0x0010; /**< Unsigned 16-bit samples */ AUDIO_U16LSB :: 0x0010 /**< Unsigned 16-bit samples */
AUDIO_S16LSB :: 0x8010; /**< Signed 16-bit samples */ AUDIO_S16LSB :: 0x8010 /**< Signed 16-bit samples */
AUDIO_U16MSB :: 0x1010; /**< As above, but big-endian byte order */ AUDIO_U16MSB :: 0x1010 /**< As above, but big-endian byte order */
AUDIO_S16MSB :: 0x9010; /**< As above, but big-endian byte order */ AUDIO_S16MSB :: 0x9010 /**< As above, but big-endian byte order */
AUDIO_U16 :: AUDIO_U16LSB; AUDIO_U16 :: AUDIO_U16LSB
AUDIO_S16 :: AUDIO_S16LSB; AUDIO_S16 :: AUDIO_S16LSB
AUDIO_S32LSB :: 0x8020; /**< 32-bit integer samples */ AUDIO_S32LSB :: 0x8020 /**< 32-bit integer samples */
AUDIO_S32MSB :: 0x9020; /**< As above, but big-endian byte order */ AUDIO_S32MSB :: 0x9020 /**< As above, but big-endian byte order */
AUDIO_S32 :: AUDIO_S32LSB; AUDIO_S32 :: AUDIO_S32LSB
AUDIO_F32LSB :: 0x8120; /**< 32-bit floating point samples */ AUDIO_F32LSB :: 0x8120 /**< 32-bit floating point samples */
AUDIO_F32MSB :: 0x9120; /**< As above, but big-endian byte order */ AUDIO_F32MSB :: 0x9120 /**< As above, but big-endian byte order */
AUDIO_F32 :: AUDIO_F32LSB; AUDIO_F32 :: AUDIO_F32LSB
when ODIN_ENDIAN == "little" { when ODIN_ENDIAN == "little" {
AUDIO_U16SYS :: AUDIO_U16LSB; AUDIO_U16SYS :: AUDIO_U16LSB
AUDIO_S16SYS :: AUDIO_S16LSB; AUDIO_S16SYS :: AUDIO_S16LSB
AUDIO_S32SYS :: AUDIO_S32LSB; AUDIO_S32SYS :: AUDIO_S32LSB
AUDIO_F32SYS :: AUDIO_F32LSB; AUDIO_F32SYS :: AUDIO_F32LSB
} else { } else {
AUDIO_U16SYS :: AUDIO_U16MSB; AUDIO_U16SYS :: AUDIO_U16MSB
AUDIO_S16SYS :: AUDIO_S16MSB; AUDIO_S16SYS :: AUDIO_S16MSB
AUDIO_S32SYS :: AUDIO_S32MSB; AUDIO_S32SYS :: AUDIO_S32MSB
AUDIO_F32SYS :: AUDIO_F32MSB; AUDIO_F32SYS :: AUDIO_F32MSB
} }
AUDIO_ALLOW_FREQUENCY_CHANGE :: 0x00000001; AUDIO_ALLOW_FREQUENCY_CHANGE :: 0x00000001
AUDIO_ALLOW_FORMAT_CHANGE :: 0x00000002; AUDIO_ALLOW_FORMAT_CHANGE :: 0x00000002
AUDIO_ALLOW_CHANNELS_CHANGE :: 0x00000004; AUDIO_ALLOW_CHANNELS_CHANGE :: 0x00000004
AUDIO_ALLOW_SAMPLES_CHANGE :: 0x00000008; AUDIO_ALLOW_SAMPLES_CHANGE :: 0x00000008
AUDIO_ALLOW_ANY_CHANGE :: AUDIO_ALLOW_FREQUENCY_CHANGE|AUDIO_ALLOW_FORMAT_CHANGE|AUDIO_ALLOW_CHANNELS_CHANGE|AUDIO_ALLOW_SAMPLES_CHANGE; AUDIO_ALLOW_ANY_CHANGE :: AUDIO_ALLOW_FREQUENCY_CHANGE|AUDIO_ALLOW_FORMAT_CHANGE|AUDIO_ALLOW_CHANNELS_CHANGE|AUDIO_ALLOW_SAMPLES_CHANGE
AudioCallback :: proc "c" (userdata: rawptr, stream: [^]u8, len: c.int); AudioCallback :: proc "c" (userdata: rawptr, stream: [^]u8, len: c.int)
/** /**
* The calculated values in this structure are calculated by SDL_OpenAudio(). * The calculated values in this structure are calculated by SDL_OpenAudio().
@@ -105,9 +105,9 @@ AudioSpec :: struct {
} }
AudioFilter :: proc "c" (cvt: ^AudioCVT, format: AudioFormat); AudioFilter :: proc "c" (cvt: ^AudioCVT, format: AudioFormat)
AUDIOCVT_MAX_FILTERS :: 9; AUDIOCVT_MAX_FILTERS :: 9
AudioCVT :: struct #packed { AudioCVT :: struct #packed {
needed: c.int, /**< Set to 1 if conversion possible */ needed: c.int, /**< Set to 1 if conversion possible */
@@ -125,7 +125,7 @@ AudioCVT :: struct #packed {
AudioDeviceID :: distinct u32; AudioDeviceID :: distinct u32
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -166,7 +166,7 @@ foreign lib {
/* this is opaque to the outside world. */ /* this is opaque to the outside world. */
AudioStream :: struct {}; AudioStream :: struct {}
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -180,7 +180,7 @@ foreign lib {
* Compatibility convenience function. * Compatibility convenience function.
*/ */
LoadWAV :: #force_inline proc "c" (file: cstring, spec: ^AudioSpec, audio_buf: ^[^]u8, audio_len: ^u32) -> ^AudioSpec { LoadWAV :: #force_inline proc "c" (file: cstring, spec: ^AudioSpec, audio_buf: ^[^]u8, audio_len: ^u32) -> ^AudioSpec {
return LoadWAV_RW(RWFromFile(file, "rb"), true, spec, audio_buf, audio_len); return LoadWAV_RW(RWFromFile(file, "rb"), true, spec, audio_buf, audio_len)
} }
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
@@ -221,7 +221,7 @@ foreign lib {
} }
MIX_MAXVOLUME :: 128; MIX_MAXVOLUME :: 128
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_cpuinfo.odin
Vendored
+1 -1
View File
@@ -12,7 +12,7 @@ when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
* The 64-bit PowerPC processors have a 128 byte cache line. * The 64-bit PowerPC processors have a 128 byte cache line.
* We'll use the larger value to be generally safe. * We'll use the larger value to be generally safe.
*/ */
CACHELINE_SIZE :: 128; CACHELINE_SIZE :: 128
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
vendor/sdl2/sdl_events.odin
Vendored
+9 -9
View File
@@ -7,8 +7,8 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
RELEASED :: 0; RELEASED :: 0
PRESSED :: 1; PRESSED :: 1
EventType :: enum u32 { EventType :: enum u32 {
FIRSTEVENT = 0, /**< Unused (do not remove) */ FIRSTEVENT = 0, /**< Unused (do not remove) */
@@ -167,7 +167,7 @@ KeyboardEvent :: struct {
keysym: Keysym, /**< The key that was pressed or released */ keysym: Keysym, /**< The key that was pressed or released */
} }
TEXTEDITINGEVENT_TEXT_SIZE :: 32; TEXTEDITINGEVENT_TEXT_SIZE :: 32
TextEditingEvent :: struct { TextEditingEvent :: struct {
type: EventType, /**< ::SDL_TEXTEDITING */ type: EventType, /**< ::SDL_TEXTEDITING */
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */ timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
@@ -178,7 +178,7 @@ TextEditingEvent :: struct {
} }
TEXTINPUTEVENT_TEXT_SIZE :: 32; TEXTINPUTEVENT_TEXT_SIZE :: 32
TextInputEvent :: struct { TextInputEvent :: struct {
type: EventType, /**< ::SDL_TEXTINPUT */ type: EventType, /**< ::SDL_TEXTINPUT */
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */ timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
@@ -468,12 +468,12 @@ eventaction :: enum c.int {
GETEVENT, GETEVENT,
} }
EventFilter :: proc "c" (userdata: rawptr, event: ^Event) -> c.int; EventFilter :: proc "c" (userdata: rawptr, event: ^Event) -> c.int
QUERY :: -1; QUERY :: -1
IGNORE :: 0; IGNORE :: 0
DISABLE :: 0; DISABLE :: 0
ENABLE :: 1; ENABLE :: 1
GetEventState :: #force_inline proc "c" (type: EventType) -> u8 { return EventState(type, QUERY) } GetEventState :: #force_inline proc "c" (type: EventType) -> u8 { return EventState(type, QUERY) }
vendor/sdl2/sdl_gamecontroller.odin
Vendored
+2 -2
View File
@@ -7,7 +7,7 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
GameController :: struct {}; GameController :: struct {}
GameControllerType :: enum c.int { GameControllerType :: enum c.int {
UNKNOWN = 0, UNKNOWN = 0,
@@ -80,7 +80,7 @@ GameControllerButton :: enum c.int {
GameControllerAddMappingsFromFile :: #force_inline proc "c" (file: cstring) -> c.int { GameControllerAddMappingsFromFile :: #force_inline proc "c" (file: cstring) -> c.int {
return GameControllerAddMappingsFromRW(RWFromFile(file, "rb"), true); return GameControllerAddMappingsFromRW(RWFromFile(file, "rb"), true)
} }
vendor/sdl2/sdl_gesture_haptic.odin
Vendored
+23 -23
View File
@@ -9,7 +9,7 @@ when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
// Gesture // Gesture
GestureID :: distinct i64; GestureID :: distinct i64
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -21,7 +21,7 @@ foreign lib {
// Haptic // Haptic
Haptic :: struct {}; Haptic :: struct {}
HapticType :: enum u16 { HapticType :: enum u16 {
@@ -42,22 +42,22 @@ HapticType :: enum u16 {
STATUS = 1<<14, STATUS = 1<<14,
PAUSE = 1<<15, PAUSE = 1<<15,
} }
HAPTIC_CONSTANT :: HapticType.CONSTANT; HAPTIC_CONSTANT :: HapticType.CONSTANT
HAPTIC_SINE :: HapticType.SINE; HAPTIC_SINE :: HapticType.SINE
HAPTIC_LEFTRIGHT :: HapticType.LEFTRIGHT; HAPTIC_LEFTRIGHT :: HapticType.LEFTRIGHT
HAPTIC_TRIANGLE :: HapticType.TRIANGLE; HAPTIC_TRIANGLE :: HapticType.TRIANGLE
HAPTIC_SAWTOOTHUP :: HapticType.SAWTOOTHUP; HAPTIC_SAWTOOTHUP :: HapticType.SAWTOOTHUP
HAPTIC_SAWTOOTHDOWN :: HapticType.SAWTOOTHDOWN; HAPTIC_SAWTOOTHDOWN :: HapticType.SAWTOOTHDOWN
HAPTIC_RAMP :: HapticType.RAMP; HAPTIC_RAMP :: HapticType.RAMP
HAPTIC_SPRING :: HapticType.SPRING; HAPTIC_SPRING :: HapticType.SPRING
HAPTIC_DAMPER :: HapticType.DAMPER; HAPTIC_DAMPER :: HapticType.DAMPER
HAPTIC_INERTIA :: HapticType.INERTIA; HAPTIC_INERTIA :: HapticType.INERTIA
HAPTIC_FRICTION :: HapticType.FRICTION; HAPTIC_FRICTION :: HapticType.FRICTION
HAPTIC_CUSTOM :: HapticType.CUSTOM; HAPTIC_CUSTOM :: HapticType.CUSTOM
HAPTIC_GAIN :: HapticType.GAIN; HAPTIC_GAIN :: HapticType.GAIN
HAPTIC_AUTOCENTER :: HapticType.AUTOCENTER; HAPTIC_AUTOCENTER :: HapticType.AUTOCENTER
HAPTIC_STATUS :: HapticType.STATUS; HAPTIC_STATUS :: HapticType.STATUS
HAPTIC_PAUSE :: HapticType.PAUSE; HAPTIC_PAUSE :: HapticType.PAUSE
HapticDirectionType :: enum u8 { HapticDirectionType :: enum u8 {
POLAR = 0, POLAR = 0,
@@ -66,12 +66,12 @@ HapticDirectionType :: enum u8 {
STEERING_AXIS = 3, STEERING_AXIS = 3,
} }
HAPTIC_POLAR :: HapticDirectionType.POLAR; HAPTIC_POLAR :: HapticDirectionType.POLAR
HAPTIC_CARTESIAN :: HapticDirectionType.CARTESIAN; HAPTIC_CARTESIAN :: HapticDirectionType.CARTESIAN
HAPTIC_SPHERICAL :: HapticDirectionType.SPHERICAL; HAPTIC_SPHERICAL :: HapticDirectionType.SPHERICAL
HAPTIC_STEERING_AXIS :: HapticDirectionType.STEERING_AXIS; HAPTIC_STEERING_AXIS :: HapticDirectionType.STEERING_AXIS
HAPTIC_INFINITY :: 4294967295; HAPTIC_INFINITY :: 4294967295
HapticDirection :: struct { HapticDirection :: struct {
type: HapticDirectionType, /**< The type of encoding. */ type: HapticDirectionType, /**< The type of encoding. */
vendor/sdl2/sdl_hints.odin
Vendored
+122 -122
View File
@@ -7,127 +7,127 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
HINT_ACCELEROMETER_AS_JOYSTICK :: "SDL_ACCELEROMETER_AS_JOYSTICK"; HINT_ACCELEROMETER_AS_JOYSTICK :: "SDL_ACCELEROMETER_AS_JOYSTICK"
HINT_ALLOW_ALT_TAB_WHILE_GRABBED :: "SDL_ALLOW_ALT_TAB_WHILE_GRABBED"; HINT_ALLOW_ALT_TAB_WHILE_GRABBED :: "SDL_ALLOW_ALT_TAB_WHILE_GRABBED"
HINT_ALLOW_TOPMOST :: "SDL_ALLOW_TOPMOST"; HINT_ALLOW_TOPMOST :: "SDL_ALLOW_TOPMOST"
HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION :: "SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION"; HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION :: "SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION"
HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION :: "SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION"; HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION :: "SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION"
HINT_ANDROID_BLOCK_ON_PAUSE :: "SDL_ANDROID_BLOCK_ON_PAUSE"; HINT_ANDROID_BLOCK_ON_PAUSE :: "SDL_ANDROID_BLOCK_ON_PAUSE"
HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO :: "SDL_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO"; HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO :: "SDL_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO"
HINT_ANDROID_TRAP_BACK_BUTTON :: "SDL_ANDROID_TRAP_BACK_BUTTON"; HINT_ANDROID_TRAP_BACK_BUTTON :: "SDL_ANDROID_TRAP_BACK_BUTTON"
HINT_APPLE_TV_CONTROLLER_UI_EVENTS :: "SDL_APPLE_TV_CONTROLLER_UI_EVENTS"; HINT_APPLE_TV_CONTROLLER_UI_EVENTS :: "SDL_APPLE_TV_CONTROLLER_UI_EVENTS"
HINT_APPLE_TV_REMOTE_ALLOW_ROTATION :: "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION"; HINT_APPLE_TV_REMOTE_ALLOW_ROTATION :: "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION"
HINT_AUDIO_CATEGORY :: "SDL_AUDIO_CATEGORY"; HINT_AUDIO_CATEGORY :: "SDL_AUDIO_CATEGORY"
HINT_AUDIO_DEVICE_APP_NAME :: "SDL_AUDIO_DEVICE_APP_NAME"; HINT_AUDIO_DEVICE_APP_NAME :: "SDL_AUDIO_DEVICE_APP_NAME"
HINT_AUDIO_DEVICE_STREAM_NAME :: "SDL_AUDIO_DEVICE_STREAM_NAME"; HINT_AUDIO_DEVICE_STREAM_NAME :: "SDL_AUDIO_DEVICE_STREAM_NAME"
HINT_AUDIO_DEVICE_STREAM_ROLE :: "SDL_AUDIO_DEVICE_STREAM_ROLE"; HINT_AUDIO_DEVICE_STREAM_ROLE :: "SDL_AUDIO_DEVICE_STREAM_ROLE"
HINT_AUDIO_RESAMPLING_MODE :: "SDL_AUDIO_RESAMPLING_MODE"; HINT_AUDIO_RESAMPLING_MODE :: "SDL_AUDIO_RESAMPLING_MODE"
HINT_AUTO_UPDATE_JOYSTICKS :: "SDL_AUTO_UPDATE_JOYSTICKS"; HINT_AUTO_UPDATE_JOYSTICKS :: "SDL_AUTO_UPDATE_JOYSTICKS"
HINT_AUTO_UPDATE_SENSORS :: "SDL_AUTO_UPDATE_SENSORS"; HINT_AUTO_UPDATE_SENSORS :: "SDL_AUTO_UPDATE_SENSORS"
HINT_BMP_SAVE_LEGACY_FORMAT :: "SDL_BMP_SAVE_LEGACY_FORMAT"; HINT_BMP_SAVE_LEGACY_FORMAT :: "SDL_BMP_SAVE_LEGACY_FORMAT"
HINT_DISPLAY_USABLE_BOUNDS :: "SDL_DISPLAY_USABLE_BOUNDS"; HINT_DISPLAY_USABLE_BOUNDS :: "SDL_DISPLAY_USABLE_BOUNDS"
HINT_EMSCRIPTEN_ASYNCIFY :: "SDL_EMSCRIPTEN_ASYNCIFY"; HINT_EMSCRIPTEN_ASYNCIFY :: "SDL_EMSCRIPTEN_ASYNCIFY"
HINT_EMSCRIPTEN_KEYBOARD_ELEMENT :: "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT"; HINT_EMSCRIPTEN_KEYBOARD_ELEMENT :: "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT"
HINT_ENABLE_STEAM_CONTROLLERS :: "SDL_ENABLE_STEAM_CONTROLLERS"; HINT_ENABLE_STEAM_CONTROLLERS :: "SDL_ENABLE_STEAM_CONTROLLERS"
HINT_EVENT_LOGGING :: "SDL_EVENT_LOGGING"; HINT_EVENT_LOGGING :: "SDL_EVENT_LOGGING"
HINT_FRAMEBUFFER_ACCELERATION :: "SDL_FRAMEBUFFER_ACCELERATION"; HINT_FRAMEBUFFER_ACCELERATION :: "SDL_FRAMEBUFFER_ACCELERATION"
HINT_GAMECONTROLLERCONFIG :: "SDL_GAMECONTROLLERCONFIG"; HINT_GAMECONTROLLERCONFIG :: "SDL_GAMECONTROLLERCONFIG"
HINT_GAMECONTROLLERCONFIG_FILE :: "SDL_GAMECONTROLLERCONFIG_FILE"; HINT_GAMECONTROLLERCONFIG_FILE :: "SDL_GAMECONTROLLERCONFIG_FILE"
HINT_GAMECONTROLLERTYPE :: "SDL_GAMECONTROLLERTYPE"; HINT_GAMECONTROLLERTYPE :: "SDL_GAMECONTROLLERTYPE"
HINT_GAMECONTROLLER_IGNORE_DEVICES :: "SDL_GAMECONTROLLER_IGNORE_DEVICES"; HINT_GAMECONTROLLER_IGNORE_DEVICES :: "SDL_GAMECONTROLLER_IGNORE_DEVICES"
HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT :: "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT"; HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT :: "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT"
HINT_GAMECONTROLLER_USE_BUTTON_LABELS :: "SDL_GAMECONTROLLER_USE_BUTTON_LABELS"; HINT_GAMECONTROLLER_USE_BUTTON_LABELS :: "SDL_GAMECONTROLLER_USE_BUTTON_LABELS"
HINT_GRAB_KEYBOARD :: "SDL_GRAB_KEYBOARD"; HINT_GRAB_KEYBOARD :: "SDL_GRAB_KEYBOARD"
HINT_IDLE_TIMER_DISABLED :: "SDL_IOS_IDLE_TIMER_DISABLED"; HINT_IDLE_TIMER_DISABLED :: "SDL_IOS_IDLE_TIMER_DISABLED"
HINT_IME_INTERNAL_EDITING :: "SDL_IME_INTERNAL_EDITING"; HINT_IME_INTERNAL_EDITING :: "SDL_IME_INTERNAL_EDITING"
HINT_IOS_HIDE_HOME_INDICATOR :: "SDL_IOS_HIDE_HOME_INDICATOR"; HINT_IOS_HIDE_HOME_INDICATOR :: "SDL_IOS_HIDE_HOME_INDICATOR"
HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS :: "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"; HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS :: "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"
HINT_JOYSTICK_HIDAPI :: "SDL_JOYSTICK_HIDAPI"; HINT_JOYSTICK_HIDAPI :: "SDL_JOYSTICK_HIDAPI"
HINT_JOYSTICK_HIDAPI_GAMECUBE :: "SDL_JOYSTICK_HIDAPI_GAMECUBE"; HINT_JOYSTICK_HIDAPI_GAMECUBE :: "SDL_JOYSTICK_HIDAPI_GAMECUBE"
HINT_JOYSTICK_HIDAPI_JOY_CONS :: "SDL_JOYSTICK_HIDAPI_JOY_CONS"; HINT_JOYSTICK_HIDAPI_JOY_CONS :: "SDL_JOYSTICK_HIDAPI_JOY_CONS"
HINT_JOYSTICK_HIDAPI_LUNA :: "SDL_JOYSTICK_HIDAPI_LUNA"; HINT_JOYSTICK_HIDAPI_LUNA :: "SDL_JOYSTICK_HIDAPI_LUNA"
HINT_JOYSTICK_HIDAPI_PS4 :: "SDL_JOYSTICK_HIDAPI_PS4"; HINT_JOYSTICK_HIDAPI_PS4 :: "SDL_JOYSTICK_HIDAPI_PS4"
HINT_JOYSTICK_HIDAPI_PS4_RUMBLE :: "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"; HINT_JOYSTICK_HIDAPI_PS4_RUMBLE :: "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"
HINT_JOYSTICK_HIDAPI_PS5 :: "SDL_JOYSTICK_HIDAPI_PS5"; HINT_JOYSTICK_HIDAPI_PS5 :: "SDL_JOYSTICK_HIDAPI_PS5"
HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED :: "SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED"; HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED :: "SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED"
HINT_JOYSTICK_HIDAPI_PS5_RUMBLE :: "SDL_JOYSTICK_HIDAPI_PS5_RUMBLE"; HINT_JOYSTICK_HIDAPI_PS5_RUMBLE :: "SDL_JOYSTICK_HIDAPI_PS5_RUMBLE"
HINT_JOYSTICK_HIDAPI_STADIA :: "SDL_JOYSTICK_HIDAPI_STADIA"; HINT_JOYSTICK_HIDAPI_STADIA :: "SDL_JOYSTICK_HIDAPI_STADIA"
HINT_JOYSTICK_HIDAPI_STEAM :: "SDL_JOYSTICK_HIDAPI_STEAM"; HINT_JOYSTICK_HIDAPI_STEAM :: "SDL_JOYSTICK_HIDAPI_STEAM"
HINT_JOYSTICK_HIDAPI_SWITCH :: "SDL_JOYSTICK_HIDAPI_SWITCH"; HINT_JOYSTICK_HIDAPI_SWITCH :: "SDL_JOYSTICK_HIDAPI_SWITCH"
HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED :: "SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED"; HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED :: "SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED"
HINT_JOYSTICK_HIDAPI_XBOX :: "SDL_JOYSTICK_HIDAPI_XBOX"; HINT_JOYSTICK_HIDAPI_XBOX :: "SDL_JOYSTICK_HIDAPI_XBOX"
HINT_JOYSTICK_RAWINPUT :: "SDL_JOYSTICK_RAWINPUT"; HINT_JOYSTICK_RAWINPUT :: "SDL_JOYSTICK_RAWINPUT"
HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT :: "SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT"; HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT :: "SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT"
HINT_JOYSTICK_THREAD :: "SDL_JOYSTICK_THREAD"; HINT_JOYSTICK_THREAD :: "SDL_JOYSTICK_THREAD"
HINT_KMSDRM_REQUIRE_DRM_MASTER :: "SDL_KMSDRM_REQUIRE_DRM_MASTER"; HINT_KMSDRM_REQUIRE_DRM_MASTER :: "SDL_KMSDRM_REQUIRE_DRM_MASTER"
HINT_LINUX_JOYSTICK_DEADZONES :: "SDL_LINUX_JOYSTICK_DEADZONES"; HINT_LINUX_JOYSTICK_DEADZONES :: "SDL_LINUX_JOYSTICK_DEADZONES"
HINT_MAC_BACKGROUND_APP :: "SDL_MAC_BACKGROUND_APP"; HINT_MAC_BACKGROUND_APP :: "SDL_MAC_BACKGROUND_APP"
HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK :: "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK"; HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK :: "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK"
HINT_MOUSE_DOUBLE_CLICK_RADIUS :: "SDL_MOUSE_DOUBLE_CLICK_RADIUS"; HINT_MOUSE_DOUBLE_CLICK_RADIUS :: "SDL_MOUSE_DOUBLE_CLICK_RADIUS"
HINT_MOUSE_DOUBLE_CLICK_TIME :: "SDL_MOUSE_DOUBLE_CLICK_TIME"; HINT_MOUSE_DOUBLE_CLICK_TIME :: "SDL_MOUSE_DOUBLE_CLICK_TIME"
HINT_MOUSE_FOCUS_CLICKTHROUGH :: "SDL_MOUSE_FOCUS_CLICKTHROUGH"; HINT_MOUSE_FOCUS_CLICKTHROUGH :: "SDL_MOUSE_FOCUS_CLICKTHROUGH"
HINT_MOUSE_NORMAL_SPEED_SCALE :: "SDL_MOUSE_NORMAL_SPEED_SCALE"; HINT_MOUSE_NORMAL_SPEED_SCALE :: "SDL_MOUSE_NORMAL_SPEED_SCALE"
HINT_MOUSE_RELATIVE_MODE_WARP :: "SDL_MOUSE_RELATIVE_MODE_WARP"; HINT_MOUSE_RELATIVE_MODE_WARP :: "SDL_MOUSE_RELATIVE_MODE_WARP"
HINT_MOUSE_RELATIVE_SCALING :: "SDL_MOUSE_RELATIVE_SCALING"; HINT_MOUSE_RELATIVE_SCALING :: "SDL_MOUSE_RELATIVE_SCALING"
HINT_MOUSE_RELATIVE_SPEED_SCALE :: "SDL_MOUSE_RELATIVE_SPEED_SCALE"; HINT_MOUSE_RELATIVE_SPEED_SCALE :: "SDL_MOUSE_RELATIVE_SPEED_SCALE"
HINT_MOUSE_TOUCH_EVENTS :: "SDL_MOUSE_TOUCH_EVENTS"; HINT_MOUSE_TOUCH_EVENTS :: "SDL_MOUSE_TOUCH_EVENTS"
HINT_NO_SIGNAL_HANDLERS :: "SDL_NO_SIGNAL_HANDLERS"; HINT_NO_SIGNAL_HANDLERS :: "SDL_NO_SIGNAL_HANDLERS"
HINT_OPENGL_ES_DRIVER :: "SDL_OPENGL_ES_DRIVER"; HINT_OPENGL_ES_DRIVER :: "SDL_OPENGL_ES_DRIVER"
HINT_ORIENTATIONS :: "SDL_IOS_ORIENTATIONS"; HINT_ORIENTATIONS :: "SDL_IOS_ORIENTATIONS"
HINT_PREFERRED_LOCALES :: "SDL_PREFERRED_LOCALES"; HINT_PREFERRED_LOCALES :: "SDL_PREFERRED_LOCALES"
HINT_QTWAYLAND_CONTENT_ORIENTATION :: "SDL_QTWAYLAND_CONTENT_ORIENTATION"; HINT_QTWAYLAND_CONTENT_ORIENTATION :: "SDL_QTWAYLAND_CONTENT_ORIENTATION"
HINT_QTWAYLAND_WINDOW_FLAGS :: "SDL_QTWAYLAND_WINDOW_FLAGS"; HINT_QTWAYLAND_WINDOW_FLAGS :: "SDL_QTWAYLAND_WINDOW_FLAGS"
HINT_RENDER_BATCHING :: "SDL_RENDER_BATCHING"; HINT_RENDER_BATCHING :: "SDL_RENDER_BATCHING"
HINT_RENDER_DIRECT3D11_DEBUG :: "SDL_RENDER_DIRECT3D11_DEBUG"; HINT_RENDER_DIRECT3D11_DEBUG :: "SDL_RENDER_DIRECT3D11_DEBUG"
HINT_RENDER_DIRECT3D_THREADSAFE :: "SDL_RENDER_DIRECT3D_THREADSAFE"; HINT_RENDER_DIRECT3D_THREADSAFE :: "SDL_RENDER_DIRECT3D_THREADSAFE"
HINT_RENDER_DRIVER :: "SDL_RENDER_DRIVER"; HINT_RENDER_DRIVER :: "SDL_RENDER_DRIVER"
HINT_RENDER_LOGICAL_SIZE_MODE :: "SDL_RENDER_LOGICAL_SIZE_MODE"; HINT_RENDER_LOGICAL_SIZE_MODE :: "SDL_RENDER_LOGICAL_SIZE_MODE"
HINT_RENDER_OPENGL_SHADERS :: "SDL_RENDER_OPENGL_SHADERS"; HINT_RENDER_OPENGL_SHADERS :: "SDL_RENDER_OPENGL_SHADERS"
HINT_RENDER_SCALE_QUALITY :: "SDL_RENDER_SCALE_QUALITY"; HINT_RENDER_SCALE_QUALITY :: "SDL_RENDER_SCALE_QUALITY"
HINT_RENDER_VSYNC :: "SDL_RENDER_VSYNC"; HINT_RENDER_VSYNC :: "SDL_RENDER_VSYNC"
HINT_RETURN_KEY_HIDES_IME :: "SDL_RETURN_KEY_HIDES_IME"; HINT_RETURN_KEY_HIDES_IME :: "SDL_RETURN_KEY_HIDES_IME"
HINT_RPI_VIDEO_LAYER :: "SDL_RPI_VIDEO_LAYER"; HINT_RPI_VIDEO_LAYER :: "SDL_RPI_VIDEO_LAYER"
HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL :: "SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL"; HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL :: "SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL"
HINT_THREAD_PRIORITY_POLICY :: "SDL_THREAD_PRIORITY_POLICY"; HINT_THREAD_PRIORITY_POLICY :: "SDL_THREAD_PRIORITY_POLICY"
HINT_THREAD_STACK_SIZE :: "SDL_THREAD_STACK_SIZE"; HINT_THREAD_STACK_SIZE :: "SDL_THREAD_STACK_SIZE"
HINT_TIMER_RESOLUTION :: "SDL_TIMER_RESOLUTION"; HINT_TIMER_RESOLUTION :: "SDL_TIMER_RESOLUTION"
HINT_TOUCH_MOUSE_EVENTS :: "SDL_TOUCH_MOUSE_EVENTS"; HINT_TOUCH_MOUSE_EVENTS :: "SDL_TOUCH_MOUSE_EVENTS"
HINT_TV_REMOTE_AS_JOYSTICK :: "SDL_TV_REMOTE_AS_JOYSTICK"; HINT_TV_REMOTE_AS_JOYSTICK :: "SDL_TV_REMOTE_AS_JOYSTICK"
HINT_VIDEO_ALLOW_SCREENSAVER :: "SDL_VIDEO_ALLOW_SCREENSAVER"; HINT_VIDEO_ALLOW_SCREENSAVER :: "SDL_VIDEO_ALLOW_SCREENSAVER"
HINT_VIDEO_DOUBLE_BUFFER :: "SDL_VIDEO_DOUBLE_BUFFER"; HINT_VIDEO_DOUBLE_BUFFER :: "SDL_VIDEO_DOUBLE_BUFFER"
HINT_VIDEO_EXTERNAL_CONTEXT :: "SDL_VIDEO_EXTERNAL_CONTEXT"; HINT_VIDEO_EXTERNAL_CONTEXT :: "SDL_VIDEO_EXTERNAL_CONTEXT"
HINT_VIDEO_HIGHDPI_DISABLED :: "SDL_VIDEO_HIGHDPI_DISABLED"; HINT_VIDEO_HIGHDPI_DISABLED :: "SDL_VIDEO_HIGHDPI_DISABLED"
HINT_VIDEO_MAC_FULLSCREEN_SPACES :: "SDL_VIDEO_MAC_FULLSCREEN_SPACES"; HINT_VIDEO_MAC_FULLSCREEN_SPACES :: "SDL_VIDEO_MAC_FULLSCREEN_SPACES"
HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS :: "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"; HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS :: "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"
HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR :: "SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR"; HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR :: "SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR"
HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT :: "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT"; HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT :: "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT"
HINT_VIDEO_WIN_D3DCOMPILER :: "SDL_VIDEO_WIN_D3DCOMPILER"; HINT_VIDEO_WIN_D3DCOMPILER :: "SDL_VIDEO_WIN_D3DCOMPILER"
HINT_VIDEO_X11_FORCE_EGL :: "SDL_VIDEO_X11_FORCE_EGL"; HINT_VIDEO_X11_FORCE_EGL :: "SDL_VIDEO_X11_FORCE_EGL"
HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR :: "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"; HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR :: "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"
HINT_VIDEO_X11_NET_WM_PING :: "SDL_VIDEO_X11_NET_WM_PING"; HINT_VIDEO_X11_NET_WM_PING :: "SDL_VIDEO_X11_NET_WM_PING"
HINT_VIDEO_X11_WINDOW_VISUALID :: "SDL_VIDEO_X11_WINDOW_VISUALID"; HINT_VIDEO_X11_WINDOW_VISUALID :: "SDL_VIDEO_X11_WINDOW_VISUALID"
HINT_VIDEO_X11_XINERAMA :: "SDL_VIDEO_X11_XINERAMA"; HINT_VIDEO_X11_XINERAMA :: "SDL_VIDEO_X11_XINERAMA"
HINT_VIDEO_X11_XRANDR :: "SDL_VIDEO_X11_XRANDR"; HINT_VIDEO_X11_XRANDR :: "SDL_VIDEO_X11_XRANDR"
HINT_VIDEO_X11_XVIDMODE :: "SDL_VIDEO_X11_XVIDMODE"; HINT_VIDEO_X11_XVIDMODE :: "SDL_VIDEO_X11_XVIDMODE"
HINT_WAVE_FACT_CHUNK :: "SDL_WAVE_FACT_CHUNK"; HINT_WAVE_FACT_CHUNK :: "SDL_WAVE_FACT_CHUNK"
HINT_WAVE_RIFF_CHUNK_SIZE :: "SDL_WAVE_RIFF_CHUNK_SIZE"; HINT_WAVE_RIFF_CHUNK_SIZE :: "SDL_WAVE_RIFF_CHUNK_SIZE"
HINT_WAVE_TRUNCATION :: "SDL_WAVE_TRUNCATION"; HINT_WAVE_TRUNCATION :: "SDL_WAVE_TRUNCATION"
HINT_WINDOWS_DISABLE_THREAD_NAMING :: "SDL_WINDOWS_DISABLE_THREAD_NAMING"; HINT_WINDOWS_DISABLE_THREAD_NAMING :: "SDL_WINDOWS_DISABLE_THREAD_NAMING"
HINT_WINDOWS_ENABLE_MESSAGELOOP :: "SDL_WINDOWS_ENABLE_MESSAGELOOP"; HINT_WINDOWS_ENABLE_MESSAGELOOP :: "SDL_WINDOWS_ENABLE_MESSAGELOOP"
HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS :: "SDL_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS"; HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS :: "SDL_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS"
HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL :: "SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL"; HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL :: "SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL"
HINT_WINDOWS_INTRESOURCE_ICON :: "SDL_WINDOWS_INTRESOURCE_ICON"; HINT_WINDOWS_INTRESOURCE_ICON :: "SDL_WINDOWS_INTRESOURCE_ICON"
HINT_WINDOWS_INTRESOURCE_ICON_SMALL :: "SDL_WINDOWS_INTRESOURCE_ICON_SMALL"; HINT_WINDOWS_INTRESOURCE_ICON_SMALL :: "SDL_WINDOWS_INTRESOURCE_ICON_SMALL"
HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 :: "SDL_WINDOWS_NO_CLOSE_ON_ALT_F4"; HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 :: "SDL_WINDOWS_NO_CLOSE_ON_ALT_F4"
HINT_WINDOWS_USE_D3D9EX :: "SDL_WINDOWS_USE_D3D9EX"; HINT_WINDOWS_USE_D3D9EX :: "SDL_WINDOWS_USE_D3D9EX"
HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN :: "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN"; HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN :: "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN"
HINT_WINRT_HANDLE_BACK_BUTTON :: "SDL_WINRT_HANDLE_BACK_BUTTON"; HINT_WINRT_HANDLE_BACK_BUTTON :: "SDL_WINRT_HANDLE_BACK_BUTTON"
HINT_WINRT_PRIVACY_POLICY_LABEL :: "SDL_WINRT_PRIVACY_POLICY_LABEL"; HINT_WINRT_PRIVACY_POLICY_LABEL :: "SDL_WINRT_PRIVACY_POLICY_LABEL"
HINT_WINRT_PRIVACY_POLICY_URL :: "SDL_WINRT_PRIVACY_POLICY_URL"; HINT_WINRT_PRIVACY_POLICY_URL :: "SDL_WINRT_PRIVACY_POLICY_URL"
HINT_X11_FORCE_OVERRIDE_REDIRECT :: "SDL_X11_FORCE_OVERRIDE_REDIRECT"; HINT_X11_FORCE_OVERRIDE_REDIRECT :: "SDL_X11_FORCE_OVERRIDE_REDIRECT"
HINT_XINPUT_ENABLED :: "SDL_XINPUT_ENABLED"; HINT_XINPUT_ENABLED :: "SDL_XINPUT_ENABLED"
HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING :: "SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING"; HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING :: "SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING"
HINT_AUDIO_INCLUDE_MONITORS :: "SDL_AUDIO_INCLUDE_MONITORS"; HINT_AUDIO_INCLUDE_MONITORS :: "SDL_AUDIO_INCLUDE_MONITORS"
HintPriority :: enum c.int { HintPriority :: enum c.int {
DEFAULT, DEFAULT,
@@ -135,7 +135,7 @@ HintPriority :: enum c.int {
OVERRIDE, OVERRIDE,
} }
HintCallback :: proc "c" (userdata: rawptr, name, oldValue, newValue: cstring); HintCallback :: proc "c" (userdata: rawptr, name, oldValue, newValue: cstring)
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_joystick.odin
Vendored
+14 -14
View File
@@ -7,13 +7,13 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
Joystick :: struct {}; Joystick :: struct {}
JoystickGUID :: struct { JoystickGUID :: struct {
data: [16]u8, data: [16]u8,
} }
JoystickID :: distinct i32; JoystickID :: distinct i32
JoystickType :: enum c.int { JoystickType :: enum c.int {
UNKNOWN, UNKNOWN,
@@ -38,20 +38,20 @@ JoystickPowerLevel :: enum c.int {
MAX, MAX,
} }
IPHONE_MAX_GFORCE :: 5.0; IPHONE_MAX_GFORCE :: 5.0
JOYSTICK_AXIS_MAX :: +32767; JOYSTICK_AXIS_MAX :: +32767
JOYSTICK_AXIS_MIN :: -32768; JOYSTICK_AXIS_MIN :: -32768
HAT_CENTERED :: 0x00; HAT_CENTERED :: 0x00
HAT_UP :: 0x01; HAT_UP :: 0x01
HAT_RIGHT :: 0x02; HAT_RIGHT :: 0x02
HAT_DOWN :: 0x04; HAT_DOWN :: 0x04
HAT_LEFT :: 0x08; HAT_LEFT :: 0x08
HAT_RIGHTUP :: HAT_RIGHT|HAT_UP; HAT_RIGHTUP :: HAT_RIGHT|HAT_UP
HAT_RIGHTDOWN :: HAT_RIGHT|HAT_DOWN; HAT_RIGHTDOWN :: HAT_RIGHT|HAT_DOWN
HAT_LEFTUP :: HAT_LEFT|HAT_UP; HAT_LEFTUP :: HAT_LEFT|HAT_UP
HAT_LEFTDOWN :: HAT_LEFT|HAT_DOWN; HAT_LEFTDOWN :: HAT_LEFT|HAT_DOWN
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_keyboard.odin
Vendored
+4 -4
View File
@@ -34,12 +34,12 @@ foreign lib {
} }
GetKeyboardStateAsSlice :: proc "c" () -> []u8 { GetKeyboardStateAsSlice :: proc "c" () -> []u8 {
numkeys: c.int; numkeys: c.int
keys := GetKeyboardState(&numkeys); keys := GetKeyboardState(&numkeys)
if keys != nil { if keys != nil {
return keys[:numkeys]; return keys[:numkeys]
} }
return nil; return nil
} }
GetModState :: #force_inline proc "c" () -> Keymod { return transmute(Keymod)u16(SDL_GetModState()) } GetModState :: #force_inline proc "c" () -> Keymod { return transmute(Keymod)u16(SDL_GetModState()) }
vendor/sdl2/sdl_keycode.odin
Vendored
+19 -19
View File
@@ -1,9 +1,9 @@
package sdl2 package sdl2
SCANCODE_MASK :: 1<<30; SCANCODE_MASK :: 1<<30
SCANCODE_TO_KEYCODE :: #force_inline proc "c" (X: Scancode) -> KeyCode { SCANCODE_TO_KEYCODE :: #force_inline proc "c" (X: Scancode) -> KeyCode {
return KeyCode(i32(X) | SCANCODE_MASK); return KeyCode(i32(X) | SCANCODE_MASK)
} }
KeyCode :: enum i32 { KeyCode :: enum i32 {
@@ -309,22 +309,22 @@ KeymodFlag :: enum u16 {
RESERVED = 0xf, RESERVED = 0xf,
} }
Keymod :: distinct bit_set[KeymodFlag; u16]; Keymod :: distinct bit_set[KeymodFlag; u16]
KMOD_NONE :: Keymod{}; KMOD_NONE :: Keymod{}
KMOD_LSHIFT :: Keymod{.LSHIFT}; KMOD_LSHIFT :: Keymod{.LSHIFT}
KMOD_RSHIFT :: Keymod{.RSHIFT}; KMOD_RSHIFT :: Keymod{.RSHIFT}
KMOD_LCTRL :: Keymod{.LCTRL}; KMOD_LCTRL :: Keymod{.LCTRL}
KMOD_RCTRL :: Keymod{.RCTRL}; KMOD_RCTRL :: Keymod{.RCTRL}
KMOD_LALT :: Keymod{.LALT}; KMOD_LALT :: Keymod{.LALT}
KMOD_RALT :: Keymod{.RALT}; KMOD_RALT :: Keymod{.RALT}
KMOD_LGUI :: Keymod{.LGUI}; KMOD_LGUI :: Keymod{.LGUI}
KMOD_RGUI :: Keymod{.RGUI}; KMOD_RGUI :: Keymod{.RGUI}
KMOD_NUM :: Keymod{.NUM}; KMOD_NUM :: Keymod{.NUM}
KMOD_CAPS :: Keymod{.CAPS}; KMOD_CAPS :: Keymod{.CAPS}
KMOD_MODE :: Keymod{.MODE}; KMOD_MODE :: Keymod{.MODE}
KMOD_RESERVED :: Keymod{.RESERVED}; KMOD_RESERVED :: Keymod{.RESERVED}
KMOD_CTRL :: Keymod{.LCTRL, .RCTRL}; KMOD_CTRL :: Keymod{.LCTRL, .RCTRL}
KMOD_SHIFT :: Keymod{.LSHIFT, .RSHIFT}; KMOD_SHIFT :: Keymod{.LSHIFT, .RSHIFT}
KMOD_ALT :: Keymod{.LALT, .RALT}; KMOD_ALT :: Keymod{.LALT, .RALT}
KMOD_GUI :: Keymod{.LGUI, .RGUI}; KMOD_GUI :: Keymod{.LGUI, .RGUI};
vendor/sdl2/sdl_log.odin
Vendored
+2 -2
View File
@@ -7,7 +7,7 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
MAX_LOG_MESSAGE :: 4096; MAX_LOG_MESSAGE :: 4096
LogCategory :: enum c.int { LogCategory :: enum c.int {
APPLICATION, APPLICATION,
@@ -54,7 +54,7 @@ LogPriority :: enum c.int {
NUM, NUM,
} }
LogOutputFunction :: proc "c" (userdata: rawptr, category: LogCategory, priority: LogPriority, message: cstring); LogOutputFunction :: proc "c" (userdata: rawptr, category: LogCategory, priority: LogPriority, message: cstring)
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
vendor/sdl2/sdl_messagebox.odin
Vendored
+9 -9
View File
@@ -17,22 +17,22 @@ MessageBoxFlag :: enum u32 {
} }
MessageBoxFlags :: distinct bit_set[MessageBoxFlag; u32]; MessageBoxFlags :: distinct bit_set[MessageBoxFlag; u32]
MESSAGEBOX_ERROR :: MessageBoxFlags{.ERROR}; MESSAGEBOX_ERROR :: MessageBoxFlags{.ERROR}
MESSAGEBOX_WARNING :: MessageBoxFlags{.WARNING}; MESSAGEBOX_WARNING :: MessageBoxFlags{.WARNING}
MESSAGEBOX_INFORMATION :: MessageBoxFlags{.INFORMATION}; MESSAGEBOX_INFORMATION :: MessageBoxFlags{.INFORMATION}
MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT :: MessageBoxFlags{.BUTTONS_LEFT_TO_RIGHT}; MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT :: MessageBoxFlags{.BUTTONS_LEFT_TO_RIGHT}
MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT :: MessageBoxFlags{.BUTTONS_RIGHT_TO_LEFT}; MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT :: MessageBoxFlags{.BUTTONS_RIGHT_TO_LEFT}
MessageBoxButtonFlag :: enum u32 { MessageBoxButtonFlag :: enum u32 {
RETURNKEY_DEFAULT = 0, /**< Marks the default button when return is hit */ RETURNKEY_DEFAULT = 0, /**< Marks the default button when return is hit */
ESCAPEKEY_DEFAULT = 1, /**< Marks the default button when escape is hit */ ESCAPEKEY_DEFAULT = 1, /**< Marks the default button when escape is hit */
} }
MessageBoxButtonFlags :: distinct bit_set[MessageBoxButtonFlag; u32]; MessageBoxButtonFlags :: distinct bit_set[MessageBoxButtonFlag; u32]
MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT :: MessageBoxButtonFlags{.RETURNKEY_DEFAULT}; MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT :: MessageBoxButtonFlags{.RETURNKEY_DEFAULT}
MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT :: MessageBoxButtonFlags{.ESCAPEKEY_DEFAULT}; MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT :: MessageBoxButtonFlags{.ESCAPEKEY_DEFAULT}
MessageBoxButtonData :: struct { MessageBoxButtonData :: struct {
flags: MessageBoxButtonFlags, /**< ::SDL_MessageBoxButtonFlags */ flags: MessageBoxButtonFlags, /**< ::SDL_MessageBoxButtonFlags */
vendor/sdl2/sdl_metal.odin
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
MetalView :: distinct rawptr; MetalView :: distinct rawptr
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_mouse.odin
Vendored
+11 -11
View File
@@ -7,19 +7,19 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
Cursor :: struct {}; Cursor :: struct {}
BUTTON :: #force_inline proc "c" (X: c.int) -> c.int { return 1 << u32(X-1) } BUTTON :: #force_inline proc "c" (X: c.int) -> c.int { return 1 << u32(X-1) }
BUTTON_LEFT :: 1; BUTTON_LEFT :: 1
BUTTON_MIDDLE :: 2; BUTTON_MIDDLE :: 2
BUTTON_RIGHT :: 3; BUTTON_RIGHT :: 3
BUTTON_X1 :: 4; BUTTON_X1 :: 4
BUTTON_X2 :: 5; BUTTON_X2 :: 5
BUTTON_LMASK :: 1<<(BUTTON_LEFT-1); BUTTON_LMASK :: 1<<(BUTTON_LEFT-1)
BUTTON_MMASK :: 1<<(BUTTON_MIDDLE-1); BUTTON_MMASK :: 1<<(BUTTON_MIDDLE-1)
BUTTON_RMASK :: 1<<(BUTTON_RIGHT-1); BUTTON_RMASK :: 1<<(BUTTON_RIGHT-1)
BUTTON_X1MASK :: 1<<(BUTTON_X1-1); BUTTON_X1MASK :: 1<<(BUTTON_X1-1)
BUTTON_X2MASK :: 1<<(BUTTON_X2-1); BUTTON_X2MASK :: 1<<(BUTTON_X2-1)
SystemCursor :: enum c.int { SystemCursor :: enum c.int {
ARROW, /**< Arrow */ ARROW, /**< Arrow */
vendor/sdl2/sdl_mutex.odin
Vendored
+8 -8
View File
@@ -7,18 +7,18 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
MUTEX_TIMEDOUT :: 1; MUTEX_TIMEDOUT :: 1
MUTEX_MAXWAIT :: ~u32(0); MUTEX_MAXWAIT :: ~u32(0)
mutex :: struct {}; mutex :: struct {}
semaphore :: struct {}; semaphore :: struct {}
sem :: semaphore; sem :: semaphore
cond :: struct {}; cond :: struct {}
mutexP :: LockMutex; mutexP :: LockMutex
mutexV :: UnlockMutex; mutexV :: UnlockMutex
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_pixels.odin
Vendored
+45 -45
View File
@@ -7,63 +7,63 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
ALPHA_OPAQUE :: 255; ALPHA_OPAQUE :: 255
ALPHA_TRANSPARENT :: 0; ALPHA_TRANSPARENT :: 0
PIXELTYPE_UNKNOWN :: 0; PIXELTYPE_UNKNOWN :: 0
PIXELTYPE_INDEX1 :: 1; PIXELTYPE_INDEX1 :: 1
PIXELTYPE_INDEX4 :: 2; PIXELTYPE_INDEX4 :: 2
PIXELTYPE_INDEX8 :: 3; PIXELTYPE_INDEX8 :: 3
PIXELTYPE_PACKED8 :: 4; PIXELTYPE_PACKED8 :: 4
PIXELTYPE_PACKED16 :: 5; PIXELTYPE_PACKED16 :: 5
PIXELTYPE_PACKED32 :: 6; PIXELTYPE_PACKED32 :: 6
PIXELTYPE_ARRAYU8 :: 7; PIXELTYPE_ARRAYU8 :: 7
PIXELTYPE_ARRAYU16 :: 8; PIXELTYPE_ARRAYU16 :: 8
PIXELTYPE_ARRAYU32 :: 9; PIXELTYPE_ARRAYU32 :: 9
PIXELTYPE_ARRAYF16 :: 10; PIXELTYPE_ARRAYF16 :: 10
PIXELTYPE_ARRAYF3 :: 11; PIXELTYPE_ARRAYF3 :: 11
BITMAPORDER_NONE :: 0; BITMAPORDER_NONE :: 0
BITMAPORDER_4321 :: 1; BITMAPORDER_4321 :: 1
BITMAPORDER_1234 :: 2; BITMAPORDER_1234 :: 2
PACKEDORDER_NONE :: 0; PACKEDORDER_NONE :: 0
PACKEDORDER_XRGB :: 1; PACKEDORDER_XRGB :: 1
PACKEDORDER_RGBX :: 2; PACKEDORDER_RGBX :: 2
PACKEDORDER_ARGB :: 3; PACKEDORDER_ARGB :: 3
PACKEDORDER_RGBA :: 4; PACKEDORDER_RGBA :: 4
PACKEDORDER_XBGR :: 5; PACKEDORDER_XBGR :: 5
PACKEDORDER_BGRX :: 6; PACKEDORDER_BGRX :: 6
PACKEDORDER_ABGR :: 7; PACKEDORDER_ABGR :: 7
PACKEDORDER_BGRA :: 8; PACKEDORDER_BGRA :: 8
/** Array component order, low byte -> high byte. */ /** Array component order, low byte -> high byte. */
/* !!! FIXME: in 2.1, make these not overlap differently with /* !!! FIXME: in 2.1, make these not overlap differently with
!!! FIXME: SDL_PACKEDORDER_*, so we can simplify SDL_ISPIXELFORMAT_ALPHA */ !!! FIXME: SDL_PACKEDORDER_*, so we can simplify SDL_ISPIXELFORMAT_ALPHA */
ARRAYORDER_NONE :: 0; ARRAYORDER_NONE :: 0
ARRAYORDER_RGB :: 1; ARRAYORDER_RGB :: 1
ARRAYORDER_RGBA :: 2; ARRAYORDER_RGBA :: 2
ARRAYORDER_ARGB :: 3; ARRAYORDER_ARGB :: 3
ARRAYORDER_BGR :: 4; ARRAYORDER_BGR :: 4
ARRAYORDER_BGRA :: 5; ARRAYORDER_BGRA :: 5
ARRAYORDER_ABG :: 6; ARRAYORDER_ABG :: 6
PACKEDLAYOUT_NONE :: 0; PACKEDLAYOUT_NONE :: 0
PACKEDLAYOUT_332 :: 1; PACKEDLAYOUT_332 :: 1
PACKEDLAYOUT_4444 :: 2; PACKEDLAYOUT_4444 :: 2
PACKEDLAYOUT_1555 :: 3; PACKEDLAYOUT_1555 :: 3
PACKEDLAYOUT_5551 :: 4; PACKEDLAYOUT_5551 :: 4
PACKEDLAYOUT_565 :: 5; PACKEDLAYOUT_565 :: 5
PACKEDLAYOUT_8888 :: 6; PACKEDLAYOUT_8888 :: 6
PACKEDLAYOUT_2101010 :: 7; PACKEDLAYOUT_2101010 :: 7
PACKEDLAYOUT_101010 :: 8; PACKEDLAYOUT_101010 :: 8
DEFINE_PIXELFOURCC :: FOURCC; DEFINE_PIXELFOURCC :: FOURCC
DEFINE_PIXELFORMAT :: #force_inline proc "c" (type: u8, order: u8, layout, bits, bytes: u8) -> u32 { DEFINE_PIXELFORMAT :: #force_inline proc "c" (type: u8, order: u8, layout, bits, bytes: u8) -> u32 {
return (1 << 28) | (u32(type) << 24) | (u32(order) << 20) | (u32(layout) << 16) | (u32(bits) << 8) | (u32(bytes) << 0); return (1 << 28) | (u32(type) << 24) | (u32(order) << 20) | (u32(layout) << 16) | (u32(bits) << 8) | (u32(bytes) << 0)
} }
@@ -180,7 +180,7 @@ PixelFormatEnum :: enum u32 {
} }
Colour :: Color; Colour :: Color
Color :: struct { Color :: struct {
r: u8, r: u8,
g: u8, g: u8,
vendor/sdl2/sdl_rect.odin
Vendored
+3 -3
View File
@@ -29,15 +29,15 @@ FRect :: struct {
} }
PointInRect :: proc(p, r: ^Rect) -> bool { PointInRect :: proc(p, r: ^Rect) -> bool {
return bool((p.x >= r.x) && (p.x < (r.x + r.w)) && (p.y >= r.y) && (p.y < (r.y + r.h))); return bool((p.x >= r.x) && (p.x < (r.x + r.w)) && (p.y >= r.y) && (p.y < (r.y + r.h)))
} }
RectEmpty :: proc(r: ^Rect) -> bool { RectEmpty :: proc(r: ^Rect) -> bool {
return bool(r == nil|| r.w <= 0 || r.h <= 0); return bool(r == nil|| r.w <= 0 || r.h <= 0)
} }
RectEquals :: proc(a, b: ^Rect) -> bool { RectEquals :: proc(a, b: ^Rect) -> bool {
return a != nil && b != nil && a^ == b^; return a != nil && b != nil && a^ == b^
} }
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
vendor/sdl2/sdl_render.odin
Vendored
+10 -10
View File
@@ -14,12 +14,12 @@ RendererFlag :: enum u32 {
TARGETTEXTURE = 3, /**< The renderer supports rendering to texture */ TARGETTEXTURE = 3, /**< The renderer supports rendering to texture */
} }
RendererFlags :: distinct bit_set[RendererFlag; u32]; RendererFlags :: distinct bit_set[RendererFlag; u32]
RENDERER_SOFTWARE :: RendererFlags{.SOFTWARE}; RENDERER_SOFTWARE :: RendererFlags{.SOFTWARE}
RENDERER_ACCELERATED :: RendererFlags{.ACCELERATED}; RENDERER_ACCELERATED :: RendererFlags{.ACCELERATED}
RENDERER_PRESENTVSYNC :: RendererFlags{.PRESENTVSYNC}; RENDERER_PRESENTVSYNC :: RendererFlags{.PRESENTVSYNC}
RENDERER_TARGETTEXTURE :: RendererFlags{.TARGETTEXTURE}; RENDERER_TARGETTEXTURE :: RendererFlags{.TARGETTEXTURE}
RendererInfo :: struct { RendererInfo :: struct {
name: cstring, /**< The name of the renderer */ name: cstring, /**< The name of the renderer */
@@ -48,9 +48,9 @@ TextureAccess :: enum c.int {
TARGET, /**< Texture can be used as a render target */ TARGET, /**< Texture can be used as a render target */
} }
SDL_TEXTUREMODULATE_NONE :: 0x00000000; /**< No modulation */ SDL_TEXTUREMODULATE_NONE :: 0x00000000 /**< No modulation */
SDL_TEXTUREMODULATE_COLOR :: 0x00000001; /**< srcC = srcC * color */ SDL_TEXTUREMODULATE_COLOR :: 0x00000001 /**< srcC = srcC * color */
SDL_TEXTUREMODULATE_ALPHA :: 0x00000002; /**< srcA = srcA * alpha */ SDL_TEXTUREMODULATE_ALPHA :: 0x00000002 /**< srcA = srcA * alpha */
/** /**
* Flip constants for SDL_RenderCopyEx * Flip constants for SDL_RenderCopyEx
@@ -61,9 +61,9 @@ RendererFlip :: enum c.int {
VERTICAL = 0x00000002, /**< flip vertically */ VERTICAL = 0x00000002, /**< flip vertically */
} }
Renderer :: struct {}; Renderer :: struct {}
Texture :: struct {}; Texture :: struct {}
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_rwops.odin
Vendored
+10 -10
View File
@@ -8,13 +8,13 @@ when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
/* RWops Types */ /* RWops Types */
RWOPS_UNKNOWN :: 0; /**< Unknown stream type */ RWOPS_UNKNOWN :: 0 /**< Unknown stream type */
RWOPS_WINFILE :: 1; /**< Win32 file */ RWOPS_WINFILE :: 1 /**< Win32 file */
RWOPS_STDFILE :: 2; /**< Stdio file */ RWOPS_STDFILE :: 2 /**< Stdio file */
RWOPS_JNIFILE :: 3; /**< Android asset */ RWOPS_JNIFILE :: 3 /**< Android asset */
RWOPS_MEMORY :: 4; /**< Memory stream */ RWOPS_MEMORY :: 4 /**< Memory stream */
RWOPS_MEMORY_RO :: 5; /**< Read-Only memory stream */ RWOPS_MEMORY_RO :: 5 /**< Read-Only memory stream */
RWOPS_VITAFILE :: 6; /**< Vita file */ RWOPS_VITAFILE :: 6 /**< Vita file */
/** /**
@@ -66,9 +66,9 @@ RWops :: struct {
} }
SEEK_SET :: 0; /**< Seek from the beginning of data */ SEEK_SET :: 0 /**< Seek from the beginning of data */
SEEK_CUR :: 1; /**< Seek relative to current read point */ SEEK_CUR :: 1 /**< Seek relative to current read point */
SEEK_END :: 2; /**< Seek relative to the end of data */ SEEK_END :: 2 /**< Seek relative to the end of data */
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_scancode.odin
Vendored
+243 -243
View File
@@ -273,270 +273,270 @@ Scancode :: enum c.int {
NUM_SCANCODES = 512, NUM_SCANCODES = 512,
} }
NUM_SCANCODES :: 512; NUM_SCANCODES :: 512
SCANCODE_UNKNOWN :: Scancode.UNKNOWN; SCANCODE_UNKNOWN :: Scancode.UNKNOWN
SCANCODE_A :: Scancode.A; SCANCODE_A :: Scancode.A
SCANCODE_B :: Scancode.B; SCANCODE_B :: Scancode.B
SCANCODE_C :: Scancode.C; SCANCODE_C :: Scancode.C
SCANCODE_D :: Scancode.D; SCANCODE_D :: Scancode.D
SCANCODE_E :: Scancode.E; SCANCODE_E :: Scancode.E
SCANCODE_F :: Scancode.F; SCANCODE_F :: Scancode.F
SCANCODE_G :: Scancode.G; SCANCODE_G :: Scancode.G
SCANCODE_H :: Scancode.H; SCANCODE_H :: Scancode.H
SCANCODE_I :: Scancode.I; SCANCODE_I :: Scancode.I
SCANCODE_J :: Scancode.J; SCANCODE_J :: Scancode.J
SCANCODE_K :: Scancode.K; SCANCODE_K :: Scancode.K
SCANCODE_L :: Scancode.L; SCANCODE_L :: Scancode.L
SCANCODE_M :: Scancode.M; SCANCODE_M :: Scancode.M
SCANCODE_N :: Scancode.N; SCANCODE_N :: Scancode.N
SCANCODE_O :: Scancode.O; SCANCODE_O :: Scancode.O
SCANCODE_P :: Scancode.P; SCANCODE_P :: Scancode.P
SCANCODE_Q :: Scancode.Q; SCANCODE_Q :: Scancode.Q
SCANCODE_R :: Scancode.R; SCANCODE_R :: Scancode.R
SCANCODE_S :: Scancode.S; SCANCODE_S :: Scancode.S
SCANCODE_T :: Scancode.T; SCANCODE_T :: Scancode.T
SCANCODE_U :: Scancode.U; SCANCODE_U :: Scancode.U
SCANCODE_V :: Scancode.V; SCANCODE_V :: Scancode.V
SCANCODE_W :: Scancode.W; SCANCODE_W :: Scancode.W
SCANCODE_X :: Scancode.X; SCANCODE_X :: Scancode.X
SCANCODE_Y :: Scancode.Y; SCANCODE_Y :: Scancode.Y
SCANCODE_Z :: Scancode.Z; SCANCODE_Z :: Scancode.Z
SCANCODE_1 :: Scancode.NUM1; SCANCODE_1 :: Scancode.NUM1
SCANCODE_2 :: Scancode.NUM2; SCANCODE_2 :: Scancode.NUM2
SCANCODE_3 :: Scancode.NUM3; SCANCODE_3 :: Scancode.NUM3
SCANCODE_4 :: Scancode.NUM4; SCANCODE_4 :: Scancode.NUM4
SCANCODE_5 :: Scancode.NUM5; SCANCODE_5 :: Scancode.NUM5
SCANCODE_6 :: Scancode.NUM6; SCANCODE_6 :: Scancode.NUM6
SCANCODE_7 :: Scancode.NUM7; SCANCODE_7 :: Scancode.NUM7
SCANCODE_8 :: Scancode.NUM8; SCANCODE_8 :: Scancode.NUM8
SCANCODE_9 :: Scancode.NUM9; SCANCODE_9 :: Scancode.NUM9
SCANCODE_0 :: Scancode.NUM0; SCANCODE_0 :: Scancode.NUM0
SCANCODE_RETURN :: Scancode.RETURN; SCANCODE_RETURN :: Scancode.RETURN
SCANCODE_ESCAPE :: Scancode.ESCAPE; SCANCODE_ESCAPE :: Scancode.ESCAPE
SCANCODE_BACKSPACE :: Scancode.BACKSPACE; SCANCODE_BACKSPACE :: Scancode.BACKSPACE
SCANCODE_TAB :: Scancode.TAB; SCANCODE_TAB :: Scancode.TAB
SCANCODE_SPACE :: Scancode.SPACE; SCANCODE_SPACE :: Scancode.SPACE
SCANCODE_MINUS :: Scancode.MINUS; SCANCODE_MINUS :: Scancode.MINUS
SCANCODE_EQUALS :: Scancode.EQUALS; SCANCODE_EQUALS :: Scancode.EQUALS
SCANCODE_LEFTBRACKET :: Scancode.LEFTBRACKET; SCANCODE_LEFTBRACKET :: Scancode.LEFTBRACKET
SCANCODE_RIGHTBRACKET :: Scancode.RIGHTBRACKET; SCANCODE_RIGHTBRACKET :: Scancode.RIGHTBRACKET
SCANCODE_BACKSLASH :: Scancode.BACKSLASH; SCANCODE_BACKSLASH :: Scancode.BACKSLASH
SCANCODE_NONUSHASH :: Scancode.NONUSHASH; SCANCODE_NONUSHASH :: Scancode.NONUSHASH
SCANCODE_SEMICOLON :: Scancode.SEMICOLON; SCANCODE_SEMICOLON :: Scancode.SEMICOLON
SCANCODE_APOSTROPHE :: Scancode.APOSTROPHE; SCANCODE_APOSTROPHE :: Scancode.APOSTROPHE
SCANCODE_GRAVE :: Scancode.GRAVE; SCANCODE_GRAVE :: Scancode.GRAVE
SCANCODE_COMMA :: Scancode.COMMA; SCANCODE_COMMA :: Scancode.COMMA
SCANCODE_PERIOD :: Scancode.PERIOD; SCANCODE_PERIOD :: Scancode.PERIOD
SCANCODE_SLASH :: Scancode.SLASH; SCANCODE_SLASH :: Scancode.SLASH
SCANCODE_CAPSLOCK :: Scancode.CAPSLOCK; SCANCODE_CAPSLOCK :: Scancode.CAPSLOCK
SCANCODE_F1 :: Scancode.F1; SCANCODE_F1 :: Scancode.F1
SCANCODE_F2 :: Scancode.F2; SCANCODE_F2 :: Scancode.F2
SCANCODE_F3 :: Scancode.F3; SCANCODE_F3 :: Scancode.F3
SCANCODE_F4 :: Scancode.F4; SCANCODE_F4 :: Scancode.F4
SCANCODE_F5 :: Scancode.F5; SCANCODE_F5 :: Scancode.F5
SCANCODE_F6 :: Scancode.F6; SCANCODE_F6 :: Scancode.F6
SCANCODE_F7 :: Scancode.F7; SCANCODE_F7 :: Scancode.F7
SCANCODE_F8 :: Scancode.F8; SCANCODE_F8 :: Scancode.F8
SCANCODE_F9 :: Scancode.F9; SCANCODE_F9 :: Scancode.F9
SCANCODE_F10 :: Scancode.F10; SCANCODE_F10 :: Scancode.F10
SCANCODE_F11 :: Scancode.F11; SCANCODE_F11 :: Scancode.F11
SCANCODE_F12 :: Scancode.F12; SCANCODE_F12 :: Scancode.F12
SCANCODE_PRINTSCREEN :: Scancode.PRINTSCREEN; SCANCODE_PRINTSCREEN :: Scancode.PRINTSCREEN
SCANCODE_SCROLLLOCK :: Scancode.SCROLLLOCK; SCANCODE_SCROLLLOCK :: Scancode.SCROLLLOCK
SCANCODE_PAUSE :: Scancode.PAUSE; SCANCODE_PAUSE :: Scancode.PAUSE
SCANCODE_INSERT :: Scancode.INSERT; SCANCODE_INSERT :: Scancode.INSERT
SCANCODE_HOME :: Scancode.HOME; SCANCODE_HOME :: Scancode.HOME
SCANCODE_PAGEUP :: Scancode.PAGEUP; SCANCODE_PAGEUP :: Scancode.PAGEUP
SCANCODE_DELETE :: Scancode.DELETE; SCANCODE_DELETE :: Scancode.DELETE
SCANCODE_END :: Scancode.END; SCANCODE_END :: Scancode.END
SCANCODE_PAGEDOWN :: Scancode.PAGEDOWN; SCANCODE_PAGEDOWN :: Scancode.PAGEDOWN
SCANCODE_RIGHT :: Scancode.RIGHT; SCANCODE_RIGHT :: Scancode.RIGHT
SCANCODE_LEFT :: Scancode.LEFT; SCANCODE_LEFT :: Scancode.LEFT
SCANCODE_DOWN :: Scancode.DOWN; SCANCODE_DOWN :: Scancode.DOWN
SCANCODE_UP :: Scancode.UP; SCANCODE_UP :: Scancode.UP
SCANCODE_NUMLOCKCLEAR :: Scancode.NUMLOCKCLEAR; SCANCODE_NUMLOCKCLEAR :: Scancode.NUMLOCKCLEAR
SCANCODE_KP_DIVIDE :: Scancode.KP_DIVIDE; SCANCODE_KP_DIVIDE :: Scancode.KP_DIVIDE
SCANCODE_KP_MULTIPLY :: Scancode.KP_MULTIPLY; SCANCODE_KP_MULTIPLY :: Scancode.KP_MULTIPLY
SCANCODE_KP_MINUS :: Scancode.KP_MINUS; SCANCODE_KP_MINUS :: Scancode.KP_MINUS
SCANCODE_KP_PLUS :: Scancode.KP_PLUS; SCANCODE_KP_PLUS :: Scancode.KP_PLUS
SCANCODE_KP_ENTER :: Scancode.KP_ENTER; SCANCODE_KP_ENTER :: Scancode.KP_ENTER
SCANCODE_KP_1 :: Scancode.KP_1; SCANCODE_KP_1 :: Scancode.KP_1
SCANCODE_KP_2 :: Scancode.KP_2; SCANCODE_KP_2 :: Scancode.KP_2
SCANCODE_KP_3 :: Scancode.KP_3; SCANCODE_KP_3 :: Scancode.KP_3
SCANCODE_KP_4 :: Scancode.KP_4; SCANCODE_KP_4 :: Scancode.KP_4
SCANCODE_KP_5 :: Scancode.KP_5; SCANCODE_KP_5 :: Scancode.KP_5
SCANCODE_KP_6 :: Scancode.KP_6; SCANCODE_KP_6 :: Scancode.KP_6
SCANCODE_KP_7 :: Scancode.KP_7; SCANCODE_KP_7 :: Scancode.KP_7
SCANCODE_KP_8 :: Scancode.KP_8; SCANCODE_KP_8 :: Scancode.KP_8
SCANCODE_KP_9 :: Scancode.KP_9; SCANCODE_KP_9 :: Scancode.KP_9
SCANCODE_KP_0 :: Scancode.KP_0; SCANCODE_KP_0 :: Scancode.KP_0
SCANCODE_KP_PERIOD :: Scancode.KP_PERIOD; SCANCODE_KP_PERIOD :: Scancode.KP_PERIOD
SCANCODE_NONUSBACKSLASH :: Scancode.NONUSBACKSLASH; SCANCODE_NONUSBACKSLASH :: Scancode.NONUSBACKSLASH
SCANCODE_APPLICATION :: Scancode.APPLICATION; SCANCODE_APPLICATION :: Scancode.APPLICATION
SCANCODE_POWER :: Scancode.POWER; SCANCODE_POWER :: Scancode.POWER
SCANCODE_KP_EQUALS :: Scancode.KP_EQUALS; SCANCODE_KP_EQUALS :: Scancode.KP_EQUALS
SCANCODE_F13 :: Scancode.F13; SCANCODE_F13 :: Scancode.F13
SCANCODE_F14 :: Scancode.F14; SCANCODE_F14 :: Scancode.F14
SCANCODE_F15 :: Scancode.F15; SCANCODE_F15 :: Scancode.F15
SCANCODE_F16 :: Scancode.F16; SCANCODE_F16 :: Scancode.F16
SCANCODE_F17 :: Scancode.F17; SCANCODE_F17 :: Scancode.F17
SCANCODE_F18 :: Scancode.F18; SCANCODE_F18 :: Scancode.F18
SCANCODE_F19 :: Scancode.F19; SCANCODE_F19 :: Scancode.F19
SCANCODE_F20 :: Scancode.F20; SCANCODE_F20 :: Scancode.F20
SCANCODE_F21 :: Scancode.F21; SCANCODE_F21 :: Scancode.F21
SCANCODE_F22 :: Scancode.F22; SCANCODE_F22 :: Scancode.F22
SCANCODE_F23 :: Scancode.F23; SCANCODE_F23 :: Scancode.F23
SCANCODE_F24 :: Scancode.F24; SCANCODE_F24 :: Scancode.F24
SCANCODE_EXECUTE :: Scancode.EXECUTE; SCANCODE_EXECUTE :: Scancode.EXECUTE
SCANCODE_HELP :: Scancode.HELP; SCANCODE_HELP :: Scancode.HELP
SCANCODE_MENU :: Scancode.MENU; SCANCODE_MENU :: Scancode.MENU
SCANCODE_SELECT :: Scancode.SELECT; SCANCODE_SELECT :: Scancode.SELECT
SCANCODE_STOP :: Scancode.STOP; SCANCODE_STOP :: Scancode.STOP
SCANCODE_AGAIN :: Scancode.AGAIN; SCANCODE_AGAIN :: Scancode.AGAIN
SCANCODE_UNDO :: Scancode.UNDO; SCANCODE_UNDO :: Scancode.UNDO
SCANCODE_CUT :: Scancode.CUT; SCANCODE_CUT :: Scancode.CUT
SCANCODE_COPY :: Scancode.COPY; SCANCODE_COPY :: Scancode.COPY
SCANCODE_PASTE :: Scancode.PASTE; SCANCODE_PASTE :: Scancode.PASTE
SCANCODE_FIND :: Scancode.FIND; SCANCODE_FIND :: Scancode.FIND
SCANCODE_MUTE :: Scancode.MUTE; SCANCODE_MUTE :: Scancode.MUTE
SCANCODE_VOLUMEUP :: Scancode.VOLUMEUP; SCANCODE_VOLUMEUP :: Scancode.VOLUMEUP
SCANCODE_VOLUMEDOWN :: Scancode.VOLUMEDOWN; SCANCODE_VOLUMEDOWN :: Scancode.VOLUMEDOWN
SCANCODE_KP_COMMA :: Scancode.KP_COMMA; SCANCODE_KP_COMMA :: Scancode.KP_COMMA
SCANCODE_KP_EQUALSAS400 :: Scancode.KP_EQUALSAS400; SCANCODE_KP_EQUALSAS400 :: Scancode.KP_EQUALSAS400
SCANCODE_INTERNATIONAL1 :: Scancode.INTERNATIONAL1; SCANCODE_INTERNATIONAL1 :: Scancode.INTERNATIONAL1
SCANCODE_INTERNATIONAL2 :: Scancode.INTERNATIONAL2; SCANCODE_INTERNATIONAL2 :: Scancode.INTERNATIONAL2
SCANCODE_INTERNATIONAL3 :: Scancode.INTERNATIONAL3; SCANCODE_INTERNATIONAL3 :: Scancode.INTERNATIONAL3
SCANCODE_INTERNATIONAL4 :: Scancode.INTERNATIONAL4; SCANCODE_INTERNATIONAL4 :: Scancode.INTERNATIONAL4
SCANCODE_INTERNATIONAL5 :: Scancode.INTERNATIONAL5; SCANCODE_INTERNATIONAL5 :: Scancode.INTERNATIONAL5
SCANCODE_INTERNATIONAL6 :: Scancode.INTERNATIONAL6; SCANCODE_INTERNATIONAL6 :: Scancode.INTERNATIONAL6
SCANCODE_INTERNATIONAL7 :: Scancode.INTERNATIONAL7; SCANCODE_INTERNATIONAL7 :: Scancode.INTERNATIONAL7
SCANCODE_INTERNATIONAL8 :: Scancode.INTERNATIONAL8; SCANCODE_INTERNATIONAL8 :: Scancode.INTERNATIONAL8
SCANCODE_INTERNATIONAL9 :: Scancode.INTERNATIONAL9; SCANCODE_INTERNATIONAL9 :: Scancode.INTERNATIONAL9
SCANCODE_LANG1 :: Scancode.LANG1; SCANCODE_LANG1 :: Scancode.LANG1
SCANCODE_LANG2 :: Scancode.LANG2; SCANCODE_LANG2 :: Scancode.LANG2
SCANCODE_LANG3 :: Scancode.LANG3; SCANCODE_LANG3 :: Scancode.LANG3
SCANCODE_LANG4 :: Scancode.LANG4; SCANCODE_LANG4 :: Scancode.LANG4
SCANCODE_LANG5 :: Scancode.LANG5; SCANCODE_LANG5 :: Scancode.LANG5
SCANCODE_LANG6 :: Scancode.LANG6; SCANCODE_LANG6 :: Scancode.LANG6
SCANCODE_LANG7 :: Scancode.LANG7; SCANCODE_LANG7 :: Scancode.LANG7
SCANCODE_LANG8 :: Scancode.LANG8; SCANCODE_LANG8 :: Scancode.LANG8
SCANCODE_LANG9 :: Scancode.LANG9; SCANCODE_LANG9 :: Scancode.LANG9
SCANCODE_ALTERASE :: Scancode.ALTERASE; SCANCODE_ALTERASE :: Scancode.ALTERASE
SCANCODE_SYSREQ :: Scancode.SYSREQ; SCANCODE_SYSREQ :: Scancode.SYSREQ
SCANCODE_CANCEL :: Scancode.CANCEL; SCANCODE_CANCEL :: Scancode.CANCEL
SCANCODE_CLEAR :: Scancode.CLEAR; SCANCODE_CLEAR :: Scancode.CLEAR
SCANCODE_PRIOR :: Scancode.PRIOR; SCANCODE_PRIOR :: Scancode.PRIOR
SCANCODE_RETURN2 :: Scancode.RETURN2; SCANCODE_RETURN2 :: Scancode.RETURN2
SCANCODE_SEPARATOR :: Scancode.SEPARATOR; SCANCODE_SEPARATOR :: Scancode.SEPARATOR
SCANCODE_OUT :: Scancode.OUT; SCANCODE_OUT :: Scancode.OUT
SCANCODE_OPER :: Scancode.OPER; SCANCODE_OPER :: Scancode.OPER
SCANCODE_CLEARAGAIN :: Scancode.CLEARAGAIN; SCANCODE_CLEARAGAIN :: Scancode.CLEARAGAIN
SCANCODE_CRSEL :: Scancode.CRSEL; SCANCODE_CRSEL :: Scancode.CRSEL
SCANCODE_EXSEL :: Scancode.EXSEL; SCANCODE_EXSEL :: Scancode.EXSEL
SCANCODE_KP_00 :: Scancode.KP_00; SCANCODE_KP_00 :: Scancode.KP_00
SCANCODE_KP_000 :: Scancode.KP_000; SCANCODE_KP_000 :: Scancode.KP_000
SCANCODE_THOUSANDSSEPARATOR :: Scancode.THOUSANDSSEPARATOR; SCANCODE_THOUSANDSSEPARATOR :: Scancode.THOUSANDSSEPARATOR
SCANCODE_DECIMALSEPARATOR :: Scancode.DECIMALSEPARATOR; SCANCODE_DECIMALSEPARATOR :: Scancode.DECIMALSEPARATOR
SCANCODE_CURRENCYUNIT :: Scancode.CURRENCYUNIT; SCANCODE_CURRENCYUNIT :: Scancode.CURRENCYUNIT
SCANCODE_CURRENCYSUBUNIT :: Scancode.CURRENCYSUBUNIT; SCANCODE_CURRENCYSUBUNIT :: Scancode.CURRENCYSUBUNIT
SCANCODE_KP_LEFTPAREN :: Scancode.KP_LEFTPAREN; SCANCODE_KP_LEFTPAREN :: Scancode.KP_LEFTPAREN
SCANCODE_KP_RIGHTPAREN :: Scancode.KP_RIGHTPAREN; SCANCODE_KP_RIGHTPAREN :: Scancode.KP_RIGHTPAREN
SCANCODE_KP_LEFTBRACE :: Scancode.KP_LEFTBRACE; SCANCODE_KP_LEFTBRACE :: Scancode.KP_LEFTBRACE
SCANCODE_KP_RIGHTBRACE :: Scancode.KP_RIGHTBRACE; SCANCODE_KP_RIGHTBRACE :: Scancode.KP_RIGHTBRACE
SCANCODE_KP_TAB :: Scancode.KP_TAB; SCANCODE_KP_TAB :: Scancode.KP_TAB
SCANCODE_KP_BACKSPACE :: Scancode.KP_BACKSPACE; SCANCODE_KP_BACKSPACE :: Scancode.KP_BACKSPACE
SCANCODE_KP_A :: Scancode.KP_A; SCANCODE_KP_A :: Scancode.KP_A
SCANCODE_KP_B :: Scancode.KP_B; SCANCODE_KP_B :: Scancode.KP_B
SCANCODE_KP_C :: Scancode.KP_C; SCANCODE_KP_C :: Scancode.KP_C
SCANCODE_KP_D :: Scancode.KP_D; SCANCODE_KP_D :: Scancode.KP_D
SCANCODE_KP_E :: Scancode.KP_E; SCANCODE_KP_E :: Scancode.KP_E
SCANCODE_KP_F :: Scancode.KP_F; SCANCODE_KP_F :: Scancode.KP_F
SCANCODE_KP_XOR :: Scancode.KP_XOR; SCANCODE_KP_XOR :: Scancode.KP_XOR
SCANCODE_KP_POWER :: Scancode.KP_POWER; SCANCODE_KP_POWER :: Scancode.KP_POWER
SCANCODE_KP_PERCENT :: Scancode.KP_PERCENT; SCANCODE_KP_PERCENT :: Scancode.KP_PERCENT
SCANCODE_KP_LESS :: Scancode.KP_LESS; SCANCODE_KP_LESS :: Scancode.KP_LESS
SCANCODE_KP_GREATER :: Scancode.KP_GREATER; SCANCODE_KP_GREATER :: Scancode.KP_GREATER
SCANCODE_KP_AMPERSAND :: Scancode.KP_AMPERSAND; SCANCODE_KP_AMPERSAND :: Scancode.KP_AMPERSAND
SCANCODE_KP_DBLAMPERSAND :: Scancode.KP_DBLAMPERSAND; SCANCODE_KP_DBLAMPERSAND :: Scancode.KP_DBLAMPERSAND
SCANCODE_KP_VERTICALBAR :: Scancode.KP_VERTICALBAR; SCANCODE_KP_VERTICALBAR :: Scancode.KP_VERTICALBAR
SCANCODE_KP_DBLVERTICALBAR :: Scancode.KP_DBLVERTICALBAR; SCANCODE_KP_DBLVERTICALBAR :: Scancode.KP_DBLVERTICALBAR
SCANCODE_KP_COLON :: Scancode.KP_COLON; SCANCODE_KP_COLON :: Scancode.KP_COLON
SCANCODE_KP_HASH :: Scancode.KP_HASH; SCANCODE_KP_HASH :: Scancode.KP_HASH
SCANCODE_KP_SPACE :: Scancode.KP_SPACE; SCANCODE_KP_SPACE :: Scancode.KP_SPACE
SCANCODE_KP_AT :: Scancode.KP_AT; SCANCODE_KP_AT :: Scancode.KP_AT
SCANCODE_KP_EXCLAM :: Scancode.KP_EXCLAM; SCANCODE_KP_EXCLAM :: Scancode.KP_EXCLAM
SCANCODE_KP_MEMSTORE :: Scancode.KP_MEMSTORE; SCANCODE_KP_MEMSTORE :: Scancode.KP_MEMSTORE
SCANCODE_KP_MEMRECALL :: Scancode.KP_MEMRECALL; SCANCODE_KP_MEMRECALL :: Scancode.KP_MEMRECALL
SCANCODE_KP_MEMCLEAR :: Scancode.KP_MEMCLEAR; SCANCODE_KP_MEMCLEAR :: Scancode.KP_MEMCLEAR
SCANCODE_KP_MEMADD :: Scancode.KP_MEMADD; SCANCODE_KP_MEMADD :: Scancode.KP_MEMADD
SCANCODE_KP_MEMSUBTRACT :: Scancode.KP_MEMSUBTRACT; SCANCODE_KP_MEMSUBTRACT :: Scancode.KP_MEMSUBTRACT
SCANCODE_KP_MEMMULTIPLY :: Scancode.KP_MEMMULTIPLY; SCANCODE_KP_MEMMULTIPLY :: Scancode.KP_MEMMULTIPLY
SCANCODE_KP_MEMDIVIDE :: Scancode.KP_MEMDIVIDE; SCANCODE_KP_MEMDIVIDE :: Scancode.KP_MEMDIVIDE
SCANCODE_KP_PLUSMINUS :: Scancode.KP_PLUSMINUS; SCANCODE_KP_PLUSMINUS :: Scancode.KP_PLUSMINUS
SCANCODE_KP_CLEAR :: Scancode.KP_CLEAR; SCANCODE_KP_CLEAR :: Scancode.KP_CLEAR
SCANCODE_KP_CLEARENTRY :: Scancode.KP_CLEARENTRY; SCANCODE_KP_CLEARENTRY :: Scancode.KP_CLEARENTRY
SCANCODE_KP_BINARY :: Scancode.KP_BINARY; SCANCODE_KP_BINARY :: Scancode.KP_BINARY
SCANCODE_KP_OCTAL :: Scancode.KP_OCTAL; SCANCODE_KP_OCTAL :: Scancode.KP_OCTAL
SCANCODE_KP_DECIMAL :: Scancode.KP_DECIMAL; SCANCODE_KP_DECIMAL :: Scancode.KP_DECIMAL
SCANCODE_KP_HEXADECIMAL :: Scancode.KP_HEXADECIMAL; SCANCODE_KP_HEXADECIMAL :: Scancode.KP_HEXADECIMAL
SCANCODE_LCTRL :: Scancode.LCTRL; SCANCODE_LCTRL :: Scancode.LCTRL
SCANCODE_LSHIFT :: Scancode.LSHIFT; SCANCODE_LSHIFT :: Scancode.LSHIFT
SCANCODE_LALT :: Scancode.LALT; SCANCODE_LALT :: Scancode.LALT
SCANCODE_LGUI :: Scancode.LGUI; SCANCODE_LGUI :: Scancode.LGUI
SCANCODE_RCTRL :: Scancode.RCTRL; SCANCODE_RCTRL :: Scancode.RCTRL
SCANCODE_RSHIFT :: Scancode.RSHIFT; SCANCODE_RSHIFT :: Scancode.RSHIFT
SCANCODE_RALT :: Scancode.RALT; SCANCODE_RALT :: Scancode.RALT
SCANCODE_RGUI :: Scancode.RGUI; SCANCODE_RGUI :: Scancode.RGUI
SCANCODE_MODE :: Scancode.MODE; SCANCODE_MODE :: Scancode.MODE
SCANCODE_AUDIONEXT :: Scancode.AUDIONEXT; SCANCODE_AUDIONEXT :: Scancode.AUDIONEXT
SCANCODE_AUDIOPREV :: Scancode.AUDIOPREV; SCANCODE_AUDIOPREV :: Scancode.AUDIOPREV
SCANCODE_AUDIOSTOP :: Scancode.AUDIOSTOP; SCANCODE_AUDIOSTOP :: Scancode.AUDIOSTOP
SCANCODE_AUDIOPLAY :: Scancode.AUDIOPLAY; SCANCODE_AUDIOPLAY :: Scancode.AUDIOPLAY
SCANCODE_AUDIOMUTE :: Scancode.AUDIOMUTE; SCANCODE_AUDIOMUTE :: Scancode.AUDIOMUTE
SCANCODE_MEDIASELECT :: Scancode.MEDIASELECT; SCANCODE_MEDIASELECT :: Scancode.MEDIASELECT
SCANCODE_WWW :: Scancode.WWW; SCANCODE_WWW :: Scancode.WWW
SCANCODE_MAIL :: Scancode.MAIL; SCANCODE_MAIL :: Scancode.MAIL
SCANCODE_CALCULATOR :: Scancode.CALCULATOR; SCANCODE_CALCULATOR :: Scancode.CALCULATOR
SCANCODE_COMPUTER :: Scancode.COMPUTER; SCANCODE_COMPUTER :: Scancode.COMPUTER
SCANCODE_AC_SEARCH :: Scancode.AC_SEARCH; SCANCODE_AC_SEARCH :: Scancode.AC_SEARCH
SCANCODE_AC_HOME :: Scancode.AC_HOME; SCANCODE_AC_HOME :: Scancode.AC_HOME
SCANCODE_AC_BACK :: Scancode.AC_BACK; SCANCODE_AC_BACK :: Scancode.AC_BACK
SCANCODE_AC_FORWARD :: Scancode.AC_FORWARD; SCANCODE_AC_FORWARD :: Scancode.AC_FORWARD
SCANCODE_AC_STOP :: Scancode.AC_STOP; SCANCODE_AC_STOP :: Scancode.AC_STOP
SCANCODE_AC_REFRESH :: Scancode.AC_REFRESH; SCANCODE_AC_REFRESH :: Scancode.AC_REFRESH
SCANCODE_AC_BOOKMARKS :: Scancode.AC_BOOKMARKS; SCANCODE_AC_BOOKMARKS :: Scancode.AC_BOOKMARKS
SCANCODE_BRIGHTNESSDOWN :: Scancode.BRIGHTNESSDOWN; SCANCODE_BRIGHTNESSDOWN :: Scancode.BRIGHTNESSDOWN
SCANCODE_BRIGHTNESSUP :: Scancode.BRIGHTNESSUP; SCANCODE_BRIGHTNESSUP :: Scancode.BRIGHTNESSUP
SCANCODE_DISPLAYSWITCH :: Scancode.DISPLAYSWITCH; SCANCODE_DISPLAYSWITCH :: Scancode.DISPLAYSWITCH
SCANCODE_KBDILLUMTOGGLE :: Scancode.KBDILLUMTOGGLE; SCANCODE_KBDILLUMTOGGLE :: Scancode.KBDILLUMTOGGLE
SCANCODE_KBDILLUMDOWN :: Scancode.KBDILLUMDOWN; SCANCODE_KBDILLUMDOWN :: Scancode.KBDILLUMDOWN
SCANCODE_KBDILLUMUP :: Scancode.KBDILLUMUP; SCANCODE_KBDILLUMUP :: Scancode.KBDILLUMUP
SCANCODE_EJECT :: Scancode.EJECT; SCANCODE_EJECT :: Scancode.EJECT
SCANCODE_SLEEP :: Scancode.SLEEP; SCANCODE_SLEEP :: Scancode.SLEEP
SCANCODE_APP1 :: Scancode.APP1; SCANCODE_APP1 :: Scancode.APP1
SCANCODE_APP2 :: Scancode.APP2; SCANCODE_APP2 :: Scancode.APP2
SCANCODE_AUDIOREWIND :: Scancode.AUDIOREWIND; SCANCODE_AUDIOREWIND :: Scancode.AUDIOREWIND
SCANCODE_AUDIOFASTFORWARD :: Scancode.AUDIOFASTFORWARD; SCANCODE_AUDIOFASTFORWARD :: Scancode.AUDIOFASTFORWARD;
vendor/sdl2/sdl_stdinc.odin
Vendored
+21 -21
View File
@@ -3,35 +3,35 @@ package sdl2
import "core:c" import "core:c"
import "core:intrinsics" import "core:intrinsics"
import "core:runtime" import "core:runtime"
_, _ :: intrinsics, runtime; _, _ :: intrinsics, runtime
when ODIN_OS == "windows" do foreign import lib "SDL2.lib" when ODIN_OS == "windows" do foreign import lib "SDL2.lib"
when ODIN_OS == "linux" do foreign import lib "system:SDL2" when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
bool :: distinct b32; bool :: distinct b32
#assert(size_of(bool) == size_of(c.int)); #assert(size_of(bool) == size_of(c.int));
FOURCC :: #force_inline proc "c" (A, B, C, D: u8) -> u32 { FOURCC :: #force_inline proc "c" (A, B, C, D: u8) -> u32 {
return u32(A) << 0 | u32(B) << 8 | u32(C) << 16 | u32(D) << 24; return u32(A) << 0 | u32(B) << 8 | u32(C) << 16 | u32(D) << 24
} }
stack_alloc :: proc "c" ($T: typeid, #any_int count: int) -> ^T { stack_alloc :: proc "c" ($T: typeid, #any_int count: int) -> ^T {
return (^T)(intrinsics.alloca(size_of(T)*count)); return (^T)(intrinsics.alloca(size_of(T)*count))
} }
stack_make :: proc "c" ($T: typeid/[]$E, #any_int count: int) -> T { stack_make :: proc "c" ($T: typeid/[]$E, #any_int count: int) -> T {
ptr := (^T)(intrinsics.alloca(size_of(T)*count)); ptr := (^T)(intrinsics.alloca(size_of(T)*count))
return transmute(T)runtime.Raw_Slice{ptr, count}; return transmute(T)runtime.Raw_Slice{ptr, count}
} }
stack_free :: proc "c" (ptr: rawptr) {} stack_free :: proc "c" (ptr: rawptr) {}
malloc_func :: proc "c" (size: c.size_t) -> rawptr; malloc_func :: proc "c" (size: c.size_t) -> rawptr
calloc_func :: proc "c" (nmemb, size: c.size_t) -> rawptr; calloc_func :: proc "c" (nmemb, size: c.size_t) -> rawptr
realloc_func :: proc "c" (mem: rawptr, size: c.size_t) -> rawptr; realloc_func :: proc "c" (mem: rawptr, size: c.size_t) -> rawptr
free_func :: proc "c" (mem: rawptr); free_func :: proc "c" (mem: rawptr)
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -81,7 +81,7 @@ foreign lib {
} }
M_PI :: 3.14159265358979323846264338327950288; M_PI :: 3.14159265358979323846264338327950288
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -130,13 +130,13 @@ foreign lib {
} }
/* The SDL implementation of iconv() returns these error codes */ /* The SDL implementation of iconv() returns these error codes */
ICONV_ERROR :: ~c.size_t(0); // (size_t)-1 ICONV_ERROR :: ~c.size_t(0) // (size_t)-1
ICONV_E2BIG :: ~c.size_t(1); // (size_t)-2 ICONV_E2BIG :: ~c.size_t(1) // (size_t)-2
ICONV_EILSEQ :: ~c.size_t(2); // (size_t)-3 ICONV_EILSEQ :: ~c.size_t(2) // (size_t)-3
ICONV_EINVAL :: ~c.size_t(3); // (size_t)-4 ICONV_EINVAL :: ~c.size_t(3) // (size_t)-4
/* SDL_iconv_* are now always real symbols/types, not macros or inlined. */ /* SDL_iconv_* are now always real symbols/types, not macros or inlined. */
iconv_t :: distinct rawptr; iconv_t :: distinct rawptr
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -147,17 +147,17 @@ foreign lib {
} }
iconv_utf8_locale :: proc "c" (s: string) -> cstring { iconv_utf8_locale :: proc "c" (s: string) -> cstring {
return cast(cstring)iconv_string("", "UTF-8", cstring(raw_data(s)), len(s)+1); return cast(cstring)iconv_string("", "UTF-8", cstring(raw_data(s)), len(s)+1)
} }
iconv_utf8_utf16 :: iconv_utf8_ucs2; iconv_utf8_utf16 :: iconv_utf8_ucs2
iconv_utf8_ucs2 :: proc "c" (s: string) -> [^]u16 { iconv_utf8_ucs2 :: proc "c" (s: string) -> [^]u16 {
return cast([^]u16)iconv_string("UCS-2-INTERNAL", "UTF-8", cstring(raw_data(s)), len(s)+1); return cast([^]u16)iconv_string("UCS-2-INTERNAL", "UTF-8", cstring(raw_data(s)), len(s)+1)
} }
#assert(size_of(rune) == size_of(c.int)); #assert(size_of(rune) == size_of(c.int));
iconv_utf8_utf32 :: iconv_utf8_ucs4; iconv_utf8_utf32 :: iconv_utf8_ucs4
iconv_utf8_ucs4 :: proc "c" (s: string) -> [^]rune { iconv_utf8_ucs4 :: proc "c" (s: string) -> [^]rune {
return cast([^]rune)iconv_string("UCS-4-INTERNAL", "UTF-8", cstring(raw_data(s)), len(s)+1); return cast([^]rune)iconv_string("UCS-4-INTERNAL", "UTF-8", cstring(raw_data(s)), len(s)+1)
} }
vendor/sdl2/sdl_surface.odin
Vendored
+12 -12
View File
@@ -7,17 +7,17 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
SWSURFACE :: 0; /**< Just here for compatibility */ SWSURFACE :: 0 /**< Just here for compatibility */
PREALLOC :: 0x00000001; /**< Surface uses preallocated memory */ PREALLOC :: 0x00000001 /**< Surface uses preallocated memory */
RLEACCEL :: 0x00000002; /**< Surface is RLE encoded */ RLEACCEL :: 0x00000002 /**< Surface is RLE encoded */
DONTFREE :: 0x00000004; /**< Surface is referenced internally */ DONTFREE :: 0x00000004 /**< Surface is referenced internally */
SIMD_ALIGNED :: 0x00000008; /**< Surface uses aligned memory */ SIMD_ALIGNED :: 0x00000008 /**< Surface uses aligned memory */
MUSTLOCK :: #force_inline proc "c" (surface: ^Surface) -> bool { MUSTLOCK :: #force_inline proc "c" (surface: ^Surface) -> bool {
return bool(surface.flags & RLEACCEL != 0); return bool(surface.flags & RLEACCEL != 0)
} }
BlitMap :: struct {}; BlitMap :: struct {}
Surface :: struct { Surface :: struct {
flags: u32, /**< Read-only */ flags: u32, /**< Read-only */
@@ -45,7 +45,7 @@ Surface :: struct {
refcount: c.int, /**< Read-mostly */ refcount: c.int, /**< Read-mostly */
} }
blit :: proc "c" (src: ^Surface, srcrect: ^Rect, dst: ^Surface, dstrect: ^Rect) -> c.int; blit :: proc "c" (src: ^Surface, srcrect: ^Rect, dst: ^Surface, dstrect: ^Rect) -> c.int
YUV_CONVERSION_MODE :: enum c.int { YUV_CONVERSION_MODE :: enum c.int {
@@ -57,15 +57,15 @@ YUV_CONVERSION_MODE :: enum c.int {
LoadBMP :: #force_inline proc "c" (file: cstring) -> ^Surface { LoadBMP :: #force_inline proc "c" (file: cstring) -> ^Surface {
return LoadBMP_RW(RWFromFile(file, "rb"), true); return LoadBMP_RW(RWFromFile(file, "rb"), true)
} }
SaveBMP :: #force_inline proc "c" (surface: ^Surface, file: cstring) -> c.int { SaveBMP :: #force_inline proc "c" (surface: ^Surface, file: cstring) -> c.int {
return SaveBMP_RW(surface, RWFromFile(file, "wb"), true); return SaveBMP_RW(surface, RWFromFile(file, "wb"), true)
} }
BlitSurface :: UpperBlit; BlitSurface :: UpperBlit
BlitScaled :: UpperBlitScaled; BlitScaled :: UpperBlitScaled
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
vendor/sdl2/sdl_system.odin
Vendored
+7 -7
View File
@@ -26,10 +26,10 @@ foreign lib {
// Windows & WinRT // Windows & WinRT
WindowsMessageHook :: proc "c" (userdata: rawptr, hWnd: rawptr, message: c.uint, wParam: u64, lParam: i64); WindowsMessageHook :: proc "c" (userdata: rawptr, hWnd: rawptr, message: c.uint, wParam: u64, lParam: i64)
IDirect3DDevice9 :: struct {}; IDirect3DDevice9 :: struct {}
ID3D11Device :: struct {}; ID3D11Device :: struct {}
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -91,8 +91,8 @@ foreign lib {
// iOS // iOS
iOSSetAnimationCallback :: iPhoneSetAnimationCallback; iOSSetAnimationCallback :: iPhoneSetAnimationCallback
iOSSetEventPump :: iPhoneSetEventPump; iOSSetEventPump :: iPhoneSetEventPump
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
@@ -104,8 +104,8 @@ foreign lib {
// Android // Android
ANDROID_EXTERNAL_STORAGE_READ :: 0x01; ANDROID_EXTERNAL_STORAGE_READ :: 0x01
ANDROID_EXTERNAL_STORAGE_WRITE :: 0x02; ANDROID_EXTERNAL_STORAGE_WRITE :: 0x02
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
vendor/sdl2/sdl_thread.odin
Vendored
+4 -4
View File
@@ -7,10 +7,10 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
Thread :: struct {}; Thread :: struct {}
threadID :: distinct c.ulong; threadID :: distinct c.ulong
TLSID :: distinct c.uint; TLSID :: distinct c.uint
ThreadPriority :: enum c.int { ThreadPriority :: enum c.int {
LOW, LOW,
@@ -19,7 +19,7 @@ ThreadPriority :: enum c.int {
TIME_CRITICAL, TIME_CRITICAL,
} }
ThreadFunction :: proc "c" (data: rawptr) -> c.int; ThreadFunction :: proc "c" (data: rawptr) -> c.int
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_timer.odin
Vendored
+3 -3
View File
@@ -7,11 +7,11 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
TimerCallback :: proc "c" (interval: u32, param: rawptr) -> u32; TimerCallback :: proc "c" (interval: u32, param: rawptr) -> u32
TimerID :: distinct c.int; TimerID :: distinct c.int
TICKS_PASSED :: #force_inline proc "c" (A, B: u32) -> bool { TICKS_PASSED :: #force_inline proc "c" (A, B: u32) -> bool {
return bool(i32(B) - i32(A) <= 0); return bool(i32(B) - i32(A) <= 0)
} }
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
vendor/sdl2/sdl_touch.odin
Vendored
+4 -4
View File
@@ -7,8 +7,8 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
TouchID :: distinct i64; TouchID :: distinct i64
FingerID :: distinct i64; FingerID :: distinct i64
TouchDeviceType :: enum c.int { TouchDeviceType :: enum c.int {
INVALID = -1, INVALID = -1,
@@ -24,8 +24,8 @@ Finger :: struct {
pressure: f32, pressure: f32,
} }
TOUCH_MOUSEID :: ~u32(0); TOUCH_MOUSEID :: ~u32(0)
MOUSE_TOUCH_ID :: TouchID(-1); MOUSE_TOUCH_ID :: TouchID(-1)
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/sdl_video.odin
Vendored
+35 -35
View File
@@ -15,7 +15,7 @@ DisplayMode :: struct {
driverdata: rawptr, /**< driver-specific data, initialize to 0 */ driverdata: rawptr, /**< driver-specific data, initialize to 0 */
} }
Window :: struct {}; Window :: struct {}
WindowFlag :: enum u32 { WindowFlag :: enum u32 {
FULLSCREEN = 0, /**< fullscreen window */ FULLSCREEN = 0, /**< fullscreen window */
@@ -46,47 +46,47 @@ WindowFlag :: enum u32 {
INPUT_GRABBED = MOUSE_GRABBED, /**< equivalent to SDL_WINDOW_MOUSE_GRABBED for compatibility */ INPUT_GRABBED = MOUSE_GRABBED, /**< equivalent to SDL_WINDOW_MOUSE_GRABBED for compatibility */
} }
WindowFlags :: distinct bit_set[WindowFlag; u32]; WindowFlags :: distinct bit_set[WindowFlag; u32]
WINDOW_FULLSCREEN :: WindowFlags{.FULLSCREEN}; WINDOW_FULLSCREEN :: WindowFlags{.FULLSCREEN}
WINDOW_OPENGL :: WindowFlags{.OPENGL}; WINDOW_OPENGL :: WindowFlags{.OPENGL}
WINDOW_SHOWN :: WindowFlags{.SHOWN}; WINDOW_SHOWN :: WindowFlags{.SHOWN}
WINDOW_HIDDEN :: WindowFlags{.HIDDEN}; WINDOW_HIDDEN :: WindowFlags{.HIDDEN}
WINDOW_BORDERLESS :: WindowFlags{.BORDERLESS}; WINDOW_BORDERLESS :: WindowFlags{.BORDERLESS}
WINDOW_RESIZABLE :: WindowFlags{.RESIZABLE}; WINDOW_RESIZABLE :: WindowFlags{.RESIZABLE}
WINDOW_MINIMIZED :: WindowFlags{.MINIMIZED}; WINDOW_MINIMIZED :: WindowFlags{.MINIMIZED}
WINDOW_MAXIMIZED :: WindowFlags{.MAXIMIZED}; WINDOW_MAXIMIZED :: WindowFlags{.MAXIMIZED}
WINDOW_MOUSE_GRABBED :: WindowFlags{.MOUSE_GRABBED}; WINDOW_MOUSE_GRABBED :: WindowFlags{.MOUSE_GRABBED}
WINDOW_INPUT_FOCUS :: WindowFlags{.INPUT_FOCUS}; WINDOW_INPUT_FOCUS :: WindowFlags{.INPUT_FOCUS}
WINDOW_MOUSE_FOCUS :: WindowFlags{.MOUSE_FOCUS}; WINDOW_MOUSE_FOCUS :: WindowFlags{.MOUSE_FOCUS}
WINDOW_FULLSCREEN_DESKTOP :: WindowFlags{.FULLSCREEN, ._INTERNAL_FULLSCREEN_DESKTOP}; WINDOW_FULLSCREEN_DESKTOP :: WindowFlags{.FULLSCREEN, ._INTERNAL_FULLSCREEN_DESKTOP}
WINDOW_FOREIGN :: WindowFlags{.FOREIGN}; WINDOW_FOREIGN :: WindowFlags{.FOREIGN}
WINDOW_ALLOW_HIGHDPI :: WindowFlags{.ALLOW_HIGHDPI}; WINDOW_ALLOW_HIGHDPI :: WindowFlags{.ALLOW_HIGHDPI}
WINDOW_MOUSE_CAPTURE :: WindowFlags{.MOUSE_CAPTURE}; WINDOW_MOUSE_CAPTURE :: WindowFlags{.MOUSE_CAPTURE}
WINDOW_ALWAYS_ON_TOP :: WindowFlags{.ALWAYS_ON_TOP}; WINDOW_ALWAYS_ON_TOP :: WindowFlags{.ALWAYS_ON_TOP}
WINDOW_SKIP_TASKBAR :: WindowFlags{.SKIP_TASKBAR}; WINDOW_SKIP_TASKBAR :: WindowFlags{.SKIP_TASKBAR}
WINDOW_UTILITY :: WindowFlags{.UTILITY}; WINDOW_UTILITY :: WindowFlags{.UTILITY}
WINDOW_TOOLTIP :: WindowFlags{.TOOLTIP}; WINDOW_TOOLTIP :: WindowFlags{.TOOLTIP}
WINDOW_POPUP_MENU :: WindowFlags{.POPUP_MENU}; WINDOW_POPUP_MENU :: WindowFlags{.POPUP_MENU}
WINDOW_KEYBOARD_GRABBED :: WindowFlags{.KEYBOARD_GRABBED}; WINDOW_KEYBOARD_GRABBED :: WindowFlags{.KEYBOARD_GRABBED}
WINDOW_VULKAN :: WindowFlags{.VULKAN}; WINDOW_VULKAN :: WindowFlags{.VULKAN}
WINDOW_METAL :: WindowFlags{.METAL}; WINDOW_METAL :: WindowFlags{.METAL}
WINDOW_INPUT_GRABBED :: WindowFlags{.INPUT_GRABBED}; WINDOW_INPUT_GRABBED :: WindowFlags{.INPUT_GRABBED}
WINDOWPOS_UNDEFINED_MASK :: 0x1FFF0000; WINDOWPOS_UNDEFINED_MASK :: 0x1FFF0000
WINDOWPOS_UNDEFINED_DISPLAY :: #force_inline proc "c" (X: c.int) -> c.int { return WINDOWPOS_UNDEFINED_MASK|X } WINDOWPOS_UNDEFINED_DISPLAY :: #force_inline proc "c" (X: c.int) -> c.int { return WINDOWPOS_UNDEFINED_MASK|X }
WINDOWPOS_UNDEFINED :: WINDOWPOS_UNDEFINED_MASK|0; WINDOWPOS_UNDEFINED :: WINDOWPOS_UNDEFINED_MASK|0
WINDOWPOS_ISUNDEFINED :: #force_inline proc "c" (X: c.int) -> bool { WINDOWPOS_ISUNDEFINED :: #force_inline proc "c" (X: c.int) -> bool {
return u32(X)&0xFFFF0000 == WINDOWPOS_UNDEFINED_MASK; return u32(X)&0xFFFF0000 == WINDOWPOS_UNDEFINED_MASK
} }
WINDOWPOS_CENTERED_MASK :: 0x2FFF0000; WINDOWPOS_CENTERED_MASK :: 0x2FFF0000
WINDOWPOS_CENTERED_DISPLAY :: #force_inline proc "c" (X: c.int) -> c.int { return WINDOWPOS_CENTERED_MASK|X } WINDOWPOS_CENTERED_DISPLAY :: #force_inline proc "c" (X: c.int) -> c.int { return WINDOWPOS_CENTERED_MASK|X }
WINDOWPOS_CENTERED :: WINDOWPOS_CENTERED_MASK|0; WINDOWPOS_CENTERED :: WINDOWPOS_CENTERED_MASK|0
WINDOWPOS_ISCENTERED :: #force_inline proc "c" (X: c.int) -> bool { WINDOWPOS_ISCENTERED :: #force_inline proc "c" (X: c.int) -> bool {
return u32(X)&0xFFFF0000 == WINDOWPOS_CENTERED_MASK; return u32(X)&0xFFFF0000 == WINDOWPOS_CENTERED_MASK
} }
@@ -136,7 +136,7 @@ FlashOperation :: enum c.int {
UNTIL_FOCUSED, /**< Flash the window until it gets focus */ UNTIL_FOCUSED, /**< Flash the window until it gets focus */
} }
GLContext :: distinct rawptr; GLContext :: distinct rawptr
GLattr :: enum c.int { GLattr :: enum c.int {
RED_SIZE, RED_SIZE,
@@ -205,7 +205,7 @@ HitTestResult :: enum c.int {
RESIZE_LEFT, RESIZE_LEFT,
} }
HitTest :: proc "c" (win: ^Window, area: ^Point, data: rawptr) -> HitTestResult; HitTest :: proc "c" (win: ^Window, area: ^Point, data: rawptr) -> HitTestResult
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
@@ -309,5 +309,5 @@ foreign lib {
// Used by vendor:OpenGL // Used by vendor:OpenGL
gl_set_proc_address :: proc(p: rawptr, name: cstring) { gl_set_proc_address :: proc(p: rawptr, name: cstring) {
(^rawptr)(p)^ = GL_GetProcAddress(name); (^rawptr)(p)^ = GL_GetProcAddress(name)
} }
vendor/sdl2/sdl_vulkan.odin
Vendored
+4 -4
View File
@@ -7,11 +7,11 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2" when ODIN_OS == "darwin" do foreign import lib "system:SDL2"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2"
VkInstance :: distinct u64; VkInstance :: distinct u64
VkSurfaceKHR :: distinct u64; VkSurfaceKHR :: distinct u64
vulkanInstance :: VkInstance; vulkanInstance :: VkInstance
vulkanSurface :: VkSurfaceKHR; vulkanSurface :: VkSurfaceKHR
@(default_calling_convention="c", link_prefix="SDL_") @(default_calling_convention="c", link_prefix="SDL_")
foreign lib { foreign lib {
vendor/sdl2/ttf/sdl_ttf.odin
Vendored
+23 -23
View File
@@ -8,18 +8,18 @@ when ODIN_OS == "linux" do foreign import lib "system:SDL2_ttf"
when ODIN_OS == "darwin" do foreign import lib "system:SDL2_ttf" when ODIN_OS == "darwin" do foreign import lib "system:SDL2_ttf"
when ODIN_OS == "freebsd" do foreign import lib "system:SDL2_ttf" when ODIN_OS == "freebsd" do foreign import lib "system:SDL2_ttf"
bool :: SDL.bool; bool :: SDL.bool
#assert(size_of(rune) == size_of(u32)); #assert(size_of(rune) == size_of(u32));
MAJOR_VERSION :: 2; MAJOR_VERSION :: 2
MINOR_VERSION :: 0; MINOR_VERSION :: 0
PATCHLEVEL :: 15; PATCHLEVEL :: 15
UNICODE_BOM_NATIVE :: 0xFEFF; UNICODE_BOM_NATIVE :: 0xFEFF
UNICODE_BOM_SWAPPED :: 0xFFFE; UNICODE_BOM_SWAPPED :: 0xFFFE
Font :: struct {}; Font :: struct {}
StyleFlag :: enum c.int { StyleFlag :: enum c.int {
BOLD = 0, BOLD = 0,
@@ -28,13 +28,13 @@ StyleFlag :: enum c.int {
STRIKETHROUGH = 3, STRIKETHROUGH = 3,
} }
Style :: distinct bit_set[StyleFlag; c.int]; Style :: distinct bit_set[StyleFlag; c.int]
STYLE_NORMAL :: Style{}; STYLE_NORMAL :: Style{}
STYLE_BOLD :: Style{.BOLD}; STYLE_BOLD :: Style{.BOLD}
STYLE_ITALIC :: Style{.ITALIC}; STYLE_ITALIC :: Style{.ITALIC}
STYLE_UNDERLINE :: Style{.UNDERLINE}; STYLE_UNDERLINE :: Style{.UNDERLINE}
STYLE_STRIKETHROUGH :: Style{.STRIKETHROUGH}; STYLE_STRIKETHROUGH :: Style{.STRIKETHROUGH}
Hinting :: enum c.int { Hinting :: enum c.int {
NORMAL = 0, NORMAL = 0,
@@ -44,25 +44,25 @@ Hinting :: enum c.int {
LIGHT_SUBPIXEL = 4, LIGHT_SUBPIXEL = 4,
} }
HINTING_NORMAL :: Hinting.NORMAL; HINTING_NORMAL :: Hinting.NORMAL
HINTING_LIGHT :: Hinting.LIGHT; HINTING_LIGHT :: Hinting.LIGHT
HINTING_MONO :: Hinting.MONO; HINTING_MONO :: Hinting.MONO
HINTING_NONE :: Hinting.NONE; HINTING_NONE :: Hinting.NONE
HINTING_LIGHT_SUBPIXEL :: Hinting.LIGHT_SUBPIXEL; HINTING_LIGHT_SUBPIXEL :: Hinting.LIGHT_SUBPIXEL
/* We'll use SDL for reporting errors */ /* We'll use SDL for reporting errors */
SetError :: SDL.SetError; SetError :: SDL.SetError
GetError :: SDL.GetError; GetError :: SDL.GetError
/* For compatibility with previous versions, here are the old functions */ /* For compatibility with previous versions, here are the old functions */
RenderText :: #force_inline proc "c" (font: ^Font, text: cstring, fg, bg: SDL.Color) -> ^SDL.Surface { RenderText :: #force_inline proc "c" (font: ^Font, text: cstring, fg, bg: SDL.Color) -> ^SDL.Surface {
return RenderText_Shaded(font, text, fg, bg); return RenderText_Shaded(font, text, fg, bg)
} }
RenderUTF8 :: #force_inline proc "c" (font: ^Font, text: cstring, fg, bg: SDL.Color) -> ^SDL.Surface { RenderUTF8 :: #force_inline proc "c" (font: ^Font, text: cstring, fg, bg: SDL.Color) -> ^SDL.Surface {
return RenderUTF8_Shaded(font, text, fg, bg); return RenderUTF8_Shaded(font, text, fg, bg)
} }
RenderUNICODE :: #force_inline proc "c" (font: ^Font, text: [^]u16, fg, bg: SDL.Color) -> ^SDL.Surface { RenderUNICODE :: #force_inline proc "c" (font: ^Font, text: [^]u16, fg, bg: SDL.Color) -> ^SDL.Surface {
return RenderUNICODE_Shaded(font, text, fg, bg); return RenderUNICODE_Shaded(font, text, fg, bg)
} }
@(default_calling_convention="c", link_prefix="TTF_") @(default_calling_convention="c", link_prefix="TTF_")
vendor/vulkan/core.odin
Vendored
+744 -744
View File
File diff suppressed because it is too large Load Diff
vendor/vulkan/enums.odin
Vendored
+170 -170
View File
@@ -1471,7 +1471,7 @@ SubpassContents :: enum c.int {
SECONDARY_COMMAND_BUFFERS = 1, SECONDARY_COMMAND_BUFFERS = 1,
} }
AccessFlags :: distinct bit_set[AccessFlag; Flags]; AccessFlags :: distinct bit_set[AccessFlag; Flags]
AccessFlag :: enum Flags { AccessFlag :: enum Flags {
INDIRECT_COMMAND_READ = 0, INDIRECT_COMMAND_READ = 0,
INDEX_READ = 1, INDEX_READ = 1,
@@ -1506,10 +1506,10 @@ AccessFlag :: enum Flags {
ACCELERATION_STRUCTURE_WRITE_NV = ACCELERATION_STRUCTURE_WRITE_KHR, ACCELERATION_STRUCTURE_WRITE_NV = ACCELERATION_STRUCTURE_WRITE_KHR,
} }
AccessFlags_NONE_KHR :: AccessFlags{}; AccessFlags_NONE_KHR :: AccessFlags{}
ImageAspectFlags :: distinct bit_set[ImageAspectFlag; Flags]; ImageAspectFlags :: distinct bit_set[ImageAspectFlag; Flags]
ImageAspectFlag :: enum Flags { ImageAspectFlag :: enum Flags {
COLOR = 0, COLOR = 0,
DEPTH = 1, DEPTH = 1,
@@ -1527,7 +1527,7 @@ ImageAspectFlag :: enum Flags {
PLANE_2_KHR = PLANE_2, PLANE_2_KHR = PLANE_2,
} }
FormatFeatureFlags :: distinct bit_set[FormatFeatureFlag; Flags]; FormatFeatureFlags :: distinct bit_set[FormatFeatureFlag; Flags]
FormatFeatureFlag :: enum Flags { FormatFeatureFlag :: enum Flags {
SAMPLED_IMAGE = 0, SAMPLED_IMAGE = 0,
STORAGE_IMAGE = 1, STORAGE_IMAGE = 1,
@@ -1573,7 +1573,7 @@ FormatFeatureFlag :: enum Flags {
SAMPLED_IMAGE_FILTER_CUBIC_EXT = SAMPLED_IMAGE_FILTER_CUBIC_IMG, SAMPLED_IMAGE_FILTER_CUBIC_EXT = SAMPLED_IMAGE_FILTER_CUBIC_IMG,
} }
ImageCreateFlags :: distinct bit_set[ImageCreateFlag; Flags]; ImageCreateFlags :: distinct bit_set[ImageCreateFlag; Flags]
ImageCreateFlag :: enum Flags { ImageCreateFlag :: enum Flags {
SPARSE_BINDING = 0, SPARSE_BINDING = 0,
SPARSE_RESIDENCY = 1, SPARSE_RESIDENCY = 1,
@@ -1598,7 +1598,7 @@ ImageCreateFlag :: enum Flags {
ALIAS_KHR = ALIAS, ALIAS_KHR = ALIAS,
} }
SampleCountFlags :: distinct bit_set[SampleCountFlag; Flags]; SampleCountFlags :: distinct bit_set[SampleCountFlag; Flags]
SampleCountFlag :: enum Flags { SampleCountFlag :: enum Flags {
_1 = 0, _1 = 0,
_2 = 1, _2 = 1,
@@ -1609,7 +1609,7 @@ SampleCountFlag :: enum Flags {
_64 = 6, _64 = 6,
} }
ImageUsageFlags :: distinct bit_set[ImageUsageFlag; Flags]; ImageUsageFlags :: distinct bit_set[ImageUsageFlag; Flags]
ImageUsageFlag :: enum Flags { ImageUsageFlag :: enum Flags {
TRANSFER_SRC = 0, TRANSFER_SRC = 0,
TRANSFER_DST = 1, TRANSFER_DST = 1,
@@ -1631,14 +1631,14 @@ ImageUsageFlag :: enum Flags {
SHADING_RATE_IMAGE_NV = FRAGMENT_SHADING_RATE_ATTACHMENT_KHR, SHADING_RATE_IMAGE_NV = FRAGMENT_SHADING_RATE_ATTACHMENT_KHR,
} }
MemoryHeapFlags :: distinct bit_set[MemoryHeapFlag; Flags]; MemoryHeapFlags :: distinct bit_set[MemoryHeapFlag; Flags]
MemoryHeapFlag :: enum Flags { MemoryHeapFlag :: enum Flags {
DEVICE_LOCAL = 0, DEVICE_LOCAL = 0,
MULTI_INSTANCE = 1, MULTI_INSTANCE = 1,
MULTI_INSTANCE_KHR = MULTI_INSTANCE, MULTI_INSTANCE_KHR = MULTI_INSTANCE,
} }
MemoryPropertyFlags :: distinct bit_set[MemoryPropertyFlag; Flags]; MemoryPropertyFlags :: distinct bit_set[MemoryPropertyFlag; Flags]
MemoryPropertyFlag :: enum Flags { MemoryPropertyFlag :: enum Flags {
DEVICE_LOCAL = 0, DEVICE_LOCAL = 0,
HOST_VISIBLE = 1, HOST_VISIBLE = 1,
@@ -1651,7 +1651,7 @@ MemoryPropertyFlag :: enum Flags {
RDMA_CAPABLE_NV = 8, RDMA_CAPABLE_NV = 8,
} }
QueueFlags :: distinct bit_set[QueueFlag; Flags]; QueueFlags :: distinct bit_set[QueueFlag; Flags]
QueueFlag :: enum Flags { QueueFlag :: enum Flags {
GRAPHICS = 0, GRAPHICS = 0,
COMPUTE = 1, COMPUTE = 1,
@@ -1662,12 +1662,12 @@ QueueFlag :: enum Flags {
VIDEO_ENCODE_KHR = 6, VIDEO_ENCODE_KHR = 6,
} }
DeviceQueueCreateFlags :: distinct bit_set[DeviceQueueCreateFlag; Flags]; DeviceQueueCreateFlags :: distinct bit_set[DeviceQueueCreateFlag; Flags]
DeviceQueueCreateFlag :: enum Flags { DeviceQueueCreateFlag :: enum Flags {
PROTECTED = 0, PROTECTED = 0,
} }
PipelineStageFlags :: distinct bit_set[PipelineStageFlag; Flags]; PipelineStageFlags :: distinct bit_set[PipelineStageFlag; Flags]
PipelineStageFlag :: enum Flags { PipelineStageFlag :: enum Flags {
TOP_OF_PIPE = 0, TOP_OF_PIPE = 0,
DRAW_INDIRECT = 1, DRAW_INDIRECT = 1,
@@ -1700,32 +1700,32 @@ PipelineStageFlag :: enum Flags {
ACCELERATION_STRUCTURE_BUILD_NV = ACCELERATION_STRUCTURE_BUILD_KHR, ACCELERATION_STRUCTURE_BUILD_NV = ACCELERATION_STRUCTURE_BUILD_KHR,
} }
PipelineStageFlags_NONE_KHR :: PipelineStageFlags{}; PipelineStageFlags_NONE_KHR :: PipelineStageFlags{}
SparseMemoryBindFlags :: distinct bit_set[SparseMemoryBindFlag; Flags]; SparseMemoryBindFlags :: distinct bit_set[SparseMemoryBindFlag; Flags]
SparseMemoryBindFlag :: enum Flags { SparseMemoryBindFlag :: enum Flags {
METADATA = 0, METADATA = 0,
} }
SparseImageFormatFlags :: distinct bit_set[SparseImageFormatFlag; Flags]; SparseImageFormatFlags :: distinct bit_set[SparseImageFormatFlag; Flags]
SparseImageFormatFlag :: enum Flags { SparseImageFormatFlag :: enum Flags {
SINGLE_MIPTAIL = 0, SINGLE_MIPTAIL = 0,
ALIGNED_MIP_SIZE = 1, ALIGNED_MIP_SIZE = 1,
NONSTANDARD_BLOCK_SIZE = 2, NONSTANDARD_BLOCK_SIZE = 2,
} }
FenceCreateFlags :: distinct bit_set[FenceCreateFlag; Flags]; FenceCreateFlags :: distinct bit_set[FenceCreateFlag; Flags]
FenceCreateFlag :: enum Flags { FenceCreateFlag :: enum Flags {
SIGNALED = 0, SIGNALED = 0,
} }
EventCreateFlags :: distinct bit_set[EventCreateFlag; Flags]; EventCreateFlags :: distinct bit_set[EventCreateFlag; Flags]
EventCreateFlag :: enum Flags { EventCreateFlag :: enum Flags {
DEVICE_ONLY_KHR = 0, DEVICE_ONLY_KHR = 0,
} }
QueryPipelineStatisticFlags :: distinct bit_set[QueryPipelineStatisticFlag; Flags]; QueryPipelineStatisticFlags :: distinct bit_set[QueryPipelineStatisticFlag; Flags]
QueryPipelineStatisticFlag :: enum Flags { QueryPipelineStatisticFlag :: enum Flags {
INPUT_ASSEMBLY_VERTICES = 0, INPUT_ASSEMBLY_VERTICES = 0,
INPUT_ASSEMBLY_PRIMITIVES = 1, INPUT_ASSEMBLY_PRIMITIVES = 1,
@@ -1740,7 +1740,7 @@ QueryPipelineStatisticFlag :: enum Flags {
COMPUTE_SHADER_INVOCATIONS = 10, COMPUTE_SHADER_INVOCATIONS = 10,
} }
QueryResultFlags :: distinct bit_set[QueryResultFlag; Flags]; QueryResultFlags :: distinct bit_set[QueryResultFlag; Flags]
QueryResultFlag :: enum Flags { QueryResultFlag :: enum Flags {
_64 = 0, _64 = 0,
WAIT = 1, WAIT = 1,
@@ -1749,7 +1749,7 @@ QueryResultFlag :: enum Flags {
WITH_STATUS_KHR = 4, WITH_STATUS_KHR = 4,
} }
BufferCreateFlags :: distinct bit_set[BufferCreateFlag; Flags]; BufferCreateFlags :: distinct bit_set[BufferCreateFlag; Flags]
BufferCreateFlag :: enum Flags { BufferCreateFlag :: enum Flags {
SPARSE_BINDING = 0, SPARSE_BINDING = 0,
SPARSE_RESIDENCY = 1, SPARSE_RESIDENCY = 1,
@@ -1760,7 +1760,7 @@ BufferCreateFlag :: enum Flags {
DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = DEVICE_ADDRESS_CAPTURE_REPLAY, DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = DEVICE_ADDRESS_CAPTURE_REPLAY,
} }
BufferUsageFlags :: distinct bit_set[BufferUsageFlag; Flags]; BufferUsageFlags :: distinct bit_set[BufferUsageFlag; Flags]
BufferUsageFlag :: enum Flags { BufferUsageFlag :: enum Flags {
TRANSFER_SRC = 0, TRANSFER_SRC = 0,
TRANSFER_DST = 1, TRANSFER_DST = 1,
@@ -1787,22 +1787,22 @@ BufferUsageFlag :: enum Flags {
SHADER_DEVICE_ADDRESS_KHR = SHADER_DEVICE_ADDRESS, SHADER_DEVICE_ADDRESS_KHR = SHADER_DEVICE_ADDRESS,
} }
ImageViewCreateFlags :: distinct bit_set[ImageViewCreateFlag; Flags]; ImageViewCreateFlags :: distinct bit_set[ImageViewCreateFlag; Flags]
ImageViewCreateFlag :: enum Flags { ImageViewCreateFlag :: enum Flags {
FRAGMENT_DENSITY_MAP_DYNAMIC_EXT = 0, FRAGMENT_DENSITY_MAP_DYNAMIC_EXT = 0,
FRAGMENT_DENSITY_MAP_DEFERRED_EXT = 1, FRAGMENT_DENSITY_MAP_DEFERRED_EXT = 1,
} }
ShaderModuleCreateFlags :: distinct bit_set[ShaderModuleCreateFlag; Flags]; ShaderModuleCreateFlags :: distinct bit_set[ShaderModuleCreateFlag; Flags]
ShaderModuleCreateFlag :: enum Flags { ShaderModuleCreateFlag :: enum Flags {
} }
PipelineCacheCreateFlags :: distinct bit_set[PipelineCacheCreateFlag; Flags]; PipelineCacheCreateFlags :: distinct bit_set[PipelineCacheCreateFlag; Flags]
PipelineCacheCreateFlag :: enum Flags { PipelineCacheCreateFlag :: enum Flags {
EXTERNALLY_SYNCHRONIZED_EXT = 0, EXTERNALLY_SYNCHRONIZED_EXT = 0,
} }
ColorComponentFlags :: distinct bit_set[ColorComponentFlag; Flags]; ColorComponentFlags :: distinct bit_set[ColorComponentFlag; Flags]
ColorComponentFlag :: enum Flags { ColorComponentFlag :: enum Flags {
R = 0, R = 0,
G = 1, G = 1,
@@ -1810,7 +1810,7 @@ ColorComponentFlag :: enum Flags {
A = 3, A = 3,
} }
PipelineCreateFlags :: distinct bit_set[PipelineCreateFlag; Flags]; PipelineCreateFlags :: distinct bit_set[PipelineCreateFlag; Flags]
PipelineCreateFlag :: enum Flags { PipelineCreateFlag :: enum Flags {
DISABLE_OPTIMIZATION = 0, DISABLE_OPTIMIZATION = 0,
ALLOW_DERIVATIVES = 1, ALLOW_DERIVATIVES = 1,
@@ -1836,13 +1836,13 @@ PipelineCreateFlag :: enum Flags {
DISPATCH_BASE_KHR = DISPATCH_BASE, DISPATCH_BASE_KHR = DISPATCH_BASE,
} }
PipelineShaderStageCreateFlags :: distinct bit_set[PipelineShaderStageCreateFlag; Flags]; PipelineShaderStageCreateFlags :: distinct bit_set[PipelineShaderStageCreateFlag; Flags]
PipelineShaderStageCreateFlag :: enum Flags { PipelineShaderStageCreateFlag :: enum Flags {
ALLOW_VARYING_SUBGROUP_SIZE_EXT = 0, ALLOW_VARYING_SUBGROUP_SIZE_EXT = 0,
REQUIRE_FULL_SUBGROUPS_EXT = 1, REQUIRE_FULL_SUBGROUPS_EXT = 1,
} }
ShaderStageFlags :: distinct bit_set[ShaderStageFlag; Flags]; ShaderStageFlags :: distinct bit_set[ShaderStageFlag; Flags]
ShaderStageFlag :: enum Flags { ShaderStageFlag :: enum Flags {
VERTEX = 0, VERTEX = 0,
TESSELLATION_CONTROL = 1, TESSELLATION_CONTROL = 1,
@@ -1868,27 +1868,27 @@ ShaderStageFlag :: enum Flags {
_MAX = 31, // Needed for the *_ALL bit set _MAX = 31, // Needed for the *_ALL bit set
} }
ShaderStageFlags_ALL_GRAPHICS :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT}; ShaderStageFlags_ALL_GRAPHICS :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT}
ShaderStageFlags_ALL :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT, .COMPUTE, .TASK_NV, .MESH_NV, .RAYGEN_KHR, .ANY_HIT_KHR, .CLOSEST_HIT_KHR, .MISS_KHR, .INTERSECTION_KHR, .CALLABLE_KHR, .SUBPASS_SHADING_HUAWEI, ShaderStageFlag(15), ShaderStageFlag(16), ShaderStageFlag(17), ShaderStageFlag(18), ShaderStageFlag(19), ShaderStageFlag(20), ShaderStageFlag(21), ShaderStageFlag(22), ShaderStageFlag(23), ShaderStageFlag(24), ShaderStageFlag(25), ShaderStageFlag(26), ShaderStageFlag(27), ShaderStageFlag(28), ShaderStageFlag(29), ShaderStageFlag(30)}; ShaderStageFlags_ALL :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT, .COMPUTE, .TASK_NV, .MESH_NV, .RAYGEN_KHR, .ANY_HIT_KHR, .CLOSEST_HIT_KHR, .MISS_KHR, .INTERSECTION_KHR, .CALLABLE_KHR, .SUBPASS_SHADING_HUAWEI, ShaderStageFlag(15), ShaderStageFlag(16), ShaderStageFlag(17), ShaderStageFlag(18), ShaderStageFlag(19), ShaderStageFlag(20), ShaderStageFlag(21), ShaderStageFlag(22), ShaderStageFlag(23), ShaderStageFlag(24), ShaderStageFlag(25), ShaderStageFlag(26), ShaderStageFlag(27), ShaderStageFlag(28), ShaderStageFlag(29), ShaderStageFlag(30)}
CullModeFlags :: distinct bit_set[CullModeFlag; Flags]; CullModeFlags :: distinct bit_set[CullModeFlag; Flags]
CullModeFlag :: enum Flags { CullModeFlag :: enum Flags {
FRONT = 0, FRONT = 0,
BACK = 1, BACK = 1,
} }
CullModeFlags_NONE :: CullModeFlags{}; CullModeFlags_NONE :: CullModeFlags{}
CullModeFlags_FRONT_AND_BACK :: CullModeFlags{.FRONT, .BACK}; CullModeFlags_FRONT_AND_BACK :: CullModeFlags{.FRONT, .BACK}
SamplerCreateFlags :: distinct bit_set[SamplerCreateFlag; Flags]; SamplerCreateFlags :: distinct bit_set[SamplerCreateFlag; Flags]
SamplerCreateFlag :: enum Flags { SamplerCreateFlag :: enum Flags {
SUBSAMPLED_EXT = 0, SUBSAMPLED_EXT = 0,
SUBSAMPLED_COARSE_RECONSTRUCTION_EXT = 1, SUBSAMPLED_COARSE_RECONSTRUCTION_EXT = 1,
} }
DescriptorPoolCreateFlags :: distinct bit_set[DescriptorPoolCreateFlag; Flags]; DescriptorPoolCreateFlags :: distinct bit_set[DescriptorPoolCreateFlag; Flags]
DescriptorPoolCreateFlag :: enum Flags { DescriptorPoolCreateFlag :: enum Flags {
FREE_DESCRIPTOR_SET = 0, FREE_DESCRIPTOR_SET = 0,
UPDATE_AFTER_BIND = 1, UPDATE_AFTER_BIND = 1,
@@ -1896,7 +1896,7 @@ DescriptorPoolCreateFlag :: enum Flags {
UPDATE_AFTER_BIND_EXT = UPDATE_AFTER_BIND, UPDATE_AFTER_BIND_EXT = UPDATE_AFTER_BIND,
} }
DescriptorSetLayoutCreateFlags :: distinct bit_set[DescriptorSetLayoutCreateFlag; Flags]; DescriptorSetLayoutCreateFlags :: distinct bit_set[DescriptorSetLayoutCreateFlag; Flags]
DescriptorSetLayoutCreateFlag :: enum Flags { DescriptorSetLayoutCreateFlag :: enum Flags {
UPDATE_AFTER_BIND_POOL = 1, UPDATE_AFTER_BIND_POOL = 1,
PUSH_DESCRIPTOR_KHR = 0, PUSH_DESCRIPTOR_KHR = 0,
@@ -1904,12 +1904,12 @@ DescriptorSetLayoutCreateFlag :: enum Flags {
UPDATE_AFTER_BIND_POOL_EXT = UPDATE_AFTER_BIND_POOL, UPDATE_AFTER_BIND_POOL_EXT = UPDATE_AFTER_BIND_POOL,
} }
AttachmentDescriptionFlags :: distinct bit_set[AttachmentDescriptionFlag; Flags]; AttachmentDescriptionFlags :: distinct bit_set[AttachmentDescriptionFlag; Flags]
AttachmentDescriptionFlag :: enum Flags { AttachmentDescriptionFlag :: enum Flags {
MAY_ALIAS = 0, MAY_ALIAS = 0,
} }
DependencyFlags :: distinct bit_set[DependencyFlag; Flags]; DependencyFlags :: distinct bit_set[DependencyFlag; Flags]
DependencyFlag :: enum Flags { DependencyFlag :: enum Flags {
BY_REGION = 0, BY_REGION = 0,
DEVICE_GROUP = 2, DEVICE_GROUP = 2,
@@ -1918,18 +1918,18 @@ DependencyFlag :: enum Flags {
DEVICE_GROUP_KHR = DEVICE_GROUP, DEVICE_GROUP_KHR = DEVICE_GROUP,
} }
FramebufferCreateFlags :: distinct bit_set[FramebufferCreateFlag; Flags]; FramebufferCreateFlags :: distinct bit_set[FramebufferCreateFlag; Flags]
FramebufferCreateFlag :: enum Flags { FramebufferCreateFlag :: enum Flags {
IMAGELESS = 0, IMAGELESS = 0,
IMAGELESS_KHR = IMAGELESS, IMAGELESS_KHR = IMAGELESS,
} }
RenderPassCreateFlags :: distinct bit_set[RenderPassCreateFlag; Flags]; RenderPassCreateFlags :: distinct bit_set[RenderPassCreateFlag; Flags]
RenderPassCreateFlag :: enum Flags { RenderPassCreateFlag :: enum Flags {
TRANSFORM_QCOM = 1, TRANSFORM_QCOM = 1,
} }
SubpassDescriptionFlags :: distinct bit_set[SubpassDescriptionFlag; Flags]; SubpassDescriptionFlags :: distinct bit_set[SubpassDescriptionFlag; Flags]
SubpassDescriptionFlag :: enum Flags { SubpassDescriptionFlag :: enum Flags {
PER_VIEW_ATTRIBUTES_NVX = 0, PER_VIEW_ATTRIBUTES_NVX = 0,
PER_VIEW_POSITION_X_ONLY_NVX = 1, PER_VIEW_POSITION_X_ONLY_NVX = 1,
@@ -1937,42 +1937,42 @@ SubpassDescriptionFlag :: enum Flags {
SHADER_RESOLVE_QCOM = 3, SHADER_RESOLVE_QCOM = 3,
} }
CommandPoolCreateFlags :: distinct bit_set[CommandPoolCreateFlag; Flags]; CommandPoolCreateFlags :: distinct bit_set[CommandPoolCreateFlag; Flags]
CommandPoolCreateFlag :: enum Flags { CommandPoolCreateFlag :: enum Flags {
TRANSIENT = 0, TRANSIENT = 0,
RESET_COMMAND_BUFFER = 1, RESET_COMMAND_BUFFER = 1,
PROTECTED = 2, PROTECTED = 2,
} }
CommandPoolResetFlags :: distinct bit_set[CommandPoolResetFlag; Flags]; CommandPoolResetFlags :: distinct bit_set[CommandPoolResetFlag; Flags]
CommandPoolResetFlag :: enum Flags { CommandPoolResetFlag :: enum Flags {
RELEASE_RESOURCES = 0, RELEASE_RESOURCES = 0,
} }
CommandBufferUsageFlags :: distinct bit_set[CommandBufferUsageFlag; Flags]; CommandBufferUsageFlags :: distinct bit_set[CommandBufferUsageFlag; Flags]
CommandBufferUsageFlag :: enum Flags { CommandBufferUsageFlag :: enum Flags {
ONE_TIME_SUBMIT = 0, ONE_TIME_SUBMIT = 0,
RENDER_PASS_CONTINUE = 1, RENDER_PASS_CONTINUE = 1,
SIMULTANEOUS_USE = 2, SIMULTANEOUS_USE = 2,
} }
QueryControlFlags :: distinct bit_set[QueryControlFlag; Flags]; QueryControlFlags :: distinct bit_set[QueryControlFlag; Flags]
QueryControlFlag :: enum Flags { QueryControlFlag :: enum Flags {
PRECISE = 0, PRECISE = 0,
} }
CommandBufferResetFlags :: distinct bit_set[CommandBufferResetFlag; Flags]; CommandBufferResetFlags :: distinct bit_set[CommandBufferResetFlag; Flags]
CommandBufferResetFlag :: enum Flags { CommandBufferResetFlag :: enum Flags {
RELEASE_RESOURCES = 0, RELEASE_RESOURCES = 0,
} }
StencilFaceFlags :: distinct bit_set[StencilFaceFlag; Flags]; StencilFaceFlags :: distinct bit_set[StencilFaceFlag; Flags]
StencilFaceFlag :: enum Flags { StencilFaceFlag :: enum Flags {
FRONT = 0, FRONT = 0,
BACK = 1, BACK = 1,
} }
StencilFaceFlags_FRONT_AND_BACK :: StencilFaceFlags{.FRONT, .BACK}; StencilFaceFlags_FRONT_AND_BACK :: StencilFaceFlags{.FRONT, .BACK}
PointClippingBehavior :: enum c.int { PointClippingBehavior :: enum c.int {
@@ -2022,7 +2022,7 @@ DescriptorUpdateTemplateType :: enum c.int {
DESCRIPTOR_SET_KHR = DESCRIPTOR_SET, DESCRIPTOR_SET_KHR = DESCRIPTOR_SET,
} }
SubgroupFeatureFlags :: distinct bit_set[SubgroupFeatureFlag; Flags]; SubgroupFeatureFlags :: distinct bit_set[SubgroupFeatureFlag; Flags]
SubgroupFeatureFlag :: enum Flags { SubgroupFeatureFlag :: enum Flags {
BASIC = 0, BASIC = 0,
VOTE = 1, VOTE = 1,
@@ -2035,7 +2035,7 @@ SubgroupFeatureFlag :: enum Flags {
PARTITIONED_NV = 8, PARTITIONED_NV = 8,
} }
PeerMemoryFeatureFlags :: distinct bit_set[PeerMemoryFeatureFlag; Flags]; PeerMemoryFeatureFlags :: distinct bit_set[PeerMemoryFeatureFlag; Flags]
PeerMemoryFeatureFlag :: enum Flags { PeerMemoryFeatureFlag :: enum Flags {
COPY_SRC = 0, COPY_SRC = 0,
COPY_DST = 1, COPY_DST = 1,
@@ -2047,7 +2047,7 @@ PeerMemoryFeatureFlag :: enum Flags {
GENERIC_DST_KHR = GENERIC_DST, GENERIC_DST_KHR = GENERIC_DST,
} }
MemoryAllocateFlags :: distinct bit_set[MemoryAllocateFlag; Flags]; MemoryAllocateFlags :: distinct bit_set[MemoryAllocateFlag; Flags]
MemoryAllocateFlag :: enum Flags { MemoryAllocateFlag :: enum Flags {
DEVICE_MASK = 0, DEVICE_MASK = 0,
DEVICE_ADDRESS = 1, DEVICE_ADDRESS = 1,
@@ -2057,7 +2057,7 @@ MemoryAllocateFlag :: enum Flags {
DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = DEVICE_ADDRESS_CAPTURE_REPLAY, DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = DEVICE_ADDRESS_CAPTURE_REPLAY,
} }
ExternalMemoryHandleTypeFlags :: distinct bit_set[ExternalMemoryHandleTypeFlag; Flags]; ExternalMemoryHandleTypeFlags :: distinct bit_set[ExternalMemoryHandleTypeFlag; Flags]
ExternalMemoryHandleTypeFlag :: enum Flags { ExternalMemoryHandleTypeFlag :: enum Flags {
OPAQUE_FD = 0, OPAQUE_FD = 0,
OPAQUE_WIN32 = 1, OPAQUE_WIN32 = 1,
@@ -2081,7 +2081,7 @@ ExternalMemoryHandleTypeFlag :: enum Flags {
D3D12_RESOURCE_KHR = D3D12_RESOURCE, D3D12_RESOURCE_KHR = D3D12_RESOURCE,
} }
ExternalMemoryFeatureFlags :: distinct bit_set[ExternalMemoryFeatureFlag; Flags]; ExternalMemoryFeatureFlags :: distinct bit_set[ExternalMemoryFeatureFlag; Flags]
ExternalMemoryFeatureFlag :: enum Flags { ExternalMemoryFeatureFlag :: enum Flags {
DEDICATED_ONLY = 0, DEDICATED_ONLY = 0,
EXPORTABLE = 1, EXPORTABLE = 1,
@@ -2091,7 +2091,7 @@ ExternalMemoryFeatureFlag :: enum Flags {
IMPORTABLE_KHR = IMPORTABLE, IMPORTABLE_KHR = IMPORTABLE,
} }
ExternalFenceHandleTypeFlags :: distinct bit_set[ExternalFenceHandleTypeFlag; Flags]; ExternalFenceHandleTypeFlags :: distinct bit_set[ExternalFenceHandleTypeFlag; Flags]
ExternalFenceHandleTypeFlag :: enum Flags { ExternalFenceHandleTypeFlag :: enum Flags {
OPAQUE_FD = 0, OPAQUE_FD = 0,
OPAQUE_WIN32 = 1, OPAQUE_WIN32 = 1,
@@ -2103,7 +2103,7 @@ ExternalFenceHandleTypeFlag :: enum Flags {
SYNC_FD_KHR = SYNC_FD, SYNC_FD_KHR = SYNC_FD,
} }
ExternalFenceFeatureFlags :: distinct bit_set[ExternalFenceFeatureFlag; Flags]; ExternalFenceFeatureFlags :: distinct bit_set[ExternalFenceFeatureFlag; Flags]
ExternalFenceFeatureFlag :: enum Flags { ExternalFenceFeatureFlag :: enum Flags {
EXPORTABLE = 0, EXPORTABLE = 0,
IMPORTABLE = 1, IMPORTABLE = 1,
@@ -2111,19 +2111,19 @@ ExternalFenceFeatureFlag :: enum Flags {
IMPORTABLE_KHR = IMPORTABLE, IMPORTABLE_KHR = IMPORTABLE,
} }
FenceImportFlags :: distinct bit_set[FenceImportFlag; Flags]; FenceImportFlags :: distinct bit_set[FenceImportFlag; Flags]
FenceImportFlag :: enum Flags { FenceImportFlag :: enum Flags {
TEMPORARY = 0, TEMPORARY = 0,
TEMPORARY_KHR = TEMPORARY, TEMPORARY_KHR = TEMPORARY,
} }
SemaphoreImportFlags :: distinct bit_set[SemaphoreImportFlag; Flags]; SemaphoreImportFlags :: distinct bit_set[SemaphoreImportFlag; Flags]
SemaphoreImportFlag :: enum Flags { SemaphoreImportFlag :: enum Flags {
TEMPORARY = 0, TEMPORARY = 0,
TEMPORARY_KHR = TEMPORARY, TEMPORARY_KHR = TEMPORARY,
} }
ExternalSemaphoreHandleTypeFlags :: distinct bit_set[ExternalSemaphoreHandleTypeFlag; Flags]; ExternalSemaphoreHandleTypeFlags :: distinct bit_set[ExternalSemaphoreHandleTypeFlag; Flags]
ExternalSemaphoreHandleTypeFlag :: enum Flags { ExternalSemaphoreHandleTypeFlag :: enum Flags {
OPAQUE_FD = 0, OPAQUE_FD = 0,
OPAQUE_WIN32 = 1, OPAQUE_WIN32 = 1,
@@ -2139,7 +2139,7 @@ ExternalSemaphoreHandleTypeFlag :: enum Flags {
SYNC_FD_KHR = SYNC_FD, SYNC_FD_KHR = SYNC_FD,
} }
ExternalSemaphoreFeatureFlags :: distinct bit_set[ExternalSemaphoreFeatureFlag; Flags]; ExternalSemaphoreFeatureFlags :: distinct bit_set[ExternalSemaphoreFeatureFlag; Flags]
ExternalSemaphoreFeatureFlag :: enum Flags { ExternalSemaphoreFeatureFlag :: enum Flags {
EXPORTABLE = 0, EXPORTABLE = 0,
IMPORTABLE = 1, IMPORTABLE = 1,
@@ -2203,7 +2203,7 @@ SemaphoreType :: enum c.int {
TIMELINE_KHR = TIMELINE, TIMELINE_KHR = TIMELINE,
} }
ResolveModeFlags :: distinct bit_set[ResolveModeFlag; Flags]; ResolveModeFlags :: distinct bit_set[ResolveModeFlag; Flags]
ResolveModeFlag :: enum Flags { ResolveModeFlag :: enum Flags {
SAMPLE_ZERO = 0, SAMPLE_ZERO = 0,
AVERAGE = 1, AVERAGE = 1,
@@ -2215,10 +2215,10 @@ ResolveModeFlag :: enum Flags {
MAX_KHR = MAX, MAX_KHR = MAX,
} }
ResolveModeFlags_NONE :: ResolveModeFlags{}; ResolveModeFlags_NONE :: ResolveModeFlags{}
DescriptorBindingFlags :: distinct bit_set[DescriptorBindingFlag; Flags]; DescriptorBindingFlags :: distinct bit_set[DescriptorBindingFlag; Flags]
DescriptorBindingFlag :: enum Flags { DescriptorBindingFlag :: enum Flags {
UPDATE_AFTER_BIND = 0, UPDATE_AFTER_BIND = 0,
UPDATE_UNUSED_WHILE_PENDING = 1, UPDATE_UNUSED_WHILE_PENDING = 1,
@@ -2230,7 +2230,7 @@ DescriptorBindingFlag :: enum Flags {
VARIABLE_DESCRIPTOR_COUNT_EXT = VARIABLE_DESCRIPTOR_COUNT, VARIABLE_DESCRIPTOR_COUNT_EXT = VARIABLE_DESCRIPTOR_COUNT,
} }
SemaphoreWaitFlags :: distinct bit_set[SemaphoreWaitFlag; Flags]; SemaphoreWaitFlags :: distinct bit_set[SemaphoreWaitFlag; Flags]
SemaphoreWaitFlag :: enum Flags { SemaphoreWaitFlag :: enum Flags {
ANY = 0, ANY = 0,
ANY_KHR = ANY, ANY_KHR = ANY,
@@ -2266,7 +2266,7 @@ ColorSpaceKHR :: enum c.int {
DCI_P3_LINEAR_EXT = DISPLAY_P3_LINEAR_EXT, DCI_P3_LINEAR_EXT = DISPLAY_P3_LINEAR_EXT,
} }
SurfaceTransformFlagsKHR :: distinct bit_set[SurfaceTransformFlagKHR; Flags]; SurfaceTransformFlagsKHR :: distinct bit_set[SurfaceTransformFlagKHR; Flags]
SurfaceTransformFlagKHR :: enum Flags { SurfaceTransformFlagKHR :: enum Flags {
IDENTITY = 0, IDENTITY = 0,
ROTATE_90 = 1, ROTATE_90 = 1,
@@ -2279,7 +2279,7 @@ SurfaceTransformFlagKHR :: enum Flags {
INHERIT = 8, INHERIT = 8,
} }
CompositeAlphaFlagsKHR :: distinct bit_set[CompositeAlphaFlagKHR; Flags]; CompositeAlphaFlagsKHR :: distinct bit_set[CompositeAlphaFlagKHR; Flags]
CompositeAlphaFlagKHR :: enum Flags { CompositeAlphaFlagKHR :: enum Flags {
OPAQUE = 0, OPAQUE = 0,
PRE_MULTIPLIED = 1, PRE_MULTIPLIED = 1,
@@ -2287,14 +2287,14 @@ CompositeAlphaFlagKHR :: enum Flags {
INHERIT = 3, INHERIT = 3,
} }
SwapchainCreateFlagsKHR :: distinct bit_set[SwapchainCreateFlagKHR; Flags]; SwapchainCreateFlagsKHR :: distinct bit_set[SwapchainCreateFlagKHR; Flags]
SwapchainCreateFlagKHR :: enum Flags { SwapchainCreateFlagKHR :: enum Flags {
SPLIT_INSTANCE_BIND_REGIONS = 0, SPLIT_INSTANCE_BIND_REGIONS = 0,
PROTECTED = 1, PROTECTED = 1,
MUTABLE_FORMAT = 2, MUTABLE_FORMAT = 2,
} }
DeviceGroupPresentModeFlagsKHR :: distinct bit_set[DeviceGroupPresentModeFlagKHR; Flags]; DeviceGroupPresentModeFlagsKHR :: distinct bit_set[DeviceGroupPresentModeFlagKHR; Flags]
DeviceGroupPresentModeFlagKHR :: enum Flags { DeviceGroupPresentModeFlagKHR :: enum Flags {
LOCAL = 0, LOCAL = 0,
REMOTE = 1, REMOTE = 1,
@@ -2302,7 +2302,7 @@ DeviceGroupPresentModeFlagKHR :: enum Flags {
LOCAL_MULTI_DEVICE = 3, LOCAL_MULTI_DEVICE = 3,
} }
DisplayPlaneAlphaFlagsKHR :: distinct bit_set[DisplayPlaneAlphaFlagKHR; Flags]; DisplayPlaneAlphaFlagsKHR :: distinct bit_set[DisplayPlaneAlphaFlagKHR; Flags]
DisplayPlaneAlphaFlagKHR :: enum Flags { DisplayPlaneAlphaFlagKHR :: enum Flags {
OPAQUE = 0, OPAQUE = 0,
GLOBAL = 1, GLOBAL = 1,
@@ -2342,13 +2342,13 @@ PerformanceCounterStorageKHR :: enum c.int {
FLOAT64 = 5, FLOAT64 = 5,
} }
PerformanceCounterDescriptionFlagsKHR :: distinct bit_set[PerformanceCounterDescriptionFlagKHR; Flags]; PerformanceCounterDescriptionFlagsKHR :: distinct bit_set[PerformanceCounterDescriptionFlagKHR; Flags]
PerformanceCounterDescriptionFlagKHR :: enum Flags { PerformanceCounterDescriptionFlagKHR :: enum Flags {
PERFORMANCE_IMPACTING = 0, PERFORMANCE_IMPACTING = 0,
CONCURRENTLY_IMPACTED = 1, CONCURRENTLY_IMPACTED = 1,
} }
AcquireProfilingLockFlagsKHR :: distinct bit_set[AcquireProfilingLockFlagKHR; Flags]; AcquireProfilingLockFlagsKHR :: distinct bit_set[AcquireProfilingLockFlagKHR; Flags]
AcquireProfilingLockFlagKHR :: enum Flags { AcquireProfilingLockFlagKHR :: enum Flags {
} }
@@ -2367,7 +2367,7 @@ PipelineExecutableStatisticFormatKHR :: enum c.int {
FLOAT64 = 3, FLOAT64 = 3,
} }
SubmitFlagsKHR :: distinct bit_set[SubmitFlagKHR; Flags]; SubmitFlagsKHR :: distinct bit_set[SubmitFlagKHR; Flags]
SubmitFlagKHR :: enum Flags { SubmitFlagKHR :: enum Flags {
PROTECTED = 0, PROTECTED = 0,
} }
@@ -2417,7 +2417,7 @@ DebugReportObjectTypeEXT :: enum c.int {
SAMPLER_YCBCR_CONVERSION_KHR = SAMPLER_YCBCR_CONVERSION, SAMPLER_YCBCR_CONVERSION_KHR = SAMPLER_YCBCR_CONVERSION,
} }
DebugReportFlagsEXT :: distinct bit_set[DebugReportFlagEXT; Flags]; DebugReportFlagsEXT :: distinct bit_set[DebugReportFlagEXT; Flags]
DebugReportFlagEXT :: enum Flags { DebugReportFlagEXT :: enum Flags {
INFORMATION = 0, INFORMATION = 0,
WARNING = 1, WARNING = 1,
@@ -2437,7 +2437,7 @@ ShaderInfoTypeAMD :: enum c.int {
DISASSEMBLY = 2, DISASSEMBLY = 2,
} }
ExternalMemoryHandleTypeFlagsNV :: distinct bit_set[ExternalMemoryHandleTypeFlagNV; Flags]; ExternalMemoryHandleTypeFlagsNV :: distinct bit_set[ExternalMemoryHandleTypeFlagNV; Flags]
ExternalMemoryHandleTypeFlagNV :: enum Flags { ExternalMemoryHandleTypeFlagNV :: enum Flags {
OPAQUE_WIN32 = 0, OPAQUE_WIN32 = 0,
OPAQUE_WIN32_KMT = 1, OPAQUE_WIN32_KMT = 1,
@@ -2445,7 +2445,7 @@ ExternalMemoryHandleTypeFlagNV :: enum Flags {
D3D11_IMAGE_KMT = 3, D3D11_IMAGE_KMT = 3,
} }
ExternalMemoryFeatureFlagsNV :: distinct bit_set[ExternalMemoryFeatureFlagNV; Flags]; ExternalMemoryFeatureFlagsNV :: distinct bit_set[ExternalMemoryFeatureFlagNV; Flags]
ExternalMemoryFeatureFlagNV :: enum Flags { ExternalMemoryFeatureFlagNV :: enum Flags {
DEDICATED_ONLY = 0, DEDICATED_ONLY = 0,
EXPORTABLE = 1, EXPORTABLE = 1,
@@ -2457,12 +2457,12 @@ ValidationCheckEXT :: enum c.int {
SHADERS = 1, SHADERS = 1,
} }
ConditionalRenderingFlagsEXT :: distinct bit_set[ConditionalRenderingFlagEXT; Flags]; ConditionalRenderingFlagsEXT :: distinct bit_set[ConditionalRenderingFlagEXT; Flags]
ConditionalRenderingFlagEXT :: enum Flags { ConditionalRenderingFlagEXT :: enum Flags {
INVERTED = 0, INVERTED = 0,
} }
SurfaceCounterFlagsEXT :: distinct bit_set[SurfaceCounterFlagEXT; Flags]; SurfaceCounterFlagsEXT :: distinct bit_set[SurfaceCounterFlagEXT; Flags]
SurfaceCounterFlagEXT :: enum Flags { SurfaceCounterFlagEXT :: enum Flags {
VBLANK = 0, VBLANK = 0,
} }
@@ -2503,7 +2503,7 @@ ConservativeRasterizationModeEXT :: enum c.int {
UNDERESTIMATE = 2, UNDERESTIMATE = 2,
} }
DebugUtilsMessageSeverityFlagsEXT :: distinct bit_set[DebugUtilsMessageSeverityFlagEXT; Flags]; DebugUtilsMessageSeverityFlagsEXT :: distinct bit_set[DebugUtilsMessageSeverityFlagEXT; Flags]
DebugUtilsMessageSeverityFlagEXT :: enum Flags { DebugUtilsMessageSeverityFlagEXT :: enum Flags {
VERBOSE = 0, VERBOSE = 0,
INFO = 4, INFO = 4,
@@ -2511,7 +2511,7 @@ DebugUtilsMessageSeverityFlagEXT :: enum Flags {
ERROR = 12, ERROR = 12,
} }
DebugUtilsMessageTypeFlagsEXT :: distinct bit_set[DebugUtilsMessageTypeFlagEXT; Flags]; DebugUtilsMessageTypeFlagsEXT :: distinct bit_set[DebugUtilsMessageTypeFlagEXT; Flags]
DebugUtilsMessageTypeFlagEXT :: enum Flags { DebugUtilsMessageTypeFlagEXT :: enum Flags {
GENERAL = 0, GENERAL = 0,
VALIDATION = 1, VALIDATION = 1,
@@ -2597,7 +2597,7 @@ AccelerationStructureMemoryRequirementsTypeNV :: enum c.int {
UPDATE_SCRATCH = 2, UPDATE_SCRATCH = 2,
} }
GeometryFlagsKHR :: distinct bit_set[GeometryFlagKHR; Flags]; GeometryFlagsKHR :: distinct bit_set[GeometryFlagKHR; Flags]
GeometryFlagKHR :: enum Flags { GeometryFlagKHR :: enum Flags {
OPAQUE = 0, OPAQUE = 0,
NO_DUPLICATE_ANY_HIT_INVOCATION = 1, NO_DUPLICATE_ANY_HIT_INVOCATION = 1,
@@ -2605,7 +2605,7 @@ GeometryFlagKHR :: enum Flags {
NO_DUPLICATE_ANY_HIT_INVOCATION_NV = NO_DUPLICATE_ANY_HIT_INVOCATION, NO_DUPLICATE_ANY_HIT_INVOCATION_NV = NO_DUPLICATE_ANY_HIT_INVOCATION,
} }
GeometryInstanceFlagsKHR :: distinct bit_set[GeometryInstanceFlagKHR; Flags]; GeometryInstanceFlagsKHR :: distinct bit_set[GeometryInstanceFlagKHR; Flags]
GeometryInstanceFlagKHR :: enum Flags { GeometryInstanceFlagKHR :: enum Flags {
TRIANGLE_FACING_CULL_DISABLE = 0, TRIANGLE_FACING_CULL_DISABLE = 0,
TRIANGLE_FLIP_FACING = 1, TRIANGLE_FLIP_FACING = 1,
@@ -2618,7 +2618,7 @@ GeometryInstanceFlagKHR :: enum Flags {
FORCE_NO_OPAQUE_NV = FORCE_NO_OPAQUE, FORCE_NO_OPAQUE_NV = FORCE_NO_OPAQUE,
} }
BuildAccelerationStructureFlagsKHR :: distinct bit_set[BuildAccelerationStructureFlagKHR; Flags]; BuildAccelerationStructureFlagsKHR :: distinct bit_set[BuildAccelerationStructureFlagKHR; Flags]
BuildAccelerationStructureFlagKHR :: enum Flags { BuildAccelerationStructureFlagKHR :: enum Flags {
ALLOW_UPDATE = 0, ALLOW_UPDATE = 0,
ALLOW_COMPACTION = 1, ALLOW_COMPACTION = 1,
@@ -2640,7 +2640,7 @@ QueueGlobalPriorityEXT :: enum c.int {
REALTIME = 1024, REALTIME = 1024,
} }
PipelineCompilerControlFlagsAMD :: distinct bit_set[PipelineCompilerControlFlagAMD; Flags]; PipelineCompilerControlFlagsAMD :: distinct bit_set[PipelineCompilerControlFlagAMD; Flags]
PipelineCompilerControlFlagAMD :: enum Flags { PipelineCompilerControlFlagAMD :: enum Flags {
} }
@@ -2657,7 +2657,7 @@ MemoryOverallocationBehaviorAMD :: enum c.int {
DISALLOWED = 2, DISALLOWED = 2,
} }
PipelineCreationFeedbackFlagsEXT :: distinct bit_set[PipelineCreationFeedbackFlagEXT; Flags]; PipelineCreationFeedbackFlagsEXT :: distinct bit_set[PipelineCreationFeedbackFlagEXT; Flags]
PipelineCreationFeedbackFlagEXT :: enum Flags { PipelineCreationFeedbackFlagEXT :: enum Flags {
VALID = 0, VALID = 0,
APPLICATION_PIPELINE_CACHE_HIT = 1, APPLICATION_PIPELINE_CACHE_HIT = 1,
@@ -2690,11 +2690,11 @@ PerformanceValueTypeINTEL :: enum c.int {
PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
} }
ShaderCorePropertiesFlagsAMD :: distinct bit_set[ShaderCorePropertiesFlagAMD; Flags]; ShaderCorePropertiesFlagsAMD :: distinct bit_set[ShaderCorePropertiesFlagAMD; Flags]
ShaderCorePropertiesFlagAMD :: enum Flags { ShaderCorePropertiesFlagAMD :: enum Flags {
} }
ToolPurposeFlagsEXT :: distinct bit_set[ToolPurposeFlagEXT; Flags]; ToolPurposeFlagsEXT :: distinct bit_set[ToolPurposeFlagEXT; Flags]
ToolPurposeFlagEXT :: enum Flags { ToolPurposeFlagEXT :: enum Flags {
VALIDATION = 0, VALIDATION = 0,
PROFILING = 1, PROFILING = 1,
@@ -2773,12 +2773,12 @@ IndirectCommandsTokenTypeNV :: enum c.int {
DRAW_TASKS = 7, DRAW_TASKS = 7,
} }
IndirectStateFlagsNV :: distinct bit_set[IndirectStateFlagNV; Flags]; IndirectStateFlagsNV :: distinct bit_set[IndirectStateFlagNV; Flags]
IndirectStateFlagNV :: enum Flags { IndirectStateFlagNV :: enum Flags {
FLAG_FRONTFACE = 0, FLAG_FRONTFACE = 0,
} }
IndirectCommandsLayoutUsageFlagsNV :: distinct bit_set[IndirectCommandsLayoutUsageFlagNV; Flags]; IndirectCommandsLayoutUsageFlagsNV :: distinct bit_set[IndirectCommandsLayoutUsageFlagNV; Flags]
IndirectCommandsLayoutUsageFlagNV :: enum Flags { IndirectCommandsLayoutUsageFlagNV :: enum Flags {
EXPLICIT_PREPROCESS = 0, EXPLICIT_PREPROCESS = 0,
INDEXED_SEQUENCES = 1, INDEXED_SEQUENCES = 1,
@@ -2793,11 +2793,11 @@ DeviceMemoryReportEventTypeEXT :: enum c.int {
ALLOCATION_FAILED = 4, ALLOCATION_FAILED = 4,
} }
PrivateDataSlotCreateFlagsEXT :: distinct bit_set[PrivateDataSlotCreateFlagEXT; Flags]; PrivateDataSlotCreateFlagsEXT :: distinct bit_set[PrivateDataSlotCreateFlagEXT; Flags]
PrivateDataSlotCreateFlagEXT :: enum Flags { PrivateDataSlotCreateFlagEXT :: enum Flags {
} }
DeviceDiagnosticsConfigFlagsNV :: distinct bit_set[DeviceDiagnosticsConfigFlagNV; Flags]; DeviceDiagnosticsConfigFlagsNV :: distinct bit_set[DeviceDiagnosticsConfigFlagNV; Flags]
DeviceDiagnosticsConfigFlagNV :: enum Flags { DeviceDiagnosticsConfigFlagNV :: enum Flags {
ENABLE_SHADER_DEBUG_INFO = 0, ENABLE_SHADER_DEBUG_INFO = 0,
ENABLE_RESOURCE_TRACKING = 1, ENABLE_RESOURCE_TRACKING = 1,
@@ -2846,7 +2846,7 @@ AccelerationStructureCompatibilityKHR :: enum c.int {
INCOMPATIBLE = 1, INCOMPATIBLE = 1,
} }
AccelerationStructureCreateFlagsKHR :: distinct bit_set[AccelerationStructureCreateFlagKHR; Flags]; AccelerationStructureCreateFlagsKHR :: distinct bit_set[AccelerationStructureCreateFlagKHR; Flags]
AccelerationStructureCreateFlagKHR :: enum Flags { AccelerationStructureCreateFlagKHR :: enum Flags {
DEVICE_ADDRESS_CAPTURE_REPLAY = 0, DEVICE_ADDRESS_CAPTURE_REPLAY = 0,
MOTION_NV = 2, MOTION_NV = 2,
@@ -2866,85 +2866,85 @@ FullScreenExclusiveEXT :: enum c.int {
APPLICATION_CONTROLLED = 3, APPLICATION_CONTROLLED = 3,
} }
PipelineCoverageReductionStateCreateFlagsNV :: distinct bit_set[PipelineCoverageReductionStateCreateFlagNV; Flags]; PipelineCoverageReductionStateCreateFlagsNV :: distinct bit_set[PipelineCoverageReductionStateCreateFlagNV; Flags]
PipelineCoverageReductionStateCreateFlagNV :: enum u32 {}; PipelineCoverageReductionStateCreateFlagNV :: enum u32 {}
DisplayModeCreateFlagsKHR :: distinct bit_set[DisplayModeCreateFlagKHR; Flags]; DisplayModeCreateFlagsKHR :: distinct bit_set[DisplayModeCreateFlagKHR; Flags]
DisplayModeCreateFlagKHR :: enum u32 {}; DisplayModeCreateFlagKHR :: enum u32 {}
DeviceCreateFlags :: distinct bit_set[DeviceCreateFlag; Flags]; DeviceCreateFlags :: distinct bit_set[DeviceCreateFlag; Flags]
DeviceCreateFlag :: enum u32 {}; DeviceCreateFlag :: enum u32 {}
PipelineInputAssemblyStateCreateFlags :: distinct bit_set[PipelineInputAssemblyStateCreateFlag; Flags]; PipelineInputAssemblyStateCreateFlags :: distinct bit_set[PipelineInputAssemblyStateCreateFlag; Flags]
PipelineInputAssemblyStateCreateFlag :: enum u32 {}; PipelineInputAssemblyStateCreateFlag :: enum u32 {}
PipelineVertexInputStateCreateFlags :: distinct bit_set[PipelineVertexInputStateCreateFlag; Flags]; PipelineVertexInputStateCreateFlags :: distinct bit_set[PipelineVertexInputStateCreateFlag; Flags]
PipelineVertexInputStateCreateFlag :: enum u32 {}; PipelineVertexInputStateCreateFlag :: enum u32 {}
PipelineRasterizationStateCreateFlags :: distinct bit_set[PipelineRasterizationStateCreateFlag; Flags]; PipelineRasterizationStateCreateFlags :: distinct bit_set[PipelineRasterizationStateCreateFlag; Flags]
PipelineRasterizationStateCreateFlag :: enum u32 {}; PipelineRasterizationStateCreateFlag :: enum u32 {}
PipelineLayoutCreateFlags :: distinct bit_set[PipelineLayoutCreateFlag; Flags]; PipelineLayoutCreateFlags :: distinct bit_set[PipelineLayoutCreateFlag; Flags]
PipelineLayoutCreateFlag :: enum u32 {}; PipelineLayoutCreateFlag :: enum u32 {}
PipelineCoverageModulationStateCreateFlagsNV :: distinct bit_set[PipelineCoverageModulationStateCreateFlagNV; Flags]; PipelineCoverageModulationStateCreateFlagsNV :: distinct bit_set[PipelineCoverageModulationStateCreateFlagNV; Flags]
PipelineCoverageModulationStateCreateFlagNV :: enum u32 {}; PipelineCoverageModulationStateCreateFlagNV :: enum u32 {}
AccelerationStructureMotionInstanceFlagsNV :: distinct bit_set[AccelerationStructureMotionInstanceFlagNV; Flags]; AccelerationStructureMotionInstanceFlagsNV :: distinct bit_set[AccelerationStructureMotionInstanceFlagNV; Flags]
AccelerationStructureMotionInstanceFlagNV :: enum u32 {}; AccelerationStructureMotionInstanceFlagNV :: enum u32 {}
DeviceMemoryReportFlagsEXT :: distinct bit_set[DeviceMemoryReportFlagEXT; Flags]; DeviceMemoryReportFlagsEXT :: distinct bit_set[DeviceMemoryReportFlagEXT; Flags]
DeviceMemoryReportFlagEXT :: enum u32 {}; DeviceMemoryReportFlagEXT :: enum u32 {}
PipelineMultisampleStateCreateFlags :: distinct bit_set[PipelineMultisampleStateCreateFlag; Flags]; PipelineMultisampleStateCreateFlags :: distinct bit_set[PipelineMultisampleStateCreateFlag; Flags]
PipelineMultisampleStateCreateFlag :: enum u32 {}; PipelineMultisampleStateCreateFlag :: enum u32 {}
QueryPoolCreateFlags :: distinct bit_set[QueryPoolCreateFlag; Flags]; QueryPoolCreateFlags :: distinct bit_set[QueryPoolCreateFlag; Flags]
QueryPoolCreateFlag :: enum u32 {}; QueryPoolCreateFlag :: enum u32 {}
DebugUtilsMessengerCreateFlagsEXT :: distinct bit_set[DebugUtilsMessengerCreateFlagEXT; Flags]; DebugUtilsMessengerCreateFlagsEXT :: distinct bit_set[DebugUtilsMessengerCreateFlagEXT; Flags]
DebugUtilsMessengerCreateFlagEXT :: enum u32 {}; DebugUtilsMessengerCreateFlagEXT :: enum u32 {}
SemaphoreCreateFlags :: distinct bit_set[SemaphoreCreateFlag; Flags]; SemaphoreCreateFlags :: distinct bit_set[SemaphoreCreateFlag; Flags]
SemaphoreCreateFlag :: enum u32 {}; SemaphoreCreateFlag :: enum u32 {}
BufferViewCreateFlags :: distinct bit_set[BufferViewCreateFlag; Flags]; BufferViewCreateFlags :: distinct bit_set[BufferViewCreateFlag; Flags]
BufferViewCreateFlag :: enum u32 {}; BufferViewCreateFlag :: enum u32 {}
PipelineDepthStencilStateCreateFlags :: distinct bit_set[PipelineDepthStencilStateCreateFlag; Flags]; PipelineDepthStencilStateCreateFlags :: distinct bit_set[PipelineDepthStencilStateCreateFlag; Flags]
PipelineDepthStencilStateCreateFlag :: enum u32 {}; PipelineDepthStencilStateCreateFlag :: enum u32 {}
PipelineViewportStateCreateFlags :: distinct bit_set[PipelineViewportStateCreateFlag; Flags]; PipelineViewportStateCreateFlags :: distinct bit_set[PipelineViewportStateCreateFlag; Flags]
PipelineViewportStateCreateFlag :: enum u32 {}; PipelineViewportStateCreateFlag :: enum u32 {}
PipelineDynamicStateCreateFlags :: distinct bit_set[PipelineDynamicStateCreateFlag; Flags]; PipelineDynamicStateCreateFlags :: distinct bit_set[PipelineDynamicStateCreateFlag; Flags]
PipelineDynamicStateCreateFlag :: enum u32 {}; PipelineDynamicStateCreateFlag :: enum u32 {}
HeadlessSurfaceCreateFlagsEXT :: distinct bit_set[HeadlessSurfaceCreateFlagEXT; Flags]; HeadlessSurfaceCreateFlagsEXT :: distinct bit_set[HeadlessSurfaceCreateFlagEXT; Flags]
HeadlessSurfaceCreateFlagEXT :: enum u32 {}; HeadlessSurfaceCreateFlagEXT :: enum u32 {}
CommandPoolTrimFlags :: distinct bit_set[CommandPoolTrimFlag; Flags]; CommandPoolTrimFlags :: distinct bit_set[CommandPoolTrimFlag; Flags]
CommandPoolTrimFlag :: enum u32 {}; CommandPoolTrimFlag :: enum u32 {}
DescriptorUpdateTemplateCreateFlags :: distinct bit_set[DescriptorUpdateTemplateCreateFlag; Flags]; DescriptorUpdateTemplateCreateFlags :: distinct bit_set[DescriptorUpdateTemplateCreateFlag; Flags]
DescriptorUpdateTemplateCreateFlag :: enum u32 {}; DescriptorUpdateTemplateCreateFlag :: enum u32 {}
PipelineColorBlendStateCreateFlags :: distinct bit_set[PipelineColorBlendStateCreateFlag; Flags]; PipelineColorBlendStateCreateFlags :: distinct bit_set[PipelineColorBlendStateCreateFlag; Flags]
PipelineColorBlendStateCreateFlag :: enum u32 {}; PipelineColorBlendStateCreateFlag :: enum u32 {}
PipelineViewportSwizzleStateCreateFlagsNV :: distinct bit_set[PipelineViewportSwizzleStateCreateFlagNV; Flags]; PipelineViewportSwizzleStateCreateFlagsNV :: distinct bit_set[PipelineViewportSwizzleStateCreateFlagNV; Flags]
PipelineViewportSwizzleStateCreateFlagNV :: enum u32 {}; PipelineViewportSwizzleStateCreateFlagNV :: enum u32 {}
MemoryMapFlags :: distinct bit_set[MemoryMapFlag; Flags]; MemoryMapFlags :: distinct bit_set[MemoryMapFlag; Flags]
MemoryMapFlag :: enum u32 {}; MemoryMapFlag :: enum u32 {}
PipelineDiscardRectangleStateCreateFlagsEXT :: distinct bit_set[PipelineDiscardRectangleStateCreateFlagEXT; Flags]; PipelineDiscardRectangleStateCreateFlagsEXT :: distinct bit_set[PipelineDiscardRectangleStateCreateFlagEXT; Flags]
PipelineDiscardRectangleStateCreateFlagEXT :: enum u32 {}; PipelineDiscardRectangleStateCreateFlagEXT :: enum u32 {}
InstanceCreateFlags :: distinct bit_set[InstanceCreateFlag; Flags]; InstanceCreateFlags :: distinct bit_set[InstanceCreateFlag; Flags]
InstanceCreateFlag :: enum u32 {}; InstanceCreateFlag :: enum u32 {}
PipelineRasterizationConservativeStateCreateFlagsEXT :: distinct bit_set[PipelineRasterizationConservativeStateCreateFlagEXT; Flags]; PipelineRasterizationConservativeStateCreateFlagsEXT :: distinct bit_set[PipelineRasterizationConservativeStateCreateFlagEXT; Flags]
PipelineRasterizationConservativeStateCreateFlagEXT :: enum u32 {}; PipelineRasterizationConservativeStateCreateFlagEXT :: enum u32 {}
PipelineRasterizationDepthClipStateCreateFlagsEXT :: distinct bit_set[PipelineRasterizationDepthClipStateCreateFlagEXT; Flags]; PipelineRasterizationDepthClipStateCreateFlagsEXT :: distinct bit_set[PipelineRasterizationDepthClipStateCreateFlagEXT; Flags]
PipelineRasterizationDepthClipStateCreateFlagEXT :: enum u32 {}; PipelineRasterizationDepthClipStateCreateFlagEXT :: enum u32 {}
PipelineRasterizationStateStreamCreateFlagsEXT :: distinct bit_set[PipelineRasterizationStateStreamCreateFlagEXT; Flags]; PipelineRasterizationStateStreamCreateFlagsEXT :: distinct bit_set[PipelineRasterizationStateStreamCreateFlagEXT; Flags]
PipelineRasterizationStateStreamCreateFlagEXT :: enum u32 {}; PipelineRasterizationStateStreamCreateFlagEXT :: enum u32 {}
DebugUtilsMessengerCallbackDataFlagsEXT :: distinct bit_set[DebugUtilsMessengerCallbackDataFlagEXT; Flags]; DebugUtilsMessengerCallbackDataFlagsEXT :: distinct bit_set[DebugUtilsMessengerCallbackDataFlagEXT; Flags]
DebugUtilsMessengerCallbackDataFlagEXT :: enum u32 {}; DebugUtilsMessengerCallbackDataFlagEXT :: enum u32 {}
DisplaySurfaceCreateFlagsKHR :: distinct bit_set[DisplaySurfaceCreateFlagKHR; Flags]; DisplaySurfaceCreateFlagsKHR :: distinct bit_set[DisplaySurfaceCreateFlagKHR; Flags]
DisplaySurfaceCreateFlagKHR :: enum u32 {}; DisplaySurfaceCreateFlagKHR :: enum u32 {}
MetalSurfaceCreateFlagsEXT :: distinct bit_set[MetalSurfaceCreateFlagEXT; Flags]; MetalSurfaceCreateFlagsEXT :: distinct bit_set[MetalSurfaceCreateFlagEXT; Flags]
MetalSurfaceCreateFlagEXT :: enum u32 {}; MetalSurfaceCreateFlagEXT :: enum u32 {}
IOSSurfaceCreateFlagsMVK :: distinct bit_set[IOSSurfaceCreateFlagMVK; Flags]; IOSSurfaceCreateFlagsMVK :: distinct bit_set[IOSSurfaceCreateFlagMVK; Flags]
IOSSurfaceCreateFlagMVK :: enum u32 {}; IOSSurfaceCreateFlagMVK :: enum u32 {}
MacOSSurfaceCreateFlagsMVK :: distinct bit_set[MacOSSurfaceCreateFlagMVK; Flags]; MacOSSurfaceCreateFlagsMVK :: distinct bit_set[MacOSSurfaceCreateFlagMVK; Flags]
MacOSSurfaceCreateFlagMVK :: enum u32 {}; MacOSSurfaceCreateFlagMVK :: enum u32 {}
PipelineCoverageToColorStateCreateFlagsNV :: distinct bit_set[PipelineCoverageToColorStateCreateFlagNV; Flags]; PipelineCoverageToColorStateCreateFlagsNV :: distinct bit_set[PipelineCoverageToColorStateCreateFlagNV; Flags]
PipelineCoverageToColorStateCreateFlagNV :: enum u32 {}; PipelineCoverageToColorStateCreateFlagNV :: enum u32 {}
ValidationCacheCreateFlagsEXT :: distinct bit_set[ValidationCacheCreateFlagEXT; Flags]; ValidationCacheCreateFlagsEXT :: distinct bit_set[ValidationCacheCreateFlagEXT; Flags]
ValidationCacheCreateFlagEXT :: enum u32 {}; ValidationCacheCreateFlagEXT :: enum u32 {}
Win32SurfaceCreateFlagsKHR :: distinct bit_set[Win32SurfaceCreateFlagKHR; Flags]; Win32SurfaceCreateFlagsKHR :: distinct bit_set[Win32SurfaceCreateFlagKHR; Flags]
Win32SurfaceCreateFlagKHR :: enum u32 {}; Win32SurfaceCreateFlagKHR :: enum u32 {}
PipelineTessellationStateCreateFlags :: distinct bit_set[PipelineTessellationStateCreateFlag; Flags]; PipelineTessellationStateCreateFlags :: distinct bit_set[PipelineTessellationStateCreateFlag; Flags]
PipelineTessellationStateCreateFlag :: enum u32 {}; PipelineTessellationStateCreateFlag :: enum u32 {}
DescriptorPoolResetFlags :: distinct bit_set[DescriptorPoolResetFlag; Flags]; DescriptorPoolResetFlags :: distinct bit_set[DescriptorPoolResetFlag; Flags]
DescriptorPoolResetFlag :: enum u32 {}; DescriptorPoolResetFlag :: enum u32 {}
AccelerationStructureMotionInfoFlagsNV :: distinct bit_set[AccelerationStructureMotionInfoFlagNV; Flags]; AccelerationStructureMotionInfoFlagsNV :: distinct bit_set[AccelerationStructureMotionInfoFlagNV; Flags]
AccelerationStructureMotionInfoFlagNV :: enum u32 {}; AccelerationStructureMotionInfoFlagNV :: enum u32 {}
vendor/vulkan/procedures.odin
Vendored
+1854 -1854
View File
File diff suppressed because it is too large Load Diff
vendor/vulkan/structs.odin
Vendored
+191 -191
View File
@@ -8,31 +8,31 @@ import "core:c"
when ODIN_OS == "windows" { when ODIN_OS == "windows" {
import win32 "core:sys/windows" import win32 "core:sys/windows"
HINSTANCE :: win32.HINSTANCE; HINSTANCE :: win32.HINSTANCE
HWND :: win32.HWND; HWND :: win32.HWND
HMONITOR :: win32.HMONITOR; HMONITOR :: win32.HMONITOR
HANDLE :: win32.HANDLE; HANDLE :: win32.HANDLE
LPCWSTR :: win32.LPCWSTR; LPCWSTR :: win32.LPCWSTR
SECURITY_ATTRIBUTES :: win32.SECURITY_ATTRIBUTES; SECURITY_ATTRIBUTES :: win32.SECURITY_ATTRIBUTES
DWORD :: win32.DWORD; DWORD :: win32.DWORD
LONG :: win32.LONG; LONG :: win32.LONG
LUID :: win32.LUID; LUID :: win32.LUID
} else { } else {
HINSTANCE :: distinct rawptr; HINSTANCE :: distinct rawptr
HWND :: distinct rawptr; HWND :: distinct rawptr
HMONITOR :: distinct rawptr; HMONITOR :: distinct rawptr
HANDLE :: distinct rawptr; HANDLE :: distinct rawptr
LPCWSTR :: ^u16; LPCWSTR :: ^u16
SECURITY_ATTRIBUTES :: struct {}; SECURITY_ATTRIBUTES :: struct {}
DWORD :: u32; DWORD :: u32
LONG :: c.long; LONG :: c.long
LUID :: struct { LUID :: struct {
LowPart: DWORD, LowPart: DWORD,
HighPart: LONG, HighPart: LONG,
} }
} }
CAMetalLayer :: struct {}; CAMetalLayer :: struct {}
/********************************/ /********************************/
@@ -5229,178 +5229,178 @@ IOSSurfaceCreateInfoMVK :: struct {
} }
// Aliases // Aliases
PhysicalDeviceVariablePointerFeatures :: PhysicalDeviceVariablePointersFeatures; PhysicalDeviceVariablePointerFeatures :: PhysicalDeviceVariablePointersFeatures
PhysicalDeviceShaderDrawParameterFeatures :: PhysicalDeviceShaderDrawParametersFeatures; PhysicalDeviceShaderDrawParameterFeatures :: PhysicalDeviceShaderDrawParametersFeatures
RenderPassMultiviewCreateInfoKHR :: RenderPassMultiviewCreateInfo; RenderPassMultiviewCreateInfoKHR :: RenderPassMultiviewCreateInfo
PhysicalDeviceMultiviewFeaturesKHR :: PhysicalDeviceMultiviewFeatures; PhysicalDeviceMultiviewFeaturesKHR :: PhysicalDeviceMultiviewFeatures
PhysicalDeviceMultiviewPropertiesKHR :: PhysicalDeviceMultiviewProperties; PhysicalDeviceMultiviewPropertiesKHR :: PhysicalDeviceMultiviewProperties
PhysicalDeviceFeatures2KHR :: PhysicalDeviceFeatures2; PhysicalDeviceFeatures2KHR :: PhysicalDeviceFeatures2
PhysicalDeviceProperties2KHR :: PhysicalDeviceProperties2; PhysicalDeviceProperties2KHR :: PhysicalDeviceProperties2
FormatProperties2KHR :: FormatProperties2; FormatProperties2KHR :: FormatProperties2
ImageFormatProperties2KHR :: ImageFormatProperties2; ImageFormatProperties2KHR :: ImageFormatProperties2
PhysicalDeviceImageFormatInfo2KHR :: PhysicalDeviceImageFormatInfo2; PhysicalDeviceImageFormatInfo2KHR :: PhysicalDeviceImageFormatInfo2
QueueFamilyProperties2KHR :: QueueFamilyProperties2; QueueFamilyProperties2KHR :: QueueFamilyProperties2
PhysicalDeviceMemoryProperties2KHR :: PhysicalDeviceMemoryProperties2; PhysicalDeviceMemoryProperties2KHR :: PhysicalDeviceMemoryProperties2
SparseImageFormatProperties2KHR :: SparseImageFormatProperties2; SparseImageFormatProperties2KHR :: SparseImageFormatProperties2
PhysicalDeviceSparseImageFormatInfo2KHR :: PhysicalDeviceSparseImageFormatInfo2; PhysicalDeviceSparseImageFormatInfo2KHR :: PhysicalDeviceSparseImageFormatInfo2
PeerMemoryFeatureFlagsKHR :: PeerMemoryFeatureFlags; PeerMemoryFeatureFlagsKHR :: PeerMemoryFeatureFlags
PeerMemoryFeatureFlagKHR :: PeerMemoryFeatureFlag; PeerMemoryFeatureFlagKHR :: PeerMemoryFeatureFlag
MemoryAllocateFlagsKHR :: MemoryAllocateFlags; MemoryAllocateFlagsKHR :: MemoryAllocateFlags
MemoryAllocateFlagKHR :: MemoryAllocateFlag; MemoryAllocateFlagKHR :: MemoryAllocateFlag
MemoryAllocateFlagsInfoKHR :: MemoryAllocateFlagsInfo; MemoryAllocateFlagsInfoKHR :: MemoryAllocateFlagsInfo
DeviceGroupRenderPassBeginInfoKHR :: DeviceGroupRenderPassBeginInfo; DeviceGroupRenderPassBeginInfoKHR :: DeviceGroupRenderPassBeginInfo
DeviceGroupCommandBufferBeginInfoKHR :: DeviceGroupCommandBufferBeginInfo; DeviceGroupCommandBufferBeginInfoKHR :: DeviceGroupCommandBufferBeginInfo
DeviceGroupSubmitInfoKHR :: DeviceGroupSubmitInfo; DeviceGroupSubmitInfoKHR :: DeviceGroupSubmitInfo
DeviceGroupBindSparseInfoKHR :: DeviceGroupBindSparseInfo; DeviceGroupBindSparseInfoKHR :: DeviceGroupBindSparseInfo
BindBufferMemoryDeviceGroupInfoKHR :: BindBufferMemoryDeviceGroupInfo; BindBufferMemoryDeviceGroupInfoKHR :: BindBufferMemoryDeviceGroupInfo
BindImageMemoryDeviceGroupInfoKHR :: BindImageMemoryDeviceGroupInfo; BindImageMemoryDeviceGroupInfoKHR :: BindImageMemoryDeviceGroupInfo
CommandPoolTrimFlagsKHR :: CommandPoolTrimFlags; CommandPoolTrimFlagsKHR :: CommandPoolTrimFlags
PhysicalDeviceGroupPropertiesKHR :: PhysicalDeviceGroupProperties; PhysicalDeviceGroupPropertiesKHR :: PhysicalDeviceGroupProperties
DeviceGroupDeviceCreateInfoKHR :: DeviceGroupDeviceCreateInfo; DeviceGroupDeviceCreateInfoKHR :: DeviceGroupDeviceCreateInfo
ExternalMemoryHandleTypeFlagsKHR :: ExternalMemoryHandleTypeFlags; ExternalMemoryHandleTypeFlagsKHR :: ExternalMemoryHandleTypeFlags
ExternalMemoryHandleTypeFlagKHR :: ExternalMemoryHandleTypeFlag; ExternalMemoryHandleTypeFlagKHR :: ExternalMemoryHandleTypeFlag
ExternalMemoryFeatureFlagsKHR :: ExternalMemoryFeatureFlags; ExternalMemoryFeatureFlagsKHR :: ExternalMemoryFeatureFlags
ExternalMemoryFeatureFlagKHR :: ExternalMemoryFeatureFlag; ExternalMemoryFeatureFlagKHR :: ExternalMemoryFeatureFlag
ExternalMemoryPropertiesKHR :: ExternalMemoryProperties; ExternalMemoryPropertiesKHR :: ExternalMemoryProperties
PhysicalDeviceExternalImageFormatInfoKHR :: PhysicalDeviceExternalImageFormatInfo; PhysicalDeviceExternalImageFormatInfoKHR :: PhysicalDeviceExternalImageFormatInfo
ExternalImageFormatPropertiesKHR :: ExternalImageFormatProperties; ExternalImageFormatPropertiesKHR :: ExternalImageFormatProperties
PhysicalDeviceExternalBufferInfoKHR :: PhysicalDeviceExternalBufferInfo; PhysicalDeviceExternalBufferInfoKHR :: PhysicalDeviceExternalBufferInfo
ExternalBufferPropertiesKHR :: ExternalBufferProperties; ExternalBufferPropertiesKHR :: ExternalBufferProperties
PhysicalDeviceIDPropertiesKHR :: PhysicalDeviceIDProperties; PhysicalDeviceIDPropertiesKHR :: PhysicalDeviceIDProperties
ExternalMemoryImageCreateInfoKHR :: ExternalMemoryImageCreateInfo; ExternalMemoryImageCreateInfoKHR :: ExternalMemoryImageCreateInfo
ExternalMemoryBufferCreateInfoKHR :: ExternalMemoryBufferCreateInfo; ExternalMemoryBufferCreateInfoKHR :: ExternalMemoryBufferCreateInfo
ExportMemoryAllocateInfoKHR :: ExportMemoryAllocateInfo; ExportMemoryAllocateInfoKHR :: ExportMemoryAllocateInfo
ExternalSemaphoreHandleTypeFlagsKHR :: ExternalSemaphoreHandleTypeFlags; ExternalSemaphoreHandleTypeFlagsKHR :: ExternalSemaphoreHandleTypeFlags
ExternalSemaphoreHandleTypeFlagKHR :: ExternalSemaphoreHandleTypeFlag; ExternalSemaphoreHandleTypeFlagKHR :: ExternalSemaphoreHandleTypeFlag
ExternalSemaphoreFeatureFlagsKHR :: ExternalSemaphoreFeatureFlags; ExternalSemaphoreFeatureFlagsKHR :: ExternalSemaphoreFeatureFlags
ExternalSemaphoreFeatureFlagKHR :: ExternalSemaphoreFeatureFlag; ExternalSemaphoreFeatureFlagKHR :: ExternalSemaphoreFeatureFlag
PhysicalDeviceExternalSemaphoreInfoKHR :: PhysicalDeviceExternalSemaphoreInfo; PhysicalDeviceExternalSemaphoreInfoKHR :: PhysicalDeviceExternalSemaphoreInfo
ExternalSemaphorePropertiesKHR :: ExternalSemaphoreProperties; ExternalSemaphorePropertiesKHR :: ExternalSemaphoreProperties
SemaphoreImportFlagsKHR :: SemaphoreImportFlags; SemaphoreImportFlagsKHR :: SemaphoreImportFlags
SemaphoreImportFlagKHR :: SemaphoreImportFlag; SemaphoreImportFlagKHR :: SemaphoreImportFlag
ExportSemaphoreCreateInfoKHR :: ExportSemaphoreCreateInfo; ExportSemaphoreCreateInfoKHR :: ExportSemaphoreCreateInfo
PhysicalDeviceShaderFloat16Int8FeaturesKHR :: PhysicalDeviceShaderFloat16Int8Features; PhysicalDeviceShaderFloat16Int8FeaturesKHR :: PhysicalDeviceShaderFloat16Int8Features
PhysicalDeviceFloat16Int8FeaturesKHR :: PhysicalDeviceShaderFloat16Int8Features; PhysicalDeviceFloat16Int8FeaturesKHR :: PhysicalDeviceShaderFloat16Int8Features
PhysicalDevice16BitStorageFeaturesKHR :: PhysicalDevice16BitStorageFeatures; PhysicalDevice16BitStorageFeaturesKHR :: PhysicalDevice16BitStorageFeatures
DescriptorUpdateTemplateKHR :: DescriptorUpdateTemplate; DescriptorUpdateTemplateKHR :: DescriptorUpdateTemplate
DescriptorUpdateTemplateTypeKHR :: DescriptorUpdateTemplateType; DescriptorUpdateTemplateTypeKHR :: DescriptorUpdateTemplateType
DescriptorUpdateTemplateCreateFlagsKHR :: DescriptorUpdateTemplateCreateFlags; DescriptorUpdateTemplateCreateFlagsKHR :: DescriptorUpdateTemplateCreateFlags
DescriptorUpdateTemplateEntryKHR :: DescriptorUpdateTemplateEntry; DescriptorUpdateTemplateEntryKHR :: DescriptorUpdateTemplateEntry
DescriptorUpdateTemplateCreateInfoKHR :: DescriptorUpdateTemplateCreateInfo; DescriptorUpdateTemplateCreateInfoKHR :: DescriptorUpdateTemplateCreateInfo
PhysicalDeviceImagelessFramebufferFeaturesKHR :: PhysicalDeviceImagelessFramebufferFeatures; PhysicalDeviceImagelessFramebufferFeaturesKHR :: PhysicalDeviceImagelessFramebufferFeatures
FramebufferAttachmentsCreateInfoKHR :: FramebufferAttachmentsCreateInfo; FramebufferAttachmentsCreateInfoKHR :: FramebufferAttachmentsCreateInfo
FramebufferAttachmentImageInfoKHR :: FramebufferAttachmentImageInfo; FramebufferAttachmentImageInfoKHR :: FramebufferAttachmentImageInfo
RenderPassAttachmentBeginInfoKHR :: RenderPassAttachmentBeginInfo; RenderPassAttachmentBeginInfoKHR :: RenderPassAttachmentBeginInfo
RenderPassCreateInfo2KHR :: RenderPassCreateInfo2; RenderPassCreateInfo2KHR :: RenderPassCreateInfo2
AttachmentDescription2KHR :: AttachmentDescription2; AttachmentDescription2KHR :: AttachmentDescription2
AttachmentReference2KHR :: AttachmentReference2; AttachmentReference2KHR :: AttachmentReference2
SubpassDescription2KHR :: SubpassDescription2; SubpassDescription2KHR :: SubpassDescription2
SubpassDependency2KHR :: SubpassDependency2; SubpassDependency2KHR :: SubpassDependency2
SubpassBeginInfoKHR :: SubpassBeginInfo; SubpassBeginInfoKHR :: SubpassBeginInfo
SubpassEndInfoKHR :: SubpassEndInfo; SubpassEndInfoKHR :: SubpassEndInfo
ExternalFenceHandleTypeFlagsKHR :: ExternalFenceHandleTypeFlags; ExternalFenceHandleTypeFlagsKHR :: ExternalFenceHandleTypeFlags
ExternalFenceHandleTypeFlagKHR :: ExternalFenceHandleTypeFlag; ExternalFenceHandleTypeFlagKHR :: ExternalFenceHandleTypeFlag
ExternalFenceFeatureFlagsKHR :: ExternalFenceFeatureFlags; ExternalFenceFeatureFlagsKHR :: ExternalFenceFeatureFlags
ExternalFenceFeatureFlagKHR :: ExternalFenceFeatureFlag; ExternalFenceFeatureFlagKHR :: ExternalFenceFeatureFlag
PhysicalDeviceExternalFenceInfoKHR :: PhysicalDeviceExternalFenceInfo; PhysicalDeviceExternalFenceInfoKHR :: PhysicalDeviceExternalFenceInfo
ExternalFencePropertiesKHR :: ExternalFenceProperties; ExternalFencePropertiesKHR :: ExternalFenceProperties
FenceImportFlagsKHR :: FenceImportFlags; FenceImportFlagsKHR :: FenceImportFlags
FenceImportFlagKHR :: FenceImportFlag; FenceImportFlagKHR :: FenceImportFlag
ExportFenceCreateInfoKHR :: ExportFenceCreateInfo; ExportFenceCreateInfoKHR :: ExportFenceCreateInfo
PointClippingBehaviorKHR :: PointClippingBehavior; PointClippingBehaviorKHR :: PointClippingBehavior
TessellationDomainOriginKHR :: TessellationDomainOrigin; TessellationDomainOriginKHR :: TessellationDomainOrigin
PhysicalDevicePointClippingPropertiesKHR :: PhysicalDevicePointClippingProperties; PhysicalDevicePointClippingPropertiesKHR :: PhysicalDevicePointClippingProperties
RenderPassInputAttachmentAspectCreateInfoKHR :: RenderPassInputAttachmentAspectCreateInfo; RenderPassInputAttachmentAspectCreateInfoKHR :: RenderPassInputAttachmentAspectCreateInfo
InputAttachmentAspectReferenceKHR :: InputAttachmentAspectReference; InputAttachmentAspectReferenceKHR :: InputAttachmentAspectReference
ImageViewUsageCreateInfoKHR :: ImageViewUsageCreateInfo; ImageViewUsageCreateInfoKHR :: ImageViewUsageCreateInfo
PipelineTessellationDomainOriginStateCreateInfoKHR :: PipelineTessellationDomainOriginStateCreateInfo; PipelineTessellationDomainOriginStateCreateInfoKHR :: PipelineTessellationDomainOriginStateCreateInfo
PhysicalDeviceVariablePointerFeaturesKHR :: PhysicalDeviceVariablePointersFeatures; PhysicalDeviceVariablePointerFeaturesKHR :: PhysicalDeviceVariablePointersFeatures
PhysicalDeviceVariablePointersFeaturesKHR :: PhysicalDeviceVariablePointersFeatures; PhysicalDeviceVariablePointersFeaturesKHR :: PhysicalDeviceVariablePointersFeatures
MemoryDedicatedRequirementsKHR :: MemoryDedicatedRequirements; MemoryDedicatedRequirementsKHR :: MemoryDedicatedRequirements
MemoryDedicatedAllocateInfoKHR :: MemoryDedicatedAllocateInfo; MemoryDedicatedAllocateInfoKHR :: MemoryDedicatedAllocateInfo
BufferMemoryRequirementsInfo2KHR :: BufferMemoryRequirementsInfo2; BufferMemoryRequirementsInfo2KHR :: BufferMemoryRequirementsInfo2
ImageMemoryRequirementsInfo2KHR :: ImageMemoryRequirementsInfo2; ImageMemoryRequirementsInfo2KHR :: ImageMemoryRequirementsInfo2
ImageSparseMemoryRequirementsInfo2KHR :: ImageSparseMemoryRequirementsInfo2; ImageSparseMemoryRequirementsInfo2KHR :: ImageSparseMemoryRequirementsInfo2
MemoryRequirements2KHR :: MemoryRequirements2; MemoryRequirements2KHR :: MemoryRequirements2
SparseImageMemoryRequirements2KHR :: SparseImageMemoryRequirements2; SparseImageMemoryRequirements2KHR :: SparseImageMemoryRequirements2
ImageFormatListCreateInfoKHR :: ImageFormatListCreateInfo; ImageFormatListCreateInfoKHR :: ImageFormatListCreateInfo
SamplerYcbcrConversionKHR :: SamplerYcbcrConversion; SamplerYcbcrConversionKHR :: SamplerYcbcrConversion
SamplerYcbcrModelConversionKHR :: SamplerYcbcrModelConversion; SamplerYcbcrModelConversionKHR :: SamplerYcbcrModelConversion
SamplerYcbcrRangeKHR :: SamplerYcbcrRange; SamplerYcbcrRangeKHR :: SamplerYcbcrRange
ChromaLocationKHR :: ChromaLocation; ChromaLocationKHR :: ChromaLocation
SamplerYcbcrConversionCreateInfoKHR :: SamplerYcbcrConversionCreateInfo; SamplerYcbcrConversionCreateInfoKHR :: SamplerYcbcrConversionCreateInfo
SamplerYcbcrConversionInfoKHR :: SamplerYcbcrConversionInfo; SamplerYcbcrConversionInfoKHR :: SamplerYcbcrConversionInfo
BindImagePlaneMemoryInfoKHR :: BindImagePlaneMemoryInfo; BindImagePlaneMemoryInfoKHR :: BindImagePlaneMemoryInfo
ImagePlaneMemoryRequirementsInfoKHR :: ImagePlaneMemoryRequirementsInfo; ImagePlaneMemoryRequirementsInfoKHR :: ImagePlaneMemoryRequirementsInfo
PhysicalDeviceSamplerYcbcrConversionFeaturesKHR :: PhysicalDeviceSamplerYcbcrConversionFeatures; PhysicalDeviceSamplerYcbcrConversionFeaturesKHR :: PhysicalDeviceSamplerYcbcrConversionFeatures
SamplerYcbcrConversionImageFormatPropertiesKHR :: SamplerYcbcrConversionImageFormatProperties; SamplerYcbcrConversionImageFormatPropertiesKHR :: SamplerYcbcrConversionImageFormatProperties
BindBufferMemoryInfoKHR :: BindBufferMemoryInfo; BindBufferMemoryInfoKHR :: BindBufferMemoryInfo
BindImageMemoryInfoKHR :: BindImageMemoryInfo; BindImageMemoryInfoKHR :: BindImageMemoryInfo
PhysicalDeviceMaintenance3PropertiesKHR :: PhysicalDeviceMaintenance3Properties; PhysicalDeviceMaintenance3PropertiesKHR :: PhysicalDeviceMaintenance3Properties
DescriptorSetLayoutSupportKHR :: DescriptorSetLayoutSupport; DescriptorSetLayoutSupportKHR :: DescriptorSetLayoutSupport
PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR :: PhysicalDeviceShaderSubgroupExtendedTypesFeatures; PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR :: PhysicalDeviceShaderSubgroupExtendedTypesFeatures
PhysicalDevice8BitStorageFeaturesKHR :: PhysicalDevice8BitStorageFeatures; PhysicalDevice8BitStorageFeaturesKHR :: PhysicalDevice8BitStorageFeatures
PhysicalDeviceShaderAtomicInt64FeaturesKHR :: PhysicalDeviceShaderAtomicInt64Features; PhysicalDeviceShaderAtomicInt64FeaturesKHR :: PhysicalDeviceShaderAtomicInt64Features
DriverIdKHR :: DriverId; DriverIdKHR :: DriverId
ConformanceVersionKHR :: ConformanceVersion; ConformanceVersionKHR :: ConformanceVersion
PhysicalDeviceDriverPropertiesKHR :: PhysicalDeviceDriverProperties; PhysicalDeviceDriverPropertiesKHR :: PhysicalDeviceDriverProperties
ShaderFloatControlsIndependenceKHR :: ShaderFloatControlsIndependence; ShaderFloatControlsIndependenceKHR :: ShaderFloatControlsIndependence
PhysicalDeviceFloatControlsPropertiesKHR :: PhysicalDeviceFloatControlsProperties; PhysicalDeviceFloatControlsPropertiesKHR :: PhysicalDeviceFloatControlsProperties
ResolveModeFlagKHR :: ResolveModeFlag; ResolveModeFlagKHR :: ResolveModeFlag
ResolveModeFlagsKHR :: ResolveModeFlags; ResolveModeFlagsKHR :: ResolveModeFlags
SubpassDescriptionDepthStencilResolveKHR :: SubpassDescriptionDepthStencilResolve; SubpassDescriptionDepthStencilResolveKHR :: SubpassDescriptionDepthStencilResolve
PhysicalDeviceDepthStencilResolvePropertiesKHR :: PhysicalDeviceDepthStencilResolveProperties; PhysicalDeviceDepthStencilResolvePropertiesKHR :: PhysicalDeviceDepthStencilResolveProperties
SemaphoreTypeKHR :: SemaphoreType; SemaphoreTypeKHR :: SemaphoreType
SemaphoreWaitFlagKHR :: SemaphoreWaitFlag; SemaphoreWaitFlagKHR :: SemaphoreWaitFlag
SemaphoreWaitFlagsKHR :: SemaphoreWaitFlags; SemaphoreWaitFlagsKHR :: SemaphoreWaitFlags
PhysicalDeviceTimelineSemaphoreFeaturesKHR :: PhysicalDeviceTimelineSemaphoreFeatures; PhysicalDeviceTimelineSemaphoreFeaturesKHR :: PhysicalDeviceTimelineSemaphoreFeatures
PhysicalDeviceTimelineSemaphorePropertiesKHR :: PhysicalDeviceTimelineSemaphoreProperties; PhysicalDeviceTimelineSemaphorePropertiesKHR :: PhysicalDeviceTimelineSemaphoreProperties
SemaphoreTypeCreateInfoKHR :: SemaphoreTypeCreateInfo; SemaphoreTypeCreateInfoKHR :: SemaphoreTypeCreateInfo
TimelineSemaphoreSubmitInfoKHR :: TimelineSemaphoreSubmitInfo; TimelineSemaphoreSubmitInfoKHR :: TimelineSemaphoreSubmitInfo
SemaphoreWaitInfoKHR :: SemaphoreWaitInfo; SemaphoreWaitInfoKHR :: SemaphoreWaitInfo
SemaphoreSignalInfoKHR :: SemaphoreSignalInfo; SemaphoreSignalInfoKHR :: SemaphoreSignalInfo
PhysicalDeviceVulkanMemoryModelFeaturesKHR :: PhysicalDeviceVulkanMemoryModelFeatures; PhysicalDeviceVulkanMemoryModelFeaturesKHR :: PhysicalDeviceVulkanMemoryModelFeatures
PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR :: PhysicalDeviceSeparateDepthStencilLayoutsFeatures; PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR :: PhysicalDeviceSeparateDepthStencilLayoutsFeatures
AttachmentReferenceStencilLayoutKHR :: AttachmentReferenceStencilLayout; AttachmentReferenceStencilLayoutKHR :: AttachmentReferenceStencilLayout
AttachmentDescriptionStencilLayoutKHR :: AttachmentDescriptionStencilLayout; AttachmentDescriptionStencilLayoutKHR :: AttachmentDescriptionStencilLayout
PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR :: PhysicalDeviceUniformBufferStandardLayoutFeatures; PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR :: PhysicalDeviceUniformBufferStandardLayoutFeatures
PhysicalDeviceBufferDeviceAddressFeaturesKHR :: PhysicalDeviceBufferDeviceAddressFeatures; PhysicalDeviceBufferDeviceAddressFeaturesKHR :: PhysicalDeviceBufferDeviceAddressFeatures
BufferDeviceAddressInfoKHR :: BufferDeviceAddressInfo; BufferDeviceAddressInfoKHR :: BufferDeviceAddressInfo
BufferOpaqueCaptureAddressCreateInfoKHR :: BufferOpaqueCaptureAddressCreateInfo; BufferOpaqueCaptureAddressCreateInfoKHR :: BufferOpaqueCaptureAddressCreateInfo
MemoryOpaqueCaptureAddressAllocateInfoKHR :: MemoryOpaqueCaptureAddressAllocateInfo; MemoryOpaqueCaptureAddressAllocateInfoKHR :: MemoryOpaqueCaptureAddressAllocateInfo
DeviceMemoryOpaqueCaptureAddressInfoKHR :: DeviceMemoryOpaqueCaptureAddressInfo; DeviceMemoryOpaqueCaptureAddressInfoKHR :: DeviceMemoryOpaqueCaptureAddressInfo
PipelineStageFlags2KHR :: Flags64; PipelineStageFlags2KHR :: Flags64
PipelineStageFlag2KHR :: Flags64; PipelineStageFlag2KHR :: Flags64
AccessFlags2KHR :: Flags64; AccessFlags2KHR :: Flags64
AccessFlag2KHR :: Flags64; AccessFlag2KHR :: Flags64
SamplerReductionModeEXT :: SamplerReductionMode; SamplerReductionModeEXT :: SamplerReductionMode
SamplerReductionModeCreateInfoEXT :: SamplerReductionModeCreateInfo; SamplerReductionModeCreateInfoEXT :: SamplerReductionModeCreateInfo
PhysicalDeviceSamplerFilterMinmaxPropertiesEXT :: PhysicalDeviceSamplerFilterMinmaxProperties; PhysicalDeviceSamplerFilterMinmaxPropertiesEXT :: PhysicalDeviceSamplerFilterMinmaxProperties
DescriptorBindingFlagEXT :: DescriptorBindingFlag; DescriptorBindingFlagEXT :: DescriptorBindingFlag
DescriptorBindingFlagsEXT :: DescriptorBindingFlags; DescriptorBindingFlagsEXT :: DescriptorBindingFlags
DescriptorSetLayoutBindingFlagsCreateInfoEXT :: DescriptorSetLayoutBindingFlagsCreateInfo; DescriptorSetLayoutBindingFlagsCreateInfoEXT :: DescriptorSetLayoutBindingFlagsCreateInfo
PhysicalDeviceDescriptorIndexingFeaturesEXT :: PhysicalDeviceDescriptorIndexingFeatures; PhysicalDeviceDescriptorIndexingFeaturesEXT :: PhysicalDeviceDescriptorIndexingFeatures
PhysicalDeviceDescriptorIndexingPropertiesEXT :: PhysicalDeviceDescriptorIndexingProperties; PhysicalDeviceDescriptorIndexingPropertiesEXT :: PhysicalDeviceDescriptorIndexingProperties
DescriptorSetVariableDescriptorCountAllocateInfoEXT :: DescriptorSetVariableDescriptorCountAllocateInfo; DescriptorSetVariableDescriptorCountAllocateInfoEXT :: DescriptorSetVariableDescriptorCountAllocateInfo
DescriptorSetVariableDescriptorCountLayoutSupportEXT :: DescriptorSetVariableDescriptorCountLayoutSupport; DescriptorSetVariableDescriptorCountLayoutSupportEXT :: DescriptorSetVariableDescriptorCountLayoutSupport
RayTracingShaderGroupTypeNV :: RayTracingShaderGroupTypeKHR; RayTracingShaderGroupTypeNV :: RayTracingShaderGroupTypeKHR
GeometryTypeNV :: GeometryTypeKHR; GeometryTypeNV :: GeometryTypeKHR
AccelerationStructureTypeNV :: AccelerationStructureTypeKHR; AccelerationStructureTypeNV :: AccelerationStructureTypeKHR
CopyAccelerationStructureModeNV :: CopyAccelerationStructureModeKHR; CopyAccelerationStructureModeNV :: CopyAccelerationStructureModeKHR
GeometryFlagsNV :: GeometryFlagsKHR; GeometryFlagsNV :: GeometryFlagsKHR
GeometryFlagNV :: GeometryFlagKHR; GeometryFlagNV :: GeometryFlagKHR
GeometryInstanceFlagsNV :: GeometryInstanceFlagsKHR; GeometryInstanceFlagsNV :: GeometryInstanceFlagsKHR
GeometryInstanceFlagNV :: GeometryInstanceFlagKHR; GeometryInstanceFlagNV :: GeometryInstanceFlagKHR
BuildAccelerationStructureFlagsNV :: BuildAccelerationStructureFlagsKHR; BuildAccelerationStructureFlagsNV :: BuildAccelerationStructureFlagsKHR
BuildAccelerationStructureFlagNV :: BuildAccelerationStructureFlagKHR; BuildAccelerationStructureFlagNV :: BuildAccelerationStructureFlagKHR
TransformMatrixNV :: TransformMatrixKHR; TransformMatrixNV :: TransformMatrixKHR
AabbPositionsNV :: AabbPositionsKHR; AabbPositionsNV :: AabbPositionsKHR
AccelerationStructureInstanceNV :: AccelerationStructureInstanceKHR; AccelerationStructureInstanceNV :: AccelerationStructureInstanceKHR
QueryPoolCreateInfoINTEL :: QueryPoolPerformanceQueryCreateInfoINTEL; QueryPoolCreateInfoINTEL :: QueryPoolPerformanceQueryCreateInfoINTEL
PhysicalDeviceScalarBlockLayoutFeaturesEXT :: PhysicalDeviceScalarBlockLayoutFeatures; PhysicalDeviceScalarBlockLayoutFeaturesEXT :: PhysicalDeviceScalarBlockLayoutFeatures
PhysicalDeviceBufferAddressFeaturesEXT :: PhysicalDeviceBufferDeviceAddressFeaturesEXT; PhysicalDeviceBufferAddressFeaturesEXT :: PhysicalDeviceBufferDeviceAddressFeaturesEXT
BufferDeviceAddressInfoEXT :: BufferDeviceAddressInfo; BufferDeviceAddressInfoEXT :: BufferDeviceAddressInfo
ImageStencilUsageCreateInfoEXT :: ImageStencilUsageCreateInfo; ImageStencilUsageCreateInfoEXT :: ImageStencilUsageCreateInfo
PhysicalDeviceHostQueryResetFeaturesEXT :: PhysicalDeviceHostQueryResetFeatures; PhysicalDeviceHostQueryResetFeaturesEXT :: PhysicalDeviceHostQueryResetFeatures