From 24ca1065214f51cfbeb9c0eff98002c7d33139a2 Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Thu, 17 Nov 2016 22:58:00 +0000 Subject: [PATCH] v0.0.3 Build --- build.bat | 4 +- code/demo.odin | 32 +- code/game.odin | 7 +- code/math.odin | 180 ----- core/_preload.odin | 4 +- core/math.odin | 373 ++++++++++ core/opengl.odin | 172 ++++- core/opengl_constants.odin | 1384 ++++++++++++++++++++++++++++++++++++ core/os.odin | 62 +- core/win32.odin | 38 +- roadmap.md | 4 + src/checker/expr.cpp | 3 +- src/ssa.cpp | 9 +- src/tokenizer.cpp | 10 +- todo.md | 20 - 15 files changed, 2013 insertions(+), 289 deletions(-) delete mode 100644 code/math.odin create mode 100644 core/math.odin create mode 100644 core/opengl_constants.odin diff --git a/build.bat b/build.bat index 4b5c1cacf..ed4442851 100644 --- a/build.bat +++ b/build.bat @@ -4,7 +4,7 @@ set exe_name=odin.exe :: Debug = 0, Release = 1 -set release_mode=0 +set release_mode=1 set compiler_flags= -nologo -Oi -TP -W4 -fp:fast -fp:except- -Gm- -MP -FC -GS- -EHsc- -GR- @@ -48,7 +48,7 @@ rem pushd %build_dir% cl %compiler_settings% "src\main.cpp" ^ /link %linker_settings% -OUT:%exe_name% ^ - && odin run w:/Freyr/src/main.odin + && odin run code/demo.odin rem odin run code/demo.odin diff --git a/code/demo.odin b/code/demo.odin index ee353c884..a72fbea6a 100644 --- a/code/demo.odin +++ b/code/demo.odin @@ -1,32 +1,6 @@ -x: i64 = 123 - -Vec2 :: struct { - x, y: i64 -} - +#import "fmt.odin" +#import "game.odin" main :: proc() { - foo :: proc() -> i64 { - bar :: proc() -> (i64, i64) { - a := [3]i64{7, 4, 2} - v := Vec2{a[0], 2} - return v.x, v.y - } - - x, y := bar() - - return x + y - } - - test :: proc(s: string) -> string { - return s - } - - foo() - x = test("Hello").count as i64 - xp := ^x - p := xp^ - - z := [..]i64{1, 2, 3, 4} - z[0] = p + fmt.println("Hellope, everybody!") } diff --git a/code/game.odin b/code/game.odin index 31b6b28f1..c5d0c52f2 100644 --- a/code/game.odin +++ b/code/game.odin @@ -107,9 +107,7 @@ make_window :: proc(title: string, msg, height: int, window_proc: win32.WNDPROC) 0, // NOTE(bill): tells the proc that this is the end of attribs } - wgl_string := "wglCreateContextAttribsARB\x00" - c_wgl_string := ^wgl_string[0] - wglCreateContextAttribsARB := wglGetProcAddress(c_wgl_string) as wglCreateContextAttribsARBType + wglCreateContextAttribsARB := wglGetProcAddress(("wglCreateContextAttribsARB\x00" as string).data) as wglCreateContextAttribsARBType w.rc = wglCreateContextAttribsARB(w.dc, 0, ^attribs[0]) wglMakeCurrent(w.dc, w.rc) SwapBuffers(w.dc) @@ -145,6 +143,7 @@ run :: proc() { } defer destroy_window(^window) + gl.init() prev_time := time_now() @@ -205,7 +204,7 @@ run :: proc() { gl.Color3f(1, 0, 0); gl.Vertex3f(x, y, 0) } - draw_rect(pos[0], pos[1], 50, 50) + draw_rect(pos.x, pos.y, 50, 50) display_window(^window) ms_to_sleep := (16 - 1000*dt) as i32 diff --git a/code/math.odin b/code/math.odin deleted file mode 100644 index e9554f6b5..000000000 --- a/code/math.odin +++ /dev/null @@ -1,180 +0,0 @@ -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 - -LOG_TWO :: 0.693147180559945309417232121458176568 -LOG_TEN :: 2.30258509299404568401799145468436421 - -EPSILON :: 1.19209290e-7 - -τ :: TAU -π :: PI - -// Vec2 :: type raw_union { -// using xy_: struct {x, y: f32} -// v: {2}f32 -// e: [2]f32 -// } -// Vec3 :: type raw_union { -// using xyz_: struct {x, y, z: f32} -// xy: Vec2 -// v: {3}f32 -// e: [3]f32 -// } -// Vec4 :: type raw_union { -// using xyzw_: struct {x, y, z, w: f32} -// xy: Vec2 -// xyz: Vec3 -// v: {4}f32 -// e: [4]f32 -// } -Vec2 :: type {2}f32 -Vec3 :: type {3}f32 -Vec4 :: type {4}f32 - -Mat2 :: type {4}f32 -Mat3 :: type {9}f32 -Mat4 :: type {16}f32 - - -sqrt32 :: proc(x: f32) -> f32 #foreign "llvm.sqrt.f32" -sqrt64 :: proc(x: f64) -> f64 #foreign "llvm.sqrt.f64" - -sin32 :: proc(x: f32) -> f32 #foreign "llvm.sin.f32" -sin64 :: proc(x: f64) -> f64 #foreign "llvm.sin.f64" - -cos64 :: proc(x: f64) -> f64 #foreign "llvm.cos.f64" -cos32 :: proc(x: f32) -> f32 #foreign "llvm.cos.f32" - -lerp32 :: proc(a, b, t: f32) -> f32 { return a*(1-t) + b*t } -lerp64 :: proc(a, b, t: f64) -> f64 { return a*(1-t) + b*t } - -clamp32 :: proc(x, lower, upper: f32) -> f32 { return min(max(x, lower), upper) } -clamp64 :: proc(x, lower, upper: f64) -> f64 { return min(max(x, lower), upper) } - -sign32 :: proc(x: f32) -> f32 { if x >= 0 { return +1 } return -1 } -sign64 :: proc(x: f64) -> f64 { if x >= 0 { return +1 } return -1 } - - - -copy_sign :: proc(x, y: f32) -> f32 { - ix := x transmute u32 - iy := y transmute u32 - ix &= 0x7fffffff - ix |= iy & 0x80000000 - return ix transmute f32 -} -round :: proc(x: f32) -> f32 { - if x >= 0 { - return floor(x + 0.5) - } - return ceil(x - 0.5) -} -floor :: proc(x: f32) -> f32 { - if x >= 0 { - return x as int as f32 - } - return (x-0.5) as int as f32 -} -ceil :: proc(x: f32) -> f32 { - if x < 0 { - return x as int as f32 - } - return ((x as int)+1) as f32 -} - -remainder :: proc(x, y: f32) -> f32 { - return x - round(x/y) * y -} - -fmod :: proc(x, y: f32) -> f32 { - y = abs(y) - result := remainder(abs(x), y) - if sign32(result) < 0 { - result += y - } - return copy_sign(result, x) -} - - -to_radians :: proc(degrees: f32) -> f32 { return degrees * TAU / 360 } -to_degrees :: proc(radians: f32) -> f32 { return radians * 360 / TAU } - - - - -dot2 :: proc(a, b: Vec2) -> f32 { c := a*b; return c[0] + c[1] } -dot3 :: proc(a, b: Vec3) -> f32 { c := a*b; return c[0] + c[1] + c[2] } -dot4 :: proc(a, b: Vec4) -> f32 { c := a*b; return c[0] + c[1] + c[2] + c[3] } - -cross :: 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 -} - - -vec2_mag :: proc(v: Vec2) -> f32 { return sqrt32(dot2(v, v)) } -vec3_mag :: proc(v: Vec3) -> f32 { return sqrt32(dot3(v, v)) } -vec4_mag :: proc(v: Vec4) -> f32 { return sqrt32(dot4(v, v)) } - -vec2_norm :: proc(v: Vec2) -> Vec2 { return v / Vec2{vec2_mag(v)} } -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) - if m == 0 { - return Vec2{0} - } - return v / Vec2{m} -} - -vec3_norm0 :: proc(v: Vec3) -> Vec3 { - m := vec3_mag(v) - if m == 0 { - return Vec3{0} - } - return v / Vec3{m} -} - -vec4_norm0 :: proc(v: Vec4) -> Vec4 { - m := vec4_mag(v) - if m == 0 { - return Vec4{0} - } - return v / Vec4{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 - -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/_preload.odin b/core/_preload.odin index 613070cd3..215b9890c 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -4,6 +4,7 @@ #import "fmt.odin" #import "mem.odin" +/* Optimization_Level :: enum { DEBUG, RELEASE, @@ -24,7 +25,7 @@ Build_Options :: struct { } build_options: Build_Options - +*/ // IMPORTANT NOTE(bill): Do not change the order of any of this data // The compiler relies upon this _exact_ order @@ -80,6 +81,7 @@ Type_Info :: union { elem: ^Type_Info elem_size: int count: int + align: int } Tuple: Record Struct: Record diff --git a/core/math.odin b/core/math.odin new file mode 100644 index 000000000..effe3367e --- /dev/null +++ b/core/math.odin @@ -0,0 +1,373 @@ +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 + +LOG_TWO :: 0.693147180559945309417232121458176568 +LOG_TEN :: 2.30258509299404568401799145468436421 + +EPSILON :: 1.19209290e-7 + +τ :: TAU +π :: PI + + +Vec2 :: type {2}f32 +Vec3 :: type {3}f32 +Vec4 :: type {4}f32 + +Mat2 :: type [2]Vec2 +Mat3 :: type [3]Vec3 +Mat4 :: type [4]Vec4 + + +sqrt32 :: proc(x: f32) -> f32 #foreign "llvm.sqrt.f32" +sqrt64 :: proc(x: f64) -> f64 #foreign "llvm.sqrt.f64" + +sin32 :: proc(x: f32) -> f32 #foreign "llvm.sin.f32" +sin64 :: proc(x: f64) -> f64 #foreign "llvm.sin.f64" + +cos32 :: proc(x: f32) -> f32 #foreign "llvm.cos.f32" +cos64 :: proc(x: f64) -> f64 #foreign "llvm.cos.f64" + +tan32 :: proc(x: f32) -> f32 #inline { return sin32(x)/cos32(x) } +tan64 :: proc(x: f64) -> f64 #inline { return sin64(x)/cos64(x) } + +lerp32 :: proc(a, b, t: f32) -> f32 { return a*(1-t) + b*t } +lerp64 :: proc(a, b, t: f64) -> f64 { return a*(1-t) + b*t } + +clamp32 :: proc(x, lower, upper: f32) -> f32 { return min(max(x, lower), upper) } +clamp64 :: proc(x, lower, upper: f64) -> f64 { return min(max(x, lower), upper) } + +sign32 :: proc(x: f32) -> f32 { if x >= 0 { return +1 } return -1 } +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 +} +round32 :: proc(x: f32) -> f32 { + if x >= 0 { + return floor32(x + 0.5) + } + return ceil32(x - 0.5) +} +floor32 :: proc(x: f32) -> f32 { + if x >= 0 { + return x 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)+1) as f32 +} + +remainder32 :: proc(x, y: f32) -> f32 { + return x - round32(x/y) * y +} + +fmod32 :: proc(x, y: f32) -> f32 { + y = abs(y) + result := remainder32(abs(x), y) + if sign32(result) < 0 { + result += y + } + return copy_sign32(result, x) +} + + +to_radians :: proc(degrees: f32) -> f32 { return degrees * TAU / 360 } +to_degrees :: proc(radians: f32) -> f32 { return radians * 360 / TAU } + + + + +dot2 :: proc(a, b: Vec2) -> f32 { c := a*b; return c.x + c.y } +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 +} + + +vec2_mag :: proc(v: Vec2) -> f32 { return sqrt32(dot2(v, v)) } +vec3_mag :: proc(v: Vec3) -> f32 { return sqrt32(dot3(v, v)) } +vec4_mag :: proc(v: Vec4) -> f32 { return sqrt32(dot4(v, v)) } + +vec2_norm :: proc(v: Vec2) -> Vec2 { return v / Vec2{vec2_mag(v)} } +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) + if m == 0 { + return Vec2{0} + } + return v / Vec2{m} +} + +vec3_norm0 :: proc(v: Vec3) -> Vec3 { + m := vec3_mag(v) + if m == 0 { + return Vec3{0} + } + return v / Vec3{m} +} + +vec4_norm0 :: proc(v: Vec4) -> Vec4 { + m := vec4_mag(v) + if m == 0 { + return Vec4{0} + } + return v / Vec4{m} +} + + + +mat4_identity :: proc() -> Mat4 { + return Mat4{ + {1, 0, 0, 0}, + {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] + } + } + return m +} + +mat4_mul :: proc(a, b: Mat4) -> 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] + } + } + return c +} + +mat4_mul_vec4 :: proc(m: Mat4, v: Vec4) -> Vec4 { + return Vec4{ + m[0][0]*v.x + m[1][0]*v.y + m[2][0]*v.z + m[3][0]*v.w, + 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 + + 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[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[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]) + + 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 +} + + +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 +} + +mat4_rotate :: proc(v: Vec3, angle_radians: f32) -> Mat4 { + c := cos32(angle_radians) + s := sin32(angle_radians) + + a := vec3_norm(v) + t := a * Vec3{1-c} + + 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[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 + + 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 +} + +mat4_scalef :: proc(m: Mat4, s: f32) -> Mat4 { + 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) + + 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} + + 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 +} + + +mat4_ortho3d :: proc(left, right, bottom, top, near, far: f32) -> Mat4 { + 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) + + 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 + +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/opengl.odin b/core/opengl.odin index 6f30286a1..94d943809 100644 --- a/core/opengl.odin +++ b/core/opengl.odin @@ -1,53 +1,155 @@ #foreign_system_library "opengl32" - -ZERO :: 0x0000 -ONE :: 0x0001 -TRIANGLES :: 0x0004 -BLEND :: 0x0be2 -SRC_ALPHA :: 0x0302 -ONE_MINUS_SRC_ALPHA :: 0x0303 -TEXTURE_2D :: 0x0de1 -RGBA8 :: 0x8058 -UNSIGNED_BYTE :: 0x1401 -BGRA_EXT :: 0x80e1 -TEXTURE_MAX_LEVEL :: 0x813d -RGBA :: 0x1908 - -NEAREST :: 0x2600 -LINEAR :: 0x2601 - -DEPTH_BUFFER_BIT :: 0x00000100 -STENCIL_BUFFER_BIT :: 0x00000400 -COLOR_BUFFER_BIT :: 0x00004000 - -TEXTURE_MAX_ANISOTROPY_EXT :: 0x84fe - -TEXTURE_MAG_FILTER :: 0x2800 -TEXTURE_MIN_FILTER :: 0x2801 -TEXTURE_WRAP_S :: 0x2802 -TEXTURE_WRAP_T :: 0x2803 +#import "win32.odin" +#load "opengl_constants.odin" Clear :: proc(mask: u32) #foreign "glClear" ClearColor :: proc(r, g, b, a: f32) #foreign "glClearColor" Begin :: proc(mode: i32) #foreign "glBegin" End :: proc() #foreign "glEnd" -Color3f :: proc(r, g, b: f32) #foreign "glColor3f" -Color4f :: proc(r, g, b, a: f32) #foreign "glColor4f" -Vertex2f :: proc(x, y: f32) #foreign "glVertex2f" -Vertex3f :: proc(x, y, z: f32) #foreign "glVertex3f" -TexCoord2f :: proc(u, v: f32) #foreign "glTexCoord2f" -LoadIdentity :: proc() #foreign "glLoadIdentity" -Ortho :: proc(left, right, bottom, top, near, far: f64) #foreign "glOrtho" +Finish :: proc() #foreign "glFinish" BlendFunc :: proc(sfactor, dfactor: i32) #foreign "glBlendFunc" Enable :: proc(cap: i32) #foreign "glEnable" Disable :: proc(cap: i32) #foreign "glDisable" GenTextures :: proc(count: i32, result: ^u32) #foreign "glGenTextures" +DeleteTextures :: proc(count: i32, result: ^u32) #foreign "glDeleteTextures" TexParameteri :: proc(target, pname, param: i32) #foreign "glTexParameteri" TexParameterf :: proc(target: i32, pname: i32, param: f32) #foreign "glTexParameterf" BindTexture :: proc(target: i32, texture: u32) #foreign "glBindTexture" -TexImage2D :: proc(target, level, internal_format, width, height, border, format, _type: i32, pixels: rawptr) #foreign "glTexImage2D" +LoadIdentity :: proc() #foreign "glLoadIdentity" +Viewport :: proc(x, y, width, height: i32) #foreign "glViewport" +Ortho :: proc(left, right, bottom, top, near, far: f64) #foreign "glOrtho" +Color3f :: proc(r, g, b: f32) #foreign "glColor3f" +Vertex3f :: proc(x, y, z: f32) #foreign "glVertex3f" +TexImage2D :: proc(target, level, internal_format, + width, height, border, + format, _type: i32, pixels: rawptr) #foreign "glTexImage2D" + +GetError :: proc() -> i32 #foreign "glGetError" +GetString :: proc(name: i32) -> ^byte #foreign "glGetString" +GetIntegerv :: proc(name: i32, v: ^i32) #foreign "glGetIntegerv" +_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) + if res == nil { + res = win32.GetProcAddress(_libgl, name.data); + } + 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) + +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) + +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) + + +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) + +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) + +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(^DrawArrays, "glDrawArrays\x00") + set_proc_address(^DrawElements, "glDrawElements\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(^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(^ActiveTexture, "glActiveTexture\x00") + set_proc_address(^GenerateMipmap, "glGenerateMipmap\x00") + + set_proc_address(^Uniform1i, "glUniform1i\x00") + set_proc_address(^UniformMatrix4fv, "glUniformMatrix4fv\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") +} + diff --git a/core/opengl_constants.odin b/core/opengl_constants.odin new file mode 100644 index 000000000..ffb1c33ec --- /dev/null +++ b/core/opengl_constants.odin @@ -0,0 +1,1384 @@ +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 + +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 + +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 + +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 + +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 + + +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 + +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 + +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 + +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 + +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 92ff61a8c..1286065bc 100644 --- a/core/os.odin +++ b/core/os.odin @@ -1,17 +1,23 @@ #import "win32.odin" +#import "fmt.odin" -File :: type struct { +File_Time :: type u64 + +File :: struct { Handle :: type win32.HANDLE - handle: Handle + 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{CreateFileA(^buf[0], FILE_GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, nil)} + f := File{ + handle = CreateFileA(^buf[0], FILE_GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, nil), + } success := f.handle != INVALID_HANDLE_VALUE as File.Handle - + f.last_write_time = last_write_time(^f) return f, success } @@ -23,6 +29,7 @@ create :: proc(name: string) -> (File, bool) { handle = CreateFileA(^buf[0], FILE_GENERIC_WRITE, FILE_SHARE_READ, nil, CREATE_ALWAYS, 0, nil), } success := f.handle != INVALID_HANDLE_VALUE as File.Handle + f.last_write_time = last_write_time(^f) return f, success } @@ -35,19 +42,56 @@ write :: proc(using f: ^File, buf: []byte) -> bool { return win32.WriteFile(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) + if f.last_write_time != last_write_time { + f.last_write_time = last_write_time + return true + } + return false +} + + + +last_write_time :: proc(f: ^File) -> File_Time { + file_info: win32.BY_HANDLE_FILE_INFORMATION + win32.GetFileInformationByHandle(f.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 + + 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 + } + + l := last_write_time.low_date_time as File_Time + h := last_write_time.high_date_time as File_Time + return l | h << 32 +} + + + File_Standard :: type enum { INPUT, OUTPUT, ERROR, - COUNT, } // NOTE(bill): Uses startup to initialize it -__std_files := [..]File{ - File{handle = win32.GetStdHandle(win32.STD_INPUT_HANDLE)}, - File{handle = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE)}, - File{handle = win32.GetStdHandle(win32.STD_ERROR_HANDLE)}, +__std_files := [File_Standard.count]File{ + {handle = win32.GetStdHandle(win32.STD_INPUT_HANDLE)}, + {handle = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE)}, + {handle = win32.GetStdHandle(win32.STD_ERROR_HANDLE)}, } stdin := ^__std_files[File_Standard.INPUT] diff --git a/core/win32.odin b/core/win32.odin index 724bc6a73..ffb9d5bd1 100644 --- a/core/win32.odin +++ b/core/win32.odin @@ -83,6 +83,35 @@ RECT :: struct #ordered { bottom: i32 } +FILETIME :: struct #ordered { + low_date_time, high_date_time: u32 +} + +BY_HANDLE_FILE_INFORMATION :: struct #ordered { + file_attributes: u32 + creation_time, + last_access_time, + last_write_time: FILETIME + volume_serial_number, + file_size_high, + file_size_low, + number_of_links, + file_index_high, + file_index_low: u32 +} + +WIN32_FILE_ATTRIBUTE_DATA :: struct #ordered { + file_attributes: u32 + creation_time, + last_access_time, + last_write_time: FILETIME + file_size_high, + file_size_low: u32 +} + +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 @@ -142,7 +171,9 @@ CreateFileA :: proc(filename: ^u8, desired_access, share_mode: u32, ReadFile :: proc(h: HANDLE, buf: rawptr, to_read: u32, bytes_read: ^i32, overlapped: rawptr) -> BOOL #foreign #dll_import WriteFile :: proc(h: HANDLE, buf: rawptr, len: i32, written_result: ^i32, overlapped: rawptr) -> i32 #foreign #dll_import -GetFileSizeEx :: proc(file_handle: HANDLE, file_size: ^i64) -> BOOL #foreign #dll_import +GetFileSizeEx :: proc(file_handle: HANDLE, file_size: ^i64) -> BOOL #foreign #dll_import +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 @@ -163,6 +194,9 @@ OPEN_ALWAYS :: 4 TRUNCATE_EXISTING :: 5 + + + HeapAlloc :: proc(h: HANDLE, flags: u32, bytes: int) -> rawptr #foreign #dll_import HeapReAlloc :: proc(h: HANDLE, flags: u32, memory: rawptr, bytes: int) -> rawptr #foreign #dll_import HeapFree :: proc(h: HANDLE, flags: u32, memory: rawptr) -> BOOL #foreign #dll_import @@ -213,6 +247,8 @@ LoadLibraryA :: proc(c_str: ^u8) -> HMODULE #foreign FreeLibrary :: proc(h: HMODULE) #foreign GetProcAddress :: proc(h: HMODULE, c_str: ^u8) -> proc() #foreign +GetClientRect :: proc(hwnd: HWND, rect: ^RECT) -> BOOL #foreign + // Windows OpenGL diff --git a/roadmap.md b/roadmap.md index 378be6ee6..5991668e6 100644 --- a/roadmap.md +++ b/roadmap.md @@ -11,3 +11,7 @@ Not in any particular order * Improve SSA design to accommodate for lowering to a "bytecode" * SSA optimizations * Parametric Polymorphism +* Documentation Generator for Entities +* Linking Options + - Executable + - Static/Dynamic Library diff --git a/src/checker/expr.cpp b/src/checker/expr.cpp index b0b7a0f9c..1d9cad048 100644 --- a/src/checker/expr.cpp +++ b/src/checker/expr.cpp @@ -92,7 +92,7 @@ b32 check_is_assignable_to(Checker *c, Operand *operand, Type *type, b32 is_argu if (is_type_maybe(dst)) { Type *elem = base_type(dst)->Maybe.elem; - return are_types_identical(elem, src); + return are_types_identical(elem, s); } if (is_type_untyped_nil(src)) { @@ -2458,6 +2458,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node) { GB_ASSERT(entity->type != NULL); b32 is_not_exported = !is_entity_exported(entity); + // TODO(bill): Fix this for `#import "file.odin" as .` if (is_not_exported) { auto found = map_get(&e->ImportName.scope->implicit, hash_string(sel_name)); if (!found && e->ImportName.scope != entity->scope) { diff --git a/src/ssa.cpp b/src/ssa.cpp index 47b81a8e0..a63000762 100644 --- a/src/ssa.cpp +++ b/src/ssa.cpp @@ -1722,6 +1722,8 @@ ssaValue *ssa_emit_deep_field_gep(ssaProcedure *proc, Type *type, ssaValue *e, S e = ssa_emit_struct_ep(proc, e, index); } else if (type->kind == Type_Vector) { e = ssa_emit_array_ep(proc, e, index); + } else if (type->kind == Type_Array) { + e = ssa_emit_array_ep(proc, e, index); } else { GB_PANIC("un-gep-able type"); } @@ -5098,6 +5100,9 @@ void ssa_gen_tree(ssaGen *s) { ssaValue *count = ssa_emit_struct_ep(proc, tag, 2); ssa_emit_store(proc, count, ssa_make_const_int(a, t->Vector.count)); + ssaValue *align = ssa_emit_struct_ep(proc, tag, 3); + ssa_emit_store(proc, count, ssa_make_const_int(a, type_align_of(m->sizes, a, t))); + } break; case Type_Record: { switch (t->Record.kind) { @@ -5245,8 +5250,8 @@ void ssa_gen_tree(ssaGen *s) { } for (isize i = 0; i < count; i++) { - ssaValue *value_gep = ssa_emit_struct_ep(proc, value_array, i); - ssaValue *name_gep = ssa_emit_struct_ep(proc, name_array, i); + ssaValue *value_gep = ssa_emit_array_ep(proc, value_array, i); + ssaValue *name_gep = ssa_emit_array_ep(proc, name_array, i); ssa_emit_store(proc, value_gep, ssa_make_const_i64(a, fields[i]->Constant.value.value_integer)); ssa_emit_store(proc, name_gep, ssa_make_const_string(a, fields[i]->token.string)); diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index 4e0cc5791..d0f14990a 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -37,6 +37,9 @@ TOKEN_KIND(Token__OperatorBegin, "_OperatorBegin"), \ \ TOKEN_KIND(Token_Prime, "'"), \ TOKEN_KIND(Token_DoublePrime, "''"), \ +\ + TOKEN_KIND(Token_CmpAnd, "&&"), \ + TOKEN_KIND(Token_CmpOr, "||"), \ \ TOKEN_KIND(Token__AssignOpBegin, "_AssignOpBegin"), \ TOKEN_KIND(Token_AddEq, "+="), \ @@ -50,16 +53,13 @@ TOKEN_KIND(Token__AssignOpBegin, "_AssignOpBegin"), \ TOKEN_KIND(Token_AndNotEq, "&~="), \ TOKEN_KIND(Token_ShlEq, "<<="), \ TOKEN_KIND(Token_ShrEq, ">>="), \ + TOKEN_KIND(Token_CmpAndEq, "&&="), \ + TOKEN_KIND(Token_CmpOrEq, "||="), \ TOKEN_KIND(Token__AssignOpEnd, "_AssignOpEnd"), \ TOKEN_KIND(Token_Increment, "++"), \ TOKEN_KIND(Token_Decrement, "--"), \ TOKEN_KIND(Token_ArrowRight, "->"), \ TOKEN_KIND(Token_ArrowLeft, "<-"), \ -\ - TOKEN_KIND(Token_CmpAnd, "&&"), \ - TOKEN_KIND(Token_CmpOr, "||"), \ - TOKEN_KIND(Token_CmpAndEq, "&&="), \ - TOKEN_KIND(Token_CmpOrEq, "||="), \ \ TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \ TOKEN_KIND(Token_CmpEq, "=="), \ diff --git a/todo.md b/todo.md index ecf45ffc1..ab35c7830 100644 --- a/todo.md +++ b/todo.md @@ -1,16 +1,5 @@ # Todo -## Tokenizer -* Unicode character category check - Letters, Digits -* Extra operators - - << and <<= - - >> and >>= - -## Parser -* Extra checking here rather than in the checker -* Mulitple files (done) - - Namespaces - ## Checker * Cyclic Type Checking - type A: struct { b: B; }; type B: struct { a: A; }; @@ -19,20 +8,11 @@ - integer - rational - real -* Multiple files (done) - - Namespaces ## Codegen -* Emit LLVM-IR using custom library * Debug info ## Command Line Tool * Begin!!! * Choose/determine architecture - - - -## Language - -* should `if/for` statements init statement be of the same scope as the block scope or not? (currently not)