diff --git a/build.bat b/build.bat index 2fb8b9bc7..430b4a35e 100644 --- a/build.bat +++ b/build.bat @@ -16,7 +16,7 @@ if %release_mode% EQU 0 ( rem Debug ) set compiler_warnings= ^ - -we4002 -we4013 -we4020 -we4024 -we4029 -we4031 -we4047 -we4133 -we4706 ^ + -we4002 -we4013 -we4020 -we4024 -we4029 -we4031 -we4047 -we4133 -we4706 -we4715 ^ -wd4100 -wd4101 -wd4127 -wd4189 ^ -wd4201 -wd4204 -wd4244 ^ -wd4306 ^ diff --git a/code/demo.odin b/code/demo.odin index 0e5c215ad..fb7f48b33 100644 --- a/code/demo.odin +++ b/code/demo.odin @@ -1,18 +1,8 @@ -#import "fmt.odin"; - -A :: type struct { - b: B; -}; -B :: type struct { - c: C; -}; -C :: type struct { - a: A; -}; +#import "fmt.odin" main :: proc() { - fmt.println(size_of(A)); - fmt.println(size_of(B)); - fmt.println(size_of(C)); + if true { + + } } diff --git a/code/http_test.odin b/code/http_test.odin index 09c6d0899..9048cfd63 100644 --- a/code/http_test.odin +++ b/code/http_test.odin @@ -1,10 +1,10 @@ -#import "fmt.odin"; +#import "fmt.odin" -#foreign_system_library "Ws2_32" when ODIN_OS == "windows"; +#foreign_system_library "Ws2_32" when ODIN_OS == "windows" -SOCKET :: type uint; -INVALID_SOCKET :: ~(0 as SOCKET); +SOCKET :: type uint +INVALID_SOCKET :: ~(0 as SOCKET) AF :: enum i32 { UNSPEC = 0, // unspecified @@ -37,45 +37,45 @@ AF :: enum i32 { MAX = 26, } -SOCK_STREAM :: 1; -SOCKET_ERROR :: -1; -IPPROTO_TCP :: 6; -AI_PASSIVE :: 0x0020; -SOMAXCONN :: 128; +SOCK_STREAM :: 1 +SOCKET_ERROR :: -1 +IPPROTO_TCP :: 6 +AI_PASSIVE :: 0x0020 +SOMAXCONN :: 128 -SD_RECEIVE :: 0; -SD_SEND :: 1; -SD_BOTH :: 2; +SD_RECEIVE :: 0 +SD_SEND :: 1 +SD_BOTH :: 2 -WSADESCRIPTION_LEN :: 256; -WSASYS_STATUS_LEN :: 128; +WSADESCRIPTION_LEN :: 256 +WSASYS_STATUS_LEN :: 128 WSADATA :: struct #ordered { - version: i16; - high_version: i16; + version: i16 + high_version: i16 // NOTE(bill): This is x64 ordering - max_sockets: u16; - max_udp_dg: u16; - vendor_info: ^byte; - description: [WSADESCRIPTION_LEN+1]byte; - system_status: [WSASYS_STATUS_LEN+1]byte; + max_sockets: u16 + max_udp_dg: u16 + vendor_info: ^byte + description: [WSADESCRIPTION_LEN+1]byte + system_status: [WSASYS_STATUS_LEN+1]byte } addrinfo :: struct #ordered { - flags: i32; - family: i32; - socktype: i32; - protocol: i32; - addrlen: uint; - canonname: ^u8; - addr: ^sockaddr; - next: ^addrinfo; + flags: i32 + family: i32 + socktype: i32 + protocol: i32 + addrlen: uint + canonname: ^u8 + addr: ^sockaddr + next: ^addrinfo } sockaddr :: struct #ordered { - family: u16; - data: [14]byte; + family: u16 + data: [14]byte } @@ -94,52 +94,52 @@ shutdown :: proc(s: SOCKET, how: i32) -> i32 WSAGetLastError :: proc() -> i32 #foreign #dll_import to_c_string :: proc(s: string) -> ^byte { - c_str := new_slice(byte, s.count+1); - assert(c_str.data != nil); - copy(c_str, s as []byte); - c_str[s.count] = 0; - return c_str.data; + c_str := new_slice(byte, s.count+1) + assert(c_str.data != nil) + copy(c_str, s as []byte) + c_str[s.count] = 0 + return c_str.data } run :: proc() { - wsa: WSADATA; - res: ^addrinfo = nil; - hints: addrinfo; - s, client: SOCKET; + wsa: WSADATA + res: ^addrinfo = nil + hints: addrinfo + s, client: SOCKET if WSAStartup(2 | (2 << 8), ^wsa) != 0 { - fmt.println("WSAStartup failed: ", WSAGetLastError()); - return; + fmt.println("WSAStartup failed: ", WSAGetLastError()) + return } - defer WSACleanup(); + defer WSACleanup() - hints.family = AF.INET as i32; - hints.socktype = SOCK_STREAM; - hints.protocol = IPPROTO_TCP; - hints.flags = AI_PASSIVE; + hints.family = AF.INET as i32 + hints.socktype = SOCK_STREAM + hints.protocol = IPPROTO_TCP + hints.flags = AI_PASSIVE if getaddrinfo(nil, to_c_string("8080"), ^hints, ^res) != 0 { - fmt.println("getaddrinfo failed: ", WSAGetLastError()); - return; + fmt.println("getaddrinfo failed: ", WSAGetLastError()) + return } - defer freeaddrinfo(res); + defer freeaddrinfo(res) - s = socket(res.family, res.socktype, res.protocol); + s = socket(res.family, res.socktype, res.protocol) if s == INVALID_SOCKET { - fmt.println("socket failed: ", WSAGetLastError()); - return; + fmt.println("socket failed: ", WSAGetLastError()) + return } - defer closesocket(s); + defer closesocket(s) - bind(s, res.addr, res.addrlen as i32); - listen(s, SOMAXCONN); + bind(s, res.addr, res.addrlen as i32) + listen(s, SOMAXCONN) - client = accept(s, nil, 0); + client = accept(s, nil, 0) if client == INVALID_SOCKET { - fmt.println("socket failed: ", WSAGetLastError()); - return; + fmt.println("socket failed: ", WSAGetLastError()) + return } - defer closesocket(client); + defer closesocket(client) html := `HTTP/1.1 200 OK @@ -154,27 +154,27 @@ Content-type: text/html

Odin Server Demo

-`; +` - buf: [1024]byte; + buf: [1024]byte for { - bytes := recv(client, ^buf[0], buf.count as i32, 0); + bytes := recv(client, ^buf[0], buf.count as i32, 0) if bytes > 0 { - // fmt.println(buf[:bytes] as string); - bytes_sent := send(client, html.data, (html.count-1) as i32, 0); + // fmt.println(buf[:bytes] as string) + bytes_sent := send(client, html.data, (html.count-1) as i32, 0) if bytes_sent == SOCKET_ERROR { - fmt.println("send failed: ", WSAGetLastError()); - return; + fmt.println("send failed: ", WSAGetLastError()) + return } - break; + break } else if bytes == 0 { - fmt.println("Connection closing..."); - break; + fmt.println("Connection closing...") + break } else { - fmt.println("recv failed: ", WSAGetLastError()); - return; + fmt.println("recv failed: ", WSAGetLastError()) + return } } - shutdown(client, SD_SEND); + shutdown(client, SD_SEND) } diff --git a/code/punity.odin b/code/punity.odin index 83d22854f..fb93189ec 100644 --- a/code/punity.odin +++ b/code/punity.odin @@ -1,34 +1,34 @@ -#import "win32.odin"; -#import "fmt.odin"; -#import "os.odin"; +#import "win32.odin" +#import "fmt.odin" +#import "os.odin" -CANVAS_WIDTH :: 128; -CANVAS_HEIGHT :: 128; -CANVAS_SCALE :: 3; -FRAME_TIME :: 1.0/30.0; -WINDOW_TITLE :: "Punity\x00"; +CANVAS_WIDTH :: 128 +CANVAS_HEIGHT :: 128 +CANVAS_SCALE :: 3 +FRAME_TIME :: 1.0/30.0 +WINDOW_TITLE :: "Punity\x00" -_ := compile_assert(CANVAS_WIDTH % 16 == 0); +_ := compile_assert(CANVAS_WIDTH % 16 == 0) -WINDOW_WIDTH :: CANVAS_WIDTH * CANVAS_SCALE; -WINDOW_HEIGHT :: CANVAS_HEIGHT * CANVAS_SCALE; +WINDOW_WIDTH :: CANVAS_WIDTH * CANVAS_SCALE +WINDOW_HEIGHT :: CANVAS_HEIGHT * CANVAS_SCALE -STACK_CAPACITY :: 1<<20; -STORAGE_CAPACITY :: 1<<20; +STACK_CAPACITY :: 1<<20 +STORAGE_CAPACITY :: 1<<20 -DRAW_LIST_RESERVE :: 128; +DRAW_LIST_RESERVE :: 128 -MAX_KEYS :: 256; +MAX_KEYS :: 256 Core :: struct { - stack: ^Bank; - storage: ^Bank; + stack: ^Bank + storage: ^Bank - running: bool; - key_modifiers: u32; - key_states: [MAX_KEYS]byte; - key_deltas: [MAX_KEYS]byte; + running: bool + key_modifiers: u32 + key_states: [MAX_KEYS]byte + key_deltas: [MAX_KEYS]byte perf_frame, perf_frame_inner, @@ -36,70 +36,70 @@ Core :: struct { perf_audio, perf_blit, perf_blit_cvt, - perf_blit_gdi: Perf_Span; + perf_blit_gdi: Perf_Span - frame: i64; + frame: i64 - canvas: Canvas; - draw_list: ^Draw_List; + canvas: Canvas + draw_list: ^Draw_List } Perf_Span :: struct { - stamp: f64; - delta: f32; + stamp: f64 + delta: f32 } Bank :: struct { - memory: []byte; - cursor: int; + memory: []byte + cursor: int } Bank_State :: struct { - state: Bank; - bank: ^Bank; + state: Bank + bank: ^Bank } Color :: raw_union { - using channels: struct{ a, b, g, r: byte; }; - rgba: u32; + using channels: struct{ a, b, g, r: byte; } + rgba: u32 } Palette :: struct { - colors: [256]Color; - colors_count: byte; + colors: [256]Color + colors_count: byte } Rect :: raw_union { using minmax: struct { - min_x, min_y, max_x, max_y: int; - }; + min_x, min_y, max_x, max_y: int + } using pos: struct { - left, top, right, bottom: int; - }; - e: [4]int; + left, top, right, bottom: int + } + e: [4]int } Bitmap :: struct { - pixels: []byte; - width: int; - height: int; + pixels: []byte + width: int + height: int } Font :: struct { - using bitmap: Bitmap; - char_width: int; - char_height: int; + using bitmap: Bitmap + char_width: int + char_height: int } Canvas :: struct { - using bitmap: ^Bitmap; - palette: Palette; - translate_x: int; - translate_y: int; - clip: Rect; - font: ^Font; + using bitmap: ^Bitmap + palette: Palette + translate_x: int + translate_y: int + clip: Rect + font: ^Font } DrawFlag :: enum { @@ -114,7 +114,7 @@ Draw_List :: struct { Item :: struct { } - items: []Item; + items: []Item } Key :: enum { @@ -272,77 +272,77 @@ Key :: enum { key_down :: proc(k: Key) -> bool { - return _core.key_states[k] != 0; + return _core.key_states[k] != 0 } key_pressed :: proc(k: Key) -> bool { - return (_core.key_deltas[k] != 0) && key_down(k); + return (_core.key_deltas[k] != 0) && key_down(k) } -win32_perf_count_freq := win32.GetQueryPerformanceFrequency(); +win32_perf_count_freq := win32.GetQueryPerformanceFrequency() time_now :: proc() -> f64 { - assert(win32_perf_count_freq != 0); + assert(win32_perf_count_freq != 0) - counter: i64; - win32.QueryPerformanceCounter(^counter); - result := counter as f64 / win32_perf_count_freq as f64; - return result; + counter: i64 + win32.QueryPerformanceCounter(^counter) + result := counter as f64 / win32_perf_count_freq as f64 + return result } -_core: Core; +_core: Core run :: proc(user_init, user_step: proc(c: ^Core)) { - using win32; + using win32 - _core.running = true; + _core.running = true win32_proc :: proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT #no_inline #stdcall { win32_app_key_mods :: proc() -> u32 { - mods: u32 = 0; + mods: u32 = 0 if is_key_down(Key_Code.SHIFT) { - mods |= Key.MOD_SHIFT as u32; + mods |= Key.MOD_SHIFT as u32 } if is_key_down(Key_Code.CONTROL) { - mods |= Key.MOD_CONTROL as u32; + mods |= Key.MOD_CONTROL as u32 } if is_key_down(Key_Code.MENU) { - mods |= Key.MOD_ALT as u32; + mods |= Key.MOD_ALT as u32 } if is_key_down(Key_Code.LWIN) || is_key_down(Key_Code.RWIN) { - mods |= Key.MOD_SUPER as u32; + mods |= Key.MOD_SUPER as u32 } - return mods; + return mods } match msg { case WM_KEYDOWN: - _core.key_modifiers = win32_app_key_mods(); + _core.key_modifiers = win32_app_key_mods() if wparam < MAX_KEYS { - _core.key_states[wparam] = 1; - _core.key_deltas[wparam] = 1; + _core.key_states[wparam] = 1 + _core.key_deltas[wparam] = 1 } - return 0; + return 0 case WM_KEYUP: - _core.key_modifiers = win32_app_key_mods(); + _core.key_modifiers = win32_app_key_mods() if wparam < MAX_KEYS { - _core.key_states[wparam] = 0; - _core.key_deltas[wparam] = 1; + _core.key_states[wparam] = 0 + _core.key_deltas[wparam] = 1 } - return 0; + return 0 case WM_CLOSE: - PostQuitMessage(0); - _core.running = false; - return 0; + PostQuitMessage(0) + _core.running = false + return 0 } - return DefWindowProcA(hwnd, msg, wparam, lparam); + return DefWindowProcA(hwnd, msg, wparam, lparam) } @@ -354,26 +354,26 @@ run :: proc(user_init, user_step: proc(c: ^Core)) { wnd_proc = win32_proc, // wnd_proc = DefWindowProcA, background = GetStockObject(BLACK_BRUSH) as HBRUSH, - }; - - if RegisterClassExA(^window_class) == 0 { - fmt.fprintln(os.stderr, "RegisterClassExA failed"); - return; } - screen_width := GetSystemMetrics(SM_CXSCREEN); - screen_height := GetSystemMetrics(SM_CYSCREEN); + if RegisterClassExA(^window_class) == 0 { + fmt.fprintln(os.stderr, "RegisterClassExA failed") + return + } - rc: RECT; - rc.left = (screen_width - WINDOW_WIDTH) / 2; - rc.top = (screen_height - WINDOW_HEIGHT) / 2; - rc.right = rc.left + WINDOW_WIDTH; - rc.bottom = rc.top + WINDOW_HEIGHT; + screen_width := GetSystemMetrics(SM_CXSCREEN) + screen_height := GetSystemMetrics(SM_CYSCREEN) - style: u32 = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX; - assert(AdjustWindowRect(^rc, style, 0) != 0); + rc: RECT + rc.left = (screen_width - WINDOW_WIDTH) / 2 + rc.top = (screen_height - WINDOW_HEIGHT) / 2 + rc.right = rc.left + WINDOW_WIDTH + rc.bottom = rc.top + WINDOW_HEIGHT - wt := WINDOW_TITLE; + style: u32 = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX + assert(AdjustWindowRect(^rc, style, 0) != 0) + + wt := WINDOW_TITLE win32_window := CreateWindowExA(0, window_class.class_name, @@ -382,101 +382,101 @@ run :: proc(user_init, user_step: proc(c: ^Core)) { rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, nil, nil, window_class.instance, - nil); + nil) if win32_window == nil { - fmt.fprintln(os.stderr, "CreateWindowExA failed"); - return; + fmt.fprintln(os.stderr, "CreateWindowExA failed") + return } - window_bmi: BITMAPINFO; - window_bmi.size = size_of(BITMAPINFO.HEADER) as u32; - window_bmi.width = CANVAS_WIDTH; - window_bmi.height = CANVAS_HEIGHT; - window_bmi.planes = 1; - window_bmi.bit_count = 32; - window_bmi.compression = BI_RGB; + window_bmi: BITMAPINFO + window_bmi.size = size_of(BITMAPINFO.HEADER) as u32 + window_bmi.width = CANVAS_WIDTH + window_bmi.height = CANVAS_HEIGHT + window_bmi.planes = 1 + window_bmi.bit_count = 32 + window_bmi.compression = BI_RGB - user_init(^_core); + user_init(^_core) - ShowWindow(win32_window, SW_SHOW); + ShowWindow(win32_window, SW_SHOW) - window_buffer := new_slice(u32, CANVAS_WIDTH * CANVAS_HEIGHT); - assert(window_buffer.data != nil); - defer free(window_buffer.data); + window_buffer := new_slice(u32, CANVAS_WIDTH * CANVAS_HEIGHT) + assert(window_buffer.data != nil) + defer free(window_buffer.data) for i := 0; i < window_buffer.count; i++ { - window_buffer[i] = 0xff00ff; + window_buffer[i] = 0xff00ff } - prev_time, curr_time,dt: f64; - prev_time = time_now(); - curr_time = time_now(); - total_time : f64 = 0; - offset_x := 0; - offset_y := 0; + prev_time, curr_time,dt: f64 + prev_time = time_now() + curr_time = time_now() + total_time : f64 = 0 + offset_x := 0 + offset_y := 0 - message: MSG; + message: MSG for _core.running { - curr_time = time_now(); - dt = curr_time - prev_time; - prev_time = curr_time; - total_time += dt; + curr_time = time_now() + dt = curr_time - prev_time + prev_time = curr_time + total_time += dt - offset_x += 1; - offset_y += 2; + offset_x += 1 + offset_y += 2 { - data: [128]byte; - buf := data[:0]; - fmt.bprintf(^buf, "Punity: % ms\x00", dt*1000); - win32.SetWindowTextA(win32_window, buf.data); + data: [128]byte + buf := data[:0] + fmt.bprintf(^buf, "Punity: % ms\x00", dt*1000) + win32.SetWindowTextA(win32_window, buf.data) } for y := 0; y < CANVAS_HEIGHT; y++ { for x := 0; x < CANVAS_WIDTH; x++ { - g := (x % 32) * 8; - b := (y % 32) * 8; - window_buffer[x + y*CANVAS_WIDTH] = (g << 8 | b) as u32; + g := (x % 32) * 8 + b := (y % 32) * 8 + window_buffer[x + y*CANVAS_WIDTH] = (g << 8 | b) as u32 } } - _core.key_deltas = nil; + _core.key_deltas = nil for PeekMessageA(^message, nil, 0, 0, PM_REMOVE) != 0 { if message.message == WM_QUIT { - _core.running = false; + _core.running = false } - TranslateMessage(^message); - DispatchMessageA(^message); + TranslateMessage(^message) + DispatchMessageA(^message) } - user_step(^_core); + user_step(^_core) - dc := GetDC(win32_window); + dc := GetDC(win32_window) StretchDIBits(dc, 0, 0, CANVAS_WIDTH * CANVAS_SCALE, CANVAS_HEIGHT * CANVAS_SCALE, 0, 0, CANVAS_WIDTH, CANVAS_HEIGHT, window_buffer.data, ^window_bmi, DIB_RGB_COLORS, - SRCCOPY); - ReleaseDC(win32_window, dc); + SRCCOPY) + ReleaseDC(win32_window, dc) { - delta := time_now() - prev_time; - ms := ((FRAME_TIME - delta) * 1000) as i32; + delta := time_now() - prev_time + ms := ((FRAME_TIME - delta) * 1000) as i32 if ms > 0 { - win32.Sleep(ms); + win32.Sleep(ms) } } - _core.frame++; + _core.frame++ } } diff --git a/core/_preload.odin b/core/_preload.odin index 103187096..6f31744ce 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -1,8 +1,8 @@ -#shared_global_scope; +#shared_global_scope -#import "os.odin"; -#import "fmt.odin"; -#import "mem.odin"; +#import "os.odin" +#import "fmt.odin" +#import "mem.odin" // IMPORTANT NOTE(bill): `type_info` & `type_info_val` cannot be used within a // #shared_global_scope due to the internals of the compiler. @@ -15,78 +15,78 @@ Type_Info :: union { Member :: type struct #ordered { name: string; // can be empty if tuple - type_info: ^Type_Info; + type_info: ^Type_Info offset: int; // offsets are not used in tuples } Record :: struct #ordered { - fields: []Member; + fields: []Member size: int; // in bytes align: int; // in bytes - packed: bool; - ordered: bool; + packed: bool + ordered: bool } Named: struct #ordered { - name: string; + name: string base: ^Type_Info; // This will _not_ be a Type_Info.Named - }; + } Integer: struct #ordered { size: int; // in bytes - signed: bool; - }; + signed: bool + } Float: struct #ordered { size: int; // in bytes - }; - Any: struct #ordered {}; - String: struct #ordered {}; - Boolean: struct #ordered {}; + } + Any: struct #ordered {} + String: struct #ordered {} + Boolean: struct #ordered {} Pointer: struct #ordered { elem: ^Type_Info; // nil -> rawptr - }; + } Maybe: struct #ordered { - elem: ^Type_Info; - }; + elem: ^Type_Info + } Procedure: struct #ordered { params: ^Type_Info; // Type_Info.Tuple results: ^Type_Info; // Type_Info.Tuple - variadic: bool; - }; + variadic: bool + } Array: struct #ordered { - elem: ^Type_Info; - elem_size: int; - count: int; - }; + elem: ^Type_Info + elem_size: int + count: int + } Slice: struct #ordered { - elem: ^Type_Info; - elem_size: int; - }; + elem: ^Type_Info + elem_size: int + } Vector: struct #ordered { - elem: ^Type_Info; - elem_size: int; - count: int; - align: int; - }; - Tuple: Record; - Struct: Record; - Union: Record; - Raw_Union: Record; + elem: ^Type_Info + elem_size: int + count: int + align: int + } + Tuple: Record + Struct: Record + Union: Record + Raw_Union: Record Enum: struct #ordered { - base: ^Type_Info; - values: []i64; - names: []string; - }; + base: ^Type_Info + values: []i64 + names: []string + } } type_info_base :: proc(info: ^Type_Info) -> ^Type_Info { if info == nil { - return nil; + return nil } - base := info; + base := info match type i : base { case Type_Info.Named: - base = i.base; + base = i.base } - return base; + return base } @@ -126,147 +126,147 @@ Allocator :: struct #ordered { old_memory: rawptr, old_size: int, flags: u64) -> rawptr - procedure: Proc; - data: rawptr; + procedure: Proc + data: rawptr } Context :: struct #ordered { - thread_id: int; + thread_id: int - allocator: Allocator; + allocator: Allocator - user_data: rawptr; - user_index: int; + user_data: rawptr + user_index: int } -#thread_local __context: Context; +#thread_local __context: Context -DEFAULT_ALIGNMENT :: align_of([vector 4]f32); +DEFAULT_ALIGNMENT :: align_of([vector 4]f32) __check_context :: proc() { - c := ^__context; + c := ^__context if c.allocator.procedure == nil { - c.allocator = default_allocator(); + c.allocator = default_allocator() } if c.thread_id == 0 { - c.thread_id = os.current_thread_id(); + c.thread_id = os.current_thread_id() } } alloc :: proc(size: int) -> rawptr #inline { return alloc_align(size, DEFAULT_ALIGNMENT); } alloc_align :: proc(size, alignment: int) -> rawptr #inline { - __check_context(); - a := context.allocator; - return a.procedure(a.data, Allocator.Mode.ALLOC, size, alignment, nil, 0, 0); + __check_context() + a := context.allocator + return a.procedure(a.data, Allocator.Mode.ALLOC, size, alignment, nil, 0, 0) } free :: proc(ptr: rawptr) #inline { - __check_context(); - a := context.allocator; + __check_context() + a := context.allocator if ptr != nil { - a.procedure(a.data, Allocator.Mode.FREE, 0, 0, ptr, 0, 0); + a.procedure(a.data, Allocator.Mode.FREE, 0, 0, ptr, 0, 0) } } free_all :: proc() #inline { - __check_context(); - a := context.allocator; - a.procedure(a.data, Allocator.Mode.FREE_ALL, 0, 0, nil, 0, 0); + __check_context() + a := context.allocator + a.procedure(a.data, Allocator.Mode.FREE_ALL, 0, 0, nil, 0, 0) } resize :: proc(ptr: rawptr, old_size, new_size: int) -> rawptr #inline { return resize_align(ptr, old_size, new_size, DEFAULT_ALIGNMENT); } resize_align :: proc(ptr: rawptr, old_size, new_size, alignment: int) -> rawptr #inline { - __check_context(); - a := context.allocator; - return a.procedure(a.data, Allocator.Mode.RESIZE, new_size, alignment, ptr, old_size, 0); + __check_context() + a := context.allocator + return a.procedure(a.data, Allocator.Mode.RESIZE, new_size, alignment, ptr, old_size, 0) } default_resize_align :: proc(old_memory: rawptr, old_size, new_size, alignment: int) -> rawptr { if old_memory == nil { - return alloc_align(new_size, alignment); + return alloc_align(new_size, alignment) } if new_size == 0 { - free(old_memory); - return nil; + free(old_memory) + return nil } if new_size == old_size { - return old_memory; + return old_memory } - new_memory := alloc_align(new_size, alignment); + new_memory := alloc_align(new_size, alignment) if new_memory == nil { - return nil; + return nil } - mem.copy(new_memory, old_memory, min(old_size, new_size));; - free(old_memory); - return new_memory; + mem.copy(new_memory, old_memory, min(old_size, new_size)); + free(old_memory) + return new_memory } default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator.Mode, size, alignment: int, old_memory: rawptr, old_size: int, flags: u64) -> rawptr { - using Allocator.Mode; + using Allocator.Mode when false { match mode { case ALLOC: - total_size := size + alignment + size_of(mem.AllocationHeader); - ptr := os.heap_alloc(total_size); - header := ptr as ^mem.AllocationHeader; - ptr = mem.align_forward(header+1, alignment); - mem.allocation_header_fill(header, ptr, size); - return mem.zero(ptr, size); + total_size := size + alignment + size_of(mem.AllocationHeader) + ptr := os.heap_alloc(total_size) + header := ptr as ^mem.AllocationHeader + ptr = mem.align_forward(header+1, alignment) + mem.allocation_header_fill(header, ptr, size) + return mem.zero(ptr, size) case FREE: - os.heap_free(mem.allocation_header(old_memory)); - return nil; + os.heap_free(mem.allocation_header(old_memory)) + return nil case FREE_ALL: // NOTE(bill): Does nothing case RESIZE: - total_size := size + alignment + size_of(mem.AllocationHeader); - ptr := os.heap_resize(mem.allocation_header(old_memory), total_size); - header := ptr as ^mem.AllocationHeader; - ptr = mem.align_forward(header+1, alignment); - mem.allocation_header_fill(header, ptr, size); - return mem.zero(ptr, size); + total_size := size + alignment + size_of(mem.AllocationHeader) + ptr := os.heap_resize(mem.allocation_header(old_memory), total_size) + header := ptr as ^mem.AllocationHeader + ptr = mem.align_forward(header+1, alignment) + mem.allocation_header_fill(header, ptr, size) + return mem.zero(ptr, size) } } else { match mode { case ALLOC: - return os.heap_alloc(size); + return os.heap_alloc(size) case FREE: - os.heap_free(old_memory); - return nil; + os.heap_free(old_memory) + return nil case FREE_ALL: // NOTE(bill): Does nothing case RESIZE: - return os.heap_resize(old_memory, size); + return os.heap_resize(old_memory, size) } } - return nil; + return nil } default_allocator :: proc() -> Allocator { return Allocator{ procedure = default_allocator_proc, data = nil, - }; + } } @@ -281,16 +281,16 @@ default_allocator :: proc() -> Allocator { __string_eq :: proc(a, b: string) -> bool { if a.count != b.count { - return false; + return false } if a.data == b.data { - return true; + return true } - return mem.compare(a.data, b.data, a.count) == 0; + return mem.compare(a.data, b.data, a.count) == 0 } __string_cmp :: proc(a, b : string) -> int { - return mem.compare(a.data, b.data, min(a.count, b.count)); + return mem.compare(a.data, b.data, min(a.count, b.count)) } __string_ne :: proc(a, b: string) -> bool #inline { return !__string_eq(a, b); } @@ -302,37 +302,37 @@ __string_ge :: proc(a, b: string) -> bool #inline { return __string_cmp(a, b) >= __assert :: proc(file: string, line, column: int, msg: string) #inline { fmt.fprintf(os.stderr, "%(%:%) Runtime assertion: %\n", - file, line, column, msg); - __debug_trap(); + file, line, column, msg) + __debug_trap() } __bounds_check_error :: proc(file: string, line, column: int, index, count: int) { if 0 <= index && index < count { - return; + return } fmt.fprintf(os.stderr, "%(%:%) Index % is out of bounds range [0, %)\n", - file, line, column, index, count); - __debug_trap(); + file, line, column, index, count) + __debug_trap() } __slice_expr_error :: proc(file: string, line, column: int, low, high, max: int) { if 0 <= low && low <= high && high <= max { - return; + return } fmt.fprintf(os.stderr, "%(%:%) Invalid slice indices: [%:%:%]\n", - file, line, column, low, high, max); - __debug_trap(); + file, line, column, low, high, max) + __debug_trap() } __substring_expr_error :: proc(file: string, line, column: int, low, high: int) { if 0 <= low && low <= high { - return; + return } fmt.fprintf(os.stderr, "%(%:%) Invalid substring indices: [%:%:%]\n", - file, line, column, low, high); - __debug_trap(); + file, line, column, low, high) + __debug_trap() } __enum_to_string :: proc(info: ^Type_Info, value: i64) -> string { @@ -341,11 +341,11 @@ __enum_to_string :: proc(info: ^Type_Info, value: i64) -> string { // TODO(bill): Search faster than linearly for i := 0; i < ti.values.count; i++ { if ti.values[i] == value { - return ti.names[i]; + return ti.names[i] } } } - return ""; + return "" } diff --git a/core/_soft_numbers.odin b/core/_soft_numbers.odin index d599265a5..305d82011 100644 --- a/core/_soft_numbers.odin +++ b/core/_soft_numbers.odin @@ -1,156 +1,156 @@ -#shared_global_scope; +#shared_global_scope -#import "fmt.odin"; +#import "fmt.odin" __u128_mod :: proc(a, b: u128) -> u128 #link_name "__umodti3" { - _, r := __u128_quo_mod(a, b); - return r; + _, r := __u128_quo_mod(a, b) + return r } __u128_quo :: proc(a, b: u128) -> u128 #link_name "__udivti3" { - n, _ := __u128_quo_mod(a, b); - return n; + n, _ := __u128_quo_mod(a, b) + return n } __i128_mod :: proc(a, b: i128) -> i128 #link_name "__modti3" { - _, r := __i128_quo_mod(a, b); - return r; + _, r := __i128_quo_mod(a, b) + return r } __i128_quo :: proc(a, b: i128) -> i128 #link_name "__divti3" { - n, _ := __i128_quo_mod(a, b); - return n; + n, _ := __i128_quo_mod(a, b) + return n } __i128_quo_mod :: proc(a, b: i128) -> (i128, i128) #link_name "__divmodti4" { - s := b >> 127; - b = (b ~ s) - s; - s = a >> 127; - a = (a ~ s) - s; + s := b >> 127 + b = (b ~ s) - s + s = a >> 127 + a = (a ~ s) - s - n, r := __u128_quo_mod(a as u128, b as u128); - return (n as i128 ~ s) - s, (r as i128 ~ s) - s; + n, r := __u128_quo_mod(a as u128, b as u128) + return (n as i128 ~ s) - s, (r as i128 ~ s) - s } __u128_quo_mod :: proc(a, b: u128) -> (u128, u128) #link_name "__udivmodti4" { clz :: proc(x: u64) -> u64 { clz_u64 :: proc(x: u64, is_zero_undef: bool) -> u64 #foreign "llvm.ctlz.i64" - return clz_u64(x, false); + return clz_u64(x, false) } ctz :: proc(x: u64) -> u64 { ctz_u64 :: proc(x: u64, is_zero_undef: bool) -> u64 #foreign "llvm.cttz.i64" - return ctz_u64(x, false); + return ctz_u64(x, false) } u128_lo_hi :: raw_union { - all: u128; - using _lohi: struct {lo, hi: u64;}; + all: u128 + using _lohi: struct {lo, hi: u64;} } - n, d, q, r: u128_lo_hi; - sr: u64; + n, d, q, r: u128_lo_hi + sr: u64 - n.all = a; - d.all = b; + n.all = a + d.all = b if n.hi == 0 { if d.hi == 0 { - return (n.lo / d.lo) as u128, (n.lo % d.lo) as u128; + return (n.lo / d.lo) as u128, (n.lo % d.lo) as u128 } - return 0, n.lo as u128; + return 0, n.lo as u128 } if d.lo == 0 { if d.hi == 0 { - return (n.hi / d.lo) as u128, (n.hi % d.lo) as u128; + return (n.hi / d.lo) as u128, (n.hi % d.lo) as u128 } if n.lo == 0 { - r.hi = n.hi % d.hi; - r.lo = 0; - return (n.hi / d.hi) as u128, r.all; + r.hi = n.hi % d.hi + r.lo = 0 + return (n.hi / d.hi) as u128, r.all } if (d.hi & (d.hi-1)) == 0 { - r.lo = n.lo; - r.hi = n.hi & (d.hi-1); - return (n.hi >> ctz(d.hi)) as u128, r.all; + r.lo = n.lo + r.hi = n.hi & (d.hi-1) + return (n.hi >> ctz(d.hi)) as u128, r.all } - sr = clz(d.hi) - clz(n.hi); + sr = clz(d.hi) - clz(n.hi) if sr > 64 - 2 { - return 0, n.all; + return 0, n.all } - sr++; - q.lo = 0; - q.hi = n.lo << (64-sr); - r.hi = n.hi >> sr; - r.lo = (n.hi << (64-sr)) | (n.lo >> sr); + sr++ + q.lo = 0 + q.hi = n.lo << (64-sr) + r.hi = n.hi >> sr + r.lo = (n.hi << (64-sr)) | (n.lo >> sr) } else { if d.hi == 0 { if (d.lo & (d.lo - 1)) == 0 { - rem := (n.lo % (d.lo - 1)) as u128; + rem := (n.lo % (d.lo - 1)) as u128 if d.lo == 1 { - return n.all, rem; + return n.all, rem } - sr = ctz(d.lo); - q.hi = n.hi >> sr; - q.lo = (n.hi << (64-sr)) | (n.lo >> sr); - return q.all, rem; + sr = ctz(d.lo) + q.hi = n.hi >> sr + q.lo = (n.hi << (64-sr)) | (n.lo >> sr) + return q.all, rem } - sr = 1 + 64 + clz(d.lo) - clz(n.hi); + sr = 1 + 64 + clz(d.lo) - clz(n.hi) - q.all = n.all << (128-sr); - r.all = n.all >> sr; + q.all = n.all << (128-sr) + r.all = n.all >> sr if sr == 64 { - q.lo = 0; - q.hi = n.lo; - r.hi = 0; - r.lo = n.hi; + q.lo = 0 + q.hi = n.lo + r.hi = 0 + r.lo = n.hi } else if sr < 64 { - q.lo = 0; - q.hi = n.lo << (64-sr); - r.hi = n.hi >> sr; - r.lo = (n.hi << (64-sr)) | (n.lo >> sr); + q.lo = 0 + q.hi = n.lo << (64-sr) + r.hi = n.hi >> sr + r.lo = (n.hi << (64-sr)) | (n.lo >> sr) } else { - q.lo = n.lo << (128-sr); - q.hi = (n.hi << (128-sr)) | (n.lo >> (sr-64)); - r.hi = 0; - r.lo = n.hi >> (sr-64); + q.lo = n.lo << (128-sr) + q.hi = (n.hi << (128-sr)) | (n.lo >> (sr-64)) + r.hi = 0 + r.lo = n.hi >> (sr-64) } } else { - sr = clz(d.hi) - clz(n.hi); + sr = clz(d.hi) - clz(n.hi) if sr > 64-1 { - return 0, n.all; + return 0, n.all } - sr++; - q.lo = 0; - q.hi = n.lo << (64-sr); - r.all = n.all >> sr; + sr++ + q.lo = 0 + q.hi = n.lo << (64-sr) + r.all = n.all >> sr if sr < 64 { - r.hi = n.hi >> sr; - r.lo = (n.hi << (64-sr)) | (n.lo >> sr); + r.hi = n.hi >> sr + r.lo = (n.hi << (64-sr)) | (n.lo >> sr) } else { - r.hi = 0; - r.lo = n.hi; + r.hi = 0 + r.lo = n.hi } } } - carry: u64; + carry: u64 for ; sr > 0; sr-- { - r.hi = (r.hi << 1) | (r.lo >> (64-1)); - r.lo = (r.lo << 1) | (r.hi >> (64-1)); - q.hi = (q.hi << 1) | (q.lo >> (64-1)); - q.lo = (q.lo << 1) | carry; + r.hi = (r.hi << 1) | (r.lo >> (64-1)) + r.lo = (r.lo << 1) | (r.hi >> (64-1)) + q.hi = (q.hi << 1) | (q.lo >> (64-1)) + q.lo = (q.lo << 1) | carry - carry = 0; + carry = 0 if r.all >= d.all { - r.all -= d.all; - carry = 1; + r.all -= d.all + carry = 1 } } - q.all = (q.all << 1) | (carry as u128); - return q.all, r.all; + q.all = (q.all << 1) | (carry as u128) + return q.all, r.all } diff --git a/core/fmt.odin b/core/fmt.odin index 2e6c8926f..70a78f527 100644 --- a/core/fmt.odin +++ b/core/fmt.odin @@ -1,592 +1,595 @@ -#import "os.odin"; -#import "mem.odin"; -#import "utf8.odin"; +#import "os.odin" +#import "mem.odin" +#import "utf8.odin" -PRINT_BUF_SIZE :: 1<<12; +PRINT_BUF_SIZE :: 1<<12 fprint :: proc(f: ^os.File, args: ..any) -> int { - data: [PRINT_BUF_SIZE]byte; - buf := data[:0]; - bprint(^buf, ..args); - os.write(f, buf); - return buf.count; + data: [PRINT_BUF_SIZE]byte + buf := data[:0] + bprint(^buf, ..args) + os.write(f, buf) + return buf.count } fprintln :: proc(f: ^os.File, args: ..any) -> int { - data: [PRINT_BUF_SIZE]byte; - buf := data[:0]; - bprintln(^buf, ..args); - os.write(f, buf); - return buf.count; + data: [PRINT_BUF_SIZE]byte + buf := data[:0] + bprintln(^buf, ..args) + os.write(f, buf) + return buf.count } fprintf :: proc(f: ^os.File, fmt: string, args: ..any) -> int { - data: [PRINT_BUF_SIZE]byte; - buf := data[:0]; - bprintf(^buf, fmt, ..args); - os.write(f, buf); - return buf.count; + data: [PRINT_BUF_SIZE]byte + buf := data[:0] + bprintf(^buf, fmt, ..args) + os.write(f, buf) + return buf.count } print :: proc(args: ..any) -> int { - return fprint(os.stdout, ..args); + return fprint(os.stdout, ..args) } println :: proc(args: ..any) -> int { - return fprintln(os.stdout, ..args); + return fprintln(os.stdout, ..args) } printf :: proc(fmt: string, args: ..any) -> int { - return fprintf(os.stdout, fmt, ..args); + return fprintf(os.stdout, fmt, ..args) } fprint_type :: proc(f: ^os.File, info: ^Type_Info) { - data: [PRINT_BUF_SIZE]byte; - buf := data[:0]; - bprint_type(^buf, info); - os.write(f, buf); + data: [PRINT_BUF_SIZE]byte + buf := data[:0] + bprint_type(^buf, info) + os.write(f, buf) } print_byte_buffer :: proc(buf: ^[]byte, b: []byte) { if buf.count < buf.capacity { - n := min(buf.capacity-buf.count, b.count); + n := min(buf.capacity-buf.count, b.count) if n > 0 { - mem.copy(buf.data + buf.count, b.data, n); - buf.count += n; + mem.copy(buf.data + buf.count, b.data, n) + buf.count += n } } } bprint_string :: proc(buf: ^[]byte, s: string) { - print_byte_buffer(buf, s as []byte); + print_byte_buffer(buf, s as []byte) } byte_reverse :: proc(b: []byte) { - n := b.count; + n := b.count for i := 0; i < n/2; i++ { - b[i], b[n-1-i] = b[n-1-i], b[i]; + b[i], b[n-1-i] = b[n-1-i], b[i] } } bprint_rune :: proc(buf: ^[]byte, r: rune) { - b, n := utf8.encode_rune(r); - bprint_string(buf, b[:n] as string); + b, n := utf8.encode_rune(r) + bprint_string(buf, b[:n] as string) } bprint_space :: proc(buf: ^[]byte) { bprint_rune(buf, ' '); } bprint_nl :: proc(buf: ^[]byte) { bprint_rune(buf, '\n'); } -__NUM_TO_CHAR_TABLE := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@$"; +__NUM_TO_CHAR_TABLE := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@$" bprint_bool :: proc(buffer: ^[]byte, b : bool) { - if b { bprint_string(buffer, "true"); } - else { bprint_string(buffer, "false"); } + if b { + bprint_string(buffer, "true") + } else { + bprint_string(buffer, "false") + } } bprint_pointer :: proc(buffer: ^[]byte, p: rawptr) #inline { - bprint_string(buffer, "0x"); - bprint_u64(buffer, p as uint as u64); + bprint_string(buffer, "0x") + bprint_u64(buffer, p as uint as u64) } bprint_f16 :: proc(buffer: ^[]byte, f: f32) #inline { print__f64(buffer, f as f64, 4); } bprint_f32 :: proc(buffer: ^[]byte, f: f32) #inline { print__f64(buffer, f as f64, 7); } bprint_f64 :: proc(buffer: ^[]byte, f: f64) #inline { print__f64(buffer, f as f64, 16); } bprint_u64 :: proc(buffer: ^[]byte, value: u64) { - i := value; - buf: [20]byte; - len := 0; + i := value + buf: [20]byte + len := 0 if i == 0 { - buf[len] = '0'; - len++; + buf[len] = '0' + len++ } for i > 0 { - buf[len] = __NUM_TO_CHAR_TABLE[i % 10]; - len++; - i /= 10; + buf[len] = __NUM_TO_CHAR_TABLE[i % 10] + len++ + i /= 10 } - byte_reverse(buf[:len]); - bprint_string(buffer, buf[:len] as string); + byte_reverse(buf[:len]) + bprint_string(buffer, buf[:len] as string) } bprint_i64 :: proc(buffer: ^[]byte, value: i64) { // TODO(bill): Cleanup printing - i := value; + i := value if i < 0 { - i = -i; - bprint_rune(buffer, '-'); + i = -i + bprint_rune(buffer, '-') } - bprint_u64(buffer, i as u64); + bprint_u64(buffer, i as u64) } bprint_u128 :: proc(buffer: ^[]byte, value: u128) { - a := value transmute [2]u64; + a := value transmute [2]u64 if a[1] != 0 { - bprint_u64(buffer, a[1]); + bprint_u64(buffer, a[1]) } - bprint_u64(buffer, a[0]); + bprint_u64(buffer, a[0]) } bprint_i128 :: proc(buffer: ^[]byte, value: i128) { - i := value; + i := value if i < 0 { - i = -i; - bprint_rune(buffer, '-'); + i = -i + bprint_rune(buffer, '-') } - bprint_u128(buffer, i as u128); + bprint_u128(buffer, i as u128) } print__f64 :: proc(buffer: ^[]byte, value: f64, decimal_places: int) { - f := value; + f := value if f == 0 { - bprint_rune(buffer, '0'); - return; + bprint_rune(buffer, '0') + return } if f < 0 { - bprint_rune(buffer, '-'); - f = -f; + bprint_rune(buffer, '-') + f = -f } - i := f as u64; - bprint_u64(buffer, i); - f -= i as f64; + i := f as u64 + bprint_u64(buffer, i) + f -= i as f64 - bprint_rune(buffer, '.'); + bprint_rune(buffer, '.') - mult: f64 = 10.0; + mult: f64 = 10.0 for ; decimal_places >= 0; decimal_places-- { - i = (f * mult) as u64; - bprint_u64(buffer, i as u64); - f -= i as f64 / mult; - mult *= 10; + i = (f * mult) as u64 + bprint_u64(buffer, i as u64) + f -= i as f64 / mult + mult *= 10 } } bprint_type :: proc(buf: ^[]byte, ti: ^Type_Info) { if ti == nil { - return; + return } - using Type_Info; + using Type_Info match type info : ti { case Named: - bprint_string(buf, info.name); + bprint_string(buf, info.name) case Integer: match { case ti == type_info(int): - bprint_string(buf, "int"); + bprint_string(buf, "int") case ti == type_info(uint): - bprint_string(buf, "uint"); + bprint_string(buf, "uint") default: if info.signed { - bprint_string(buf, "i"); + bprint_string(buf, "i") } else { - bprint_string(buf, "u"); + bprint_string(buf, "u") } - bprint_u64(buf, 8*info.size as u64); + bprint_u64(buf, 8*info.size as u64) } case Float: match info.size { - case 4: bprint_string(buf, "f32"); - case 8: bprint_string(buf, "f64"); + case 4: bprint_string(buf, "f32") + case 8: bprint_string(buf, "f64") } - case String: bprint_string(buf, "string"); - case Boolean: bprint_string(buf, "bool"); + case String: bprint_string(buf, "string") + case Boolean: bprint_string(buf, "bool") case Pointer: if info.elem == nil { - bprint_string(buf, "rawptr"); + bprint_string(buf, "rawptr") } else { - bprint_string(buf, "^"); - bprint_type(buf, info.elem); + bprint_string(buf, "^") + bprint_type(buf, info.elem) } case Maybe: - bprint_string(buf, "?"); - bprint_type(buf, info.elem); + bprint_string(buf, "?") + bprint_type(buf, info.elem) case Procedure: - bprint_string(buf, "proc"); + bprint_string(buf, "proc") if info.params == nil { - bprint_string(buf, "()"); + bprint_string(buf, "()") } else { - count := (info.params as ^Tuple).fields.count; + count := (info.params as ^Tuple).fields.count if count == 1 { bprint_string(buf, "("); } - bprint_type(buf, info.params); + bprint_type(buf, info.params) if count == 1 { bprint_string(buf, ")"); } } if info.results != nil { - bprint_string(buf, " -> "); - bprint_type(buf, info.results); + bprint_string(buf, " -> ") + bprint_type(buf, info.results) } case Tuple: - count := info.fields.count; + count := info.fields.count if count != 1 { bprint_string(buf, "("); } for i := 0; i < count; i++ { if i > 0 { bprint_string(buf, ", "); } - f := info.fields[i]; + f := info.fields[i] if f.name.count > 0 { - bprint_string(buf, f.name); - bprint_string(buf, ": "); + bprint_string(buf, f.name) + bprint_string(buf, ": ") } - bprint_type(buf, f.type_info); + bprint_type(buf, f.type_info) } if count != 1 { bprint_string(buf, ")"); } case Array: - bprint_string(buf, "["); - bprint_i64(buf, info.count as i64); - bprint_string(buf, "]"); - bprint_type(buf, info.elem); + bprint_string(buf, "[") + bprint_i64(buf, info.count as i64) + bprint_string(buf, "]") + bprint_type(buf, info.elem) case Slice: - bprint_string(buf, "["); - bprint_string(buf, "]"); - bprint_type(buf, info.elem); + bprint_string(buf, "[") + bprint_string(buf, "]") + bprint_type(buf, info.elem) case Vector: - bprint_string(buf, "[vector "); - bprint_i64(buf, info.count as i64); - bprint_string(buf, "]"); - bprint_type(buf, info.elem); + bprint_string(buf, "[vector ") + bprint_i64(buf, info.count as i64) + bprint_string(buf, "]") + bprint_type(buf, info.elem) case Struct: - bprint_string(buf, "struct "); + bprint_string(buf, "struct ") if info.packed { bprint_string(buf, "#packed "); } if info.ordered { bprint_string(buf, "#ordered "); } - bprint_string(buf, "{"); + bprint_string(buf, "{") for i := 0; i < info.fields.count; i++ { if i > 0 { - bprint_string(buf, ", "); + bprint_string(buf, ", ") } - bprint_any(buf, info.fields[i].name); - bprint_string(buf, ": "); - bprint_type(buf, info.fields[i].type_info); + bprint_any(buf, info.fields[i].name) + bprint_string(buf, ": ") + bprint_type(buf, info.fields[i].type_info) } - bprint_string(buf, "}"); + bprint_string(buf, "}") case Union: - bprint_string(buf, "union {"); + bprint_string(buf, "union {") for i := 0; i < info.fields.count; i++ { if i > 0 { - bprint_string(buf, ", "); + bprint_string(buf, ", ") } - bprint_any(buf, info.fields[i].name); - bprint_string(buf, ": "); - bprint_type(buf, info.fields[i].type_info); + bprint_any(buf, info.fields[i].name) + bprint_string(buf, ": ") + bprint_type(buf, info.fields[i].type_info) } - bprint_string(buf, "}"); + bprint_string(buf, "}") case Raw_Union: - bprint_string(buf, "raw_union {"); + bprint_string(buf, "raw_union {") for i := 0; i < info.fields.count; i++ { if i > 0 { - bprint_string(buf, ", "); + bprint_string(buf, ", ") } - bprint_any(buf, info.fields[i].name); - bprint_string(buf, ": "); - bprint_type(buf, info.fields[i].type_info); + bprint_any(buf, info.fields[i].name) + bprint_string(buf, ": ") + bprint_type(buf, info.fields[i].type_info) } - bprint_string(buf, "}"); + bprint_string(buf, "}") case Enum: - bprint_string(buf, "enum "); - bprint_type(buf, info.base); - bprint_string(buf, "{}"); + bprint_string(buf, "enum ") + bprint_type(buf, info.base) + bprint_string(buf, "{}") } } make_any :: proc(type_info: ^Type_Info, data: rawptr) -> any { - a: any; - a.type_info = type_info; - a.data = data; - return a; + a: any + a.type_info = type_info + a.data = data + return a } bprint_any :: proc(buf: ^[]byte, arg: any) { if arg.type_info == nil { - bprint_string(buf, ""); - return; + bprint_string(buf, "") + return } if arg.data == nil { - bprint_string(buf, ""); - return; + bprint_string(buf, "") + return } - using Type_Info; + using Type_Info match type info : arg.type_info { case Named: - a := make_any(info.base, arg.data); + a := make_any(info.base, arg.data) match type b : info.base { case Struct: - bprint_string(buf, info.name); - bprint_string(buf, "{"); + bprint_string(buf, info.name) + bprint_string(buf, "{") for i := 0; i < b.fields.count; i++ { - f := b.fields[i]; + f := b.fields[i] if i > 0 { - bprint_string(buf, ", "); + bprint_string(buf, ", ") } - bprint_string(buf, f.name); - // bprint_any(buf, f.offset); - bprint_string(buf, " = "); - data := arg.data as ^byte + f.offset; - bprint_any(buf, make_any(f.type_info, data)); + bprint_string(buf, f.name) + // bprint_any(buf, f.offset) + bprint_string(buf, " = ") + data := arg.data as ^byte + f.offset + bprint_any(buf, make_any(f.type_info, data)) } - bprint_string(buf, "}"); + bprint_string(buf, "}") default: - bprint_any(buf, a); + bprint_any(buf, a) } case Integer: match type i : arg { - case i8: bprint_i64(buf, i as i64); - case u8: bprint_u64(buf, i as u64); - case i16: bprint_i64(buf, i as i64); - case u16: bprint_u64(buf, i as u64); - case i32: bprint_i64(buf, i as i64); - case u32: bprint_u64(buf, i as u64); - case i64: bprint_i64(buf, i); - case u64: bprint_u64(buf, i); - case i128: bprint_i128(buf, i); - case u128: bprint_u128(buf, i); + case i8: bprint_i64(buf, i as i64) + case u8: bprint_u64(buf, i as u64) + case i16: bprint_i64(buf, i as i64) + case u16: bprint_u64(buf, i as u64) + case i32: bprint_i64(buf, i as i64) + case u32: bprint_u64(buf, i as u64) + case i64: bprint_i64(buf, i) + case u64: bprint_u64(buf, i) + case i128: bprint_i128(buf, i) + case u128: bprint_u128(buf, i) - case int: bprint_i64(buf, i as i64); - case uint: bprint_u64(buf, i as u64); + case int: bprint_i64(buf, i as i64) + case uint: bprint_u64(buf, i as u64) } case Float: match type f : arg { - // case f16: bprint_f64(buf, f as f64); - case f32: bprint_f32(buf, f); - case f64: bprint_f64(buf, f); - // case f128: bprint_f64(buf, f as f64); + // case f16: bprint_f64(buf, f as f64) + case f32: bprint_f32(buf, f) + case f64: bprint_f64(buf, f) + // case f128: bprint_f64(buf, f as f64) } case String: match type s : arg { - case string: bprint_string(buf, s); + case string: bprint_string(buf, s) } case Boolean: match type b : arg { - case bool: bprint_bool(buf, b); + case bool: bprint_bool(buf, b) } case Pointer: match type p : arg { - case ^Type_Info: bprint_type(buf, p); - default: bprint_pointer(buf, (arg.data as ^rawptr)^); + case ^Type_Info: bprint_type(buf, p) + default: bprint_pointer(buf, (arg.data as ^rawptr)^) } case Maybe: - size := mem.size_of_type_info(info.elem); - data := slice_ptr(arg.data as ^byte, size+1); + size := mem.size_of_type_info(info.elem) + data := slice_ptr(arg.data as ^byte, size+1) if data[size] != 0 { - bprint_any(buf, make_any(info.elem, arg.data)); + bprint_any(buf, make_any(info.elem, arg.data)) } else { - bprint_string(buf, "nil"); + bprint_string(buf, "nil") } case Enum: - value: i64 = 0; + value: i64 = 0 match type i : make_any(info.base, arg.data) { - case i8: value = i as i64; - case i16: value = i as i64; - case i32: value = i as i64; - case i64: value = i as i64; - case u8: value = i as i64; - case u16: value = i as i64; - case u32: value = i as i64; - case u64: value = i as i64; + case i8: value = i as i64 + case i16: value = i as i64 + case i32: value = i as i64 + case i64: value = i as i64 + case u8: value = i as i64 + case u16: value = i as i64 + case u32: value = i as i64 + case u64: value = i as i64 } - bprint_string(buf, __enum_to_string(arg.type_info, value)); + bprint_string(buf, __enum_to_string(arg.type_info, value)) case Array: - bprintf(buf, "[%]%{", info.count, info.elem); - defer bprint_string(buf, "}"); + bprintf(buf, "[%]%{", info.count, info.elem) + defer bprint_string(buf, "}") for i := 0; i < info.count; i++ { if i > 0 { - bprint_string(buf, ", "); + bprint_string(buf, ", ") } - data := arg.data as ^byte + i*info.elem_size; - bprint_any(buf, make_any(info.elem, data)); + data := arg.data as ^byte + i*info.elem_size + bprint_any(buf, make_any(info.elem, data)) } case Slice: - slice := arg.data as ^[]byte; - bprintf(buf, "[]%{", info.elem); - defer bprint_string(buf, "}"); + slice := arg.data as ^[]byte + bprintf(buf, "[]%{", info.elem) + defer bprint_string(buf, "}") for i := 0; i < slice.count; i++ { if i > 0 { - bprint_string(buf, ", "); + bprint_string(buf, ", ") } - data := slice.data + i*info.elem_size; - bprint_any(buf, make_any(info.elem, data)); + data := slice.data + i*info.elem_size + bprint_any(buf, make_any(info.elem, data)) } case Vector: is_bool :: proc(type_info: ^Type_Info) -> bool { match type info : type_info { case Named: - return is_bool(info.base); + return is_bool(info.base) case Boolean: - return true; + return true } - return false; + return false } - bprintf(buf, "[vector %]%{", info.count, info.elem); - defer bprint_string(buf, "}"); + bprintf(buf, "[vector %]%{", info.count, info.elem) + defer bprint_string(buf, "}") if is_bool(info.elem) { - return; + return } for i := 0; i < info.count; i++ { if i > 0 { - bprint_string(buf, ", "); + bprint_string(buf, ", ") } - data := arg.data as ^byte + i*info.elem_size; - bprint_any(buf, make_any(info.elem, data)); + data := arg.data as ^byte + i*info.elem_size + bprint_any(buf, make_any(info.elem, data)) } case Struct: - bprintf(buf, "%{", arg.type_info); - defer bprint_string(buf, "}"); + bprintf(buf, "%{", arg.type_info) + defer bprint_string(buf, "}") for i := 0; i < info.fields.count; i++ { if i > 0 { - bprint_string(buf, ", "); + bprint_string(buf, ", ") } - bprint_string(buf, info.fields[i].name); - bprint_string(buf, " = "); - data := arg.data as ^byte + info.fields[i].offset; - ti := info.fields[i].type_info; - bprint_any(buf, make_any(ti, data)); + bprint_string(buf, info.fields[i].name) + bprint_string(buf, " = ") + data := arg.data as ^byte + info.fields[i].offset + ti := info.fields[i].type_info + bprint_any(buf, make_any(ti, data)) } case Union: - bprint_string(buf, "(union)"); + bprint_string(buf, "(union)") case Raw_Union: - bprint_string(buf, "(raw_union)"); + bprint_string(buf, "(raw_union)") case Procedure: - bprint_type(buf, arg.type_info); - bprint_string(buf, " @ 0x"); - bprint_pointer(buf, (arg.data as ^rawptr)^); + bprint_type(buf, arg.type_info) + bprint_string(buf, " @ 0x") + bprint_pointer(buf, (arg.data as ^rawptr)^) } } bprintf :: proc(buf: ^[]byte, fmt: string, args: ..any) -> int { is_digit :: proc(r: rune) -> bool #inline { - return '0' <= r && r <= '9'; + return '0' <= r && r <= '9' } parse_int :: proc(s: string, offset: int) -> (int, int) { - result := 0; + result := 0 for ; offset < s.count; offset++ { - c := s[offset] as rune; + c := s[offset] as rune if !is_digit(c) { - break; + break } - result *= 10; - result += (c - '0') as int; + result *= 10 + result += (c - '0') as int } - return result, offset; + return result, offset } - prev := 0; - implicit_index := 0; + prev := 0 + implicit_index := 0 for i := 0; i < fmt.count; i++ { - r := fmt[i] as rune; - index := implicit_index; + r := fmt[i] as rune + index := implicit_index if r != '%' { - continue; + continue } - bprint_string(buf, fmt[prev:i]); + bprint_string(buf, fmt[prev:i]) i++; // Skip % if i < fmt.count { - next := fmt[i] as rune; + next := fmt[i] as rune if next == '%' { - bprint_string(buf, "%"); - i++; - prev = i; - continue; + bprint_string(buf, "%") + i++ + prev = i + continue } if is_digit(next) { - index, i = parse_int(fmt, i); + index, i = parse_int(fmt, i) } } if 0 <= index && index < args.count { - bprint_any(buf, args[index]); - implicit_index = index+1; + bprint_any(buf, args[index]) + implicit_index = index+1 } else { // TODO(bill): Error check index out bounds - bprint_string(buf, ""); + bprint_string(buf, "") } - prev = i; + prev = i } - bprint_string(buf, fmt[prev:]); - return buf.count; + bprint_string(buf, fmt[prev:]) + return buf.count } bprint :: proc(buf: ^[]byte, args: ..any) -> int { is_type_string :: proc(info: ^Type_Info) -> bool { - using Type_Info; + using Type_Info if info == nil { - return false; + return false } match type i : type_info_base(info) { case String: - return true; + return true } - return false; + return false } - prev_string := false; + prev_string := false for i := 0; i < args.count; i++ { - arg := args[i]; - is_string := arg.data != nil && is_type_string(arg.type_info); + arg := args[i] + is_string := arg.data != nil && is_type_string(arg.type_info) if i > 0 && !is_string && !prev_string { - bprint_space(buf); + bprint_space(buf) } - bprint_any(buf, arg); - prev_string = is_string; + bprint_any(buf, arg) + prev_string = is_string } - return buf.count; + return buf.count } bprintln :: proc(buf: ^[]byte, args: ..any) -> int { for i := 0; i < args.count; i++ { if i > 0 { - append(buf, ' '); + append(buf, ' ') } - bprint_any(buf, args[i]); + bprint_any(buf, args[i]) } - bprint_nl(buf); - return buf.count; + bprint_nl(buf) + return buf.count } diff --git a/core/hash.odin b/core/hash.odin index 9a827e1bb..d61b01a71 100644 --- a/core/hash.odin +++ b/core/hash.odin @@ -1,164 +1,164 @@ crc32 :: proc(data: rawptr, len: int) -> u32 { - result := ~(0 as u32); - s := slice_ptr(data as ^u8, len); + result := ~(0 as u32) + s := slice_ptr(data as ^u8, len) for i := 0; i < len; i++ { - b := s[i] as u32; - result = result>>8 ~ __CRC32_TABLE[(result ~ b) & 0xff]; + b := s[i] as u32 + result = result>>8 ~ __CRC32_TABLE[(result ~ b) & 0xff] } - return ~result; + return ~result } crc64 :: proc(data: rawptr, len: int) -> u64 { - result := ~(0 as u64); - s := slice_ptr(data as ^u8, len); + result := ~(0 as u64) + s := slice_ptr(data as ^u8, len) for i := 0; i < len; i++ { - b := s[i] as u64; - result = result>>8 ~ __CRC64_TABLE[(result ~ b) & 0xff]; + b := s[i] as u64 + result = result>>8 ~ __CRC64_TABLE[(result ~ b) & 0xff] } - return ~result; + return ~result } fnv32 :: proc(data: rawptr, len: int) -> u32 { - s := slice_ptr(data as ^u8, len); + s := slice_ptr(data as ^u8, len) - h: u32 = 0x811c9dc5; + h: u32 = 0x811c9dc5 for i := 0; i < len; i++ { - h = (h * 0x01000193) ~ s[i] as u32; + h = (h * 0x01000193) ~ s[i] as u32 } - return h; + return h } fnv64 :: proc(data: rawptr, len: int) -> u64 { - s := slice_ptr(data as ^u8, len); + s := slice_ptr(data as ^u8, len) - h: u64 = 0xcbf29ce484222325; + h: u64 = 0xcbf29ce484222325 for i := 0; i < len; i++ { - h = (h * 0x100000001b3) ~ s[i] as u64; + h = (h * 0x100000001b3) ~ s[i] as u64 } - return h; + return h } fnv32a :: proc(data: rawptr, len: int) -> u32 { - s := slice_ptr(data as ^u8, len); + s := slice_ptr(data as ^u8, len) - h: u32 = 0x811c9dc5; + h: u32 = 0x811c9dc5 for i := 0; i < len; i++ { - h = (h ~ s[i] as u32) * 0x01000193; + h = (h ~ s[i] as u32) * 0x01000193 } - return h; + return h } fnv64a :: proc(data: rawptr, len: int) -> u64 { - s := slice_ptr(data as ^u8, len); + s := slice_ptr(data as ^u8, len) - h: u64 = 0xcbf29ce484222325; + h: u64 = 0xcbf29ce484222325 for i := 0; i < len; i++ { - h = (h ~ s[i] as u64) * 0x100000001b3; + h = (h ~ s[i] as u64) * 0x100000001b3 } - return h; + return h } murmur64 :: proc(data_: rawptr, len: int) -> u64 { - SEED :: 0x9747b28c; + SEED :: 0x9747b28c if size_of(int) == 8 { - m :: 0xc6a4a7935bd1e995; - r :: 47; + m :: 0xc6a4a7935bd1e995 + r :: 47 - h: u64 = SEED ~ (len as u64 * m); + h: u64 = SEED ~ (len as u64 * m) - data := slice_ptr(data_ as ^u64, len/size_of(u64)); - data2 := slice_ptr(data_ as ^u8, len); + data := slice_ptr(data_ as ^u64, len/size_of(u64)) + data2 := slice_ptr(data_ as ^u8, len) for i := 0; i < data.count; i++ { - k := data[i]; + k := data[i] - k *= m; - k ~= k>>r; - k *= m; + k *= m + k ~= k>>r + k *= m - h ~= k; - h *= m; + h ~= k + h *= m } match len & 7 { - case 7: h ~= data2[6] as u64 << 48; fallthrough; - case 6: h ~= data2[5] as u64 << 40; fallthrough; - case 5: h ~= data2[4] as u64 << 32; fallthrough; - case 4: h ~= data2[3] as u64 << 24; fallthrough; - case 3: h ~= data2[2] as u64 << 16; fallthrough; - case 2: h ~= data2[1] as u64 << 8; fallthrough; + case 7: h ~= data2[6] as u64 << 48; fallthrough + case 6: h ~= data2[5] as u64 << 40; fallthrough + case 5: h ~= data2[4] as u64 << 32; fallthrough + case 4: h ~= data2[3] as u64 << 24; fallthrough + case 3: h ~= data2[2] as u64 << 16; fallthrough + case 2: h ~= data2[1] as u64 << 8; fallthrough case 1: - h ~= data2[0] as u64; - h *= m; + h ~= data2[0] as u64 + h *= m } - h ~= h>>r; - h *= m; - h ~= h>>r; + h ~= h>>r + h *= m + h ~= h>>r - return h; + return h } else { - m :: 0x5bd1e995; - r :: 24; + m :: 0x5bd1e995 + r :: 24 - h1: u32 = SEED as u32 ~ len as u32; - h2: u32 = SEED >> 32; + h1: u32 = SEED as u32 ~ len as u32 + h2: u32 = SEED >> 32 - data := slice_ptr(data_ as ^u32, len/size_of(u32)); + data := slice_ptr(data_ as ^u32, len/size_of(u32)) - i := 0; + i := 0 for len >= 8 { - k1, k2: u32; - k1 = data[i]; i++; - k1 *= m; - k1 ~= k1>>r; - k1 *= m; - h1 *= m; - h1 ~= k1; - len -= 4; + k1, k2: u32 + k1 = data[i]; i++ + k1 *= m + k1 ~= k1>>r + k1 *= m + h1 *= m + h1 ~= k1 + len -= 4 - k2 = data[i]; i++; - k2 *= m; - k2 ~= k2>>r; - k2 *= m; - h2 *= m; - h2 ~= k2; - len -= 4; + k2 = data[i]; i++ + k2 *= m + k2 ~= k2>>r + k2 *= m + h2 *= m + h2 ~= k2 + len -= 4 } if (len >= 4) { - k1: u32; - k1 = data[i]; i++; - k1 *= m; - k1 ~= k1>>r; - k1 *= m; - h1 *= m; - h1 ~= k1; - len -= 4; + k1: u32 + k1 = data[i]; i++ + k1 *= m + k1 ~= k1>>r + k1 *= m + h1 *= m + h1 ~= k1 + len -= 4 } data8 := slice_ptr((data.data+i) as ^u8, 3); // NOTE(bill): This is unsafe match len { - case 3: h2 ~= data8[2] as u32 << 16; fallthrough; - case 2: h2 ~= data8[1] as u32 << 8; fallthrough; + case 3: h2 ~= data8[2] as u32 << 16; fallthrough + case 2: h2 ~= data8[1] as u32 << 8; fallthrough case 1: - h2 ~= data8[0] as u32; - h2 *= m; + h2 ~= data8[0] as u32 + h2 *= m } - h1 ~= h2>>18; - h1 *= m; - h2 ~= h1>>22; - h2 *= m; - h1 ~= h2>>17; - h1 *= m; - h2 ~= h1>>19; - h2 *= m; + h1 ~= h2>>18 + h1 *= m + h2 ~= h1>>22 + h2 *= m + h1 ~= h2>>17 + h1 *= m + h2 ~= h1>>19 + h2 *= m - h := (h1 as u64)<<32 | h2 as u64; - return h; + h := (h1 as u64)<<32 | h2 as u64 + return h } } @@ -229,7 +229,7 @@ __CRC32_TABLE := [256]u32{ 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d, -}; +} __CRC64_TABLE := [256]u64{ 0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5, 0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a, @@ -295,4 +295,4 @@ __CRC64_TABLE := [256]u64{ 0xcf8b0890283e370c, 0x8d7be97b81d4019f, 0x4a6acb477bea5a2a, 0x089a2aacd2006cb9, 0x14dea25f3af9026d, 0x562e43b4931334fe, 0x913f6188692d6f4b, 0xd3cf8063c0c759d8, 0x5dedc41a34bbeeb2, 0x1f1d25f19d51d821, 0xd80c07cd676f8394, 0x9afce626ce85b507, -}; +} diff --git a/core/math.odin b/core/math.odin index a996e2320..9476eac21 100644 --- a/core/math.odin +++ b/core/math.odin @@ -1,29 +1,29 @@ -TAU :: 6.28318530717958647692528676655900576; -PI :: 3.14159265358979323846264338327950288; -ONE_OVER_TAU :: 0.636619772367581343075535053490057448; -ONE_OVER_PI :: 0.159154943091895335768883763372514362; +TAU :: 6.28318530717958647692528676655900576 +PI :: 3.14159265358979323846264338327950288 +ONE_OVER_TAU :: 0.636619772367581343075535053490057448 +ONE_OVER_PI :: 0.159154943091895335768883763372514362 -E :: 2.71828182845904523536; -SQRT_TWO :: 1.41421356237309504880168872420969808; -SQRT_THREE :: 1.73205080756887729352744634150587236; -SQRT_FIVE :: 2.23606797749978969640917366873127623; +E :: 2.71828182845904523536 +SQRT_TWO :: 1.41421356237309504880168872420969808 +SQRT_THREE :: 1.73205080756887729352744634150587236 +SQRT_FIVE :: 2.23606797749978969640917366873127623 -LOG_TWO :: 0.693147180559945309417232121458176568; -LOG_TEN :: 2.30258509299404568401799145468436421; +LOG_TWO :: 0.693147180559945309417232121458176568 +LOG_TEN :: 2.30258509299404568401799145468436421 -EPSILON :: 1.19209290e-7; +EPSILON :: 1.19209290e-7 -τ :: TAU; -π :: PI; +τ :: TAU +π :: PI -Vec2 :: type [vector 2]f32; -Vec3 :: type [vector 3]f32; -Vec4 :: type [vector 4]f32; +Vec2 :: type [vector 2]f32 +Vec3 :: type [vector 3]f32 +Vec4 :: type [vector 4]f32 -Mat2 :: type [2]Vec2; -Mat3 :: type [3]Vec3; -Mat4 :: type [4]Vec4; +Mat2 :: type [2]Vec2 +Mat3 :: type [3]Vec3 +Mat4 :: type [4]Vec4 sqrt32 :: proc(x: f32) -> f32 #foreign "llvm.sqrt.f32" @@ -47,42 +47,42 @@ sign64 :: proc(x: f64) -> f64 { if x >= 0 { return +1; } return -1; } copy_sign32 :: proc(x, y: f32) -> f32 { - ix := x transmute u32; - iy := y transmute u32; - ix &= 0x7fffffff; - ix |= iy & 0x80000000; - return ix transmute f32; + ix := x transmute u32 + iy := y transmute u32 + ix &= 0x7fffffff + ix |= iy & 0x80000000 + return ix transmute f32 } round32 :: proc(x: f32) -> f32 { if x >= 0 { - return floor32(x + 0.5); + return floor32(x + 0.5) } - return ceil32(x - 0.5); + return ceil32(x - 0.5) } floor32 :: proc(x: f32) -> f32 { if x >= 0 { - return x as int as f32; + return x as int as f32 } - return (x-0.5) as int as f32; + return (x-0.5) as int as f32 } ceil32 :: proc(x: f32) -> f32 { if x < 0 { - return x as int as f32; + return x as int as f32 } - return ((x as int)+1) as f32; + return ((x as int)+1) as f32 } remainder32 :: proc(x, y: f32) -> f32 { - return x - round32(x/y) * y; + return x - round32(x/y) * y } fmod32 :: proc(x, y: f32) -> f32 { - y = abs(y); - result := remainder32(abs(x), y); + y = abs(y) + result := remainder32(abs(x), y) if sign32(result) < 0 { - result += y; + result += y } - return copy_sign32(result, x); + return copy_sign32(result, x) } @@ -97,9 +97,9 @@ dot3 :: proc(a, b: Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; } dot4 :: proc(a, b: Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; } cross3 :: proc(x, y: Vec3) -> Vec3 { - a := swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1); - b := swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0); - return a - b; + a := swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1) + b := swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0) + return a - b } @@ -112,27 +112,27 @@ vec3_norm :: proc(v: Vec3) -> Vec3 { return v / Vec3{vec3_mag(v)}; } vec4_norm :: proc(v: Vec4) -> Vec4 { return v / Vec4{vec4_mag(v)}; } vec2_norm0 :: proc(v: Vec2) -> Vec2 { - m := vec2_mag(v); + m := vec2_mag(v) if m == 0 { - return Vec2{0}; + return Vec2{0} } - return v / Vec2{m}; + return v / Vec2{m} } vec3_norm0 :: proc(v: Vec3) -> Vec3 { - m := vec3_mag(v); + m := vec3_mag(v) if m == 0 { - return Vec3{0}; + return Vec3{0} } - return v / Vec3{m}; + return v / Vec3{m} } vec4_norm0 :: proc(v: Vec4) -> Vec4 { - m := vec4_mag(v); + m := vec4_mag(v) if m == 0 { - return Vec4{0}; + return Vec4{0} } - return v / Vec4{m}; + return v / Vec4{m} } @@ -143,29 +143,29 @@ mat4_identity :: proc() -> Mat4 { {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}, - }; + } } mat4_transpose :: proc(m: Mat4) -> Mat4 { for j := 0; j < 4; j++ { for i := 0; i < 4; i++ { - m[i][j], m[j][i] = m[j][i], m[i][j]; + m[i][j], m[j][i] = m[j][i], m[i][j] } } - return m; + return m } mat4_mul :: proc(a, b: Mat4) -> Mat4 { - c: Mat4; + c: Mat4 for j := 0; j < 4; j++ { for i := 0; i < 4; i++ { c[j][i] = a[0][i]*b[j][0] + a[1][i]*b[j][1] + a[2][i]*b[j][2] - + a[3][i]*b[j][3]; + + a[3][i]*b[j][3] } } - return c; + return c } mat4_mul_vec4 :: proc(m: Mat4, v: Vec4) -> Vec4 { @@ -174,197 +174,197 @@ mat4_mul_vec4 :: proc(m: Mat4, v: Vec4) -> Vec4 { m[0][1]*v.x + m[1][1]*v.y + m[2][1]*v.z + m[3][1]*v.w, m[0][2]*v.x + m[1][2]*v.y + m[2][2]*v.z + m[3][2]*v.w, m[0][3]*v.x + m[1][3]*v.y + m[2][3]*v.z + m[3][3]*v.w, - }; + } } mat4_inverse :: proc(m: Mat4) -> Mat4 { - o: Mat4; + o: Mat4 - sf00 := m[2][2] * m[3][3] - m[3][2] * m[2][3]; - sf01 := m[2][1] * m[3][3] - m[3][1] * m[2][3]; - sf02 := m[2][1] * m[3][2] - m[3][1] * m[2][2]; - sf03 := m[2][0] * m[3][3] - m[3][0] * m[2][3]; - sf04 := m[2][0] * m[3][2] - m[3][0] * m[2][2]; - sf05 := m[2][0] * m[3][1] - m[3][0] * m[2][1]; - sf06 := m[1][2] * m[3][3] - m[3][2] * m[1][3]; - sf07 := m[1][1] * m[3][3] - m[3][1] * m[1][3]; - sf08 := m[1][1] * m[3][2] - m[3][1] * m[1][2]; - sf09 := m[1][0] * m[3][3] - m[3][0] * m[1][3]; - sf10 := m[1][0] * m[3][2] - m[3][0] * m[1][2]; - sf11 := m[1][1] * m[3][3] - m[3][1] * m[1][3]; - sf12 := m[1][0] * m[3][1] - m[3][0] * m[1][1]; - sf13 := m[1][2] * m[2][3] - m[2][2] * m[1][3]; - sf14 := m[1][1] * m[2][3] - m[2][1] * m[1][3]; - sf15 := m[1][1] * m[2][2] - m[2][1] * m[1][2]; - sf16 := m[1][0] * m[2][3] - m[2][0] * m[1][3]; - sf17 := m[1][0] * m[2][2] - m[2][0] * m[1][2]; - sf18 := m[1][0] * m[2][1] - m[2][0] * m[1][1]; + sf00 := m[2][2] * m[3][3] - m[3][2] * m[2][3] + sf01 := m[2][1] * m[3][3] - m[3][1] * m[2][3] + sf02 := m[2][1] * m[3][2] - m[3][1] * m[2][2] + sf03 := m[2][0] * m[3][3] - m[3][0] * m[2][3] + sf04 := m[2][0] * m[3][2] - m[3][0] * m[2][2] + sf05 := m[2][0] * m[3][1] - m[3][0] * m[2][1] + sf06 := m[1][2] * m[3][3] - m[3][2] * m[1][3] + sf07 := m[1][1] * m[3][3] - m[3][1] * m[1][3] + sf08 := m[1][1] * m[3][2] - m[3][1] * m[1][2] + sf09 := m[1][0] * m[3][3] - m[3][0] * m[1][3] + sf10 := m[1][0] * m[3][2] - m[3][0] * m[1][2] + sf11 := m[1][1] * m[3][3] - m[3][1] * m[1][3] + sf12 := m[1][0] * m[3][1] - m[3][0] * m[1][1] + sf13 := m[1][2] * m[2][3] - m[2][2] * m[1][3] + sf14 := m[1][1] * m[2][3] - m[2][1] * m[1][3] + sf15 := m[1][1] * m[2][2] - m[2][1] * m[1][2] + sf16 := m[1][0] * m[2][3] - m[2][0] * m[1][3] + sf17 := m[1][0] * m[2][2] - m[2][0] * m[1][2] + sf18 := m[1][0] * m[2][1] - m[2][0] * m[1][1] - o[0][0] = +(m[1][1] * sf00 - m[1][2] * sf01 + m[1][3] * sf02); - o[0][1] = -(m[1][0] * sf00 - m[1][2] * sf03 + m[1][3] * sf04); - o[0][2] = +(m[1][0] * sf01 - m[1][1] * sf03 + m[1][3] * sf05); - o[0][3] = -(m[1][0] * sf02 - m[1][1] * sf04 + m[1][2] * sf05); + o[0][0] = +(m[1][1] * sf00 - m[1][2] * sf01 + m[1][3] * sf02) + o[0][1] = -(m[1][0] * sf00 - m[1][2] * sf03 + m[1][3] * sf04) + o[0][2] = +(m[1][0] * sf01 - m[1][1] * sf03 + m[1][3] * sf05) + o[0][3] = -(m[1][0] * sf02 - m[1][1] * sf04 + m[1][2] * sf05) - o[1][0] = -(m[0][1] * sf00 - m[0][2] * sf01 + m[0][3] * sf02); - o[1][1] = +(m[0][0] * sf00 - m[0][2] * sf03 + m[0][3] * sf04); - o[1][2] = -(m[0][0] * sf01 - m[0][1] * sf03 + m[0][3] * sf05); - o[1][3] = +(m[0][0] * sf02 - m[0][1] * sf04 + m[0][2] * sf05); + o[1][0] = -(m[0][1] * sf00 - m[0][2] * sf01 + m[0][3] * sf02) + o[1][1] = +(m[0][0] * sf00 - m[0][2] * sf03 + m[0][3] * sf04) + o[1][2] = -(m[0][0] * sf01 - m[0][1] * sf03 + m[0][3] * sf05) + o[1][3] = +(m[0][0] * sf02 - m[0][1] * sf04 + m[0][2] * sf05) - o[2][0] = +(m[0][1] * sf06 - m[0][2] * sf07 + m[0][3] * sf08); - o[2][1] = -(m[0][0] * sf06 - m[0][2] * sf09 + m[0][3] * sf10); - o[2][2] = +(m[0][0] * sf11 - m[0][1] * sf09 + m[0][3] * sf12); - o[2][3] = -(m[0][0] * sf08 - m[0][1] * sf10 + m[0][2] * sf12); + o[2][0] = +(m[0][1] * sf06 - m[0][2] * sf07 + m[0][3] * sf08) + o[2][1] = -(m[0][0] * sf06 - m[0][2] * sf09 + m[0][3] * sf10) + o[2][2] = +(m[0][0] * sf11 - m[0][1] * sf09 + m[0][3] * sf12) + o[2][3] = -(m[0][0] * sf08 - m[0][1] * sf10 + m[0][2] * sf12) - o[3][0] = -(m[0][1] * sf13 - m[0][2] * sf14 + m[0][3] * sf15); - o[3][1] = +(m[0][0] * sf13 - m[0][2] * sf16 + m[0][3] * sf17); - o[3][2] = -(m[0][0] * sf14 - m[0][1] * sf16 + m[0][3] * sf18); - o[3][3] = +(m[0][0] * sf15 - m[0][1] * sf17 + m[0][2] * sf18); + o[3][0] = -(m[0][1] * sf13 - m[0][2] * sf14 + m[0][3] * sf15) + o[3][1] = +(m[0][0] * sf13 - m[0][2] * sf16 + m[0][3] * sf17) + o[3][2] = -(m[0][0] * sf14 - m[0][1] * sf16 + m[0][3] * sf18) + o[3][3] = +(m[0][0] * sf15 - m[0][1] * sf17 + m[0][2] * sf18) ood := 1.0 / (m[0][0] * o[0][0] + m[0][1] * o[0][1] + m[0][2] * o[0][2] + - m[0][3] * o[0][3]); + m[0][3] * o[0][3]) - o[0][0] *= ood; - o[0][1] *= ood; - o[0][2] *= ood; - o[0][3] *= ood; - o[1][0] *= ood; - o[1][1] *= ood; - o[1][2] *= ood; - o[1][3] *= ood; - o[2][0] *= ood; - o[2][1] *= ood; - o[2][2] *= ood; - o[2][3] *= ood; - o[3][0] *= ood; - o[3][1] *= ood; - o[3][2] *= ood; - o[3][3] *= ood; + o[0][0] *= ood + o[0][1] *= ood + o[0][2] *= ood + o[0][3] *= ood + o[1][0] *= ood + o[1][1] *= ood + o[1][2] *= ood + o[1][3] *= ood + o[2][0] *= ood + o[2][1] *= ood + o[2][2] *= ood + o[2][3] *= ood + o[3][0] *= ood + o[3][1] *= ood + o[3][2] *= ood + o[3][3] *= ood - return o; + return o } mat4_translate :: proc(v: Vec3) -> Mat4 { - m := mat4_identity(); - m[3][0] = v.x; - m[3][1] = v.y; - m[3][2] = v.z; - m[3][3] = 1; - return m; + m := mat4_identity() + m[3][0] = v.x + m[3][1] = v.y + m[3][2] = v.z + m[3][3] = 1 + return m } mat4_rotate :: proc(v: Vec3, angle_radians: f32) -> Mat4 { - c := cos32(angle_radians); - s := sin32(angle_radians); + c := cos32(angle_radians) + s := sin32(angle_radians) - a := vec3_norm(v); - t := a * Vec3{1-c}; + a := vec3_norm(v) + t := a * Vec3{1-c} - rot := mat4_identity(); + rot := mat4_identity() - rot[0][0] = c + t.x*a.x; - rot[0][1] = 0 + t.x*a.y + s*a.z; - rot[0][2] = 0 + t.x*a.z - s*a.y; - rot[0][3] = 0; + rot[0][0] = c + t.x*a.x + rot[0][1] = 0 + t.x*a.y + s*a.z + rot[0][2] = 0 + t.x*a.z - s*a.y + rot[0][3] = 0 - rot[1][0] = 0 + t.y*a.x - s*a.z; - rot[1][1] = c + t.y*a.y; - rot[1][2] = 0 + t.y*a.z + s*a.x; - rot[1][3] = 0; + rot[1][0] = 0 + t.y*a.x - s*a.z + rot[1][1] = c + t.y*a.y + rot[1][2] = 0 + t.y*a.z + s*a.x + rot[1][3] = 0 - rot[2][0] = 0 + t.z*a.x + s*a.y; - rot[2][1] = 0 + t.z*a.y - s*a.x; - rot[2][2] = c + t.z*a.z; - rot[2][3] = 0; + rot[2][0] = 0 + t.z*a.x + s*a.y + rot[2][1] = 0 + t.z*a.y - s*a.x + rot[2][2] = c + t.z*a.z + rot[2][3] = 0 - return rot; + return rot } mat4_scale :: proc(m: Mat4, v: Vec3) -> Mat4 { - m[0][0] = v.x; - m[1][1] = v.y; - m[2][2] = v.z; - return m; + m[0][0] = v.x + m[1][1] = v.y + m[2][2] = v.z + return m } mat4_scalef :: proc(m: Mat4, s: f32) -> Mat4 { - m[0][0] = s; - m[1][1] = s; - m[2][2] = s; - return m; + m[0][0] = s + m[1][1] = s + m[2][2] = s + return m } mat4_look_at :: proc(eye, centre, up: Vec3) -> Mat4 { - f := vec3_norm(centre - eye); - s := vec3_norm(cross3(f, up)); - u := cross3(s, f); + f := vec3_norm(centre - eye) + s := vec3_norm(cross3(f, up)) + u := cross3(s, f) - m: Mat4; + m: Mat4 - m[0] = Vec4{+s.x, +s.y, +s.z, 0}; - m[1] = Vec4{+u.x, +u.y, +u.z, 0}; - m[2] = Vec4{-f.x, -f.y, -f.z, 0}; - m[3] = Vec4{dot3(s, eye), dot3(u, eye), dot3(f, eye), 1}; + m[0] = Vec4{+s.x, +s.y, +s.z, 0} + m[1] = Vec4{+u.x, +u.y, +u.z, 0} + m[2] = Vec4{-f.x, -f.y, -f.z, 0} + m[3] = Vec4{dot3(s, eye), dot3(u, eye), dot3(f, eye), 1} - return m; + return m } mat4_perspective :: proc(fovy, aspect, near, far: f32) -> Mat4 { - m: Mat4; - tan_half_fovy := tan32(0.5 * fovy); - m[0][0] = 1.0 / (aspect*tan_half_fovy); - m[1][1] = 1.0 / (tan_half_fovy); - m[2][2] = -(far + near) / (far - near); - m[2][3] = -1.0; - m[3][2] = -2.0*far*near / (far - near); - return m; + m: Mat4 + tan_half_fovy := tan32(0.5 * fovy) + m[0][0] = 1.0 / (aspect*tan_half_fovy) + m[1][1] = 1.0 / (tan_half_fovy) + m[2][2] = -(far + near) / (far - near) + m[2][3] = -1.0 + m[3][2] = -2.0*far*near / (far - near) + return m } mat4_ortho3d :: proc(left, right, bottom, top, near, far: f32) -> Mat4 { - m := mat4_identity(); + m := mat4_identity() - m[0][0] = +2.0 / (right - left); - m[1][1] = +2.0 / (top - bottom); - m[2][2] = -2.0 / (far - near); - m[3][0] = -(right + left) / (right - left); - m[3][1] = -(top + bottom) / (top - bottom); - m[3][2] = -(far + near) / (far - near); + m[0][0] = +2.0 / (right - left) + m[1][1] = +2.0 / (top - bottom) + m[2][2] = -2.0 / (far - near) + m[3][0] = -(right + left) / (right - left) + m[3][1] = -(top + bottom) / (top - bottom) + m[3][2] = -(far + near) / (far - near) - return m; + return m } -F32_DIG :: 6; -F32_EPSILON :: 1.192092896e-07; -F32_GUARD :: 0; -F32_MANT_DIG :: 24; -F32_MAX :: 3.402823466e+38; -F32_MAX_10_EXP :: 38; -F32_MAX_EXP :: 128; -F32_MIN :: 1.175494351e-38; -F32_MIN_10_EXP :: -37; -F32_MIN_EXP :: -125; -F32_NORMALIZE :: 0; -F32_RADIX :: 2; -F32_ROUNDS :: 1; +F32_DIG :: 6 +F32_EPSILON :: 1.192092896e-07 +F32_GUARD :: 0 +F32_MANT_DIG :: 24 +F32_MAX :: 3.402823466e+38 +F32_MAX_10_EXP :: 38 +F32_MAX_EXP :: 128 +F32_MIN :: 1.175494351e-38 +F32_MIN_10_EXP :: -37 +F32_MIN_EXP :: -125 +F32_NORMALIZE :: 0 +F32_RADIX :: 2 +F32_ROUNDS :: 1 -F64_DIG :: 15; // # of decimal digits of precision -F64_EPSILON :: 2.2204460492503131e-016; // smallest such that 1.0+F64_EPSILON != 1.0 -F64_MANT_DIG :: 53; // # of bits in mantissa -F64_MAX :: 1.7976931348623158e+308; // max value -F64_MAX_10_EXP :: 308; // max decimal exponent -F64_MAX_EXP :: 1024; // max binary exponent -F64_MIN :: 2.2250738585072014e-308; // min positive value -F64_MIN_10_EXP :: -307; // min decimal exponent -F64_MIN_EXP :: -1021; // min binary exponent -F64_RADIX :: 2; // exponent radix -F64_ROUNDS :: 1; // addition rounding: near +F64_DIG :: 15 // # of decimal digits of precision +F64_EPSILON :: 2.2204460492503131e-016 // smallest such that 1.0+F64_EPSILON != 1.0 +F64_MANT_DIG :: 53 // # of bits in mantissa +F64_MAX :: 1.7976931348623158e+308 // max value +F64_MAX_10_EXP :: 308 // max decimal exponent +F64_MAX_EXP :: 1024 // max binary exponent +F64_MIN :: 2.2250738585072014e-308 // min positive value +F64_MIN_10_EXP :: -307 // min decimal exponent +F64_MIN_EXP :: -1021 // min binary exponent +F64_RADIX :: 2 // exponent radix +F64_ROUNDS :: 1 // addition rounding: near diff --git a/core/mem.odin b/core/mem.odin index 60335fe43..719c2c073 100644 --- a/core/mem.odin +++ b/core/mem.odin @@ -1,51 +1,51 @@ -#import "fmt.odin"; -#import "os.odin"; +#import "fmt.odin" +#import "os.odin" set :: proc(data: rawptr, value: i32, len: int) -> rawptr #link_name "__mem_set" { llvm_memset_64bit :: proc(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign "llvm.memset.p0i8.i64" - llvm_memset_64bit(data, value as byte, len, 1, false); - return data; + llvm_memset_64bit(data, value as byte, len, 1, false) + return data } zero :: proc(data: rawptr, len: int) -> rawptr { - return set(data, 0, len); + return set(data, 0, len) } copy :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy" { // NOTE(bill): This _must_ implemented like C's memmove llvm_memmove_64bit :: proc(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign "llvm.memmove.p0i8.p0i8.i64" - llvm_memmove_64bit(dst, src, len, 1, false); - return dst; + llvm_memmove_64bit(dst, src, len, 1, false) + return dst } copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy_non_overlapping" { // NOTE(bill): This _must_ implemented like C's memcpy llvm_memcpy_64bit :: proc(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign "llvm.memcpy.p0i8.p0i8.i64" - llvm_memcpy_64bit(dst, src, len, 1, false); - return dst; + llvm_memcpy_64bit(dst, src, len, 1, false) + return dst } compare :: proc(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" { // Translation of http://mgronhol.github.io/fast-strcmp/ - a := slice_ptr(dst as ^byte, n); - b := slice_ptr(src as ^byte, n); + a := slice_ptr(dst as ^byte, n) + b := slice_ptr(src as ^byte, n) - fast := n/size_of(int) + 1; - offset := (fast-1)*size_of(int); - curr_block := 0; + fast := n/size_of(int) + 1 + offset := (fast-1)*size_of(int) + curr_block := 0 if n <= size_of(int) { - fast = 0; + fast = 0 } - la := slice_ptr(^a[0] as ^int, fast); - lb := slice_ptr(^b[0] as ^int, fast); + la := slice_ptr(^a[0] as ^int, fast) + lb := slice_ptr(^b[0] as ^int, fast) for ; curr_block < fast; curr_block++ { if (la[curr_block] ~ lb[curr_block]) != 0 { for pos := curr_block*size_of(int); pos < n; pos++ { if (a[pos] ~ b[pos]) != 0 { - return a[pos] as int - b[pos] as int; + return a[pos] as int - b[pos] as int } } } @@ -54,11 +54,11 @@ compare :: proc(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" { for ; offset < n; offset++ { if (a[offset] ~ b[offset]) != 0 { - return a[offset] as int - b[offset] as int; + return a[offset] as int - b[offset] as int } } - return 0; + return 0 } @@ -70,42 +70,42 @@ terabytes :: proc(x: int) -> int #inline { return terabytes(x) * 1024; } is_power_of_two :: proc(x: int) -> bool { if x <= 0 { - return false; + return false } - return (x & (x-1)) == 0; + return (x & (x-1)) == 0 } align_forward :: proc(ptr: rawptr, align: int) -> rawptr { - assert(is_power_of_two(align)); + assert(is_power_of_two(align)) - a := align as uint; - p := ptr as uint; - modulo := p & (a-1); + a := align as uint + p := ptr as uint + modulo := p & (a-1) if modulo != 0 { - p += a - modulo; + p += a - modulo } - return p as rawptr; + return p as rawptr } AllocationHeader :: struct { - size: int; + size: int } allocation_header_fill :: proc(header: ^AllocationHeader, data: rawptr, size: int) { - header.size = size; - ptr := (header+1) as ^int; + header.size = size + ptr := (header+1) as ^int for i := 0; ptr as rawptr < data; i++ { - (ptr+i)^ = -1; + (ptr+i)^ = -1 } } allocation_header :: proc(data: rawptr) -> ^AllocationHeader { - p := data as ^int; + p := data as ^int for (p-1)^ == -1 { - p = (p-1); + p = (p-1) } - return (p as ^AllocationHeader)-1; + return (p as ^AllocationHeader)-1 } @@ -115,13 +115,13 @@ allocation_header :: proc(data: rawptr) -> ^AllocationHeader { // Custom allocators Arena :: struct { - backing: Allocator; - memory: []byte; - temp_count: int; + backing: Allocator + memory: []byte + temp_count: int Temp_Memory :: struct { - arena: ^Arena; - original_count: int; + arena: ^Arena + original_count: int } } @@ -130,22 +130,22 @@ Arena :: struct { init_arena_from_memory :: proc(using a: ^Arena, data: []byte) { - backing = Allocator{}; - memory = data[:0]; - temp_count = 0; + backing = Allocator{} + memory = data[:0] + temp_count = 0 } init_arena_from_context :: proc(using a: ^Arena, size: int) { - backing = context.allocator; - memory = new_slice(byte, 0, size); - temp_count = 0; + backing = context.allocator + memory = new_slice(byte, 0, size) + temp_count = 0 } free_arena :: proc(using a: ^Arena) { if backing.procedure != nil { push_allocator backing { - free(memory.data); - memory = memory[0:0:0]; + free(memory.data) + memory = memory[0:0:0] } } } @@ -154,57 +154,57 @@ arena_allocator :: proc(arena: ^Arena) -> Allocator { return Allocator{ procedure = arena_allocator_proc, data = arena, - }; + } } arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator.Mode, size, alignment: int, old_memory: rawptr, old_size: int, flags: u64) -> rawptr { - arena := allocator_data as ^Arena; + arena := allocator_data as ^Arena - using Allocator.Mode; + using Allocator.Mode match mode { case ALLOC: - total_size := size + alignment; + total_size := size + alignment if arena.memory.count + total_size > arena.memory.capacity { - fmt.fprintln(os.stderr, "Arena out of memory"); - return nil; + fmt.fprintln(os.stderr, "Arena out of memory") + return nil } - #no_bounds_check end := ^arena.memory[arena.memory.count]; + #no_bounds_check end := ^arena.memory[arena.memory.count] - ptr := align_forward(end, alignment); - arena.memory.count += total_size; - return zero(ptr, size); + ptr := align_forward(end, alignment) + arena.memory.count += total_size + return zero(ptr, size) case FREE: // NOTE(bill): Free all at once // Use Arena.Temp_Memory if you want to free a block case FREE_ALL: - arena.memory.count = 0; + arena.memory.count = 0 case RESIZE: - return default_resize_align(old_memory, old_size, size, alignment); + return default_resize_align(old_memory, old_size, size, alignment) } - return nil; + return nil } begin_arena_temp_memory :: proc(a: ^Arena) -> Arena.Temp_Memory { - tmp: Arena.Temp_Memory; - tmp.arena = a; - tmp.original_count = a.memory.count; - a.temp_count++; - return tmp; + tmp: Arena.Temp_Memory + tmp.arena = a + tmp.original_count = a.memory.count + a.temp_count++ + return tmp } end_arena_temp_memory :: proc(using tmp: Arena.Temp_Memory) { - assert(arena.memory.count >= original_count); - assert(arena.temp_count > 0); - arena.memory.count = original_count; - arena.temp_count--; + assert(arena.memory.count >= original_count) + assert(arena.temp_count > 0) + arena.memory.count = original_count + arena.temp_count-- } @@ -214,119 +214,119 @@ end_arena_temp_memory :: proc(using tmp: Arena.Temp_Memory) { align_of_type_info :: proc(type_info: ^Type_Info) -> int { - WORD_SIZE :: size_of(int); - using Type_Info; + WORD_SIZE :: size_of(int) + using Type_Info match type info : type_info { case Named: - return align_of_type_info(info.base); + return align_of_type_info(info.base) case Integer: - return info.size; + return info.size case Float: - return info.size; + return info.size case String: - return WORD_SIZE; + return WORD_SIZE case Boolean: - return 1; + return 1 case Pointer: - return WORD_SIZE; + return WORD_SIZE case Maybe: - return max(align_of_type_info(info.elem), 1); + return max(align_of_type_info(info.elem), 1) case Procedure: - return WORD_SIZE; + return WORD_SIZE case Array: - return align_of_type_info(info.elem); + return align_of_type_info(info.elem) case Slice: - return WORD_SIZE; + return WORD_SIZE case Vector: - return align_of_type_info(info.elem); + return align_of_type_info(info.elem) case Struct: - return info.align; + return info.align case Union: - return info.align; + return info.align case Raw_Union: - return info.align; + return info.align case Enum: - return align_of_type_info(info.base); + return align_of_type_info(info.base) } - return 0; + return 0 } align_formula :: proc(size, align: int) -> int { - result := size + align-1; - return result - result%align; + result := size + align-1 + return result - result%align } size_of_type_info :: proc(type_info: ^Type_Info) -> int { - WORD_SIZE :: size_of(int); - using Type_Info; + WORD_SIZE :: size_of(int) + using Type_Info match type info : type_info { case Named: - return size_of_type_info(info.base); + return size_of_type_info(info.base) case Integer: - return info.size; + return info.size case Float: - return info.size; + return info.size case Any: - return 2*WORD_SIZE; + return 2*WORD_SIZE case String: - return 2*WORD_SIZE; + return 2*WORD_SIZE case Boolean: - return 1; + return 1 case Pointer: - return WORD_SIZE; + return WORD_SIZE case Maybe: - return size_of_type_info(info.elem) + 1; + return size_of_type_info(info.elem) + 1 case Procedure: - return WORD_SIZE; + return WORD_SIZE case Array: - count := info.count; + count := info.count if count == 0 { - return 0; + return 0 } - size := size_of_type_info(info.elem); - align := align_of_type_info(info.elem); - alignment := align_formula(size, align); - return alignment*(count-1) + size; + size := size_of_type_info(info.elem) + align := align_of_type_info(info.elem) + alignment := align_formula(size, align) + return alignment*(count-1) + size case Slice: - return 3*WORD_SIZE; + return 3*WORD_SIZE case Vector: is_bool :: proc(type_info: ^Type_Info) -> bool { match type info : type_info { case Named: - return is_bool(info.base); + return is_bool(info.base) case Boolean: - return true; + return true } - return false; + return false } - count := info.count; + count := info.count if count == 0 { - return 0; + return 0 } - bit_size := 8*size_of_type_info(info.elem); + bit_size := 8*size_of_type_info(info.elem) if is_bool(info.elem) { // NOTE(bill): LLVM can store booleans as 1 bit because a boolean _is_ an `i1` // Silly LLVM spec - bit_size = 1; + bit_size = 1 } - total_size_in_bits := bit_size * count; - total_size := (total_size_in_bits+7)/8; - return total_size; + total_size_in_bits := bit_size * count + total_size := (total_size_in_bits+7)/8 + return total_size case Struct: - return info.size; + return info.size case Union: - return info.size; + return info.size case Raw_Union: - return info.size; + return info.size case Enum: - return size_of_type_info(info.base); + return size_of_type_info(info.base) } - return 0; + return 0 } diff --git a/core/opengl.odin b/core/opengl.odin index d67e9c7cb..3e546b9ca 100644 --- a/core/opengl.odin +++ b/core/opengl.odin @@ -1,6 +1,6 @@ -#foreign_system_library "opengl32" when ODIN_OS == "windows"; -#import "win32.odin" when ODIN_OS == "windows"; -#include "opengl_constants.odin"; +#foreign_system_library "opengl32" when ODIN_OS == "windows" +#import "win32.odin" when ODIN_OS == "windows" +#include "opengl_constants.odin" Clear :: proc(mask: u32) #foreign "glClear" ClearColor :: proc(r, g, b, a: f32) #foreign "glClearColor" @@ -30,126 +30,126 @@ GetIntegerv :: proc(name: i32, v: ^i32) #foreign "glGetIntegerv" -_libgl := win32.LoadLibraryA(("opengl32.dll\x00" as string).data); +_libgl := win32.LoadLibraryA(("opengl32.dll\x00" as string).data) GetProcAddress :: proc(name: string) -> proc() { - assert(name[name.count-1] == 0); - res := win32.wglGetProcAddress(name.data); + assert(name[name.count-1] == 0) + res := win32.wglGetProcAddress(name.data) if res == nil { - res = win32.GetProcAddress(_libgl, name.data); + res = win32.GetProcAddress(_libgl, name.data) } - return res; + return res } -GenBuffers: proc(count: i32, buffers: ^u32); -GenVertexArrays: proc(count: i32, buffers: ^u32); -GenSamplers: proc(count: i32, buffers: ^u32); -BindBuffer: proc(target: i32, buffer: u32); -BindVertexArray: proc(buffer: u32); -BindSampler: proc(position: i32, sampler: u32); -BufferData: proc(target: i32, size: int, data: rawptr, usage: i32); -BufferSubData: proc(target: i32, offset, size: int, data: rawptr); +GenBuffers: proc(count: i32, buffers: ^u32) +GenVertexArrays: proc(count: i32, buffers: ^u32) +GenSamplers: proc(count: i32, buffers: ^u32) +BindBuffer: proc(target: i32, buffer: u32) +BindVertexArray: proc(buffer: u32) +BindSampler: proc(position: i32, sampler: u32) +BufferData: proc(target: i32, size: int, data: rawptr, usage: i32) +BufferSubData: proc(target: i32, offset, size: int, data: rawptr) -DrawArrays: proc(mode, first: i32, count: u32); -DrawElements: proc(mode: i32, count: u32, type_: i32, indices: rawptr); +DrawArrays: proc(mode, first: i32, count: u32) +DrawElements: proc(mode: i32, count: u32, type_: i32, indices: rawptr) -MapBuffer: proc(target, access: i32) -> rawptr; -UnmapBuffer: proc(target: i32); +MapBuffer: proc(target, access: i32) -> rawptr +UnmapBuffer: proc(target: i32) -VertexAttribPointer: proc(index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr); -EnableVertexAttribArray: proc(index: u32); +VertexAttribPointer: proc(index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr) +EnableVertexAttribArray: proc(index: u32) -CreateShader: proc(shader_type: i32) -> u32; -ShaderSource: proc(shader: u32, count: u32, string: ^^byte, length: ^i32); -CompileShader: proc(shader: u32); -CreateProgram: proc() -> u32; -AttachShader: proc(program, shader: u32); -DetachShader: proc(program, shader: u32); -DeleteShader: proc(shader: u32); -LinkProgram: proc(program: u32); -UseProgram: proc(program: u32); -DeleteProgram: proc(program: u32); +CreateShader: proc(shader_type: i32) -> u32 +ShaderSource: proc(shader: u32, count: u32, string: ^^byte, length: ^i32) +CompileShader: proc(shader: u32) +CreateProgram: proc() -> u32 +AttachShader: proc(program, shader: u32) +DetachShader: proc(program, shader: u32) +DeleteShader: proc(shader: u32) +LinkProgram: proc(program: u32) +UseProgram: proc(program: u32) +DeleteProgram: proc(program: u32) -GetShaderiv: proc(shader: u32, pname: i32, params: ^i32); -GetProgramiv: proc(program: u32, pname: i32, params: ^i32); -GetShaderInfoLog: proc(shader: u32, max_length: u32, length: ^u32, info_long: ^byte); -GetProgramInfoLog: proc(program: u32, max_length: u32, length: ^u32, info_long: ^byte); +GetShaderiv: proc(shader: u32, pname: i32, params: ^i32) +GetProgramiv: proc(program: u32, pname: i32, params: ^i32) +GetShaderInfoLog: proc(shader: u32, max_length: u32, length: ^u32, info_long: ^byte) +GetProgramInfoLog: proc(program: u32, max_length: u32, length: ^u32, info_long: ^byte) -ActiveTexture: proc(texture: i32); -GenerateMipmap: proc(target: i32); +ActiveTexture: proc(texture: i32) +GenerateMipmap: proc(target: i32) -SamplerParameteri: proc(sampler: u32, pname: i32, param: i32); -SamplerParameterf: proc(sampler: u32, pname: i32, param: f32); -SamplerParameteriv: proc(sampler: u32, pname: i32, params: ^i32); -SamplerParameterfv: proc(sampler: u32, pname: i32, params: ^f32); -SamplerParameterIiv: proc(sampler: u32, pname: i32, params: ^i32); -SamplerParameterIuiv: proc(sampler: u32, pname: i32, params: ^u32); +SamplerParameteri: proc(sampler: u32, pname: i32, param: i32) +SamplerParameterf: proc(sampler: u32, pname: i32, param: f32) +SamplerParameteriv: proc(sampler: u32, pname: i32, params: ^i32) +SamplerParameterfv: proc(sampler: u32, pname: i32, params: ^f32) +SamplerParameterIiv: proc(sampler: u32, pname: i32, params: ^i32) +SamplerParameterIuiv: proc(sampler: u32, pname: i32, params: ^u32) -Uniform1i: proc(loc: i32, v0: i32); -Uniform2i: proc(loc: i32, v0, v1: i32); -Uniform3i: proc(loc: i32, v0, v1, v2: i32); -Uniform4i: proc(loc: i32, v0, v1, v2, v3: i32); -Uniform1f: proc(loc: i32, v0: f32); -Uniform2f: proc(loc: i32, v0, v1: f32); -Uniform3f: proc(loc: i32, v0, v1, v2: f32); -Uniform4f: proc(loc: i32, v0, v1, v2, v3: f32); -UniformMatrix4fv: proc(loc: i32, count: u32, transpose: i32, value: ^f32); +Uniform1i: proc(loc: i32, v0: i32) +Uniform2i: proc(loc: i32, v0, v1: i32) +Uniform3i: proc(loc: i32, v0, v1, v2: i32) +Uniform4i: proc(loc: i32, v0, v1, v2, v3: i32) +Uniform1f: proc(loc: i32, v0: f32) +Uniform2f: proc(loc: i32, v0, v1: f32) +Uniform3f: proc(loc: i32, v0, v1, v2: f32) +Uniform4f: proc(loc: i32, v0, v1, v2, v3: f32) +UniformMatrix4fv: proc(loc: i32, count: u32, transpose: i32, value: ^f32) -GetUniformLocation: proc(program: u32, name: ^byte) -> i32; +GetUniformLocation: proc(program: u32, name: ^byte) -> i32 init :: proc() { set_proc_address :: proc(p: rawptr, name: string) #inline { (p as ^proc())^ = GetProcAddress(name); } - set_proc_address(^GenBuffers, "glGenBuffers\x00"); - set_proc_address(^GenVertexArrays, "glGenVertexArrays\x00"); - set_proc_address(^GenSamplers, "glGenSamplers\x00"); - set_proc_address(^BindBuffer, "glBindBuffer\x00"); - set_proc_address(^BindSampler, "glBindSampler\x00"); - set_proc_address(^BindVertexArray, "glBindVertexArray\x00"); - set_proc_address(^BufferData, "glBufferData\x00"); - set_proc_address(^BufferSubData, "glBufferSubData\x00"); + set_proc_address(^GenBuffers, "glGenBuffers\x00") + set_proc_address(^GenVertexArrays, "glGenVertexArrays\x00") + set_proc_address(^GenSamplers, "glGenSamplers\x00") + set_proc_address(^BindBuffer, "glBindBuffer\x00") + set_proc_address(^BindSampler, "glBindSampler\x00") + set_proc_address(^BindVertexArray, "glBindVertexArray\x00") + set_proc_address(^BufferData, "glBufferData\x00") + set_proc_address(^BufferSubData, "glBufferSubData\x00") - set_proc_address(^DrawArrays, "glDrawArrays\x00"); - set_proc_address(^DrawElements, "glDrawElements\x00"); + set_proc_address(^DrawArrays, "glDrawArrays\x00") + set_proc_address(^DrawElements, "glDrawElements\x00") - set_proc_address(^MapBuffer, "glMapBuffer\x00"); - set_proc_address(^UnmapBuffer, "glUnmapBuffer\x00"); + set_proc_address(^MapBuffer, "glMapBuffer\x00") + set_proc_address(^UnmapBuffer, "glUnmapBuffer\x00") - set_proc_address(^VertexAttribPointer, "glVertexAttribPointer\x00"); - set_proc_address(^EnableVertexAttribArray, "glEnableVertexAttribArray\x00"); + set_proc_address(^VertexAttribPointer, "glVertexAttribPointer\x00") + set_proc_address(^EnableVertexAttribArray, "glEnableVertexAttribArray\x00") - set_proc_address(^CreateShader, "glCreateShader\x00"); - set_proc_address(^ShaderSource, "glShaderSource\x00"); - set_proc_address(^CompileShader, "glCompileShader\x00"); - set_proc_address(^CreateProgram, "glCreateProgram\x00"); - set_proc_address(^AttachShader, "glAttachShader\x00"); - set_proc_address(^DetachShader, "glDetachShader\x00"); - set_proc_address(^DeleteShader, "glDeleteShader\x00"); - set_proc_address(^LinkProgram, "glLinkProgram\x00"); - set_proc_address(^UseProgram, "glUseProgram\x00"); - set_proc_address(^DeleteProgram, "glDeleteProgram\x00"); + set_proc_address(^CreateShader, "glCreateShader\x00") + set_proc_address(^ShaderSource, "glShaderSource\x00") + set_proc_address(^CompileShader, "glCompileShader\x00") + set_proc_address(^CreateProgram, "glCreateProgram\x00") + set_proc_address(^AttachShader, "glAttachShader\x00") + set_proc_address(^DetachShader, "glDetachShader\x00") + set_proc_address(^DeleteShader, "glDeleteShader\x00") + set_proc_address(^LinkProgram, "glLinkProgram\x00") + set_proc_address(^UseProgram, "glUseProgram\x00") + set_proc_address(^DeleteProgram, "glDeleteProgram\x00") - set_proc_address(^GetShaderiv, "glGetShaderiv\x00"); - set_proc_address(^GetProgramiv, "glGetProgramiv\x00"); - set_proc_address(^GetShaderInfoLog, "glGetShaderInfoLog\x00"); - set_proc_address(^GetProgramInfoLog, "glGetProgramInfoLog\x00"); + set_proc_address(^GetShaderiv, "glGetShaderiv\x00") + set_proc_address(^GetProgramiv, "glGetProgramiv\x00") + set_proc_address(^GetShaderInfoLog, "glGetShaderInfoLog\x00") + set_proc_address(^GetProgramInfoLog, "glGetProgramInfoLog\x00") - set_proc_address(^ActiveTexture, "glActiveTexture\x00"); - set_proc_address(^GenerateMipmap, "glGenerateMipmap\x00"); + set_proc_address(^ActiveTexture, "glActiveTexture\x00") + set_proc_address(^GenerateMipmap, "glGenerateMipmap\x00") - set_proc_address(^Uniform1i, "glUniform1i\x00"); - set_proc_address(^UniformMatrix4fv, "glUniformMatrix4fv\x00"); + set_proc_address(^Uniform1i, "glUniform1i\x00") + set_proc_address(^UniformMatrix4fv, "glUniformMatrix4fv\x00") - set_proc_address(^GetUniformLocation, "glGetUniformLocation\x00"); + set_proc_address(^GetUniformLocation, "glGetUniformLocation\x00") - set_proc_address(^SamplerParameteri, "glSamplerParameteri\x00"); - set_proc_address(^SamplerParameterf, "glSamplerParameterf\x00"); - set_proc_address(^SamplerParameteriv, "glSamplerParameteriv\x00"); - set_proc_address(^SamplerParameterfv, "glSamplerParameterfv\x00"); - set_proc_address(^SamplerParameterIiv, "glSamplerParameterIiv\x00"); - set_proc_address(^SamplerParameterIuiv, "glSamplerParameterIuiv\x00"); + set_proc_address(^SamplerParameteri, "glSamplerParameteri\x00") + set_proc_address(^SamplerParameterf, "glSamplerParameterf\x00") + set_proc_address(^SamplerParameteriv, "glSamplerParameteriv\x00") + set_proc_address(^SamplerParameterfv, "glSamplerParameterfv\x00") + set_proc_address(^SamplerParameterIiv, "glSamplerParameterIiv\x00") + set_proc_address(^SamplerParameterIuiv, "glSamplerParameterIuiv\x00") } diff --git a/core/opengl_constants.odin b/core/opengl_constants.odin index 306f56fee..ffb1c33ec 100644 --- a/core/opengl_constants.odin +++ b/core/opengl_constants.odin @@ -1,1384 +1,1384 @@ -FALSE :: 0; -TRUE :: 1; +FALSE :: 0 +TRUE :: 1 -DEPTH_BUFFER_BIT :: 0x00000100; -STENCIL_BUFFER_BIT :: 0x00000400; -COLOR_BUFFER_BIT :: 0x00004000; -POINTS :: 0x0000; -LINES :: 0x0001; -LINE_LOOP :: 0x0002; -LINE_STRIP :: 0x0003; -TRIANGLES :: 0x0004; -TRIANGLE_STRIP :: 0x0005; -TRIANGLE_FAN :: 0x0006; -QUADS :: 0x0007; -NEVER :: 0x0200; -LESS :: 0x0201; -EQUAL :: 0x0202; -LEQUAL :: 0x0203; -GREATER :: 0x0204; -NOTEQUAL :: 0x0205; -GEQUAL :: 0x0206; -ALWAYS :: 0x0207; -ZERO :: 0; -ONE :: 1; -SRC_COLOR :: 0x0300; -ONE_MINUS_SRC_COLOR :: 0x0301; -SRC_ALPHA :: 0x0302; -ONE_MINUS_SRC_ALPHA :: 0x0303; -DST_ALPHA :: 0x0304; -ONE_MINUS_DST_ALPHA :: 0x0305; -DST_COLOR :: 0x0306; -ONE_MINUS_DST_COLOR :: 0x0307; -SRC_ALPHA_SATURATE :: 0x0308; -NONE :: 0; -FRONT_LEFT :: 0x0400; -FRONT_RIGHT :: 0x0401; -BACK_LEFT :: 0x0402; -BACK_RIGHT :: 0x0403; -FRONT :: 0x0404; -BACK :: 0x0405; -LEFT :: 0x0406; -RIGHT :: 0x0407; -FRONT_AND_BACK :: 0x0408; -NO_ERROR :: 0; -INVALID_ENUM :: 0x0500; -INVALID_VALUE :: 0x0501; -INVALID_OPERATION :: 0x0502; -OUT_OF_MEMORY :: 0x0505; -CW :: 0x0900; -CCW :: 0x0901; -POINT_SIZE :: 0x0B11; -POINT_SIZE_RANGE :: 0x0B12; -POINT_SIZE_GRANULARITY :: 0x0B13; -LINE_SMOOTH :: 0x0B20; -LINE_WIDTH :: 0x0B21; -LINE_WIDTH_RANGE :: 0x0B22; -LINE_WIDTH_GRANULARITY :: 0x0B23; -POLYGON_MODE :: 0x0B40; -POLYGON_SMOOTH :: 0x0B41; -CULL_FACE :: 0x0B44; -CULL_FACE_MODE :: 0x0B45; -FRONT_FACE :: 0x0B46; -DEPTH_RANGE :: 0x0B70; -DEPTH_TEST :: 0x0B71; -DEPTH_WRITEMASK :: 0x0B72; -DEPTH_CLEAR_VALUE :: 0x0B73; -DEPTH_FUNC :: 0x0B74; -STENCIL_TEST :: 0x0B90; -STENCIL_CLEAR_VALUE :: 0x0B91; -STENCIL_FUNC :: 0x0B92; -STENCIL_VALUE_MASK :: 0x0B93; -STENCIL_FAIL :: 0x0B94; -STENCIL_PASS_DEPTH_FAIL :: 0x0B95; -STENCIL_PASS_DEPTH_PASS :: 0x0B96; -STENCIL_REF :: 0x0B97; -STENCIL_WRITEMASK :: 0x0B98; -VIEWPORT :: 0x0BA2; -DITHER :: 0x0BD0; -BLEND_DST :: 0x0BE0; -BLEND_SRC :: 0x0BE1; -BLEND :: 0x0BE2; -LOGIC_OP_MODE :: 0x0BF0; -COLOR_LOGIC_OP :: 0x0BF2; -DRAW_BUFFER :: 0x0C01; -READ_BUFFER :: 0x0C02; -SCISSOR_BOX :: 0x0C10; -SCISSOR_TEST :: 0x0C11; -COLOR_CLEAR_VALUE :: 0x0C22; -COLOR_WRITEMASK :: 0x0C23; -DOUBLEBUFFER :: 0x0C32; -STEREO :: 0x0C33; -LINE_SMOOTH_HINT :: 0x0C52; -POLYGON_SMOOTH_HINT :: 0x0C53; -UNPACK_SWAP_BYTES :: 0x0CF0; -UNPACK_LSB_FIRST :: 0x0CF1; -UNPACK_ROW_LENGTH :: 0x0CF2; -UNPACK_SKIP_ROWS :: 0x0CF3; -UNPACK_SKIP_PIXELS :: 0x0CF4; -UNPACK_ALIGNMENT :: 0x0CF5; -PACK_SWAP_BYTES :: 0x0D00; -PACK_LSB_FIRST :: 0x0D01; -PACK_ROW_LENGTH :: 0x0D02; -PACK_SKIP_ROWS :: 0x0D03; -PACK_SKIP_PIXELS :: 0x0D04; -PACK_ALIGNMENT :: 0x0D05; -MAX_TEXTURE_SIZE :: 0x0D33; -MAX_VIEWPORT_DIMS :: 0x0D3A; -SUBPIXEL_BITS :: 0x0D50; -TEXTURE_1D :: 0x0DE0; -TEXTURE_2D :: 0x0DE1; -POLYGON_OFFSET_UNITS :: 0x2A00; -POLYGON_OFFSET_POINT :: 0x2A01; -POLYGON_OFFSET_LINE :: 0x2A02; -POLYGON_OFFSET_FILL :: 0x8037; -POLYGON_OFFSET_FACTOR :: 0x8038; -TEXTURE_BINDING_1D :: 0x8068; -TEXTURE_BINDING_2D :: 0x8069; -TEXTURE_WIDTH :: 0x1000; -TEXTURE_HEIGHT :: 0x1001; -TEXTURE_INTERNAL_FORMAT :: 0x1003; -TEXTURE_BORDER_COLOR :: 0x1004; -TEXTURE_RED_SIZE :: 0x805C; -TEXTURE_GREEN_SIZE :: 0x805D; -TEXTURE_BLUE_SIZE :: 0x805E; -TEXTURE_ALPHA_SIZE :: 0x805F; -DONT_CARE :: 0x1100; -FASTEST :: 0x1101; -NICEST :: 0x1102; -BYTE :: 0x1400; -UNSIGNED_BYTE :: 0x1401; -SHORT :: 0x1402; -UNSIGNED_SHORT :: 0x1403; -INT :: 0x1404; -UNSIGNED_INT :: 0x1405; -FLOAT :: 0x1406; -DOUBLE :: 0x140A; -STACK_OVERFLOW :: 0x0503; -STACK_UNDERFLOW :: 0x0504; -CLEAR :: 0x1500; -AND :: 0x1501; -AND_REVERSE :: 0x1502; -COPY :: 0x1503; -AND_INVERTED :: 0x1504; -NOOP :: 0x1505; -XOR :: 0x1506; -OR :: 0x1507; -NOR :: 0x1508; -EQUIV :: 0x1509; -INVERT :: 0x150A; -OR_REVERSE :: 0x150B; -COPY_INVERTED :: 0x150C; -OR_INVERTED :: 0x150D; -NAND :: 0x150E; -SET :: 0x150F; -TEXTURE :: 0x1702; -COLOR :: 0x1800; -DEPTH :: 0x1801; -STENCIL :: 0x1802; -STENCIL_INDEX :: 0x1901; -DEPTH_COMPONENT :: 0x1902; -RED :: 0x1903; -GREEN :: 0x1904; -BLUE :: 0x1905; -ALPHA :: 0x1906; -RGB :: 0x1907; -RGBA :: 0x1908; -POINT :: 0x1B00; -LINE :: 0x1B01; -FILL :: 0x1B02; -KEEP :: 0x1E00; -REPLACE :: 0x1E01; -INCR :: 0x1E02; -DECR :: 0x1E03; -VENDOR :: 0x1F00; -RENDERER :: 0x1F01; -VERSION :: 0x1F02; -EXTENSIONS :: 0x1F03; -NEAREST :: 0x2600; -LINEAR :: 0x2601; -NEAREST_MIPMAP_NEAREST :: 0x2700; -LINEAR_MIPMAP_NEAREST :: 0x2701; -NEAREST_MIPMAP_LINEAR :: 0x2702; -LINEAR_MIPMAP_LINEAR :: 0x2703; -TEXTURE_MAG_FILTER :: 0x2800; -TEXTURE_MIN_FILTER :: 0x2801; -TEXTURE_WRAP_S :: 0x2802; -TEXTURE_WRAP_T :: 0x2803; -PROXY_TEXTURE_1D :: 0x8063; -PROXY_TEXTURE_2D :: 0x8064; -REPEAT :: 0x2901; -R3_G3_B2 :: 0x2A10; -RGB4 :: 0x804F; -RGB5 :: 0x8050; -RGB8 :: 0x8051; -RGB10 :: 0x8052; -RGB12 :: 0x8053; -RGB16 :: 0x8054; -RGBA2 :: 0x8055; -RGBA4 :: 0x8056; -RGB5_A1 :: 0x8057; -RGBA8 :: 0x8058; -RGB10_A2 :: 0x8059; -RGBA12 :: 0x805A; -RGBA16 :: 0x805B; -VERTEX_ARRAY :: 0x8074; +DEPTH_BUFFER_BIT :: 0x00000100 +STENCIL_BUFFER_BIT :: 0x00000400 +COLOR_BUFFER_BIT :: 0x00004000 +POINTS :: 0x0000 +LINES :: 0x0001 +LINE_LOOP :: 0x0002 +LINE_STRIP :: 0x0003 +TRIANGLES :: 0x0004 +TRIANGLE_STRIP :: 0x0005 +TRIANGLE_FAN :: 0x0006 +QUADS :: 0x0007 +NEVER :: 0x0200 +LESS :: 0x0201 +EQUAL :: 0x0202 +LEQUAL :: 0x0203 +GREATER :: 0x0204 +NOTEQUAL :: 0x0205 +GEQUAL :: 0x0206 +ALWAYS :: 0x0207 +ZERO :: 0 +ONE :: 1 +SRC_COLOR :: 0x0300 +ONE_MINUS_SRC_COLOR :: 0x0301 +SRC_ALPHA :: 0x0302 +ONE_MINUS_SRC_ALPHA :: 0x0303 +DST_ALPHA :: 0x0304 +ONE_MINUS_DST_ALPHA :: 0x0305 +DST_COLOR :: 0x0306 +ONE_MINUS_DST_COLOR :: 0x0307 +SRC_ALPHA_SATURATE :: 0x0308 +NONE :: 0 +FRONT_LEFT :: 0x0400 +FRONT_RIGHT :: 0x0401 +BACK_LEFT :: 0x0402 +BACK_RIGHT :: 0x0403 +FRONT :: 0x0404 +BACK :: 0x0405 +LEFT :: 0x0406 +RIGHT :: 0x0407 +FRONT_AND_BACK :: 0x0408 +NO_ERROR :: 0 +INVALID_ENUM :: 0x0500 +INVALID_VALUE :: 0x0501 +INVALID_OPERATION :: 0x0502 +OUT_OF_MEMORY :: 0x0505 +CW :: 0x0900 +CCW :: 0x0901 +POINT_SIZE :: 0x0B11 +POINT_SIZE_RANGE :: 0x0B12 +POINT_SIZE_GRANULARITY :: 0x0B13 +LINE_SMOOTH :: 0x0B20 +LINE_WIDTH :: 0x0B21 +LINE_WIDTH_RANGE :: 0x0B22 +LINE_WIDTH_GRANULARITY :: 0x0B23 +POLYGON_MODE :: 0x0B40 +POLYGON_SMOOTH :: 0x0B41 +CULL_FACE :: 0x0B44 +CULL_FACE_MODE :: 0x0B45 +FRONT_FACE :: 0x0B46 +DEPTH_RANGE :: 0x0B70 +DEPTH_TEST :: 0x0B71 +DEPTH_WRITEMASK :: 0x0B72 +DEPTH_CLEAR_VALUE :: 0x0B73 +DEPTH_FUNC :: 0x0B74 +STENCIL_TEST :: 0x0B90 +STENCIL_CLEAR_VALUE :: 0x0B91 +STENCIL_FUNC :: 0x0B92 +STENCIL_VALUE_MASK :: 0x0B93 +STENCIL_FAIL :: 0x0B94 +STENCIL_PASS_DEPTH_FAIL :: 0x0B95 +STENCIL_PASS_DEPTH_PASS :: 0x0B96 +STENCIL_REF :: 0x0B97 +STENCIL_WRITEMASK :: 0x0B98 +VIEWPORT :: 0x0BA2 +DITHER :: 0x0BD0 +BLEND_DST :: 0x0BE0 +BLEND_SRC :: 0x0BE1 +BLEND :: 0x0BE2 +LOGIC_OP_MODE :: 0x0BF0 +COLOR_LOGIC_OP :: 0x0BF2 +DRAW_BUFFER :: 0x0C01 +READ_BUFFER :: 0x0C02 +SCISSOR_BOX :: 0x0C10 +SCISSOR_TEST :: 0x0C11 +COLOR_CLEAR_VALUE :: 0x0C22 +COLOR_WRITEMASK :: 0x0C23 +DOUBLEBUFFER :: 0x0C32 +STEREO :: 0x0C33 +LINE_SMOOTH_HINT :: 0x0C52 +POLYGON_SMOOTH_HINT :: 0x0C53 +UNPACK_SWAP_BYTES :: 0x0CF0 +UNPACK_LSB_FIRST :: 0x0CF1 +UNPACK_ROW_LENGTH :: 0x0CF2 +UNPACK_SKIP_ROWS :: 0x0CF3 +UNPACK_SKIP_PIXELS :: 0x0CF4 +UNPACK_ALIGNMENT :: 0x0CF5 +PACK_SWAP_BYTES :: 0x0D00 +PACK_LSB_FIRST :: 0x0D01 +PACK_ROW_LENGTH :: 0x0D02 +PACK_SKIP_ROWS :: 0x0D03 +PACK_SKIP_PIXELS :: 0x0D04 +PACK_ALIGNMENT :: 0x0D05 +MAX_TEXTURE_SIZE :: 0x0D33 +MAX_VIEWPORT_DIMS :: 0x0D3A +SUBPIXEL_BITS :: 0x0D50 +TEXTURE_1D :: 0x0DE0 +TEXTURE_2D :: 0x0DE1 +POLYGON_OFFSET_UNITS :: 0x2A00 +POLYGON_OFFSET_POINT :: 0x2A01 +POLYGON_OFFSET_LINE :: 0x2A02 +POLYGON_OFFSET_FILL :: 0x8037 +POLYGON_OFFSET_FACTOR :: 0x8038 +TEXTURE_BINDING_1D :: 0x8068 +TEXTURE_BINDING_2D :: 0x8069 +TEXTURE_WIDTH :: 0x1000 +TEXTURE_HEIGHT :: 0x1001 +TEXTURE_INTERNAL_FORMAT :: 0x1003 +TEXTURE_BORDER_COLOR :: 0x1004 +TEXTURE_RED_SIZE :: 0x805C +TEXTURE_GREEN_SIZE :: 0x805D +TEXTURE_BLUE_SIZE :: 0x805E +TEXTURE_ALPHA_SIZE :: 0x805F +DONT_CARE :: 0x1100 +FASTEST :: 0x1101 +NICEST :: 0x1102 +BYTE :: 0x1400 +UNSIGNED_BYTE :: 0x1401 +SHORT :: 0x1402 +UNSIGNED_SHORT :: 0x1403 +INT :: 0x1404 +UNSIGNED_INT :: 0x1405 +FLOAT :: 0x1406 +DOUBLE :: 0x140A +STACK_OVERFLOW :: 0x0503 +STACK_UNDERFLOW :: 0x0504 +CLEAR :: 0x1500 +AND :: 0x1501 +AND_REVERSE :: 0x1502 +COPY :: 0x1503 +AND_INVERTED :: 0x1504 +NOOP :: 0x1505 +XOR :: 0x1506 +OR :: 0x1507 +NOR :: 0x1508 +EQUIV :: 0x1509 +INVERT :: 0x150A +OR_REVERSE :: 0x150B +COPY_INVERTED :: 0x150C +OR_INVERTED :: 0x150D +NAND :: 0x150E +SET :: 0x150F +TEXTURE :: 0x1702 +COLOR :: 0x1800 +DEPTH :: 0x1801 +STENCIL :: 0x1802 +STENCIL_INDEX :: 0x1901 +DEPTH_COMPONENT :: 0x1902 +RED :: 0x1903 +GREEN :: 0x1904 +BLUE :: 0x1905 +ALPHA :: 0x1906 +RGB :: 0x1907 +RGBA :: 0x1908 +POINT :: 0x1B00 +LINE :: 0x1B01 +FILL :: 0x1B02 +KEEP :: 0x1E00 +REPLACE :: 0x1E01 +INCR :: 0x1E02 +DECR :: 0x1E03 +VENDOR :: 0x1F00 +RENDERER :: 0x1F01 +VERSION :: 0x1F02 +EXTENSIONS :: 0x1F03 +NEAREST :: 0x2600 +LINEAR :: 0x2601 +NEAREST_MIPMAP_NEAREST :: 0x2700 +LINEAR_MIPMAP_NEAREST :: 0x2701 +NEAREST_MIPMAP_LINEAR :: 0x2702 +LINEAR_MIPMAP_LINEAR :: 0x2703 +TEXTURE_MAG_FILTER :: 0x2800 +TEXTURE_MIN_FILTER :: 0x2801 +TEXTURE_WRAP_S :: 0x2802 +TEXTURE_WRAP_T :: 0x2803 +PROXY_TEXTURE_1D :: 0x8063 +PROXY_TEXTURE_2D :: 0x8064 +REPEAT :: 0x2901 +R3_G3_B2 :: 0x2A10 +RGB4 :: 0x804F +RGB5 :: 0x8050 +RGB8 :: 0x8051 +RGB10 :: 0x8052 +RGB12 :: 0x8053 +RGB16 :: 0x8054 +RGBA2 :: 0x8055 +RGBA4 :: 0x8056 +RGB5_A1 :: 0x8057 +RGBA8 :: 0x8058 +RGB10_A2 :: 0x8059 +RGBA12 :: 0x805A +RGBA16 :: 0x805B +VERTEX_ARRAY :: 0x8074 -UNSIGNED_BYTE_3_3_2 :: 0x8032; -UNSIGNED_SHORT_4_4_4_4 :: 0x8033; -UNSIGNED_SHORT_5_5_5_1 :: 0x8034; -UNSIGNED_INT_8_8_8_8 :: 0x8035; -UNSIGNED_INT_10_10_10_2 :: 0x8036; -TEXTURE_BINDING_3D :: 0x806A; -PACK_SKIP_IMAGES :: 0x806B; -PACK_IMAGE_HEIGHT :: 0x806C; -UNPACK_SKIP_IMAGES :: 0x806D; -UNPACK_IMAGE_HEIGHT :: 0x806E; -TEXTURE_3D :: 0x806F; -PROXY_TEXTURE_3D :: 0x8070; -TEXTURE_DEPTH :: 0x8071; -TEXTURE_WRAP_R :: 0x8072; -MAX_3D_TEXTURE_SIZE :: 0x8073; -UNSIGNED_BYTE_2_3_3_REV :: 0x8362; -UNSIGNED_SHORT_5_6_5 :: 0x8363; -UNSIGNED_SHORT_5_6_5_REV :: 0x8364; -UNSIGNED_SHORT_4_4_4_4_REV :: 0x8365; -UNSIGNED_SHORT_1_5_5_5_REV :: 0x8366; -UNSIGNED_INT_8_8_8_8_REV :: 0x8367; -UNSIGNED_INT_2_10_10_10_REV :: 0x8368; -BGR :: 0x80E0; -BGRA :: 0x80E1; -MAX_ELEMENTS_VERTICES :: 0x80E8; -MAX_ELEMENTS_INDICES :: 0x80E9; -CLAMP_TO_EDGE :: 0x812F; -TEXTURE_MIN_LOD :: 0x813A; -TEXTURE_MAX_LOD :: 0x813B; -TEXTURE_BASE_LEVEL :: 0x813C; -TEXTURE_MAX_LEVEL :: 0x813D; -SMOOTH_POINT_SIZE_RANGE :: 0x0B12; -SMOOTH_POINT_SIZE_GRANULARITY :: 0x0B13; -SMOOTH_LINE_WIDTH_RANGE :: 0x0B22; -SMOOTH_LINE_WIDTH_GRANULARITY :: 0x0B23; -ALIASED_LINE_WIDTH_RANGE :: 0x846E; +UNSIGNED_BYTE_3_3_2 :: 0x8032 +UNSIGNED_SHORT_4_4_4_4 :: 0x8033 +UNSIGNED_SHORT_5_5_5_1 :: 0x8034 +UNSIGNED_INT_8_8_8_8 :: 0x8035 +UNSIGNED_INT_10_10_10_2 :: 0x8036 +TEXTURE_BINDING_3D :: 0x806A +PACK_SKIP_IMAGES :: 0x806B +PACK_IMAGE_HEIGHT :: 0x806C +UNPACK_SKIP_IMAGES :: 0x806D +UNPACK_IMAGE_HEIGHT :: 0x806E +TEXTURE_3D :: 0x806F +PROXY_TEXTURE_3D :: 0x8070 +TEXTURE_DEPTH :: 0x8071 +TEXTURE_WRAP_R :: 0x8072 +MAX_3D_TEXTURE_SIZE :: 0x8073 +UNSIGNED_BYTE_2_3_3_REV :: 0x8362 +UNSIGNED_SHORT_5_6_5 :: 0x8363 +UNSIGNED_SHORT_5_6_5_REV :: 0x8364 +UNSIGNED_SHORT_4_4_4_4_REV :: 0x8365 +UNSIGNED_SHORT_1_5_5_5_REV :: 0x8366 +UNSIGNED_INT_8_8_8_8_REV :: 0x8367 +UNSIGNED_INT_2_10_10_10_REV :: 0x8368 +BGR :: 0x80E0 +BGRA :: 0x80E1 +MAX_ELEMENTS_VERTICES :: 0x80E8 +MAX_ELEMENTS_INDICES :: 0x80E9 +CLAMP_TO_EDGE :: 0x812F +TEXTURE_MIN_LOD :: 0x813A +TEXTURE_MAX_LOD :: 0x813B +TEXTURE_BASE_LEVEL :: 0x813C +TEXTURE_MAX_LEVEL :: 0x813D +SMOOTH_POINT_SIZE_RANGE :: 0x0B12 +SMOOTH_POINT_SIZE_GRANULARITY :: 0x0B13 +SMOOTH_LINE_WIDTH_RANGE :: 0x0B22 +SMOOTH_LINE_WIDTH_GRANULARITY :: 0x0B23 +ALIASED_LINE_WIDTH_RANGE :: 0x846E -TEXTURE0 :: 0x84C0; -TEXTURE1 :: 0x84C1; -TEXTURE2 :: 0x84C2; -TEXTURE3 :: 0x84C3; -TEXTURE4 :: 0x84C4; -TEXTURE5 :: 0x84C5; -TEXTURE6 :: 0x84C6; -TEXTURE7 :: 0x84C7; -TEXTURE8 :: 0x84C8; -TEXTURE9 :: 0x84C9; -TEXTURE10 :: 0x84CA; -TEXTURE11 :: 0x84CB; -TEXTURE12 :: 0x84CC; -TEXTURE13 :: 0x84CD; -TEXTURE14 :: 0x84CE; -TEXTURE15 :: 0x84CF; -TEXTURE16 :: 0x84D0; -TEXTURE17 :: 0x84D1; -TEXTURE18 :: 0x84D2; -TEXTURE19 :: 0x84D3; -TEXTURE20 :: 0x84D4; -TEXTURE21 :: 0x84D5; -TEXTURE22 :: 0x84D6; -TEXTURE23 :: 0x84D7; -TEXTURE24 :: 0x84D8; -TEXTURE25 :: 0x84D9; -TEXTURE26 :: 0x84DA; -TEXTURE27 :: 0x84DB; -TEXTURE28 :: 0x84DC; -TEXTURE29 :: 0x84DD; -TEXTURE30 :: 0x84DE; -TEXTURE31 :: 0x84DF; -ACTIVE_TEXTURE :: 0x84E0; -MULTISAMPLE :: 0x809D; -SAMPLE_ALPHA_TO_COVERAGE :: 0x809E; -SAMPLE_ALPHA_TO_ONE :: 0x809F; -SAMPLE_COVERAGE :: 0x80A0; -SAMPLE_BUFFERS :: 0x80A8; -SAMPLES :: 0x80A9; -SAMPLE_COVERAGE_VALUE :: 0x80AA; -SAMPLE_COVERAGE_INVERT :: 0x80AB; -TEXTURE_CUBE_MAP :: 0x8513; -TEXTURE_BINDING_CUBE_MAP :: 0x8514; -TEXTURE_CUBE_MAP_POSITIVE_X :: 0x8515; -TEXTURE_CUBE_MAP_NEGATIVE_X :: 0x8516; -TEXTURE_CUBE_MAP_POSITIVE_Y :: 0x8517; -TEXTURE_CUBE_MAP_NEGATIVE_Y :: 0x8518; -TEXTURE_CUBE_MAP_POSITIVE_Z :: 0x8519; -TEXTURE_CUBE_MAP_NEGATIVE_Z :: 0x851A; -PROXY_TEXTURE_CUBE_MAP :: 0x851B; -MAX_CUBE_MAP_TEXTURE_SIZE :: 0x851C; -COMPRESSED_RGB :: 0x84ED; -COMPRESSED_RGBA :: 0x84EE; -TEXTURE_COMPRESSION_HINT :: 0x84EF; -TEXTURE_COMPRESSED_IMAGE_SIZE :: 0x86A0; -TEXTURE_COMPRESSED :: 0x86A1; -NUM_COMPRESSED_TEXTURE_FORMATS :: 0x86A2; -COMPRESSED_TEXTURE_FORMATS :: 0x86A3; -CLAMP_TO_BORDER :: 0x812D; +TEXTURE0 :: 0x84C0 +TEXTURE1 :: 0x84C1 +TEXTURE2 :: 0x84C2 +TEXTURE3 :: 0x84C3 +TEXTURE4 :: 0x84C4 +TEXTURE5 :: 0x84C5 +TEXTURE6 :: 0x84C6 +TEXTURE7 :: 0x84C7 +TEXTURE8 :: 0x84C8 +TEXTURE9 :: 0x84C9 +TEXTURE10 :: 0x84CA +TEXTURE11 :: 0x84CB +TEXTURE12 :: 0x84CC +TEXTURE13 :: 0x84CD +TEXTURE14 :: 0x84CE +TEXTURE15 :: 0x84CF +TEXTURE16 :: 0x84D0 +TEXTURE17 :: 0x84D1 +TEXTURE18 :: 0x84D2 +TEXTURE19 :: 0x84D3 +TEXTURE20 :: 0x84D4 +TEXTURE21 :: 0x84D5 +TEXTURE22 :: 0x84D6 +TEXTURE23 :: 0x84D7 +TEXTURE24 :: 0x84D8 +TEXTURE25 :: 0x84D9 +TEXTURE26 :: 0x84DA +TEXTURE27 :: 0x84DB +TEXTURE28 :: 0x84DC +TEXTURE29 :: 0x84DD +TEXTURE30 :: 0x84DE +TEXTURE31 :: 0x84DF +ACTIVE_TEXTURE :: 0x84E0 +MULTISAMPLE :: 0x809D +SAMPLE_ALPHA_TO_COVERAGE :: 0x809E +SAMPLE_ALPHA_TO_ONE :: 0x809F +SAMPLE_COVERAGE :: 0x80A0 +SAMPLE_BUFFERS :: 0x80A8 +SAMPLES :: 0x80A9 +SAMPLE_COVERAGE_VALUE :: 0x80AA +SAMPLE_COVERAGE_INVERT :: 0x80AB +TEXTURE_CUBE_MAP :: 0x8513 +TEXTURE_BINDING_CUBE_MAP :: 0x8514 +TEXTURE_CUBE_MAP_POSITIVE_X :: 0x8515 +TEXTURE_CUBE_MAP_NEGATIVE_X :: 0x8516 +TEXTURE_CUBE_MAP_POSITIVE_Y :: 0x8517 +TEXTURE_CUBE_MAP_NEGATIVE_Y :: 0x8518 +TEXTURE_CUBE_MAP_POSITIVE_Z :: 0x8519 +TEXTURE_CUBE_MAP_NEGATIVE_Z :: 0x851A +PROXY_TEXTURE_CUBE_MAP :: 0x851B +MAX_CUBE_MAP_TEXTURE_SIZE :: 0x851C +COMPRESSED_RGB :: 0x84ED +COMPRESSED_RGBA :: 0x84EE +TEXTURE_COMPRESSION_HINT :: 0x84EF +TEXTURE_COMPRESSED_IMAGE_SIZE :: 0x86A0 +TEXTURE_COMPRESSED :: 0x86A1 +NUM_COMPRESSED_TEXTURE_FORMATS :: 0x86A2 +COMPRESSED_TEXTURE_FORMATS :: 0x86A3 +CLAMP_TO_BORDER :: 0x812D -BLEND_DST_RGB :: 0x80C8; -BLEND_SRC_RGB :: 0x80C9; -BLEND_DST_ALPHA :: 0x80CA; -BLEND_SRC_ALPHA :: 0x80CB; -POINT_FADE_THRESHOLD_SIZE :: 0x8128; -DEPTH_COMPONENT16 :: 0x81A5; -DEPTH_COMPONENT24 :: 0x81A6; -DEPTH_COMPONENT32 :: 0x81A7; -MIRRORED_REPEAT :: 0x8370; -MAX_TEXTURE_LOD_BIAS :: 0x84FD; -TEXTURE_LOD_BIAS :: 0x8501; -INCR_WRAP :: 0x8507; -DECR_WRAP :: 0x8508; -TEXTURE_DEPTH_SIZE :: 0x884A; -TEXTURE_COMPARE_MODE :: 0x884C; -TEXTURE_COMPARE_FUNC :: 0x884D; -FUNC_ADD :: 0x8006; -FUNC_SUBTRACT :: 0x800A; -FUNC_REVERSE_SUBTRACT :: 0x800B; -MIN :: 0x8007; -MAX :: 0x8008; -CONSTANT_COLOR :: 0x8001; -ONE_MINUS_CONSTANT_COLOR :: 0x8002; -CONSTANT_ALPHA :: 0x8003; -ONE_MINUS_CONSTANT_ALPHA :: 0x8004; +BLEND_DST_RGB :: 0x80C8 +BLEND_SRC_RGB :: 0x80C9 +BLEND_DST_ALPHA :: 0x80CA +BLEND_SRC_ALPHA :: 0x80CB +POINT_FADE_THRESHOLD_SIZE :: 0x8128 +DEPTH_COMPONENT16 :: 0x81A5 +DEPTH_COMPONENT24 :: 0x81A6 +DEPTH_COMPONENT32 :: 0x81A7 +MIRRORED_REPEAT :: 0x8370 +MAX_TEXTURE_LOD_BIAS :: 0x84FD +TEXTURE_LOD_BIAS :: 0x8501 +INCR_WRAP :: 0x8507 +DECR_WRAP :: 0x8508 +TEXTURE_DEPTH_SIZE :: 0x884A +TEXTURE_COMPARE_MODE :: 0x884C +TEXTURE_COMPARE_FUNC :: 0x884D +FUNC_ADD :: 0x8006 +FUNC_SUBTRACT :: 0x800A +FUNC_REVERSE_SUBTRACT :: 0x800B +MIN :: 0x8007 +MAX :: 0x8008 +CONSTANT_COLOR :: 0x8001 +ONE_MINUS_CONSTANT_COLOR :: 0x8002 +CONSTANT_ALPHA :: 0x8003 +ONE_MINUS_CONSTANT_ALPHA :: 0x8004 -BUFFER_SIZE :: 0x8764; -BUFFER_USAGE :: 0x8765; -QUERY_COUNTER_BITS :: 0x8864; -CURRENT_QUERY :: 0x8865; -QUERY_RESULT :: 0x8866; -QUERY_RESULT_AVAILABLE :: 0x8867; -ARRAY_BUFFER :: 0x8892; -ELEMENT_ARRAY_BUFFER :: 0x8893; -ARRAY_BUFFER_BINDING :: 0x8894; -ELEMENT_ARRAY_BUFFER_BINDING :: 0x8895; -VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: 0x889F; -READ_ONLY :: 0x88B8; -WRITE_ONLY :: 0x88B9; -READ_WRITE :: 0x88BA; -BUFFER_ACCESS :: 0x88BB; -BUFFER_MAPPED :: 0x88BC; -BUFFER_MAP_POINTER :: 0x88BD; -STREAM_DRAW :: 0x88E0; -STREAM_READ :: 0x88E1; -STREAM_COPY :: 0x88E2; -STATIC_DRAW :: 0x88E4; -STATIC_READ :: 0x88E5; -STATIC_COPY :: 0x88E6; -DYNAMIC_DRAW :: 0x88E8; -DYNAMIC_READ :: 0x88E9; -DYNAMIC_COPY :: 0x88EA; -SAMPLES_PASSED :: 0x8914; -SRC1_ALPHA :: 0x8589; +BUFFER_SIZE :: 0x8764 +BUFFER_USAGE :: 0x8765 +QUERY_COUNTER_BITS :: 0x8864 +CURRENT_QUERY :: 0x8865 +QUERY_RESULT :: 0x8866 +QUERY_RESULT_AVAILABLE :: 0x8867 +ARRAY_BUFFER :: 0x8892 +ELEMENT_ARRAY_BUFFER :: 0x8893 +ARRAY_BUFFER_BINDING :: 0x8894 +ELEMENT_ARRAY_BUFFER_BINDING :: 0x8895 +VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: 0x889F +READ_ONLY :: 0x88B8 +WRITE_ONLY :: 0x88B9 +READ_WRITE :: 0x88BA +BUFFER_ACCESS :: 0x88BB +BUFFER_MAPPED :: 0x88BC +BUFFER_MAP_POINTER :: 0x88BD +STREAM_DRAW :: 0x88E0 +STREAM_READ :: 0x88E1 +STREAM_COPY :: 0x88E2 +STATIC_DRAW :: 0x88E4 +STATIC_READ :: 0x88E5 +STATIC_COPY :: 0x88E6 +DYNAMIC_DRAW :: 0x88E8 +DYNAMIC_READ :: 0x88E9 +DYNAMIC_COPY :: 0x88EA +SAMPLES_PASSED :: 0x8914 +SRC1_ALPHA :: 0x8589 -BLEND_EQUATION_RGB :: 0x8009; -VERTEX_ATTRIB_ARRAY_ENABLED :: 0x8622; -VERTEX_ATTRIB_ARRAY_SIZE :: 0x8623; -VERTEX_ATTRIB_ARRAY_STRIDE :: 0x8624; -VERTEX_ATTRIB_ARRAY_TYPE :: 0x8625; -CURRENT_VERTEX_ATTRIB :: 0x8626; -VERTEX_PROGRAM_POINT_SIZE :: 0x8642; -VERTEX_ATTRIB_ARRAY_POINTER :: 0x8645; -STENCIL_BACK_FUNC :: 0x8800; -STENCIL_BACK_FAIL :: 0x8801; -STENCIL_BACK_PASS_DEPTH_FAIL :: 0x8802; -STENCIL_BACK_PASS_DEPTH_PASS :: 0x8803; -MAX_DRAW_BUFFERS :: 0x8824; -DRAW_BUFFER0 :: 0x8825; -DRAW_BUFFER1 :: 0x8826; -DRAW_BUFFER2 :: 0x8827; -DRAW_BUFFER3 :: 0x8828; -DRAW_BUFFER4 :: 0x8829; -DRAW_BUFFER5 :: 0x882A; -DRAW_BUFFER6 :: 0x882B; -DRAW_BUFFER7 :: 0x882C; -DRAW_BUFFER8 :: 0x882D; -DRAW_BUFFER9 :: 0x882E; -DRAW_BUFFER10 :: 0x882F; -DRAW_BUFFER11 :: 0x8830; -DRAW_BUFFER12 :: 0x8831; -DRAW_BUFFER13 :: 0x8832; -DRAW_BUFFER14 :: 0x8833; -DRAW_BUFFER15 :: 0x8834; -BLEND_EQUATION_ALPHA :: 0x883D; -MAX_VERTEX_ATTRIBS :: 0x8869; -VERTEX_ATTRIB_ARRAY_NORMALIZED :: 0x886A; -MAX_TEXTURE_IMAGE_UNITS :: 0x8872; -FRAGMENT_SHADER :: 0x8B30; -VERTEX_SHADER :: 0x8B31; -MAX_FRAGMENT_UNIFORM_COMPONENTS :: 0x8B49; -MAX_VERTEX_UNIFORM_COMPONENTS :: 0x8B4A; -MAX_VARYING_FLOATS :: 0x8B4B; -MAX_VERTEX_TEXTURE_IMAGE_UNITS :: 0x8B4C; -MAX_COMBINED_TEXTURE_IMAGE_UNITS :: 0x8B4D; -SHADER_TYPE :: 0x8B4F; -FLOAT_VEC2 :: 0x8B50; -FLOAT_VEC3 :: 0x8B51; -FLOAT_VEC4 :: 0x8B52; -INT_VEC2 :: 0x8B53; -INT_VEC3 :: 0x8B54; -INT_VEC4 :: 0x8B55; -BOOL :: 0x8B56; -BOOL_VEC2 :: 0x8B57; -BOOL_VEC3 :: 0x8B58; -BOOL_VEC4 :: 0x8B59; -FLOAT_MAT2 :: 0x8B5A; -FLOAT_MAT3 :: 0x8B5B; -FLOAT_MAT4 :: 0x8B5C; -SAMPLER_1D :: 0x8B5D; -SAMPLER_2D :: 0x8B5E; -SAMPLER_3D :: 0x8B5F; -SAMPLER_CUBE :: 0x8B60; -SAMPLER_1D_SHADOW :: 0x8B61; -SAMPLER_2D_SHADOW :: 0x8B62; -DELETE_STATUS :: 0x8B80; -COMPILE_STATUS :: 0x8B81; -LINK_STATUS :: 0x8B82; -VALIDATE_STATUS :: 0x8B83; -INFO_LOG_LENGTH :: 0x8B84; -ATTACHED_SHADERS :: 0x8B85; -ACTIVE_UNIFORMS :: 0x8B86; -ACTIVE_UNIFORM_MAX_LENGTH :: 0x8B87; -SHADER_SOURCE_LENGTH :: 0x8B88; -ACTIVE_ATTRIBUTES :: 0x8B89; -ACTIVE_ATTRIBUTE_MAX_LENGTH :: 0x8B8A; -FRAGMENT_SHADER_DERIVATIVE_HINT :: 0x8B8B; -SHADING_LANGUAGE_VERSION :: 0x8B8C; -CURRENT_PROGRAM :: 0x8B8D; -POINT_SPRITE_COORD_ORIGIN :: 0x8CA0; -LOWER_LEFT :: 0x8CA1; -UPPER_LEFT :: 0x8CA2; -STENCIL_BACK_REF :: 0x8CA3; -STENCIL_BACK_VALUE_MASK :: 0x8CA4; -STENCIL_BACK_WRITEMASK :: 0x8CA5; +BLEND_EQUATION_RGB :: 0x8009 +VERTEX_ATTRIB_ARRAY_ENABLED :: 0x8622 +VERTEX_ATTRIB_ARRAY_SIZE :: 0x8623 +VERTEX_ATTRIB_ARRAY_STRIDE :: 0x8624 +VERTEX_ATTRIB_ARRAY_TYPE :: 0x8625 +CURRENT_VERTEX_ATTRIB :: 0x8626 +VERTEX_PROGRAM_POINT_SIZE :: 0x8642 +VERTEX_ATTRIB_ARRAY_POINTER :: 0x8645 +STENCIL_BACK_FUNC :: 0x8800 +STENCIL_BACK_FAIL :: 0x8801 +STENCIL_BACK_PASS_DEPTH_FAIL :: 0x8802 +STENCIL_BACK_PASS_DEPTH_PASS :: 0x8803 +MAX_DRAW_BUFFERS :: 0x8824 +DRAW_BUFFER0 :: 0x8825 +DRAW_BUFFER1 :: 0x8826 +DRAW_BUFFER2 :: 0x8827 +DRAW_BUFFER3 :: 0x8828 +DRAW_BUFFER4 :: 0x8829 +DRAW_BUFFER5 :: 0x882A +DRAW_BUFFER6 :: 0x882B +DRAW_BUFFER7 :: 0x882C +DRAW_BUFFER8 :: 0x882D +DRAW_BUFFER9 :: 0x882E +DRAW_BUFFER10 :: 0x882F +DRAW_BUFFER11 :: 0x8830 +DRAW_BUFFER12 :: 0x8831 +DRAW_BUFFER13 :: 0x8832 +DRAW_BUFFER14 :: 0x8833 +DRAW_BUFFER15 :: 0x8834 +BLEND_EQUATION_ALPHA :: 0x883D +MAX_VERTEX_ATTRIBS :: 0x8869 +VERTEX_ATTRIB_ARRAY_NORMALIZED :: 0x886A +MAX_TEXTURE_IMAGE_UNITS :: 0x8872 +FRAGMENT_SHADER :: 0x8B30 +VERTEX_SHADER :: 0x8B31 +MAX_FRAGMENT_UNIFORM_COMPONENTS :: 0x8B49 +MAX_VERTEX_UNIFORM_COMPONENTS :: 0x8B4A +MAX_VARYING_FLOATS :: 0x8B4B +MAX_VERTEX_TEXTURE_IMAGE_UNITS :: 0x8B4C +MAX_COMBINED_TEXTURE_IMAGE_UNITS :: 0x8B4D +SHADER_TYPE :: 0x8B4F +FLOAT_VEC2 :: 0x8B50 +FLOAT_VEC3 :: 0x8B51 +FLOAT_VEC4 :: 0x8B52 +INT_VEC2 :: 0x8B53 +INT_VEC3 :: 0x8B54 +INT_VEC4 :: 0x8B55 +BOOL :: 0x8B56 +BOOL_VEC2 :: 0x8B57 +BOOL_VEC3 :: 0x8B58 +BOOL_VEC4 :: 0x8B59 +FLOAT_MAT2 :: 0x8B5A +FLOAT_MAT3 :: 0x8B5B +FLOAT_MAT4 :: 0x8B5C +SAMPLER_1D :: 0x8B5D +SAMPLER_2D :: 0x8B5E +SAMPLER_3D :: 0x8B5F +SAMPLER_CUBE :: 0x8B60 +SAMPLER_1D_SHADOW :: 0x8B61 +SAMPLER_2D_SHADOW :: 0x8B62 +DELETE_STATUS :: 0x8B80 +COMPILE_STATUS :: 0x8B81 +LINK_STATUS :: 0x8B82 +VALIDATE_STATUS :: 0x8B83 +INFO_LOG_LENGTH :: 0x8B84 +ATTACHED_SHADERS :: 0x8B85 +ACTIVE_UNIFORMS :: 0x8B86 +ACTIVE_UNIFORM_MAX_LENGTH :: 0x8B87 +SHADER_SOURCE_LENGTH :: 0x8B88 +ACTIVE_ATTRIBUTES :: 0x8B89 +ACTIVE_ATTRIBUTE_MAX_LENGTH :: 0x8B8A +FRAGMENT_SHADER_DERIVATIVE_HINT :: 0x8B8B +SHADING_LANGUAGE_VERSION :: 0x8B8C +CURRENT_PROGRAM :: 0x8B8D +POINT_SPRITE_COORD_ORIGIN :: 0x8CA0 +LOWER_LEFT :: 0x8CA1 +UPPER_LEFT :: 0x8CA2 +STENCIL_BACK_REF :: 0x8CA3 +STENCIL_BACK_VALUE_MASK :: 0x8CA4 +STENCIL_BACK_WRITEMASK :: 0x8CA5 -PIXEL_PACK_BUFFER :: 0x88EB; -PIXEL_UNPACK_BUFFER :: 0x88EC; -PIXEL_PACK_BUFFER_BINDING :: 0x88ED; -PIXEL_UNPACK_BUFFER_BINDING :: 0x88EF; -FLOAT_MAT2x3 :: 0x8B65; -FLOAT_MAT2x4 :: 0x8B66; -FLOAT_MAT3x2 :: 0x8B67; -FLOAT_MAT3x4 :: 0x8B68; -FLOAT_MAT4x2 :: 0x8B69; -FLOAT_MAT4x3 :: 0x8B6A; -SRGB :: 0x8C40; -SRGB8 :: 0x8C41; -SRGB_ALPHA :: 0x8C42; -SRGB8_ALPHA8 :: 0x8C43; -COMPRESSED_SRGB :: 0x8C48; -COMPRESSED_SRGB_ALPHA :: 0x8C49; +PIXEL_PACK_BUFFER :: 0x88EB +PIXEL_UNPACK_BUFFER :: 0x88EC +PIXEL_PACK_BUFFER_BINDING :: 0x88ED +PIXEL_UNPACK_BUFFER_BINDING :: 0x88EF +FLOAT_MAT2x3 :: 0x8B65 +FLOAT_MAT2x4 :: 0x8B66 +FLOAT_MAT3x2 :: 0x8B67 +FLOAT_MAT3x4 :: 0x8B68 +FLOAT_MAT4x2 :: 0x8B69 +FLOAT_MAT4x3 :: 0x8B6A +SRGB :: 0x8C40 +SRGB8 :: 0x8C41 +SRGB_ALPHA :: 0x8C42 +SRGB8_ALPHA8 :: 0x8C43 +COMPRESSED_SRGB :: 0x8C48 +COMPRESSED_SRGB_ALPHA :: 0x8C49 -COMPARE_REF_TO_TEXTURE :: 0x884E; -CLIP_DISTANCE0 :: 0x3000; -CLIP_DISTANCE1 :: 0x3001; -CLIP_DISTANCE2 :: 0x3002; -CLIP_DISTANCE3 :: 0x3003; -CLIP_DISTANCE4 :: 0x3004; -CLIP_DISTANCE5 :: 0x3005; -CLIP_DISTANCE6 :: 0x3006; -CLIP_DISTANCE7 :: 0x3007; -MAX_CLIP_DISTANCES :: 0x0D32; -MAJOR_VERSION :: 0x821B; -MINOR_VERSION :: 0x821C; -NUM_EXTENSIONS :: 0x821D; -CONTEXT_FLAGS :: 0x821E; -COMPRESSED_RED :: 0x8225; -COMPRESSED_RG :: 0x8226; -CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT :: 0x00000001; -RGBA32F :: 0x8814; -RGB32F :: 0x8815; -RGBA16F :: 0x881A; -RGB16F :: 0x881B; -VERTEX_ATTRIB_ARRAY_INTEGER :: 0x88FD; -MAX_ARRAY_TEXTURE_LAYERS :: 0x88FF; -MIN_PROGRAM_TEXEL_OFFSET :: 0x8904; -MAX_PROGRAM_TEXEL_OFFSET :: 0x8905; -CLAMP_READ_COLOR :: 0x891C; -FIXED_ONLY :: 0x891D; -MAX_VARYING_COMPONENTS :: 0x8B4B; -TEXTURE_1D_ARRAY :: 0x8C18; -PROXY_TEXTURE_1D_ARRAY :: 0x8C19; -TEXTURE_2D_ARRAY :: 0x8C1A; -PROXY_TEXTURE_2D_ARRAY :: 0x8C1B; -TEXTURE_BINDING_1D_ARRAY :: 0x8C1C; -TEXTURE_BINDING_2D_ARRAY :: 0x8C1D; -R11F_G11F_B10F :: 0x8C3A; -UNSIGNED_INT_10F_11F_11F_REV :: 0x8C3B; -RGB9_E5 :: 0x8C3D; -UNSIGNED_INT_5_9_9_9_REV :: 0x8C3E; -TEXTURE_SHARED_SIZE :: 0x8C3F; -TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH :: 0x8C76; -TRANSFORM_FEEDBACK_BUFFER_MODE :: 0x8C7F; -MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS :: 0x8C80; -TRANSFORM_FEEDBACK_VARYINGS :: 0x8C83; -TRANSFORM_FEEDBACK_BUFFER_START :: 0x8C84; -TRANSFORM_FEEDBACK_BUFFER_SIZE :: 0x8C85; -PRIMITIVES_GENERATED :: 0x8C87; -TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN :: 0x8C88; -RASTERIZER_DISCARD :: 0x8C89; -MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS :: 0x8C8A; -MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS :: 0x8C8B; -INTERLEAVED_ATTRIBS :: 0x8C8C; -SEPARATE_ATTRIBS :: 0x8C8D; -TRANSFORM_FEEDBACK_BUFFER :: 0x8C8E; -TRANSFORM_FEEDBACK_BUFFER_BINDING :: 0x8C8F; -RGBA32UI :: 0x8D70; -RGB32UI :: 0x8D71; -RGBA16UI :: 0x8D76; -RGB16UI :: 0x8D77; -RGBA8UI :: 0x8D7C; -RGB8UI :: 0x8D7D; -RGBA32I :: 0x8D82; -RGB32I :: 0x8D83; -RGBA16I :: 0x8D88; -RGB16I :: 0x8D89; -RGBA8I :: 0x8D8E; -RGB8I :: 0x8D8F; -RED_INTEGER :: 0x8D94; -GREEN_INTEGER :: 0x8D95; -BLUE_INTEGER :: 0x8D96; -RGB_INTEGER :: 0x8D98; -RGBA_INTEGER :: 0x8D99; -BGR_INTEGER :: 0x8D9A; -BGRA_INTEGER :: 0x8D9B; -SAMPLER_1D_ARRAY :: 0x8DC0; -SAMPLER_2D_ARRAY :: 0x8DC1; -SAMPLER_1D_ARRAY_SHADOW :: 0x8DC3; -SAMPLER_2D_ARRAY_SHADOW :: 0x8DC4; -SAMPLER_CUBE_SHADOW :: 0x8DC5; -UNSIGNED_INT_VEC2 :: 0x8DC6; -UNSIGNED_INT_VEC3 :: 0x8DC7; -UNSIGNED_INT_VEC4 :: 0x8DC8; -INT_SAMPLER_1D :: 0x8DC9; -INT_SAMPLER_2D :: 0x8DCA; -INT_SAMPLER_3D :: 0x8DCB; -INT_SAMPLER_CUBE :: 0x8DCC; -INT_SAMPLER_1D_ARRAY :: 0x8DCE; -INT_SAMPLER_2D_ARRAY :: 0x8DCF; -UNSIGNED_INT_SAMPLER_1D :: 0x8DD1; -UNSIGNED_INT_SAMPLER_2D :: 0x8DD2; -UNSIGNED_INT_SAMPLER_3D :: 0x8DD3; -UNSIGNED_INT_SAMPLER_CUBE :: 0x8DD4; -UNSIGNED_INT_SAMPLER_1D_ARRAY :: 0x8DD6; -UNSIGNED_INT_SAMPLER_2D_ARRAY :: 0x8DD7; -QUERY_WAIT :: 0x8E13; -QUERY_NO_WAIT :: 0x8E14; -QUERY_BY_REGION_WAIT :: 0x8E15; -QUERY_BY_REGION_NO_WAIT :: 0x8E16; -BUFFER_ACCESS_FLAGS :: 0x911F; -BUFFER_MAP_LENGTH :: 0x9120; -BUFFER_MAP_OFFSET :: 0x9121; -DEPTH_COMPONENT32F :: 0x8CAC; -DEPTH32F_STENCIL8 :: 0x8CAD; -FLOAT_32_UNSIGNED_INT_24_8_REV :: 0x8DAD; -INVALID_FRAMEBUFFER_OPERATION :: 0x0506; -FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING :: 0x8210; -FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE :: 0x8211; -FRAMEBUFFER_ATTACHMENT_RED_SIZE :: 0x8212; -FRAMEBUFFER_ATTACHMENT_GREEN_SIZE :: 0x8213; -FRAMEBUFFER_ATTACHMENT_BLUE_SIZE :: 0x8214; -FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE :: 0x8215; -FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE :: 0x8216; -FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE :: 0x8217; -FRAMEBUFFER_DEFAULT :: 0x8218; -FRAMEBUFFER_UNDEFINED :: 0x8219; -DEPTH_STENCIL_ATTACHMENT :: 0x821A; -MAX_RENDERBUFFER_SIZE :: 0x84E8; -DEPTH_STENCIL :: 0x84F9; -UNSIGNED_INT_24_8 :: 0x84FA; -DEPTH24_STENCIL8 :: 0x88F0; -TEXTURE_STENCIL_SIZE :: 0x88F1; -TEXTURE_RED_TYPE :: 0x8C10; -TEXTURE_GREEN_TYPE :: 0x8C11; -TEXTURE_BLUE_TYPE :: 0x8C12; -TEXTURE_ALPHA_TYPE :: 0x8C13; -TEXTURE_DEPTH_TYPE :: 0x8C16; -UNSIGNED_NORMALIZED :: 0x8C17; -FRAMEBUFFER_BINDING :: 0x8CA6; -DRAW_FRAMEBUFFER_BINDING :: 0x8CA6; -RENDERBUFFER_BINDING :: 0x8CA7; -READ_FRAMEBUFFER :: 0x8CA8; -DRAW_FRAMEBUFFER :: 0x8CA9; -READ_FRAMEBUFFER_BINDING :: 0x8CAA; -RENDERBUFFER_SAMPLES :: 0x8CAB; -FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE :: 0x8CD0; -FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: 0x8CD1; -FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: 0x8CD2; -FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: 0x8CD3; -FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: 0x8CD4; -FRAMEBUFFER_COMPLETE :: 0x8CD5; -FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: 0x8CD6; -FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: 0x8CD7; -FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER :: 0x8CDB; -FRAMEBUFFER_INCOMPLETE_READ_BUFFER :: 0x8CDC; -FRAMEBUFFER_UNSUPPORTED :: 0x8CDD; -MAX_COLOR_ATTACHMENTS :: 0x8CDF; -COLOR_ATTACHMENT0 :: 0x8CE0; -COLOR_ATTACHMENT1 :: 0x8CE1; -COLOR_ATTACHMENT2 :: 0x8CE2; -COLOR_ATTACHMENT3 :: 0x8CE3; -COLOR_ATTACHMENT4 :: 0x8CE4; -COLOR_ATTACHMENT5 :: 0x8CE5; -COLOR_ATTACHMENT6 :: 0x8CE6; -COLOR_ATTACHMENT7 :: 0x8CE7; -COLOR_ATTACHMENT8 :: 0x8CE8; -COLOR_ATTACHMENT9 :: 0x8CE9; -COLOR_ATTACHMENT10 :: 0x8CEA; -COLOR_ATTACHMENT11 :: 0x8CEB; -COLOR_ATTACHMENT12 :: 0x8CEC; -COLOR_ATTACHMENT13 :: 0x8CED; -COLOR_ATTACHMENT14 :: 0x8CEE; -COLOR_ATTACHMENT15 :: 0x8CEF; -COLOR_ATTACHMENT16 :: 0x8CF0; -COLOR_ATTACHMENT17 :: 0x8CF1; -COLOR_ATTACHMENT18 :: 0x8CF2; -COLOR_ATTACHMENT19 :: 0x8CF3; -COLOR_ATTACHMENT20 :: 0x8CF4; -COLOR_ATTACHMENT21 :: 0x8CF5; -COLOR_ATTACHMENT22 :: 0x8CF6; -COLOR_ATTACHMENT23 :: 0x8CF7; -COLOR_ATTACHMENT24 :: 0x8CF8; -COLOR_ATTACHMENT25 :: 0x8CF9; -COLOR_ATTACHMENT26 :: 0x8CFA; -COLOR_ATTACHMENT27 :: 0x8CFB; -COLOR_ATTACHMENT28 :: 0x8CFC; -COLOR_ATTACHMENT29 :: 0x8CFD; -COLOR_ATTACHMENT30 :: 0x8CFE; -COLOR_ATTACHMENT31 :: 0x8CFF; -DEPTH_ATTACHMENT :: 0x8D00; -STENCIL_ATTACHMENT :: 0x8D20; -FRAMEBUFFER :: 0x8D40; -RENDERBUFFER :: 0x8D41; -RENDERBUFFER_WIDTH :: 0x8D42; -RENDERBUFFER_HEIGHT :: 0x8D43; -RENDERBUFFER_INTERNAL_FORMAT :: 0x8D44; -STENCIL_INDEX1 :: 0x8D46; -STENCIL_INDEX4 :: 0x8D47; -STENCIL_INDEX8 :: 0x8D48; -STENCIL_INDEX16 :: 0x8D49; -RENDERBUFFER_RED_SIZE :: 0x8D50; -RENDERBUFFER_GREEN_SIZE :: 0x8D51; -RENDERBUFFER_BLUE_SIZE :: 0x8D52; -RENDERBUFFER_ALPHA_SIZE :: 0x8D53; -RENDERBUFFER_DEPTH_SIZE :: 0x8D54; -RENDERBUFFER_STENCIL_SIZE :: 0x8D55; -FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: 0x8D56; -MAX_SAMPLES :: 0x8D57; -FRAMEBUFFER_SRGB :: 0x8DB9; -HALF_FLOAT :: 0x140B; -MAP_READ_BIT :: 0x0001; -MAP_WRITE_BIT :: 0x0002; -MAP_INVALIDATE_RANGE_BIT :: 0x0004; -MAP_INVALIDATE_BUFFER_BIT :: 0x0008; -MAP_FLUSH_EXPLICIT_BIT :: 0x0010; -MAP_UNSYNCHRONIZED_BIT :: 0x0020; -COMPRESSED_RED_RGTC1 :: 0x8DBB; -COMPRESSED_SIGNED_RED_RGTC1 :: 0x8DBC; -COMPRESSED_RG_RGTC2 :: 0x8DBD; -COMPRESSED_SIGNED_RG_RGTC2 :: 0x8DBE; -RG :: 0x8227; -RG_INTEGER :: 0x8228; -R8 :: 0x8229; -R16 :: 0x822A; -RG8 :: 0x822B; -RG16 :: 0x822C; -R16F :: 0x822D; -R32F :: 0x822E; -RG16F :: 0x822F; -RG32F :: 0x8230; -R8I :: 0x8231; -R8UI :: 0x8232; -R16I :: 0x8233; -R16UI :: 0x8234; -R32I :: 0x8235; -R32UI :: 0x8236; -RG8I :: 0x8237; -RG8UI :: 0x8238; -RG16I :: 0x8239; -RG16UI :: 0x823A; -RG32I :: 0x823B; -RG32UI :: 0x823C; -VERTEX_ARRAY_BINDING :: 0x85B5; +COMPARE_REF_TO_TEXTURE :: 0x884E +CLIP_DISTANCE0 :: 0x3000 +CLIP_DISTANCE1 :: 0x3001 +CLIP_DISTANCE2 :: 0x3002 +CLIP_DISTANCE3 :: 0x3003 +CLIP_DISTANCE4 :: 0x3004 +CLIP_DISTANCE5 :: 0x3005 +CLIP_DISTANCE6 :: 0x3006 +CLIP_DISTANCE7 :: 0x3007 +MAX_CLIP_DISTANCES :: 0x0D32 +MAJOR_VERSION :: 0x821B +MINOR_VERSION :: 0x821C +NUM_EXTENSIONS :: 0x821D +CONTEXT_FLAGS :: 0x821E +COMPRESSED_RED :: 0x8225 +COMPRESSED_RG :: 0x8226 +CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT :: 0x00000001 +RGBA32F :: 0x8814 +RGB32F :: 0x8815 +RGBA16F :: 0x881A +RGB16F :: 0x881B +VERTEX_ATTRIB_ARRAY_INTEGER :: 0x88FD +MAX_ARRAY_TEXTURE_LAYERS :: 0x88FF +MIN_PROGRAM_TEXEL_OFFSET :: 0x8904 +MAX_PROGRAM_TEXEL_OFFSET :: 0x8905 +CLAMP_READ_COLOR :: 0x891C +FIXED_ONLY :: 0x891D +MAX_VARYING_COMPONENTS :: 0x8B4B +TEXTURE_1D_ARRAY :: 0x8C18 +PROXY_TEXTURE_1D_ARRAY :: 0x8C19 +TEXTURE_2D_ARRAY :: 0x8C1A +PROXY_TEXTURE_2D_ARRAY :: 0x8C1B +TEXTURE_BINDING_1D_ARRAY :: 0x8C1C +TEXTURE_BINDING_2D_ARRAY :: 0x8C1D +R11F_G11F_B10F :: 0x8C3A +UNSIGNED_INT_10F_11F_11F_REV :: 0x8C3B +RGB9_E5 :: 0x8C3D +UNSIGNED_INT_5_9_9_9_REV :: 0x8C3E +TEXTURE_SHARED_SIZE :: 0x8C3F +TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH :: 0x8C76 +TRANSFORM_FEEDBACK_BUFFER_MODE :: 0x8C7F +MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS :: 0x8C80 +TRANSFORM_FEEDBACK_VARYINGS :: 0x8C83 +TRANSFORM_FEEDBACK_BUFFER_START :: 0x8C84 +TRANSFORM_FEEDBACK_BUFFER_SIZE :: 0x8C85 +PRIMITIVES_GENERATED :: 0x8C87 +TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN :: 0x8C88 +RASTERIZER_DISCARD :: 0x8C89 +MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS :: 0x8C8A +MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS :: 0x8C8B +INTERLEAVED_ATTRIBS :: 0x8C8C +SEPARATE_ATTRIBS :: 0x8C8D +TRANSFORM_FEEDBACK_BUFFER :: 0x8C8E +TRANSFORM_FEEDBACK_BUFFER_BINDING :: 0x8C8F +RGBA32UI :: 0x8D70 +RGB32UI :: 0x8D71 +RGBA16UI :: 0x8D76 +RGB16UI :: 0x8D77 +RGBA8UI :: 0x8D7C +RGB8UI :: 0x8D7D +RGBA32I :: 0x8D82 +RGB32I :: 0x8D83 +RGBA16I :: 0x8D88 +RGB16I :: 0x8D89 +RGBA8I :: 0x8D8E +RGB8I :: 0x8D8F +RED_INTEGER :: 0x8D94 +GREEN_INTEGER :: 0x8D95 +BLUE_INTEGER :: 0x8D96 +RGB_INTEGER :: 0x8D98 +RGBA_INTEGER :: 0x8D99 +BGR_INTEGER :: 0x8D9A +BGRA_INTEGER :: 0x8D9B +SAMPLER_1D_ARRAY :: 0x8DC0 +SAMPLER_2D_ARRAY :: 0x8DC1 +SAMPLER_1D_ARRAY_SHADOW :: 0x8DC3 +SAMPLER_2D_ARRAY_SHADOW :: 0x8DC4 +SAMPLER_CUBE_SHADOW :: 0x8DC5 +UNSIGNED_INT_VEC2 :: 0x8DC6 +UNSIGNED_INT_VEC3 :: 0x8DC7 +UNSIGNED_INT_VEC4 :: 0x8DC8 +INT_SAMPLER_1D :: 0x8DC9 +INT_SAMPLER_2D :: 0x8DCA +INT_SAMPLER_3D :: 0x8DCB +INT_SAMPLER_CUBE :: 0x8DCC +INT_SAMPLER_1D_ARRAY :: 0x8DCE +INT_SAMPLER_2D_ARRAY :: 0x8DCF +UNSIGNED_INT_SAMPLER_1D :: 0x8DD1 +UNSIGNED_INT_SAMPLER_2D :: 0x8DD2 +UNSIGNED_INT_SAMPLER_3D :: 0x8DD3 +UNSIGNED_INT_SAMPLER_CUBE :: 0x8DD4 +UNSIGNED_INT_SAMPLER_1D_ARRAY :: 0x8DD6 +UNSIGNED_INT_SAMPLER_2D_ARRAY :: 0x8DD7 +QUERY_WAIT :: 0x8E13 +QUERY_NO_WAIT :: 0x8E14 +QUERY_BY_REGION_WAIT :: 0x8E15 +QUERY_BY_REGION_NO_WAIT :: 0x8E16 +BUFFER_ACCESS_FLAGS :: 0x911F +BUFFER_MAP_LENGTH :: 0x9120 +BUFFER_MAP_OFFSET :: 0x9121 +DEPTH_COMPONENT32F :: 0x8CAC +DEPTH32F_STENCIL8 :: 0x8CAD +FLOAT_32_UNSIGNED_INT_24_8_REV :: 0x8DAD +INVALID_FRAMEBUFFER_OPERATION :: 0x0506 +FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING :: 0x8210 +FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE :: 0x8211 +FRAMEBUFFER_ATTACHMENT_RED_SIZE :: 0x8212 +FRAMEBUFFER_ATTACHMENT_GREEN_SIZE :: 0x8213 +FRAMEBUFFER_ATTACHMENT_BLUE_SIZE :: 0x8214 +FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE :: 0x8215 +FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE :: 0x8216 +FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE :: 0x8217 +FRAMEBUFFER_DEFAULT :: 0x8218 +FRAMEBUFFER_UNDEFINED :: 0x8219 +DEPTH_STENCIL_ATTACHMENT :: 0x821A +MAX_RENDERBUFFER_SIZE :: 0x84E8 +DEPTH_STENCIL :: 0x84F9 +UNSIGNED_INT_24_8 :: 0x84FA +DEPTH24_STENCIL8 :: 0x88F0 +TEXTURE_STENCIL_SIZE :: 0x88F1 +TEXTURE_RED_TYPE :: 0x8C10 +TEXTURE_GREEN_TYPE :: 0x8C11 +TEXTURE_BLUE_TYPE :: 0x8C12 +TEXTURE_ALPHA_TYPE :: 0x8C13 +TEXTURE_DEPTH_TYPE :: 0x8C16 +UNSIGNED_NORMALIZED :: 0x8C17 +FRAMEBUFFER_BINDING :: 0x8CA6 +DRAW_FRAMEBUFFER_BINDING :: 0x8CA6 +RENDERBUFFER_BINDING :: 0x8CA7 +READ_FRAMEBUFFER :: 0x8CA8 +DRAW_FRAMEBUFFER :: 0x8CA9 +READ_FRAMEBUFFER_BINDING :: 0x8CAA +RENDERBUFFER_SAMPLES :: 0x8CAB +FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE :: 0x8CD0 +FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: 0x8CD1 +FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: 0x8CD2 +FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: 0x8CD3 +FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: 0x8CD4 +FRAMEBUFFER_COMPLETE :: 0x8CD5 +FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: 0x8CD6 +FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: 0x8CD7 +FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER :: 0x8CDB +FRAMEBUFFER_INCOMPLETE_READ_BUFFER :: 0x8CDC +FRAMEBUFFER_UNSUPPORTED :: 0x8CDD +MAX_COLOR_ATTACHMENTS :: 0x8CDF +COLOR_ATTACHMENT0 :: 0x8CE0 +COLOR_ATTACHMENT1 :: 0x8CE1 +COLOR_ATTACHMENT2 :: 0x8CE2 +COLOR_ATTACHMENT3 :: 0x8CE3 +COLOR_ATTACHMENT4 :: 0x8CE4 +COLOR_ATTACHMENT5 :: 0x8CE5 +COLOR_ATTACHMENT6 :: 0x8CE6 +COLOR_ATTACHMENT7 :: 0x8CE7 +COLOR_ATTACHMENT8 :: 0x8CE8 +COLOR_ATTACHMENT9 :: 0x8CE9 +COLOR_ATTACHMENT10 :: 0x8CEA +COLOR_ATTACHMENT11 :: 0x8CEB +COLOR_ATTACHMENT12 :: 0x8CEC +COLOR_ATTACHMENT13 :: 0x8CED +COLOR_ATTACHMENT14 :: 0x8CEE +COLOR_ATTACHMENT15 :: 0x8CEF +COLOR_ATTACHMENT16 :: 0x8CF0 +COLOR_ATTACHMENT17 :: 0x8CF1 +COLOR_ATTACHMENT18 :: 0x8CF2 +COLOR_ATTACHMENT19 :: 0x8CF3 +COLOR_ATTACHMENT20 :: 0x8CF4 +COLOR_ATTACHMENT21 :: 0x8CF5 +COLOR_ATTACHMENT22 :: 0x8CF6 +COLOR_ATTACHMENT23 :: 0x8CF7 +COLOR_ATTACHMENT24 :: 0x8CF8 +COLOR_ATTACHMENT25 :: 0x8CF9 +COLOR_ATTACHMENT26 :: 0x8CFA +COLOR_ATTACHMENT27 :: 0x8CFB +COLOR_ATTACHMENT28 :: 0x8CFC +COLOR_ATTACHMENT29 :: 0x8CFD +COLOR_ATTACHMENT30 :: 0x8CFE +COLOR_ATTACHMENT31 :: 0x8CFF +DEPTH_ATTACHMENT :: 0x8D00 +STENCIL_ATTACHMENT :: 0x8D20 +FRAMEBUFFER :: 0x8D40 +RENDERBUFFER :: 0x8D41 +RENDERBUFFER_WIDTH :: 0x8D42 +RENDERBUFFER_HEIGHT :: 0x8D43 +RENDERBUFFER_INTERNAL_FORMAT :: 0x8D44 +STENCIL_INDEX1 :: 0x8D46 +STENCIL_INDEX4 :: 0x8D47 +STENCIL_INDEX8 :: 0x8D48 +STENCIL_INDEX16 :: 0x8D49 +RENDERBUFFER_RED_SIZE :: 0x8D50 +RENDERBUFFER_GREEN_SIZE :: 0x8D51 +RENDERBUFFER_BLUE_SIZE :: 0x8D52 +RENDERBUFFER_ALPHA_SIZE :: 0x8D53 +RENDERBUFFER_DEPTH_SIZE :: 0x8D54 +RENDERBUFFER_STENCIL_SIZE :: 0x8D55 +FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: 0x8D56 +MAX_SAMPLES :: 0x8D57 +FRAMEBUFFER_SRGB :: 0x8DB9 +HALF_FLOAT :: 0x140B +MAP_READ_BIT :: 0x0001 +MAP_WRITE_BIT :: 0x0002 +MAP_INVALIDATE_RANGE_BIT :: 0x0004 +MAP_INVALIDATE_BUFFER_BIT :: 0x0008 +MAP_FLUSH_EXPLICIT_BIT :: 0x0010 +MAP_UNSYNCHRONIZED_BIT :: 0x0020 +COMPRESSED_RED_RGTC1 :: 0x8DBB +COMPRESSED_SIGNED_RED_RGTC1 :: 0x8DBC +COMPRESSED_RG_RGTC2 :: 0x8DBD +COMPRESSED_SIGNED_RG_RGTC2 :: 0x8DBE +RG :: 0x8227 +RG_INTEGER :: 0x8228 +R8 :: 0x8229 +R16 :: 0x822A +RG8 :: 0x822B +RG16 :: 0x822C +R16F :: 0x822D +R32F :: 0x822E +RG16F :: 0x822F +RG32F :: 0x8230 +R8I :: 0x8231 +R8UI :: 0x8232 +R16I :: 0x8233 +R16UI :: 0x8234 +R32I :: 0x8235 +R32UI :: 0x8236 +RG8I :: 0x8237 +RG8UI :: 0x8238 +RG16I :: 0x8239 +RG16UI :: 0x823A +RG32I :: 0x823B +RG32UI :: 0x823C +VERTEX_ARRAY_BINDING :: 0x85B5 -SAMPLER_2D_RECT :: 0x8B63; -SAMPLER_2D_RECT_SHADOW :: 0x8B64; -SAMPLER_BUFFER :: 0x8DC2; -INT_SAMPLER_2D_RECT :: 0x8DCD; -INT_SAMPLER_BUFFER :: 0x8DD0; -UNSIGNED_INT_SAMPLER_2D_RECT :: 0x8DD5; -UNSIGNED_INT_SAMPLER_BUFFER :: 0x8DD8; -TEXTURE_BUFFER :: 0x8C2A; -MAX_TEXTURE_BUFFER_SIZE :: 0x8C2B; -TEXTURE_BINDING_BUFFER :: 0x8C2C; -TEXTURE_BUFFER_DATA_STORE_BINDING :: 0x8C2D; -TEXTURE_RECTANGLE :: 0x84F5; -TEXTURE_BINDING_RECTANGLE :: 0x84F6; -PROXY_TEXTURE_RECTANGLE :: 0x84F7; -MAX_RECTANGLE_TEXTURE_SIZE :: 0x84F8; -R8_SNORM :: 0x8F94; -RG8_SNORM :: 0x8F95; -RGB8_SNORM :: 0x8F96; -RGBA8_SNORM :: 0x8F97; -R16_SNORM :: 0x8F98; -RG16_SNORM :: 0x8F99; -RGB16_SNORM :: 0x8F9A; -RGBA16_SNORM :: 0x8F9B; -SIGNED_NORMALIZED :: 0x8F9C; -PRIMITIVE_RESTART :: 0x8F9D; -PRIMITIVE_RESTART_INDEX :: 0x8F9E; -COPY_READ_BUFFER :: 0x8F36; -COPY_WRITE_BUFFER :: 0x8F37; -UNIFORM_BUFFER :: 0x8A11; -UNIFORM_BUFFER_BINDING :: 0x8A28; -UNIFORM_BUFFER_START :: 0x8A29; -UNIFORM_BUFFER_SIZE :: 0x8A2A; -MAX_VERTEX_UNIFORM_BLOCKS :: 0x8A2B; -MAX_GEOMETRY_UNIFORM_BLOCKS :: 0x8A2C; -MAX_FRAGMENT_UNIFORM_BLOCKS :: 0x8A2D; -MAX_COMBINED_UNIFORM_BLOCKS :: 0x8A2E; -MAX_UNIFORM_BUFFER_BINDINGS :: 0x8A2F; -MAX_UNIFORM_BLOCK_SIZE :: 0x8A30; -MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS :: 0x8A31; -MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS :: 0x8A32; -MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS :: 0x8A33; -UNIFORM_BUFFER_OFFSET_ALIGNMENT :: 0x8A34; -ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH :: 0x8A35; -ACTIVE_UNIFORM_BLOCKS :: 0x8A36; -UNIFORM_TYPE :: 0x8A37; -UNIFORM_SIZE :: 0x8A38; -UNIFORM_NAME_LENGTH :: 0x8A39; -UNIFORM_BLOCK_INDEX :: 0x8A3A; -UNIFORM_OFFSET :: 0x8A3B; -UNIFORM_ARRAY_STRIDE :: 0x8A3C; -UNIFORM_MATRIX_STRIDE :: 0x8A3D; -UNIFORM_IS_ROW_MAJOR :: 0x8A3E; -UNIFORM_BLOCK_BINDING :: 0x8A3F; -UNIFORM_BLOCK_DATA_SIZE :: 0x8A40; -UNIFORM_BLOCK_NAME_LENGTH :: 0x8A41; -UNIFORM_BLOCK_ACTIVE_UNIFORMS :: 0x8A42; -UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: 0x8A43; -UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: 0x8A44; -UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER :: 0x8A45; -UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: 0x8A46; -INVALID_INDEX :: 0xFFFFFFFF; +SAMPLER_2D_RECT :: 0x8B63 +SAMPLER_2D_RECT_SHADOW :: 0x8B64 +SAMPLER_BUFFER :: 0x8DC2 +INT_SAMPLER_2D_RECT :: 0x8DCD +INT_SAMPLER_BUFFER :: 0x8DD0 +UNSIGNED_INT_SAMPLER_2D_RECT :: 0x8DD5 +UNSIGNED_INT_SAMPLER_BUFFER :: 0x8DD8 +TEXTURE_BUFFER :: 0x8C2A +MAX_TEXTURE_BUFFER_SIZE :: 0x8C2B +TEXTURE_BINDING_BUFFER :: 0x8C2C +TEXTURE_BUFFER_DATA_STORE_BINDING :: 0x8C2D +TEXTURE_RECTANGLE :: 0x84F5 +TEXTURE_BINDING_RECTANGLE :: 0x84F6 +PROXY_TEXTURE_RECTANGLE :: 0x84F7 +MAX_RECTANGLE_TEXTURE_SIZE :: 0x84F8 +R8_SNORM :: 0x8F94 +RG8_SNORM :: 0x8F95 +RGB8_SNORM :: 0x8F96 +RGBA8_SNORM :: 0x8F97 +R16_SNORM :: 0x8F98 +RG16_SNORM :: 0x8F99 +RGB16_SNORM :: 0x8F9A +RGBA16_SNORM :: 0x8F9B +SIGNED_NORMALIZED :: 0x8F9C +PRIMITIVE_RESTART :: 0x8F9D +PRIMITIVE_RESTART_INDEX :: 0x8F9E +COPY_READ_BUFFER :: 0x8F36 +COPY_WRITE_BUFFER :: 0x8F37 +UNIFORM_BUFFER :: 0x8A11 +UNIFORM_BUFFER_BINDING :: 0x8A28 +UNIFORM_BUFFER_START :: 0x8A29 +UNIFORM_BUFFER_SIZE :: 0x8A2A +MAX_VERTEX_UNIFORM_BLOCKS :: 0x8A2B +MAX_GEOMETRY_UNIFORM_BLOCKS :: 0x8A2C +MAX_FRAGMENT_UNIFORM_BLOCKS :: 0x8A2D +MAX_COMBINED_UNIFORM_BLOCKS :: 0x8A2E +MAX_UNIFORM_BUFFER_BINDINGS :: 0x8A2F +MAX_UNIFORM_BLOCK_SIZE :: 0x8A30 +MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS :: 0x8A31 +MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS :: 0x8A32 +MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS :: 0x8A33 +UNIFORM_BUFFER_OFFSET_ALIGNMENT :: 0x8A34 +ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH :: 0x8A35 +ACTIVE_UNIFORM_BLOCKS :: 0x8A36 +UNIFORM_TYPE :: 0x8A37 +UNIFORM_SIZE :: 0x8A38 +UNIFORM_NAME_LENGTH :: 0x8A39 +UNIFORM_BLOCK_INDEX :: 0x8A3A +UNIFORM_OFFSET :: 0x8A3B +UNIFORM_ARRAY_STRIDE :: 0x8A3C +UNIFORM_MATRIX_STRIDE :: 0x8A3D +UNIFORM_IS_ROW_MAJOR :: 0x8A3E +UNIFORM_BLOCK_BINDING :: 0x8A3F +UNIFORM_BLOCK_DATA_SIZE :: 0x8A40 +UNIFORM_BLOCK_NAME_LENGTH :: 0x8A41 +UNIFORM_BLOCK_ACTIVE_UNIFORMS :: 0x8A42 +UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: 0x8A43 +UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: 0x8A44 +UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER :: 0x8A45 +UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: 0x8A46 +INVALID_INDEX :: 0xFFFFFFFF -CONTEXT_CORE_PROFILE_BIT :: 0x00000001; -CONTEXT_COMPATIBILITY_PROFILE_BIT :: 0x00000002; -LINES_ADJACENCY :: 0x000A; -LINE_STRIP_ADJACENCY :: 0x000B; -TRIANGLES_ADJACENCY :: 0x000C; -TRIANGLE_STRIP_ADJACENCY :: 0x000D; -PROGRAM_POINT_SIZE :: 0x8642; -MAX_GEOMETRY_TEXTURE_IMAGE_UNITS :: 0x8C29; -FRAMEBUFFER_ATTACHMENT_LAYERED :: 0x8DA7; -FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS :: 0x8DA8; -GEOMETRY_SHADER :: 0x8DD9; -GEOMETRY_VERTICES_OUT :: 0x8916; -GEOMETRY_INPUT_TYPE :: 0x8917; -GEOMETRY_OUTPUT_TYPE :: 0x8918; -MAX_GEOMETRY_UNIFORM_COMPONENTS :: 0x8DDF; -MAX_GEOMETRY_OUTPUT_VERTICES :: 0x8DE0; -MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS :: 0x8DE1; -MAX_VERTEX_OUTPUT_COMPONENTS :: 0x9122; -MAX_GEOMETRY_INPUT_COMPONENTS :: 0x9123; -MAX_GEOMETRY_OUTPUT_COMPONENTS :: 0x9124; -MAX_FRAGMENT_INPUT_COMPONENTS :: 0x9125; -CONTEXT_PROFILE_MASK :: 0x9126; -DEPTH_CLAMP :: 0x864F; -QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION :: 0x8E4C; -FIRST_VERTEX_CONVENTION :: 0x8E4D; -LAST_VERTEX_CONVENTION :: 0x8E4E; -PROVOKING_VERTEX :: 0x8E4F; -TEXTURE_CUBE_MAP_SEAMLESS :: 0x884F; -MAX_SERVER_WAIT_TIMEOUT :: 0x9111; -OBJECT_TYPE :: 0x9112; -SYNC_CONDITION :: 0x9113; -SYNC_STATUS :: 0x9114; -SYNC_FLAGS :: 0x9115; -SYNC_FENCE :: 0x9116; -SYNC_GPU_COMMANDS_COMPLETE :: 0x9117; -UNSIGNALED :: 0x9118; -SIGNALED :: 0x9119; -ALREADY_SIGNALED :: 0x911A; -TIMEOUT_EXPIRED :: 0x911B; -CONDITION_SATISFIED :: 0x911C; -WAIT_FAILED :: 0x911D; -TIMEOUT_IGNORED :: 0xFFFFFFFFFFFFFFFF; -SYNC_FLUSH_COMMANDS_BIT :: 0x00000001; -SAMPLE_POSITION :: 0x8E50; -SAMPLE_MASK :: 0x8E51; -SAMPLE_MASK_VALUE :: 0x8E52; -MAX_SAMPLE_MASK_WORDS :: 0x8E59; -TEXTURE_2D_MULTISAMPLE :: 0x9100; -PROXY_TEXTURE_2D_MULTISAMPLE :: 0x9101; -TEXTURE_2D_MULTISAMPLE_ARRAY :: 0x9102; -PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY :: 0x9103; -TEXTURE_BINDING_2D_MULTISAMPLE :: 0x9104; -TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY :: 0x9105; -TEXTURE_SAMPLES :: 0x9106; -TEXTURE_FIXED_SAMPLE_LOCATIONS :: 0x9107; -SAMPLER_2D_MULTISAMPLE :: 0x9108; -INT_SAMPLER_2D_MULTISAMPLE :: 0x9109; -UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE :: 0x910A; -SAMPLER_2D_MULTISAMPLE_ARRAY :: 0x910B; -INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: 0x910C; -UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: 0x910D; -MAX_COLOR_TEXTURE_SAMPLES :: 0x910E; -MAX_DEPTH_TEXTURE_SAMPLES :: 0x910F; -MAX_INTEGER_SAMPLES :: 0x9110; +CONTEXT_CORE_PROFILE_BIT :: 0x00000001 +CONTEXT_COMPATIBILITY_PROFILE_BIT :: 0x00000002 +LINES_ADJACENCY :: 0x000A +LINE_STRIP_ADJACENCY :: 0x000B +TRIANGLES_ADJACENCY :: 0x000C +TRIANGLE_STRIP_ADJACENCY :: 0x000D +PROGRAM_POINT_SIZE :: 0x8642 +MAX_GEOMETRY_TEXTURE_IMAGE_UNITS :: 0x8C29 +FRAMEBUFFER_ATTACHMENT_LAYERED :: 0x8DA7 +FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS :: 0x8DA8 +GEOMETRY_SHADER :: 0x8DD9 +GEOMETRY_VERTICES_OUT :: 0x8916 +GEOMETRY_INPUT_TYPE :: 0x8917 +GEOMETRY_OUTPUT_TYPE :: 0x8918 +MAX_GEOMETRY_UNIFORM_COMPONENTS :: 0x8DDF +MAX_GEOMETRY_OUTPUT_VERTICES :: 0x8DE0 +MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS :: 0x8DE1 +MAX_VERTEX_OUTPUT_COMPONENTS :: 0x9122 +MAX_GEOMETRY_INPUT_COMPONENTS :: 0x9123 +MAX_GEOMETRY_OUTPUT_COMPONENTS :: 0x9124 +MAX_FRAGMENT_INPUT_COMPONENTS :: 0x9125 +CONTEXT_PROFILE_MASK :: 0x9126 +DEPTH_CLAMP :: 0x864F +QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION :: 0x8E4C +FIRST_VERTEX_CONVENTION :: 0x8E4D +LAST_VERTEX_CONVENTION :: 0x8E4E +PROVOKING_VERTEX :: 0x8E4F +TEXTURE_CUBE_MAP_SEAMLESS :: 0x884F +MAX_SERVER_WAIT_TIMEOUT :: 0x9111 +OBJECT_TYPE :: 0x9112 +SYNC_CONDITION :: 0x9113 +SYNC_STATUS :: 0x9114 +SYNC_FLAGS :: 0x9115 +SYNC_FENCE :: 0x9116 +SYNC_GPU_COMMANDS_COMPLETE :: 0x9117 +UNSIGNALED :: 0x9118 +SIGNALED :: 0x9119 +ALREADY_SIGNALED :: 0x911A +TIMEOUT_EXPIRED :: 0x911B +CONDITION_SATISFIED :: 0x911C +WAIT_FAILED :: 0x911D +TIMEOUT_IGNORED :: 0xFFFFFFFFFFFFFFFF +SYNC_FLUSH_COMMANDS_BIT :: 0x00000001 +SAMPLE_POSITION :: 0x8E50 +SAMPLE_MASK :: 0x8E51 +SAMPLE_MASK_VALUE :: 0x8E52 +MAX_SAMPLE_MASK_WORDS :: 0x8E59 +TEXTURE_2D_MULTISAMPLE :: 0x9100 +PROXY_TEXTURE_2D_MULTISAMPLE :: 0x9101 +TEXTURE_2D_MULTISAMPLE_ARRAY :: 0x9102 +PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY :: 0x9103 +TEXTURE_BINDING_2D_MULTISAMPLE :: 0x9104 +TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY :: 0x9105 +TEXTURE_SAMPLES :: 0x9106 +TEXTURE_FIXED_SAMPLE_LOCATIONS :: 0x9107 +SAMPLER_2D_MULTISAMPLE :: 0x9108 +INT_SAMPLER_2D_MULTISAMPLE :: 0x9109 +UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE :: 0x910A +SAMPLER_2D_MULTISAMPLE_ARRAY :: 0x910B +INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: 0x910C +UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: 0x910D +MAX_COLOR_TEXTURE_SAMPLES :: 0x910E +MAX_DEPTH_TEXTURE_SAMPLES :: 0x910F +MAX_INTEGER_SAMPLES :: 0x9110 -VERTEX_ATTRIB_ARRAY_DIVISOR :: 0x88FE; -SRC1_COLOR :: 0x88F9; -ONE_MINUS_SRC1_COLOR :: 0x88FA; -ONE_MINUS_SRC1_ALPHA :: 0x88FB; -MAX_DUAL_SOURCE_DRAW_BUFFERS :: 0x88FC; -ANY_SAMPLES_PASSED :: 0x8C2F; -SAMPLER_BINDING :: 0x8919; -RGB10_A2UI :: 0x906F; -TEXTURE_SWIZZLE_R :: 0x8E42; -TEXTURE_SWIZZLE_G :: 0x8E43; -TEXTURE_SWIZZLE_B :: 0x8E44; -TEXTURE_SWIZZLE_A :: 0x8E45; -TEXTURE_SWIZZLE_RGBA :: 0x8E46; -TIME_ELAPSED :: 0x88BF; -TIMESTAMP :: 0x8E28; -INT_2_10_10_10_REV :: 0x8D9F; +VERTEX_ATTRIB_ARRAY_DIVISOR :: 0x88FE +SRC1_COLOR :: 0x88F9 +ONE_MINUS_SRC1_COLOR :: 0x88FA +ONE_MINUS_SRC1_ALPHA :: 0x88FB +MAX_DUAL_SOURCE_DRAW_BUFFERS :: 0x88FC +ANY_SAMPLES_PASSED :: 0x8C2F +SAMPLER_BINDING :: 0x8919 +RGB10_A2UI :: 0x906F +TEXTURE_SWIZZLE_R :: 0x8E42 +TEXTURE_SWIZZLE_G :: 0x8E43 +TEXTURE_SWIZZLE_B :: 0x8E44 +TEXTURE_SWIZZLE_A :: 0x8E45 +TEXTURE_SWIZZLE_RGBA :: 0x8E46 +TIME_ELAPSED :: 0x88BF +TIMESTAMP :: 0x8E28 +INT_2_10_10_10_REV :: 0x8D9F -SAMPLE_SHADING :: 0x8C36; -MIN_SAMPLE_SHADING_VALUE :: 0x8C37; -MIN_PROGRAM_TEXTURE_GATHER_OFFSET :: 0x8E5E; -MAX_PROGRAM_TEXTURE_GATHER_OFFSET :: 0x8E5F; -TEXTURE_CUBE_MAP_ARRAY :: 0x9009; -TEXTURE_BINDING_CUBE_MAP_ARRAY :: 0x900A; -PROXY_TEXTURE_CUBE_MAP_ARRAY :: 0x900B; -SAMPLER_CUBE_MAP_ARRAY :: 0x900C; -SAMPLER_CUBE_MAP_ARRAY_SHADOW :: 0x900D; -INT_SAMPLER_CUBE_MAP_ARRAY :: 0x900E; -UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY :: 0x900F; -DRAW_INDIRECT_BUFFER :: 0x8F3F; -DRAW_INDIRECT_BUFFER_BINDING :: 0x8F43; -GEOMETRY_SHADER_INVOCATIONS :: 0x887F; -MAX_GEOMETRY_SHADER_INVOCATIONS :: 0x8E5A; -MIN_FRAGMENT_INTERPOLATION_OFFSET :: 0x8E5B; -MAX_FRAGMENT_INTERPOLATION_OFFSET :: 0x8E5C; -FRAGMENT_INTERPOLATION_OFFSET_BITS :: 0x8E5D; -MAX_VERTEX_STREAMS :: 0x8E71; -DOUBLE_VEC2 :: 0x8FFC; -DOUBLE_VEC3 :: 0x8FFD; -DOUBLE_VEC4 :: 0x8FFE; -DOUBLE_MAT2 :: 0x8F46; -DOUBLE_MAT3 :: 0x8F47; -DOUBLE_MAT4 :: 0x8F48; -DOUBLE_MAT2x3 :: 0x8F49; -DOUBLE_MAT2x4 :: 0x8F4A; -DOUBLE_MAT3x2 :: 0x8F4B; -DOUBLE_MAT3x4 :: 0x8F4C; -DOUBLE_MAT4x2 :: 0x8F4D; -DOUBLE_MAT4x3 :: 0x8F4E; -ACTIVE_SUBROUTINES :: 0x8DE5; -ACTIVE_SUBROUTINE_UNIFORMS :: 0x8DE6; -ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS :: 0x8E47; -ACTIVE_SUBROUTINE_MAX_LENGTH :: 0x8E48; -ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH :: 0x8E49; -MAX_SUBROUTINES :: 0x8DE7; -MAX_SUBROUTINE_UNIFORM_LOCATIONS :: 0x8DE8; -NUM_COMPATIBLE_SUBROUTINES :: 0x8E4A; -COMPATIBLE_SUBROUTINES :: 0x8E4B; -PATCHES :: 0x000E; -PATCH_VERTICES :: 0x8E72; -PATCH_DEFAULT_INNER_LEVEL :: 0x8E73; -PATCH_DEFAULT_OUTER_LEVEL :: 0x8E74; -TESS_CONTROL_OUTPUT_VERTICES :: 0x8E75; -TESS_GEN_MODE :: 0x8E76; -TESS_GEN_SPACING :: 0x8E77; -TESS_GEN_VERTEX_ORDER :: 0x8E78; -TESS_GEN_POINT_MODE :: 0x8E79; -ISOLINES :: 0x8E7A; -FRACTIONAL_ODD :: 0x8E7B; -FRACTIONAL_EVEN :: 0x8E7C; -MAX_PATCH_VERTICES :: 0x8E7D; -MAX_TESS_GEN_LEVEL :: 0x8E7E; -MAX_TESS_CONTROL_UNIFORM_COMPONENTS :: 0x8E7F; -MAX_TESS_EVALUATION_UNIFORM_COMPONENTS :: 0x8E80; -MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS :: 0x8E81; -MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS :: 0x8E82; -MAX_TESS_CONTROL_OUTPUT_COMPONENTS :: 0x8E83; -MAX_TESS_PATCH_COMPONENTS :: 0x8E84; -MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS :: 0x8E85; -MAX_TESS_EVALUATION_OUTPUT_COMPONENTS :: 0x8E86; -MAX_TESS_CONTROL_UNIFORM_BLOCKS :: 0x8E89; -MAX_TESS_EVALUATION_UNIFORM_BLOCKS :: 0x8E8A; -MAX_TESS_CONTROL_INPUT_COMPONENTS :: 0x886C; -MAX_TESS_EVALUATION_INPUT_COMPONENTS :: 0x886D; -MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS :: 0x8E1E; -MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS :: 0x8E1F; -UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER :: 0x84F0; -UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x84F1; -TESS_EVALUATION_SHADER :: 0x8E87; -TESS_CONTROL_SHADER :: 0x8E88; -TRANSFORM_FEEDBACK :: 0x8E22; -TRANSFORM_FEEDBACK_BUFFER_PAUSED :: 0x8E23; -TRANSFORM_FEEDBACK_BUFFER_ACTIVE :: 0x8E24; -TRANSFORM_FEEDBACK_BINDING :: 0x8E25; -MAX_TRANSFORM_FEEDBACK_BUFFERS :: 0x8E70; +SAMPLE_SHADING :: 0x8C36 +MIN_SAMPLE_SHADING_VALUE :: 0x8C37 +MIN_PROGRAM_TEXTURE_GATHER_OFFSET :: 0x8E5E +MAX_PROGRAM_TEXTURE_GATHER_OFFSET :: 0x8E5F +TEXTURE_CUBE_MAP_ARRAY :: 0x9009 +TEXTURE_BINDING_CUBE_MAP_ARRAY :: 0x900A +PROXY_TEXTURE_CUBE_MAP_ARRAY :: 0x900B +SAMPLER_CUBE_MAP_ARRAY :: 0x900C +SAMPLER_CUBE_MAP_ARRAY_SHADOW :: 0x900D +INT_SAMPLER_CUBE_MAP_ARRAY :: 0x900E +UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY :: 0x900F +DRAW_INDIRECT_BUFFER :: 0x8F3F +DRAW_INDIRECT_BUFFER_BINDING :: 0x8F43 +GEOMETRY_SHADER_INVOCATIONS :: 0x887F +MAX_GEOMETRY_SHADER_INVOCATIONS :: 0x8E5A +MIN_FRAGMENT_INTERPOLATION_OFFSET :: 0x8E5B +MAX_FRAGMENT_INTERPOLATION_OFFSET :: 0x8E5C +FRAGMENT_INTERPOLATION_OFFSET_BITS :: 0x8E5D +MAX_VERTEX_STREAMS :: 0x8E71 +DOUBLE_VEC2 :: 0x8FFC +DOUBLE_VEC3 :: 0x8FFD +DOUBLE_VEC4 :: 0x8FFE +DOUBLE_MAT2 :: 0x8F46 +DOUBLE_MAT3 :: 0x8F47 +DOUBLE_MAT4 :: 0x8F48 +DOUBLE_MAT2x3 :: 0x8F49 +DOUBLE_MAT2x4 :: 0x8F4A +DOUBLE_MAT3x2 :: 0x8F4B +DOUBLE_MAT3x4 :: 0x8F4C +DOUBLE_MAT4x2 :: 0x8F4D +DOUBLE_MAT4x3 :: 0x8F4E +ACTIVE_SUBROUTINES :: 0x8DE5 +ACTIVE_SUBROUTINE_UNIFORMS :: 0x8DE6 +ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS :: 0x8E47 +ACTIVE_SUBROUTINE_MAX_LENGTH :: 0x8E48 +ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH :: 0x8E49 +MAX_SUBROUTINES :: 0x8DE7 +MAX_SUBROUTINE_UNIFORM_LOCATIONS :: 0x8DE8 +NUM_COMPATIBLE_SUBROUTINES :: 0x8E4A +COMPATIBLE_SUBROUTINES :: 0x8E4B +PATCHES :: 0x000E +PATCH_VERTICES :: 0x8E72 +PATCH_DEFAULT_INNER_LEVEL :: 0x8E73 +PATCH_DEFAULT_OUTER_LEVEL :: 0x8E74 +TESS_CONTROL_OUTPUT_VERTICES :: 0x8E75 +TESS_GEN_MODE :: 0x8E76 +TESS_GEN_SPACING :: 0x8E77 +TESS_GEN_VERTEX_ORDER :: 0x8E78 +TESS_GEN_POINT_MODE :: 0x8E79 +ISOLINES :: 0x8E7A +FRACTIONAL_ODD :: 0x8E7B +FRACTIONAL_EVEN :: 0x8E7C +MAX_PATCH_VERTICES :: 0x8E7D +MAX_TESS_GEN_LEVEL :: 0x8E7E +MAX_TESS_CONTROL_UNIFORM_COMPONENTS :: 0x8E7F +MAX_TESS_EVALUATION_UNIFORM_COMPONENTS :: 0x8E80 +MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS :: 0x8E81 +MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS :: 0x8E82 +MAX_TESS_CONTROL_OUTPUT_COMPONENTS :: 0x8E83 +MAX_TESS_PATCH_COMPONENTS :: 0x8E84 +MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS :: 0x8E85 +MAX_TESS_EVALUATION_OUTPUT_COMPONENTS :: 0x8E86 +MAX_TESS_CONTROL_UNIFORM_BLOCKS :: 0x8E89 +MAX_TESS_EVALUATION_UNIFORM_BLOCKS :: 0x8E8A +MAX_TESS_CONTROL_INPUT_COMPONENTS :: 0x886C +MAX_TESS_EVALUATION_INPUT_COMPONENTS :: 0x886D +MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS :: 0x8E1E +MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS :: 0x8E1F +UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER :: 0x84F0 +UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x84F1 +TESS_EVALUATION_SHADER :: 0x8E87 +TESS_CONTROL_SHADER :: 0x8E88 +TRANSFORM_FEEDBACK :: 0x8E22 +TRANSFORM_FEEDBACK_BUFFER_PAUSED :: 0x8E23 +TRANSFORM_FEEDBACK_BUFFER_ACTIVE :: 0x8E24 +TRANSFORM_FEEDBACK_BINDING :: 0x8E25 +MAX_TRANSFORM_FEEDBACK_BUFFERS :: 0x8E70 -FIXED :: 0x140C; -IMPLEMENTATION_COLOR_READ_TYPE :: 0x8B9A; -IMPLEMENTATION_COLOR_READ_FORMAT :: 0x8B9B; -LOW_FLOAT :: 0x8DF0; -MEDIUM_FLOAT :: 0x8DF1; -HIGH_FLOAT :: 0x8DF2; -LOW_INT :: 0x8DF3; -MEDIUM_INT :: 0x8DF4; -HIGH_INT :: 0x8DF5; -SHADER_COMPILER :: 0x8DFA; -SHADER_BINARY_FORMATS :: 0x8DF8; -NUM_SHADER_BINARY_FORMATS :: 0x8DF9; -MAX_VERTEX_UNIFORM_VECTORS :: 0x8DFB; -MAX_VARYING_VECTORS :: 0x8DFC; -MAX_FRAGMENT_UNIFORM_VECTORS :: 0x8DFD; -RGB565 :: 0x8D62; -PROGRAM_BINARY_RETRIEVABLE_HINT :: 0x8257; -PROGRAM_BINARY_LENGTH :: 0x8741; -NUM_PROGRAM_BINARY_FORMATS :: 0x87FE; -PROGRAM_BINARY_FORMATS :: 0x87FF; -VERTEX_SHADER_BIT :: 0x00000001; -FRAGMENT_SHADER_BIT :: 0x00000002; -GEOMETRY_SHADER_BIT :: 0x00000004; -TESS_CONTROL_SHADER_BIT :: 0x00000008; -TESS_EVALUATION_SHADER_BIT :: 0x00000010; -ALL_SHADER_BITS :: 0xFFFFFFFF; -PROGRAM_SEPARABLE :: 0x8258; -ACTIVE_PROGRAM :: 0x8259; -PROGRAM_PIPELINE_BINDING :: 0x825A; -MAX_VIEWPORTS :: 0x825B; -VIEWPORT_SUBPIXEL_BITS :: 0x825C; -VIEWPORT_BOUNDS_RANGE :: 0x825D; -LAYER_PROVOKING_VERTEX :: 0x825E; -VIEWPORT_INDEX_PROVOKING_VERTEX :: 0x825F; -UNDEFINED_VERTEX :: 0x8260; +FIXED :: 0x140C +IMPLEMENTATION_COLOR_READ_TYPE :: 0x8B9A +IMPLEMENTATION_COLOR_READ_FORMAT :: 0x8B9B +LOW_FLOAT :: 0x8DF0 +MEDIUM_FLOAT :: 0x8DF1 +HIGH_FLOAT :: 0x8DF2 +LOW_INT :: 0x8DF3 +MEDIUM_INT :: 0x8DF4 +HIGH_INT :: 0x8DF5 +SHADER_COMPILER :: 0x8DFA +SHADER_BINARY_FORMATS :: 0x8DF8 +NUM_SHADER_BINARY_FORMATS :: 0x8DF9 +MAX_VERTEX_UNIFORM_VECTORS :: 0x8DFB +MAX_VARYING_VECTORS :: 0x8DFC +MAX_FRAGMENT_UNIFORM_VECTORS :: 0x8DFD +RGB565 :: 0x8D62 +PROGRAM_BINARY_RETRIEVABLE_HINT :: 0x8257 +PROGRAM_BINARY_LENGTH :: 0x8741 +NUM_PROGRAM_BINARY_FORMATS :: 0x87FE +PROGRAM_BINARY_FORMATS :: 0x87FF +VERTEX_SHADER_BIT :: 0x00000001 +FRAGMENT_SHADER_BIT :: 0x00000002 +GEOMETRY_SHADER_BIT :: 0x00000004 +TESS_CONTROL_SHADER_BIT :: 0x00000008 +TESS_EVALUATION_SHADER_BIT :: 0x00000010 +ALL_SHADER_BITS :: 0xFFFFFFFF +PROGRAM_SEPARABLE :: 0x8258 +ACTIVE_PROGRAM :: 0x8259 +PROGRAM_PIPELINE_BINDING :: 0x825A +MAX_VIEWPORTS :: 0x825B +VIEWPORT_SUBPIXEL_BITS :: 0x825C +VIEWPORT_BOUNDS_RANGE :: 0x825D +LAYER_PROVOKING_VERTEX :: 0x825E +VIEWPORT_INDEX_PROVOKING_VERTEX :: 0x825F +UNDEFINED_VERTEX :: 0x8260 -COPY_READ_BUFFER_BINDING :: 0x8F36; -COPY_WRITE_BUFFER_BINDING :: 0x8F37; -TRANSFORM_FEEDBACK_ACTIVE :: 0x8E24; -TRANSFORM_FEEDBACK_PAUSED :: 0x8E23; -UNPACK_COMPRESSED_BLOCK_WIDTH :: 0x9127; -UNPACK_COMPRESSED_BLOCK_HEIGHT :: 0x9128; -UNPACK_COMPRESSED_BLOCK_DEPTH :: 0x9129; -UNPACK_COMPRESSED_BLOCK_SIZE :: 0x912A; -PACK_COMPRESSED_BLOCK_WIDTH :: 0x912B; -PACK_COMPRESSED_BLOCK_HEIGHT :: 0x912C; -PACK_COMPRESSED_BLOCK_DEPTH :: 0x912D; -PACK_COMPRESSED_BLOCK_SIZE :: 0x912E; -NUM_SAMPLE_COUNTS :: 0x9380; -MIN_MAP_BUFFER_ALIGNMENT :: 0x90BC; -ATOMIC_COUNTER_BUFFER :: 0x92C0; -ATOMIC_COUNTER_BUFFER_BINDING :: 0x92C1; -ATOMIC_COUNTER_BUFFER_START :: 0x92C2; -ATOMIC_COUNTER_BUFFER_SIZE :: 0x92C3; -ATOMIC_COUNTER_BUFFER_DATA_SIZE :: 0x92C4; -ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS :: 0x92C5; -ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES :: 0x92C6; -ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER :: 0x92C7; -ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER :: 0x92C8; -ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x92C9; -ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER :: 0x92CA; -ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER :: 0x92CB; -MAX_VERTEX_ATOMIC_COUNTER_BUFFERS :: 0x92CC; -MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS :: 0x92CD; -MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS :: 0x92CE; -MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS :: 0x92CF; -MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS :: 0x92D0; -MAX_COMBINED_ATOMIC_COUNTER_BUFFERS :: 0x92D1; -MAX_VERTEX_ATOMIC_COUNTERS :: 0x92D2; -MAX_TESS_CONTROL_ATOMIC_COUNTERS :: 0x92D3; -MAX_TESS_EVALUATION_ATOMIC_COUNTERS :: 0x92D4; -MAX_GEOMETRY_ATOMIC_COUNTERS :: 0x92D5; -MAX_FRAGMENT_ATOMIC_COUNTERS :: 0x92D6; -MAX_COMBINED_ATOMIC_COUNTERS :: 0x92D7; -MAX_ATOMIC_COUNTER_BUFFER_SIZE :: 0x92D8; -MAX_ATOMIC_COUNTER_BUFFER_BINDINGS :: 0x92DC; -ACTIVE_ATOMIC_COUNTER_BUFFERS :: 0x92D9; -UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX :: 0x92DA; -UNSIGNED_INT_ATOMIC_COUNTER :: 0x92DB; -VERTEX_ATTRIB_ARRAY_BARRIER_BIT :: 0x00000001; -ELEMENT_ARRAY_BARRIER_BIT :: 0x00000002; -UNIFORM_BARRIER_BIT :: 0x00000004; -TEXTURE_FETCH_BARRIER_BIT :: 0x00000008; -SHADER_IMAGE_ACCESS_BARRIER_BIT :: 0x00000020; -COMMAND_BARRIER_BIT :: 0x00000040; -PIXEL_BUFFER_BARRIER_BIT :: 0x00000080; -TEXTURE_UPDATE_BARRIER_BIT :: 0x00000100; -BUFFER_UPDATE_BARRIER_BIT :: 0x00000200; -FRAMEBUFFER_BARRIER_BIT :: 0x00000400; -TRANSFORM_FEEDBACK_BARRIER_BIT :: 0x00000800; -ATOMIC_COUNTER_BARRIER_BIT :: 0x00001000; -ALL_BARRIER_BITS :: 0xFFFFFFFF; -MAX_IMAGE_UNITS :: 0x8F38; -MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS :: 0x8F39; -IMAGE_BINDING_NAME :: 0x8F3A; -IMAGE_BINDING_LEVEL :: 0x8F3B; -IMAGE_BINDING_LAYERED :: 0x8F3C; -IMAGE_BINDING_LAYER :: 0x8F3D; -IMAGE_BINDING_ACCESS :: 0x8F3E; -IMAGE_1D :: 0x904C; -IMAGE_2D :: 0x904D; -IMAGE_3D :: 0x904E; -IMAGE_2D_RECT :: 0x904F; -IMAGE_CUBE :: 0x9050; -IMAGE_BUFFER :: 0x9051; -IMAGE_1D_ARRAY :: 0x9052; -IMAGE_2D_ARRAY :: 0x9053; -IMAGE_CUBE_MAP_ARRAY :: 0x9054; -IMAGE_2D_MULTISAMPLE :: 0x9055; -IMAGE_2D_MULTISAMPLE_ARRAY :: 0x9056; -INT_IMAGE_1D :: 0x9057; -INT_IMAGE_2D :: 0x9058; -INT_IMAGE_3D :: 0x9059; -INT_IMAGE_2D_RECT :: 0x905A; -INT_IMAGE_CUBE :: 0x905B; -INT_IMAGE_BUFFER :: 0x905C; -INT_IMAGE_1D_ARRAY :: 0x905D; -INT_IMAGE_2D_ARRAY :: 0x905E; -INT_IMAGE_CUBE_MAP_ARRAY :: 0x905F; -INT_IMAGE_2D_MULTISAMPLE :: 0x9060; -INT_IMAGE_2D_MULTISAMPLE_ARRAY :: 0x9061; -UNSIGNED_INT_IMAGE_1D :: 0x9062; -UNSIGNED_INT_IMAGE_2D :: 0x9063; -UNSIGNED_INT_IMAGE_3D :: 0x9064; -UNSIGNED_INT_IMAGE_2D_RECT :: 0x9065; -UNSIGNED_INT_IMAGE_CUBE :: 0x9066; -UNSIGNED_INT_IMAGE_BUFFER :: 0x9067; -UNSIGNED_INT_IMAGE_1D_ARRAY :: 0x9068; -UNSIGNED_INT_IMAGE_2D_ARRAY :: 0x9069; -UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY :: 0x906A; -UNSIGNED_INT_IMAGE_2D_MULTISAMPLE :: 0x906B; -UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY :: 0x906C; -MAX_IMAGE_SAMPLES :: 0x906D; -IMAGE_BINDING_FORMAT :: 0x906E; -IMAGE_FORMAT_COMPATIBILITY_TYPE :: 0x90C7; -IMAGE_FORMAT_COMPATIBILITY_BY_SIZE :: 0x90C8; -IMAGE_FORMAT_COMPATIBILITY_BY_CLASS :: 0x90C9; -MAX_VERTEX_IMAGE_UNIFORMS :: 0x90CA; -MAX_TESS_CONTROL_IMAGE_UNIFORMS :: 0x90CB; -MAX_TESS_EVALUATION_IMAGE_UNIFORMS :: 0x90CC; -MAX_GEOMETRY_IMAGE_UNIFORMS :: 0x90CD; -MAX_FRAGMENT_IMAGE_UNIFORMS :: 0x90CE; -MAX_COMBINED_IMAGE_UNIFORMS :: 0x90CF; -COMPRESSED_RGBA_BPTC_UNORM :: 0x8E8C; -COMPRESSED_SRGB_ALPHA_BPTC_UNORM :: 0x8E8D; -COMPRESSED_RGB_BPTC_SIGNED_FLOAT :: 0x8E8E; -COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT :: 0x8E8F; -TEXTURE_IMMUTABLE_FORMAT :: 0x912F; +COPY_READ_BUFFER_BINDING :: 0x8F36 +COPY_WRITE_BUFFER_BINDING :: 0x8F37 +TRANSFORM_FEEDBACK_ACTIVE :: 0x8E24 +TRANSFORM_FEEDBACK_PAUSED :: 0x8E23 +UNPACK_COMPRESSED_BLOCK_WIDTH :: 0x9127 +UNPACK_COMPRESSED_BLOCK_HEIGHT :: 0x9128 +UNPACK_COMPRESSED_BLOCK_DEPTH :: 0x9129 +UNPACK_COMPRESSED_BLOCK_SIZE :: 0x912A +PACK_COMPRESSED_BLOCK_WIDTH :: 0x912B +PACK_COMPRESSED_BLOCK_HEIGHT :: 0x912C +PACK_COMPRESSED_BLOCK_DEPTH :: 0x912D +PACK_COMPRESSED_BLOCK_SIZE :: 0x912E +NUM_SAMPLE_COUNTS :: 0x9380 +MIN_MAP_BUFFER_ALIGNMENT :: 0x90BC +ATOMIC_COUNTER_BUFFER :: 0x92C0 +ATOMIC_COUNTER_BUFFER_BINDING :: 0x92C1 +ATOMIC_COUNTER_BUFFER_START :: 0x92C2 +ATOMIC_COUNTER_BUFFER_SIZE :: 0x92C3 +ATOMIC_COUNTER_BUFFER_DATA_SIZE :: 0x92C4 +ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS :: 0x92C5 +ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES :: 0x92C6 +ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER :: 0x92C7 +ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER :: 0x92C8 +ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x92C9 +ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER :: 0x92CA +ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER :: 0x92CB +MAX_VERTEX_ATOMIC_COUNTER_BUFFERS :: 0x92CC +MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS :: 0x92CD +MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS :: 0x92CE +MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS :: 0x92CF +MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS :: 0x92D0 +MAX_COMBINED_ATOMIC_COUNTER_BUFFERS :: 0x92D1 +MAX_VERTEX_ATOMIC_COUNTERS :: 0x92D2 +MAX_TESS_CONTROL_ATOMIC_COUNTERS :: 0x92D3 +MAX_TESS_EVALUATION_ATOMIC_COUNTERS :: 0x92D4 +MAX_GEOMETRY_ATOMIC_COUNTERS :: 0x92D5 +MAX_FRAGMENT_ATOMIC_COUNTERS :: 0x92D6 +MAX_COMBINED_ATOMIC_COUNTERS :: 0x92D7 +MAX_ATOMIC_COUNTER_BUFFER_SIZE :: 0x92D8 +MAX_ATOMIC_COUNTER_BUFFER_BINDINGS :: 0x92DC +ACTIVE_ATOMIC_COUNTER_BUFFERS :: 0x92D9 +UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX :: 0x92DA +UNSIGNED_INT_ATOMIC_COUNTER :: 0x92DB +VERTEX_ATTRIB_ARRAY_BARRIER_BIT :: 0x00000001 +ELEMENT_ARRAY_BARRIER_BIT :: 0x00000002 +UNIFORM_BARRIER_BIT :: 0x00000004 +TEXTURE_FETCH_BARRIER_BIT :: 0x00000008 +SHADER_IMAGE_ACCESS_BARRIER_BIT :: 0x00000020 +COMMAND_BARRIER_BIT :: 0x00000040 +PIXEL_BUFFER_BARRIER_BIT :: 0x00000080 +TEXTURE_UPDATE_BARRIER_BIT :: 0x00000100 +BUFFER_UPDATE_BARRIER_BIT :: 0x00000200 +FRAMEBUFFER_BARRIER_BIT :: 0x00000400 +TRANSFORM_FEEDBACK_BARRIER_BIT :: 0x00000800 +ATOMIC_COUNTER_BARRIER_BIT :: 0x00001000 +ALL_BARRIER_BITS :: 0xFFFFFFFF +MAX_IMAGE_UNITS :: 0x8F38 +MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS :: 0x8F39 +IMAGE_BINDING_NAME :: 0x8F3A +IMAGE_BINDING_LEVEL :: 0x8F3B +IMAGE_BINDING_LAYERED :: 0x8F3C +IMAGE_BINDING_LAYER :: 0x8F3D +IMAGE_BINDING_ACCESS :: 0x8F3E +IMAGE_1D :: 0x904C +IMAGE_2D :: 0x904D +IMAGE_3D :: 0x904E +IMAGE_2D_RECT :: 0x904F +IMAGE_CUBE :: 0x9050 +IMAGE_BUFFER :: 0x9051 +IMAGE_1D_ARRAY :: 0x9052 +IMAGE_2D_ARRAY :: 0x9053 +IMAGE_CUBE_MAP_ARRAY :: 0x9054 +IMAGE_2D_MULTISAMPLE :: 0x9055 +IMAGE_2D_MULTISAMPLE_ARRAY :: 0x9056 +INT_IMAGE_1D :: 0x9057 +INT_IMAGE_2D :: 0x9058 +INT_IMAGE_3D :: 0x9059 +INT_IMAGE_2D_RECT :: 0x905A +INT_IMAGE_CUBE :: 0x905B +INT_IMAGE_BUFFER :: 0x905C +INT_IMAGE_1D_ARRAY :: 0x905D +INT_IMAGE_2D_ARRAY :: 0x905E +INT_IMAGE_CUBE_MAP_ARRAY :: 0x905F +INT_IMAGE_2D_MULTISAMPLE :: 0x9060 +INT_IMAGE_2D_MULTISAMPLE_ARRAY :: 0x9061 +UNSIGNED_INT_IMAGE_1D :: 0x9062 +UNSIGNED_INT_IMAGE_2D :: 0x9063 +UNSIGNED_INT_IMAGE_3D :: 0x9064 +UNSIGNED_INT_IMAGE_2D_RECT :: 0x9065 +UNSIGNED_INT_IMAGE_CUBE :: 0x9066 +UNSIGNED_INT_IMAGE_BUFFER :: 0x9067 +UNSIGNED_INT_IMAGE_1D_ARRAY :: 0x9068 +UNSIGNED_INT_IMAGE_2D_ARRAY :: 0x9069 +UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY :: 0x906A +UNSIGNED_INT_IMAGE_2D_MULTISAMPLE :: 0x906B +UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY :: 0x906C +MAX_IMAGE_SAMPLES :: 0x906D +IMAGE_BINDING_FORMAT :: 0x906E +IMAGE_FORMAT_COMPATIBILITY_TYPE :: 0x90C7 +IMAGE_FORMAT_COMPATIBILITY_BY_SIZE :: 0x90C8 +IMAGE_FORMAT_COMPATIBILITY_BY_CLASS :: 0x90C9 +MAX_VERTEX_IMAGE_UNIFORMS :: 0x90CA +MAX_TESS_CONTROL_IMAGE_UNIFORMS :: 0x90CB +MAX_TESS_EVALUATION_IMAGE_UNIFORMS :: 0x90CC +MAX_GEOMETRY_IMAGE_UNIFORMS :: 0x90CD +MAX_FRAGMENT_IMAGE_UNIFORMS :: 0x90CE +MAX_COMBINED_IMAGE_UNIFORMS :: 0x90CF +COMPRESSED_RGBA_BPTC_UNORM :: 0x8E8C +COMPRESSED_SRGB_ALPHA_BPTC_UNORM :: 0x8E8D +COMPRESSED_RGB_BPTC_SIGNED_FLOAT :: 0x8E8E +COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT :: 0x8E8F +TEXTURE_IMMUTABLE_FORMAT :: 0x912F -NUM_SHADING_LANGUAGE_VERSIONS :: 0x82E9; -VERTEX_ATTRIB_ARRAY_LONG :: 0x874E; -COMPRESSED_RGB8_ETC2 :: 0x9274; -COMPRESSED_SRGB8_ETC2 :: 0x9275; -COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: 0x9276; -COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: 0x9277; -COMPRESSED_RGBA8_ETC2_EAC :: 0x9278; -COMPRESSED_SRGB8_ALPHA8_ETC2_EAC :: 0x9279; -COMPRESSED_R11_EAC :: 0x9270; -COMPRESSED_SIGNED_R11_EAC :: 0x9271; -COMPRESSED_RG11_EAC :: 0x9272; -COMPRESSED_SIGNED_RG11_EAC :: 0x9273; -PRIMITIVE_RESTART_FIXED_INDEX :: 0x8D69; -ANY_SAMPLES_PASSED_CONSERVATIVE :: 0x8D6A; -MAX_ELEMENT_INDEX :: 0x8D6B; -COMPUTE_SHADER :: 0x91B9; -MAX_COMPUTE_UNIFORM_BLOCKS :: 0x91BB; -MAX_COMPUTE_TEXTURE_IMAGE_UNITS :: 0x91BC; -MAX_COMPUTE_IMAGE_UNIFORMS :: 0x91BD; -MAX_COMPUTE_SHARED_MEMORY_SIZE :: 0x8262; -MAX_COMPUTE_UNIFORM_COMPONENTS :: 0x8263; -MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS :: 0x8264; -MAX_COMPUTE_ATOMIC_COUNTERS :: 0x8265; -MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS :: 0x8266; -MAX_COMPUTE_WORK_GROUP_INVOCATIONS :: 0x90EB; -MAX_COMPUTE_WORK_GROUP_COUNT :: 0x91BE; -MAX_COMPUTE_WORK_GROUP_SIZE :: 0x91BF; -COMPUTE_WORK_GROUP_SIZE :: 0x8267; -UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER :: 0x90EC; -ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER :: 0x90ED; -DISPATCH_INDIRECT_BUFFER :: 0x90EE; -DISPATCH_INDIRECT_BUFFER_BINDING :: 0x90EF; -COMPUTE_SHADER_BIT :: 0x00000020; -DEBUG_OUTPUT_SYNCHRONOUS :: 0x8242; -DEBUG_NEXT_LOGGED_MESSAGE_LENGTH :: 0x8243; -DEBUG_CALLBACK_FUNCTION :: 0x8244; -DEBUG_CALLBACK_USER_PARAM :: 0x8245; -DEBUG_SOURCE_API :: 0x8246; -DEBUG_SOURCE_WINDOW_SYSTEM :: 0x8247; -DEBUG_SOURCE_SHADER_COMPILER :: 0x8248; -DEBUG_SOURCE_THIRD_PARTY :: 0x8249; -DEBUG_SOURCE_APPLICATION :: 0x824A; -DEBUG_SOURCE_OTHER :: 0x824B; -DEBUG_TYPE_ERROR :: 0x824C; -DEBUG_TYPE_DEPRECATED_BEHAVIOR :: 0x824D; -DEBUG_TYPE_UNDEFINED_BEHAVIOR :: 0x824E; -DEBUG_TYPE_PORTABILITY :: 0x824F; -DEBUG_TYPE_PERFORMANCE :: 0x8250; -DEBUG_TYPE_OTHER :: 0x8251; -MAX_DEBUG_MESSAGE_LENGTH :: 0x9143; -MAX_DEBUG_LOGGED_MESSAGES :: 0x9144; -DEBUG_LOGGED_MESSAGES :: 0x9145; -DEBUG_SEVERITY_HIGH :: 0x9146; -DEBUG_SEVERITY_MEDIUM :: 0x9147; -DEBUG_SEVERITY_LOW :: 0x9148; -DEBUG_TYPE_MARKER :: 0x8268; -DEBUG_TYPE_PUSH_GROUP :: 0x8269; -DEBUG_TYPE_POP_GROUP :: 0x826A; -DEBUG_SEVERITY_NOTIFICATION :: 0x826B; -MAX_DEBUG_GROUP_STACK_DEPTH :: 0x826C; -DEBUG_GROUP_STACK_DEPTH :: 0x826D; -BUFFER :: 0x82E0; -SHADER :: 0x82E1; -PROGRAM :: 0x82E2; -QUERY :: 0x82E3; -PROGRAM_PIPELINE :: 0x82E4; -SAMPLER :: 0x82E6; -MAX_LABEL_LENGTH :: 0x82E8; -DEBUG_OUTPUT :: 0x92E0; -CONTEXT_FLAG_DEBUG_BIT :: 0x00000002; -MAX_UNIFORM_LOCATIONS :: 0x826E; -FRAMEBUFFER_DEFAULT_WIDTH :: 0x9310; -FRAMEBUFFER_DEFAULT_HEIGHT :: 0x9311; -FRAMEBUFFER_DEFAULT_LAYERS :: 0x9312; -FRAMEBUFFER_DEFAULT_SAMPLES :: 0x9313; -FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS :: 0x9314; -MAX_FRAMEBUFFER_WIDTH :: 0x9315; -MAX_FRAMEBUFFER_HEIGHT :: 0x9316; -MAX_FRAMEBUFFER_LAYERS :: 0x9317; -MAX_FRAMEBUFFER_SAMPLES :: 0x9318; -INTERNALFORMAT_SUPPORTED :: 0x826F; -INTERNALFORMAT_PREFERRED :: 0x8270; -INTERNALFORMAT_RED_SIZE :: 0x8271; -INTERNALFORMAT_GREEN_SIZE :: 0x8272; -INTERNALFORMAT_BLUE_SIZE :: 0x8273; -INTERNALFORMAT_ALPHA_SIZE :: 0x8274; -INTERNALFORMAT_DEPTH_SIZE :: 0x8275; -INTERNALFORMAT_STENCIL_SIZE :: 0x8276; -INTERNALFORMAT_SHARED_SIZE :: 0x8277; -INTERNALFORMAT_RED_TYPE :: 0x8278; -INTERNALFORMAT_GREEN_TYPE :: 0x8279; -INTERNALFORMAT_BLUE_TYPE :: 0x827A; -INTERNALFORMAT_ALPHA_TYPE :: 0x827B; -INTERNALFORMAT_DEPTH_TYPE :: 0x827C; -INTERNALFORMAT_STENCIL_TYPE :: 0x827D; -MAX_WIDTH :: 0x827E; -MAX_HEIGHT :: 0x827F; -MAX_DEPTH :: 0x8280; -MAX_LAYERS :: 0x8281; -MAX_COMBINED_DIMENSIONS :: 0x8282; -COLOR_COMPONENTS :: 0x8283; -DEPTH_COMPONENTS :: 0x8284; -STENCIL_COMPONENTS :: 0x8285; -COLOR_RENDERABLE :: 0x8286; -DEPTH_RENDERABLE :: 0x8287; -STENCIL_RENDERABLE :: 0x8288; -FRAMEBUFFER_RENDERABLE :: 0x8289; -FRAMEBUFFER_RENDERABLE_LAYERED :: 0x828A; -FRAMEBUFFER_BLEND :: 0x828B; -READ_PIXELS :: 0x828C; -READ_PIXELS_FORMAT :: 0x828D; -READ_PIXELS_TYPE :: 0x828E; -TEXTURE_IMAGE_FORMAT :: 0x828F; -TEXTURE_IMAGE_TYPE :: 0x8290; -GET_TEXTURE_IMAGE_FORMAT :: 0x8291; -GET_TEXTURE_IMAGE_TYPE :: 0x8292; -MIPMAP :: 0x8293; -MANUAL_GENERATE_MIPMAP :: 0x8294; -AUTO_GENERATE_MIPMAP :: 0x8295; -COLOR_ENCODING :: 0x8296; -SRGB_READ :: 0x8297; -SRGB_WRITE :: 0x8298; -FILTER :: 0x829A; -VERTEX_TEXTURE :: 0x829B; -TESS_CONTROL_TEXTURE :: 0x829C; -TESS_EVALUATION_TEXTURE :: 0x829D; -GEOMETRY_TEXTURE :: 0x829E; -FRAGMENT_TEXTURE :: 0x829F; -COMPUTE_TEXTURE :: 0x82A0; -TEXTURE_SHADOW :: 0x82A1; -TEXTURE_GATHER :: 0x82A2; -TEXTURE_GATHER_SHADOW :: 0x82A3; -SHADER_IMAGE_LOAD :: 0x82A4; -SHADER_IMAGE_STORE :: 0x82A5; -SHADER_IMAGE_ATOMIC :: 0x82A6; -IMAGE_TEXEL_SIZE :: 0x82A7; -IMAGE_COMPATIBILITY_CLASS :: 0x82A8; -IMAGE_PIXEL_FORMAT :: 0x82A9; -IMAGE_PIXEL_TYPE :: 0x82AA; -SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST :: 0x82AC; -SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST :: 0x82AD; -SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE :: 0x82AE; -SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE :: 0x82AF; -TEXTURE_COMPRESSED_BLOCK_WIDTH :: 0x82B1; -TEXTURE_COMPRESSED_BLOCK_HEIGHT :: 0x82B2; -TEXTURE_COMPRESSED_BLOCK_SIZE :: 0x82B3; -CLEAR_BUFFER :: 0x82B4; -TEXTURE_VIEW :: 0x82B5; -VIEW_COMPATIBILITY_CLASS :: 0x82B6; -FULL_SUPPORT :: 0x82B7; -CAVEAT_SUPPORT :: 0x82B8; -IMAGE_CLASS_4_X_32 :: 0x82B9; -IMAGE_CLASS_2_X_32 :: 0x82BA; -IMAGE_CLASS_1_X_32 :: 0x82BB; -IMAGE_CLASS_4_X_16 :: 0x82BC; -IMAGE_CLASS_2_X_16 :: 0x82BD; -IMAGE_CLASS_1_X_16 :: 0x82BE; -IMAGE_CLASS_4_X_8 :: 0x82BF; -IMAGE_CLASS_2_X_8 :: 0x82C0; -IMAGE_CLASS_1_X_8 :: 0x82C1; -IMAGE_CLASS_11_11_10 :: 0x82C2; -IMAGE_CLASS_10_10_10_2 :: 0x82C3; -VIEW_CLASS_128_BITS :: 0x82C4; -VIEW_CLASS_96_BITS :: 0x82C5; -VIEW_CLASS_64_BITS :: 0x82C6; -VIEW_CLASS_48_BITS :: 0x82C7; -VIEW_CLASS_32_BITS :: 0x82C8; -VIEW_CLASS_24_BITS :: 0x82C9; -VIEW_CLASS_16_BITS :: 0x82CA; -VIEW_CLASS_8_BITS :: 0x82CB; -VIEW_CLASS_S3TC_DXT1_RGB :: 0x82CC; -VIEW_CLASS_S3TC_DXT1_RGBA :: 0x82CD; -VIEW_CLASS_S3TC_DXT3_RGBA :: 0x82CE; -VIEW_CLASS_S3TC_DXT5_RGBA :: 0x82CF; -VIEW_CLASS_RGTC1_RED :: 0x82D0; -VIEW_CLASS_RGTC2_RG :: 0x82D1; -VIEW_CLASS_BPTC_UNORM :: 0x82D2; -VIEW_CLASS_BPTC_FLOAT :: 0x82D3; -UNIFORM :: 0x92E1; -UNIFORM_BLOCK :: 0x92E2; -PROGRAM_INPUT :: 0x92E3; -PROGRAM_OUTPUT :: 0x92E4; -BUFFER_VARIABLE :: 0x92E5; -SHADER_STORAGE_BLOCK :: 0x92E6; -VERTEX_SUBROUTINE :: 0x92E8; -TESS_CONTROL_SUBROUTINE :: 0x92E9; -TESS_EVALUATION_SUBROUTINE :: 0x92EA; -GEOMETRY_SUBROUTINE :: 0x92EB; -FRAGMENT_SUBROUTINE :: 0x92EC; -COMPUTE_SUBROUTINE :: 0x92ED; -VERTEX_SUBROUTINE_UNIFORM :: 0x92EE; -TESS_CONTROL_SUBROUTINE_UNIFORM :: 0x92EF; -TESS_EVALUATION_SUBROUTINE_UNIFORM :: 0x92F0; -GEOMETRY_SUBROUTINE_UNIFORM :: 0x92F1; -FRAGMENT_SUBROUTINE_UNIFORM :: 0x92F2; -COMPUTE_SUBROUTINE_UNIFORM :: 0x92F3; -TRANSFORM_FEEDBACK_VARYING :: 0x92F4; -ACTIVE_RESOURCES :: 0x92F5; -MAX_NAME_LENGTH :: 0x92F6; -MAX_NUM_ACTIVE_VARIABLES :: 0x92F7; -MAX_NUM_COMPATIBLE_SUBROUTINES :: 0x92F8; -NAME_LENGTH :: 0x92F9; -TYPE :: 0x92FA; -ARRAY_SIZE :: 0x92FB; -OFFSET :: 0x92FC; -BLOCK_INDEX :: 0x92FD; -ARRAY_STRIDE :: 0x92FE; -MATRIX_STRIDE :: 0x92FF; -IS_ROW_MAJOR :: 0x9300; -ATOMIC_COUNTER_BUFFER_INDEX :: 0x9301; -BUFFER_BINDING :: 0x9302; -BUFFER_DATA_SIZE :: 0x9303; -NUM_ACTIVE_VARIABLES :: 0x9304; -ACTIVE_VARIABLES :: 0x9305; -REFERENCED_BY_VERTEX_SHADER :: 0x9306; -REFERENCED_BY_TESS_CONTROL_SHADER :: 0x9307; -REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x9308; -REFERENCED_BY_GEOMETRY_SHADER :: 0x9309; -REFERENCED_BY_FRAGMENT_SHADER :: 0x930A; -REFERENCED_BY_COMPUTE_SHADER :: 0x930B; -TOP_LEVEL_ARRAY_SIZE :: 0x930C; -TOP_LEVEL_ARRAY_STRIDE :: 0x930D; -LOCATION :: 0x930E; -LOCATION_INDEX :: 0x930F; -IS_PER_PATCH :: 0x92E7; -SHADER_STORAGE_BUFFER :: 0x90D2; -SHADER_STORAGE_BUFFER_BINDING :: 0x90D3; -SHADER_STORAGE_BUFFER_START :: 0x90D4; -SHADER_STORAGE_BUFFER_SIZE :: 0x90D5; -MAX_VERTEX_SHADER_STORAGE_BLOCKS :: 0x90D6; -MAX_GEOMETRY_SHADER_STORAGE_BLOCKS :: 0x90D7; -MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS :: 0x90D8; -MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS :: 0x90D9; -MAX_FRAGMENT_SHADER_STORAGE_BLOCKS :: 0x90DA; -MAX_COMPUTE_SHADER_STORAGE_BLOCKS :: 0x90DB; -MAX_COMBINED_SHADER_STORAGE_BLOCKS :: 0x90DC; -MAX_SHADER_STORAGE_BUFFER_BINDINGS :: 0x90DD; -MAX_SHADER_STORAGE_BLOCK_SIZE :: 0x90DE; -SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT :: 0x90DF; -SHADER_STORAGE_BARRIER_BIT :: 0x00002000; -MAX_COMBINED_SHADER_OUTPUT_RESOURCES :: 0x8F39; -DEPTH_STENCIL_TEXTURE_MODE :: 0x90EA; -TEXTURE_BUFFER_OFFSET :: 0x919D; -TEXTURE_BUFFER_SIZE :: 0x919E; -TEXTURE_BUFFER_OFFSET_ALIGNMENT :: 0x919F; -TEXTURE_VIEW_MIN_LEVEL :: 0x82DB; -TEXTURE_VIEW_NUM_LEVELS :: 0x82DC; -TEXTURE_VIEW_MIN_LAYER :: 0x82DD; -TEXTURE_VIEW_NUM_LAYERS :: 0x82DE; -TEXTURE_IMMUTABLE_LEVELS :: 0x82DF; -VERTEX_ATTRIB_BINDING :: 0x82D4; -VERTEX_ATTRIB_RELATIVE_OFFSET :: 0x82D5; -VERTEX_BINDING_DIVISOR :: 0x82D6; -VERTEX_BINDING_OFFSET :: 0x82D7; -VERTEX_BINDING_STRIDE :: 0x82D8; -MAX_VERTEX_ATTRIB_RELATIVE_OFFSET :: 0x82D9; -MAX_VERTEX_ATTRIB_BINDINGS :: 0x82DA; -VERTEX_BINDING_BUFFER :: 0x8F4F; +NUM_SHADING_LANGUAGE_VERSIONS :: 0x82E9 +VERTEX_ATTRIB_ARRAY_LONG :: 0x874E +COMPRESSED_RGB8_ETC2 :: 0x9274 +COMPRESSED_SRGB8_ETC2 :: 0x9275 +COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: 0x9276 +COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: 0x9277 +COMPRESSED_RGBA8_ETC2_EAC :: 0x9278 +COMPRESSED_SRGB8_ALPHA8_ETC2_EAC :: 0x9279 +COMPRESSED_R11_EAC :: 0x9270 +COMPRESSED_SIGNED_R11_EAC :: 0x9271 +COMPRESSED_RG11_EAC :: 0x9272 +COMPRESSED_SIGNED_RG11_EAC :: 0x9273 +PRIMITIVE_RESTART_FIXED_INDEX :: 0x8D69 +ANY_SAMPLES_PASSED_CONSERVATIVE :: 0x8D6A +MAX_ELEMENT_INDEX :: 0x8D6B +COMPUTE_SHADER :: 0x91B9 +MAX_COMPUTE_UNIFORM_BLOCKS :: 0x91BB +MAX_COMPUTE_TEXTURE_IMAGE_UNITS :: 0x91BC +MAX_COMPUTE_IMAGE_UNIFORMS :: 0x91BD +MAX_COMPUTE_SHARED_MEMORY_SIZE :: 0x8262 +MAX_COMPUTE_UNIFORM_COMPONENTS :: 0x8263 +MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS :: 0x8264 +MAX_COMPUTE_ATOMIC_COUNTERS :: 0x8265 +MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS :: 0x8266 +MAX_COMPUTE_WORK_GROUP_INVOCATIONS :: 0x90EB +MAX_COMPUTE_WORK_GROUP_COUNT :: 0x91BE +MAX_COMPUTE_WORK_GROUP_SIZE :: 0x91BF +COMPUTE_WORK_GROUP_SIZE :: 0x8267 +UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER :: 0x90EC +ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER :: 0x90ED +DISPATCH_INDIRECT_BUFFER :: 0x90EE +DISPATCH_INDIRECT_BUFFER_BINDING :: 0x90EF +COMPUTE_SHADER_BIT :: 0x00000020 +DEBUG_OUTPUT_SYNCHRONOUS :: 0x8242 +DEBUG_NEXT_LOGGED_MESSAGE_LENGTH :: 0x8243 +DEBUG_CALLBACK_FUNCTION :: 0x8244 +DEBUG_CALLBACK_USER_PARAM :: 0x8245 +DEBUG_SOURCE_API :: 0x8246 +DEBUG_SOURCE_WINDOW_SYSTEM :: 0x8247 +DEBUG_SOURCE_SHADER_COMPILER :: 0x8248 +DEBUG_SOURCE_THIRD_PARTY :: 0x8249 +DEBUG_SOURCE_APPLICATION :: 0x824A +DEBUG_SOURCE_OTHER :: 0x824B +DEBUG_TYPE_ERROR :: 0x824C +DEBUG_TYPE_DEPRECATED_BEHAVIOR :: 0x824D +DEBUG_TYPE_UNDEFINED_BEHAVIOR :: 0x824E +DEBUG_TYPE_PORTABILITY :: 0x824F +DEBUG_TYPE_PERFORMANCE :: 0x8250 +DEBUG_TYPE_OTHER :: 0x8251 +MAX_DEBUG_MESSAGE_LENGTH :: 0x9143 +MAX_DEBUG_LOGGED_MESSAGES :: 0x9144 +DEBUG_LOGGED_MESSAGES :: 0x9145 +DEBUG_SEVERITY_HIGH :: 0x9146 +DEBUG_SEVERITY_MEDIUM :: 0x9147 +DEBUG_SEVERITY_LOW :: 0x9148 +DEBUG_TYPE_MARKER :: 0x8268 +DEBUG_TYPE_PUSH_GROUP :: 0x8269 +DEBUG_TYPE_POP_GROUP :: 0x826A +DEBUG_SEVERITY_NOTIFICATION :: 0x826B +MAX_DEBUG_GROUP_STACK_DEPTH :: 0x826C +DEBUG_GROUP_STACK_DEPTH :: 0x826D +BUFFER :: 0x82E0 +SHADER :: 0x82E1 +PROGRAM :: 0x82E2 +QUERY :: 0x82E3 +PROGRAM_PIPELINE :: 0x82E4 +SAMPLER :: 0x82E6 +MAX_LABEL_LENGTH :: 0x82E8 +DEBUG_OUTPUT :: 0x92E0 +CONTEXT_FLAG_DEBUG_BIT :: 0x00000002 +MAX_UNIFORM_LOCATIONS :: 0x826E +FRAMEBUFFER_DEFAULT_WIDTH :: 0x9310 +FRAMEBUFFER_DEFAULT_HEIGHT :: 0x9311 +FRAMEBUFFER_DEFAULT_LAYERS :: 0x9312 +FRAMEBUFFER_DEFAULT_SAMPLES :: 0x9313 +FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS :: 0x9314 +MAX_FRAMEBUFFER_WIDTH :: 0x9315 +MAX_FRAMEBUFFER_HEIGHT :: 0x9316 +MAX_FRAMEBUFFER_LAYERS :: 0x9317 +MAX_FRAMEBUFFER_SAMPLES :: 0x9318 +INTERNALFORMAT_SUPPORTED :: 0x826F +INTERNALFORMAT_PREFERRED :: 0x8270 +INTERNALFORMAT_RED_SIZE :: 0x8271 +INTERNALFORMAT_GREEN_SIZE :: 0x8272 +INTERNALFORMAT_BLUE_SIZE :: 0x8273 +INTERNALFORMAT_ALPHA_SIZE :: 0x8274 +INTERNALFORMAT_DEPTH_SIZE :: 0x8275 +INTERNALFORMAT_STENCIL_SIZE :: 0x8276 +INTERNALFORMAT_SHARED_SIZE :: 0x8277 +INTERNALFORMAT_RED_TYPE :: 0x8278 +INTERNALFORMAT_GREEN_TYPE :: 0x8279 +INTERNALFORMAT_BLUE_TYPE :: 0x827A +INTERNALFORMAT_ALPHA_TYPE :: 0x827B +INTERNALFORMAT_DEPTH_TYPE :: 0x827C +INTERNALFORMAT_STENCIL_TYPE :: 0x827D +MAX_WIDTH :: 0x827E +MAX_HEIGHT :: 0x827F +MAX_DEPTH :: 0x8280 +MAX_LAYERS :: 0x8281 +MAX_COMBINED_DIMENSIONS :: 0x8282 +COLOR_COMPONENTS :: 0x8283 +DEPTH_COMPONENTS :: 0x8284 +STENCIL_COMPONENTS :: 0x8285 +COLOR_RENDERABLE :: 0x8286 +DEPTH_RENDERABLE :: 0x8287 +STENCIL_RENDERABLE :: 0x8288 +FRAMEBUFFER_RENDERABLE :: 0x8289 +FRAMEBUFFER_RENDERABLE_LAYERED :: 0x828A +FRAMEBUFFER_BLEND :: 0x828B +READ_PIXELS :: 0x828C +READ_PIXELS_FORMAT :: 0x828D +READ_PIXELS_TYPE :: 0x828E +TEXTURE_IMAGE_FORMAT :: 0x828F +TEXTURE_IMAGE_TYPE :: 0x8290 +GET_TEXTURE_IMAGE_FORMAT :: 0x8291 +GET_TEXTURE_IMAGE_TYPE :: 0x8292 +MIPMAP :: 0x8293 +MANUAL_GENERATE_MIPMAP :: 0x8294 +AUTO_GENERATE_MIPMAP :: 0x8295 +COLOR_ENCODING :: 0x8296 +SRGB_READ :: 0x8297 +SRGB_WRITE :: 0x8298 +FILTER :: 0x829A +VERTEX_TEXTURE :: 0x829B +TESS_CONTROL_TEXTURE :: 0x829C +TESS_EVALUATION_TEXTURE :: 0x829D +GEOMETRY_TEXTURE :: 0x829E +FRAGMENT_TEXTURE :: 0x829F +COMPUTE_TEXTURE :: 0x82A0 +TEXTURE_SHADOW :: 0x82A1 +TEXTURE_GATHER :: 0x82A2 +TEXTURE_GATHER_SHADOW :: 0x82A3 +SHADER_IMAGE_LOAD :: 0x82A4 +SHADER_IMAGE_STORE :: 0x82A5 +SHADER_IMAGE_ATOMIC :: 0x82A6 +IMAGE_TEXEL_SIZE :: 0x82A7 +IMAGE_COMPATIBILITY_CLASS :: 0x82A8 +IMAGE_PIXEL_FORMAT :: 0x82A9 +IMAGE_PIXEL_TYPE :: 0x82AA +SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST :: 0x82AC +SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST :: 0x82AD +SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE :: 0x82AE +SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE :: 0x82AF +TEXTURE_COMPRESSED_BLOCK_WIDTH :: 0x82B1 +TEXTURE_COMPRESSED_BLOCK_HEIGHT :: 0x82B2 +TEXTURE_COMPRESSED_BLOCK_SIZE :: 0x82B3 +CLEAR_BUFFER :: 0x82B4 +TEXTURE_VIEW :: 0x82B5 +VIEW_COMPATIBILITY_CLASS :: 0x82B6 +FULL_SUPPORT :: 0x82B7 +CAVEAT_SUPPORT :: 0x82B8 +IMAGE_CLASS_4_X_32 :: 0x82B9 +IMAGE_CLASS_2_X_32 :: 0x82BA +IMAGE_CLASS_1_X_32 :: 0x82BB +IMAGE_CLASS_4_X_16 :: 0x82BC +IMAGE_CLASS_2_X_16 :: 0x82BD +IMAGE_CLASS_1_X_16 :: 0x82BE +IMAGE_CLASS_4_X_8 :: 0x82BF +IMAGE_CLASS_2_X_8 :: 0x82C0 +IMAGE_CLASS_1_X_8 :: 0x82C1 +IMAGE_CLASS_11_11_10 :: 0x82C2 +IMAGE_CLASS_10_10_10_2 :: 0x82C3 +VIEW_CLASS_128_BITS :: 0x82C4 +VIEW_CLASS_96_BITS :: 0x82C5 +VIEW_CLASS_64_BITS :: 0x82C6 +VIEW_CLASS_48_BITS :: 0x82C7 +VIEW_CLASS_32_BITS :: 0x82C8 +VIEW_CLASS_24_BITS :: 0x82C9 +VIEW_CLASS_16_BITS :: 0x82CA +VIEW_CLASS_8_BITS :: 0x82CB +VIEW_CLASS_S3TC_DXT1_RGB :: 0x82CC +VIEW_CLASS_S3TC_DXT1_RGBA :: 0x82CD +VIEW_CLASS_S3TC_DXT3_RGBA :: 0x82CE +VIEW_CLASS_S3TC_DXT5_RGBA :: 0x82CF +VIEW_CLASS_RGTC1_RED :: 0x82D0 +VIEW_CLASS_RGTC2_RG :: 0x82D1 +VIEW_CLASS_BPTC_UNORM :: 0x82D2 +VIEW_CLASS_BPTC_FLOAT :: 0x82D3 +UNIFORM :: 0x92E1 +UNIFORM_BLOCK :: 0x92E2 +PROGRAM_INPUT :: 0x92E3 +PROGRAM_OUTPUT :: 0x92E4 +BUFFER_VARIABLE :: 0x92E5 +SHADER_STORAGE_BLOCK :: 0x92E6 +VERTEX_SUBROUTINE :: 0x92E8 +TESS_CONTROL_SUBROUTINE :: 0x92E9 +TESS_EVALUATION_SUBROUTINE :: 0x92EA +GEOMETRY_SUBROUTINE :: 0x92EB +FRAGMENT_SUBROUTINE :: 0x92EC +COMPUTE_SUBROUTINE :: 0x92ED +VERTEX_SUBROUTINE_UNIFORM :: 0x92EE +TESS_CONTROL_SUBROUTINE_UNIFORM :: 0x92EF +TESS_EVALUATION_SUBROUTINE_UNIFORM :: 0x92F0 +GEOMETRY_SUBROUTINE_UNIFORM :: 0x92F1 +FRAGMENT_SUBROUTINE_UNIFORM :: 0x92F2 +COMPUTE_SUBROUTINE_UNIFORM :: 0x92F3 +TRANSFORM_FEEDBACK_VARYING :: 0x92F4 +ACTIVE_RESOURCES :: 0x92F5 +MAX_NAME_LENGTH :: 0x92F6 +MAX_NUM_ACTIVE_VARIABLES :: 0x92F7 +MAX_NUM_COMPATIBLE_SUBROUTINES :: 0x92F8 +NAME_LENGTH :: 0x92F9 +TYPE :: 0x92FA +ARRAY_SIZE :: 0x92FB +OFFSET :: 0x92FC +BLOCK_INDEX :: 0x92FD +ARRAY_STRIDE :: 0x92FE +MATRIX_STRIDE :: 0x92FF +IS_ROW_MAJOR :: 0x9300 +ATOMIC_COUNTER_BUFFER_INDEX :: 0x9301 +BUFFER_BINDING :: 0x9302 +BUFFER_DATA_SIZE :: 0x9303 +NUM_ACTIVE_VARIABLES :: 0x9304 +ACTIVE_VARIABLES :: 0x9305 +REFERENCED_BY_VERTEX_SHADER :: 0x9306 +REFERENCED_BY_TESS_CONTROL_SHADER :: 0x9307 +REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x9308 +REFERENCED_BY_GEOMETRY_SHADER :: 0x9309 +REFERENCED_BY_FRAGMENT_SHADER :: 0x930A +REFERENCED_BY_COMPUTE_SHADER :: 0x930B +TOP_LEVEL_ARRAY_SIZE :: 0x930C +TOP_LEVEL_ARRAY_STRIDE :: 0x930D +LOCATION :: 0x930E +LOCATION_INDEX :: 0x930F +IS_PER_PATCH :: 0x92E7 +SHADER_STORAGE_BUFFER :: 0x90D2 +SHADER_STORAGE_BUFFER_BINDING :: 0x90D3 +SHADER_STORAGE_BUFFER_START :: 0x90D4 +SHADER_STORAGE_BUFFER_SIZE :: 0x90D5 +MAX_VERTEX_SHADER_STORAGE_BLOCKS :: 0x90D6 +MAX_GEOMETRY_SHADER_STORAGE_BLOCKS :: 0x90D7 +MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS :: 0x90D8 +MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS :: 0x90D9 +MAX_FRAGMENT_SHADER_STORAGE_BLOCKS :: 0x90DA +MAX_COMPUTE_SHADER_STORAGE_BLOCKS :: 0x90DB +MAX_COMBINED_SHADER_STORAGE_BLOCKS :: 0x90DC +MAX_SHADER_STORAGE_BUFFER_BINDINGS :: 0x90DD +MAX_SHADER_STORAGE_BLOCK_SIZE :: 0x90DE +SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT :: 0x90DF +SHADER_STORAGE_BARRIER_BIT :: 0x00002000 +MAX_COMBINED_SHADER_OUTPUT_RESOURCES :: 0x8F39 +DEPTH_STENCIL_TEXTURE_MODE :: 0x90EA +TEXTURE_BUFFER_OFFSET :: 0x919D +TEXTURE_BUFFER_SIZE :: 0x919E +TEXTURE_BUFFER_OFFSET_ALIGNMENT :: 0x919F +TEXTURE_VIEW_MIN_LEVEL :: 0x82DB +TEXTURE_VIEW_NUM_LEVELS :: 0x82DC +TEXTURE_VIEW_MIN_LAYER :: 0x82DD +TEXTURE_VIEW_NUM_LAYERS :: 0x82DE +TEXTURE_IMMUTABLE_LEVELS :: 0x82DF +VERTEX_ATTRIB_BINDING :: 0x82D4 +VERTEX_ATTRIB_RELATIVE_OFFSET :: 0x82D5 +VERTEX_BINDING_DIVISOR :: 0x82D6 +VERTEX_BINDING_OFFSET :: 0x82D7 +VERTEX_BINDING_STRIDE :: 0x82D8 +MAX_VERTEX_ATTRIB_RELATIVE_OFFSET :: 0x82D9 +MAX_VERTEX_ATTRIB_BINDINGS :: 0x82DA +VERTEX_BINDING_BUFFER :: 0x8F4F -MAX_VERTEX_ATTRIB_STRIDE :: 0x82E5; -PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED :: 0x8221; -TEXTURE_BUFFER_BINDING :: 0x8C2A; -MAP_PERSISTENT_BIT :: 0x0040; -MAP_COHERENT_BIT :: 0x0080; -DYNAMIC_STORAGE_BIT :: 0x0100; -CLIENT_STORAGE_BIT :: 0x0200; -CLIENT_MAPPED_BUFFER_BARRIER_BIT :: 0x00004000; -BUFFER_IMMUTABLE_STORAGE :: 0x821F; -BUFFER_STORAGE_FLAGS :: 0x8220; -CLEAR_TEXTURE :: 0x9365; -LOCATION_COMPONENT :: 0x934A; -TRANSFORM_FEEDBACK_BUFFER_INDEX :: 0x934B; -TRANSFORM_FEEDBACK_BUFFER_STRIDE :: 0x934C; -QUERY_BUFFER :: 0x9192; -QUERY_BUFFER_BARRIER_BIT :: 0x00008000; -QUERY_BUFFER_BINDING :: 0x9193; -QUERY_RESULT_NO_WAIT :: 0x9194; -MIRROR_CLAMP_TO_EDGE :: 0x8743; +MAX_VERTEX_ATTRIB_STRIDE :: 0x82E5 +PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED :: 0x8221 +TEXTURE_BUFFER_BINDING :: 0x8C2A +MAP_PERSISTENT_BIT :: 0x0040 +MAP_COHERENT_BIT :: 0x0080 +DYNAMIC_STORAGE_BIT :: 0x0100 +CLIENT_STORAGE_BIT :: 0x0200 +CLIENT_MAPPED_BUFFER_BARRIER_BIT :: 0x00004000 +BUFFER_IMMUTABLE_STORAGE :: 0x821F +BUFFER_STORAGE_FLAGS :: 0x8220 +CLEAR_TEXTURE :: 0x9365 +LOCATION_COMPONENT :: 0x934A +TRANSFORM_FEEDBACK_BUFFER_INDEX :: 0x934B +TRANSFORM_FEEDBACK_BUFFER_STRIDE :: 0x934C +QUERY_BUFFER :: 0x9192 +QUERY_BUFFER_BARRIER_BIT :: 0x00008000 +QUERY_BUFFER_BINDING :: 0x9193 +QUERY_RESULT_NO_WAIT :: 0x9194 +MIRROR_CLAMP_TO_EDGE :: 0x8743 -CONTEXT_LOST :: 0x0507; -NEGATIVE_ONE_TO_ONE :: 0x935E; -ZERO_TO_ONE :: 0x935F; -CLIP_ORIGIN :: 0x935C; -CLIP_DEPTH_MODE :: 0x935D; -QUERY_WAIT_INVERTED :: 0x8E17; -QUERY_NO_WAIT_INVERTED :: 0x8E18; -QUERY_BY_REGION_WAIT_INVERTED :: 0x8E19; -QUERY_BY_REGION_NO_WAIT_INVERTED :: 0x8E1A; -MAX_CULL_DISTANCES :: 0x82F9; -MAX_COMBINED_CLIP_AND_CULL_DISTANCES :: 0x82FA; -TEXTURE_TARGET :: 0x1006; -QUERY_TARGET :: 0x82EA; -GUILTY_CONTEXT_RESET :: 0x8253; -INNOCENT_CONTEXT_RESET :: 0x8254; -UNKNOWN_CONTEXT_RESET :: 0x8255; -RESET_NOTIFICATION_STRATEGY :: 0x8256; -LOSE_CONTEXT_ON_RESET :: 0x8252; -NO_RESET_NOTIFICATION :: 0x8261; -CONTEXT_FLAG_ROBUST_ACCESS_BIT :: 0x00000004; -CONTEXT_RELEASE_BEHAVIOR :: 0x82FB; -CONTEXT_RELEASE_BEHAVIOR_FLUSH :: 0x82FC; +CONTEXT_LOST :: 0x0507 +NEGATIVE_ONE_TO_ONE :: 0x935E +ZERO_TO_ONE :: 0x935F +CLIP_ORIGIN :: 0x935C +CLIP_DEPTH_MODE :: 0x935D +QUERY_WAIT_INVERTED :: 0x8E17 +QUERY_NO_WAIT_INVERTED :: 0x8E18 +QUERY_BY_REGION_WAIT_INVERTED :: 0x8E19 +QUERY_BY_REGION_NO_WAIT_INVERTED :: 0x8E1A +MAX_CULL_DISTANCES :: 0x82F9 +MAX_COMBINED_CLIP_AND_CULL_DISTANCES :: 0x82FA +TEXTURE_TARGET :: 0x1006 +QUERY_TARGET :: 0x82EA +GUILTY_CONTEXT_RESET :: 0x8253 +INNOCENT_CONTEXT_RESET :: 0x8254 +UNKNOWN_CONTEXT_RESET :: 0x8255 +RESET_NOTIFICATION_STRATEGY :: 0x8256 +LOSE_CONTEXT_ON_RESET :: 0x8252 +NO_RESET_NOTIFICATION :: 0x8261 +CONTEXT_FLAG_ROBUST_ACCESS_BIT :: 0x00000004 +CONTEXT_RELEASE_BEHAVIOR :: 0x82FB +CONTEXT_RELEASE_BEHAVIOR_FLUSH :: 0x82FC -DEBUG_OUTPUT_SYNCHRONOUS_ARB :: 0x8242; -DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB :: 0x8243; -DEBUG_CALLBACK_FUNCTION_ARB :: 0x8244; -DEBUG_CALLBACK_USER_PARAM_ARB :: 0x8245; -DEBUG_SOURCE_API_ARB :: 0x8246; -DEBUG_SOURCE_WINDOW_SYSTEM_ARB :: 0x8247; -DEBUG_SOURCE_SHADER_COMPILER_ARB :: 0x8248; -DEBUG_SOURCE_THIRD_PARTY_ARB :: 0x8249; -DEBUG_SOURCE_APPLICATION_ARB :: 0x824A; -DEBUG_SOURCE_OTHER_ARB :: 0x824B; -DEBUG_TYPE_ERROR_ARB :: 0x824C; -DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB :: 0x824D; -DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB :: 0x824E; -DEBUG_TYPE_PORTABILITY_ARB :: 0x824F; -DEBUG_TYPE_PERFORMANCE_ARB :: 0x8250; -DEBUG_TYPE_OTHER_ARB :: 0x8251; -MAX_DEBUG_MESSAGE_LENGTH_ARB :: 0x9143; -MAX_DEBUG_LOGGED_MESSAGES_ARB :: 0x9144; -DEBUG_LOGGED_MESSAGES_ARB :: 0x9145; -DEBUG_SEVERITY_HIGH_ARB :: 0x9146; -DEBUG_SEVERITY_MEDIUM_ARB :: 0x9147; -DEBUG_SEVERITY_LOW_ARB :: 0x9148; +DEBUG_OUTPUT_SYNCHRONOUS_ARB :: 0x8242 +DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB :: 0x8243 +DEBUG_CALLBACK_FUNCTION_ARB :: 0x8244 +DEBUG_CALLBACK_USER_PARAM_ARB :: 0x8245 +DEBUG_SOURCE_API_ARB :: 0x8246 +DEBUG_SOURCE_WINDOW_SYSTEM_ARB :: 0x8247 +DEBUG_SOURCE_SHADER_COMPILER_ARB :: 0x8248 +DEBUG_SOURCE_THIRD_PARTY_ARB :: 0x8249 +DEBUG_SOURCE_APPLICATION_ARB :: 0x824A +DEBUG_SOURCE_OTHER_ARB :: 0x824B +DEBUG_TYPE_ERROR_ARB :: 0x824C +DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB :: 0x824D +DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB :: 0x824E +DEBUG_TYPE_PORTABILITY_ARB :: 0x824F +DEBUG_TYPE_PERFORMANCE_ARB :: 0x8250 +DEBUG_TYPE_OTHER_ARB :: 0x8251 +MAX_DEBUG_MESSAGE_LENGTH_ARB :: 0x9143 +MAX_DEBUG_LOGGED_MESSAGES_ARB :: 0x9144 +DEBUG_LOGGED_MESSAGES_ARB :: 0x9145 +DEBUG_SEVERITY_HIGH_ARB :: 0x9146 +DEBUG_SEVERITY_MEDIUM_ARB :: 0x9147 +DEBUG_SEVERITY_LOW_ARB :: 0x9148 diff --git a/core/os.odin b/core/os.odin index 2a44b8a88..22e2d533c 100644 --- a/core/os.odin +++ b/core/os.odin @@ -1,2 +1,2 @@ -#include "os_windows.odin" when ODIN_OS == "windows"; +#include "os_windows.odin" when ODIN_OS == "windows" diff --git a/core/os_windows.odin b/core/os_windows.odin index 4624ea1ef..34ab661da 100644 --- a/core/os_windows.odin +++ b/core/os_windows.odin @@ -1,82 +1,82 @@ -#import "win32.odin"; -#import "fmt.odin"; +#import "win32.odin" +#import "fmt.odin" File_Time :: type u64 File :: struct { Handle :: raw_union { - p: rawptr; - i: int; + p: rawptr + i: int } - handle: Handle; - last_write_time: File_Time; + handle: Handle + last_write_time: File_Time } open :: proc(name: string) -> (File, bool) { - using win32; - buf: [300]byte; - copy(buf[:], name as []byte); - f: File; - f.handle.p = CreateFileA(^buf[0], FILE_GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, nil) as rawptr; - success := f.handle.p != INVALID_HANDLE_VALUE; - f.last_write_time = last_write_time(^f); - return f, success; + using win32 + buf: [300]byte + copy(buf[:], name as []byte) + f: File + f.handle.p = CreateFileA(^buf[0], FILE_GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, nil) as rawptr + success := f.handle.p != INVALID_HANDLE_VALUE + f.last_write_time = last_write_time(^f) + return f, success } create :: proc(name: string) -> (File, bool) { - using win32; - buf: [300]byte; - copy(buf[:], name as []byte); - f: File; - f.handle.p = CreateFileA(^buf[0], FILE_GENERIC_WRITE, FILE_SHARE_READ, nil, CREATE_ALWAYS, 0, nil) as rawptr; - success := f.handle.p != INVALID_HANDLE_VALUE; - f.last_write_time = last_write_time(^f); - return f, success; + using win32 + buf: [300]byte + copy(buf[:], name as []byte) + f: File + f.handle.p = CreateFileA(^buf[0], FILE_GENERIC_WRITE, FILE_SHARE_READ, nil, CREATE_ALWAYS, 0, nil) as rawptr + success := f.handle.p != INVALID_HANDLE_VALUE + f.last_write_time = last_write_time(^f) + return f, success } close :: proc(using f: ^File) { - win32.CloseHandle(handle.p as win32.HANDLE); + win32.CloseHandle(handle.p as win32.HANDLE) } write :: proc(using f: ^File, buf: []byte) -> bool { - bytes_written: i32; - return win32.WriteFile(handle.p as win32.HANDLE, buf.data, buf.count as i32, ^bytes_written, nil) != 0; + bytes_written: i32 + return win32.WriteFile(handle.p as win32.HANDLE, buf.data, buf.count as i32, ^bytes_written, nil) != 0 } file_has_changed :: proc(f: ^File) -> bool { - last_write_time := last_write_time(f); + last_write_time := last_write_time(f) if f.last_write_time != last_write_time { - f.last_write_time = last_write_time; - return true; + f.last_write_time = last_write_time + return true } - return false; + return false } last_write_time :: proc(f: ^File) -> File_Time { - file_info: win32.BY_HANDLE_FILE_INFORMATION; - win32.GetFileInformationByHandle(f.handle.p as win32.HANDLE, ^file_info); - l := file_info.last_write_time.low_date_time as File_Time; - h := file_info.last_write_time.high_date_time as File_Time; - return l | h << 32; + file_info: win32.BY_HANDLE_FILE_INFORMATION + win32.GetFileInformationByHandle(f.handle.p as win32.HANDLE, ^file_info) + l := file_info.last_write_time.low_date_time as File_Time + h := file_info.last_write_time.high_date_time as File_Time + return l | h << 32 } last_write_time_by_name :: proc(name: string) -> File_Time { - last_write_time: win32.FILETIME; - data: win32.WIN32_FILE_ATTRIBUTE_DATA; + last_write_time: win32.FILETIME + data: win32.WIN32_FILE_ATTRIBUTE_DATA - buf: [1024]byte; - path := buf[:0]; - fmt.bprint(^path, name, "\x00"); + buf: [1024]byte + path := buf[:0] + fmt.bprint(^path, name, "\x00") if win32.GetFileAttributesExA(path.data, win32.GetFileExInfoStandard, ^data) != 0 { - last_write_time = data.last_write_time; + last_write_time = data.last_write_time } - l := last_write_time.low_date_time as File_Time; - h := last_write_time.high_date_time as File_Time; - return l | h << 32; + l := last_write_time.low_date_time as File_Time + h := last_write_time.high_date_time as File_Time + return l | h << 32 } @@ -93,81 +93,81 @@ __std_files := [File_Standard.count]File{ {handle = win32.GetStdHandle(win32.STD_INPUT_HANDLE) transmute File.Handle }, {handle = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE) transmute File.Handle }, {handle = win32.GetStdHandle(win32.STD_ERROR_HANDLE) transmute File.Handle }, -}; +} -stdin := ^__std_files[File_Standard.INPUT]; -stdout := ^__std_files[File_Standard.OUTPUT]; -stderr := ^__std_files[File_Standard.ERROR]; +stdin := ^__std_files[File_Standard.INPUT] +stdout := ^__std_files[File_Standard.OUTPUT] +stderr := ^__std_files[File_Standard.ERROR] read_entire_file :: proc(name: string) -> ([]byte, bool) { - buf: [300]byte; - copy(buf[:], name as []byte); + buf: [300]byte + copy(buf[:], name as []byte) - f, file_ok := open(name); + f, file_ok := open(name) if !file_ok { - return nil, false; + return nil, false } - defer close(^f); + defer close(^f) - length: i64; - file_size_ok := win32.GetFileSizeEx(f.handle.p as win32.HANDLE, ^length) != 0; + length: i64 + file_size_ok := win32.GetFileSizeEx(f.handle.p as win32.HANDLE, ^length) != 0 if !file_size_ok { - return nil, false; + return nil, false } - data := new_slice(u8, length); + data := new_slice(u8, length) if data.data == nil { - return nil, false; + return nil, false } - single_read_length: i32; - total_read: i64; + single_read_length: i32 + total_read: i64 for total_read < length { - remaining := length - total_read; - to_read: u32; - MAX :: 1<<32-1; + remaining := length - total_read + to_read: u32 + MAX :: 1<<32-1 if remaining <= MAX { - to_read = remaining as u32; + to_read = remaining as u32 } else { - to_read = MAX; + to_read = MAX } - win32.ReadFile(f.handle.p as win32.HANDLE, ^data[total_read], to_read, ^single_read_length, nil); + win32.ReadFile(f.handle.p as win32.HANDLE, ^data[total_read], to_read, ^single_read_length, nil) if single_read_length <= 0 { - free(data.data); - return nil, false; + free(data.data) + return nil, false } - total_read += single_read_length as i64; + total_read += single_read_length as i64 } - return data, true; + return data, true } heap_alloc :: proc(size: int) -> rawptr { - return win32.HeapAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, size); + return win32.HeapAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, size) } heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - return win32.HeapReAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, ptr, new_size); + return win32.HeapReAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, ptr, new_size) } heap_free :: proc(ptr: rawptr) { - win32.HeapFree(win32.GetProcessHeap(), 0, ptr); + win32.HeapFree(win32.GetProcessHeap(), 0, ptr) } exit :: proc(code: int) { - win32.ExitProcess(code as u32); + win32.ExitProcess(code as u32) } current_thread_id :: proc() -> int { GetCurrentThreadId :: proc() -> u32 #foreign #dll_import - return GetCurrentThreadId() as int; + return GetCurrentThreadId() as int } diff --git a/core/utf8.odin b/core/utf8.odin index 32769881f..c2bac6194 100644 --- a/core/utf8.odin +++ b/core/utf8.odin @@ -1,17 +1,17 @@ -RUNE_ERROR :: '\ufffd'; -RUNE_SELF :: 0x80; -RUNE_BOM :: 0xfeff; -RUNE_EOF :: ~(0 as rune); -MAX_RUNE :: '\U0010ffff'; -UTF_MAX :: 4; +RUNE_ERROR :: '\ufffd' +RUNE_SELF :: 0x80 +RUNE_BOM :: 0xfeff +RUNE_EOF :: ~(0 as rune) +MAX_RUNE :: '\U0010ffff' +UTF_MAX :: 4 -SURROGATE_MIN :: 0xd800; -SURROGATE_MAX :: 0xdfff; +SURROGATE_MIN :: 0xd800 +SURROGATE_MAX :: 0xdfff Accept_Range :: struct { - lo, hi: u8; + lo, hi: u8 } accept_ranges := [5]Accept_Range{ @@ -20,7 +20,7 @@ accept_ranges := [5]Accept_Range{ {0x80, 0x9f}, {0x90, 0xbf}, {0x80, 0x8f}, -}; +} accept_sizes := [256]byte{ 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f @@ -40,177 +40,177 @@ accept_sizes := [256]byte{ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xd0-0xdf 0x13, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x23, 0x03, 0x03, // 0xe0-0xef 0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff -}; +} encode_rune :: proc(r_: rune) -> ([4]byte, int) { - r := r_; - buf: [4]byte; - i := r as u32; - mask: byte : 0x3f; + r := r_ + buf: [4]byte + i := r as u32 + mask: byte : 0x3f if i <= 1<<7-1 { - buf[0] = r as byte; - return buf, 1; + buf[0] = r as byte + return buf, 1 } if i <= 1<<11-1 { - buf[0] = 0xc0 | (r>>6) as byte; - buf[1] = 0x80 | (r) as byte & mask; - return buf, 2; + buf[0] = 0xc0 | (r>>6) as byte + buf[1] = 0x80 | (r) as byte & mask + return buf, 2 } // Invalid or Surrogate range if i > 0x0010ffff || (0xd800 <= i && i <= 0xdfff) { - r = 0xfffd; + r = 0xfffd } if i <= 1<<16-1 { - buf[0] = 0xe0 | (r>>12) as byte; - buf[1] = 0x80 | (r>>6) as byte & mask; - buf[2] = 0x80 | (r) as byte & mask; - return buf, 3; + buf[0] = 0xe0 | (r>>12) as byte + buf[1] = 0x80 | (r>>6) as byte & mask + buf[2] = 0x80 | (r) as byte & mask + return buf, 3 } - buf[0] = 0xf0 | (r>>18) as byte; - buf[1] = 0x80 | (r>>12) as byte & mask; - buf[2] = 0x80 | (r>>6) as byte & mask; - buf[3] = 0x80 | (r) as byte & mask; - return buf, 4; + buf[0] = 0xf0 | (r>>18) as byte + buf[1] = 0x80 | (r>>12) as byte & mask + buf[2] = 0x80 | (r>>6) as byte & mask + buf[3] = 0x80 | (r) as byte & mask + return buf, 4 } decode_rune :: proc(s: string) -> (rune, int) { - n := s.count; + n := s.count if n < 1 { - return RUNE_ERROR, 0; + return RUNE_ERROR, 0 } - b0 := s[0]; - x := accept_sizes[b0]; + b0 := s[0] + x := accept_sizes[b0] if x >= 0xf0 { mask := (x as rune << 31) >> 31; // all zeros or all ones - return (b0 as rune) &~ mask | RUNE_ERROR&mask, 1; + return (b0 as rune) &~ mask | RUNE_ERROR&mask, 1 } - size := x & 7; - ar := accept_ranges[x>>4]; + size := x & 7 + ar := accept_ranges[x>>4] if n < size as int { - return RUNE_ERROR, 1; + return RUNE_ERROR, 1 } - b1 := s[1]; + b1 := s[1] if b1 < ar.lo || ar.hi < b1 { - return RUNE_ERROR, 1; + return RUNE_ERROR, 1 } - MASK_X :: 0b00111111; - MASK_2 :: 0b00011111; - MASK_3 :: 0b00001111; - MASK_4 :: 0b00000111; + MASK_X :: 0b00111111 + MASK_2 :: 0b00011111 + MASK_3 :: 0b00001111 + MASK_4 :: 0b00000111 if size == 2 { - return (b0&MASK_2) as rune <<6 | (b1&MASK_X) as rune, 2; + return (b0&MASK_2) as rune <<6 | (b1&MASK_X) as rune, 2 } - b2 := s[2]; + b2 := s[2] if b2 < 0x80 || 0xbf < b2 { - return RUNE_ERROR, 1; + return RUNE_ERROR, 1 } if size == 3 { - return (b0&MASK_3) as rune <<12 | (b1&MASK_X) as rune <<6 | (b2&MASK_X) as rune, 3; + return (b0&MASK_3) as rune <<12 | (b1&MASK_X) as rune <<6 | (b2&MASK_X) as rune, 3 } - b3 := s[3]; + b3 := s[3] if b3 < 0x80 || 0xbf < b3 { - return RUNE_ERROR, 1; + return RUNE_ERROR, 1 } - return (b0&MASK_4) as rune <<18 | (b1&MASK_X) as rune <<12 | (b3&MASK_X) as rune <<6 | (b3&MASK_X) as rune, 4; + return (b0&MASK_4) as rune <<18 | (b1&MASK_X) as rune <<12 | (b3&MASK_X) as rune <<6 | (b3&MASK_X) as rune, 4 } valid_rune :: proc(r: rune) -> bool { if r < 0 { - return false; + return false } else if SURROGATE_MIN <= r && r <= SURROGATE_MAX { - return false; + return false } else if r > MAX_RUNE { - return false; + return false } - return true; + return true } valid_string :: proc(s: string) -> bool { - n := s.count; + n := s.count for i := 0; i < n; { - si := s[i]; + si := s[i] if si < RUNE_SELF { // ascii - i++; - continue; + i++ + continue } - x := accept_sizes[si]; + x := accept_sizes[si] if x == 0xf1 { - return false; + return false } - size := (x & 7) as int; + size := (x & 7) as int if i+size > n { - return false; + return false } - ar := accept_ranges[x>>4]; + ar := accept_ranges[x>>4] if b := s[i+1]; b < ar.lo || ar.hi < b { - return false; + return false } else if size == 2 { // Okay } else if b := s[i+2]; b < 0x80 || 0xbf < b { - return false; + return false } else if size == 3 { // Okay } else if b := s[i+3]; b < 0x80 || 0xbf < b { - return false; + return false } - i += size; + i += size } - return true; + return true } rune_count :: proc(s: string) -> int { - count := 0; - n := s.count; + count := 0 + n := s.count for i := 0; i < n; count++ { - si := s[i]; + si := s[i] if si < RUNE_SELF { // ascii - i++; - continue; + i++ + continue } - x := accept_sizes[si]; + x := accept_sizes[si] if x == 0xf1 { - i++; - continue; + i++ + continue } - size := (x & 7) as int; + size := (x & 7) as int if i+size > n { - i++; - continue; + i++ + continue } - ar := accept_ranges[x>>4]; + ar := accept_ranges[x>>4] if b := s[i+1]; b < ar.lo || ar.hi < b { - size = 1; + size = 1 } else if size == 2 { // Okay } else if b := s[i+2]; b < 0x80 || 0xbf < b { - size = 1; + size = 1 } else if size == 3 { // Okay } else if b := s[i+3]; b < 0x80 || 0xbf < b { - size = 1; + size = 1 } - i += size; + i += size } - return count; + return count } rune_size :: proc(r: rune) -> int { match { - case r < 0: return -1; - case r <= 1<<7 - 1: return 1; - case r <= 1<<11 - 1: return 2; - case SURROGATE_MIN <= r && r <= SURROGATE_MAX: return -1; - case r <= 1<<16 - 1: return 3; - case r <= MAX_RUNE: return 4; + case r < 0: return -1 + case r <= 1<<7 - 1: return 1 + case r <= 1<<11 - 1: return 2 + case SURROGATE_MIN <= r && r <= SURROGATE_MAX: return -1 + case r <= 1<<16 - 1: return 3 + case r <= MAX_RUNE: return 4 } - return -1; + return -1 } diff --git a/core/win32.odin b/core/win32.odin index 3b29c1b77..93eeec1f5 100644 --- a/core/win32.odin +++ b/core/win32.odin @@ -1,5 +1,5 @@ -#foreign_system_library "user32" when ODIN_OS == "windows"; -#foreign_system_library "gdi32" when ODIN_OS == "windows"; +#foreign_system_library "user32" when ODIN_OS == "windows" +#foreign_system_library "gdi32" when ODIN_OS == "windows" HANDLE :: type rawptr HWND :: type HANDLE @@ -18,100 +18,100 @@ ATOM :: type i16 BOOL :: type i32 WNDPROC :: type proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT -INVALID_HANDLE_VALUE :: (-1 as int) as HANDLE; +INVALID_HANDLE_VALUE :: (-1 as int) as HANDLE -CS_VREDRAW :: 0x0001; -CS_HREDRAW :: 0x0002; -CS_OWNDC :: 0x0020; -CW_USEDEFAULT :: -0x80000000; +CS_VREDRAW :: 0x0001 +CS_HREDRAW :: 0x0002 +CS_OWNDC :: 0x0020 +CW_USEDEFAULT :: -0x80000000 -WS_OVERLAPPED :: 0; -WS_MAXIMIZEBOX :: 0x00010000; -WS_MINIMIZEBOX :: 0x00020000; -WS_THICKFRAME :: 0x00040000; -WS_SYSMENU :: 0x00080000; -WS_CAPTION :: 0x00C00000; -WS_VISIBLE :: 0x10000000; -WS_OVERLAPPEDWINDOW :: WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX; +WS_OVERLAPPED :: 0 +WS_MAXIMIZEBOX :: 0x00010000 +WS_MINIMIZEBOX :: 0x00020000 +WS_THICKFRAME :: 0x00040000 +WS_SYSMENU :: 0x00080000 +WS_CAPTION :: 0x00C00000 +WS_VISIBLE :: 0x10000000 +WS_OVERLAPPEDWINDOW :: WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX -WM_DESTROY :: 0x0002; -WM_CLOSE :: 0x0010; -WM_QUIT :: 0x0012; -WM_KEYDOWN :: 0x0100; -WM_KEYUP :: 0x0101; +WM_DESTROY :: 0x0002 +WM_CLOSE :: 0x0010 +WM_QUIT :: 0x0012 +WM_KEYDOWN :: 0x0100 +WM_KEYUP :: 0x0101 -PM_REMOVE :: 1; +PM_REMOVE :: 1 -COLOR_BACKGROUND :: 1 as HBRUSH; -BLACK_BRUSH :: 4; +COLOR_BACKGROUND :: 1 as HBRUSH +BLACK_BRUSH :: 4 -SM_CXSCREEN :: 0; -SM_CYSCREEN :: 1; +SM_CXSCREEN :: 0 +SM_CYSCREEN :: 1 -SW_SHOW :: 5; +SW_SHOW :: 5 POINT :: struct #ordered { - x, y: i32; + x, y: i32 } WNDCLASSEXA :: struct #ordered { - size, style: u32; - wnd_proc: WNDPROC; - cls_extra, wnd_extra: i32; - instance: HINSTANCE; - icon: HICON; - cursor: HCURSOR; - background: HBRUSH; - menu_name, class_name: ^u8; - sm: HICON; + size, style: u32 + wnd_proc: WNDPROC + cls_extra, wnd_extra: i32 + instance: HINSTANCE + icon: HICON + cursor: HCURSOR + background: HBRUSH + menu_name, class_name: ^u8 + sm: HICON } MSG :: struct #ordered { - hwnd: HWND; - message: u32; - wparam: WPARAM; - lparam: LPARAM; - time: u32; - pt: POINT; + hwnd: HWND + message: u32 + wparam: WPARAM + lparam: LPARAM + time: u32 + pt: POINT } RECT :: struct #ordered { - left: i32; - top: i32; - right: i32; - bottom: i32; + left: i32 + top: i32 + right: i32 + bottom: i32 } FILETIME :: struct #ordered { - low_date_time, high_date_time: u32; + low_date_time, high_date_time: u32 } BY_HANDLE_FILE_INFORMATION :: struct #ordered { - file_attributes: u32; + file_attributes: u32 creation_time, last_access_time, - last_write_time: FILETIME; + last_write_time: FILETIME volume_serial_number, file_size_high, file_size_low, number_of_links, file_index_high, - file_index_low: u32; + file_index_low: u32 } WIN32_FILE_ATTRIBUTE_DATA :: struct #ordered { - file_attributes: u32; + file_attributes: u32 creation_time, last_access_time, - last_write_time: FILETIME; + last_write_time: FILETIME file_size_high, - file_size_low: u32; + file_size_low: u32 } -GET_FILEEX_INFO_LEVELS :: type i32; -GetFileExInfoStandard : GET_FILEEX_INFO_LEVELS : 0; -GetFileExMaxInfoLevel : GET_FILEEX_INFO_LEVELS : 1; +GET_FILEEX_INFO_LEVELS :: type i32 +GetFileExInfoStandard : GET_FILEEX_INFO_LEVELS : 0 +GetFileExMaxInfoLevel : GET_FILEEX_INFO_LEVELS : 1 GetLastError :: proc() -> i32 #foreign #dll_import ExitProcess :: proc(exit_code: u32) #foreign #dll_import @@ -152,9 +152,9 @@ AdjustWindowRect :: proc(rect: ^RECT, style: u32, menu: BOOL) -> BOOL #foreign # GetQueryPerformanceFrequency :: proc() -> i64 { - r: i64; - QueryPerformanceFrequency(^r); - return r; + r: i64 + QueryPerformanceFrequency(^r) + return r } GetCommandLineA :: proc() -> ^u8 #foreign #dll_import @@ -175,23 +175,23 @@ GetFileSizeEx :: proc(file_handle: HANDLE, file_size: ^i64) -> BOOL GetFileAttributesExA :: proc(filename: ^u8, info_level_id: GET_FILEEX_INFO_LEVELS, file_info: rawptr) -> BOOL #foreign #dll_import GetFileInformationByHandle :: proc(file_handle: HANDLE, file_info: ^BY_HANDLE_FILE_INFORMATION) -> BOOL #foreign #dll_import -FILE_SHARE_READ :: 0x00000001; -FILE_SHARE_WRITE :: 0x00000002; -FILE_SHARE_DELETE :: 0x00000004; -FILE_GENERIC_ALL :: 0x10000000; -FILE_GENERIC_EXECUTE :: 0x20000000; -FILE_GENERIC_WRITE :: 0x40000000; -FILE_GENERIC_READ :: 0x80000000; +FILE_SHARE_READ :: 0x00000001 +FILE_SHARE_WRITE :: 0x00000002 +FILE_SHARE_DELETE :: 0x00000004 +FILE_GENERIC_ALL :: 0x10000000 +FILE_GENERIC_EXECUTE :: 0x20000000 +FILE_GENERIC_WRITE :: 0x40000000 +FILE_GENERIC_READ :: 0x80000000 -STD_INPUT_HANDLE :: -10; -STD_OUTPUT_HANDLE :: -11; -STD_ERROR_HANDLE :: -12; +STD_INPUT_HANDLE :: -10 +STD_OUTPUT_HANDLE :: -11 +STD_ERROR_HANDLE :: -12 -CREATE_NEW :: 1; -CREATE_ALWAYS :: 2; -OPEN_EXISTING :: 3; -OPEN_ALWAYS :: 4; -TRUNCATE_EXISTING :: 5; +CREATE_NEW :: 1 +CREATE_ALWAYS :: 2 +OPEN_EXISTING :: 3 +OPEN_ALWAYS :: 4 +TRUNCATE_EXISTING :: 5 @@ -203,7 +203,7 @@ HeapFree :: proc(h: HANDLE, flags: u32, memory: rawptr) -> BOOL GetProcessHeap :: proc() -> HANDLE #foreign #dll_import -HEAP_ZERO_MEMORY :: 0x00000008; +HEAP_ZERO_MEMORY :: 0x00000008 @@ -211,28 +211,28 @@ HEAP_ZERO_MEMORY :: 0x00000008; BITMAPINFO :: struct #ordered { HEADER :: struct #ordered { - size: u32; - width, height: i32; - planes, bit_count: i16; - compression: u32; - size_image: u32; - x_pels_per_meter: i32; - y_pels_per_meter: i32; - clr_used: u32; - clr_important: u32; + size: u32 + width, height: i32 + planes, bit_count: i16 + compression: u32 + size_image: u32 + x_pels_per_meter: i32 + y_pels_per_meter: i32 + clr_used: u32 + clr_important: u32 } - using header: HEADER; - colors: [1]RGBQUAD; + using header: HEADER + colors: [1]RGBQUAD } RGBQUAD :: struct #ordered { - blue, green, red, reserved: byte; + blue, green, red, reserved: byte } -BI_RGB :: 0; -DIB_RGB_COLORS :: 0x00; -SRCCOPY : u32 : 0x00cc0020; +BI_RGB :: 0 +DIB_RGB_COLORS :: 0x00 +SRCCOPY : u32 : 0x00cc0020 StretchDIBits :: proc(hdc: HDC, x_dst, y_dst, width_dst, height_dst: i32, @@ -253,27 +253,27 @@ GetClientRect :: proc(hwnd: HWND, rect: ^RECT) -> BOOL #foreign // Windows OpenGL -PFD_TYPE_RGBA :: 0; -PFD_TYPE_COLORINDEX :: 1; -PFD_MAIN_PLANE :: 0; -PFD_OVERLAY_PLANE :: 1; -PFD_UNDERLAY_PLANE :: -1; -PFD_DOUBLEBUFFER :: 1; -PFD_STEREO :: 2; -PFD_DRAW_TO_WINDOW :: 4; -PFD_DRAW_TO_BITMAP :: 8; -PFD_SUPPORT_GDI :: 16; -PFD_SUPPORT_OPENGL :: 32; -PFD_GENERIC_FORMAT :: 64; -PFD_NEED_PALETTE :: 128; -PFD_NEED_SYSTEM_PALETTE :: 0x00000100; -PFD_SWAP_EXCHANGE :: 0x00000200; -PFD_SWAP_COPY :: 0x00000400; -PFD_SWAP_LAYER_BUFFERS :: 0x00000800; -PFD_GENERIC_ACCELERATED :: 0x00001000; -PFD_DEPTH_DONTCARE :: 0x20000000; -PFD_DOUBLEBUFFER_DONTCARE :: 0x40000000; -PFD_STEREO_DONTCARE :: 0x80000000; +PFD_TYPE_RGBA :: 0 +PFD_TYPE_COLORINDEX :: 1 +PFD_MAIN_PLANE :: 0 +PFD_OVERLAY_PLANE :: 1 +PFD_UNDERLAY_PLANE :: -1 +PFD_DOUBLEBUFFER :: 1 +PFD_STEREO :: 2 +PFD_DRAW_TO_WINDOW :: 4 +PFD_DRAW_TO_BITMAP :: 8 +PFD_SUPPORT_GDI :: 16 +PFD_SUPPORT_OPENGL :: 32 +PFD_GENERIC_FORMAT :: 64 +PFD_NEED_PALETTE :: 128 +PFD_NEED_SYSTEM_PALETTE :: 0x00000100 +PFD_SWAP_EXCHANGE :: 0x00000200 +PFD_SWAP_COPY :: 0x00000400 +PFD_SWAP_LAYER_BUFFERS :: 0x00000800 +PFD_GENERIC_ACCELERATED :: 0x00001000 +PFD_DEPTH_DONTCARE :: 0x20000000 +PFD_DOUBLEBUFFER_DONTCARE :: 0x40000000 +PFD_STEREO_DONTCARE :: 0x80000000 HGLRC :: type HANDLE PROC :: type proc() @@ -283,7 +283,7 @@ wglCreateContextAttribsARBType :: type proc(hdc: HDC, hshareContext: rawptr, att PIXELFORMATDESCRIPTOR :: struct #ordered { size, version, - flags: u32; + flags: u32 pixel_type, color_bits, @@ -304,11 +304,11 @@ PIXELFORMATDESCRIPTOR :: struct #ordered { stencil_bits, aux_buffers, layer_type, - reserved: byte; + reserved: byte layer_mask, visible_mask, - damage_mask: u32; + damage_mask: u32 } GetDC :: proc(h: HANDLE) -> HDC #foreign @@ -317,11 +317,11 @@ ChoosePixelFormat :: proc(hdc: HDC, pfd: ^PIXELFORMATDESCRIPTOR) -> i32 #foreign SwapBuffers :: proc(hdc: HDC) -> BOOL #foreign #dll_import ReleaseDC :: proc(wnd: HWND, hdc: HDC) -> i32 #foreign #dll_import -WGL_CONTEXT_MAJOR_VERSION_ARB :: 0x2091; -WGL_CONTEXT_MINOR_VERSION_ARB :: 0x2092; -WGL_CONTEXT_PROFILE_MASK_ARB :: 0x9126; -WGL_CONTEXT_CORE_PROFILE_BIT_ARB :: 0x0001; -WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x0002; +WGL_CONTEXT_MAJOR_VERSION_ARB :: 0x2091 +WGL_CONTEXT_MINOR_VERSION_ARB :: 0x2092 +WGL_CONTEXT_PROFILE_MASK_ARB :: 0x9126 +WGL_CONTEXT_CORE_PROFILE_BIT_ARB :: 0x0001 +WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x0002 wglCreateContext :: proc(hdc: HDC) -> HGLRC #foreign #dll_import wglMakeCurrent :: proc(hdc: HDC, hglrc: HGLRC) -> BOOL #foreign #dll_import @@ -334,7 +334,7 @@ GetKeyState :: proc(v_key: i32) -> i16 #foreign #dll_import GetAsyncKeyState :: proc(v_key: i32) -> i16 #foreign #dll_import is_key_down :: proc(key: Key_Code) -> bool { - return GetAsyncKeyState(key as i32) < 0; + return GetAsyncKeyState(key as i32) < 0 } Key_Code :: enum i32 { diff --git a/src/parser.c b/src/parser.c index 28925fb57..7eeb9133f 100644 --- a/src/parser.c +++ b/src/parser.c @@ -1157,26 +1157,6 @@ bool expect_semicolon_after_stmt(AstFile *f, AstNode *s) { return true; } - if (s != NULL) { - switch (s->kind) { - case AstNode_ProcDecl: - case AstNode_TypeDecl: - return true; - } - } - - // if (f->curr_token.pos.line != f->prev_token.pos.line) { - // return true; - // } - - if (f->curr_token.pos.line == f->prev_token.pos.line) { - switch (f->curr_token.kind) { - case Token_EOF: - case Token_CloseBrace: - return true; - } - } - if (s != NULL) { syntax_error(f->prev_token, "Expected `;` after %.*s, got `%.*s`", LIT(ast_node_strings[s->kind]), LIT(token_strings[f->prev_token.kind])); @@ -2222,10 +2202,14 @@ AstNode *parse_identifier_or_type(AstFile *f, u32 flags) { break; } // fallthrough - default: + default: { + String prev = str_lit("newline"); + if (str_ne(f->prev_token.string, str_lit("\n"))) { + prev = f->prev_token.string; + } syntax_error(f->curr_token, - "Expected a type or identifier after `%.*s`, got `%.*s`", LIT(f->prev_token.string), LIT(f->curr_token.string)); - break; + "Expected a type or identifier after %.*s, got %.*s", LIT(prev), LIT(f->curr_token.string)); + } break; } return NULL; diff --git a/src/tokenizer.c b/src/tokenizer.c index 455d7bf36..13cafc1f7 100644 --- a/src/tokenizer.c +++ b/src/tokenizer.c @@ -303,6 +303,8 @@ typedef struct Tokenizer { u8 * line; // current line pos isize line_count; + bool insert_semicolon; // Inserts a semicolon before the next newline + isize error_count; Array(String) allocated_strings; } Tokenizer; @@ -413,7 +415,10 @@ gb_inline void destroy_tokenizer(Tokenizer *t) { } void tokenizer_skip_whitespace(Tokenizer *t) { - while (rune_is_whitespace(t->curr_rune)) { + while (t->curr_rune == ' ' || + t->curr_rune == '\t' || + (t->curr_rune == '\n' && !t->insert_semicolon) || + t->curr_rune == '\r') { advance_to_next_rune(t); } } @@ -617,6 +622,51 @@ gb_inline TokenKind token_kind_dub_eq(Tokenizer *t, Rune sing_rune, TokenKind si return sing; } +void tokenizer__fle_update(Tokenizer *t) { + t->curr_rune = '/'; + t->curr = t->curr-1; + t->read_curr = t->curr+1; + advance_to_next_rune(t); +} + +// NOTE(bill): needed if comment is straight after a "semicolon" +bool tokenizer_find_line_end(Tokenizer *t) { + while (t->curr_rune == '/' || t->curr_rune == '*') { + if (t->curr_rune == '/') { + tokenizer__fle_update(t); + return true; + } + + advance_to_next_rune(t); + while (t->curr_rune >= 0) { + Rune r = t->curr_rune; + if (r == '\n') { + tokenizer__fle_update(t); + return true; + } + advance_to_next_rune(t); + if (r == '*' && t->curr_rune == '/') { + advance_to_next_rune(t); + break; + } + } + + tokenizer_skip_whitespace(t); + if (t->curr_rune < 0 || t->curr_rune == '\n') { + tokenizer__fle_update(t); + return true; + } + if (t->curr_rune != '/') { + tokenizer__fle_update(t); + return false; + } + advance_to_next_rune(t); + } + + tokenizer__fle_update(t); + return false; +} + Token tokenizer_get_token(Tokenizer *t) { Token token = {0}; Rune curr_rune; @@ -627,6 +677,8 @@ Token tokenizer_get_token(Tokenizer *t) { token.pos.line = t->line_count; token.pos.column = t->curr - t->line + 1; + bool insert_semicolon = false; + curr_rune = t->curr_rune; if (rune_is_letter(curr_rune)) { token.kind = Token_Ident; @@ -654,19 +706,48 @@ Token tokenizer_get_token(Tokenizer *t) { } } } + + switch (token.kind) { + case Token_Ident: + case Token_return: + case Token_break: + case Token_continue: + case Token_fallthrough: + insert_semicolon = true; + break; + } + } else { + insert_semicolon = true; } } else if (gb_is_between(curr_rune, '0', '9')) { + insert_semicolon = true; token = scan_number_to_token(t, false); } else { advance_to_next_rune(t); switch (curr_rune) { case GB_RUNE_EOF: + if (t->insert_semicolon) { + t->insert_semicolon = false; + token.string = str_lit("\n"); + token.kind = Token_Semicolon; + return token; + } token.kind = Token_EOF; break; + case '\n': + // NOTE(bill): This will be only be reached if t->insert_semicolom was set + // earlier and exited early from tokenizer_skip_whitespace() + t->insert_semicolon = false; + token.string = str_lit("\n"); + token.kind = Token_Semicolon; + return token; + case '\'': // Rune Literal { + insert_semicolon = true; + token.kind = Token_Rune; Rune quote = curr_rune; bool valid = true; @@ -699,6 +780,7 @@ Token tokenizer_get_token(Tokenizer *t) { if (success == 2) { array_add(&t->allocated_strings, token.string); } + t->insert_semicolon = true; return token; } else { tokenizer_err(t, "Invalid rune literal"); @@ -708,6 +790,8 @@ Token tokenizer_get_token(Tokenizer *t) { case '`': // Raw String Literal case '"': // String Literal { + insert_semicolon = true; + i32 success; Rune quote = curr_rune; token.kind = Token_String; @@ -745,6 +829,7 @@ Token tokenizer_get_token(Tokenizer *t) { if (success == 2) { array_add(&t->allocated_strings, token.string); } + t->insert_semicolon = true; return token; } else { tokenizer_err(t, "Invalid string literal"); @@ -754,6 +839,7 @@ Token tokenizer_get_token(Tokenizer *t) { case '.': token.kind = Token_Period; // Default if (gb_is_between(t->curr_rune, '0', '9')) { // Might be a number + insert_semicolon = true; token = scan_number_to_token(t, true); } else if (t->curr_rune == '.') { // Could be an ellipsis advance_to_next_rune(t); @@ -765,54 +851,107 @@ Token tokenizer_get_token(Tokenizer *t) { } break; - case '#': token.kind = Token_Hash; break; - case '@': token.kind = Token_At; break; - case '^': token.kind = Token_Pointer; break; - case '?': token.kind = Token_Maybe; break; - case ';': token.kind = Token_Semicolon; break; - case ',': token.kind = Token_Comma; break; - case '(': token.kind = Token_OpenParen; break; - case ')': token.kind = Token_CloseParen; break; - case '[': token.kind = Token_OpenBracket; break; - case ']': token.kind = Token_CloseBracket; break; - case '{': token.kind = Token_OpenBrace; break; - case '}': token.kind = Token_CloseBrace; break; - case ':': token.kind = Token_Colon; break; + case '#': + token.kind = Token_Hash; + break; + case '@': + token.kind = Token_At; + break; + case '^': + token.kind = Token_Pointer; + break; + case '?': + token.kind = Token_Maybe; + break; + case ';': + token.kind = Token_Semicolon; + token.string = str_lit(";"); + break; + case ',': + token.kind = Token_Comma; + break; + case ':': + token.kind = Token_Colon; + break; + case '(': + token.kind = Token_OpenParen; + break; + case ')': + insert_semicolon = true; + token.kind = Token_CloseParen; + break; + case '[': + token.kind = Token_OpenBracket; + break; + case ']': + insert_semicolon = true; + token.kind = Token_CloseBracket; + break; + case '{': + token.kind = Token_OpenBrace; + break; + case '}': + insert_semicolon = true; + token.kind = Token_CloseBrace; + break; case '*': token.kind = token_kind_variant2(t, Token_Mul, Token_MulEq); break; case '%': token.kind = token_kind_variant2(t, Token_Mod, Token_ModEq); break; case '=': token.kind = token_kind_variant2(t, Token_Eq, Token_CmpEq); break; case '~': token.kind = token_kind_variant2(t, Token_Xor, Token_XorEq); break; case '!': token.kind = token_kind_variant2(t, Token_Not, Token_NotEq); break; - case '+': token.kind = token_kind_variant3(t, Token_Add, Token_AddEq, '+', Token_Increment); break; - case '-': token.kind = token_kind_variant4(t, Token_Sub, Token_SubEq, '-', Token_Decrement, '>', Token_ArrowRight); break; + case '+': + token.kind = token_kind_variant3(t, Token_Add, Token_AddEq, '+', Token_Increment); + if (token.kind == Token_Increment) { + insert_semicolon = true; + } + break; + case '-': + token.kind = token_kind_variant4(t, Token_Sub, Token_SubEq, '-', Token_Decrement, '>', Token_ArrowRight); + if (token.kind == Token_Decrement) { + insert_semicolon = true; + } + break; case '/': { - if (t->curr_rune == '/') { - while (t->curr_rune != '\n') { - advance_to_next_rune(t); + if (t->curr_rune == '/' || t->curr_rune == '*') { + if (t->insert_semicolon && tokenizer_find_line_end(t)) { + t->curr_rune = '/'; + t->curr = token.string.text; + t->read_curr = t->curr+1; + t->insert_semicolon = false; + + token.kind = Token_Semicolon; + token.string = str_lit("\n"); + return token; } - token.kind = Token_Comment; - } else if (t->curr_rune == '*') { - isize comment_scope = 1; - advance_to_next_rune(t); - while (comment_scope > 0) { - if (t->curr_rune == '/') { - advance_to_next_rune(t); - if (t->curr_rune == '*') { - advance_to_next_rune(t); - comment_scope++; - } - } else if (t->curr_rune == '*') { - advance_to_next_rune(t); - if (t->curr_rune == '/') { - advance_to_next_rune(t); - comment_scope--; - } - } else { + + if (t->curr_rune == '/') { + while (t->curr_rune != '\n') { advance_to_next_rune(t); } + token.kind = Token_Comment; + } else if (t->curr_rune == '*') { + isize comment_scope = 1; + advance_to_next_rune(t); + while (comment_scope > 0) { + if (t->curr_rune == '/') { + advance_to_next_rune(t); + if (t->curr_rune == '*') { + advance_to_next_rune(t); + comment_scope++; + } + } else if (t->curr_rune == '*') { + advance_to_next_rune(t); + if (t->curr_rune == '/') { + advance_to_next_rune(t); + comment_scope--; + } + } else { + advance_to_next_rune(t); + } + } + token.kind = Token_Comment; } - token.kind = Token_Comment; } else { token.kind = token_kind_variant2(t, Token_Quo, Token_QuoEq); } @@ -851,11 +990,14 @@ Token tokenizer_get_token(Tokenizer *t) { int len = cast(int)gb_utf8_encode_rune(str, curr_rune); tokenizer_err(t, "Illegal character: %.*s (%d) ", len, str, curr_rune); } + insert_semicolon = t->insert_semicolon; token.kind = Token_Invalid; break; } } + t->insert_semicolon = insert_semicolon; + token.string.len = t->curr - token.string.text; return token; }