v0.0.3 Build

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
 
 

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!")
 }

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

code/math.odin

@@ -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

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

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
+
+
+

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")
+}
 

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

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]

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

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

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) {

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));

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, "=="), \

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)